Changeset 5135


Ignore:
Timestamp:
Jun 20, 2016 8:23:40 PM (6 years ago)
Author:
Gassmann
Message:

More on matrices; plugged memory leaks; fixed parser bugs

Location:
trunk/OS
Files:
19 edited

Legend:

Unmodified
Added
Removed
  • trunk/OS/data/osilFiles/testMatricesAndCones.osil

    r5131 r5135  
    33    <instanceHeader>
    44        <name>testMatricesAndCones.osil</name>
    5         <description>To test matrices and cones sections</description>
     5        <description>
     6            To test matrices and cones sections and, by extension, most other features
     7        </description>
    68        <fileCreator>H.I. Gassmann, J. Ma and R.K. Martin </fileCreator>
    79        <licence>This file is distributed under the Eclipse Public License</licence>
     
    1113            <var mult="2"/>
    1214        </variables>
    13         <objectives numberOfObjectives="1">
     15        <objectives numberOfObjectives="2">
    1416            <obj maxOrMin="max" numberOfObjCoef="2">
    1517                <coef idx="0">2.0</coef>
    1618                <coef idx="1">5.0</coef>
     19            </obj>
     20            <obj maxOrMin="max" numberOfObjCoef="2">
     21                <coef idx="0">1.0</coef>
     22                <coef idx="1">3.0</coef>
    1723            </obj>
    1824        </objectives>
     
    3541            </value>
    3642        </linearConstraintCoefficients>
     43        <quadraticCoefficients numberOfQuadraticTerms="4">
     44            <qTerm idx="-1" idxOne="0" idxTwo="0" coef="-.06666666"/>
     45            <qTerm idx="-2" idxOne="1" idxTwo="1" coef="-.2"/>
     46            <qTerm idx=" 0" idxOne="0" idxTwo="1" coef="1.0"/>
     47            <qTerm idx=" 1" idxOne="1" idxTwo="0" coef="0.5"/>
     48        </quadraticCoefficients>
    3749
    3850<!-- The nonlinearExpressions test some OSnLNodes, such as matrix reference, trace, etc. -->
     
    265277                    <value>
    266278                        <el>
     279                            <sin>
     280                                <variable idx="1" coef="5.0"/>
     281                            </sin>
     282                        </el>
     283                        <el>
     284                            <times>
     285                                <variable idx="0" coef="2.0"/>
     286                                <variable idx="1"></variable>
     287                            </times>
     288                        </el>
     289                        <el>
     290                            <number value="3.0"></number>
     291                        </el>
     292                        <el>
    267293                            <sum>
    268294                                <matrixDeterminant>
     
    311337                                </matrixToScalar>
    312338                            </sum>
    313                         </el>
    314                         <el>
    315                             <times>
    316                                 <variable idx="0" coef="2.0"/>
    317                                 <variable idx="1"></variable>
    318                             </times>
    319                         </el>
    320                         <el>
    321                             <sin>
    322                                 <variable idx="1" coef="5.0"/>
    323                             </sin>
    324                         </el>
    325                         <el>
    326                             <number value="3.0"></number>
    327339                        </el>
    328340                    </value>
  • trunk/OS/src/OSCommonInterfaces/OSInstance.cpp

    r5131 r5135  
    32163216        if ( (n < 0) || (n >= nMatrices) )
    32173217            throw ErrorClass("invalid matrix index in method getExpandedMatrix()");
    3218         return instanceData->matrices->matrix[n]->getExpandedMatrix(rowMajor);
     3218        int i = instanceData->matrices->matrix[n]->getExpandedMatrix(rowMajor);
     3219        if (i < 0) throw ErrorClass("Expanded matrix could not be retrieved");
     3220        return instanceData->matrices->matrix[n]->expandedMatrixByElements[i];
    32193221    }
    32203222    catch(const ErrorClass& eclass)
     
    53435345        }
    53445346    }
     5347    //this is the only place where we can make sure that variable indices reference true variables
     5348    std::map<int, RealValuedExpressionTree*>::iterator ixpr;
     5349    std::map<int, int>::iterator ivar;
     5350    for (ixpr = m_mapExpressionTreesMod.begin(); ixpr != m_mapExpressionTreesMod.end(); ++ixpr)
     5351    {
     5352        RealValuedExpressionTree* tmpTree = ixpr->second;
     5353        for (ivar = (*tmpTree->mapVarIdx).begin(); ivar != (*tmpTree->mapVarIdx).end(); ++ivar)
     5354        {
     5355            if (ivar->first < 0 || ivar->first >= instanceData->variables->numberOfVariables)
     5356                throw ErrorClass("Variable index references nonexisting variable");
     5357        }
     5358    }
    53455359    // only execute the following code if there are linear constraint coefficients
    53465360    if (this->instanceData->linearConstraintCoefficients != NULL &&
     
    55195533            m_mapExpressionTreesMod[ i]->getVariableIndicesMap();
    55205534
     5535        }
     5536    }
     5537    //make sure that variable indices reference true variables
     5538    std::map<int, RealValuedExpressionTree*>::iterator ixpr;
     5539    std::map<int, int>::iterator ivar;
     5540    for (ixpr = m_mapExpressionTreesMod.begin(); ixpr != m_mapExpressionTreesMod.end(); ++ixpr)
     5541    {
     5542        RealValuedExpressionTree* tmpTree = ixpr->second;
     5543        for (ivar = (*tmpTree->mapVarIdx).begin(); ivar != (*tmpTree->mapVarIdx).end(); ++ivar)
     5544        {
     5545            if (ivar->first < 0 || ivar->first >= instanceData->variables->numberOfVariables)
     5546                throw ErrorClass("Variable index references nonexisting variable");
    55215547        }
    55225548    }
  • trunk/OS/src/OSCommonInterfaces/OSMatrix.cpp

    r5131 r5135  
    4040    declaredMatrixType(ENUM_MATRIX_TYPE_unknown),
    4141    inferredMatrixType(ENUM_MATRIX_TYPE_unknown),
    42     nType(ENUM_MATRIX_CONSTRUCTOR_TYPE_unknown),
     42    nType (ENUM_MATRIX_CONSTRUCTOR_TYPE_unknown),
    4343    inumberOfChildren(),
    4444    m_mChildren(NULL){
    4545#ifndef NDEBUG
    46     osoutput->OSPrint(ENUM_OUTPUT_AREA_OSGeneral, ENUM_OUTPUT_LEVEL_trace, "in MatrixNode constructor");
     46    osoutput->OSPrint(ENUM_OUTPUT_AREA_OSMatrix, ENUM_OUTPUT_LEVEL_trace, "in MatrixNode constructor");
     47    std::ostringstream outStr;
     48    outStr << "Allocate MatrixNode at address" << this;
     49    osoutput->OSPrint(ENUM_OUTPUT_AREA_OSMatrix, ENUM_OUTPUT_LEVEL_detailed_trace, outStr.str());
    4750#endif
    4851}
     
    5558    outStr << "number of kids = " <<  inumberOfChildren << std::endl;
    5659    osoutput->OSPrint(ENUM_OUTPUT_AREA_OSMatrix, ENUM_OUTPUT_LEVEL_trace, outStr.str());
     60    outStr.str("");
     61    outStr.clear();
     62    outStr << "deleting MatrixNode at address" << this << std::endl;
     63    osoutput->OSPrint(ENUM_OUTPUT_AREA_OSMatrix, ENUM_OUTPUT_LEVEL_detailed_trace, outStr.str());
    5764#endif
    5865    if (inumberOfChildren > 0 && m_mChildren != NULL)
     
    6572                outStr.str("");
    6673                outStr.clear();
    67                 outStr << "deleting Matrixnode->m_mChildren[" << i << "] at "
     74                outStr << "deleting MatrixNode->m_mChildren[" << i << "] at "
    6875                                                              << &m_mChildren[i] << std::endl;
    6976                osoutput->OSPrint(ENUM_OUTPUT_AREA_OSMatrix,
     
    183190{
    184191#ifndef NDEBUG
    185     osoutput->OSPrint(ENUM_OUTPUT_AREA_OSInstance, ENUM_OUTPUT_LEVEL_trace, "Inside the  MatrixConstructor Constructor");
     192    osoutput->OSPrint(ENUM_OUTPUT_AREA_OSMatrix, ENUM_OUTPUT_LEVEL_trace,
     193        "Inside the  MatrixConstructor Constructor");
     194    std::ostringstream outStr;
     195    outStr << "Allocate MatrixConstructor at address" << this;
     196    osoutput->OSPrint(ENUM_OUTPUT_AREA_OSMatrix, ENUM_OUTPUT_LEVEL_detailed_trace, outStr.str());
    186197#endif
    187198}
     
    190201{
    191202#ifndef NDEBUG
    192     osoutput->OSPrint(ENUM_OUTPUT_AREA_OSInstance, ENUM_OUTPUT_LEVEL_trace, "Inside the MatrixConstructor Destructor");
     203    osoutput->OSPrint(ENUM_OUTPUT_AREA_OSMatrix, ENUM_OUTPUT_LEVEL_trace,
     204        "Inside the MatrixConstructor Destructor");
     205    std::ostringstream outStr;
     206    outStr << "deleting MatrixConstructor at address" << this << std::endl;
     207    osoutput->OSPrint(ENUM_OUTPUT_AREA_OSMatrix, ENUM_OUTPUT_LEVEL_detailed_trace, outStr.str());
    193208#endif
    194209}//end of MatrixConstructor::~MatrixConstructor
     
    203218    numberOfRows(0),
    204219    numberOfColumns(0),
    205     expandedMatrixInRowMajorForm(NULL),
    206     expandedMatrixInColumnMajorForm(NULL),
     220    m_bHaveRowPartition(false),
     221    m_iRowPartitionSize(0),
    207222    m_miRowPartition(NULL),
    208     m_iRowPartitionSize(0),
    209     m_miColumnPartition(NULL),
     223    m_bHaveColumnPartition(false),
    210224    m_iColumnPartitionSize(0),
    211     m_bHaveRowPartition(false),
    212     m_bHaveColumnPartition(false)
    213 {
    214 #ifndef NDEBUG
    215     osoutput->OSPrint(ENUM_OUTPUT_AREA_OSInstance, ENUM_OUTPUT_LEVEL_trace, "Inside the MatrixType Constructor");
     225    m_miColumnPartition(NULL)
     226{
     227#ifndef NDEBUG
     228    osoutput->OSPrint(ENUM_OUTPUT_AREA_OSMatrix, ENUM_OUTPUT_LEVEL_trace,
     229        "Inside the MatrixType Constructor");
     230    std::ostringstream outStr;
     231    outStr << "Allocate MatrixType at address" << this;
     232    osoutput->OSPrint(ENUM_OUTPUT_AREA_OSMatrix, ENUM_OUTPUT_LEVEL_detailed_trace, outStr.str());
    216233#endif
    217234}// end of MatrixType
     
    221238{
    222239#ifndef NDEBUG
    223     osoutput->OSPrint(ENUM_OUTPUT_AREA_OSInstance, ENUM_OUTPUT_LEVEL_trace, "Inside the MatrixType Destructor");
    224 #endif
    225     if (expandedMatrixInRowMajorForm != NULL)
    226         delete expandedMatrixInRowMajorForm;
    227     expandedMatrixInRowMajorForm = NULL;
    228 
    229     if (expandedMatrixInColumnMajorForm != NULL)
    230         delete expandedMatrixInColumnMajorForm;
    231     expandedMatrixInColumnMajorForm = NULL;
    232 
     240    osoutput->OSPrint(ENUM_OUTPUT_AREA_OSMatrix, ENUM_OUTPUT_LEVEL_trace,
     241        "Inside the MatrixType Destructor");
     242    std::ostringstream outStr;
     243    outStr << "deleting MatrixType at address" << this << std::endl;
     244    osoutput->OSPrint(ENUM_OUTPUT_AREA_OSMatrix, ENUM_OUTPUT_LEVEL_detailed_trace, outStr.str());
     245#endif
    233246    if (m_miRowPartition != NULL)
    234247        delete[] m_miRowPartition;
     
    238251        delete[] m_miColumnPartition;
    239252    m_miColumnPartition = NULL;
     253
     254    for(size_t i = 0; i < expandedMatrixByElements.size(); ++i)
     255    {
     256        delete expandedMatrixByElements[i];
     257    }
     258    expandedMatrixByElements.clear();
     259
     260    for(size_t i = 0; i < expandedMatrixByBlocks.size(); ++i)
     261    {
     262        delete expandedMatrixByBlocks[i];
     263    }
     264    expandedMatrixByBlocks.clear();
    240265}// end of ~MatrixType
    241266
     
    337362
    338363
    339 GeneralSparseMatrix* MatrixType::processBaseMatrix(bool rowMajor, ENUM_MATRIX_SYMMETRY symmetry)
    340 {
    341 #ifndef NDEBUG
    342     osoutput->OSPrint(ENUM_OUTPUT_AREA_OSInstance, ENUM_OUTPUT_LEVEL_trace, "Inside processBaseMatrix()");
     364GeneralSparseMatrix* MatrixType::processBaseMatrix(bool rowMajor_, ENUM_MATRIX_TYPE convertTo_,
     365                                                                   ENUM_MATRIX_SYMMETRY symmetry_)
     366{
     367#ifndef NDEBUG
     368    osoutput->OSPrint(ENUM_OUTPUT_AREA_OSMatrix, ENUM_OUTPUT_LEVEL_trace, "Inside processBaseMatrix()");
    343369#endif
    344370    try
    345371    {
     372        ENUM_MATRIX_SYMMETRY symmetry = symmetry_;
     373
     374        if (symmetry == ENUM_MATRIX_SYMMETRY_default)
     375            symmetry  = this->symmetry;
    346376        if (symmetry != this->symmetry)
    347377            throw ErrorClass("Symmetry changes not yet implemented in processBaseMatrix()");
     
    356386
    357387        GeneralSparseMatrix* baseMtx;
    358         if (((BaseMatrix*)m_mChildren[0])->baseTranspose != rowMajor)
    359         {
    360 //            baseMtx = baseMtxPtr->getMatrixCoefficientsInRowMajor();
    361             baseMtx = baseMtxPtr->getExpandedMatrix(true);
     388
     389        // expand into row or column major format, depending on how the base matrix is used
     390        if (((BaseMatrix*)m_mChildren[0])->baseTranspose != rowMajor_)
     391        {
     392            int i = baseMtxPtr->getExpandedMatrix(true, convertTo_, symmetry);
     393            if (i < 0)
     394                throw ErrorClass("Base matrix could not be expanded");
     395            baseMtx = baseMtxPtr->expandedMatrixByElements[i];
    362396            base_r0 = ((BaseMatrix*)m_mChildren[0])->baseMatrixStartCol;
    363397            base_c0 = ((BaseMatrix*)m_mChildren[0])->baseMatrixStartRow;
     
    371405        else
    372406        {
    373 //            baseMtx = baseMtxPtr->getMatrixCoefficientsInColumnMajor();
    374             baseMtx = baseMtxPtr->getExpandedMatrix(false);
     407            int i = baseMtxPtr->getExpandedMatrix(false, convertTo_, symmetry);
     408            if (i < 0)
     409                throw ErrorClass("Base matrix could not be expanded");
     410            baseMtx = baseMtxPtr->expandedMatrixByElements[i];
    375411            base_r0 = ((BaseMatrix*)m_mChildren[0])->baseMatrixStartRow;
    376412            base_c0 = ((BaseMatrix*)m_mChildren[0])->baseMatrixStartCol;
     
    384420
    385421        double scaleMult = ((BaseMatrix*)m_mChildren[0])->scalarMultiplier;
     422        double scaleImag = ((BaseMatrix*)m_mChildren[0])->scalarImaginaryPart;
    386423
    387424        GeneralSparseMatrix* tempMtx = new GeneralSparseMatrix();
    388         tempMtx->symmetry  = symmetry;
    389         tempMtx->startSize = numberOfColumns + 1;
     425        tempMtx->symmetry        = symmetry;
     426        tempMtx->startSize       = numberOfColumns + 1;
     427        tempMtx->numberOfRows    = numberOfRows;
     428        tempMtx->numberOfColumns = numberOfColumns;
    390429
    391430        // position and other options can affect how arrays need to be duplicated
     
    396435        bool isClipped = (iroff + base_rN - base_r0 >= numberOfRows ||
    397436                          icoff + base_cN - base_c0 >= numberOfColumns);
    398         bool hasGap    = (icoff + base_cN - base_c0 < numberOfColumns - 1);
    399         bool isScaled  = (scaleMult < 1 || scaleMult > 1);
     437        bool hasGap    = (icoff + base_cN - base_c0 <  numberOfColumns - 1);
     438        bool isScaled  = (scaleMult < 1 || scaleMult > 1 || scaleImag < 0 || scaleImag > 0);
    400439        bool reTyped   = (getMatrixType() != m_mChildren[0]->getMatrixType());
    401440
    402         //default position without cropping, scaling or retyping is easiest
     441        //default position without cropping is easiest (retyping and scaling is handled here)
    403442        if ( !isShifted && !isCropped && !isClipped )
    404443        {
     
    406445            tempMtx->b_deleteIndexArray = true;
    407446            tempMtx->b_deleteValueArray = true;
    408             tempMtx->isRowMajor = false;
     447            tempMtx->isRowMajor = rowMajor_;
    409448            tempMtx->valueSize  = baseMtx->valueSize;
    410             tempMtx->matrixType = m_mChildren[0]->getMatrixType();
     449
     450            ENUM_MATRIX_TYPE convertTo = convertTo_;
     451            ENUM_MATRIX_TYPE inferredType = m_mChildren[0]->getMatrixType();
     452            if (convertTo == ENUM_MATRIX_TYPE_unknown)
     453                convertTo  = inferredType;
     454            if (convertTo != mergeMatrixType(convertTo, inferredType))
     455               throw ErrorClass("Requested improper conversion of element values");
     456
     457            tempMtx->valueType = convertTo;
     458
     459            if (scaleImag < 0 || scaleImag > 0)
     460                tempMtx->valueType = mergeMatrixType(tempMtx->valueType, ENUM_MATRIX_TYPE_complexConstant);
     461            else if (scaleMult < 1 || scaleMult > 1)
     462                tempMtx->valueType = mergeMatrixType(tempMtx->valueType, ENUM_MATRIX_TYPE_constant);
    411463
    412464            tempMtx->startSize = numberOfColumns + 1;
     
    430482                tempMtx->index[i] = baseMtx->index[i];
    431483
    432             // allocate space and store value array --- based on type
    433             switch (tempMtx->matrixType)
    434             {
    435                 case ENUM_MATRIX_TYPE_empty:
    436                 {
    437                     if (tempMtx->valueSize != 0)
    438                         throw ErrorClass("Matrix should be empty, but is not!!!");
    439                     break;
    440                 }
    441 
    442                 case ENUM_MATRIX_TYPE_constant:
    443                 {
    444                     tempMtx->value = new ConstantMatrixValues();
    445                     ((ConstantMatrixValues*)tempMtx->value)->el = new double[tempMtx->valueSize];
    446                     for (int i = 0; i < baseMtx->valueSize; i++)
    447                         ((ConstantMatrixValues*)tempMtx->value)->el[i]
    448                             = scaleMult*((ConstantMatrixValues*)baseMtx->value)->el[i];
    449                     break;
    450                 }
    451                 case ENUM_MATRIX_TYPE_complexConstant:
    452                 {
    453                     tempMtx->value = new ComplexMatrixValues();
    454                     ((ComplexMatrixValues*)tempMtx->value)->el
    455                         = new std::complex<double>[tempMtx->valueSize];
    456                     for (int i = 0; i < baseMtx->valueSize; i++)
    457                         ((ComplexMatrixValues*)tempMtx->value)->el[i]
    458                             = scaleMult*((ComplexMatrixValues*)baseMtx->value)->el[i];
    459                     break;
    460                 }
    461 
    462                 case ENUM_MATRIX_TYPE_varReference:
    463                 {
    464                     if (isScaled)
    465                     {
    466                         // must convert to linear elements
    467                         LinearMatrixValues* tmpValues = new LinearMatrixValues();
    468                         tmpValues->el = new LinearMatrixElement*[tempMtx->valueSize];
    469                         for (int i = 0; i < baseMtx->valueSize; i++)
    470                         {
    471                             tmpValues->el[i] = new LinearMatrixElement();
    472                             tmpValues->el[i]->numberOfVarIdx = 1;
    473                             tmpValues->el[i]->varIdx    = new LinearMatrixElementTerm*[1];
    474                             tmpValues->el[i]->varIdx[0] = new LinearMatrixElementTerm();
    475                             tmpValues->el[i]->varIdx[0]->coef = scaleMult;
    476                             tmpValues->el[i]->varIdx[0]->idx 
    477                                 = ((VarReferenceMatrixValues*)baseMtx->value)->el[i];
    478                         }
    479                         tempMtx->value = tmpValues;
    480                     }
    481                     else
    482                     {
    483                         tempMtx->value = new VarReferenceMatrixValues();
    484                         ((VarReferenceMatrixValues*)tempMtx->value)->el = new int[tempMtx->valueSize];
    485                         for (int i = 0; i < baseMtx->valueSize; i++)
    486                             ((VarReferenceMatrixValues*)tempMtx->value)->el[i]
    487                                 = ((VarReferenceMatrixValues*)baseMtx->value)->el[i];
    488                     }
    489                     break;
    490                 }
    491 
    492                 case ENUM_MATRIX_TYPE_linear:
    493                 {
    494                     LinearMatrixValues* tmpValues = new LinearMatrixValues();
    495                     tmpValues->el = new LinearMatrixElement*[baseMtx->valueSize];
    496                     for (int i = 0; i < baseMtx->valueSize; i++)
    497                     {
    498                         tmpValues->el[i] = new LinearMatrixElement();
    499                         if (!(tmpValues->el[i]
    500                                 ->deepCopyFrom(((LinearMatrixValues*)baseMtx->value)->el[i])))
    501                             throw ErrorClass("failed copying linear element values in method processBaseMatrix()");
    502                         for (int j=0; j<tmpValues->el[i]->numberOfVarIdx; j++)
    503                             tmpValues->el[i]->varIdx[j]->coef *= scaleMult;
    504                     }
    505                     tempMtx->value = tmpValues;
    506                     break;
    507                 }
    508 
    509                 case ENUM_MATRIX_TYPE_objReference:
    510                 {
    511                     tempMtx->value = new ObjReferenceMatrixValues();
    512                     ((ObjReferenceMatrixValues*)tempMtx->value)->el = new int[tempMtx->valueSize];
    513 
    514                     if (isScaled)
    515                     {
    516                         throw ErrorClass("scalar multiple not defined for objReference elements in  processBaseMatrix()");
    517                     }
    518                     else
    519                     {
    520                         for (int i = 0; i < baseMtx->valueSize; i++)
    521                             ((ObjReferenceMatrixValues*)tempMtx->value)->el[i]
    522                                 = ((ObjReferenceMatrixValues*)baseMtx->value)->el[i];
    523                     }
    524                     break;
    525                 }
    526 
    527                 case ENUM_MATRIX_TYPE_mixedRowReference:
    528                 case ENUM_MATRIX_TYPE_conReference:
    529                 {
    530                     ConReferenceMatrixValues* tmpValues = new ConReferenceMatrixValues();
    531                     tmpValues->el = new ConReferenceMatrixElement*[baseMtx->valueSize];
    532 
    533                     if (isScaled)
    534                     {
    535                         throw ErrorClass("scalar multiple not defined for conReference elements in  processBaseMatrix()");
    536                     }
    537                     else
    538                     {
    539                         for (int i = 0; i < baseMtx->valueSize; i++)
    540                         {
    541                             tmpValues->el[i] = new ConReferenceMatrixElement();
    542                             if (!(tmpValues->el[i]
    543                                 ->deepCopyFrom(((ConReferenceMatrixValues*)baseMtx->value)->el[i])))
    544                             throw ErrorClass("failed copying linear element values in method processBaseMatrix()");
    545                         }
    546                     }
    547                     tempMtx->value = tmpValues;
    548                     break;
    549                 }
    550 
    551                 case ENUM_MATRIX_TYPE_realValuedExpressions:
    552                 {
    553                     RealValuedExpressionArray* tmpValues = new RealValuedExpressionArray();
    554                     tmpValues->el = new RealValuedExpressionTree*[tempMtx->valueSize];
    555 
    556                     if (!isScaled)
    557                     {
    558                         for (int i = 0; i < baseMtx->valueSize; i++)
    559                         {
    560                             tmpValues->el[i] = new RealValuedExpressionTree();
    561                             tmpValues->el[i]->m_treeRoot
    562                                 = ((OSnLNode*)((RealValuedExpressionArray*)baseMtx->value)->el[i]
    563                                     ->m_treeRoot->cloneExprNode());
    564                         }
    565                     }
    566                     else
    567                     {
    568                         // add scalar multiple as a product
    569                         for (int i = 0; i < baseMtx->valueSize; i++)
    570                         {
    571                             tmpValues->el[i] = new RealValuedExpressionTree();
    572                             tmpValues->el[i]->m_treeRoot = new OSnLNodeTimes();
    573                             tmpValues->el[i]->m_treeRoot->m_mChildren[0] = new OSnLNodeNumber();
    574                             ((OSnLNodeNumber*)tmpValues->el[i]->m_treeRoot->m_mChildren[0])->value
    575                                 = scaleMult;
    576                             tmpValues->el[i]->m_treeRoot->m_mChildren[1]
    577                                  = ((OSnLNode*)((RealValuedExpressionArray*)baseMtx->value)->el[i]
    578                                     ->m_treeRoot->cloneExprNode());
    579                         }
    580                     }
    581                     tempMtx->value = tmpValues;
    582                     break;
    583                 }
    584 
    585                 case ENUM_MATRIX_TYPE_complexValuedExpressions:
    586                 {
    587                     ComplexValuedExpressionArray* tmpValues = new ComplexValuedExpressionArray();
    588                     tmpValues->el = new ComplexValuedExpressionTree*[tempMtx->valueSize];
    589 
    590                     if (!isScaled)
    591                     {
    592                         for (int i = 0; i < baseMtx->valueSize; i++)
    593                         {
    594                             tmpValues->el[i] = new ComplexValuedExpressionTree();
    595                             tmpValues->el[i]->m_treeRoot
    596                                 = ((OSnLNode*)((ComplexValuedExpressionArray*)baseMtx->value)->el[i]
    597                                     ->m_treeRoot->cloneExprNode());
    598                         }
    599                     }
    600                     else
    601                     {
    602                         // add scalar multiple as a product
    603                         for (int i = 0; i < baseMtx->valueSize; i++)
    604                         {
    605                             tmpValues->el[i] = new ComplexValuedExpressionTree();
    606                             tmpValues->el[i]->m_treeRoot = new OSnLCNodeTimes();
    607                             tmpValues->el[i]->m_treeRoot->m_mChildren[0] = new OSnLCNodeNumber();
    608                             ((OSnLCNodeNumber*)
    609                                     tmpValues->el[i]->m_treeRoot->m_mChildren[0])->setValue(scaleMult, 0);
    610                             tmpValues->el[i]->m_treeRoot->m_mChildren[1]
    611                                  = ((OSnLCNode*)((ComplexValuedExpressionArray*)baseMtx->value)->el[i]
    612                                     ->m_treeRoot->cloneExprNode());
    613                         }
    614                     }
    615                     tempMtx->value = tmpValues;
    616                     break;
    617                 }
    618 
    619                 case ENUM_MATRIX_TYPE_string:
    620                 {
    621                     tempMtx->value = new StringValuedMatrixValues();
    622                     ((StringValuedMatrixValues*)tempMtx->value)->el
    623                         = new std::string[tempMtx->valueSize];
    624 
    625                     if (isScaled)
    626                     {
    627                         throw ErrorClass("scalar multiple not defined for string-valued elements in  processBaseMatrix()");
    628                     }
    629                     else
    630                     {
    631                         for (int i = 0; i < baseMtx->valueSize; i++)
    632                             ((StringValuedMatrixValues*)tempMtx->value)->el[i]
    633                                 = ((StringValuedMatrixValues*)baseMtx->value)->el[i];
    634                     }
    635                     break;
    636                 }
    637 
    638                 default :
    639                     throw ErrorClass("Unsupported matrix type");
    640                     break;
    641             }
     484            // allocate space and store value array
     485            if (!tempMtx->allocateValueArray(baseMtx->valueSize))
     486                throw ErrorClass("Error allocating value array of a GeneralSparseMatrix");
     487
     488            for (int i = 0; i < baseMtx->valueSize; i++)
     489                if (!tempMtx->copyValue(baseMtx, i, i, scaleMult, scaleImag))
     490                    throw ErrorClass("Matrix expansion failed while copying element values");
    642491        }
    643492        else // repositioned Basematrix with cropping
     
    648497            tempMtx->isRowMajor = false;
    649498            tempMtx->startSize  = numberOfColumns + 1;
    650             tempMtx->matrixType = baseMtx->matrixType;
     499            tempMtx->valueType  = baseMtx->valueType;
    651500
    652501            int  startSize = numberOfColumns + 1;
     
    672521                tmpStarts[i] += tmpStarts[i-1];
    673522
    674             int valueSize = tmpStarts[startSize-1];
    675             int* tmpIndexes = new int[valueSize];
    676 
     523            int valueSize      = tmpStarts[startSize-1];
    677524            tempMtx->valueSize = valueSize;
    678525            tempMtx->start     = tmpStarts;
     526            tempMtx->index     = new int[valueSize];
    679527
    680528            // to get the values, go through the base matrix a second time
    681             if ( baseMtx->matrixType == ENUM_MATRIX_TYPE_constant)
    682             {
    683                 MatrixElementValues* tmpValues = new ConstantMatrixValues();
    684                 ((ConstantMatrixValues*)tmpValues)->el = new double[valueSize];
    685 
    686                 int ival = 0;
    687                 for (int i=icoff; i<lastcol; i++)
    688                     for (int j=baseMtx->start[i-adjc]; j<baseMtx->start[i-adjc+1]; j++)
     529            // allocate space and store value array
     530            if (!tempMtx->allocateValueArray(valueSize))
     531                throw ErrorClass("Error allocating value array of a GeneralSparseMatrix");
     532
     533            int ival = 0;
     534            for (int i=icoff; i<lastcol; i++)
     535                for (int j=baseMtx->start[i-adjc]; j<baseMtx->start[i-adjc+1]; j++)
     536                {
     537                    if (baseMtx->index[j] >= base_r0 &&
     538                        baseMtx->index[j] <= base_rN &&
     539                        baseMtx->index[j] <  numberOfRows + base_r0 - iroff)
    689540                    {
    690                         if (baseMtx->index[j] >= base_r0 &&
    691                             baseMtx->index[j] <= base_rN &&
    692                             baseMtx->index[j] <  numberOfRows + base_r0 - iroff)
    693                         {
    694                             tmpIndexes[ival] = baseMtx->index[j] - base_r0 + iroff;
    695                             ((ConstantMatrixValues*)tmpValues)->el[ival]
    696                                 = scaleMult*((ConstantMatrixValues*)baseMtx->value)->el[j];
    697                             ival++;
    698                         }   
    699                     }
    700                 tempMtx->index = tmpIndexes;
    701                 tempMtx->value = tmpValues;
    702             }
    703 
    704             else if (baseMtx->matrixType == ENUM_MATRIX_TYPE_varReference)
    705             {
    706                 if (!isScaled)
    707                 {
    708                     MatrixElementValues* tmpValues = new VarReferenceMatrixValues();
    709                     ((VarReferenceMatrixValues*)tmpValues)->el = new int[valueSize];
    710 
    711                     int ival = 0;
    712                     for (int i=icoff; i<lastcol; i++)
    713                         for (int j=baseMtx->start[i-adjc]; j<baseMtx->start[i-adjc+1]; j++)
    714                         {
    715                             if (baseMtx->index[j] >= base_r0 &&
    716                                 baseMtx->index[j] <  numberOfRows + base_r0 - iroff)
    717                             {
    718                                 tmpIndexes[ival] = baseMtx->index[j] - base_r0 + iroff;
    719                                 ((VarReferenceMatrixValues*)tmpValues)->el[ival]
    720                                     = ((VarReferenceMatrixValues*)baseMtx->value)->el[j];
    721                                 ival++;
    722                             }   
    723                         }
    724                     tempMtx->index = tmpIndexes;
    725                     tempMtx->value = tmpValues;
     541                        tempMtx->index[ival] = baseMtx->index[j] - base_r0 + iroff;
     542                        if (!tempMtx->copyValue(baseMtx, j, ival, scaleMult, scaleImag))
     543                            throw ErrorClass("Matrix expansion failed while copying element values");
     544                        ival++;
     545                    }   
    726546                }
    727                 else
    728                 {
    729                     // must convert to linear elements
    730                     MatrixElementValues* tmpValues = new LinearMatrixValues();
    731                     ((LinearMatrixValues*)tmpValues)->el = new LinearMatrixElement*[valueSize];
    732 
    733                     int ival = 0;
    734                     for (int i=icoff; i<lastcol; i++)
    735                         for (int j=baseMtx->start[i-adjc]; j<baseMtx->start[i-adjc+1]; j++)
    736                         {
    737                             if (baseMtx->index[j] >= base_r0 &&
    738                                 baseMtx->index[j] <  numberOfRows + base_r0 - iroff)
    739                             {
    740                                 tmpIndexes[ival] = baseMtx->index[j] - base_r0 + iroff;
    741                                 ((LinearMatrixValues*)tmpValues)->el[ival]
    742                                     = new LinearMatrixElement();
    743                                 ((LinearMatrixValues*)tmpValues)->el[ival]->numberOfVarIdx = 1;
    744                                 ((LinearMatrixValues*)tmpValues)->el[ival]->varIdx
    745                                     = new LinearMatrixElementTerm*[1];
    746                                 ((LinearMatrixValues*)tmpValues)->el[ival]->varIdx[0]
    747                                     = new LinearMatrixElementTerm();
    748                                 ((LinearMatrixValues*)tmpValues)->el[ival]->varIdx[0]->coef
    749                                     = scaleMult;
    750                                 ((LinearMatrixValues*)tmpValues)->el[ival]->varIdx[0]->idx 
    751                                     = ((VarReferenceMatrixValues*)baseMtx->value)->el[j];
    752                                 ival++;
    753                             }
    754                         }
    755                     tempMtx->index = tmpIndexes;
    756                     tempMtx->value = tmpValues;
    757                 }
    758             }
    759             else if (baseMtx->matrixType == ENUM_MATRIX_TYPE_linear)
    760             {
    761                 LinearMatrixValues* tmpValues = new LinearMatrixValues();
    762                 tmpValues->el = new LinearMatrixElement*[baseMtx->valueSize];
    763 
    764                 int ival = 0;
    765                 for (int i=icoff; i<lastcol; i++)
    766                     for (int j=baseMtx->start[i-adjc]; j<baseMtx->start[i-adjc+1]; j++)
    767                     {
    768                         if (baseMtx->index[j] >= base_r0 &&
    769                             baseMtx->index[j] <  numberOfRows + base_r0 - iroff)
    770                         {
    771                             tmpIndexes[ival] = baseMtx->index[j] - base_r0 + iroff;
    772                             tmpValues->el[ival] = new LinearMatrixElement();
    773                             if (!(tmpValues->el[ival]
    774                                     ->deepCopyFrom(((LinearMatrixValues*)baseMtx->value)->el[j])))
    775                             throw ErrorClass("failed copying linear element values in method processBaseMatrix()");
    776                             for (int k=0; k<tmpValues->el[ival]->numberOfVarIdx; k++)
    777                                 tmpValues->el[ival]->varIdx[k]->coef *= scaleMult;
    778                             ival++;
    779                         }
    780                     }
    781                 tempMtx->index = tmpIndexes;
    782                 tempMtx->value = tmpValues;
    783             }
    784             else if (baseMtx->matrixType == ENUM_MATRIX_TYPE_realValuedExpressions)
    785             {
    786                 if (!isScaled)
    787                 {
    788                     RealValuedExpressionArray* tmpValues = new RealValuedExpressionArray();
    789                     tmpValues->el = new RealValuedExpressionTree*[baseMtx->valueSize];
    790 
    791                     int ival = 0;
    792                     for (int i=icoff; i<lastcol; i++)
    793                         for (int j=baseMtx->start[i-adjc]; j<baseMtx->start[i-adjc+1]; j++)
    794                         {
    795                             if (baseMtx->index[j] >= base_r0 &&
    796                                 baseMtx->index[j] <  numberOfRows + base_r0 - iroff)
    797                             {
    798                                 tmpIndexes[ival] = baseMtx->index[j] - base_r0 + iroff;
    799                                 ((RealValuedExpressionArray*)tmpValues)->el[ival]
    800                                     = new RealValuedExpressionTree();
    801                                 ((RealValuedExpressionArray*)tmpValues)->el[ival]->m_treeRoot
    802                                     = ((RealValuedExpressionArray*)baseMtx->value)->el[j]
    803                                         ->m_treeRoot->cloneExprNode();
    804                                 ival++;
    805                             }
    806                         }
    807                     tempMtx->index = tmpIndexes;
    808                     tempMtx->value = tmpValues;
    809                 }
    810                 else
    811                 {
    812                     // add scalar multiple as a product
    813                     RealValuedExpressionArray* tmpValues = new RealValuedExpressionArray();
    814                     tmpValues->el = new RealValuedExpressionTree*[baseMtx->valueSize];
    815                     int ival = 0;
    816                     for (int i=icoff; i<lastcol; i++)
    817                         for (int j=baseMtx->start[i-adjc]; j<baseMtx->start[i-adjc+1]; j++)
    818                         {
    819                             if (baseMtx->index[j] >= base_r0 &&
    820                                 baseMtx->index[j] <  numberOfRows + base_r0 - iroff)
    821                             {
    822                                 tmpIndexes[ival] = baseMtx->index[j] - base_r0 + iroff;
    823                                 ((RealValuedExpressionArray*)tmpValues)->el[ival]
    824                                     = new RealValuedExpressionTree();
    825                                 ((RealValuedExpressionArray*)tmpValues)->el[ival]->m_treeRoot
    826                                     = new OSnLNodeTimes();
    827                                 ((RealValuedExpressionArray*)tmpValues)->el[ival]->m_treeRoot->m_mChildren[0]
    828                                     = new OSnLNodeNumber();
    829                                 ((OSnLNodeNumber*)tmpValues->el[ival]->m_treeRoot->m_mChildren[0])->value = scaleMult;
    830                                 ((RealValuedExpressionArray*)tmpValues)->el[ival]->m_treeRoot->m_mChildren[1]
    831                                     = ((RealValuedExpressionArray*)baseMtx->value)
    832                                         ->el[j]->m_treeRoot->cloneExprNode();
    833                                 ival++;
    834 
    835                             }
    836                         }
    837                     tempMtx->index = tmpIndexes;
    838                     tempMtx->value = tmpValues;
    839                 }
    840             }
    841             else if (baseMtx->matrixType == ENUM_MATRIX_TYPE_complexValuedExpressions)
    842             {
    843                 if (!isScaled)
    844                 {
    845                     ComplexValuedExpressionArray* tmpValues = new ComplexValuedExpressionArray();
    846                     tmpValues->el = new ComplexValuedExpressionTree*[baseMtx->valueSize];
    847 
    848                     int ival = 0;
    849                     for (int i=icoff; i<lastcol; i++)
    850                         for (int j=baseMtx->start[i-adjc]; j<baseMtx->start[i-adjc+1]; j++)
    851                         {
    852                             if (baseMtx->index[j] >= base_r0 &&
    853                                 baseMtx->index[j] <  numberOfRows + base_r0 - iroff)
    854                             {
    855                                 tmpIndexes[ival] = baseMtx->index[j] - base_r0 + iroff;
    856                                 ((ComplexValuedExpressionArray*)tmpValues)->el[ival]
    857                                     = new ComplexValuedExpressionTree();
    858                                 ((ComplexValuedExpressionArray*)tmpValues)->el[ival]->m_treeRoot
    859                                     = ((ComplexValuedExpressionArray*)baseMtx->value)->el[j]
    860                                         ->m_treeRoot->cloneExprNode();
    861                                 ival++;
    862                             }
    863                         }
    864                     tempMtx->index = tmpIndexes;
    865                     tempMtx->value = tmpValues;
    866                 }
    867                 else
    868                 {
    869                     // add scalar multiple as a product
    870                     ComplexValuedExpressionArray* tmpValues = new ComplexValuedExpressionArray();
    871                     tmpValues->el = new ComplexValuedExpressionTree*[baseMtx->valueSize];
    872                     int ival = 0;
    873                     for (int i=icoff; i<lastcol; i++)
    874                         for (int j=baseMtx->start[i-adjc]; j<baseMtx->start[i-adjc+1]; j++)
    875                         {
    876                             if (baseMtx->index[j] >= base_r0 &&
    877                                 baseMtx->index[j] <  numberOfRows + base_r0 - iroff)
    878                             {
    879                                 tmpIndexes[ival] = baseMtx->index[j] - base_r0 + iroff;
    880                                 ((ComplexValuedExpressionArray*)tmpValues)->el[ival]
    881                                     = new ComplexValuedExpressionTree();
    882                                 ((ComplexValuedExpressionArray*)tmpValues)->el[ival]->m_treeRoot
    883                                     = new OSnLNodeTimes();
    884                                 ((ComplexValuedExpressionArray*)tmpValues)->el[ival]->m_treeRoot->m_mChildren[0]
    885                                     = new OSnLNodeNumber();
    886                                 ((OSnLNodeNumber*)tmpValues->el[ival]->m_treeRoot->m_mChildren[0])->value = scaleMult;
    887                                 ((ComplexValuedExpressionArray*)tmpValues)->el[ival]->m_treeRoot->m_mChildren[1]
    888                                     = ((ComplexValuedExpressionArray*)baseMtx->value)
    889                                         ->el[j]->m_treeRoot->cloneExprNode();
    890                                 ival++;
    891 
    892                             }
    893                         }
    894                     tempMtx->index = tmpIndexes;
    895                     tempMtx->value = tmpValues;
    896                 }
    897             }
    898             else if (baseMtx->matrixType == ENUM_MATRIX_TYPE_objReference)
    899             {
    900                 throw ErrorClass("scalar multiple not defined for objReference elements in  processBaseMatrix()");
    901             }
    902             else if (baseMtx->matrixType == ENUM_MATRIX_TYPE_conReference)
    903             {
    904                 throw ErrorClass("scalar multiple not defined for conReference elements in  processBaseMatrix()");
    905             }
    906 //            return tempMtx;
    907547        }
    908548        tempMtx->printMatrix();
     
    916556
    917557
    918 GeneralSparseMatrix* MatrixType::expandBlocks(ExpandedMatrixBlocks* currentBlocks,
    919                                               bool rowMajor, ENUM_MATRIX_SYMMETRY symmetry)
    920 {
    921 #ifndef NDEBUG
    922     osoutput->OSPrint(ENUM_OUTPUT_AREA_OSInstance, ENUM_OUTPUT_LEVEL_trace, "Inside expandBlocks()");
    923 #endif
     558GeneralSparseMatrix* MatrixType::expandBlocks( ExpandedMatrixBlocks* currentBlocks, bool rowMajor_,
     559                                               ENUM_MATRIX_TYPE convertTo_,
     560                                               ENUM_MATRIX_SYMMETRY symmetry_)
     561{
     562#ifndef NDEBUG
     563    osoutput->OSPrint(ENUM_OUTPUT_AREA_OSMatrix, ENUM_OUTPUT_LEVEL_trace, "Inside expandBlocks()");
     564#endif
     565    GeneralSparseMatrix* tempMtx = NULL;
     566
     567    try
     568    {
     569        tempMtx = new GeneralSparseMatrix();
     570
     571        ENUM_MATRIX_TYPE convertTo = convertTo_;
     572        ENUM_MATRIX_TYPE inferredType = getMatrixType();
     573        if (convertTo == ENUM_MATRIX_TYPE_unknown)
     574            convertTo  = inferredType;
     575        if (convertTo != mergeMatrixType(convertTo, inferredType))
     576           throw ErrorClass("Requested improper conversion of element values");
     577
     578        ENUM_MATRIX_SYMMETRY symmetry = symmetry_;
     579
     580        if (symmetry == ENUM_MATRIX_SYMMETRY_default)
     581//            symmetry  = this->symmetry;
     582//        if (symmetry != this->symmetry)
     583            throw ErrorClass("Cannot handle symmetry properly in processBaseMatrix()");
     584
     585        tempMtx->b_deleteStartArray  = true;
     586        tempMtx->b_deleteIndexArray  = true;
     587        tempMtx->b_deleteValueArray  = true;
     588        tempMtx->isRowMajor          = rowMajor_;
     589        tempMtx->symmetry            = symmetry;
     590        tempMtx->numberOfRows        = numberOfRows;
     591        tempMtx->numberOfColumns     = numberOfColumns;
     592        tempMtx->startSize           = numberOfColumns + 1;
     593        tempMtx->start               = new int[numberOfColumns + 1];
     594        tempMtx->valueType           = convertTo;
     595        for (int i=0; i <= numberOfColumns; i++)
     596            tempMtx->start[i] = 0;
     597
     598        // augment column lengths block by block
     599        for (int i=0; i < currentBlocks->blockNumber; i++)
     600        {
     601            int c0 = currentBlocks->colOffset[currentBlocks->blockColumns[i]];
     602            int cN = currentBlocks->colOffset[currentBlocks->blockColumns[i]+1];
     603            for (int j = c0; j < cN; j++)
     604            {
     605                tempMtx->start[j+1] += ( currentBlocks->blocks[i]->start[j+1-c0]
     606                                       - currentBlocks->blocks[i]->start[j  -c0] );
     607            }
     608        }
     609
     610        for (int i=1; i <= numberOfColumns; i++)
     611            tempMtx->start[i] += tempMtx->start[i-1];
     612        tempMtx->valueSize = tempMtx->start[numberOfColumns];
     613        if (tempMtx->valueSize > 0)
     614            tempMtx->index = new int[tempMtx->valueSize];
     615
     616        // allocate space to store value array
     617        if (!tempMtx->allocateValueArray(tempMtx->valueSize))
     618            throw ErrorClass("Error while allocating value array for expanded baseMatrix");
     619
     620        // go through the blocks a second time to store values
     621        for (int i=0; i < currentBlocks->blockNumber; i++)
     622        {
     623            int c0 = currentBlocks->colOffset[currentBlocks->blockColumns[i]];
     624            int cN = currentBlocks->colOffset[currentBlocks->blockColumns[i]+1];
     625            int row_adj = currentBlocks->rowOffset[currentBlocks->blockRows[i]];
     626
     627            for (int j = c0; j < cN; j++)
     628            {
     629                int loc = tempMtx->start[j];
     630                for (int k = currentBlocks->blocks[i]->start[j-c0];
     631                         k < currentBlocks->blocks[i]->start[j-c0+1]; k++)
     632                {
     633                    tempMtx->index[loc] = currentBlocks->blocks[i]->index[k] + row_adj;
     634                    if (!tempMtx->copyValue(currentBlocks->blocks[i], k, loc))
     635                        throw ErrorClass("Matrix expansion failed while copying element values");
     636                    loc++;
     637                }
     638                tempMtx->start[j] = loc;
     639            }
     640        }
     641
     642        for (int i=numberOfColumns; i > 0; i--)
     643            tempMtx->start[i] =
     644                tempMtx->start[i-1];
     645
     646        tempMtx->start[0] = 0;
     647        tempMtx->printMatrix();
     648        return tempMtx;
     649    }
     650    catch(const ErrorClass& eclass)
     651    {
     652        if (tempMtx != NULL)
     653            delete tempMtx;
     654        tempMtx = NULL;
     655        throw ErrorClass( eclass.errormsg);
     656    }
     657}// end of expandBlocks
     658
     659GeneralSparseMatrix* MatrixType::expandBlocks( int nConst, bool rowMajor_,
     660                                               ENUM_MATRIX_TYPE convertTo_,
     661                                               ENUM_MATRIX_SYMMETRY symmetry_)
     662{
    924663    GeneralSparseMatrix* tempMtx = new GeneralSparseMatrix();
    925     tempMtx->b_deleteStartArray = true;
    926     tempMtx->b_deleteIndexArray = true;
    927     tempMtx->b_deleteValueArray = true;
    928     tempMtx->isRowMajor = false;
    929     tempMtx->symmetry   = symmetry;
    930     tempMtx->startSize  = numberOfColumns + 1;
    931     tempMtx->start      = new int[numberOfColumns + 1];
    932     tempMtx->matrixType = getMatrixType();
    933     for (int i=0; i <= numberOfColumns; i++)
    934         tempMtx->start[i] = 0;
    935 
    936     // augment column lengths block by block
    937     for (int i=0; i < currentBlocks->blockNumber; i++)
    938     {
    939         int c0 = currentBlocks->colOffset[currentBlocks->blockColumns[i]];
    940         int cN = currentBlocks->colOffset[currentBlocks->blockColumns[i]+1];
    941         for (int j = c0; j < cN; j++)
    942         {
    943             tempMtx->start[j+1] += ( currentBlocks->blocks[i]->start[j+1-c0]
    944                                    - currentBlocks->blocks[i]->start[j  -c0] );
    945         }
    946     }
    947 
    948     for (int i=1; i <= numberOfColumns; i++)
    949         tempMtx->start[i] += tempMtx->start[i-1];
    950     tempMtx->valueSize = tempMtx->start[numberOfColumns];
    951     if (tempMtx->valueSize > 0)
    952         tempMtx->index = new int[tempMtx->valueSize];
    953 
    954     // allocate space to store value array --- based on type
    955     switch (tempMtx->matrixType)
    956     {
    957         case ENUM_MATRIX_TYPE_empty:
    958             if (tempMtx->valueSize != 0)
    959                 throw ErrorClass("Matrix should be empty, but is not!!!");
    960             else
    961             {
    962                 tempMtx->matrixType = ENUM_MATRIX_TYPE_empty;
    963                 tempMtx->valueSize = 0;
    964                 for (int i=0; i <= numberOfColumns; i++)
    965                     tempMtx->start[i] = 0;
    966                 tempMtx->printMatrix();
    967                 return tempMtx;
    968             }
    969             break;
    970 
    971         case ENUM_MATRIX_TYPE_constant:
    972         {
    973             tempMtx->value = new ConstantMatrixValues();
    974             ((ConstantMatrixValues*)tempMtx->value)->el = new double[tempMtx->valueSize];
    975             break;
    976         }
    977 
    978         case ENUM_MATRIX_TYPE_complexConstant:
    979         {
    980             tempMtx->value = new ComplexMatrixValues();
    981             ((ComplexMatrixValues*)tempMtx->value)->el = new std::complex<double>[tempMtx->valueSize];
    982             break;
    983         }
    984 
    985         case ENUM_MATRIX_TYPE_varReference:
    986         {
    987             tempMtx->value = new VarReferenceMatrixValues();
    988             ((VarReferenceMatrixValues*)tempMtx->value)->el = new int[tempMtx->valueSize];
    989             break;
    990         }
    991 
    992         case ENUM_MATRIX_TYPE_linear:
    993         {
    994             tempMtx->value = new LinearMatrixValues();
    995             ((LinearMatrixValues*)tempMtx->value)->el = new LinearMatrixElement*[tempMtx->valueSize];
    996             break;
    997         }
    998 
    999         case ENUM_MATRIX_TYPE_objReference:
    1000         {
    1001             tempMtx->value = new ObjReferenceMatrixValues();
    1002             ((ObjReferenceMatrixValues*)tempMtx->value)->el = new int[tempMtx->valueSize];
    1003             break;
    1004         }
    1005 
    1006         case ENUM_MATRIX_TYPE_mixedRowReference:
    1007         case ENUM_MATRIX_TYPE_conReference:
    1008         {
    1009             tempMtx->value = new ConReferenceMatrixValues();
    1010             ((ConReferenceMatrixValues*)tempMtx->value)->el
    1011                 = new ConReferenceMatrixElement*[tempMtx->valueSize];
    1012             break;
    1013         }
    1014 
    1015         case ENUM_MATRIX_TYPE_realValuedExpressions:
    1016         {
    1017             tempMtx->value = new RealValuedExpressionArray();
    1018             ((RealValuedExpressionArray*)tempMtx->value)->el
    1019                 = new RealValuedExpressionTree*[tempMtx->valueSize];
    1020             break;
    1021         }
    1022 
    1023 
    1024         case ENUM_MATRIX_TYPE_complexValuedExpressions:
    1025         {
    1026             tempMtx->value = new ComplexValuedExpressionArray();
    1027             ((ComplexValuedExpressionArray*)tempMtx->value)->el
    1028                 = new ComplexValuedExpressionTree*[tempMtx->valueSize];
    1029             break;
    1030         }
    1031 
    1032         case ENUM_MATRIX_TYPE_string:
    1033         {
    1034             tempMtx->value = new StringValuedMatrixValues();
    1035             ((StringValuedMatrixValues*)tempMtx->value)->el = new std::string[tempMtx->valueSize];
    1036             break;
    1037         }
    1038 
    1039         default :
    1040             throw ErrorClass("Unsupported matrix type");
    1041             break;
    1042     }
    1043 
    1044     // go through the blocks a second time to store values --- based on type
    1045     for (int i=0; i < currentBlocks->blockNumber; i++)
    1046     {
    1047         int c0 = currentBlocks->colOffset[currentBlocks->blockColumns[i]];
    1048         int cN = currentBlocks->colOffset[currentBlocks->blockColumns[i]+1];
    1049         int row_adj = currentBlocks->rowOffset[currentBlocks->blockRows[i]];
    1050 
    1051         for (int j = c0; j < cN; j++)
    1052         {
    1053             int loc = tempMtx->start[j];
    1054             for (int k = currentBlocks->blocks[i]->start[j-c0];
    1055                      k < currentBlocks->blocks[i]->start[j-c0+1]; k++)
    1056             {
    1057                 // the index is independent of value type
    1058                 tempMtx->index[loc] = currentBlocks->blocks[i]->index[k] + row_adj;
    1059 
    1060                 // the value needs to be processed separately for each type (and possibly converted)
    1061                 switch (tempMtx->matrixType)
     664    try
     665    {
     666#ifndef NDEBUG
     667        osoutput->OSPrint(ENUM_OUTPUT_AREA_OSMatrix, ENUM_OUTPUT_LEVEL_trace, "Inside expandBlocks()");
     668#endif
     669        if (m_mChildren[nConst]->nType != ENUM_MATRIX_CONSTRUCTOR_TYPE_blocks)
     670            throw ErrorClass("expandBlocks(): Constructor does not have <blocks> type");
     671
     672        // Here we have matching block partitions
     673        ExpandedMatrixBlocks* tmpBlocks = new ExpandedMatrixBlocks();
     674
     675        ENUM_MATRIX_TYPE convertTo = convertTo_;
     676        ENUM_MATRIX_TYPE inferredType = getMatrixType();
     677        if (convertTo == ENUM_MATRIX_TYPE_unknown)
     678            convertTo  = inferredType;
     679        if (convertTo != mergeMatrixType(convertTo, inferredType))
     680           throw ErrorClass("Requested improper conversion of element values");
     681
     682        ENUM_MATRIX_SYMMETRY symmetry = symmetry_;
     683
     684        if (symmetry == ENUM_MATRIX_SYMMETRY_default)
     685//            symmetry  = this->symmetry;
     686//        if (symmetry != this->symmetry)
     687            throw ErrorClass("Cannot handle symmetry properly in expandBlocks()");
     688
     689        tmpBlocks->bDeleteArrays = false;
     690        tmpBlocks->valueType     = convertTo;
     691        tmpBlocks->isRowMajor    = rowMajor_;
     692        tmpBlocks->rowOffsetSize = sizeof(((MatrixBlocks*)m_mChildren[nConst])->rowOffset)/sizeof(int);
     693        tmpBlocks->colOffsetSize = sizeof(((MatrixBlocks*)m_mChildren[nConst])->colOffset)/sizeof(int);
     694        tmpBlocks->rowOffset     = new int[tmpBlocks->rowOffsetSize];
     695        tmpBlocks->colOffset     = new int[tmpBlocks->colOffsetSize];
     696        for (int kr=0; kr < tmpBlocks->rowOffsetSize; kr++)
     697            tmpBlocks->rowOffset[kr] = ((MatrixBlocks*)m_mChildren[nConst])->rowOffset->el[kr];
     698        for (int kc=0; kc < tmpBlocks->rowOffsetSize; kc++)
     699            tmpBlocks->colOffset[kc] = ((MatrixBlocks*)m_mChildren[nConst])->colOffset->el[kc];
     700
     701        // Allocate memory
     702        tmpBlocks->blockNumber  = ((MatrixBlocks*)m_mChildren[nConst])->inumberOfChildren;
     703        tmpBlocks->blocks       = new GeneralSparseMatrix*[tmpBlocks->blockNumber];
     704        tmpBlocks->blockRows    = new int[tmpBlocks->blockNumber];
     705        tmpBlocks->blockColumns = new int[tmpBlocks->blockNumber];
     706
     707        // access each block; expand and store pointers
     708        MatrixBlock* tmpChild;
     709        int tmpBlockNumber = 0;
     710        for (unsigned int j=0; j<((MatrixBlocks*)m_mChildren[nConst])->inumberOfChildren; j++)
     711        {
     712            tmpChild = (MatrixBlock*)((MatrixBlocks*)m_mChildren[nConst])->m_mChildren[j];
     713            int iBlock = tmpChild->getExpandedMatrix(rowMajor_, convertTo, symmetry);
     714            if (iBlock < 0)
     715                throw ErrorClass("One or more blocks could not be expanded");
     716            tmpBlocks->blocks[tmpBlockNumber] = tmpChild->expandedMatrixByElements[iBlock];
     717            tmpBlocks->blockRows[tmpBlockNumber]    = tmpChild->blockRowIdx;
     718            tmpBlocks->blockColumns[tmpBlockNumber] = tmpChild->blockColIdx;
     719
     720#ifndef NDEBUG
     721            ((GeneralSparseMatrix*)tmpBlocks->blocks[tmpBlockNumber])->printMatrix();
     722#endif
     723
     724            tmpBlockNumber++;
     725        }
     726
     727        tempMtx->b_deleteStartArray  = true;
     728        tempMtx->b_deleteIndexArray  = true;
     729        tempMtx->b_deleteValueArray  = true;
     730        tempMtx->isRowMajor          = rowMajor_;
     731        tempMtx->symmetry            = symmetry;
     732        tempMtx->numberOfRows        = numberOfRows;
     733        tempMtx->numberOfColumns     = numberOfColumns;
     734        tempMtx->startSize           = numberOfColumns + 1;
     735        tempMtx->start               = new int[numberOfColumns + 1];
     736        tempMtx->valueType           = convertTo;
     737        for (int i=0; i <= numberOfColumns; i++)
     738            tempMtx->start[i] = 0;
     739
     740        // augment column lengths block by block
     741        for (int i=0; i < tmpBlockNumber; i++)
     742        {
     743            int c0 = tmpBlocks->colOffset[tmpBlocks->blockColumns[i]];
     744            int cN = tmpBlocks->colOffset[tmpBlocks->blockColumns[i]+1];
     745            for (int j = c0; j < cN; j++)
     746            {
     747                tempMtx->start[j+1] += ( tmpBlocks->blocks[i]->start[j+1-c0]
     748                                       - tmpBlocks->blocks[i]->start[j  -c0] );
     749            }
     750        }
     751
     752        for (int i=1; i <= numberOfColumns; i++)
     753            tempMtx->start[i] += tempMtx->start[i-1];
     754        tempMtx->valueSize = tempMtx->start[numberOfColumns];
     755        if (tempMtx->valueSize > 0)
     756            tempMtx->index = new int[tempMtx->valueSize];
     757
     758        // allocate space to store value array
     759        if (!tempMtx->allocateValueArray(tempMtx->valueSize))
     760            throw ErrorClass("Error while allocating value array for expanded baseMatrix");
     761
     762        // go through the blocks a second time to store values
     763        for (int i=0; i < tmpBlockNumber; i++)
     764        {
     765            int c0      = tmpBlocks->colOffset[tmpBlocks->blockColumns[i]];
     766            int cN      = tmpBlocks->colOffset[tmpBlocks->blockColumns[i]+1];
     767            int row_adj = tmpBlocks->rowOffset[tmpBlocks->blockRows[i]];
     768   
     769            for (int j = c0; j < cN; j++)
     770            {
     771                int loc = tempMtx->start[j];
     772                for (int k = tmpBlocks->blocks[i]->start[j-c0];
     773                         k < tmpBlocks->blocks[i]->start[j-c0+1]; k++)
    1062774                {
    1063                     case ENUM_MATRIX_TYPE_constant:
    1064                     {
    1065                         ((ConstantMatrixValues*) tempMtx->value)->el[loc]
    1066                             = ((ConstantMatrixValues*) currentBlocks->blocks[i]->value)->el[k];
    1067                         break;
    1068                     }
    1069 
    1070                     case ENUM_MATRIX_TYPE_varReference:
    1071                     {
    1072                         ((VarReferenceMatrixValues*) tempMtx->value)->el[loc]
    1073                             = ((VarReferenceMatrixValues*) currentBlocks->blocks[i]->value)->el[k];
    1074                         break;
    1075                     }
    1076 
    1077                     case ENUM_MATRIX_TYPE_objReference:
    1078                     {
    1079                         ((ObjReferenceMatrixValues*) tempMtx->value)->el[loc]
    1080                             = ((ObjReferenceMatrixValues*) currentBlocks->blocks[i]->value)->el[k];
    1081                         break;
    1082                     }
    1083 
    1084                     case ENUM_MATRIX_TYPE_conReference:
    1085                     {
    1086                         ((ConReferenceMatrixValues*) tempMtx->value)->el[loc]
    1087                             = new ConReferenceMatrixElement();
    1088                         if (currentBlocks->blocks[i]->matrixType
    1089                                     == ENUM_MATRIX_TYPE_conReference)
    1090                         {
    1091                             ((ConReferenceMatrixValues*)tempMtx->value)
    1092                                 ->el[loc]->deepCopyFrom(((ConReferenceMatrixValues*)
    1093                                     currentBlocks->blocks[i]->value)->el[k]);
    1094                         }
    1095                         else
    1096                             throw ErrorClass ("undefined matrix element conversion");
    1097                         break;
    1098                     }
    1099 
    1100                     // The other types may require conversion and more elaborate copying
    1101                     // First, complexConstant. The only legal conversion is from (real) constant
    1102                     case ENUM_MATRIX_TYPE_complexConstant:
    1103                     {
    1104                         if (currentBlocks->blocks[i]->matrixType == ENUM_MATRIX_TYPE_complexConstant)
    1105                         {
    1106                             std::complex<double> (((ComplexMatrixValues*)  tempMtx->value)->el[loc])
    1107                                 = ((ComplexMatrixValues*) currentBlocks->blocks[i]->value)->el[k]; 
    1108                         }
    1109                         else if (currentBlocks->blocks[i]->matrixType == ENUM_MATRIX_TYPE_constant)
    1110                         {
    1111                             std::complex<double> (((ComplexMatrixValues*)  tempMtx->value)->el[loc])
    1112                                  = convertToComplexMatrixElement(((ConstantMatrixValues*)
    1113                                                           currentBlocks->blocks[i]->value)->el[k]); 
    1114                         }
    1115                         else
    1116                             throw ErrorClass ("undefined matrix element conversion");
    1117                         break;
    1118                     }
    1119 
    1120                     case ENUM_MATRIX_TYPE_linear:
    1121                     {
    1122                         ((LinearMatrixElements*) tempMtx)->value->el[loc] = new LinearMatrixElement();
    1123                         switch (currentBlocks->blocks[i]->matrixType)
    1124                         {
    1125                             // linear elements do not have to be converted
    1126                             case ENUM_MATRIX_TYPE_linear:
    1127                             {
    1128                                 ((LinearMatrixValues*)tempMtx->value)
    1129                                     ->el[loc]->deepCopyFrom(((LinearMatrixValues*)
    1130                                         currentBlocks->blocks[i]->value)->el[k]);
    1131                                 break;
    1132                             }
    1133 
    1134                             // legal conversions: constant, varReference
    1135                             case ENUM_MATRIX_TYPE_constant:
    1136                             {
    1137                                 ((LinearMatrixValues*) tempMtx->value)->el[loc]->constant
    1138                                     = ((ConstantMatrixValues*) currentBlocks->blocks[i]->value)->el[k];
    1139                                 break;
    1140                             }
    1141                             case ENUM_MATRIX_TYPE_varReference:
    1142                             {
    1143                                 ((LinearMatrixValues*)tempMtx->value)->el[loc]->numberOfVarIdx = 1;
    1144                                 ((LinearMatrixValues*)tempMtx->value)->el[loc]->varIdx
    1145                                     = new LinearMatrixElementTerm*[1];
    1146                                 ((LinearMatrixValues*)tempMtx->value)->el[loc]->varIdx[0]
    1147                                     = new LinearMatrixElementTerm();
    1148                                 ((LinearMatrixValues*)tempMtx->value)->el[loc]->varIdx[0]->idx
    1149                                     = ((VarReferenceMatrixValues*) currentBlocks->blocks[i]->value)->el[k];
    1150                                 ((LinearMatrixValues*)tempMtx->value)->el[loc]->varIdx[0]->coef = 0;
    1151                                 break;
    1152                             }
    1153                             // other conversion are illegal
    1154                             default:
    1155                                 throw ErrorClass ("undefined matrix element conversion");
    1156                                 break;
    1157                         }
    1158                         break;
    1159                     }
    1160 
    1161                     case ENUM_MATRIX_TYPE_mixedRowReference:
    1162                     {
    1163                         ((ConReferenceMatrixValues*) tempMtx->value)->el[loc]
    1164                             = new ConReferenceMatrixElement();
    1165 
    1166                         switch (currentBlocks->blocks[i]->matrixType)
    1167                         {
    1168                             // elements with constraint references do not have to be converted
    1169                             case ENUM_MATRIX_TYPE_mixedRowReference:
    1170                             case ENUM_MATRIX_TYPE_conReference:
    1171                             {
    1172                                 ((ConReferenceMatrixValues*) tempMtx->value)->el[loc]->deepCopyFrom(
    1173                                     ((ConReferenceMatrixValues*) currentBlocks->blocks[i]->value)->el[k]);
    1174                                 break;
    1175                             }
    1176 
    1177                             // only other legal possibility: objective references
    1178                             case ENUM_MATRIX_TYPE_objReference:
    1179                             {
    1180                                 ((ConReferenceMatrixValues*) tempMtx->value)->el[loc]
    1181                                     = new ConReferenceMatrixElement();
    1182                                 ((ConReferenceMatrixValues*) tempMtx->value)->el[loc]->conReference
    1183                                     = ((ObjReferenceMatrixValues*)currentBlocks->blocks[i]->value)->el[k];
    1184                                 break;
    1185                             }
    1186 
    1187                             default:
    1188                                 throw ErrorClass ("undefined matrix element conversion");
    1189                                 break;
    1190                         }
    1191                         break;
    1192                     }
    1193 
    1194                     case ENUM_MATRIX_TYPE_realValuedExpressions:
    1195                     {
    1196                         switch (currentBlocks->blocks[i]->matrixType)
    1197                         {
    1198                             case ENUM_MATRIX_TYPE_constant:
    1199                             {
    1200                                 ((RealValuedExpressionArray*) tempMtx->value)->el[loc]
    1201                                     = new RealValuedExpressionTree();
    1202                                 ((RealValuedExpressionArray*) tempMtx->value)->el[loc]
    1203                                     = convertToRealExpressionTree(((ConstantMatrixValues*)
    1204                                                                  currentBlocks->blocks[i]->value)->el[k]);
    1205                                 break;
    1206                             }
    1207                             case ENUM_MATRIX_TYPE_varReference:
    1208                             {
    1209                                 ((RealValuedExpressionArray*) tempMtx->value)->el[loc]
    1210                                     = new RealValuedExpressionTree();
    1211                                 ((RealValuedExpressionArray*) tempMtx->value)->el[loc]
    1212                                     = convertToRealExpressionTree(((VarReferenceMatrixValues*)
    1213                                                           currentBlocks->blocks[i]->value)->el[k], true);
    1214                                 break;
    1215                             }
    1216 
    1217                             case ENUM_MATRIX_TYPE_realValuedExpressions:
    1218                             {
    1219                                 ((RealValuedExpressionArray*) tempMtx->value)->el[loc]
    1220                                     = new RealValuedExpressionTree();
    1221                                 ((RealValuedExpressionArray*) tempMtx->value)->el[loc]->m_treeRoot
    1222                                     = ((RealValuedExpressionArray*)currentBlocks->blocks[i]
    1223                                                     ->value)->el[k]->m_treeRoot->cloneExprNode();
    1224                                 break;
    1225                             }
    1226 
    1227                             case ENUM_MATRIX_TYPE_linear:
    1228                             {
    1229                                 ((RealValuedExpressionArray*) tempMtx->value)->el[loc]
    1230                                     = new RealValuedExpressionTree();
    1231                                 ((RealValuedExpressionArray*) tempMtx->value)->el[loc]
    1232                                     = convertToRealExpressionTree(((LinearMatrixValues*)
    1233                                                     currentBlocks->blocks[i]->value)->el[k]);
    1234                                 break;
    1235                             }
    1236 
    1237                             case ENUM_MATRIX_TYPE_objReference:
    1238                                 throw ErrorClass("OSnLNodeObjective not implemented yet");
    1239                                 break;
    1240 
    1241                             case ENUM_MATRIX_TYPE_conReference:
    1242                                 throw ErrorClass("OSnLNodeConstraint not implemented yet");
    1243                                 break;
    1244 
    1245                             case ENUM_MATRIX_TYPE_mixedRowReference:
    1246                                 throw ErrorClass("relevant OSnLNodes not implemented yet");
    1247                                 break;
    1248 
    1249                             case ENUM_MATRIX_TYPE_complexConstant:
    1250                             case ENUM_MATRIX_TYPE_complexValuedExpressions:
    1251                                 throw ErrorClass("improper conversion of complex-valued elements");
    1252                                 break;
    1253 
    1254                             default: throw ErrorClass ("undefined matrix element conversion");
    1255                                 break;
    1256                         }
    1257                         break;
    1258                     }
    1259 
    1260                     case ENUM_MATRIX_TYPE_complexValuedExpressions:
    1261                     {
    1262                         ComplexValuedExpressionTree* temp = new ComplexValuedExpressionTree();
    1263 
    1264                         switch (currentBlocks->blocks[i]->matrixType)
    1265                         {
    1266                             case ENUM_MATRIX_TYPE_complexValuedExpressions:
    1267                             {
    1268                                 temp->m_treeRoot
    1269                                     = ((ComplexValuedExpressionArray*)currentBlocks->blocks[i]
    1270                                                     ->value)->el[k]->m_treeRoot->cloneExprNode();
    1271                                 break;
    1272                             }
    1273 
    1274                             case ENUM_MATRIX_TYPE_constant:
    1275                             {
    1276                                 temp->m_treeRoot = new OSnLCNodeNumber();
    1277                                 double tempVal = ((ConstantMatrixValues*)
    1278                                                         currentBlocks->blocks[i]->value)->el[k];
    1279                                 ((OSnLCNodeNumber*) temp->m_treeRoot)->setValue(tempVal, 0.0);
    1280                                 break;
    1281                             }
    1282 
    1283                             case ENUM_MATRIX_TYPE_complexConstant:
    1284                             {
    1285                                 temp->m_treeRoot = new OSnLCNodeNumber();
    1286                                 std::complex<double> tempVal 
    1287                                     = ((ComplexMatrixValues*)
    1288                                                     currentBlocks->blocks[i]->value)->el[k];
    1289                                 ((OSnLCNodeNumber*) temp->m_treeRoot)->setValue(tempVal);
    1290                                 break;
    1291                             }
    1292 
    1293                             case ENUM_MATRIX_TYPE_varReference:
    1294                             {
    1295                                 temp->m_treeRoot = new OSnLCNodeCreate();
    1296                                 temp->m_treeRoot->m_mChildren[0] = new OSnLNodeVariable();
    1297                                 temp->m_treeRoot->m_mChildren[1] = new OSnLNodeNumber();
    1298                                 ((OSnLNodeVariable*)temp->m_treeRoot->m_mChildren[0])->idx
    1299                                     = ((VarReferenceMatrixValues*) currentBlocks->blocks[i]->value)->el[k];
    1300                                 ((OSnLNodeNumber*) temp->m_treeRoot->m_mChildren[1])->value = 0.0;
    1301                                 break;
    1302                             }
    1303 
    1304                             case ENUM_MATRIX_TYPE_realValuedExpressions:
    1305                             {
    1306                                 temp->m_treeRoot = new OSnLCNodeCreate();
    1307                                 temp->m_treeRoot->m_mChildren[1] = new OSnLNodeNumber();
    1308                                 ((OSnLNodeNumber*) temp->m_treeRoot->m_mChildren[1])->value = 0.0;
    1309 
    1310                                 temp->m_treeRoot->m_mChildren[0]
    1311                                     = ((RealValuedExpressionArray*)currentBlocks->blocks[i]
    1312                                                     ->value)->el[k]->m_treeRoot->cloneExprNode();
    1313                                 break;
    1314                             }
    1315 
    1316                             // the hardest conversion: linear expressions
    1317                             case ENUM_MATRIX_TYPE_linear:
    1318                             {
    1319                                 temp->m_treeRoot = new OSnLCNodeCreate();
    1320                                 temp->m_treeRoot->m_mChildren[1] = new OSnLNodeNumber();
    1321                                 ((OSnLNodeNumber*) temp->m_treeRoot->m_mChildren[1])->value = 0.0;
    1322 
    1323                                 int nn = ((LinearMatrixValues*)
    1324                                     currentBlocks->blocks[i]->value)->el[k]->numberOfVarIdx;
    1325                                 bool haveConstant;
    1326 
    1327                                 if (((LinearMatrixValues*)
    1328                                     currentBlocks->blocks[i]->value)->el[k]->constant == 0)
    1329                                 {
    1330                                     haveConstant = false;
    1331                                     if (nn == 0)
    1332                                     {
    1333                                         temp->m_treeRoot->m_mChildren[0] = new OSnLNodeNumber();
    1334                                         ((OSnLNodeNumber*) temp->m_treeRoot->m_mChildren[1])->value = 0.0;
    1335                                         break;
    1336                                     }
    1337                                     temp->m_treeRoot->m_mChildren[0] = new OSnLNodeSum();
    1338                                     temp->m_treeRoot->m_mChildren[0]->m_mChildren = new ExprNode*[nn];
    1339                                     temp->m_treeRoot->m_mChildren[0]->inumberOfChildren = nn;
    1340                                 }
    1341                                 else
    1342                                 {
    1343                                     haveConstant = true;
    1344                                     temp->m_treeRoot->m_mChildren[0] = new OSnLNodeSum();
    1345                                     temp->m_treeRoot->m_mChildren[0]->m_mChildren = new ExprNode*[nn+1];
    1346                                     temp->m_treeRoot->m_mChildren[0]->inumberOfChildren = nn+1;
    1347                                 }
    1348 
    1349                                 for (int ii=0; ii<nn; ii++)
    1350                                 {
    1351                                     temp->m_treeRoot->m_mChildren[0]->m_mChildren[ii]
    1352                                                     = new OSnLNodeVariable();
    1353                                     ((OSnLNodeVariable*)
    1354                                             temp->m_treeRoot->m_mChildren[0]->m_mChildren[ii])->idx
    1355                                         = ((LinearMatrixValues*)
    1356                                             currentBlocks->blocks[i]->value)->el[k]->varIdx[ii]->idx;
    1357                                     ((OSnLNodeVariable*)
    1358                                             temp->m_treeRoot->m_mChildren[0]->m_mChildren[ii])->coef
    1359                                         = ((LinearMatrixValues*)
    1360                                             currentBlocks->blocks[i]->value)->el[k]->varIdx[ii]->coef;
    1361                                 }
    1362 
    1363                                 if (haveConstant)
    1364                                 {
    1365                                     temp->m_treeRoot->m_mChildren[0]->m_mChildren[nn]
    1366                                                     = new OSnLNodeNumber();
    1367                                     ((OSnLNodeNumber*)
    1368                                             temp->m_treeRoot->m_mChildren[0]->m_mChildren[nn])->value
    1369                                         = ((LinearMatrixValues*)
    1370                                             currentBlocks->blocks[i]->value)->el[k]->constant;
    1371                                 }
    1372                                 break;
    1373                             }
    1374 
    1375                             case ENUM_MATRIX_TYPE_objReference:
    1376                             {
    1377                                 throw ErrorClass("OSnLNodeObjective not implemented yet");
    1378                                 break;
    1379                             }
    1380 
    1381                             case ENUM_MATRIX_TYPE_conReference:
    1382                             {
    1383                                 throw ErrorClass("OSnLNodeConstraint not implemented yet");
    1384                                 break;
    1385                             }
    1386 
    1387                             case ENUM_MATRIX_TYPE_mixedRowReference:
    1388                             {
    1389                                 throw ErrorClass("relevant OSnLNodes not implemented yet");
    1390                                 break;
    1391                             }
    1392 
    1393                             default:
    1394                             {
    1395                                 throw ErrorClass("undefined matrix element conversion");
    1396                                 break;
    1397                             }
    1398                         } // end of switch for source element types
    1399 
    1400                         ((ComplexValuedExpressionArray*) tempMtx->value)->el[loc] = temp;
    1401                         break;
    1402                     } // end of case complexValuedExpressions for target element value
    1403 
    1404                     case ENUM_MATRIX_TYPE_string:
    1405                     {
    1406                         ostringstream outStr;
    1407 
    1408                         switch (currentBlocks->blocks[i]->matrixType)
    1409                         {
    1410                             case ENUM_MATRIX_TYPE_constant:
    1411                                 outStr << os_dtoa_format(((ConstantMatrixValues*)
    1412                                                currentBlocks->blocks[i]->value)->el[k]);
    1413                             break;
    1414 
    1415                             case ENUM_MATRIX_TYPE_complexConstant:
    1416                                 outStr << "(" << os_dtoa_format(((ComplexMatrixValues*)
    1417                                             currentBlocks->blocks[i]->value)->el[k].real());
    1418                                 outStr << "," << os_dtoa_format(((ComplexMatrixValues*)
    1419                                             currentBlocks->blocks[i]->value)->el[k].imag());
    1420                                 outStr << ")";
    1421                             break;
    1422 
    1423                             case ENUM_MATRIX_TYPE_varReference:
    1424                                 outStr << "x_"
    1425                                        << ((VarReferenceMatrixValues*)
    1426                                                 currentBlocks->blocks[i]->value)->el[k];
    1427                             break;
    1428 
    1429                             case ENUM_MATRIX_TYPE_objReference:
    1430                                 outStr << "o_"
    1431                                        << ((ObjReferenceMatrixValues*)
    1432                                                 currentBlocks->blocks[i]->value)->el[k];
    1433                             break;
    1434 
    1435                             case ENUM_MATRIX_TYPE_conReference:
    1436                                 outStr << "c_"
    1437                                        << ((ConReferenceMatrixValues*)
    1438                                            currentBlocks->blocks[i]->value)->el[k]->conReference
    1439                                        << "."
    1440                                        << returnConReferenceValueTypeString(
    1441                                            ((ConReferenceMatrixValues*)
    1442                                                    currentBlocks->blocks[i]->value)->el[k]->valueType);
    1443                             break;
    1444 
    1445                             case ENUM_MATRIX_TYPE_mixedRowReference:
    1446                             {
    1447                                 int temp = ((ConReferenceMatrixValues*)
    1448                                                    currentBlocks->blocks[i]->value)->el[k]->conReference;
    1449                                 if (temp < 0)
    1450                                     outStr << "o_"
    1451                                            << temp;
    1452                                 else
    1453                                     outStr << "c_"
    1454                                            << temp
    1455                                            << "."
    1456                                            << returnConReferenceValueTypeString(
    1457                                                ((ConReferenceMatrixValues*)
    1458                                                    currentBlocks->blocks[i]->value)->el[k]->valueType);
    1459                                 break;
    1460                             }
    1461 
    1462                             case ENUM_MATRIX_TYPE_string:
    1463                                 outStr << ((StringValuedMatrixValues*)
    1464                                                currentBlocks->blocks[i]->value)->el[k];
    1465                             break;
    1466 
    1467                             case ENUM_MATRIX_TYPE_linear:
    1468                             {
    1469                                 LinearMatrixElement* temp =
    1470                                     ((LinearMatrixValues*) currentBlocks->blocks[i]->value)->el[k];
    1471                                 if (temp->constant < 0.0 || temp->constant > 0.0)
    1472                                 {
    1473                                     outStr << os_dtoa_format(temp->constant);
    1474                                 }
    1475                                 if (temp->numberOfVarIdx > 0)
    1476                                 {
    1477                                     if (temp->varIdx[0]->coef >= 0)
    1478                                     {
    1479                                         if (temp->constant < 0.0 || temp->constant > 0.0)
    1480                                             outStr << " + ";
    1481                                         else
    1482                                             outStr << " - ";
    1483                                     }
    1484                                     else
    1485                                         outStr << "-";
    1486                                     if (temp->varIdx[0]->coef < 1 || temp->varIdx[0]->coef > 1 )
    1487                                         outStr << os_dtoa_format(abs(temp->varIdx[0]->coef))
    1488                                                << "*";
    1489                                     outStr << "x_" << temp->varIdx[0]->idx;
    1490                                 }
    1491                                 for (int j=1; j<temp->numberOfVarIdx; j++)
    1492                                 {
    1493                                     if (temp->varIdx[j]->coef >= 0)
    1494                                         outStr << " + ";
    1495                                     else
    1496                                         outStr << " - ";
    1497                                     if (temp->varIdx[j]->coef < 1 || temp->varIdx[j]->coef > 1 )
    1498                                         outStr << os_dtoa_format(abs(temp->varIdx[j]->coef)) << "*";
    1499                                     outStr << "x_" << temp->varIdx[j]->idx;
    1500                                 }
    1501                                 break;
    1502                             }
    1503 
    1504                             case ENUM_MATRIX_TYPE_realValuedExpressions:
    1505                             {
    1506                                 std::vector<ExprNode*> postfixVec;
    1507                                 if ( ((RealValuedExpressionArray*)
    1508                                                     currentBlocks->blocks[i]->value)->el[k] != NULL)
    1509                                 {
    1510                                     postfixVec = ((RealValuedExpressionArray*)
    1511                                         currentBlocks->blocks[i]->value)->el[k]
    1512                                                         ->getPostfixFromExpressionTree();
    1513                                     outStr << getExpressionTreeAsInfixString(postfixVec);
    1514                                 }
    1515                                 else
    1516                                     outStr.str() = "";
    1517                                 break;
    1518                             }
    1519 
    1520                             case ENUM_MATRIX_TYPE_complexValuedExpressions:
    1521                             {
    1522                                 std::vector<ExprNode*> postfixVec;
    1523                                 if ( ((ComplexValuedExpressionArray*)
    1524                                         currentBlocks->blocks[i]->value)->el[k] != NULL)
    1525                                 {
    1526                                     postfixVec = ((ComplexValuedExpressionArray*)
    1527                                                     currentBlocks->blocks[i]->value)->el[k]
    1528                                                         ->getPostfixFromExpressionTree();
    1529                                     outStr << getExpressionTreeAsInfixString(postfixVec);
    1530                                 }
    1531                                else
    1532                                     outStr.str() = "";
    1533                                 break;
    1534                             }
    1535 
    1536                             default:
    1537                                 throw ErrorClass("undefined matrix element conversion");
    1538                                 break;
    1539 
    1540                         }
    1541                         ((StringValuedMatrixValues*) tempMtx->value)->el[loc] = outStr.str();
    1542                         break;
    1543                     }
    1544 
    1545                     case ENUM_MATRIX_TYPE_empty:
    1546                         throw ErrorClass("Matrix should be empty, but is not!!!");
    1547                         break;
    1548 
    1549                     default :
    1550                         throw ErrorClass("Unsupported matrix type");
    1551                         break;
    1552 
     775                    tempMtx->index[loc] = tmpBlocks->blocks[i]->index[k] + row_adj;
     776                    tempMtx->copyValue(tmpBlocks->blocks[i],tmpBlocks->blocks[i]->index[k],loc);
    1553777                }
    1554                 loc++;
    1555             }
    1556             tempMtx->start[j] = loc;
    1557         }
    1558     }
    1559 
    1560     for (int i=numberOfColumns; i > 0; i--)
    1561         tempMtx->start[i] =
    1562             tempMtx->start[i-1];
    1563     tempMtx->start[0] = 0;
    1564     tempMtx->printMatrix();
    1565     return tempMtx;
     778            }
     779        }
     780   
     781        for (int i=numberOfColumns; i > 0; i--)
     782            tempMtx->start[i] =
     783                tempMtx->start[i-1];
     784        tempMtx->start[0] = 0;
     785
     786        tempMtx->printMatrix();
     787
     788        return tempMtx;
     789    }
     790    catch(const ErrorClass& eclass)
     791    {
     792        // clear memory if already allocated
     793        if (tempMtx != NULL)
     794            delete tempMtx;
     795        tempMtx = NULL;
     796        throw ErrorClass( eclass.errormsg);
     797    }
    1566798}// end of expandBlocks
    1567799
     800
    1568801GeneralSparseMatrix* MatrixType::extractElements(int constructorNo_, bool rowMajor,
    1569                                                  ENUM_MATRIX_SYMMETRY symmetry)
    1570 {
    1571 #ifndef NDEBUG
    1572     osoutput->OSPrint(ENUM_OUTPUT_AREA_OSInstance, ENUM_OUTPUT_LEVEL_trace, "Inside extractElements()");
     802                                                 ENUM_MATRIX_SYMMETRY symmetry_)
     803{
     804#ifndef NDEBUG
     805    osoutput->OSPrint(ENUM_OUTPUT_AREA_OSMatrix, ENUM_OUTPUT_LEVEL_trace, "Inside extractElements()");
    1573806#endif
    1574807
     
    1579812        if (!((MatrixElements*)m_mChildren[constructorNo_])->rowMajor)
    1580813        {
     814            ENUM_MATRIX_SYMMETRY symmetry = symmetry_;
     815
     816            if (symmetry == ENUM_MATRIX_SYMMETRY_default)
     817//                symmetry  = this->symmetry;
     818//            if (symmetry != this->symmetry)
     819                throw ErrorClass("Cannot handle symmetry properly in expandBlocks()");
     820
    1581821            tempMtx->symmetry = symmetry;
    1582822            tempMtx->b_deleteStartArray = false;
     
    1584824            tempMtx->b_deleteValueArray = false;
    1585825            tempMtx->isRowMajor = false;
    1586             tempMtx->matrixType = m_mChildren[constructorNo_]->getMatrixType();
     826            tempMtx->valueType  = m_mChildren[constructorNo_]->getMatrixType();
     827            tempMtx->numberOfRows    = numberOfRows;
     828            tempMtx->numberOfColumns = numberOfColumns;
    1587829            tempMtx->startSize  = numberOfColumns + 1;
    1588830            tempMtx->valueSize  = ((MatrixElements*)m_mChildren[constructorNo_])->numberOfValues;
     
    1590832            tempMtx->index      = ((MatrixElements*)m_mChildren[constructorNo_])->index->el;
    1591833
    1592             if (tempMtx->matrixType == ENUM_MATRIX_TYPE_constant)
     834            if (tempMtx->valueType == ENUM_MATRIX_TYPE_constant)
    1593835                tempMtx->value  = ((ConstantMatrixElements*)m_mChildren[constructorNo_])->value;
    1594836
    1595             else if (tempMtx->matrixType == ENUM_MATRIX_TYPE_varReference)
     837            else if (tempMtx->valueType == ENUM_MATRIX_TYPE_varReference)
    1596838                tempMtx->value  = ((VarReferenceMatrixElements*)m_mChildren[constructorNo_])->value;
    1597839
    1598             else if (tempMtx->matrixType == ENUM_MATRIX_TYPE_linear)
     840            else if (tempMtx->valueType == ENUM_MATRIX_TYPE_linear)
    1599841                tempMtx->value  = ((LinearMatrixElements*)m_mChildren[constructorNo_])->value;
    1600842
    1601             else if (tempMtx->matrixType
     843            else if (tempMtx->valueType
    1602844                    == ENUM_MATRIX_TYPE_realValuedExpressions)
    1603845                tempMtx->value  = ((RealValuedExpressions*)m_mChildren[constructorNo_])->value;
    1604846
    1605             else if (tempMtx->matrixType
     847            else if (tempMtx->valueType
    1606848                    == ENUM_MATRIX_TYPE_complexValuedExpressions)
    1607849                tempMtx->value  = ((ComplexValuedExpressions*)m_mChildren[constructorNo_])->value;
    1608850
    1609             else if (tempMtx->matrixType == ENUM_MATRIX_TYPE_objReference)
     851            else if (tempMtx->valueType == ENUM_MATRIX_TYPE_objReference)
    1610852                tempMtx->value  = ((ObjReferenceMatrixElements*)m_mChildren[constructorNo_])->value;
    1611853
    1612             else if (tempMtx->matrixType == ENUM_MATRIX_TYPE_conReference)
     854            else if (tempMtx->valueType == ENUM_MATRIX_TYPE_conReference)
    1613855                tempMtx->value  = ((ConReferenceMatrixElements*)m_mChildren[constructorNo_])->value;
    1614856
    1615             else if (tempMtx->matrixType == ENUM_MATRIX_TYPE_string)
     857            else if (tempMtx->valueType == ENUM_MATRIX_TYPE_string)
    1616858                tempMtx->value  = ((StringValuedMatrixElements*)m_mChildren[constructorNo_])->value;
    1617859
     
    1630872            tempMtx->start = new int[numberOfColumns + 1];
    1631873            tempMtx->startSize = numberOfColumns + 1;
    1632             tempMtx->matrixType = m_mChildren[constructorNo_]->getMatrixType();
     874            tempMtx->valueType = m_mChildren[constructorNo_]->getMatrixType();
     875            tempMtx->numberOfRows    = numberOfRows;
     876            tempMtx->numberOfColumns = numberOfColumns;
    1633877
    1634878            for (int i=0; i <= numberOfColumns; i++)
     
    1664908
    1665909            // store the elements, by type
    1666             if (tempMtx->matrixType == ENUM_MATRIX_TYPE_constant)
     910            if (tempMtx->valueType == ENUM_MATRIX_TYPE_constant)
    1667911            {
    1668912                tempMtx->value = new ConstantMatrixValues();
     
    1682926                }
    1683927            }
    1684             else if (tempMtx->matrixType == ENUM_MATRIX_TYPE_varReference)
     928            else if (tempMtx->valueType == ENUM_MATRIX_TYPE_varReference)
    1685929            {
    1686930                tempMtx->value = new VarReferenceMatrixValues();
     
    1701945                }
    1702946            }
    1703             else if (tempMtx->matrixType == ENUM_MATRIX_TYPE_linear)
     947            else if (tempMtx->valueType == ENUM_MATRIX_TYPE_linear)
    1704948            {
    1705949                tempMtx->value = new LinearMatrixValues();
     
    1724968                }
    1725969            }
    1726             else if (tempMtx->matrixType == ENUM_MATRIX_TYPE_realValuedExpressions)
     970            else if (tempMtx->valueType == ENUM_MATRIX_TYPE_realValuedExpressions)
    1727971            {
    1728972                tempMtx->value = new RealValuedExpressionArray();
     
    1751995            }
    1752996
    1753             else if (tempMtx->matrixType == ENUM_MATRIX_TYPE_complexValuedExpressions)
     997            else if (tempMtx->valueType == ENUM_MATRIX_TYPE_complexValuedExpressions)
    1754998            {
    1755999                tempMtx->value = new ComplexValuedExpressionArray();
     
    17771021            }
    17781022
    1779             else if (tempMtx->matrixType == ENUM_MATRIX_TYPE_objReference)
     1023            else if (tempMtx->valueType == ENUM_MATRIX_TYPE_objReference)
    17801024            {
    17811025                tempMtx->value = new ObjReferenceMatrixValues();
     
    17961040                }
    17971041            }
    1798             else if (tempMtx->matrixType == ENUM_MATRIX_TYPE_conReference)
     1042            else if (tempMtx->valueType == ENUM_MATRIX_TYPE_conReference)
    17991043            {
    18001044                tempMtx->value = new ConReferenceMatrixValues();
     
    18431087
    18441088
    1845 GeneralSparseMatrix* MatrixType::expandTransformation(bool rowMajor, ENUM_MATRIX_SYMMETRY symmetry)
     1089GeneralSparseMatrix* MatrixType::expandTransformation(bool rowMajor, ENUM_MATRIX_SYMMETRY symmetry_)
    18461090{
    18471091    ostringstream outStr;
    18481092#ifndef NDEBUG
    1849     osoutput->OSPrint(ENUM_OUTPUT_AREA_OSInstance,
     1093    osoutput->OSPrint(ENUM_OUTPUT_AREA_OSMatrix,
    18501094                      ENUM_OUTPUT_LEVEL_trace, "Inside expandTransformation()");
    18511095    if (rowMajor)
     
    18531097    else   
    18541098        outStr << "return matrix elements in column major form" << std::endl;
    1855     osoutput->OSPrint(ENUM_OUTPUT_AREA_OSInstance, ENUM_OUTPUT_LEVEL_trace, outStr.str());
     1099    osoutput->OSPrint(ENUM_OUTPUT_AREA_OSMatrix, ENUM_OUTPUT_LEVEL_trace, outStr.str());
    18561100#endif
    18571101    throw ErrorClass("method expandTransformation() not implemented yet");
     
    18591103
    18601104
    1861 GeneralSparseMatrix* MatrixType::getExpandedMatrix(bool rowMajor, ENUM_MATRIX_TYPE convertTo)
     1105int MatrixType::getExpandedMatrix(bool rowMajor_, ENUM_MATRIX_TYPE convertTo_,
     1106                                                  ENUM_MATRIX_SYMMETRY symmetry_)
    18621107{
    18631108    ostringstream outStr;
    18641109#ifndef NDEBUG
    1865     osoutput->OSPrint(ENUM_OUTPUT_AREA_OSInstance, ENUM_OUTPUT_LEVEL_debug, "Inside getExpandedMatrix()");
    1866     if (rowMajor)
     1110    osoutput->OSPrint(ENUM_OUTPUT_AREA_OSMatrix, ENUM_OUTPUT_LEVEL_debug, "Inside getExpandedMatrix()");
     1111    if (rowMajor_)
    18671112        outStr << "return matrix elements in row major form" << std::endl;
    18681113    else   
    18691114        outStr << "return matrix elements in column major form" << std::endl;
    1870     if (convertTo != ENUM_MATRIX_TYPE_unknown)
    1871         outStr << " - convert to " << returnMatrixTypeString(convertTo);
     1115    if (convertTo_ != ENUM_MATRIX_TYPE_unknown)
     1116        outStr << " - convert to " << returnMatrixTypeString(convertTo_);
    18721117    outStr << std::endl;
    18731118    outStr << "expand an object of kind " << returnMatrixConstructorTypeString(nType);
     
    18751120    outStr << " - inferred type " << returnMatrixTypeString(getInferredMatrixType());
    18761121    outStr << std::endl << std::endl;
    1877     osoutput->OSPrint(ENUM_OUTPUT_AREA_OSInstance, ENUM_OUTPUT_LEVEL_trace, outStr.str());
    1878 #endif
    1879 
    1880     GeneralSparseMatrix* tempMtx;
     1122    osoutput->OSPrint(ENUM_OUTPUT_AREA_OSMatrix, ENUM_OUTPUT_LEVEL_trace, outStr.str());
     1123#endif
     1124
     1125    GeneralSparseMatrix* tempMtx = NULL;
     1126
     1127    // these two dense columns track the locations of elements durng the merge
     1128    int* ctorNbr  = NULL;
     1129    int* location = NULL;
    18811130
    18821131    try
    18831132    {
     1133        ENUM_MATRIX_TYPE convertTo = convertTo_;
     1134        ENUM_MATRIX_TYPE inferredType = getMatrixType();
     1135        if (convertTo == ENUM_MATRIX_TYPE_unknown)
     1136            convertTo  = inferredType;
     1137        if (convertTo != mergeMatrixType(convertTo, inferredType))
     1138           throw ErrorClass("Requested improper conversion of element values");
     1139
     1140        ENUM_MATRIX_SYMMETRY symmetry = symmetry_;
     1141
     1142        if (symmetry == ENUM_MATRIX_SYMMETRY_default)
     1143//            symmetry  = this->symmetry;
     1144//        if (symmetry != this->symmetry)
     1145            throw ErrorClass("Cannot handle symmetry properly in expandBlocks()");
     1146
    18841147        //Check if previous expansion available
    1885         if (rowMajor)
    1886         {
    1887             if (expandedMatrixInRowMajorForm != NULL)
    1888                 return expandedMatrixInRowMajorForm;
    1889             if (expandedMatrixInColumnMajorForm != NULL)
    1890             {
    1891                 expandedMatrixInRowMajorForm = convertToOtherMajor(true);
    1892                 return expandedMatrixInRowMajorForm;
    1893             }
    1894         }
    1895         else
    1896         {
    1897             if (expandedMatrixInColumnMajorForm != NULL)
    1898                 return expandedMatrixInColumnMajorForm;
    1899             if (expandedMatrixInRowMajorForm != NULL)
    1900             {
    1901                 expandedMatrixInColumnMajorForm = convertToOtherMajor(false);
    1902                 return expandedMatrixInColumnMajorForm;
    1903             }
    1904         }
     1148        int bestMatch = 0;
     1149        int thisMatch;
     1150        int bestMatch_index = -1;
     1151        for (int i=0; i<expandedMatrixByElements.size(); i++)
     1152        {
     1153            thisMatch = 0;
     1154            if (expandedMatrixByElements[i]->valueType == convertTo)
     1155            {
     1156                thisMatch += 1;
     1157            }
     1158            if (expandedMatrixByElements[i]->isRowMajor == rowMajor_)
     1159            {
     1160                thisMatch += 2;
     1161            }
     1162            if (expandedMatrixByElements[i]->symmetry == symmetry)
     1163            {
     1164                thisMatch += 4;
     1165            }
     1166            if (thisMatch > bestMatch)
     1167            {
     1168                if (thisMatch == 7) // a previous expansion meets all criteria; just use it
     1169                    return /*expandedMatrixByElements[*/i/*]*/;
     1170
     1171                bestMatch = thisMatch;
     1172                bestMatch_index = i;
     1173            }
     1174        }
     1175
     1176        // Here we need to create a new expansion and add it to the collection
    19051177
    19061178        tempMtx = new GeneralSparseMatrix();
     1179        tempMtx->numberOfRows    = numberOfRows;
     1180        tempMtx->numberOfColumns = numberOfColumns;
     1181
     1182        if (bestMatch > 0) // base the expansion on previous work
     1183        {
     1184            switch (bestMatch)
     1185            {
     1186// cases 1-3 will rely on    GeneralSparseMatrix* convertSymmetry(ENUM_MATRIX_SYMMETRY symmetry_);
     1187                case 1: //Transpose, then apply symmetry --- Can this be done in one operation?
     1188                    throw ErrorClass("Requested conversion not yet implemented");
     1189                    break;
     1190                case 2: //Convert type and apply symmetry --- this should be doable in one operation
     1191                    throw ErrorClass("Requested conversion not yet implemented");
     1192                    break;
     1193                case 3: //Just apply symmetry --- this is a simple copy operation
     1194                    throw ErrorClass("Requested conversion not yet implemented");
     1195                    break;
     1196                case 4: //Transpose and convert
     1197                case 5: //Transpose only
     1198                    tempMtx = expandedMatrixByElements[bestMatch_index]
     1199                                        ->convertToOtherMajor(convertTo,false);
     1200                    break;
     1201                case 6: //Just convert type
     1202                    tempMtx = expandedMatrixByElements[bestMatch_index]->convertType(convertTo);
     1203                    break;
     1204            }
     1205
     1206            tempMtx->valueType  = convertTo;
     1207            tempMtx->symmetry   = symmetry;
     1208            tempMtx->isRowMajor = rowMajor_;
     1209            expandedMatrixByElements.push_back(tempMtx);
     1210            return expandedMatrixByElements.size() - 1; //tempMtx;
     1211
     1212        }
     1213
     1214        // Here we need to expand from scratch
    19071215
    19081216        // The complexity increases with the number and diversity of constructors
     
    19111219        if (inumberOfChildren == 0)
    19121220        {
    1913             if (rowMajor)
     1221            if (rowMajor_)
    19141222                tempMtx->startSize   = numberOfRows + 1;
    19151223            else
     
    19181226            tempMtx->start           = new int[tempMtx->startSize];
    19191227            tempMtx->valueSize       = 0;
    1920             tempMtx->matrixType      = ENUM_MATRIX_TYPE_empty;
     1228            tempMtx->valueType       = ENUM_MATRIX_TYPE_empty;
    19211229            this->inferredMatrixType = ENUM_MATRIX_TYPE_empty;
    19221230            for (int i=0; i < tempMtx->startSize; i++)
     
    19291237            if (m_mChildren[0]->getNodeType() == ENUM_MATRIX_CONSTRUCTOR_TYPE_baseMatrix)
    19301238            {
    1931                 tempMtx = this->processBaseMatrix(rowMajor,symmetry);
    1932                 tempMtx->matrixType      = m_mChildren[0]->getMatrixType();
     1239                tempMtx = this->processBaseMatrix(rowMajor_, ENUM_MATRIX_TYPE_unknown, symmetry);
     1240                tempMtx->valueType       = m_mChildren[0]->getMatrixType();
    19331241                this->inferredMatrixType = m_mChildren[0]->getMatrixType();
    1934 
    1935 //                return expandedMatrixInColumnMajorForm;
    19361242            }
    19371243
     
    19391245            {
    19401246                //make sure the blocks have been expanded, then retrieve them
    1941                 if (!processBlocks(rowMajor, symmetry))
     1247                if (!processBlocks(rowMajor_, tempMtx->valueType, symmetry))
    19421248                    throw ErrorClass("error processing blocks in getExpandedMatrix()");
    19431249
    19441250                ExpandedMatrixBlocks* currentBlocks
    19451251                    = getBlocks(m_miRowPartition, m_iRowPartitionSize, m_miColumnPartition,
    1946                                 m_iColumnPartitionSize, rowMajor, true);
    1947 
    1948                 tempMtx = expandBlocks(currentBlocks, rowMajor, symmetry);
     1252                                m_iColumnPartitionSize, true, rowMajor_, convertTo, symmetry);
     1253
     1254                tempMtx = expandBlocks(currentBlocks, rowMajor_, convertTo, symmetry);
    19491255            }
    19501256
     
    19521258            {
    19531259//              transformation: see if we can do at least AB, A'B, AB'
    1954                 tempMtx = expandTransformation(rowMajor, symmetry);
     1260                tempMtx = expandTransformation(rowMajor_, symmetry);
    19551261            }
    19561262            else // some kind of elements
    19571263            {
    1958                 tempMtx = this->extractElements(0,rowMajor,symmetry);
    1959                 this->inferredMatrixType = tempMtx->matrixType;
     1264                tempMtx = this->extractElements(0,rowMajor_,symmetry);
     1265                this->inferredMatrixType = tempMtx->valueType;
    19601266//                expandedMatrixInColumnMajorForm->printMatrix();
    19611267            }
     
    19681274//            expandedMatrixInColumnMajorForm = new GeneralSparseMatrix();
    19691275            tempMtx->symmetry = symmetry;
    1970             if (rowMajor)
     1276            if (rowMajor_)
    19711277                tempMtx->startSize = numberOfRows + 1;
    19721278            else
     
    19851291            {
    19861292                OSMatrix* baseMtxPtr = ((BaseMatrix*)m_mChildren[0])->baseMatrix;
    1987                 tempExpansion[0] = this->processBaseMatrix(true,symmetry);
     1293                tempExpansion[0] = this->processBaseMatrix(true, ENUM_MATRIX_TYPE_unknown, symmetry);
    19881294                if (tempExpansion[0] != NULL)
    19891295                {
     
    19981304                if (m_mChildren[i]->getNodeType() == ENUM_MATRIX_CONSTRUCTOR_TYPE_transformation)
    19991305                {
    2000                     tempExpansion[i] = expandTransformation(rowMajor, symmetry);
     1306                    tempExpansion[i] = expandTransformation(rowMajor_, symmetry);
    20011307                }
    20021308                else if (m_mChildren[i]->getNodeType() == ENUM_MATRIX_CONSTRUCTOR_TYPE_blocks)
    20031309                {
    20041310                    //make sure the blocks have been expanded, then retrieve them
    2005                     if (!processBlocks(rowMajor, symmetry))
     1311                    if (!processBlocks(rowMajor_, tempMtx->valueType, symmetry))
    20061312                        throw ErrorClass("error processing blocks in getExpandedMatrix()");
    20071313
    20081314                    ExpandedMatrixBlocks* currentBlocks
    20091315                        = getBlocks(m_miRowPartition, m_iRowPartitionSize, m_miColumnPartition,
    2010                                 m_iColumnPartitionSize, rowMajor, true);
    2011 
    2012                     tempExpansion[i] = expandBlocks(currentBlocks, rowMajor, symmetry);
     1316                                m_iColumnPartitionSize, true, rowMajor_, convertTo, symmetry);
     1317
     1318                    tempExpansion[i] = expandBlocks(currentBlocks, rowMajor_, convertTo, symmetry);
    20131319                }
    20141320                else
    20151321                {
    2016                     tempExpansion[i] = this->extractElements(i,rowMajor,symmetry);
    2017                     tempExpansion[i]->matrixType = m_mChildren[i]->getMatrixType();
     1322                    tempExpansion[i] = this->extractElements(i,rowMajor_, symmetry);
     1323                    tempExpansion[i]->valueType = m_mChildren[i]->getMatrixType();
    20181324                }
    20191325
     
    20291335               throw ErrorClass("Requested improper conversion of element values");
    20301336            inferredType = convertTo;
    2031             tempMtx->matrixType = inferredType;
     1337            tempMtx->valueType = inferredType;
    20321338               
    20331339            // allocate space for elements (nv is an overestimate --- don't worry about cancelations)
     
    20351341
    20361342            tempMtx->index = new int[nv];
    2037 
    2038             switch (inferredType)
    2039             {
    2040                 case ENUM_MATRIX_TYPE_empty:
    2041                 {
    2042                     if (nv != 0)
    2043                         throw ErrorClass("Matrix should be empty, but is not!!!");
    2044                     else
    2045                     {
    2046                         tempMtx->matrixType = ENUM_MATRIX_TYPE_empty;
    2047                         tempMtx->valueSize = 0;
    2048                         for (int i=0; i < tempMtx->startSize; i++)
    2049                             tempMtx->start[i] = 0;
    2050 //                        return expandedMatrixInColumnMajorForm;
    2051                     }
    2052                     break;
    2053                 }
    2054 
    2055                 case ENUM_MATRIX_TYPE_constant:
    2056                 {
    2057                     tempMtx->value = new ConstantMatrixValues();
    2058                     ((ConstantMatrixValues*)tempMtx->value)->el = new double[nv];
    2059                     break;
    2060                 }
    2061 
    2062                 case ENUM_MATRIX_TYPE_complexConstant:
    2063                 {
    2064                     tempMtx->value = new ComplexMatrixValues();
    2065                     ((ComplexMatrixValues*)tempMtx->value)->el = new std::complex<double>[nv];
    2066                     break;
    2067                 }
    2068 
    2069                 case ENUM_MATRIX_TYPE_varReference:
    2070                 {
    2071                     tempMtx->value = new VarReferenceMatrixValues();
    2072                     ((VarReferenceMatrixValues*)tempMtx->value)->el = new int[nv];
    2073                     break;
    2074                 }
    2075 
    2076                 case ENUM_MATRIX_TYPE_linear:
    2077                 {
    2078                     tempMtx->value = new LinearMatrixValues();
    2079                     ((LinearMatrixValues*)tempMtx->value)->el = new LinearMatrixElement*[nv];
    2080                     break;
    2081                 }
    2082 
    2083                 case ENUM_MATRIX_TYPE_objReference:
    2084                 {
    2085                     tempMtx->value = new ObjReferenceMatrixValues();
    2086                     ((ObjReferenceMatrixValues*)tempMtx->value)->el = new int[nv];
    2087                     break;
    2088                 }
    2089 
    2090                 case ENUM_MATRIX_TYPE_mixedRowReference:
    2091                 case ENUM_MATRIX_TYPE_conReference:
    2092                 {
    2093                     tempMtx->value = new ConReferenceMatrixValues();
    2094                     ((ConReferenceMatrixValues*)tempMtx->value)->el = new ConReferenceMatrixElement*[nv];
    2095                     break;
    2096                 }
    2097 
    2098                 case ENUM_MATRIX_TYPE_realValuedExpressions:
    2099                 {
    2100                     tempMtx->value = new RealValuedExpressionArray();
    2101                     ((RealValuedExpressionArray*)tempMtx->value)->el = new RealValuedExpressionTree*[nv];
    2102                     break;
    2103                 }
    2104 
    2105                 case ENUM_MATRIX_TYPE_complexValuedExpressions:
    2106                 {
    2107                     tempMtx->value = new ComplexValuedExpressionArray();
    2108                     ((ComplexValuedExpressionArray*)
    2109                         tempMtx->value)->el = new ComplexValuedExpressionTree*[nv];
    2110                     break;
    2111                 }
    2112 
    2113                 case ENUM_MATRIX_TYPE_string:
    2114                 {
    2115                     tempMtx->value = new StringValuedMatrixValues();
    2116                     ((StringValuedMatrixValues*)tempMtx->value)->el = new std::string[nv];
    2117                     break;
    2118                 }
    2119 
    2120                 default :
    2121                     throw ErrorClass("Unsupported matrix type");
    2122                     break;
    2123             }
     1343            if (!tempMtx->allocateValueArray(nv))
     1344                throw ErrorClass("Error allocating value array of a GeneralSparseMatrix");
    21241345
    21251346            // allocate and initial two dense columns of locations of elements
     
    21271348            // ctorNbr[i] gives the number of the constructor whose value is used
    21281349            // location[i] gives the location of the nonzero within this constructor
    2129             int* ctorNbr  = new int[numberOfRows];
    2130             int* location = new int[numberOfRows];
     1350            ctorNbr  = new int[numberOfRows];
     1351            location = new int[numberOfRows];
    21311352
    21321353            for (int i=0; i < numberOfRows; i++)
     
    21791400                        tempMtx->index[nz] = tempExpansion[n]->index[l];
    21801401
    2181                         // If the constructors differ in type, we convert to the most general type
    2182                         switch (inferredType)
    2183                         {
    2184                             // the first three types are minimal types, so no conversion is necessary,
    2185                             // and copying is much simpler as well
    2186                             case ENUM_MATRIX_TYPE_constant:
    2187                                 ((ConstantMatrixValues*)tempMtx->value)->el[nz]
    2188                                     = ((ConstantMatrixValues*)tempExpansion[n]->value)->el[l];
    2189                                 break;
    2190 
    2191                             case ENUM_MATRIX_TYPE_varReference:
    2192                                 ((VarReferenceMatrixValues*) ((VarReferenceMatrixElements*)
    2193                                         tempMtx)->value)->el[nz]
    2194                                     = ((VarReferenceMatrixValues*)tempExpansion[n]->value)->el[l];
    2195                                 break;
    2196 
    2197                             case ENUM_MATRIX_TYPE_objReference:
    2198                                 ((ObjReferenceMatrixValues*) ((ObjReferenceMatrixElements*)
    2199                                         tempMtx)->value)->el[nz]
    2200                                     = ((ObjReferenceMatrixValues*)tempExpansion[n]->value)->el[l];
    2201                                 break;
    2202 
    2203                             // conReference is minimal, but the copying is a little more complicated
    2204                             case ENUM_MATRIX_TYPE_conReference:
    2205                                 ((ConReferenceMatrixValues*)tempMtx->value)->el[nz] =
    2206                                     new ConReferenceMatrixElement();
    2207                                 if (tempExpansion[n]->matrixType == ENUM_MATRIX_TYPE_conReference)
    2208                                 {
    2209                                     ((ConReferenceMatrixValues*) ((ConReferenceMatrixElements*)
    2210                                         tempMtx)->value)->el[nz]->deepCopyFrom(
    2211                                             ((ConReferenceMatrixValues*)tempExpansion[n]->value)->el[l]);
    2212                                 }
    2213                                 else
    2214                                     throw ErrorClass ("undefined matrix element conversion");
    2215                                 break;
    2216 
    2217                             // The other types may require conversion and more elaborate copying
    2218                             // First, complexConstant. The only legal conversion is from (real) constant
    2219                             case ENUM_MATRIX_TYPE_complexConstant:
    2220 
    2221                                 if (tempExpansion[n]->matrixType == ENUM_MATRIX_TYPE_complexConstant)
    2222                                 {
    2223                                     std::complex<double> (((ComplexMatrixValues*)tempMtx->value)->el[nz])
    2224                                         = ((ComplexMatrixValues*)tempExpansion[n]->value)->el[l]; 
    2225                                 }
    2226                                 else if (tempExpansion[n]->matrixType == ENUM_MATRIX_TYPE_constant)
    2227                                 {
    2228                                     std::complex<double> (((ComplexMatrixValues*)tempMtx->value)->el[nz])
    2229                                         = convertToComplexMatrixElement(
    2230                                             ((ConstantMatrixElements*)tempExpansion[n])->value->el[l]); 
    2231                                 }
    2232                                 else
    2233                                     throw ErrorClass ("undefined matrix element conversion");
    2234                                 break;
    2235 
    2236                             case ENUM_MATRIX_TYPE_linear:
    2237                                 ((LinearMatrixValues*)tempMtx->value)->el[nz] = new LinearMatrixElement();
    2238                                 switch (tempExpansion[n]->matrixType)
    2239                                 {
    2240                                     // linear elements do not have to be converted
    2241                                     case ENUM_MATRIX_TYPE_linear:
    2242                                         ((LinearMatrixValues*)tempMtx->value)->el[nz]
    2243                                             = ((LinearMatrixValues*)tempExpansion[n]->value)->el[l];
    2244                                         break;
    2245 
    2246                                     // legal conversions: constant, varReference
    2247                                     case ENUM_MATRIX_TYPE_constant:
    2248                                         ((LinearMatrixValues*)tempMtx->value)->el[nz]->constant
    2249                                             = ((ConstantMatrixValues*)tempExpansion[n]->value)->el[l];
    2250                                         break;
    2251 
    2252                                     case ENUM_MATRIX_TYPE_varReference:
    2253                                         ((LinearMatrixValues*)tempMtx->value)->el[nz]->numberOfVarIdx = 1;
    2254                                         ((LinearMatrixValues*)tempMtx->value)->el[nz]->varIdx =
    2255                                             new LinearMatrixElementTerm*[1];
    2256                                         ((LinearMatrixValues*)tempMtx->value)->el[nz]->varIdx[0] =
    2257                                             new LinearMatrixElementTerm();
    2258                                         ((LinearMatrixValues*)tempMtx->value)->el[nz]->varIdx[0]->idx =
    2259                                             ((VarReferenceMatrixValues*)tempExpansion[n]->value)->el[l];
    2260                                         ((LinearMatrixValues*)tempMtx->value)->el[nz]->varIdx[0]->coef = 0;
    2261                                         break;
    2262 
    2263                                     // other conversion are illegal
    2264                                     default: throw ErrorClass ("undefined matrix element conversion");
    2265                                         break;
    2266                                 }//end switch (tempExpansion[n]->matrixType)
    2267                                 break;
    2268 
    2269                             case ENUM_MATRIX_TYPE_mixedRowReference:
    2270                                 ((ConReferenceMatrixValues*)tempMtx->value)->el[nz]
    2271                                     = new ConReferenceMatrixElement();
    2272                                 switch (tempExpansion[n]->matrixType)
    2273                                 {
    2274                                     // elements with constraint references do not have to be converted
    2275                                     case ENUM_MATRIX_TYPE_mixedRowReference:
    2276                                     case ENUM_MATRIX_TYPE_conReference:
    2277                                         ((ConReferenceMatrixValues*)
    2278                                             tempMtx->value)->el[nz]->deepCopyFrom(
    2279                                                 ((ConReferenceMatrixValues*)
    2280                                                     tempExpansion[n]->value)->el[l]);
    2281                                         break;
    2282 
    2283                                     // only other legal possibility: objective references
    2284                                     case ENUM_MATRIX_TYPE_objReference:
    2285                                         ((ConReferenceMatrixValues*)tempMtx->value)->el[nz]
    2286                                             = new ConReferenceMatrixElement();
    2287                                         ((ConReferenceMatrixValues*)tempMtx->value)->el[nz]->conReference
    2288                                             = ((ObjReferenceMatrixValues*)tempExpansion[n]->value)->el[l];
    2289                                         break;
    2290 
    2291                                     default: throw ErrorClass ("undefined matrix element conversion");
    2292                                         break;
    2293                                 }
    2294                                 break;
    2295 
    2296                             case ENUM_MATRIX_TYPE_realValuedExpressions:
    2297                             {
    2298                                 switch (tempExpansion[n]->matrixType)
    2299                                 {
    2300                                     case ENUM_MATRIX_TYPE_constant:
    2301                                         ((RealValuedExpressionArray*)tempMtx->value)->el[nz]
    2302                                             = convertToRealExpressionTree(
    2303                                                 ((ConstantMatrixValues*)tempExpansion[n]->value)->el[l]); 
    2304                                         break;
    2305 
    2306                                     case ENUM_MATRIX_TYPE_varReference:
    2307                                         ((RealValuedExpressionArray*)tempMtx->value)->el[nz]
    2308                                             = convertToRealExpressionTree(((VarReferenceMatrixValues*)
    2309                                                                    tempExpansion[n]->value)->el[l], true);
    2310                                         break;
    2311 
    2312                                     case ENUM_MATRIX_TYPE_realValuedExpressions:
    2313                                     {
    2314                                         ((RealValuedExpressionArray*)tempMtx->value)->el[nz]
    2315                                             = ((RealValuedExpressionArray*)
    2316                                                 tempExpansion[n]->value)->el[l]->cloneExpressionTree();
    2317                                         break;
    2318                                     }
    2319 
    2320                                     case ENUM_MATRIX_TYPE_linear:
    2321                                         ((RealValuedExpressionArray*)tempMtx->value)->el[nz]
    2322                                             = convertToRealExpressionTree(((LinearMatrixValues*)
    2323                                                                         tempExpansion[n]->value)->el[l]); 
    2324                                         break;
    2325 
    2326                                     case ENUM_MATRIX_TYPE_objReference:
    2327                                         throw ErrorClass("OSnLNodeObjective not implemented yet");
    2328                                         break;
    2329 
    2330                                     case ENUM_MATRIX_TYPE_conReference:
    2331                                         throw ErrorClass("OSnLNodeConstraint not implemented yet");
    2332                                         break;
    2333 
    2334                                     case ENUM_MATRIX_TYPE_mixedRowReference:
    2335                                         throw ErrorClass("relevant OSnLNodes not implemented yet");
    2336                                         break;
    2337 
    2338                                     case ENUM_MATRIX_TYPE_complexConstant:
    2339                                     case ENUM_MATRIX_TYPE_complexValuedExpressions:
    2340                                         throw ErrorClass("improper conversion of complex-valued elements");
    2341                                         break;
    2342 
    2343                                     default: throw ErrorClass ("undefined matrix element conversion");
    2344                                         break;
    2345                                 }
    2346                                 break;
    2347                             }// end case realValuedExpressions
    2348 
    2349                             case ENUM_MATRIX_TYPE_complexValuedExpressions:
    2350                             {
    2351                                 ComplexValuedExpressionTree* temp = new ComplexValuedExpressionTree();
    2352 
    2353                                 switch (tempExpansion[n]->matrixType)
    2354                                 {
    2355                                     case ENUM_MATRIX_TYPE_complexValuedExpressions:
    2356                                     {
    2357                                         temp->m_treeRoot
    2358                                             = ((ComplexValuedExpressionArray*)tempExpansion[n]
    2359                                                 ->value)->el[l]->m_treeRoot->cloneExprNode();
    2360                                         break;
    2361                                     }
    2362 
    2363                                     case ENUM_MATRIX_TYPE_constant:
    2364                                     {
    2365                                         temp->m_treeRoot = new OSnLCNodeNumber();
    2366                                         double tempVal = ((ConstantMatrixValues*)
    2367                                                             tempExpansion[n]->value)->el[l];
    2368                                         ((OSnLCNodeNumber*) temp->m_treeRoot)->setValue(tempVal, 0.0);
    2369                                         break;
    2370                                     }
    2371 
    2372                                     case ENUM_MATRIX_TYPE_complexConstant:
    2373                                     {
    2374                                         temp->m_treeRoot = new OSnLCNodeNumber();
    2375                                         std::complex<double> tempVal
    2376                                             = ((ComplexMatrixValues*)tempExpansion[n]->value)->el[l];
    2377                                         ((OSnLCNodeNumber*)temp->m_treeRoot)->setValue(tempVal);
    2378                                         break;
    2379                                     }
    2380 
    2381                                     case ENUM_MATRIX_TYPE_varReference:
    2382                                     {
    2383                                         temp->m_treeRoot = new OSnLCNodeCreate();
    2384                                         temp->m_treeRoot->m_mChildren[0] = new OSnLNodeVariable();
    2385                                         temp->m_treeRoot->m_mChildren[1] = new OSnLNodeNumber();
    2386                                         ((OSnLNodeVariable*)temp->m_treeRoot->m_mChildren[0])->idx
    2387                                             = ((VarReferenceMatrixValues*)tempExpansion[n]->value)->el[l];
    2388                                         ((OSnLNodeNumber*)temp->m_treeRoot->m_mChildren[1])->value  = 0.0;
    2389                                         break;
    2390                                     }
    2391 
    2392                                     case ENUM_MATRIX_TYPE_realValuedExpressions:
    2393                                     {
    2394                                         temp->m_treeRoot = new OSnLCNodeCreate();
    2395                                         temp->m_treeRoot->m_mChildren[1] = new OSnLNodeNumber();
    2396                                         ((OSnLNodeNumber*)temp->m_treeRoot->m_mChildren[1])->value  = 0.0;
    2397 
    2398                                         temp->m_treeRoot->m_mChildren[0]
    2399                                             = ((RealValuedExpressionArray*)tempExpansion[n]
    2400                                                 ->value)->el[l]->m_treeRoot->cloneExprNode();
    2401                                         break;
    2402                                     }
    2403 
    2404                                     // the hardest conversion: linear expressions
    2405                                     case ENUM_MATRIX_TYPE_linear:
    2406                                     {
    2407                                         temp->m_treeRoot = new OSnLCNodeCreate();
    2408                                         temp->m_treeRoot->m_mChildren[1] = new OSnLNodeNumber();
    2409                                         ((OSnLNodeNumber*)temp->m_treeRoot->m_mChildren[1])->value = 0.0;
    2410 
    2411                                         temp->m_treeRoot->m_mChildren[0] = new OSnLNodeVariable();
    2412                                         ((OSnLNodeVariable*)temp->m_treeRoot->m_mChildren[0])->idx
    2413                                             = ((VarReferenceMatrixValues*)tempExpansion[n]->value)->el[l];
    2414 
    2415                                         int nn = ((LinearMatrixElements*)
    2416                                                   m_mChildren[n])->value->el[l]->numberOfVarIdx;
    2417                                         bool haveConstant;
    2418 
    2419                                         if (nn == 0)
    2420                                         {
    2421                                             temp->m_treeRoot->m_mChildren[0] = new OSnLNodeNumber();
    2422                                             ((OSnLNodeNumber*)
    2423                                                 temp->m_treeRoot->m_mChildren[1])->value = 0.0;
    2424                                         }
    2425                                         else
    2426                                         {
    2427                                             if (((LinearMatrixElements*)
    2428                                                   tempExpansion[n])->value->el[l]->constant == 0)
    2429                                             {
    2430                                                 haveConstant = false;
    2431                                                 temp->m_treeRoot->m_mChildren[0] = new OSnLNodeSum();
    2432                                                 temp->m_treeRoot->m_mChildren[0]->m_mChildren
    2433                                                     = new ExprNode*[nn];
    2434                                                 temp->m_treeRoot->m_mChildren[0]->inumberOfChildren = nn;
    2435                                             }
    2436                                             else
    2437                                             {
    2438                                                 haveConstant = true;
    2439                                                 temp->m_treeRoot->m_mChildren[0] = new OSnLNodeSum();
    2440                                                 temp->m_treeRoot->m_mChildren[0]->m_mChildren
    2441                                                     = new ExprNode*[nn+1];
    2442                                                 temp->m_treeRoot->m_mChildren[0]->inumberOfChildren = nn+1;
    2443                                             }
    2444 
    2445                                             for (int ii=0; ii<nn; ii++)
    2446                                             {
    2447                                                 temp->m_treeRoot->m_mChildren[0]->m_mChildren[ii]
    2448                                                     = new OSnLNodeVariable();
    2449                                                 ((OSnLNodeVariable*)temp->m_treeRoot
    2450                                                             ->m_mChildren[0]->m_mChildren[ii])->idx
    2451                                                     = ((LinearMatrixValues*)
    2452                                                         tempExpansion[n]->value)->el[l]->varIdx[ii]->idx;
    2453                                                 ((OSnLNodeVariable*)temp->m_treeRoot
    2454                                                             ->m_mChildren[0]->m_mChildren[ii])->coef
    2455                                                     = ((LinearMatrixValues*)
    2456                                                         tempExpansion[n]->value)->el[l]->varIdx[ii]->coef;
    2457                                             }
    2458 
    2459                                             if (haveConstant)
    2460                                             {
    2461                                                 temp->m_treeRoot->m_mChildren[0]->m_mChildren[nn]
    2462                                                     = new OSnLNodeNumber();
    2463                                                 ((OSnLNodeNumber*)temp->m_treeRoot
    2464                                                      ->m_mChildren[0]->m_mChildren[nn])->value
    2465                                                     = ((LinearMatrixValues*)
    2466                                                        tempExpansion[n]->value)->el[l]->constant;
    2467                                             }
    2468                                         }
    2469                                         break;
    2470                                     }
    2471 
    2472                                     case ENUM_MATRIX_TYPE_objReference:
    2473                                         throw ErrorClass("OSnLNodeObjective not implemented yet");
    2474                                         break;
    2475 
    2476                                     case ENUM_MATRIX_TYPE_conReference:
    2477                                         throw ErrorClass("OSnLNodeConstraint not implemented yet");
    2478                                         break;
    2479 
    2480                                     case ENUM_MATRIX_TYPE_mixedRowReference:
    2481                                         throw ErrorClass("relevant OSnLNodes not implemented yet");
    2482                                         break;
    2483 
    2484                                     default:
    2485                                         throw ErrorClass("undefined matrix element conversion");
    2486                                         break;
    2487 
    2488                                 }
    2489                                 ((ComplexValuedExpressionArray*)tempMtx->value)->el[nz] = temp;
    2490                                 break;
    2491                             }// end case complexValuedExpressions
    2492 
    2493                             case ENUM_MATRIX_TYPE_string:
    2494                             {
    2495                                 outStr.str("");
    2496                                 outStr.clear();
    2497 
    2498                                 switch (tempExpansion[n]->matrixType)
    2499                                 {
    2500                                     case ENUM_MATRIX_TYPE_constant:
    2501                                         outStr << os_dtoa_format(((ConstantMatrixValues*)
    2502                                                        tempExpansion[n]->value)->el[l]);
    2503                                         break;
    2504 
    2505                                     case ENUM_MATRIX_TYPE_complexConstant:
    2506                                         outStr << "(" << os_dtoa_format(((ComplexMatrixValues*)
    2507                                                             tempExpansion[n]->value)->el[l].real());
    2508                                         outStr << "," << os_dtoa_format(((ComplexMatrixValues*)
    2509                                                             tempExpansion[n]->value)->el[l].imag()) << ")";
    2510                                         break;
    2511 
    2512                                     case ENUM_MATRIX_TYPE_varReference:
    2513                                         outStr << "x_"
    2514                                                << ((VarReferenceMatrixValues*)
    2515                                                        tempExpansion[n]->value)->el[l];
    2516                                         break;
    2517 
    2518                                     case ENUM_MATRIX_TYPE_objReference:
    2519                                         outStr << "o_"
    2520                                                << ((ObjReferenceMatrixValues*)
    2521                                                        tempExpansion[n]->value)->el[l];
    2522                                         break;
    2523 
    2524                                     case ENUM_MATRIX_TYPE_conReference:
    2525                                         outStr << "c_"
    2526                                                << ((ConReferenceMatrixValues*)
    2527                                                        tempExpansion[n]->value)->el[l]->conReference
    2528                                                << "."
    2529                                                << returnConReferenceValueTypeString(
    2530                                                     ((ConReferenceMatrixValues*)
    2531                                                        tempExpansion[n]->value)->el[l]->valueType);
    2532                                         break;
    2533 
    2534                                     case ENUM_MATRIX_TYPE_mixedRowReference:
    2535                                     {
    2536                                         int temp = ((ConReferenceMatrixValues*)
    2537                                                        tempExpansion[n]->value)->el[l]->conReference;
    2538                                         if (temp < 0)
    2539                                             outStr << "o_"
    2540                                                    << temp;
    2541                                         else
    2542                                             outStr << "c_"
    2543                                                    << temp
    2544                                                    << "."
    2545                                                    << returnConReferenceValueTypeString(
    2546                                                        ((ConReferenceMatrixValues*)
    2547                                                            tempExpansion[n]->value)->el[l]->valueType);
    2548                                         break;
    2549                                     }
    2550 
    2551                                     case ENUM_MATRIX_TYPE_string:
    2552                                         outStr << ((StringValuedMatrixValues*)
    2553                                                        tempExpansion[n]->value)->el[l];
    2554                                         break;
    2555 
    2556                                     case ENUM_MATRIX_TYPE_linear:
    2557                                     {
    2558                                         LinearMatrixElement* temp =
    2559                                             ((LinearMatrixValues*)tempExpansion[n]->value)->el[l];
    2560 
    2561                                         if (temp->constant < 0.0 || temp->constant > 0.0)
    2562                                         {
    2563                                             outStr << os_dtoa_format(temp->constant);
    2564                                         }
    2565 
    2566                                         if (temp->numberOfVarIdx > 0)
    2567                                         {
    2568                                             if (temp->varIdx[0]->coef >= 0)
    2569                                             {
    2570                                                 if (temp->constant < 0.0 || temp->constant > 0.0)
    2571                                                     outStr << " + ";
    2572                                                 else
    2573                                                     outStr << " - ";
    2574                                             }
    2575                                             else
    2576                                                 outStr << "-";
    2577                                             if (temp->varIdx[0]->coef < 1 || temp->varIdx[0]->coef > 1 )
    2578                                                 outStr << os_dtoa_format(abs(temp->varIdx[0]->coef)) << "*";
    2579                                             outStr << "x_" << temp->varIdx[0]->idx;
    2580                                         }
    2581 
    2582                                         for (int j=1; j<temp->numberOfVarIdx; i++)
    2583                                         {
    2584                                             if (temp->varIdx[j]->coef >= 0)
    2585                                                 outStr << " + ";
    2586                                             else
    2587                                                 outStr << " - ";
    2588                                             if (temp->varIdx[j]->coef < 1 || temp->varIdx[j]->coef > 1 )
    2589                                                 outStr << os_dtoa_format(abs(temp->varIdx[j]->coef)) << "*";
    2590                                             outStr << "x_" << temp->varIdx[j]->idx;
    2591                                         }
    2592                                         break;
    2593                                     }
    2594 
    2595                                     case ENUM_MATRIX_TYPE_realValuedExpressions:
    2596                                     {
    2597                                         std::vector<ExprNode*> postfixVec;
    2598                                         if ( ((RealValuedExpressionArray*)
    2599                                                 tempExpansion[n]->value)->el[l] != NULL)
    2600                                         {
    2601                                             postfixVec
    2602                                                 = ((RealValuedExpressionArray*) tempExpansion[n]->value)
    2603                                                     ->el[l]->getPostfixFromExpressionTree();
    2604                                             outStr << getExpressionTreeAsInfixString(postfixVec);
    2605                                         }
    2606                                         else
    2607                                             outStr.str() = "";
    2608                                         break;
    2609                                     }
    2610 
    2611                                     case ENUM_MATRIX_TYPE_complexValuedExpressions:
    2612                                     {
    2613                                         std::vector<ExprNode*> postfixVec;
    2614                                         if ( ((ComplexValuedExpressionArray*)
    2615                                                 tempExpansion[n]->value)->el[l] != NULL)
    2616                                         {
    2617                                             postfixVec
    2618                                                 = ((ComplexValuedExpressionArray*) tempExpansion[n]->value)
    2619                                                     ->el[l]->getPostfixFromExpressionTree();
    2620                                             outStr << getExpressionTreeAsInfixString(postfixVec);
    2621                                         }
    2622                                         else
    2623                                             outStr.str() = "";
    2624                                         break;
    2625                                     }
    2626 
    2627                                     default:
    2628                                         throw ErrorClass("undefined matrix element conversion");
    2629                                     break;
    2630 
    2631                                 }// end switch (tempExpansion[n]->matrixType)
    2632 
    2633                                 ((StringValuedMatrixValues*)
    2634                                     tempMtx->value)->el[nz] = outStr.str();
    2635                                 break;
    2636                             }
    2637 
    2638                             case ENUM_MATRIX_TYPE_empty:
    2639                                 throw ErrorClass("Matrix should be empty, but is not!!!");
    2640                                 break;
    2641 
    2642                             default :
    2643                                 throw ErrorClass("Unsupported matrix type");
    2644                                 break;
    2645                         }// end switch (inferredType)
     1402                        if (!tempMtx->copyValue(tempExpansion[n], l, nz))
     1403                            throw ErrorClass("Matrix expansion failed while copying element values");
    26461404
    26471405                        nz++;
     
    26611419            delete []  ctorNbr;
    26621420
    2663 //            expandedMatrixInColumnMajorForm->printMatrix();
    2664 
    2665 //            return expandedMatrixInColumnMajorForm;
    2666 //            }
    26671421/*
    26681422        blocks should be doable --- but worry about cancellations
     
    26771431        tempMtx->printMatrix();
    26781432#endif
    2679         if (rowMajor)
    2680             expandedMatrixInRowMajorForm = tempMtx;
    2681         else
    2682             expandedMatrixInColumnMajorForm = tempMtx;
    2683         return tempMtx;
     1433        expandedMatrixByElements.push_back(tempMtx);
     1434        return expandedMatrixByElements.size() - 1;
    26841435    }//end try
    26851436    catch(const ErrorClass& eclass)
     
    26891440            delete tempMtx;
    26901441        tempMtx = NULL;
    2691         throw ErrorClass( eclass.errormsg);
     1442        if (location != NULL)
     1443            delete [] location;
     1444        location = NULL;
     1445        if (ctorNbr != NULL)
     1446            delete []  ctorNbr;
     1447        ctorNbr = NULL;
     1448//        throw ErrorClass( eclass.errormsg);
     1449        osoutput->OSPrint(ENUM_OUTPUT_AREA_OSMatrix, ENUM_OUTPUT_LEVEL_error, eclass.errormsg);
     1450        return -1;
    26921451    }
    26931452}// end of getExpandedMatrix
    26941453
    2695 
    2696 GeneralSparseMatrix* MatrixType::getMatrixCoefficientsInColumnMajor(ENUM_MATRIX_TYPE convertTo)
    2697 {
    2698     ostringstream outStr;
    2699 #ifndef NDEBUG
    2700     outStr << "Inside getMatrixCoefficientsInColumnMajor()";
    2701     if (convertTo != ENUM_MATRIX_TYPE_unknown)
    2702         outStr << " - convert to " << returnMatrixTypeString(convertTo);
    2703     outStr << std::endl;
    2704     outStr << "expand an object of kind " << returnMatrixConstructorTypeString(nType);
    2705     outStr << " - declared type " << returnMatrixTypeString(getDeclaredMatrixType());
    2706     outStr << " - inferred type " << returnMatrixTypeString(getInferredMatrixType());
    2707     outStr << std::endl << std::endl;
    2708     osoutput->OSPrint(ENUM_OUTPUT_AREA_OSInstance, ENUM_OUTPUT_LEVEL_trace, outStr.str());
    2709 #endif
    2710     try
    2711     {
    2712         //Check if previous expansion available
    2713         if (expandedMatrixInColumnMajorForm != NULL)
    2714             return expandedMatrixInColumnMajorForm;
    2715         if (expandedMatrixInRowMajorForm != NULL)
    2716         {
    2717             expandedMatrixInColumnMajorForm = convertToOtherMajor(false);
    2718             return expandedMatrixInColumnMajorForm;
    2719         }
    2720 
    2721         // The complexity increases with the number and diversity of constructors
    2722 
    2723         // Start by checking for empty matrix
    2724         if (inumberOfChildren == 0)
    2725         {
    2726             expandedMatrixInColumnMajorForm = new GeneralSparseMatrix();
    2727             expandedMatrixInColumnMajorForm->symmetry   = symmetry;
    2728             expandedMatrixInColumnMajorForm->start      = new int[numberOfColumns + 1];
    2729             expandedMatrixInColumnMajorForm->startSize  = numberOfColumns + 1;
    2730             expandedMatrixInColumnMajorForm->valueSize  = 0;
    2731             expandedMatrixInColumnMajorForm->matrixType = ENUM_MATRIX_TYPE_empty;
    2732             this->inferredMatrixType                    = ENUM_MATRIX_TYPE_empty;
    2733             for (int i=0; i <= numberOfColumns; i++)
    2734                 expandedMatrixInColumnMajorForm->start[i] = 0;
    2735             expandedMatrixInColumnMajorForm->printMatrix();
    2736             return expandedMatrixInColumnMajorForm;
    2737         }
    2738 
    2739         // single constructor --- process by type
    2740         else if (inumberOfChildren == 1)
    2741         {
    2742             if (m_mChildren[0]->getNodeType() == ENUM_MATRIX_CONSTRUCTOR_TYPE_baseMatrix)
    2743             {
    2744                 expandedMatrixInColumnMajorForm = this->processBaseMatrix(false,symmetry);
    2745                 expandedMatrixInColumnMajorForm->matrixType = m_mChildren[0]->getMatrixType();
    2746                 this->inferredMatrixType                    = m_mChildren[0]->getMatrixType();
    2747                 expandedMatrixInColumnMajorForm->printMatrix();
    2748                 return expandedMatrixInColumnMajorForm;
    2749             }
    2750 
    2751             else if (m_mChildren[0]->getNodeType() == ENUM_MATRIX_CONSTRUCTOR_TYPE_blocks)
    2752             {
    2753                 //make sure the blocks have been expanded, then retrieve them
    2754                 if (!processBlocks(false, symmetry))
    2755                     throw ErrorClass("error processing blocks in getMatrixCoefficientsInColumnMajor()");
    2756 
    2757                 ExpandedMatrixBlocks* currentBlocks
    2758                     = getBlocks(m_miRowPartition, m_iRowPartitionSize, m_miColumnPartition,
    2759                                 m_iColumnPartitionSize, false, true);
    2760 
    2761                 expandedMatrixInColumnMajorForm = expandBlocks(currentBlocks, false, symmetry);
    2762 
    2763                 expandedMatrixInColumnMajorForm->printMatrix();
    2764                 return expandedMatrixInColumnMajorForm;
    2765             }
    2766 
    2767             else if (m_mChildren[0]->getNodeType() == ENUM_MATRIX_CONSTRUCTOR_TYPE_transformation)
    2768             {
    2769 //              transformation: see if we can do at least AB, A'B, AB'
    2770 //              for now:
    2771                 throw ErrorClass("transformations not yet implemented in getMatrixCoefficientsInColumnMajor()");
    2772             }
    2773             else // some kind of elements
    2774             {
    2775                 expandedMatrixInColumnMajorForm = this->extractElements(0,false,symmetry);
    2776                 this->inferredMatrixType                    = expandedMatrixInColumnMajorForm->matrixType;
    2777                 expandedMatrixInColumnMajorForm->printMatrix();
    2778                 return expandedMatrixInColumnMajorForm;
    2779             }
    2780         }
    2781         else // two or more constructors --- worry about overwriting and number of elements
    2782         {
    2783             // Here we have (base matrix plus) elements
    2784             if (matrixHasTransformations() || matrixHasBlocks() )
    2785                 throw ErrorClass("Multiple constructors with transformations or blocks not yet implemented in getMatrixCoefficientsInColumnMajor()");
    2786 
    2787             expandedMatrixInColumnMajorForm = new GeneralSparseMatrix();
    2788             expandedMatrixInColumnMajorForm->symmetry = symmetry;
    2789             expandedMatrixInColumnMajorForm->startSize = numberOfColumns + 1;
    2790             expandedMatrixInColumnMajorForm->start = new int[numberOfColumns + 1];
    2791 
    2792             GeneralSparseMatrix** tempExpansion = new GeneralSparseMatrix*[inumberOfChildren];
    2793 
    2794             //estimate number of elements --- assume all different
    2795             int  nv = 0;
    2796             int  i0 = 0;
    2797             bool haveBase = false;
    2798             ENUM_MATRIX_TYPE inferredType = getMatrixType(); //ENUM_MATRIX_TYPE_unknown;
    2799 
    2800             if (m_mChildren[0]->getNodeType() == ENUM_MATRIX_CONSTRUCTOR_TYPE_baseMatrix)
    2801             {
    2802                 OSMatrix* baseMtxPtr = ((BaseMatrix*)m_mChildren[0])->baseMatrix;
    2803                 tempExpansion[0] = this->processBaseMatrix(true,symmetry);
    2804                 if (tempExpansion[0] != NULL)
    2805                 {
    2806                     nv = tempExpansion[0]->valueSize;
    2807                     haveBase = true;
    2808                 }
    2809                 i0 = 1;
    2810             }
    2811 
    2812             for (unsigned int i=i0; i < inumberOfChildren; i++)
    2813             {
    2814 
    2815                 tempExpansion[i] = this->extractElements(i,false,symmetry);
    2816                 tempExpansion[i]->matrixType = m_mChildren[i]->getMatrixType();
    2817                 tempExpansion[i]->printMatrix();
    2818                 nv += ((MatrixElements*)m_mChildren[i])->numberOfValues;
    2819             }
    2820 
    2821             if (convertTo == ENUM_MATRIX_TYPE_unknown)
    2822                 convertTo  = inferredType;
    2823             if (convertTo != mergeMatrixType(convertTo, inferredType))
    2824                throw ErrorClass("Requested improper conversion of element values");
    2825             inferredType = convertTo;
    2826             expandedMatrixInColumnMajorForm->matrixType = inferredType;
    2827                
    2828             // allocate space for elements (nv is an overestimate --- don't worry about cancelations)
    2829             // should use vectors eventually...
    2830 
    2831             expandedMatrixInColumnMajorForm->index = new int[nv];
    2832 
    2833             switch (inferredType)
    2834             {
    2835                 case ENUM_MATRIX_TYPE_empty:
    2836                 {
    2837                     if (nv != 0)
    2838                         throw ErrorClass("Matrix should be empty, but is not!!!");
    2839                     else
    2840                     {
    2841                         expandedMatrixInColumnMajorForm->matrixType = ENUM_MATRIX_TYPE_empty;
    2842                         expandedMatrixInColumnMajorForm->valueSize = 0;
    2843                         for (int i=0; i <= numberOfColumns; i++)
    2844                             expandedMatrixInColumnMajorForm->start[i] = 0;
    2845                         return expandedMatrixInColumnMajorForm;
    2846                     }
    2847                     break;
    2848                 }
    2849 
    2850                 case ENUM_MATRIX_TYPE_constant:
    2851                 {
    2852                     expandedMatrixInColumnMajorForm->value = new ConstantMatrixValues();
    2853                     ((ConstantMatrixValues*)expandedMatrixInColumnMajorForm->value)->el
    2854                         = new double[nv];
    2855                     break;
    2856                 }
    2857 
    2858                 case ENUM_MATRIX_TYPE_complexConstant:
    2859                 {
    2860                     expandedMatrixInColumnMajorForm->value = new ComplexMatrixValues();
    2861                     ((ComplexMatrixValues*)expandedMatrixInColumnMajorForm->value)->el
    2862                         = new std::complex<double>[nv];
    2863                     break;
    2864                 }
    2865 
    2866                 case ENUM_MATRIX_TYPE_varReference:
    2867                 {
    2868                     expandedMatrixInColumnMajorForm->value = new VarReferenceMatrixValues();
    2869                     ((VarReferenceMatrixValues*)expandedMatrixInColumnMajorForm->value)->el
    2870                         = new int[nv];
    2871                     break;
    2872                 }
    2873 
    2874                 case ENUM_MATRIX_TYPE_linear:
    2875                 {
    2876                     expandedMatrixInColumnMajorForm->value = new LinearMatrixValues();
    2877                     ((LinearMatrixValues*)expandedMatrixInColumnMajorForm->value)->el
    2878                         = new LinearMatrixElement*[nv];
    2879                     break;
    2880                 }
    2881 
    2882                 case ENUM_MATRIX_TYPE_objReference:
    2883                 {
    2884                     expandedMatrixInColumnMajorForm->value = new ObjReferenceMatrixValues();
    2885                     ((ObjReferenceMatrixValues*)expandedMatrixInColumnMajorForm->value)->el
    2886                         = new int[nv];
    2887                     break;
    2888                 }
    2889 
    2890                 case ENUM_MATRIX_TYPE_mixedRowReference:
    2891                 case ENUM_MATRIX_TYPE_conReference:
    2892                 {
    2893                     expandedMatrixInColumnMajorForm->value = new ConReferenceMatrixValues();
    2894                     ((ConReferenceMatrixValues*)expandedMatrixInColumnMajorForm->value)->el
    2895                         = new ConReferenceMatrixElement*[nv];
    2896                     break;
    2897                 }
    2898 
    2899                 case ENUM_MATRIX_TYPE_realValuedExpressions:
    2900                 {
    2901                     expandedMatrixInColumnMajorForm->value = new RealValuedExpressionArray();
    2902                     ((RealValuedExpressionArray*)expandedMatrixInColumnMajorForm->value)->el
    2903                         = new RealValuedExpressionTree*[nv];
    2904                     break;
    2905                 }
    2906 
    2907                 case ENUM_MATRIX_TYPE_complexValuedExpressions:
    2908                 {
    2909                     expandedMatrixInColumnMajorForm->value = new ComplexValuedExpressionArray();
    2910                     ((ComplexValuedExpressionArray*)expandedMatrixInColumnMajorForm->value)->el
    2911                         = new ComplexValuedExpressionTree*[nv];
    2912                     break;
    2913                 }
    2914 
    2915                 case ENUM_MATRIX_TYPE_string:
    2916                 {
    2917                     expandedMatrixInColumnMajorForm->value = new StringValuedMatrixValues();
    2918                     ((StringValuedMatrixValues*)expandedMatrixInColumnMajorForm->value)->el
    2919                         = new std::string[nv];
    2920                     break;
    2921                 }
    2922 
    2923                 default :
    2924                     throw ErrorClass("Unsupported matrix type");
    2925                     break;
    2926             }
    2927 
    2928             // allocate and initial two dense columns of locations of elements
    2929             // If the merged matrix has a nonzero in row i of the current column,
    2930             // ctorNbr[i] gives the number of the constructor whose value is used
    2931             // location[i] gives the location of the nonzero within this constructor
    2932             int* ctorNbr  = new int[numberOfRows];
    2933             int* location = new int[numberOfRows];
    2934 
    2935             for (int i=0; i < numberOfRows; i++)
    2936             {
    2937                  ctorNbr[i] = -1;
    2938                 location[i] = -1;
    2939             }
    2940 
    2941             int nz = 0;
    2942             expandedMatrixInColumnMajorForm->start[0] = 0;
    2943 
    2944             // Access nonzeros column by column
    2945             for (int j=0; j < numberOfColumns; j++)
    2946             {
    2947                 // First pass --- record nonzeros
    2948                 for (unsigned int i=0; i < inumberOfChildren; i++)
    2949                 {
    2950                     // if constructor i has a nonzero, it overrides previous information
    2951                     for (int k = tempExpansion[i]->start[j];
    2952                              k < tempExpansion[i]->start[j+1]; k++)
    2953                     {
    2954                         location[tempExpansion[i]->index[k]] = k;
    2955                          ctorNbr[tempExpansion[i]->index[k]] = i;
    2956                     }
    2957                 }
    2958 
    2959 #ifndef NDEBUG
    2960                 outStr.str("");
    2961                 outStr.clear();
    2962                 outStr << "Locations   for column " << j << ":";
    2963                 for (int i=0; i < numberOfRows; i++)
    2964                     outStr << "  "  << location[i];
    2965                 outStr << std::endl << std::endl;
    2966                 outStr << "Constructor for column " << j << ":";
    2967                 for (int i=0; i < numberOfRows; i++)
    2968                     outStr << "  "  << ctorNbr[i];
    2969                 outStr << std::endl << std::endl;
    2970                 osoutput->OSPrint(ENUM_OUTPUT_AREA_OSMatrix,
    2971                     ENUM_OUTPUT_LEVEL_detailed_trace, outStr.str());
    2972 #endif
    2973                 // Second pass --- retrieve nonzeros and store --- Note: Deep copy!
    2974                 int l, n;
    2975 
    2976                 for (int i=0; i < numberOfRows; i++)
    2977                 {
    2978                     if (location[i] >= 0)
    2979                     {
    2980                         l = location[i];
    2981                         n =  ctorNbr[i];
    2982                         expandedMatrixInColumnMajorForm->index[nz] = tempExpansion[n]->index[l];
    2983 
    2984                         // If the constructors differ in type, we convert to the most general type
    2985                         switch (inferredType)
    2986                         {
    2987                             // the first three types are minimal types, so no conversion is necessary,
    2988                             // and copying is much simpler as well
    2989                             case ENUM_MATRIX_TYPE_constant:
    2990                                 ((ConstantMatrixValues*)
    2991                                         expandedMatrixInColumnMajorForm->value)->el[nz]
    2992                                     = ((ConstantMatrixValues*) //((ConstantMatrixElements*)
    2993                                         tempExpansion[n]/*)*/->value)->el[l];
    2994                                 break;
    2995 
    2996                             case ENUM_MATRIX_TYPE_varReference:
    2997                                 ((VarReferenceMatrixValues*) ((VarReferenceMatrixElements*)
    2998                                         expandedMatrixInColumnMajorForm)->value)->el[nz]
    2999                                     = ((VarReferenceMatrixValues*) //((VarReferenceMatrixElements*)
    3000                                         tempExpansion[n]/*)*/->value)->el[l];
    3001                                 break;
    3002 
    3003                             case ENUM_MATRIX_TYPE_objReference:
    3004                                 ((ObjReferenceMatrixValues*) ((ObjReferenceMatrixElements*)
    3005                                         expandedMatrixInColumnMajorForm)->value)->el[nz]
    3006                                     = ((ObjReferenceMatrixValues*) //((ObjReferenceMatrixElements*)
    3007                                         tempExpansion[n]/*)*/->value)->el[l];
    3008                                 break;
    3009 
    3010                             // conReference is minimal, but the copying is a little more complicated
    3011                             case ENUM_MATRIX_TYPE_conReference:
    3012                                 ((ConReferenceMatrixValues*)
    3013                                         expandedMatrixInColumnMajorForm->value)->el[nz] =
    3014                                     new ConReferenceMatrixElement();
    3015                                 if (tempExpansion[n]->matrixType == ENUM_MATRIX_TYPE_conReference)
    3016                                 {
    3017                                     ((ConReferenceMatrixValues*) ((ConReferenceMatrixElements*)
    3018                                         expandedMatrixInColumnMajorForm)->value)->el[nz]->deepCopyFrom(
    3019                                             ((ConReferenceMatrixValues*)
    3020                                                                 tempExpansion[n]->value)->el[l]);
    3021                                 }
    3022                                 else
    3023                                     throw ErrorClass ("undefined matrix element conversion");
    3024                                 break;
    3025 
    3026                             // The other types may require conversion and more elaborate copying
    3027                             // First, complexConstant. The only legal conversion is from (real) constant
    3028                             case ENUM_MATRIX_TYPE_complexConstant:
    3029 
    3030                                 if (tempExpansion[n]->matrixType == ENUM_MATRIX_TYPE_complexConstant)
    3031                                 {
    3032                                     std::complex<double> (((ComplexMatrixValues*)
    3033                                             expandedMatrixInColumnMajorForm->value)->el[nz]) = 
    3034                                         ((ComplexMatrixValues*)tempExpansion[n]->value)->el[l]; 
    3035                                 }
    3036                                 else if (tempExpansion[n]->matrixType == ENUM_MATRIX_TYPE_constant)
    3037                                 {
    3038                                     std::complex<double> (((ComplexMatrixValues*)
    3039                                             expandedMatrixInColumnMajorForm->value)->el[nz]) = 
    3040                                         convertToComplexMatrixElement(((ConstantMatrixElements*)
    3041                                                                         tempExpansion[n])->value->el[l]); 
    3042 std::cout << "complex matrix value = " << ((ComplexMatrixValues*)
    3043                                             expandedMatrixInColumnMajorForm->value)->el[nz] << std::endl;
    3044                                 }
    3045                                 else
    3046                                     throw ErrorClass ("undefined matrix element conversion");
    3047                                 break;
    3048 
    3049                             case ENUM_MATRIX_TYPE_linear:
    3050                                 ((LinearMatrixValues*)
    3051                                     expandedMatrixInColumnMajorForm->value)->el[nz]
    3052                                         = new LinearMatrixElement();
    3053                                 switch (tempExpansion[n]->matrixType)
    3054                                 {
    3055                                     // linear elements do not have to be converted
    3056                                     case ENUM_MATRIX_TYPE_linear:
    3057                                         ((LinearMatrixValues*)expandedMatrixInColumnMajorForm->value)
    3058                                             ->el[nz]->deepCopyFrom(((LinearMatrixValues*)
    3059                                                                     tempExpansion[n]->value)->el[l]);
    3060                                         break;
    3061 
    3062                                     // legal conversions: constant, varReference
    3063                                     case ENUM_MATRIX_TYPE_constant:
    3064                                         ((LinearMatrixValues*)
    3065                                              expandedMatrixInColumnMajorForm->value)->el[nz]->constant =
    3066                                                 ((ConstantMatrixValues*)tempExpansion[n]->value)->el[l];
    3067                                         break;
    3068 
    3069                                     case ENUM_MATRIX_TYPE_varReference:
    3070                                         ((LinearMatrixValues*)expandedMatrixInColumnMajorForm
    3071                                                         ->value)->el[nz]->numberOfVarIdx = 1;
    3072                                         ((LinearMatrixValues*)expandedMatrixInColumnMajorForm
    3073                                                         ->value)->el[nz]->varIdx =
    3074                                             new LinearMatrixElementTerm*[1];
    3075                                         ((LinearMatrixValues*)expandedMatrixInColumnMajorForm
    3076                                                         ->value)->el[nz]->varIdx[0] =
    3077                                             new LinearMatrixElementTerm();
    3078                                         ((LinearMatrixValues*)expandedMatrixInColumnMajorForm
    3079                                                         ->value)->el[nz]->varIdx[0]->idx =
    3080                                             ((VarReferenceMatrixValues*)tempExpansion[n]->value)->el[l];
    3081                                         ((LinearMatrixValues*)expandedMatrixInColumnMajorForm
    3082                                                         ->value)->el[nz]->varIdx[0]->coef = 0;
    3083                                         break;
    3084 
    3085                                     // other conversion are illegal
    3086                                     default: throw ErrorClass ("undefined matrix element conversion");
    3087                                         break;
    3088                                 }//end switch (tempExpansion[n]->matrixType)
    3089                                 break;
    3090 
    3091                             case ENUM_MATRIX_TYPE_mixedRowReference:
    3092                                 ((ConReferenceMatrixValues*)
    3093                                     expandedMatrixInColumnMajorForm->value)->el[nz]
    3094                                         = new ConReferenceMatrixElement();
    3095                                 switch (tempExpansion[n]->matrixType)
    3096                                 {
    3097                                     // elements with constraint references do not have to be converted
    3098                                     case ENUM_MATRIX_TYPE_mixedRowReference:
    3099                                     case ENUM_MATRIX_TYPE_conReference:
    3100                                         ((ConReferenceMatrixValues*)
    3101                                             expandedMatrixInColumnMajorForm->value)->el[nz]
    3102                                                 ->deepCopyFrom(((ConReferenceMatrixValues*)
    3103                                                                 tempExpansion[n]->value)->el[l]);
    3104                                         break;
    3105 
    3106                                     // only other legal possibility: objective references
    3107                                     case ENUM_MATRIX_TYPE_objReference:
    3108                                         ((ConReferenceMatrixValues*)
    3109                                             expandedMatrixInColumnMajorForm->value)->el[nz]
    3110                                                 = new ConReferenceMatrixElement();
    3111                                         ((ConReferenceMatrixValues*)
    3112                                             expandedMatrixInColumnMajorForm->value)->el[nz]->conReference
    3113                                                 = ((ObjReferenceMatrixValues*)
    3114                                                                 tempExpansion[n]->value)->el[l];
    3115                                         break;
    3116 
    3117                                     default: throw ErrorClass ("undefined matrix element conversion");
    3118                                         break;
    3119                                 }
    3120                                 break;
    3121 
    3122                             case ENUM_MATRIX_TYPE_realValuedExpressions:
    3123                             {
    3124                                 switch (tempExpansion[n]->matrixType)
    3125                                 {
    3126                                     case ENUM_MATRIX_TYPE_constant:
    3127                                         ((RealValuedExpressionArray*)
    3128                                                 expandedMatrixInColumnMajorForm->value)->el[nz]
    3129                                             = convertToRealExpressionTree(((ConstantMatrixValues*)
    3130                                                                         tempExpansion[n]->value)->el[l]); 
    3131                                         break;
    3132 
    3133                                     case ENUM_MATRIX_TYPE_varReference:
    3134                                         ((RealValuedExpressionArray*)
    3135                                                 expandedMatrixInColumnMajorForm->value)->el[nz]
    3136                                             = convertToRealExpressionTree(((VarReferenceMatrixValues*)
    3137                                                                    tempExpansion[n]->value)->el[l], true);
    3138                                         break;
    3139 
    3140                                     case ENUM_MATRIX_TYPE_realValuedExpressions:
    3141                                     {
    3142                                         ((RealValuedExpressionArray*)
    3143                                                 expandedMatrixInColumnMajorForm->value)->el[nz]
    3144                                             = ((RealValuedExpressionArray*)tempExpansion[n]
    3145                                                 ->value)->el[l]->cloneExpressionTree();
    3146                                         break;
    3147                                     }
    3148 
    3149                                     case ENUM_MATRIX_TYPE_linear:
    3150                                         ((RealValuedExpressionArray*)
    3151                                                 expandedMatrixInColumnMajorForm->value)->el[nz]
    3152                                             = convertToRealExpressionTree(((LinearMatrixValues*)
    3153                                                                         tempExpansion[n]->value)->el[l]); 
    3154                                         break;
    3155 
    3156                                     case ENUM_MATRIX_TYPE_objReference:
    3157                                         throw ErrorClass("OSnLNodeObjective not implemented yet");
    3158                                         break;
    3159 
    3160                                     case ENUM_MATRIX_TYPE_conReference:
    3161                                         throw ErrorClass("OSnLNodeConstraint not implemented yet");
    3162                                         break;
    3163 
    3164                                     case ENUM_MATRIX_TYPE_mixedRowReference:
    3165                                         throw ErrorClass("relevant OSnLNodes not implemented yet");
    3166                                         break;
    3167 
    3168                                     case ENUM_MATRIX_TYPE_complexConstant:
    3169                                     case ENUM_MATRIX_TYPE_complexValuedExpressions:
    3170                                         throw ErrorClass("improper conversion of complex-valued elements");
    3171                                         break;
    3172 
    3173                                     default: throw ErrorClass ("undefined matrix element conversion");
    3174                                         break;
    3175                                 }
    3176                                 break;
    3177                             }// end case realValuedExpressions
    3178 
    3179                             case ENUM_MATRIX_TYPE_complexValuedExpressions:
    3180                             {
    3181                                 ComplexValuedExpressionTree* temp = new ComplexValuedExpressionTree();
    3182 
    3183                                 switch (tempExpansion[n]->matrixType)
    3184                                 {
    3185                                     case ENUM_MATRIX_TYPE_complexValuedExpressions:
    3186                                     {
    3187                                         temp->m_treeRoot
    3188                                             = ((ComplexValuedExpressionArray*)tempExpansion[n]
    3189                                                 ->value)->el[l]->m_treeRoot->cloneExprNode();
    3190                                         break;
    3191                                     }
    3192 
    3193                                     case ENUM_MATRIX_TYPE_constant:
    3194                                     {
    3195                                         temp->m_treeRoot = new OSnLCNodeNumber();
    3196                                         double tempVal = ((ConstantMatrixValues*)
    3197                                                             tempExpansion[n]->value)->el[l];
    3198                                         ((OSnLCNodeNumber*) temp->m_treeRoot)->setValue(tempVal, 0.0);
    3199                                         break;
    3200                                     }
    3201 
    3202                                     case ENUM_MATRIX_TYPE_complexConstant:
    3203                                     {
    3204                                         temp->m_treeRoot = new OSnLCNodeNumber();
    3205                                         std::complex<double> tempVal
    3206                                             = ((ComplexMatrixValues*) tempExpansion[n]->value)->el[l];
    3207                                         ((OSnLCNodeNumber*) temp->m_treeRoot)->setValue(tempVal);
    3208                                         break;
    3209                                     }
    3210 
    3211                                     case ENUM_MATRIX_TYPE_varReference:
    3212                                     {
    3213                                         temp->m_treeRoot = new OSnLCNodeCreate();
    3214                                         temp->m_treeRoot->m_mChildren[0] = new OSnLNodeVariable();
    3215                                         temp->m_treeRoot->m_mChildren[1] = new OSnLNodeNumber();
    3216                                         ((OSnLNodeVariable*)temp->m_treeRoot->m_mChildren[0])->idx
    3217                                             = ((VarReferenceMatrixValues*)tempExpansion[n]->value)->el[l];
    3218                                         ((OSnLNodeNumber*)temp->m_treeRoot->m_mChildren[1])->value  = 0.0;
    3219                                         break;
    3220                                     }
    3221 
    3222                                     case ENUM_MATRIX_TYPE_realValuedExpressions:
    3223                                     {
    3224                                         temp->m_treeRoot = new OSnLCNodeCreate();
    3225                                         temp->m_treeRoot->m_mChildren[1] = new OSnLNodeNumber();
    3226                                         ((OSnLNodeNumber*)temp->m_treeRoot->m_mChildren[1])->value  = 0.0;
    3227 
    3228                                         temp->m_treeRoot->m_mChildren[0]
    3229                                             = ((RealValuedExpressionArray*)tempExpansion[n]
    3230                                                 ->value)->el[l]->m_treeRoot->cloneExprNode();
    3231                                         break;
    3232                                     }
    3233 
    3234                                     // the hardest conversion: linear expressions
    3235                                     case ENUM_MATRIX_TYPE_linear:
    3236                                     {
    3237                                         temp->m_treeRoot = new OSnLCNodeCreate();
    3238                                         temp->m_treeRoot->m_mChildren[1] = new OSnLNodeNumber();
    3239                                         ((OSnLNodeNumber*)temp->m_treeRoot->m_mChildren[1])->value = 0.0;
    3240 
    3241                                         temp->m_treeRoot->m_mChildren[0] = new OSnLNodeVariable();
    3242                                         ((OSnLNodeVariable*)temp->m_treeRoot->m_mChildren[0])->idx
    3243                                             = ((VarReferenceMatrixValues*)tempExpansion[n]->value)->el[l];
    3244 
    3245                                         int nn = ((LinearMatrixElements*)
    3246                                                   m_mChildren[n])->value->el[l]->numberOfVarIdx;
    3247                                         bool haveConstant;
    3248 
    3249                                         if (nn == 0)
    3250                                         {
    3251                                             temp->m_treeRoot->m_mChildren[0] = new OSnLNodeNumber();
    3252                                             ((OSnLNodeNumber*)
    3253                                                 temp->m_treeRoot->m_mChildren[1])->value = 0.0;
    3254                                         }
    3255                                         else
    3256                                         {
    3257                                             if (((LinearMatrixElements*)
    3258                                                   tempExpansion[n])->value->el[l]->constant == 0)
    3259                                             {
    3260                                                 haveConstant = false;
    3261                                                 temp->m_treeRoot->m_mChildren[0] = new OSnLNodeSum();
    3262                                                 temp->m_treeRoot->m_mChildren[0]->m_mChildren
    3263                                                     = new ExprNode*[nn];
    3264                                                 temp->m_treeRoot->m_mChildren[0]->inumberOfChildren = nn;
    3265                                             }
    3266                                             else
    3267                                             {
    3268                                                 haveConstant = true;
    3269                                                 temp->m_treeRoot->m_mChildren[0] = new OSnLNodeSum();
    3270                                                 temp->m_treeRoot->m_mChildren[0]->m_mChildren
    3271                                                     = new ExprNode*[nn+1];
    3272                                                 temp->m_treeRoot->m_mChildren[0]->inumberOfChildren = nn+1;
    3273                                             }
    3274 
    3275                                             for (int ii=0; ii<nn; ii++)
    3276                                             {
    3277                                                 temp->m_treeRoot->m_mChildren[0]->m_mChildren[ii]
    3278                                                     = new OSnLNodeVariable();
    3279                                                 ((OSnLNodeVariable*) temp->m_treeRoot
    3280                                                             ->m_mChildren[0]->m_mChildren[ii])->idx
    3281                                                     = ((LinearMatrixValues*)
    3282                                                         tempExpansion[n]->value)->el[l]->varIdx[ii]->idx;
    3283                                                 ((OSnLNodeVariable*) temp->m_treeRoot
    3284                                                             ->m_mChildren[0]->m_mChildren[ii])->coef
    3285                                                     = ((LinearMatrixValues*)
    3286                                                         tempExpansion[n]->value)->el[l]->varIdx[ii]->coef;
    3287                                             }
    3288 
    3289                                             if (haveConstant)
    3290                                             {
    3291                                                 temp->m_treeRoot->m_mChildren[0]->m_mChildren[nn]
    3292                                                     = new OSnLNodeNumber();
    3293                                                 ((OSnLNodeNumber*) temp->m_treeRoot
    3294                                                      ->m_mChildren[0]->m_mChildren[nn])->value
    3295                                                     = ((LinearMatrixValues*)
    3296                                                        tempExpansion[n]->value)->el[l]->constant;
    3297                                             }
    3298                                         }
    3299                                         break;
    3300                                     }
    3301 
    3302                                         case ENUM_MATRIX_TYPE_objReference:
    3303                                             throw ErrorClass("OSnLNodeObjective not implemented yet");
    3304                                             break;
    3305 
    3306                                         case ENUM_MATRIX_TYPE_conReference:
    3307                                             throw ErrorClass("OSnLNodeConstraint not implemented yet");
    3308                                             break;
    3309 
    3310                                         case ENUM_MATRIX_TYPE_mixedRowReference:
    3311                                             throw ErrorClass("relevant OSnLNodes not implemented yet");
    3312                                             break;
    3313 
    3314                                         default:
    3315                                             throw ErrorClass("undefined matrix element conversion");
    3316                                             break;
    3317 
    3318                                     }
    3319                                     ((ComplexValuedExpressionArray*)
    3320                                         expandedMatrixInColumnMajorForm->value)->el[nz] = temp;
    3321                                 break;
    3322                             }// end case complexValuedExpressions
    3323 
    3324                             case ENUM_MATRIX_TYPE_string:
    3325                             {
    3326                                 outStr.str("");
    3327                                 outStr.clear();
    3328 
    3329                                 switch (tempExpansion[n]->matrixType)
    3330                                 {
    3331                                     case ENUM_MATRIX_TYPE_constant:
    3332                                         outStr << os_dtoa_format(((ConstantMatrixValues*)
    3333                                                        tempExpansion[n]->value)->el[l]);
    3334                                         break;
    3335 
    3336                                     case ENUM_MATRIX_TYPE_complexConstant:
    3337                                         outStr << "(" << os_dtoa_format(((ComplexMatrixValues*)
    3338                                                             tempExpansion[n]->value)->el[l].real());
    3339                                         outStr << "," << os_dtoa_format(((ComplexMatrixValues*)
    3340                                                             tempExpansion[n]->value)->el[l].imag()) << ")";
    3341                                         break;
    3342 
    3343                                     case ENUM_MATRIX_TYPE_varReference:
    3344                                         outStr << "x_"
    3345                                                << ((VarReferenceMatrixValues*)
    3346                                                        tempExpansion[n]->value)->el[l];
    3347                                         break;
    3348 
    3349                                     case ENUM_MATRIX_TYPE_objReference:
    3350                                         outStr << "o_"
    3351                                                << ((ObjReferenceMatrixValues*)
    3352                                                        tempExpansion[n]->value)->el[l];
    3353                                         break;
    3354 
    3355                                     case ENUM_MATRIX_TYPE_conReference:
    3356                                         outStr << "c_"
    3357                                                << ((ConReferenceMatrixValues*)
    3358                                                        tempExpansion[n]->value)->el[l]->conReference
    3359                                                << "."
    3360                                                << returnConReferenceValueTypeString(
    3361                                                     ((ConReferenceMatrixValues*)
    3362                                                        tempExpansion[n]->value)->el[l]->valueType);
    3363                                         break;
    3364 
    3365                                     case ENUM_MATRIX_TYPE_mixedRowReference:
    3366                                     {
    3367                                         int temp = ((ConReferenceMatrixValues*)
    3368                                                        tempExpansion[n]->value)->el[l]->conReference;
    3369                                         if (temp < 0)
    3370                                             outStr << "o_"
    3371                                                    << temp;
    3372                                         else
    3373                                             outStr << "c_"
    3374                                                    << temp
    3375                                                    << "."
    3376                                                    << returnConReferenceValueTypeString(
    3377                                                        ((ConReferenceMatrixValues*)
    3378                                                            tempExpansion[n]->value)->el[l]->valueType);
    3379                                         break;
    3380                                     }
    3381 
    3382                                     case ENUM_MATRIX_TYPE_string:
    3383                                         outStr << ((StringValuedMatrixValues*)
    3384                                                        tempExpansion[n]->value)->el[l];
    3385                                         break;
    3386 
    3387                                     case ENUM_MATRIX_TYPE_linear:
    3388                                     {
    3389                                         LinearMatrixElement* temp =
    3390                                             ((LinearMatrixValues*)tempExpansion[n]->value)->el[l];
    3391 
    3392                                         if (temp->constant < 0.0 || temp->constant > 0.0)
    3393                                         {
    3394                                             outStr << os_dtoa_format(temp->constant);
    3395                                         }
    3396 
    3397                                         if (temp->numberOfVarIdx > 0)
    3398                                         {
    3399                                             if (temp->varIdx[0]->coef >= 0)
    3400                                             {
    3401                                                 if (temp->constant < 0.0 || temp->constant > 0.0)
    3402                                                     outStr << " + ";
    3403                                                 else
    3404                                                     outStr << " - ";
    3405                                             }
    3406                                             else
    3407                                                 outStr << "-";
    3408                                             if (temp->varIdx[0]->coef < 1 || temp->varIdx[0]->coef > 1 )
    3409                                                 outStr << os_dtoa_format(abs(temp->varIdx[0]->coef)) << "*";
    3410                                             outStr << "x_" << temp->varIdx[0]->idx;
    3411                                         }
    3412 
    3413                                         for (int j=1; j<temp->numberOfVarIdx; i++)
    3414                                         {
    3415                                             if (temp->varIdx[j]->coef >= 0)
    3416                                                 outStr << " + ";
    3417                                             else
    3418                                                 outStr << " - ";
    3419                                             if (temp->varIdx[j]->coef < 1 || temp->varIdx[j]->coef > 1 )
    3420                                                 outStr << os_dtoa_format(abs(temp->varIdx[j]->coef)) << "*";
    3421                                             outStr << "x_" << temp->varIdx[j]->idx;
    3422                                         }
    3423                                         break;
    3424                                     }
    3425 
    3426                                     case ENUM_MATRIX_TYPE_realValuedExpressions:
    3427                                     {
    3428                                         std::vector<ExprNode*> postfixVec;
    3429                                         if ( ((RealValuedExpressionArray*)
    3430                                                 tempExpansion[n]->value)->el[l] != NULL)
    3431                                         {
    3432                                             postfixVec
    3433                                                 = ((RealValuedExpressionArray*) tempExpansion[n]->value)
    3434                                                     ->el[l]->getPostfixFromExpressionTree();
    3435                                             outStr << getExpressionTreeAsInfixString(postfixVec);
    3436                                         }
    3437                                         else
    3438                                             outStr.str() = "";
    3439                                         break;
    3440                                     }
    3441 
    3442                                     case ENUM_MATRIX_TYPE_complexValuedExpressions:
    3443                                     {
    3444                                         std::vector<ExprNode*> postfixVec;
    3445                                         if ( ((ComplexValuedExpressionArray*)
    3446                                                 tempExpansion[n]->value)->el[l] != NULL)
    3447                                         {
    3448                                             postfixVec
    3449                                                 = ((ComplexValuedExpressionArray*) tempExpansion[n]->value)
    3450                                                     ->el[l]->getPostfixFromExpressionTree();
    3451                                             outStr << getExpressionTreeAsInfixString(postfixVec);
    3452                                         }
    3453                                         else
    3454                                             outStr.str() = "";
    3455                                         break;
    3456                                     }
    3457 
    3458                                     default:
    3459                                         throw ErrorClass("undefined matrix element conversion");
    3460                                     break;
    3461 
    3462                                 }// end switch (tempExpansion[n]->matrixType)
    3463 
    3464                                 ((StringValuedMatrixValues*)
    3465                                     expandedMatrixInColumnMajorForm->value)->el[nz] = outStr.str();
    3466                                 break;
    3467                             }
    3468 
    3469                             case ENUM_MATRIX_TYPE_empty:
    3470                                 throw ErrorClass("Matrix should be empty, but is not!!!");
    3471                                 break;
    3472 
    3473                             default :
    3474                                 throw ErrorClass("Unsupported matrix type");
    3475                                 break;
    3476                         }// end switch (inferredType)
    3477 
    3478                         nz++;
    3479 
    3480                         // "turn out the lights" for the next column
    3481                         location[i] = -1;
    3482                          ctorNbr[i] = -1;
    3483                     }// end if (location[i] >= 0)
    3484                 }// end for (int i=0; i < numberOfRows; i++)
    3485 
    3486                 expandedMatrixInColumnMajorForm->start[j+1] = nz;
    3487             }
    3488 
    3489             expandedMatrixInColumnMajorForm->valueSize = nz;
    3490 
    3491             delete [] location;
    3492             delete []  ctorNbr;
    3493 
    3494             expandedMatrixInColumnMajorForm->printMatrix();
    3495 
    3496             return expandedMatrixInColumnMajorForm;
    3497 
    3498 /*
    3499         maybe transformation (product) plus elements
    3500         others: throw error
    3501 */
    3502             throw ErrorClass("Multiple constructors not yet implemented in getMatrixCoefficientsInColumnMajor()");
    3503         }
    3504         return NULL;
    3505     }
    3506     catch(const ErrorClass& eclass)
    3507     {
    3508         // clear memory if already allocated
    3509         if (expandedMatrixInColumnMajorForm != NULL)
    3510             delete expandedMatrixInColumnMajorForm;
    3511         expandedMatrixInColumnMajorForm = NULL;
    3512         throw ErrorClass( eclass.errormsg);
    3513     }
    3514 }// end of getMatrixCoefficientsInColumnMajor
    3515 
    3516 GeneralSparseMatrix* MatrixType::getMatrixCoefficientsInRowMajor(ENUM_MATRIX_TYPE convertTo)
    3517 {
    3518     ostringstream outStr;
    3519 #ifndef NDEBUG
    3520     outStr << "Inside getMatrixCoefficientsInRowMajor()";
    3521     if (convertTo != ENUM_MATRIX_TYPE_unknown)
    3522         outStr << " - convert to " << returnMatrixTypeString(convertTo);
    3523     outStr << std::endl;
    3524     outStr << "expand an object of kind " << returnMatrixConstructorTypeString(nType);
    3525     outStr << " - declared type " << returnMatrixTypeString(getDeclaredMatrixType());
    3526     outStr << " - inferred type " << returnMatrixTypeString(getInferredMatrixType());
    3527     outStr << std::endl << std::endl;
    3528     osoutput->OSPrint(ENUM_OUTPUT_AREA_OSInstance, ENUM_OUTPUT_LEVEL_trace, outStr.str());
    3529 #endif
    3530     try
    3531     {
    3532         //Check if previous expansion available
    3533         if (expandedMatrixInRowMajorForm != NULL)
    3534             return expandedMatrixInRowMajorForm;
    3535         if (expandedMatrixInColumnMajorForm != NULL)
    3536         {
    3537             expandedMatrixInRowMajorForm = convertToOtherMajor(true);
    3538             return expandedMatrixInRowMajorForm;
    3539         }
    3540 
    3541         // The complexity increases with the number of constructors
    3542 
    3543         // Start by checking for empty matrix
    3544         if (inumberOfChildren == 0)
    3545         {
    3546             expandedMatrixInRowMajorForm = new GeneralSparseMatrix();
    3547             expandedMatrixInRowMajorForm->symmetry   = symmetry;
    3548             expandedMatrixInRowMajorForm->startSize  = numberOfRows + 1;
    3549             expandedMatrixInRowMajorForm->valueSize  = 0;
    3550             expandedMatrixInRowMajorForm->matrixType = ENUM_MATRIX_TYPE_empty;
    3551             this->inferredMatrixType                 = ENUM_MATRIX_TYPE_empty;
    3552             expandedMatrixInRowMajorForm->start      = new int[numberOfRows + 1];
    3553             for (int i=0; i <= numberOfRows; i++)
    3554                 expandedMatrixInRowMajorForm->start[i] = 0;
    3555             expandedMatrixInRowMajorForm->printMatrix();
    3556             return expandedMatrixInRowMajorForm;
    3557         }
    3558 
    3559         // single constructor --- process by type
    3560         else if (inumberOfChildren == 1)
    3561         {
    3562             if (m_mChildren[0]->getNodeType() == ENUM_MATRIX_CONSTRUCTOR_TYPE_baseMatrix)
    3563             {
    3564                 expandedMatrixInRowMajorForm = this->processBaseMatrix(false,symmetry);
    3565                 expandedMatrixInRowMajorForm->matrixType = m_mChildren[0]->getMatrixType();
    3566                 this->inferredMatrixType                 = m_mChildren[0]->getMatrixType();
    3567                 expandedMatrixInRowMajorForm->printMatrix();
    3568                 return expandedMatrixInRowMajorForm;
    3569             }
    3570 
    3571             else if (m_mChildren[0]->getNodeType() == ENUM_MATRIX_CONSTRUCTOR_TYPE_blocks)
    3572             {
    3573                 //make sure the blocks have been expanded, then retrieve them
    3574                 if (!processBlocks(true, symmetry))
    3575                     throw ErrorClass("error processing blocks in getMatrixCoefficientsInRowMajor()");
    3576                
    3577                 ExpandedMatrixBlocks* currentBlocks
    3578                     = getBlocks(m_miRowPartition, m_iRowPartitionSize, m_miColumnPartition,
    3579                                 m_iColumnPartitionSize, true, true);
    3580 
    3581                 expandedMatrixInRowMajorForm = expandBlocks(currentBlocks, true, symmetry);
    3582 
    3583                 expandedMatrixInRowMajorForm->printMatrix();
    3584                 return expandedMatrixInRowMajorForm;
    3585             }
    3586 
    3587             else if (m_mChildren[0]->getNodeType() == ENUM_MATRIX_CONSTRUCTOR_TYPE_transformation)
    3588             {
    3589 //              transformation: see if we can do at least AB, A'B, AB'
    3590 //              for now:
    3591                 throw ErrorClass("transformations not yet implemented in getMatrixCoefficientsInRowMajor()");
    3592             }
    3593             else // some kind of elements --- if given row-wise, just copy pointers
    3594             {
    3595                 expandedMatrixInRowMajorForm = this->extractElements(0,true,symmetry);
    3596                 expandedMatrixInRowMajorForm->printMatrix();
    3597                 return expandedMatrixInRowMajorForm;
    3598             }
    3599         }
    3600 
    3601         else // two or more constructors --- worry about overwriting and number of elements
    3602         {
    3603 //------------------------------------------
    3604             // Here we have (base matrix plus) elements
    3605             if (matrixHasTransformations() || matrixHasBlocks() )
    3606                 throw ErrorClass("Multiple constructors with transformations or blocks not yet implemented in getMatrixCoefficientsInRowMajor()");
    3607 
    3608             expandedMatrixInColumnMajorForm = new GeneralSparseMatrix();
    3609             expandedMatrixInColumnMajorForm->symmetry = symmetry;
    3610             expandedMatrixInColumnMajorForm->startSize = numberOfColumns + 1;
    3611             expandedMatrixInColumnMajorForm->start = new int[numberOfColumns + 1];
    3612 
    3613             GeneralSparseMatrix** tempExpansion = new GeneralSparseMatrix*[inumberOfChildren];
    3614 
    3615             //estimate number of elements --- assume all different
    3616             int  nv = 0;
    3617             int  i0 = 0;
    3618             bool haveBase = false;
    3619             ENUM_MATRIX_TYPE inferredType = getMatrixType(); //ENUM_MATRIX_TYPE_unknown;
    3620 
    3621             if (m_mChildren[0]->getNodeType() == ENUM_MATRIX_CONSTRUCTOR_TYPE_baseMatrix)
    3622             {
    3623                 OSMatrix* baseMtxPtr = ((BaseMatrix*)m_mChildren[0])->baseMatrix;
    3624                 tempExpansion[0] = this->processBaseMatrix(true,symmetry);
    3625                 if (tempExpansion[0] != NULL)
    3626                 {
    3627                     nv = tempExpansion[0]->valueSize;
    3628                     haveBase = true;
    3629 //                    inferredType = tempExpansion[0]->matrixType;
    3630                 }
    3631                 i0 = 1;
    3632             }
    3633 
    3634             for (unsigned int i=i0; i < inumberOfChildren; i++)
    3635             {
    3636 
    3637                 tempExpansion[i] = this->extractElements(i,false,symmetry);
    3638 if (i == 3)
    3639 {
    3640 std::cout << std::endl << "tempExpansion[3]:" << std::endl;
    3641 std::cout << ((RealValuedExpressionTree*)((RealValuedExpressionArray*)
    3642     tempExpansion[i]->value)->el[0])->m_treeRoot->getNodeInfo(true, 0) << std::endl;
    3643 }
    3644                 tempExpansion[i]->matrixType = m_mChildren[i]->getMatrixType();
    3645                 tempExpansion[i]->printMatrix();
    3646                 nv += ((MatrixElements*)m_mChildren[i])->numberOfValues;
    3647 //                inferredType = mergeMatrixType(inferredType,
    3648 //                                               ((MatrixElements*)m_mChildren[i])->getMatrixType());
    3649             }
    3650 
    3651             if (convertTo == ENUM_MATRIX_TYPE_unknown)
    3652                 convertTo  = inferredType;
    3653             if (convertTo != mergeMatrixType(convertTo, inferredType))
    3654                throw ErrorClass("Requested improper conversion of element values");
    3655             inferredType = convertTo;
    3656             expandedMatrixInColumnMajorForm->matrixType = inferredType;
    3657                
    3658             // allocate space for elements (nv is an overestimate --- don't worry about cancelations)
    3659             // should use vectors eventually...
    3660 
    3661             expandedMatrixInColumnMajorForm->index = new int[nv];
    3662 
    3663             switch (inferredType)
    3664             {
    3665                 case ENUM_MATRIX_TYPE_empty:
    3666                 {
    3667                     if (nv != 0)
    3668                         throw ErrorClass("Matrix should be empty, but is not!!!");
    3669                     else
    3670                     {
    3671                         expandedMatrixInColumnMajorForm->matrixType = ENUM_MATRIX_TYPE_empty;
    3672                         expandedMatrixInColumnMajorForm->valueSize = 0;
    3673                         for (int i=0; i <= numberOfColumns; i++)
    3674                             expandedMatrixInColumnMajorForm->start[i] = 0;
    3675                         return expandedMatrixInColumnMajorForm;
    3676                     }
    3677                     break;
    3678                 }
    3679 
    3680                 case ENUM_MATRIX_TYPE_constant:
    3681                 {
    3682                     expandedMatrixInColumnMajorForm->value = new ConstantMatrixValues();
    3683                     ((ConstantMatrixValues*)expandedMatrixInColumnMajorForm->value)->el
    3684                         = new double[nv];
    3685                     break;
    3686                 }
    3687 
    3688                 case ENUM_MATRIX_TYPE_complexConstant:
    3689                 {
    3690                     expandedMatrixInColumnMajorForm->value = new ComplexMatrixValues();
    3691                     ((ComplexMatrixValues*)expandedMatrixInColumnMajorForm->value)->el
    3692                         = new std::complex<double>[nv];
    3693                     break;
    3694                 }
    3695 
    3696                 case ENUM_MATRIX_TYPE_varReference:
    3697                 {
    3698                     expandedMatrixInColumnMajorForm->value = new VarReferenceMatrixValues();
    3699                     ((VarReferenceMatrixValues*)expandedMatrixInColumnMajorForm->value)->el
    3700                         = new int[nv];
    3701                     break;
    3702                 }
    3703 
    3704                 case ENUM_MATRIX_TYPE_linear:
    3705                 {
    3706                     expandedMatrixInColumnMajorForm->value = new LinearMatrixValues();
    3707                     ((LinearMatrixValues*)expandedMatrixInColumnMajorForm->value)->el
    3708                         = new LinearMatrixElement*[nv];
    3709                     break;
    3710                 }
    3711 
    3712                 case ENUM_MATRIX_TYPE_objReference:
    3713                 {
    3714                     expandedMatrixInColumnMajorForm->value = new ObjReferenceMatrixValues();
    3715                     ((ObjReferenceMatrixValues*)expandedMatrixInColumnMajorForm->value)->el
    3716                         = new int[nv];
    3717                     break;
    3718                 }
    3719 
    3720                 case ENUM_MATRIX_TYPE_mixedRowReference:
    3721                 case ENUM_MATRIX_TYPE_conReference:
    3722                 {
    3723                     expandedMatrixInColumnMajorForm->value = new ConReferenceMatrixValues();
    3724                     ((ConReferenceMatrixValues*)expandedMatrixInColumnMajorForm->value)->el
    3725                         = new ConReferenceMatrixElement*[nv];
    3726                     break;
    3727                 }
    3728 
    3729                 case ENUM_MATRIX_TYPE_realValuedExpressions:
    3730                 {
    3731                     expandedMatrixInColumnMajorForm->value = new RealValuedExpressionArray();
    3732                     ((RealValuedExpressionArray*)expandedMatrixInColumnMajorForm->value)->el
    3733                         = new RealValuedExpressionTree*[nv];
    3734                     break;
    3735                 }
    3736 
    3737                 case ENUM_MATRIX_TYPE_complexValuedExpressions:
    3738                 {
    3739                     expandedMatrixInColumnMajorForm->value = new ComplexValuedExpressionArray();
    3740                     ((ComplexValuedExpressionArray*)expandedMatrixInColumnMajorForm->value)->el
    3741                         = new ComplexValuedExpressionTree*[nv];
    3742                     break;
    3743                 }
    3744 
    3745                 case ENUM_MATRIX_TYPE_string:
    3746                 {
    3747                     expandedMatrixInColumnMajorForm->value = new StringValuedMatrixValues();
    3748                     ((StringValuedMatrixValues*)expandedMatrixInColumnMajorForm->value)->el
    3749                         = new std::string[nv];
    3750                     break;
    3751                 }
    3752 
    3753                 default :
    3754                     throw ErrorClass("Unsupported matrix type");
    3755                     break;
    3756             }
    3757 
    3758             // allocate and initial two dense columns of locations of elements
    3759             // If the merged matrix has a nonzero in row i of the current column,
    3760             // ctorNbr[i] gives the number of the constructor whose value is used
    3761             // location[i] gives the location of the nonzero within this constructor
    3762             int* ctorNbr  = new int[numberOfRows];
    3763             int* location = new int[numberOfRows];
    3764 
    3765             for (int i=0; i < numberOfRows; i++)
    3766             {
    3767                  ctorNbr[i] = -1;
    3768                 location[i] = -1;
    3769             }
    3770 
    3771             int nz = 0;
    3772             expandedMatrixInColumnMajorForm->start[0] = 0;
    3773 
    3774             // Access nonzeros column by column
    3775             for (int j=0; j < numberOfColumns; j++)
    3776             {
    3777                 // First pass --- record nonzeros
    3778                 for (unsigned int i=0; i < inumberOfChildren; i++)
    3779                 {
    3780                     // if constructor i has a nonzero, it overrides previous information
    3781                     for (int k = tempExpansion[i]->start[j];
    3782                              k < tempExpansion[i]->start[j+1]; k++)
    3783                     {
    3784                         location[tempExpansion[i]->index[k]] = k;
    3785                          ctorNbr[tempExpansion[i]->index[k]] = i;
    3786                     }
    3787                 }
    3788 
    3789 #ifndef NDEBUG
    3790                 outStr.str("");
    3791                 outStr.clear();
    3792                 outStr << "Locations   for column " << j << ":";
    3793                 for (int i=0; i < numberOfRows; i++)
    3794                     outStr << "  "  << location[i];
    3795                 outStr << std::endl << std::endl;
    3796                 outStr << "Constructor for column " << j << ":";
    3797                 for (int i=0; i < numberOfRows; i++)
    3798                     outStr << "  "  << ctorNbr[i];
    3799                 outStr << std::endl << std::endl;
    3800                 osoutput->OSPrint(ENUM_OUTPUT_AREA_OSMatrix,
    3801                     ENUM_OUTPUT_LEVEL_detailed_trace, outStr.str());
    3802 #endif
    3803                 // Second pass --- retrieve nonzeros and store --- Note: Deep copy!
    3804                 int l, n;
    3805 
    3806                 for (int i=0; i < numberOfRows; i++)
    3807                 {
    3808                     if (location[i] >= 0)
    3809                     {
    3810                         l = location[i];
    3811                         n =  ctorNbr[i];
    3812                         expandedMatrixInColumnMajorForm->index[nz] = tempExpansion[n]->index[l];
    3813 
    3814                         // If the constructors differ in type, we convert to the most general type
    3815                         switch (inferredType)
    3816                         {
    3817                             // the first three types are minimal types, so no conversion is necessary,
    3818                             // and copying is much simpler as well
    3819                             case ENUM_MATRIX_TYPE_constant:
    3820                                 ((ConstantMatrixValues*)
    3821                                         expandedMatrixInColumnMajorForm->value)->el[nz]
    3822                                     = ((ConstantMatrixValues*) //((ConstantMatrixElements*)
    3823                                         tempExpansion[n]/*)*/->value)->el[l];
    3824                                 break;
    3825 
    3826                             case ENUM_MATRIX_TYPE_varReference:
    3827                                 ((VarReferenceMatrixValues*) ((VarReferenceMatrixElements*)
    3828                                         expandedMatrixInColumnMajorForm)->value)->el[nz]
    3829                                     = ((VarReferenceMatrixValues*) //((VarReferenceMatrixElements*)
    3830                                         tempExpansion[n]/*)*/->value)->el[l];
    3831                                 break;
    3832 
    3833                             case ENUM_MATRIX_TYPE_objReference:
    3834                                 ((ObjReferenceMatrixValues*) ((ObjReferenceMatrixElements*)
    3835                                         expandedMatrixInColumnMajorForm)->value)->el[nz]
    3836                                     = ((ObjReferenceMatrixValues*) //((ObjReferenceMatrixElements*)
    3837                                         tempExpansion[n]/*)*/->value)->el[l];
    3838                                 break;
    3839 
    3840                             // conReference is minimal, but the copying is a little more complicated
    3841                             case ENUM_MATRIX_TYPE_conReference:
    3842                                 ((ConReferenceMatrixValues*)
    3843                                         expandedMatrixInColumnMajorForm->value)->el[nz] =
    3844                                     new ConReferenceMatrixElement();
    3845                                 if (tempExpansion[n]->matrixType == ENUM_MATRIX_TYPE_conReference)
    3846                                 {
    3847                                     ((ConReferenceMatrixValues*) ((ConReferenceMatrixElements*)
    3848                                         expandedMatrixInColumnMajorForm)->value)->el[nz]->deepCopyFrom(
    3849                                             ((ConReferenceMatrixValues*)
    3850                                                                 tempExpansion[n]->value)->el[l]);
    3851                                 }
    3852                                 else
    3853                                     throw ErrorClass ("undefined matrix element conversion");
    3854                                 break;
    3855 
    3856                             // The other types may require conversion and more elaborate copying
    3857                             // First, complexConstant. The only legal conversion is from (real) constant
    3858                             case ENUM_MATRIX_TYPE_complexConstant:
    3859 
    3860                                 if (tempExpansion[n]->matrixType == ENUM_MATRIX_TYPE_complexConstant)
    3861                                 {
    3862                                     std::complex<double> (((ComplexMatrixValues*)
    3863                                             expandedMatrixInColumnMajorForm->value)->el[nz]) = 
    3864                                         ((ComplexMatrixValues*)tempExpansion[n]->value)->el[l]; 
    3865                                 }
    3866                                 else if (tempExpansion[n]->matrixType == ENUM_MATRIX_TYPE_constant)
    3867                                 {
    3868                                     std::complex<double> (((ComplexMatrixValues*)
    3869                                             expandedMatrixInColumnMajorForm->value)->el[nz]) = 
    3870                                         convertToComplexMatrixElement(((ConstantMatrixElements*)
    3871                                                                         tempExpansion[n])->value->el[l]); 
    3872 std::cout << "complex matrix value = " << ((ComplexMatrixValues*)
    3873                                             expandedMatrixInColumnMajorForm->value)->el[nz] << std::endl;
    3874                                 }
    3875                                 else
    3876                                     throw ErrorClass ("undefined matrix element conversion");
    3877                                 break;
    3878 
    3879                             case ENUM_MATRIX_TYPE_linear:
    3880                                 ((LinearMatrixValues*)
    3881                                     expandedMatrixInColumnMajorForm->value)->el[nz]
    3882                                         = new LinearMatrixElement();
    3883                                 switch (tempExpansion[n]->matrixType)
    3884                                 {
    3885                                     // linear elements do not have to be converted
    3886                                     case ENUM_MATRIX_TYPE_linear:
    3887                                         ((LinearMatrixValues*)expandedMatrixInColumnMajorForm->value)
    3888                                             ->el[nz]->deepCopyFrom(((LinearMatrixValues*)
    3889                                                                     tempExpansion[n]->value)->el[l]);
    3890                                         break;
    3891 
    3892                                     // legal conversions: constant, varReference
    3893                                     case ENUM_MATRIX_TYPE_constant:
    3894                                         ((LinearMatrixValues*)
    3895                                              expandedMatrixInColumnMajorForm->value)->el[nz]->constant =
    3896                                                 ((ConstantMatrixValues*)tempExpansion[n]->value)->el[l];
    3897                                         break;
    3898 
    3899                                     case ENUM_MATRIX_TYPE_varReference:
    3900                                         ((LinearMatrixValues*)expandedMatrixInColumnMajorForm
    3901                                                         ->value)->el[nz]->numberOfVarIdx = 1;
    3902                                         ((LinearMatrixValues*)expandedMatrixInColumnMajorForm
    3903                                                         ->value)->el[nz]->varIdx =
    3904                                             new LinearMatrixElementTerm*[1];
    3905                                         ((LinearMatrixValues*)expandedMatrixInColumnMajorForm
    3906                                                         ->value)->el[nz]->varIdx[0] =
    3907                                             new LinearMatrixElementTerm();
    3908                                         ((LinearMatrixValues*)expandedMatrixInColumnMajorForm
    3909                                                         ->value)->el[nz]->varIdx[0]->idx =
    3910 //                                            ((VarReferenceMatrixElements*)tempExpansion[n])->value->el[l];
    3911                                             ((VarReferenceMatrixValues*)tempExpansion[n]->value)->el[l];
    3912                                         ((LinearMatrixValues*)expandedMatrixInColumnMajorForm
    3913                                                         ->value)->el[nz]->varIdx[0]->coef = 0;
    3914                                         break;
    3915 
    3916                                     // other conversion are illegal
    3917                                     default: throw ErrorClass ("undefined matrix element conversion");
    3918                                         break;
    3919                                 }//end switch (tempExpansion[n]->matrixType)
    3920                                 break;
    3921 
    3922                             case ENUM_MATRIX_TYPE_mixedRowReference:
    3923                                 ((ConReferenceMatrixValues*)
    3924                                     expandedMatrixInColumnMajorForm->value)->el[nz]
    3925                                         = new ConReferenceMatrixElement();
    3926                                 switch (tempExpansion[n]->matrixType)
    3927                                 {
    3928                                     // elements with constraint references do not have to be converted
    3929                                     case ENUM_MATRIX_TYPE_mixedRowReference:
    3930                                     case ENUM_MATRIX_TYPE_conReference:
    3931                                         ((ConReferenceMatrixValues*)
    3932                                             expandedMatrixInColumnMajorForm->value)->el[nz]
    3933                                                 ->deepCopyFrom(((ConReferenceMatrixValues*)
    3934                                                                 tempExpansion[n]->value)->el[l]);
    3935                                         break;
    3936 
    3937                                     // only other legal possibility: objective references
    3938                                     case ENUM_MATRIX_TYPE_objReference:
    3939                                         ((ConReferenceMatrixValues*)
    3940                                             expandedMatrixInColumnMajorForm->value)->el[nz]
    3941                                                 = new ConReferenceMatrixElement();
    3942                                         ((ConReferenceMatrixValues*)
    3943                                             expandedMatrixInColumnMajorForm->value)->el[nz]->conReference
    3944                                                 = ((ObjReferenceMatrixValues*)
    3945                                                                 tempExpansion[n]->value)->el[l];
    3946                                         break;
    3947 
    3948                                     default: throw ErrorClass ("undefined matrix element conversion");
    3949                                         break;
    3950                                 }
    3951                                 break;
    3952 
    3953                             case ENUM_MATRIX_TYPE_realValuedExpressions:
    3954                             {
    3955                                 switch (tempExpansion[n]->matrixType)
    3956                                 {
    3957                                     case ENUM_MATRIX_TYPE_constant:
    3958                                         ((RealValuedExpressionArray*)
    3959                                                 expandedMatrixInColumnMajorForm->value)->el[nz]
    3960                                             = convertToRealExpressionTree(((ConstantMatrixValues*)
    3961                                                                         tempExpansion[n]->value)->el[l]); 
    3962                                         break;
    3963 
    3964                                     case ENUM_MATRIX_TYPE_varReference:
    3965                                         ((RealValuedExpressionArray*)
    3966                                                 expandedMatrixInColumnMajorForm->value)->el[nz]
    3967                                             = convertToRealExpressionTree(((VarReferenceMatrixValues*)
    3968                                                                    tempExpansion[n]->value)->el[l], true);
    3969                                         break;
    3970 
    3971                                     case ENUM_MATRIX_TYPE_realValuedExpressions:
    3972                                     {
    3973                                         ((RealValuedExpressionArray*)
    3974                                                 expandedMatrixInColumnMajorForm->value)->el[nz]
    3975                                             = ((RealValuedExpressionArray*)tempExpansion[n]
    3976                                                 ->value)->el[l]->cloneExpressionTree();
    3977                                         break;
    3978                                     }
    3979 
    3980                                     case ENUM_MATRIX_TYPE_linear:
    3981                                         ((RealValuedExpressionArray*)
    3982                                                 expandedMatrixInColumnMajorForm->value)->el[nz]
    3983                                             = convertToRealExpressionTree(((LinearMatrixValues*)
    3984                                                                         tempExpansion[n]->value)->el[l]); 
    3985                                         break;
    3986 
    3987                                     case ENUM_MATRIX_TYPE_objReference:
    3988                                         throw ErrorClass("OSnLNodeObjective not implemented yet");
    3989                                         break;
    3990 
    3991                                     case ENUM_MATRIX_TYPE_conReference:
    3992                                         throw ErrorClass("OSnLNodeConstraint not implemented yet");
    3993                                         break;
    3994 
    3995                                     case ENUM_MATRIX_TYPE_mixedRowReference:
    3996                                         throw ErrorClass("relevant OSnLNodes not implemented yet");
    3997                                         break;
    3998 
    3999                                     case ENUM_MATRIX_TYPE_complexConstant:
    4000                                     case ENUM_MATRIX_TYPE_complexValuedExpressions:
    4001                                         throw ErrorClass("improper conversion of complex-valued elements");
    4002                                         break;
    4003 
    4004                                     default: throw ErrorClass ("undefined matrix element conversion");
    4005                                         break;
    4006                                 }
    4007                                 break;
    4008                             }// end case realValuedExpressions
    4009 
    4010                             case ENUM_MATRIX_TYPE_complexValuedExpressions:
    4011                             {
    4012                                 ComplexValuedExpressionTree* temp = new ComplexValuedExpressionTree();
    4013 
    4014                                 switch (tempExpansion[n]->matrixType)
    4015                                 {
    4016                                     case ENUM_MATRIX_TYPE_complexValuedExpressions:
    4017                                     {
    4018                                         temp->m_treeRoot
    4019                                             = ((ComplexValuedExpressionArray*)tempExpansion[n]
    4020                                                 ->value)->el[l]->m_treeRoot->cloneExprNode();
    4021                                         break;
    4022                                     }
    4023 
    4024                                     case ENUM_MATRIX_TYPE_constant:
    4025                                     {
    4026                                         temp->m_treeRoot = new OSnLCNodeNumber();
    4027                                         double tempVal = ((ConstantMatrixValues*)
    4028                                                             tempExpansion[n]->value)->el[l];
    4029                                         ((OSnLCNodeNumber*) temp->m_treeRoot)->setValue(tempVal, 0.0);
    4030                                         break;
    4031                                     }
    4032 
    4033                                     case ENUM_MATRIX_TYPE_complexConstant:
    4034                                     {
    4035                                         temp->m_treeRoot = new OSnLCNodeNumber();
    4036                                         std::complex<double> tempVal
    4037                                             = ((ComplexMatrixValues*) tempExpansion[n]->value)->el[l];
    4038                                         ((OSnLCNodeNumber*) temp->m_treeRoot)->setValue(tempVal);
    4039                                         break;
    4040                                     }
    4041 
    4042                                     case ENUM_MATRIX_TYPE_varReference:
    4043                                     {
    4044                                         temp->m_treeRoot = new OSnLCNodeCreate();
    4045                                         temp->m_treeRoot->m_mChildren[0] = new OSnLNodeVariable();
    4046                                         temp->m_treeRoot->m_mChildren[1] = new OSnLNodeNumber();
    4047                                         ((OSnLNodeVariable*)temp->m_treeRoot->m_mChildren[0])->idx
    4048                                             = ((VarReferenceMatrixValues*)tempExpansion[n]->value)->el[l];
    4049                                         ((OSnLNodeNumber*)temp->m_treeRoot->m_mChildren[1])->value  = 0.0;
    4050                                         break;
    4051                                     }
    4052 
    4053                                     case ENUM_MATRIX_TYPE_realValuedExpressions:
    4054                                     {
    4055                                         temp->m_treeRoot = new OSnLCNodeCreate();
    4056                                         temp->m_treeRoot->m_mChildren[1] = new OSnLNodeNumber();
    4057                                         ((OSnLNodeNumber*)temp->m_treeRoot->m_mChildren[1])->value  = 0.0;
    4058 
    4059                                         temp->m_treeRoot->m_mChildren[0]
    4060                                             = ((RealValuedExpressionArray*)tempExpansion[n]
    4061                                                 ->value)->el[l]->m_treeRoot->cloneExprNode();
    4062                                         break;
    4063                                     }
    4064 
    4065                                     // the hardest conversion: linear expressions
    4066                                     case ENUM_MATRIX_TYPE_linear:
    4067                                     {
    4068                                         temp->m_treeRoot = new OSnLCNodeCreate();
    4069                                         temp->m_treeRoot->m_mChildren[1] = new OSnLNodeNumber();
    4070                                         ((OSnLNodeNumber*)temp->m_treeRoot->m_mChildren[1])->value = 0.0;
    4071 
    4072                                         temp->m_treeRoot->m_mChildren[0] = new OSnLNodeVariable();
    4073                                         ((OSnLNodeVariable*)temp->m_treeRoot->m_mChildren[0])->idx
    4074                                             = ((VarReferenceMatrixValues*)tempExpansion[n]->value)->el[l];
    4075 
    4076                                         int nn = ((LinearMatrixElements*)
    4077                                                   m_mChildren[n])->value->el[l]->numberOfVarIdx;
    4078                                         bool haveConstant;
    4079 
    4080                                         if (nn == 0)
    4081                                         {
    4082                                             temp->m_treeRoot->m_mChildren[0] = new OSnLNodeNumber();
    4083                                             ((OSnLNodeNumber*)
    4084                                                 temp->m_treeRoot->m_mChildren[1])->value = 0.0;
    4085                                         }
    4086                                         else
    4087                                         {
    4088                                             if (((LinearMatrixElements*)
    4089                                                   tempExpansion[n])->value->el[l]->constant == 0)
    4090                                             {
    4091                                                 haveConstant = false;
    4092                                                 temp->m_treeRoot->m_mChildren[0] = new OSnLNodeSum();
    4093                                                 temp->m_treeRoot->m_mChildren[0]->m_mChildren
    4094                                                     = new ExprNode*[nn];
    4095                                                 temp->m_treeRoot->m_mChildren[0]->inumberOfChildren = nn;
    4096                                             }
    4097                                             else
    4098                                             {
    4099                                                 haveConstant = true;
    4100                                                 temp->m_treeRoot->m_mChildren[0] = new OSnLNodeSum();
    4101                                                 temp->m_treeRoot->m_mChildren[0]->m_mChildren
    4102                                                     = new ExprNode*[nn+1];
    4103                                                 temp->m_treeRoot->m_mChildren[0]->inumberOfChildren = nn+1;
    4104                                             }
    4105 
    4106                                             for (int ii=0; ii<nn; ii++)
    4107                                             {
    4108                                                 temp->m_treeRoot->m_mChildren[0]->m_mChildren[ii]
    4109                                                     = new OSnLNodeVariable();
    4110                                                 ((OSnLNodeVariable*) temp->m_treeRoot
    4111                                                             ->m_mChildren[0]->m_mChildren[ii])->idx
    4112                                                     = ((LinearMatrixValues*)
    4113                                                         tempExpansion[n]->value)->el[l]->varIdx[ii]->idx;
    4114                                                 ((OSnLNodeVariable*) temp->m_treeRoot
    4115                                                             ->m_mChildren[0]->m_mChildren[ii])->coef
    4116                                                     = ((LinearMatrixValues*)
    4117                                                         tempExpansion[n]->value)->el[l]->varIdx[ii]->coef;
    4118                                             }
    4119 
    4120                                             if (haveConstant)
    4121                                             {
    4122                                                 temp->m_treeRoot->m_mChildren[0]->m_mChildren[nn]
    4123                                                     = new OSnLNodeNumber();
    4124                                                 ((OSnLNodeNumber*) temp->m_treeRoot
    4125                                                      ->m_mChildren[0]->m_mChildren[nn])->value
    4126                                                     = ((LinearMatrixValues*)
    4127                                                        tempExpansion[n]->value)->el[l]->constant;
    4128                                             }
    4129                                         }
    4130                                         break;
    4131                                     }
    4132 
    4133                                         case ENUM_MATRIX_TYPE_objReference:
    4134                                             throw ErrorClass("OSnLNodeObjective not implemented yet");
    4135                                             break;
    4136 
    4137                                         case ENUM_MATRIX_TYPE_conReference:
    4138                                             throw ErrorClass("OSnLNodeConstraint not implemented yet");
    4139                                             break;
    4140 
    4141                                         case ENUM_MATRIX_TYPE_mixedRowReference:
    4142                                             throw ErrorClass("relevant OSnLNodes not implemented yet");
    4143                                             break;
    4144 
    4145                                         default:
    4146                                             throw ErrorClass("undefined matrix element conversion");
    4147                                             break;
    4148 
    4149                                     }
    4150                                     ((ComplexValuedExpressionArray*)
    4151                                         expandedMatrixInColumnMajorForm->value)->el[nz] = temp;
    4152                                 break;
    4153                             }// end case complexValuedExpressions
    4154 
    4155                             case ENUM_MATRIX_TYPE_string:
    4156                             {
    4157                                 outStr.str("");
    4158                                 outStr.clear();
    4159 
    4160                                 switch (tempExpansion[n]->matrixType)
    4161                                 {
    4162                                     case ENUM_MATRIX_TYPE_constant:
    4163                                         outStr << os_dtoa_format(((ConstantMatrixValues*)
    4164                                                        tempExpansion[n]->value)->el[l]);
    4165                                         break;
    4166 
    4167                                     case ENUM_MATRIX_TYPE_complexConstant:
    4168                                         outStr << "(" << os_dtoa_format(((ComplexMatrixValues*)
    4169                                                             tempExpansion[n]->value)->el[l].real());
    4170                                         outStr << "," << os_dtoa_format(((ComplexMatrixValues*)
    4171                                                             tempExpansion[n]->value)->el[l].imag()) << ")";
    4172                                         break;
    4173 
    4174                                     case ENUM_MATRIX_TYPE_varReference:
    4175                                         outStr << "x_"
    4176                                                << ((VarReferenceMatrixValues*)
    4177                                                        tempExpansion[n]->value)->el[l];
    4178                                         break;
    4179 
    4180                                     case ENUM_MATRIX_TYPE_objReference:
    4181                                         outStr << "o_"
    4182                                                << ((ObjReferenceMatrixValues*)
    4183                                                        tempExpansion[n]->value)->el[l];
    4184                                         break;
    4185 
    4186                                     case ENUM_MATRIX_TYPE_conReference:
    4187                                         outStr << "c_"
    4188                                                << ((ConReferenceMatrixValues*)
    4189                                                        tempExpansion[n]->value)->el[l]->conReference
    4190                                                << "."
    4191                                                << returnConReferenceValueTypeString(
    4192                                                     ((ConReferenceMatrixValues*)
    4193                                                        tempExpansion[n]->value)->el[l]->valueType);
    4194                                         break;
    4195 
    4196                                     case ENUM_MATRIX_TYPE_mixedRowReference:
    4197                                     {
    4198                                         int temp = ((ConReferenceMatrixValues*)
    4199                                                        tempExpansion[n]->value)->el[l]->conReference;
    4200                                         if (temp < 0)
    4201                                             outStr << "o_"
    4202                                                    << temp;
    4203                                         else
    4204                                             outStr << "c_"
    4205                                                    << temp
    4206                                                    << "."
    4207                                                    << returnConReferenceValueTypeString(
    4208                                                        ((ConReferenceMatrixValues*)
    4209                                                            tempExpansion[n]->value)->el[l]->valueType);
    4210                                         break;
    4211                                     }
    4212 
    4213                                     case ENUM_MATRIX_TYPE_string:
    4214                                         outStr << ((StringValuedMatrixValues*)
    4215                                                        tempExpansion[n]->value)->el[l];
    4216                                         break;
    4217 
    4218                                     case ENUM_MATRIX_TYPE_linear:
    4219                                     {
    4220                                         LinearMatrixElement* temp =
    4221                                             ((LinearMatrixValues*)tempExpansion[n]->value)->el[l];
    4222 
    4223                                         if (temp->constant < 0.0 || temp->constant > 0.0)
    4224                                         {
    4225                                             outStr << os_dtoa_format(temp->constant);
    4226                                         }
    4227 
    4228                                         if (temp->numberOfVarIdx > 0)
    4229                                         {
    4230                                             if (temp->varIdx[0]->coef >= 0)
    4231                                             {
    4232                                                 if (temp->constant < 0.0 || temp->constant > 0.0)
    4233                                                     outStr << " + ";
    4234                                                 else
    4235                                                     outStr << " - ";
    4236                                             }
    4237                                             else
    4238                                                 outStr << "-";
    4239                                             if (temp->varIdx[0]->coef < 1 || temp->varIdx[0]->coef > 1 )
    4240                                                 outStr << os_dtoa_format(abs(temp->varIdx[0]->coef)) << "*";
    4241                                             outStr << "x_" << temp->varIdx[0]->idx;
    4242                                         }
    4243 
    4244                                         for (int j=1; j<temp->numberOfVarIdx; i++)
    4245                                         {
    4246                                             if (temp->varIdx[j]->coef >= 0)
    4247                                                 outStr << " + ";
    4248                                             else
    4249                                                 outStr << " - ";
    4250                                             if (temp->varIdx[j]->coef < 1 || temp->varIdx[j]->coef > 1 )
    4251                                                 outStr << os_dtoa_format(abs(temp->varIdx[j]->coef)) << "*";
    4252                                             outStr << "x_" << temp->varIdx[j]->idx;
    4253                                         }
    4254                                         break;
    4255                                     }
    4256 
    4257                                     case ENUM_MATRIX_TYPE_realValuedExpressions:
    4258                                     {
    4259                                         std::vector<ExprNode*> postfixVec;
    4260                                         if ( ((RealValuedExpressionArray*)
    4261                                                 tempExpansion[n]->value)->el[l] != NULL)
    4262                                         {
    4263                                             postfixVec
    4264                                                 = ((RealValuedExpressionArray*) tempExpansion[n]->value)
    4265                                                     ->el[l]->getPostfixFromExpressionTree();
    4266                                             outStr << getExpressionTreeAsInfixString(postfixVec);
    4267                                         }
    4268                                         else
    4269                                             outStr.str() = "";
    4270                                         break;
    4271                                     }
    4272 
    4273                                     case ENUM_MATRIX_TYPE_complexValuedExpressions:
    4274                                     {
    4275                                         std::vector<ExprNode*> postfixVec;
    4276                                         if ( ((ComplexValuedExpressionArray*)
    4277                                                 tempExpansion[n]->value)->el[l] != NULL)
    4278                                         {
    4279                                             postfixVec
    4280                                                 = ((ComplexValuedExpressionArray*) tempExpansion[n]->value)
    4281                                                     ->el[l]->getPostfixFromExpressionTree();
    4282                                             outStr << getExpressionTreeAsInfixString(postfixVec);
    4283                                         }
    4284                                         else
    4285                                             outStr.str() = "";
    4286                                         break;
    4287                                     }
    4288 
    4289                                     default:
    4290                                         throw ErrorClass("undefined matrix element conversion");
    4291                                     break;
    4292 
    4293                                 }// end switch (tempExpansion[n]->matrixType)
    4294 
    4295                                 ((StringValuedMatrixValues*)
    4296                                     expandedMatrixInColumnMajorForm->value)->el[nz] = outStr.str();
    4297                                 break;
    4298                             }
    4299 
    4300                             case ENUM_MATRIX_TYPE_empty:
    4301                                 throw ErrorClass("Matrix should be empty, but is not!!!");
    4302                                 break;
    4303 
    4304                             default :
    4305                                 throw ErrorClass("Unsupported matrix type");
    4306                                 break;
    4307                         }// end switch (inferredType)
    4308 
    4309                         nz++;
    4310 
    4311                         // "turn out the lights" for the next column
    4312                         location[i] = -1;
    4313                          ctorNbr[i] = -1;
    4314                     }// end if (location[i] >= 0)
    4315                 }// end for (int i=0; i < numberOfRows; i++)
    4316 
    4317                 expandedMatrixInColumnMajorForm->start[j+1] = nz;
    4318             }
    4319 
    4320             expandedMatrixInColumnMajorForm->valueSize = nz;
    4321 
    4322             delete [] location;
    4323             delete []  ctorNbr;
    4324 
    4325             expandedMatrixInColumnMajorForm->printMatrix();
    4326 
    4327             return expandedMatrixInColumnMajorForm;
    4328 
    4329 
    4330 
    4331 /*
    4332         (basematrix plus) elements should be ok
    4333         maybe transformation (product) plus elements
    4334         others: throw error
    4335 */
    4336             throw ErrorClass("Multiple constructors not yet implemented in getMatrixCoefficientsInRowMajor()");
    4337         }
    4338         return NULL;
    4339     }
    4340     catch(const ErrorClass& eclass)
    4341     {
    4342         // clear memory if already allocated
    4343         if (expandedMatrixInRowMajorForm != NULL)
    4344             delete expandedMatrixInRowMajorForm;
    4345         expandedMatrixInRowMajorForm = NULL;
    4346         throw ErrorClass( eclass.errormsg);
    4347     }
    4348 }// end of getMatrixCoefficientsInRowMajor
    43491454
    43501455bool MatrixType::expandElements(bool rowMajor)
     
    43541459
    43551460
    4356 bool MatrixType::printExpandedMatrix(bool rowMajor_)
    4357 {
     1461bool MatrixType::printExpandedMatrix(int idx)
     1462{
     1463#ifndef NDEBUG
     1464    osoutput->OSPrint(ENUM_OUTPUT_AREA_OSMatrix, ENUM_OUTPUT_LEVEL_trace,
     1465        "Inside printExpandedMatrix()");
     1466#endif
    43581467    std::ostringstream outStr;
    43591468    try
    43601469    {
    4361         GeneralSparseMatrix* tmp;
    4362 
    4363         if (rowMajor_)
    4364         {
    4365             if (expandedMatrixInRowMajorForm == NULL)
    4366                 return false;
    4367             tmp = expandedMatrixInRowMajorForm;
    4368         }
    4369         else
    4370         {
    4371             if (expandedMatrixInColumnMajorForm == NULL)
    4372                 return false;
    4373             tmp = expandedMatrixInColumnMajorForm;
    4374         }
    4375        
     1470        if (idx < 0 || idx >= expandedMatrixByElements.size())
     1471            throw ErrorClass("Invalid index value for printExpandedMatrix()");
     1472
     1473        GeneralSparseMatrix* tmp = expandedMatrixByElements[idx];
     1474
    43761475        outStr << std::endl;
    43771476
     
    43911490        outStr << "number of columns  " << numberOfColumns << std::endl;
    43921491        outStr << "number of nonzeros " << tmp->valueSize << std::endl;
    4393         outStr << "type of nonzeros   " << returnMatrixTypeString(tmp->matrixType) << std::endl;
     1492        outStr << "type of nonzeros   " << returnMatrixTypeString(tmp->valueType) << std::endl;
    43941493        outStr << "symmetry           " << returnMatrixSymmetryString(symmetry) << std::endl;
    43951494
    43961495        outStr << std::endl << "These matrix arrays are organized ";             
    4397         if (rowMajor_)
     1496        if (tmp->isRowMajor)
    43981497            outStr << "by rows" << std::endl;
    43991498        else
     
    44111510
    44121511        outStr << std::endl << "values: ";
    4413         if (tmp->matrixType == ENUM_MATRIX_TYPE_constant)
     1512        if (tmp->valueType == ENUM_MATRIX_TYPE_constant)
    44141513        {
    44151514            for (int i=0; i < tmp->valueSize; i++)
     
    44171516            outStr << std::endl;
    44181517        }
    4419         else if (tmp->matrixType == ENUM_MATRIX_TYPE_varReference)
     1518        else if (tmp->valueType == ENUM_MATRIX_TYPE_varReference)
    44201519        {
    44211520            for (int i=0; i < tmp->valueSize; i++)
     
    44231522            outStr << std::endl;
    44241523        }
    4425         else if (tmp->matrixType == ENUM_MATRIX_TYPE_objReference)
     1524        else if (tmp->valueType == ENUM_MATRIX_TYPE_objReference)
    44261525        {
    44271526            for (int i=0; i < tmp->valueSize; i++)
     
    44291528            outStr << std::endl;
    44301529        }
    4431         else if (tmp->matrixType == ENUM_MATRIX_TYPE_conReference)
     1530        else if (tmp->valueType == ENUM_MATRIX_TYPE_conReference)
    44321531        {
    44331532            for (int i=0; i < tmp->valueSize; i++)
     
    44351534            outStr << std::endl;
    44361535        }
    4437         else if (tmp->matrixType == ENUM_MATRIX_TYPE_realValuedExpressions)
     1536        else if (tmp->valueType == ENUM_MATRIX_TYPE_realValuedExpressions)
    44381537        {
    44391538            std::vector<ExprNode*> postfixVec;
     
    44511550            outStr << std::endl;
    44521551        }
    4453         else if (tmp->matrixType == ENUM_MATRIX_TYPE_complexValuedExpressions)
     1552        else if (tmp->valueType == ENUM_MATRIX_TYPE_complexValuedExpressions)
    44541553        {
    44551554            std::vector<ExprNode*> postfixVec;
     
    44671566            outStr << std::endl;
    44681567        }
    4469         else if (tmp->matrixType == ENUM_MATRIX_TYPE_linear)
     1568        else if (tmp->valueType == ENUM_MATRIX_TYPE_linear)
    44701569        {
    44711570            outStr << std::endl;
     
    45051604        throw ErrorClass( eclass.errormsg);
    45061605    }
    4507 }// end of printExpandedMatrix
    4508 
     1606}// end of printExpandedMatrix(int idx)
     1607
     1608#if 0
    45091609GeneralSparseMatrix* MatrixType::convertToOtherMajor(bool isColumnMajor)
    45101610{
    45111611#ifndef NDEBUG
    4512     osoutput->OSPrint(ENUM_OUTPUT_AREA_OSInstance, ENUM_OUTPUT_LEVEL_trace, "Inside convertToOtherMajor()");
     1612    osoutput->OSPrint(ENUM_OUTPUT_AREA_OSMatrix, ENUM_OUTPUT_LEVEL_trace, "Inside convertToOtherMajor()");
    45131613#endif
    45141614    GeneralSparseMatrix* refMtx;
     
    45281628    int iStartSize = isColumnMajor ? numberOfRows+1 : numberOfColumns+1;
    45291629    GeneralSparseMatrix *matrix
    4530         = new GeneralSparseMatrix( !isColumnMajor, iStartSize, refMtx->valueSize, refMtx->matrixType);
     1630        = new GeneralSparseMatrix( !isColumnMajor, numberOfRows, numberOfColumns,
     1631                                   iStartSize, refMtx->valueSize, refMtx->valueType);
    45311632
    45321633    int i,j, iTemp;
     
    45651666    // loop over columns
    45661667    // this is a bit tedious, since different types of elements need to be treated differently
    4567     if ( refMtx->matrixType == ENUM_MATRIX_TYPE_constant)
     1668    if ( refMtx->valueType == ENUM_MATRIX_TYPE_constant)
    45681669    {
    45691670        matrix->value = new ConstantMatrixValues();
     
    45831684        }
    45841685    }
    4585     else if (refMtx->matrixType == ENUM_MATRIX_TYPE_varReference)
     1686    else if (refMtx->valueType == ENUM_MATRIX_TYPE_varReference)
    45861687    {
    45871688        matrix->value = new VarReferenceMatrixValues();
     
    46011702        }
    46021703    }
    4603     else if (refMtx->matrixType == ENUM_MATRIX_TYPE_linear)
     1704    else if (refMtx->valueType == ENUM_MATRIX_TYPE_linear)
    46041705    {
    46051706        matrix->value = new LinearMatrixValues();
     
    46211722        }
    46221723    }
    4623     else if (refMtx->matrixType == ENUM_MATRIX_TYPE_realValuedExpressions)
     1724    else if (refMtx->valueType == ENUM_MATRIX_TYPE_realValuedExpressions)
    46241725    {
    46251726        matrix->value = new RealValuedExpressionArray();
     
    46421743        }
    46431744    }
    4644     else if (refMtx->matrixType == ENUM_MATRIX_TYPE_complexValuedExpressions)
     1745    else if (refMtx->valueType == ENUM_MATRIX_TYPE_complexValuedExpressions)
    46451746    {
    46461747        matrix->value = new ComplexValuedExpressionArray();
     
    46631764        }
    46641765    }
    4665     else if (refMtx->matrixType == ENUM_MATRIX_TYPE_objReference)
     1766    else if (refMtx->valueType == ENUM_MATRIX_TYPE_objReference)
    46661767    {
    46671768        matrix->value = new ObjReferenceMatrixValues();
     
    46811782        }
    46821783    }
    4683     else if (refMtx->matrixType == ENUM_MATRIX_TYPE_conReference)
     1784    else if (refMtx->valueType == ENUM_MATRIX_TYPE_conReference)
    46841785    {
    46851786        matrix->value = new