/home/coin/svn-release/OS-2.10.0/OS/src/OSCommonInterfaces/OSMatrix.h

Go to the documentation of this file.

/* $Id: OSMatrix.h 3172 2010-02-05 04:59:24Z Gassmann $ */
#ifndef OSMATRIX_H
#define OSMATRIX_H

#include "OSConfig.h"
#include "OSParameters.h"
#include "OSnLNode.h"
#include "OSExpressionTree.h"

#include <string>
#include <vector>


/*********************************************************************************
 *
 * This file contains a number of classes to represent a matrix
 * This construct is new to OS starting June 2014 (trunk version 4811)
 *
 *********************************************************************************/

class OSnLNode;
class OSnLMNode;
class ScalarExpressionTree;


class MatrixNode
{
public:
    ENUM_MATRIX_TYPE matrixType;

    ENUM_MATRIX_CONSTRUCTOR_TYPE nType;

    unsigned int inumberOfChildren;

    MatrixNode **m_mChildren;

    MatrixNode();

    virtual ~MatrixNode();

    virtual ENUM_MATRIX_CONSTRUCTOR_TYPE getNodeType();

    virtual ENUM_MATRIX_TYPE getMatrixType() = 0;

    virtual std::string getNodeName() = 0;

    virtual std::string getMatrixNodeInXML() = 0;

    std::vector<MatrixNode*> getPrefixFromNodeTree();

    /*
     * <p>
     * Called by getPrefixFromNodeTree().  
     * This method calls itself recursively and
     * generates a vector of pointers to MatrixNode in prefix
     * </p>
     * @param a pointer prefixVector to a vector of pointers of MatrixNodes
     * @return a vector of pointers to MatrixNode in prefix.
     */
    std::vector<MatrixNode*> preOrderMatrixNodeTraversal( std::vector<MatrixNode*> *prefixVector);

    std::vector<MatrixNode*> getPostfixFromNodeTree();

    std::vector<MatrixNode*> postOrderMatrixNodeTraversal( std::vector<MatrixNode*> *postfixVector);

    virtual MatrixNode *cloneMatrixNode() = 0;

    virtual bool alignsOnBlockBoundary(int firstRow, int firstColumn, int nRows, int nCols) = 0;

    virtual bool IsEqual(MatrixNode *that);

    bool setRandom(double density, bool conformant, int iMin, int iMax);

    bool deepCopyFrom(MatrixNode *that);
};//end MatrixNode


class MatrixConstructor : public MatrixNode
{
public:
    MatrixConstructor();

    virtual ~MatrixConstructor();

    //bool IsEqual(MatrixConstructor *that);

    //bool setRandom(double density, bool conformant, int iMin, int iMax);

    //bool deepCopyFrom(MatrixConstructor *that);
};//class MatrixConstructor


class MatrixElements: public MatrixConstructor
{
public:
    bool rowMajor;
 
    int numberOfValues;

    IntVector *start;

    IntVector *index;


    MatrixElements();
    virtual ~MatrixElements();

    bool getRowMajor();

    //virtual std::string getMatrixElementsInXML() = 0;

    bool IsEqual(MatrixElements *that);

#if 0

    bool setRandom(double density, bool conformant, int iMin, int iMax);

    bool deepCopyFrom(MatrixElements *that);
#endif
};//class MatrixElements


class MatrixElementValues
{
public:
    int numberOfEl;

    MatrixElementValues();
    virtual ~MatrixElementValues();

    //virtual std::string getMatrixValuesInXML() = 0;

    //bool IsEqual(MatrixElementValues *that);

    //bool setRandom(double density, bool conformant, int iMin, int iMax);

    virtual bool deepCopyFrom(MatrixElementValues *that);
};//class MatrixElementValues

// ------------------ concrete classes start here ------------------------------

class LinearMatrixElementTerm
{
public:
    int idx;
    double coef;

    LinearMatrixElementTerm();
    ~LinearMatrixElementTerm();

    bool IsEqual(LinearMatrixElementTerm *that);

    bool setRandom(double density, bool conformant, int iMin, int iMax);

    bool deepCopyFrom(LinearMatrixElementTerm *that);
};//class LinearMatrixElementTerm

class LinearMatrixElement
{
public:
    int numberOfVarIdx;
    double constant;

    LinearMatrixElementTerm** varIdx;

    LinearMatrixElement();
    ~LinearMatrixElement();

    bool IsEqual(LinearMatrixElement *that);

    bool setRandom(double density, bool conformant, int iMin, int iMax);

    bool deepCopyFrom(LinearMatrixElement *that);
};//class LinearMatrixElement


class ConReferenceMatrixElement
{
public:
    int conReference;

    ENUM_CONREFERENCE_VALUETYPE valueType;

    double value;

    ConReferenceMatrixElement();
    ~ConReferenceMatrixElement();

    bool IsEqual(ConReferenceMatrixElement *that);

    bool setRandom(double density, bool conformant, int iMin, int iMax);

    bool deepCopyFrom(ConReferenceMatrixElement *that);
};//class ConReferenceMatrixElement


class ConstantMatrixValues : public MatrixElementValues
{
public:
    double *el;

    ConstantMatrixValues();
    ~ConstantMatrixValues();

    //virtual ENUM_MATRIX_CONSTRUCTOR_TYPE getNodeType();

    //virtual ENUM_MATRIX_TYPE getMatrixType();

    //virtual std::string getNodeName();

    //virtual std::string getMatrixValuesInXML();

    bool IsEqual(ConstantMatrixValues *that);

    bool setRandom(double density, bool conformant, int iMin, int iMax);

    bool deepCopyFrom(ConstantMatrixValues *that);
};//class ConstantMatrixValues


class VarReferenceMatrixValues : public MatrixElementValues
{
public:
    int *el;

    VarReferenceMatrixValues();
    ~VarReferenceMatrixValues();

    bool IsEqual(VarReferenceMatrixValues *that);

    bool setRandom(double density, bool conformant, int iMin, int iMax);

    virtual bool deepCopyFrom(VarReferenceMatrixValues *that);
};//class VarReferenceMatrixValues


class LinearMatrixValues : public MatrixElementValues
{
public:
    LinearMatrixElement **el;     
    
    LinearMatrixValues();
    ~LinearMatrixValues();

    bool IsEqual(LinearMatrixValues *that);

    bool setRandom(double density, bool conformant, int iMin, int iMax);

    virtual bool deepCopyFrom(LinearMatrixValues *that);
};//class LinearMatrixValues


class GeneralMatrixValues : public MatrixElementValues
{
public:
    ScalarExpressionTree **el;

    GeneralMatrixValues();
    ~GeneralMatrixValues();

    bool IsEqual(GeneralMatrixValues *that);

    bool setRandom(double density, bool conformant, int iMin, int iMax);

    virtual bool deepCopyFrom(GeneralMatrixValues *that);
};//class GeneralMatrixValues


class ObjReferenceMatrixValues : public MatrixElementValues
{
public:
    int *el;

    ObjReferenceMatrixValues();
    ~ObjReferenceMatrixValues();

    bool IsEqual(ObjReferenceMatrixValues *that);

    bool setRandom(double density, bool conformant, int iMin, int iMax);

    virtual bool deepCopyFrom(ObjReferenceMatrixValues *that);
};//class ObjReferenceMatrixValues


class ConReferenceMatrixValues : public MatrixElementValues
{
public:
    ConReferenceMatrixElement **el;

    ConReferenceMatrixValues();
    ~ConReferenceMatrixValues();

    bool IsEqual(ConReferenceMatrixValues *that);

    bool setRandom(double density, bool conformant, int iMin, int iMax);

    virtual bool deepCopyFrom(ConReferenceMatrixValues *that);
};//class ConReferenceMatrixValues


class ConstantMatrixElements: public MatrixElements
{
public:
    ConstantMatrixValues *value;

    ConstantMatrixElements();
    ~ConstantMatrixElements();


    virtual ENUM_MATRIX_CONSTRUCTOR_TYPE getNodeType();

    virtual std::string getNodeName();

    virtual ENUM_MATRIX_TYPE getMatrixType();

    virtual std::string getMatrixNodeInXML();

    virtual bool alignsOnBlockBoundary(int firstRow, int firstColumn, int nRows, int nCols);

    virtual ConstantMatrixElements *cloneMatrixNode();

    bool IsEqual(ConstantMatrixElements *that);

    bool setRandom(double density, bool conformant, int iMin, int iMax);

    bool deepCopyFrom(ConstantMatrixElements *that);
};//class ConstantMatrixElements


class VarReferenceMatrixElements: public MatrixElements
{
public:
    VarReferenceMatrixValues *value;

    VarReferenceMatrixElements();
    ~VarReferenceMatrixElements();

    virtual ENUM_MATRIX_CONSTRUCTOR_TYPE getNodeType();

    virtual ENUM_MATRIX_TYPE getMatrixType();

    virtual std::string getNodeName();
    virtual std::string getMatrixNodeInXML();

    virtual bool alignsOnBlockBoundary(int firstRow, int firstColumn, int nRows, int nCols);

    virtual VarReferenceMatrixElements *cloneMatrixNode();

    bool IsEqual(VarReferenceMatrixElements *that);

    bool setRandom(double density, bool conformant, int iMin, int iMax);

    bool deepCopyFrom(VarReferenceMatrixElements *that);
};//class VarReferenceMatrixElements


class LinearMatrixElements: public MatrixElements
{
public:
    LinearMatrixValues *value;     

    LinearMatrixElements();
    ~LinearMatrixElements();


    virtual ENUM_MATRIX_CONSTRUCTOR_TYPE getNodeType();

    virtual ENUM_MATRIX_TYPE getMatrixType();

    virtual std::string getNodeName();
    virtual std::string getMatrixNodeInXML();

    virtual bool alignsOnBlockBoundary(int firstRow, int firstColumn, int nRows, int nCols);

    virtual LinearMatrixElements *cloneMatrixNode();

    bool IsEqual(LinearMatrixElements *that);

    bool setRandom(double density, bool conformant, int iMin, int iMax);

    bool deepCopyFrom(LinearMatrixElements *that);
};//class LinearMatrixElements


class GeneralMatrixElements: public MatrixElements
{
public:
    GeneralMatrixValues *value;

    GeneralMatrixElements();
    ~GeneralMatrixElements();


    virtual ENUM_MATRIX_CONSTRUCTOR_TYPE getNodeType();

    virtual ENUM_MATRIX_TYPE getMatrixType();

    virtual std::string getNodeName();
    virtual std::string getMatrixNodeInXML();

    virtual bool alignsOnBlockBoundary(int firstRow, int firstColumn, int nRows, int nCols);

    virtual GeneralMatrixElements *cloneMatrixNode();

    bool IsEqual(GeneralMatrixElements *that);

    bool setRandom(double density, bool conformant, int iMin, int iMax);

    bool deepCopyFrom(GeneralMatrixElements *that);
};//class GeneralMatrixElements


class ObjReferenceMatrixElements: public MatrixElements
{
public:
    ObjReferenceMatrixValues *value;

    ObjReferenceMatrixElements();
    ~ObjReferenceMatrixElements();


    virtual ENUM_MATRIX_CONSTRUCTOR_TYPE getNodeType();

    virtual ENUM_MATRIX_TYPE getMatrixType();

    virtual std::string getNodeName();

    virtual std::string getMatrixNodeInXML();

    virtual bool alignsOnBlockBoundary(int firstRow, int firstColumn, int nRows, int nCols);

    virtual ObjReferenceMatrixElements *cloneMatrixNode();

    bool IsEqual(ObjReferenceMatrixElements *that);

    bool setRandom(double density, bool conformant, int iMin, int iMax);

    bool deepCopyFrom(ObjReferenceMatrixElements *that);
};//class ObjReferenceMatrixElements


class ConReferenceMatrixElements: public MatrixElements
{
public:
    ConReferenceMatrixValues *value;

    ConReferenceMatrixElements();
    ~ConReferenceMatrixElements();


    virtual ENUM_MATRIX_CONSTRUCTOR_TYPE getNodeType();

    virtual ENUM_MATRIX_TYPE getMatrixType();

    virtual std::string getNodeName();

    virtual std::string getMatrixNodeInXML();

    virtual bool alignsOnBlockBoundary(int firstRow, int firstColumn, int nRows, int nCols);

    virtual ConReferenceMatrixElements *cloneMatrixNode();

    bool IsEqual(ConReferenceMatrixElements *that);

    bool setRandom(double density, bool conformant, int iMin, int iMax);

    bool deepCopyFrom(ConReferenceMatrixElements *that);
};//class ConReferenceMatrixElements


class MixedRowReferenceMatrixElements: public MatrixElements
{
public:
    ConReferenceMatrixValues *value;

    MixedRowReferenceMatrixElements();
    ~MixedRowReferenceMatrixElements();


    virtual ENUM_MATRIX_CONSTRUCTOR_TYPE getNodeType();

    virtual ENUM_MATRIX_TYPE getMatrixType();

    virtual std::string getNodeName();

    virtual std::string getMatrixNodeInXML();

    virtual bool alignsOnBlockBoundary(int firstRow, int firstColumn, int nRows, int nCols);

    virtual MixedRowReferenceMatrixElements *cloneMatrixNode();

    bool IsEqual(MixedRowReferenceMatrixElements *that);

    bool setRandom(double density, bool conformant, int iMin, int iMax);

    bool deepCopyFrom(MixedRowReferenceMatrixElements *that);
};//class MixedRowReferenceMatrixElements


class MatrixTransformation : public MatrixConstructor
{
public:
    OSnLMNode *transformation;

    ENUM_NL_EXPR_SHAPE shape;

    MatrixTransformation();
    ~MatrixTransformation();

    virtual ENUM_MATRIX_CONSTRUCTOR_TYPE getNodeType();

    virtual std::string getNodeName();


    virtual ENUM_MATRIX_TYPE getMatrixType();

    virtual std::string getMatrixNodeInXML();

    virtual bool alignsOnBlockBoundary(int firstRow, int firstColumn, int nRows, int nCols);

    virtual MatrixTransformation *cloneMatrixNode();

    bool IsEqual(MatrixTransformation *that);

    bool setRandom(double density, bool conformant, int iMin, int iMax);

    bool deepCopyFrom(MatrixTransformation *that);
};//class MatrixTransformation

//class MatrixBlock; //forward declaration

class MatrixBlocks : public MatrixConstructor
{
public:
    IntVector *colOffset;

    IntVector *rowOffset;

    MatrixBlocks();
    ~MatrixBlocks();

    virtual ENUM_MATRIX_CONSTRUCTOR_TYPE getNodeType();

    virtual std::string getNodeName();

    virtual ENUM_MATRIX_TYPE getMatrixType();

    virtual std::string getMatrixNodeInXML();

    virtual bool alignsOnBlockBoundary(int firstRow, int firstColumn, int nRows, int nCols) ;

    virtual MatrixBlocks *cloneMatrixNode();

    bool IsEqual(MatrixBlocks *that);

    bool setRandom(double density, bool conformant, int iMin, int iMax);

    bool deepCopyFrom(MatrixBlocks *that);
};//class MatrixBlocks


class BaseMatrix : public MatrixConstructor
{
public:
    int baseMatrixIdx;

    OSMatrix* baseMatrix;

    int targetMatrixFirstRow;
    int targetMatrixFirstCol;

    int baseMatrixStartRow;
    int baseMatrixStartCol;

    int baseMatrixEndRow;
    int baseMatrixEndCol;

    bool baseTranspose;

    double scalarMultiplier;

    BaseMatrix();
    ~BaseMatrix();

    virtual ENUM_MATRIX_CONSTRUCTOR_TYPE getNodeType();

    virtual std::string getNodeName();

    virtual ENUM_MATRIX_TYPE getMatrixType();

    virtual std::string getMatrixNodeInXML();

    virtual bool alignsOnBlockBoundary(int firstRow, int firstColumn, int nRows, int nCols) ;

    virtual BaseMatrix *cloneMatrixNode();

    bool IsEqual(BaseMatrix *that);

#if 0

    bool setRandom(double density, bool conformant, int iMin, int iMax);

    bool deepCopyFrom(BaseMatrix *that);
#endif
};//class BaseMatrix


class GeneralSparseMatrix
{
public:

    bool b_deleteStartArray;

    bool b_deleteIndexArray;

    bool b_deleteValueArray;

    bool isRowMajor;

    ENUM_MATRIX_SYMMETRY symmetry;

    int startSize;

    int valueSize;

    int* start;

    int* index;

    ENUM_MATRIX_TYPE vType;

    MatrixElementValues* value;

    GeneralSparseMatrix();

    GeneralSparseMatrix(bool isColumnMajor, int startSize, int valueSize, ENUM_MATRIX_TYPE type);

    ~GeneralSparseMatrix();

    bool display(int secondaryDim);

    bool isDiagonal(); 
}; //GeneralSparseMatrix


class ExpandedMatrixBlocks
{
public:
    bool bDeleteArrays;

    ENUM_MATRIX_TYPE vType;

    bool isRowMajor;

    int blockNumber;

    int* rowOffset;

    int* colOffset;

    int rowOffsetSize;
    int colOffsetSize;

    int* blockRows;

    int* blockColumns;

    GeneralSparseMatrix** blocks;

    ExpandedMatrixBlocks();

    ExpandedMatrixBlocks(bool isColumnMajor_, int startSize, int valueSize);

    ~ExpandedMatrixBlocks();

    bool display(int secondaryDim);

    GeneralSparseMatrix* getBlock(int rowIdx, int colIdx);

    bool isBlockDiagonal(); 
}; //ExpandedMatrixBlocks


class MatrixType : public MatrixNode
{
public:
    ENUM_MATRIX_SYMMETRY symmetry;

    ENUM_MATRIX_TYPE type;

    int numberOfRows;
    int numberOfColumns;

    GeneralSparseMatrix* ExpandedMatrixInRowMajorForm;
    GeneralSparseMatrix* ExpandedMatrixInColumnMajorForm;
    std::vector<ExpandedMatrixBlocks*> ExpandedMatrixByBlocks;

private:
    int* m_miRowPartition;

    int m_iRowPartitionSize;

    int* m_miColumnPartition;

    int m_iColumnPartitionSize;

    bool m_bHaveRowPartition; 

    bool m_bHaveColumnPartition; 

public:
    MatrixType();
    virtual ~MatrixType();


    //virtual bool isDiagonal();

    virtual bool alignsOnBlockBoundary(int firstRow, int firstColumn, int nRows, int nCols) ;

    bool matrixHasBase();
    bool matrixHasElements();
    bool matrixHasTransformations();
    bool matrixHasBlocks();
    int  getNumberOfElementConstructors();
    int  getNumberOfTransformationConstructors();
    int  getNumberOfBlocksConstructors();

    GeneralSparseMatrix* getMatrixCoefficientsInColumnMajor();
    GeneralSparseMatrix* getMatrixCoefficientsInRowMajor();
    GeneralSparseMatrix* getMatrixBlockInColumnMajorForm(int columnIdx, int rowIdx);

    bool printExpandedMatrix(bool rowMajor);

    int  getRowPartitionSize();

    int* getRowPartition();

    int  getColumnPartitionSize();

    int* getColumnPartition();


    virtual bool expandElements(bool rowMajor);

    GeneralSparseMatrix* convertToOtherMajor(bool isColumnMajor);

    bool processBlockPartition();

     virtual bool processBlocks(bool rowMajor, ENUM_MATRIX_SYMMETRY symmetry);

     virtual bool processBlocks(int* rowOffset, int rowOffsetSize, int* colOffset,
                                int colOffsetSize, bool rowMajor, ENUM_MATRIX_SYMMETRY symmetry);

    GeneralSparseMatrix* extractBlock(int firstrow, int firstcol, int lastrow, int lastcol,
                                      bool rowMajor, ENUM_MATRIX_SYMMETRY symmetry);

    ExpandedMatrixBlocks* getBlocks(int* rowPartition, int rowPartitionSize, 
                                    int* colPartition, int colPartitionSize, 
                                    bool rowMajor, bool appendToBlockArray);

    ExpandedMatrixBlocks* disassembleMatrix(int* rowPartition, int rowPartitionSize, 
                                    int* colPartition, int colPartitionSize, 
                                    bool rowMajor, ENUM_MATRIX_SYMMETRY symmetry);

    bool IsEqual(MatrixType *that);

    bool setRandom(double density, bool conformant, int iMin, int iMax);

    bool deepCopyFrom(MatrixType *that);
};// class MatrixType


class OSMatrix : public MatrixType
{
public:
    int idx;
    std::string name;

public:
    OSMatrix();
    ~OSMatrix();

    OSMatrix* createConstructorTreeFromPrefix(std::vector<MatrixNode*> mtxConstructorVec);

    virtual ENUM_MATRIX_CONSTRUCTOR_TYPE getNodeType();

    virtual std::string getNodeName();

    virtual ENUM_MATRIX_TYPE getMatrixType();

     //virtual bool processBlocks(int* rowOffset, int* colOffset,
     //                                 bool rowMajor, ENUM_MATRIX_SYMMETRY symmetry);

    virtual bool expandElements(bool rowMajor);

    virtual bool alignsOnBlockBoundary(int firstRow, int firstColumn, int nRows, int nCols) ;

    bool isBlockDiagonal();

    bool setMatrix(std::string name, int numberOfRows, int numberOfColumns, 
                   ENUM_MATRIX_SYMMETRY symmetry, ENUM_MATRIX_TYPE matrixType, 
                   unsigned int inumberOfChildren, MatrixNode **m_mChildren);


    virtual std::string getMatrixNodeInXML();

    virtual OSMatrix *cloneMatrixNode();

    bool IsEqual(OSMatrix *that);

    bool setRandom(double density, bool conformant, int iMin, int iMax);

    bool deepCopyFrom(OSMatrix *that);
};// class OSMatrix


class OSMatrixWithMatrixVarIdx : public OSMatrix
{
public:
    int matrixVarIdx;

public:
    OSMatrixWithMatrixVarIdx();
    ~OSMatrixWithMatrixVarIdx();

    virtual std::string getMatrixNodeInXML();

    virtual OSMatrixWithMatrixVarIdx *cloneMatrixNode();

    bool IsEqual(OSMatrixWithMatrixVarIdx *that);

    bool setRandom(double density, bool conformant, int iMin, int iMax);

    bool deepCopyFrom(OSMatrixWithMatrixVarIdx *that);
};// class OSMatrixWithMatrixVarIdx


class OSMatrixWithMatrixObjIdx : public OSMatrix
{
public:
    int matrixObjIdx;

public:
    OSMatrixWithMatrixObjIdx();
    ~OSMatrixWithMatrixObjIdx();

    virtual std::string getMatrixNodeInXML();

    virtual OSMatrixWithMatrixObjIdx *cloneMatrixNode();

    bool IsEqual(OSMatrixWithMatrixObjIdx *that);

    bool setRandom(double density, bool conformant, int iMin, int iMax);

    bool deepCopyFrom(OSMatrixWithMatrixObjIdx *that);
};// class OSMatrixWithMatrixObjIdx

class OSMatrixWithMatrixConIdx : public OSMatrix
{
public:
    int matrixConIdx;

public:
    OSMatrixWithMatrixConIdx();
    ~OSMatrixWithMatrixConIdx();

    virtual std::string getMatrixNodeInXML();

    virtual OSMatrixWithMatrixConIdx *cloneMatrixNode();

    bool IsEqual(OSMatrixWithMatrixConIdx *that);

    bool setRandom(double density, bool conformant, int iMin, int iMax);

    bool deepCopyFrom(OSMatrixWithMatrixConIdx *that);
};// class OSMatrixWithMatrixConIdx


class MatrixBlock : public MatrixType
{
public:
    int blockRowIdx;
    int blockColIdx;

    MatrixBlock();
    ~MatrixBlock();

    virtual ENUM_MATRIX_CONSTRUCTOR_TYPE getNodeType();

    virtual std::string getNodeName();


    virtual ENUM_MATRIX_TYPE getMatrixType();

    virtual std::string getMatrixNodeInXML();

    virtual bool alignsOnBlockBoundary(int firstRow, int firstColumn, int nRows, int nCols);

    virtual bool expandElements(bool rowMajor);

    virtual MatrixBlock *cloneMatrixNode();

    bool IsEqual(MatrixBlock *that);

    bool setRandom(double density, bool conformant, int iMin, int iMax);

    bool deepCopyFrom(MatrixBlock *that);
};// class MatrixBlock


LinearMatrixElement* convertToLinearMatrixElement(double val);
LinearMatrixElement* convertToLinearMatrixElement(int varref);
ScalarExpressionTree* convertToGeneralMatrixElement(double val);
ScalarExpressionTree* convertToGeneralMatrixElement(int refIdx, bool varRef); // varref or objref
ScalarExpressionTree* convertToGeneralMatrixElement(LinearMatrixElement* val);
ScalarExpressionTree* convertToGeneralMatrixElement(ConReferenceMatrixElement* val);
ConReferenceMatrixElement* convertToConReferenceMatrixElement(int objref);
#endif

---