Changeset 152


Ignore:
Timestamp:
Nov 21, 2007 4:35:38 PM (14 years ago)
Author:
kingaj
Message:

Revised matrix construction in SmiScnModel::addNode() to use contiguous sparse arrays.

Location:
stable/0.8/Smi/src
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • stable/0.8/Smi/src/SmiCoreCombineRule.cpp

    r151 r152  
    8181
    8282}
    83 
     83int SmiCoreCombineReplace::Process(vector<double> *dr,CoinPackedVector *cpv,double *dels,int *indx)
     84{
     85
     86        int numels=0;
     87        double *cpv_els=cpv->getElements();
     88        int *cpv_ind=cpv->getIndices();
     89
     90        for (int j=0; j<dr->size(); ++j)
     91        {
     92                dels[numels] = (*dr)[j];
     93                if (*cpv_ind == j)
     94                {
     95                        dels[numels] = *cpv_els;
     96                        cpv_ind++;
     97                        cpv_els++;
     98                }
     99                if (dels[numels])
     100                {
     101                        indx[numels]=j;
     102                        numels++;
     103                }
     104        }
     105        return numels;
     106}
    84107//////////////////////////////////////////////////////////////////////
    85108// SmiCoreCombineReplace
     
    154177
    155178}
    156 
     179int SmiCoreCombineAdd::Process(vector<double> *dr,CoinPackedVector *cpv,double *dels,int *indx)
     180{
     181
     182        int numels=0;
     183        double *cpv_els=cpv->getElements();
     184        int *cpv_ind=cpv->getIndices();
     185
     186        for (int j=0; j<dr->size(); ++j)
     187        {
     188                dels[numels] = (*dr)[j];
     189                if (*cpv_ind == j)
     190                {
     191                        dels[numels] += *cpv_els;
     192                        cpv_ind++;
     193                        cpv_els++;
     194                }
     195                if (dels[numels])
     196                {
     197                        indx[numels]=j;
     198                        numels++;
     199                }
     200        }
     201        return numels;
     202}
     203
  • stable/0.8/Smi/src/SmiCoreCombineRule.hpp

    r98 r152  
    1515#include "CoinPackedVector.hpp"
    1616#include <string>
     17#include <vector>
     18using namespace std;
     19
    1720/** This deals with combining Core and Stochastic data.
    1821
     
    4245        virtual void Process(double *d1, int o1, const CoinPackedVector &cpv2, char *type=0)=0;
    4346        virtual CoinPackedVector * Process(CoinPackedVector *cpv1, CoinPackedVector *cpv2, char *type=0)=0;
     47        virtual int Process(vector<double> *dr,CoinPackedVector *cpv,double *dels,int *indx)=0;
    4448        virtual ~SmiCoreCombineRule(){};
    4549};
     
    5559        virtual void Process(double *d1, int o1, const CoinPackedVector &cpv2, char *type=0);
    5660        virtual CoinPackedVector * Process(CoinPackedVector *cpv1, CoinPackedVector *cpv2, char *type=0);
     61        virtual int Process(vector<double> *dr,CoinPackedVector *cpv,double *dels,int *indx);
    5762protected:
    5863        SmiCoreCombineReplace(){}
     
    7176        virtual void Process(double *d1, int o1, const CoinPackedVector &cpv2, char* type=0);
    7277        virtual CoinPackedVector * Process(CoinPackedVector *cpv1, CoinPackedVector *cpv2, char* type=0);
     78        virtual int Process(vector<double> *dr,CoinPackedVector *cpv,double *dels,int *indx);
    7379protected:
    7480        SmiCoreCombineAdd(){}
  • stable/0.8/Smi/src/SmiScnData.cpp

    r151 r152  
    187187        }
    188188
    189        
     189        // reserve space for dense row pointers
     190        pDenseRow_.reserve(nrow_);
     191        for (int i=0; i<nrow_; ++i) pDenseRow_[i]=NULL;
    190192
    191193}
     
    406408}
    407409
     410int SmiNodeData::combineWithDenseCoreRow(vector<double> *dr,CoinPackedVector *cpv,double *dels,int *indx)
     411{
     412        return getCoreCombineRule()->Process(dr,cpv,dels,indx);
     413}
    408414
    409415CoinPackedVector * SmiNodeData::combineWithCoreRow(CoinPackedVector *cr, CoinPackedVector *nr)
     
    459465}
    460466
     467vector<double> *
     468SmiNodeData::getDenseRow(int i) {
     469                if ( dRowMap[i] == NULL )
     470                {
     471                        double * dbeg=this->getRow(i)->denseVector(this->getCore()->getNumCols());
     472                        double * dend=dbeg+this->getCore()->getNumCols();
     473                        dRowMap[i] = new vector<double>(dbeg,dend);
     474                }
     475                return dRowMap[i];
     476        }
  • stable/0.8/Smi/src/SmiScnData.hpp

    r49 r152  
    3232public:
    3333        typedef map<int,CoinPackedVector *> SmiRowMap;
     34        typedef map<int,vector<double> *> SmiDenseRowMap;
    3435        void setCoreNode();
    3536        CoinPackedVector * getRow(int i) {
     
    3738                if (r!=rowMap.end()) return r->second;
    3839                else return NULL;}
     40        vector<double> * getDenseRow(int i);
    3941        inline SmiCoreData * getCore() { return core_;}
    4042        inline int getStage() { return stg_;}
     
    5153
    5254        CoinPackedVector * combineWithCoreRow(CoinPackedVector *cr, CoinPackedVector *nr);
     55        int combineWithDenseCoreRow(vector<double> *dr,CoinPackedVector *cpv,double *dels,int *indx);
    5356
    5457        SmiNodeData(SmiStageIndex stg, SmiCoreData *core,
     
    6770        SmiStageIndex stg_;
    6871        SmiRowMap rowMap;
     72        SmiDenseRowMap dRowMap;
    6973        int nels_;
    7074        SmiCoreData *core_;
     
    137141        double **cdcup_;
    138142        vector<SmiNodeData*> nodes_;
     143        vector<double *> pDenseRow_;
    139144};
    140145
  • stable/0.8/Smi/src/SmiScnModel.cpp

    r132 r152  
    77#include "CoinHelperFunctions.hpp"
    88#include "CoinError.hpp"
     9#include "CoinPackedVector.hpp"
    910#include <assert.h>
    1011#include <algorithm>
     
    111112                this->ncol_ += core->getNumCols(t);
    112113                this->nrow_ += core->getNumRows(t);
    113                 this->nels_ += node->getNumElements();
     114                this->nels_ += core->getNode(t)->getNumElements() + node->getNumElements();
    114115        }
    115116
     
    165166                SmiNodeData *node = new SmiNodeData(t,core,matrix,
    166167                        v_dclo,v_dcup,v_dobj,v_drlo,v_drup);
     168               
    167169                node->setCoreCombineRule(r);
    168170                // generate new tree node
     
    172174                this->ncol_ += core->getNumCols(t);
    173175                this->nrow_ += core->getNumRows(t);
    174                 this->nels_ += node->getNumElements();
     176                this->nels_ += core->getNode(t)->getNumElements() + node->getNumElements();
    175177        }
    176178
     
    215217        this->drlo_ = new double[this->nrow_];
    216218        this->drup_ = new double[this->nrow_];
    217         // initialize row-ordered matrix with no extragaps or extramajors
    218         CoinPackedMatrix *matrix = new CoinPackedMatrix(false,0,0);
    219         matrix->reserve(nrow_,4*nels_);
    220         this->matrix_=matrix;
     219
     220        // initialize row-ordered matrix arrays
     221        this->dels_ = new double[this->nels_];
     222        this->indx_ = new int[this->nels_];
     223        this->rstrt_ = new int[this->nrow_+1];
     224        this->rstrt_[0] = 0;
    221225
    222226        ncol_=0;
    223227        nrow_=0;
     228        nels_=0;
    224229       
    225230        // loop to addNodes
    226231        for_each(smiTree_.treeBegin(),smiTree_.treeEnd(),SmiScnModelAddNode(this));
    227232
     233        matrix_ = new CoinPackedMatrix(false,0,0);
     234        int *len=NULL;
     235        matrix_->assignMatrix(false,ncol_,nrow_,nels_,
     236                dels_,indx_,rstrt_,len);
     237       
    228238        // pass data to osiStoch
    229239        osiStoch_->loadProblem(CoinPackedMatrix(*matrix_),dclo_,dcup_,dobj_,drlo_,drup_);
     
    271281                dobj_[j] *= prob;
    272282       
    273        
     283
     284        vector<int> stochColStart(stg+1);
     285        SmiScnNode *pnode=tnode;
     286       
     287        stochColStart[stg]=ncol_;
     288        for (int t=stg-1; t>0; t--)
     289        {
     290                pnode=pnode->getParent();
     291                stochColStart[t] = pnode->getColStart();
     292        }
     293
     294        // row counter
     295        int rowCount=nrow_;
     296
    274297        // add rows to matrix
    275298        for (int i=core->getRowStart(stg); i<core->getRowStart(stg+1) ; i++)
     
    277300                // get node rows
    278301                CoinPackedVector *cr = cnode->getRow(i);
     302               
    279303                if (stg)
    280304                {
    281                         CoinPackedVector *newrow = node->combineWithCoreRow(cr,node->getRow(i));
    282 
    283                         // TODO: this is probably a throwable error
    284                         if (!newrow)
    285                                 continue;
    286                        
     305                        // build row explicitly into sparse arrays
     306                        CoinPackedVector *nodeRow = node->getRow(i);
     307                        int rowStart=this->rstrt_[rowCount];
     308
     309                        int rowNumEls=0;
     310                        if (nodeRow)
     311                        {
     312                                vector<double> *denseCoreRow = cnode->getDenseRow(i);
     313                                rowNumEls=node->combineWithDenseCoreRow(denseCoreRow,nodeRow,dels_+rowStart,indx_+rowStart);
     314                        }
     315                        else
     316                        {
     317                                CoinPackedVector *coreRow=cnode->getRow(i);
     318                                double *cels=coreRow->getElements();
     319                                int *cind=coreRow->getIndices();
     320                                rowNumEls=coreRow->getNumElements();
     321                                memcpy(dels_+rowStart,cels,sizeof(double)*rowNumEls);
     322                                memcpy(indx_+rowStart,cind,sizeof(int)*rowNumEls);
     323                        }
     324
     325
     326                        rowCount++;
     327                        nels_+=rowNumEls;
     328                        this->rstrt_[rowCount] = nels_;
    287329                       
    288330                        // coefficients of new row
    289                         int *indx = newrow->getIndices();
     331                        int *indx = indx_+rowStart;
    290332                       
    291333                        // stage starts
     
    294336                       
    295337                        // net offset to be added to indices
    296                         int coff = ncol_-jlo;
     338                        int coff= stochColStart[stg]-jlo;
    297339                       
    298340                        if(coff)
    299341                        {
    300                                 // parent node
    301                                 SmiScnNode *pnode=tnode;
    302342                               
    303343                                // main loop iterates backwards through indices
    304                                 for (int j=newrow->getNumElements()-1; j>-1;--j)
     344                                for (int j=rowNumEls-1; j>-1;--j)
    305345                                {
    306346                                        // get new offset from parent node when crossing stage bndy
     
    308348                                        {
    309349                                                jlo = core->getColStart(--t);
    310                                                 pnode=pnode->getParent();
    311                                                 coff = pnode->getColStart()-jlo;
     350                                                coff = stochColStart[t] - jlo;
    312351                                        }
    313352                                       
     
    316355                                }
    317356                        }
    318                         matrix_->appendRow(*newrow);
    319357                }
    320358                else
    321                         matrix_->appendRow(*cr);
     359                {
     360                        // build row explicitly into sparse arrays
     361                        double *els = cr->getElements();
     362                        int *ind = cr->getIndices();
     363
     364                        int rowStart=this->rstrt_[rowCount];
     365
     366                        memcpy(dels_+rowStart,els,sizeof(double)*cr->getNumElements());
     367                        memcpy(indx_+rowStart,ind,sizeof(int)*cr->getNumElements());
     368
     369                        rowCount++;
     370                        nels_+=cr->getNumElements();
     371                        this->rstrt_[rowCount] = nels_;
     372
     373                }
     374
    322375
    323376        }
     
    326379        ncol_ += core->getNumCols(stg);
    327380        nrow_ += core->getNumRows(stg);
    328 
    329         // for debug sanity
    330         int mnrow,mncol;
    331         mnrow = matrix_->getNumRows();
    332         mncol = matrix_->getNumCols();
    333         assert(mnrow == nrow_);
    334         assert(mncol == ncol_);
    335381}
    336382
  • stable/0.8/Smi/src/SmiScnModel.hpp

    r132 r152  
    202202        double *dcup_;
    203203        CoinPackedMatrix *matrix_;
     204        double *dels_;
     205        int    *indx_;
     206        int    *rstrt_;
    204207        // number of scenarios
    205208//      int scen_;
Note: See TracChangeset for help on using the changeset viewer.