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

Go to the documentation of this file.

/* $Id: OSInstance.h 5014 2015-05-19 20:39:39Z Gassmann $ */
#ifndef OSINSTANCE_H
#define OSINSTANCE_H
#include "OSConfig.h"
#include "OSParameters.h"
#include "OSGeneral.h"
#include "OSMatrix.h"
#include "OSnLNode.h"
#include "OSExpressionTree.h"
#include <string>
#include <map>


class Variable
{
public:
    Variable();

    ~Variable();

    double lb;

    double ub;

    char type;

    std::string name;

    bool IsEqual(Variable *that);
}; // class Variable


class Variables
{
public:

    Variables();

    ~Variables();

    int numberOfVariables;

    Variable **var;

    bool IsEqual(Variables *that);
}; // class Variables


class ObjCoef
{
public:

    ObjCoef();

    ~ObjCoef();

    int idx;

    double value;

    bool IsEqual(ObjCoef *that);
};//class ObjCoef


class Objective
{
public:

    Objective();

    ~Objective();

    std::string name;

    std::string maxOrMin;

    double constant;

    double weight;

    int numberOfObjCoef;

    ObjCoef **coef;

    bool IsEqual(Objective *that);
};//class Objective

class Objectives
{
public:

    Objectives();

    ~Objectives();

    int numberOfObjectives;

    Objective **obj;

    bool IsEqual(Objectives *that);
};//class Objectives


class Constraint
{
public:

    Constraint();

    ~Constraint();

    std::string name;

    double constant;

    double lb;

    double ub;

    bool IsEqual(Constraint *that);
};//class Constraint


class Constraints
{
public:

    Constraints();

    ~Constraints();

    int numberOfConstraints;

    Constraint **con;

    bool IsEqual(Constraints *that);
};//class Constraints


class LinearConstraintCoefficients
{
public:

    LinearConstraintCoefficients();

    ~LinearConstraintCoefficients();

    int numberOfValues;

    IntVector *start;

    IntVector *rowIdx;

    IntVector *colIdx;

    DoubleVector *value;
    int iNumberOfStartElements;

    bool IsEqual(LinearConstraintCoefficients *that);
};//class LinearConstraintCoefficients


class QuadraticTerm
{
public:

    QuadraticTerm();

    ~QuadraticTerm();

    int idx;

    int idxOne;

    int idxTwo;

    double coef;

    bool IsEqual(QuadraticTerm *that);
}; // QuadraticTerm


class QuadraticCoefficients
{
public:

    QuadraticCoefficients();

    ~QuadraticCoefficients();

    int numberOfQuadraticTerms;

    QuadraticTerm** qTerm;

    bool IsEqual(QuadraticCoefficients *that);
}; // QuadraticCoefficients


class Nl
{
public:
    int idx;

    ENUM_NL_EXPR_SHAPE shape;

    bool m_bDeleteExpressionTree;

    ScalarExpressionTree *osExpressionTree;

    Nl();

    ~Nl();

    bool IsEqual(Nl *that);
};//end Nl

class NonlinearExpressions
{
public:

    NonlinearExpressions();

    ~NonlinearExpressions();

    int numberOfNonlinearExpressions;

    Nl **nl;

    bool IsEqual(NonlinearExpressions *that);
}; // NonlinearExpressions


class Matrices
{
public:

    Matrices();

    ~Matrices();

    int numberOfMatrices;

    OSMatrix **matrix;

    bool IsEqual(Matrices *that);

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

    bool deepCopyFrom(Matrices *that);
}; // Matrices


class Cone
{
public:

    Cone();

    virtual ~Cone();

    int numberOfRows;
    int numberOfColumns;

    int numberOfOtherIndexes;
    int* otherIndexes;

    ENUM_CONE_TYPE coneType;

    std::string name;

    int idx;

    virtual std::string getConeName();

    virtual std::string getConeInXML() = 0;


    bool IsEqual(Cone *that);

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

    bool deepCopyFrom(Cone *that);
}; // Cone

class NonnegativeCone : public Cone
{
public:
    NonnegativeCone();

    ~NonnegativeCone();

    virtual std::string getConeName();

    virtual std::string getConeInXML();

    bool IsEqual(NonnegativeCone *that);

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

    bool deepCopyFrom(NonnegativeCone *that);

};//end NonnegativeCone

class NonpositiveCone : public Cone
{
public:
    NonpositiveCone();

    ~NonpositiveCone();

    virtual std::string getConeName();

    virtual std::string getConeInXML();

    bool IsEqual(NonpositiveCone *that);

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

    bool deepCopyFrom(NonpositiveCone *that);

};//end NonpositiveCone


class OrthantCone : public Cone
{
public:
    double* ub;
    double* lb;

    OrthantCone();

    ~OrthantCone();

    virtual std::string getConeName();

    virtual std::string getConeInXML();

    bool IsEqual(OrthantCone *that);

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

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

class PolyhedralCone : public Cone
{
public:

    PolyhedralCone();

    ~PolyhedralCone();

    int numberOfRows;
    int numberOfColumns;

    int numberOfOtherIndexes;
    int* otherIndexes;

    int coneType;

    int idx;

    int referenceMatrixIdx;

    virtual std::string getConeName();

    virtual std::string getConeInXML();

    bool IsEqual(PolyhedralCone *that);

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

    bool deepCopyFrom(PolyhedralCone *that);
}; // PolyhedralCone


class QuadraticCone : public Cone
{
public:

    QuadraticCone();

    ~QuadraticCone();

    int numberOfRows;
    int numberOfColumns;

    int numberOfOtherIndexes;
    int* otherIndexes;

    int coneType;

    int idx;

    double normScaleFactor;
    int distortionMatrixIdx;

    int axisDirection;

    virtual std::string getConeName();

    virtual std::string getConeInXML();

    bool IsEqual(QuadraticCone *that);

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

    bool deepCopyFrom(QuadraticCone *that);
}; // QuadraticCone


class RotatedQuadraticCone : public Cone
{
public:

    RotatedQuadraticCone();

    ~RotatedQuadraticCone();

    int numberOfRows;
    int numberOfColumns;

    int numberOfOtherIndexes;
    int* otherIndexes;

    int coneType;

    int idx;

    double normScaleFactor;
    int distortionMatrixIdx;

    int firstAxisDirection;
    int secondAxisDirection;

    virtual std::string getConeName();

    virtual std::string getConeInXML();

    bool IsEqual(RotatedQuadraticCone *that);

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

    bool deepCopyFrom(RotatedQuadraticCone *that);
}; // RotatedQuadraticCone

/*  Not yet implemented:
    ENUM_CONE_TYPE_normed,
*/

class SemidefiniteCone : public Cone
{
public:

    SemidefiniteCone();

    ~SemidefiniteCone();

    int numberOfRows;
    int numberOfColumns;

    int numberOfOtherIndexes;
    int* otherIndexes;

    int coneType;

    int idx;

    std::string semidefiniteness;

    bool isPositiveSemiDefinite;

    virtual std::string getConeName();

    virtual std::string getConeInXML();

    bool IsEqual(SemidefiniteCone *that);

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

    bool deepCopyFrom(SemidefiniteCone *that);
}; // SemidefiniteCone


class CopositiveMatricesCone : public Cone
{
public:
    CopositiveMatricesCone();

    ~CopositiveMatricesCone();

    virtual std::string getConeName();

    virtual std::string getConeInXML();

    bool IsEqual(CopositiveMatricesCone *that);

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

    bool deepCopyFrom(CopositiveMatricesCone *that);

};//end CopositiveMatricesCone


class CompletelyPositiveMatricesCone : public Cone
{
public:
    CompletelyPositiveMatricesCone();

    ~CompletelyPositiveMatricesCone();

    virtual std::string getConeName();

    virtual std::string getConeInXML();

    bool IsEqual(CompletelyPositiveMatricesCone *that);

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

    bool deepCopyFrom(CompletelyPositiveMatricesCone *that);

};//end CompletelyPositiveMatricesCone

/*  Not yet implemented: 
    ENUM_CONE_TYPE_hyperbolicity,
    ENUM_CONE_TYPE_nonnegativePolynomials,
    ENUM_CONE_TYPE_moments,
*/

class ProductCone : public Cone
{
public:

    ProductCone();

    ~ProductCone();

    int numberOfRows;
    int numberOfColumns;

    int numberOfOtherIndexes;
    int* otherIndexes;

    int coneType;

    int idx;

    IntVector* factors;

    virtual std::string getConeName();

    virtual std::string getConeInXML();

    bool IsEqual(ProductCone *that);

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


    bool deepCopyFrom(ProductCone *that);
}; // ProductCone

class IntersectionCone : public Cone
{
public:

    IntersectionCone();

    ~IntersectionCone();

    int numberOfRows;
    int numberOfColumns;

    int numberOfOtherIndexes;
    int* otherIndexes;

    int coneType;

    int idx;

    IntVector* components;

    virtual std::string getConeName();

    virtual std::string getConeInXML();

    bool IsEqual(IntersectionCone *that);

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

    bool deepCopyFrom(IntersectionCone *that);
}; // IntersectionCone


class DualCone : public Cone
{
public:

    DualCone();

    ~DualCone();

    int numberOfRows;
    int numberOfColumns;

    int numberOfOtherIndexes;
    int* otherIndexes;

    int coneType;

    int idx;

    int referenceConeIdx;

    virtual std::string getConeName();

    bool IsEqual(DualCone *that);

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

    bool deepCopyFrom(DualCone *that);
}; // DualCone

class PolarCone : public Cone
{
public:

    PolarCone();

    ~PolarCone();

    int numberOfRows;
    int numberOfColumns;

    int numberOfOtherIndexes;
    int* otherIndexes;

    int coneType;

    int idx;

    int referenceConeIdx;

    virtual std::string getConeName();

    bool IsEqual(PolarCone *that);

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

    bool deepCopyFrom(PolarCone *that);
}; // PolarCone


class Cones
{
public:

    Cones();

    ~Cones();

    int numberOfCones;

    Cone **cone;

    bool IsEqual(Cones *that);

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

    bool deepCopyFrom(Cones *that);
}; // Cones


class MatrixVar
{
public:
    int numberOfRows;

    int numberOfColumns;

    int templateMatrixIdx;

    int varReferenceMatrixIdx;

    int lbMatrixIdx;

    int lbConeIdx;

    int ubMatrixIdx;

    int ubConeIdx;

    std::string name;

    char varType;

    MatrixVar();

    ~MatrixVar();

    bool IsEqual(MatrixVar *that);
}; // MatrixVar


class MatrixVariables
{
public:
    int numberOfMatrixVar;

    MatrixVar** matrixVar;

    MatrixVariables();

    ~MatrixVariables();

    bool IsEqual(MatrixVariables *that);
}; // MatrixVariables


class MatrixObj
{
public:
    int numberOfRows;

    int numberOfColumns;

    int templateMatrixIdx;

    int objReferenceMatrixIdx;

    int orderConeIdx;

    int constantMatrixIdx;

    std::string name;

    MatrixObj();

    ~MatrixObj();

    bool IsEqual(MatrixObj *that);
}; // MatrixObj


class MatrixObjectives
{
public:

    MatrixObjectives();

    ~MatrixObjectives();

    int numberOfMatrixObj;

    MatrixObj** matrixObj;


    bool IsEqual(MatrixObjectives *that);
}; // MatrixObjectives


class MatrixCon
{
public:
    int numberOfRows;

    int numberOfColumns;

    int templateMatrixIdx;

    int conReferenceMatrixIdx;

    int lbMatrixIdx;

    int lbConeIdx;

    int ubMatrixIdx;

    int ubConeIdx;

    std::string name;

    MatrixCon();

    ~MatrixCon();

    bool IsEqual(MatrixCon *that);
}; // MatrixCon


class MatrixConstraints
{
public:

    MatrixConstraints();

    ~MatrixConstraints();

    int numberOfMatrixCon;

    MatrixCon** matrixCon;


    bool IsEqual(MatrixConstraints *that);
}; // MatrixConstraints

class MatrixExpression
{
public:
    int idx;

    ENUM_NL_EXPR_SHAPE shape;

    MatrixExpressionTree *matrixExpressionTree;

    bool m_bDeleteExpressionTree;

    MatrixExpression();

    ~MatrixExpression();

    bool IsEqual(MatrixExpression *that);
}; // MatrixExpression


class MatrixExpressions
{
public:
    int numberOfExpr;

    MatrixExpression **expr;

    MatrixExpressions();

    ~MatrixExpressions();

    bool IsEqual(MatrixExpressions *that);
}; // MatrixExpressions

class MatrixProgramming
{
public:
    MatrixProgramming();

    ~MatrixProgramming();

    MatrixVariables* matrixVariables;

    MatrixObjectives* matrixObjectives;

    MatrixConstraints* matrixConstraints;

    MatrixExpressions* matrixExpressions;


    bool IsEqual(MatrixProgramming *that);

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

    bool deepCopyFrom(MatrixProgramming *that);
}; // MatrixProgramming


class TimeDomainStageVar
{
public:

    TimeDomainStageVar();

    ~TimeDomainStageVar();

    int idx;
}; // TimeDomainStageVar

class TimeDomainStageVariables
{
public:

    TimeDomainStageVariables();

    ~TimeDomainStageVariables();

    int numberOfVariables;

    int startIdx;

    TimeDomainStageVar** var;
}; // TimeDomainStageVariables


class TimeDomainStageCon
{
public:

    TimeDomainStageCon();

    ~TimeDomainStageCon();

    int idx;
}; // TimeDomainStageCon

class TimeDomainStageConstraints
{
public:

    TimeDomainStageConstraints();

    ~TimeDomainStageConstraints();

    int numberOfConstraints;

    int startIdx;

    TimeDomainStageCon** con;
}; // TimeDomainStageConstraints


class TimeDomainStageObj
{
public:

    TimeDomainStageObj();

    ~TimeDomainStageObj();

    int idx;
}; // TimeDomainStageObj

class TimeDomainStageObjectives
{
public:

    TimeDomainStageObjectives();

    ~TimeDomainStageObjectives();

    int numberOfObjectives;

    int startIdx;

    TimeDomainStageObj** obj;
}; // TimeDomainStageObjectives


class TimeDomainStage
{
public:

    TimeDomainStage();

    ~TimeDomainStage();

    std::string name;

    TimeDomainStageVariables *variables;

    TimeDomainStageConstraints *constraints;

    TimeDomainStageObjectives *objectives;
}; // TimeDomainStage

class TimeDomainStages
{
public:

    TimeDomainStages();

    ~TimeDomainStages();

    int numberOfStages;

    TimeDomainStage **stage;
}; // Stages

class TimeDomainInterval
{
public:

    TimeDomainInterval();

    ~TimeDomainInterval();

    double start;

    double horizon;
}; // Interval

class TimeDomain
{
public:

    TimeDomain();

    ~TimeDomain();

    TimeDomainStages *stages;

    TimeDomainInterval *interval;
}; // TimeDomain

class InstanceData
{
public:

    InstanceData();

    ~InstanceData();

    Variables *variables;

    Objectives *objectives;

    Constraints *constraints;

    LinearConstraintCoefficients *linearConstraintCoefficients;

    QuadraticCoefficients* quadraticCoefficients;

    NonlinearExpressions* nonlinearExpressions;

    Matrices* matrices;

    Cones* cones;

    MatrixProgramming* matrixProgramming;

    TimeDomain* timeDomain;

    bool IsEqual(InstanceData *that);
}; // class InstanceData


class OSInstance
{
public:

    OSInstance();

    ~OSInstance();

    GeneralFileHeader *instanceHeader;

    InstanceData *instanceData;

    bool IsEqual(OSInstance *that);

    bool bVariablesModified;

    bool bObjectivesModified;

    bool bConstraintsModified;

    bool bAMatrixModified;

private:
    std::string m_sInstanceName;
    std::string m_sInstanceSource;
    std::string m_sInstanceDescription;
    std::string m_sInstanceCreator;
    std::string m_sInstanceLicence;


    bool m_bProcessVariables;

    int m_iVariableNumber;

    int m_iNumberOfIntegerVariables;

    int m_iNumberOfBinaryVariables;

    int m_iNumberOfSemiContinuousVariables;

    int m_iNumberOfSemiIntegerVariables;

    int m_iNumberOfStringVariables;

    std::string* m_msVariableNames;

    char* m_mcVariableTypes;

    double* m_mdVariableLowerBounds;

    double* m_mdVariableUpperBounds;


    bool m_bProcessObjectives;

    int m_iObjectiveNumber;

    int m_iObjectiveNumberNonlinear;

    std::string* m_msObjectiveNames;

    std::string* m_msMaxOrMins;

    int* m_miNumberOfObjCoef;

    double* m_mdObjectiveConstants;

    double* m_mdObjectiveWeights;

    SparseVector** m_mObjectiveCoefficients;

    bool m_bGetDenseObjectives;

    double** m_mmdDenseObjectiveCoefficients;


    bool m_bProcessConstraints;

    int m_iConstraintNumber;

    int m_iConstraintNumberNonlinear;

    std::string* m_msConstraintNames;

    double* m_mdConstraintLowerBounds;

    double* m_mdConstraintUpperBounds;

    double* m_mdConstraintConstants;

    char* m_mcConstraintTypes;


    bool m_bProcessLinearConstraintCoefficients;

    int m_iLinearConstraintCoefficientNumber;

    bool m_bColumnMajor;

    SparseMatrix* m_linearConstraintCoefficientsInColumnMajor;

    SparseMatrix* m_linearConstraintCoefficientsInRowMajor;


    int m_iNumberOfQuadraticRowIndexes;

    bool m_bQuadraticRowIndexesProcessed;

    int *m_miQuadRowIndexes;

    bool m_bProcessQuadraticTerms;

    int m_iQuadraticTermNumber;

    QuadraticTerms* m_quadraticTerms;

    bool m_bQTermsAdded;


    int m_iNumberOfNonlinearExpressionTreeIndexes;
  
    bool m_bNonlinearExpressionTreeIndexesProcessed;

    int *m_miNonlinearExpressionTreeIndexes;

    int m_iNumberOfNonlinearExpressionTreeModIndexes;

    bool m_bNonlinearExpressionTreeModIndexesProcessed;

    int *m_miNonlinearExpressionTreeModIndexes;


    bool m_binitForAlgDiff;

    unsigned int m_iNumberOfNonlinearVariables;

    bool m_bProcessNonlinearExpressions;

    int m_iNonlinearExpressionNumber;

    int* m_miNonlinearExpressionIndexes;

    bool m_bProcessExpressionTrees;

    bool m_bProcessExpressionTreesMod;

    double *m_mdConstraintFunctionValues;

    double *m_mdObjectiveFunctionValues;

    int m_iJacValueSize;

    int *m_miJacStart;

    int *m_miJacIndex;

    double *m_mdJacValue;

    int *m_miJacNumConTerms;

    SparseJacobianMatrix *m_sparseJacMatrix;

    int m_iHighestTaylorCoeffOrder;

    std::map<int, ScalarExpressionTree*> m_mapExpressionTrees;

    std::map<int, int> m_mapOSADFunRangeIndex;

    std::map<int, MatrixExpressionTree*> m_mapMatrixExpressionTrees;

    ScalarExpressionTree *m_LagrangianExpTree;

    bool m_bLagrangianExpTreeCreated;

    SparseHessianMatrix* m_LagrangianSparseHessian;

    bool m_bLagrangianSparseHessianCreated;

    std::map<int, int> m_mapAllNonlinearVariablesIndex;

    int *m_miNonLinearVarsReverseMap;

    bool m_bAllNonlinearVariablesIndex;

    std::map<int, ScalarExpressionTree*> m_mapExpressionTreesMod ;

    bool m_bOSADFunIsCreated;

    bool m_bCppADTapesBuilt;

    bool m_bCppADMustReTape;

    bool m_bDuplicateExpressionTreesMap;

    bool m_bNonLinearStructuresInitialized;

    bool m_bSparseJacobianCalculated;

    std::map<int, std::vector<OSnLNode*> > m_mapExpressionTreesInPostfix ;

    int m_iHighestOrderEvaluated;

    double **m_mmdObjGradient;


    std::vector<double> m_vdX;

    std::vector<double> m_vdYval;

    std::vector<bool> m_vbLagHessNonz;

    std::vector<double> m_vdYjacval;

    std::vector<double> m_vdw;

    std::vector<double> m_vdLambda;

    std::vector<double> m_vdDomainUnitVec;

    std::vector<double> m_vdRangeUnitVec;


    bool m_bProcessMatrices;

    int m_iMatrixNumber;

    ENUM_MATRIX_SYMMETRY* m_miMatrixSymmetry;

    ENUM_MATRIX_TYPE* m_miMatrixType;

    int* m_miMatrixNumberOfColumns;

    int* m_miMatrixNumberOfRows;

    std::string* m_msMatrixNames;

    OSMatrix** m_mMatrix;

#if 0

    GeneralSparseMatrix** m_mExpandedMatricesInColumnMajor;

    GeneralSparseMatrix** m_mExpandedMatricesInRowMajor;

    ExpandedMatrixBlocks** m_mMatrixBlocksInColumnMajor;

    OSnLMNode *m_mMatrixTransformation;
#endif

    int m_iMatrixVarNumber;

    int m_iMatrixObjNumber;

    int m_iMatrixConNumber;

    int m_iMatrixExpressionNumber;


    bool m_bProcessTimeDomain;

    bool m_bProcessTimeStages;

    bool m_bProcessTimeInterval;

    bool m_bFiniteTimeStages;

    int m_iNumberOfTimeStages;

    std::string m_sTimeDomainFormat;

    std::string* m_msTimeDomainStageNames;




    int* m_miTimeDomainStageVariableNumber;

    int** m_mmiTimeDomainStageVarList;

    int* m_miTimeDomainStageConstraintNumber;

    int** m_mmiTimeDomainStageConList;

    int* m_miTimeDomainStageObjectiveNumber;

    int** m_mmiTimeDomainStageObjList;


    bool processVariables();

    bool processObjectives();

    bool processConstraints();

    bool processLinearConstraintCoefficients();

    bool processMatrices();

public:

    std::string getInstanceName();

    std::string getInstanceSource();

    std::string getInstanceDescription();

    std::string getInstanceCreator();

    std::string getInstanceLicence();


    int getVariableNumber();

    std::string* getVariableNames();

    //double* getVariableInitialValues();

    //std::string* getVariableInitialStringValues();

    char* getVariableTypes();

    int getNumberOfIntegerVariables();

    int getNumberOfBinaryVariables();

    int getNumberOfSemiContinuousVariables();

    int getNumberOfSemiIntegerVariables();

    int getNumberOfStringVariables();

    double* getVariableLowerBounds();

    double* getVariableUpperBounds();

    int getObjectiveNumber();


    std::string* getObjectiveNames();

    std::string* getObjectiveMaxOrMins();


    int* getObjectiveCoefficientNumbers();

    double* getObjectiveConstants();

    double* getObjectiveWeights();

    SparseVector** getObjectiveCoefficients();

    double** getDenseObjectiveCoefficients();

    int getConstraintNumber();

    std::string* getConstraintNames();

    double* getConstraintLowerBounds();

    double *getConstraintUpperBounds();

    double *getConstraintConstants();

    char* getConstraintTypes();

    int getLinearConstraintCoefficientNumber();


    bool getLinearConstraintCoefficientMajor();


    SparseMatrix* getLinearConstraintCoefficientsInColumnMajor();

    SparseMatrix* getLinearConstraintCoefficientsInRowMajor();

    int getNumberOfQuadraticTerms();

    QuadraticTerms* getQuadraticTerms();

    int* getQuadraticRowIndexes();

    int getNumberOfQuadraticRowIndexes();


/*********************************************************************
 *                                                                   *
 * Here we have a number of methods for dealing with                 *
 * scalar-valued expression trees.                                   *
 * Even though the tree can contain OSnLMNodes (e.g., to compute     *
 * the trace of a matrix), the root of the tree is of type OSnLNode. *
 *                                                                   *
 *********************************************************************/

    int getNumberOfNonlinearExpressions();

    Nl** getNonlinearExpressions();

    ScalarExpressionTree* getNonlinearExpressionTree(int rowIdx);

    ScalarExpressionTree* getNonlinearExpressionTreeMod(int rowIdx);

    std::vector<ExprNode*> getNonlinearExpressionTreeInPostfix( int rowIdx);

    std::vector<ExprNode*> getNonlinearExpressionTreeModInPostfix( int rowIdx);

    std::vector<ExprNode*> getNonlinearExpressionTreeInPrefix( int rowIdx);

    std::string getNonlinearExpressionTreeInInfix( int rowIdx);


    std::vector<ExprNode*> getNonlinearExpressionTreeModInPrefix( int rowIdx);


    int getNumberOfNonlinearObjectives();

    int getNumberOfNonlinearConstraints();

    std::map<int, ScalarExpressionTree* > getAllNonlinearExpressionTrees();

    std::map<int, ScalarExpressionTree* > getAllNonlinearExpressionTreesMod();

    int* getNonlinearExpressionTreeIndexes();


    int getNumberOfNonlinearExpressionTreeIndexes();


    int* getNonlinearExpressionTreeModIndexes();

    int getNumberOfNonlinearExpressionTreeModIndexes();

    int getMatrixNumber();

    ENUM_MATRIX_TYPE getMatrixType(int n);

    ENUM_MATRIX_SYMMETRY getMatrixSymmetry(int n);

//    int getNumberOfBlocksForMatrix(int n);

    int getNumberOfColumnsForMatrix(int n);

    int getNumberOfRowsForMatrix(int n);

    int getNumberOfValuesForMatrix(int n);

    std::string getMatrixName(int n);

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

    OSMatrix* getMatrix(int n);

    GeneralSparseMatrix* getMatrixCoefficientsInColumnMajor(int n);

    GeneralSparseMatrix* getMatrixCoefficientsInRowMajor(int n);

//    SymmetricMatrixBlocks* getSymmetricMatrixBlocks(int n);

    GeneralSparseMatrix* getMatrixBlockInColumnMajorForm(int n, int columnIdx, int rowIdx);


/***********************************************************************
 *                                                                     *
 * Here we have a number of methods for dealing with                   *
 * matrix programming and matrix-valued expression trees.              *
 * Even though the tree can contain OSnLNodes (e.g., to compute the    *
 * scalar multiple of a matrix), the root of the tree is an OSnLMNode. *
 *                                                                     *
 ***********************************************************************/

    int getNumberOfMatrixVariables();

    int getNumberOfMatrixObjectives();

    int getNumberOfMatrixConstraints();

    int getNumberOfMatrixExpressions();

    MatrixExpression** getMatrixExpressions();

    MatrixExpressionTree* getMatrixExpressionTree(int rowIdx);

    std::vector<ExprNode*> getMatrixExpressionTreeInPostfix( int rowIdx);

    std::vector<ExprNode*> getMatrixExpressionTreeModInPostfix( int rowIdx);

    std::vector<ExprNode*> getMatrixExpressionTreeInPrefix( int rowIdx);

    std::string getMatrixExpressionTreeInInfix( int rowIdx);


    std::map<int, MatrixExpressionTree* > getAllMatrixExpressionTrees();


    std::map<int, MatrixExpressionTree* > getAllMatrixExpressionTreesMod();

    int* getMatrixExpressionTreeIndexes();


    int getNumberOfMatrixExpressionTreeIndexes();

//===============================================

    std::string getTimeDomainFormat();

    int getTimeDomainStageNumber();

    std::string* getTimeDomainStageNames();

    int* getTimeDomainStageNumberOfVariables();


    int* getTimeDomainStageNumberOfConstraints();

    int* getTimeDomainStageNumberOfObjectives();

    int** getTimeDomainStageVarList();

    int** getTimeDomainStageConList();

    int** getTimeDomainStageObjList();

    double getTimeDomainIntervalStart();

    double getTimeDomainIntervalHorizon();



    // the set() methods


    bool setInstanceName(std::string name);

    bool setInstanceSource(std::string source);

    bool setInstanceDescription(std::string description);

    bool setInstanceCreator(std::string fileCreator);

    bool setInstanceLicence(std::string licence);


    bool setVariableNumber(int number);

    bool addVariable(int index, std::string name, double lowerBound, double upperBound, char type);

    bool setVariables(int number, std::string* names, double* lowerBounds,
                      double* upperBounds, char* types);


    bool setObjectiveNumber(int number);

    bool addObjective(int index, std::string name, std::string maxOrMin, double constant, double weight, SparseVector* objectiveCoefficients);

    bool setObjectives(int number, std::string *names, std::string *maxOrMins, double *constants, double *weights, SparseVector **objectitiveCoefficients);

    bool setConstraintNumber(int number);

    bool addConstraint(int index, std::string name, double lowerBound, double upperBound, double constant);

    bool setConstraints(int number, std::string* names, double* lowerBounds, double* upperBounds, double* constants);

    bool setLinearConstraintCoefficients(int numberOfValues, bool isColumnMajor,
                                         double* values, int valuesBegin, int valuesEnd,
                                         int* indexes, int indexesBegin, int indexesEnd,
                                         int* starts, int startsBegin, int startsEnd);

    bool copyLinearConstraintCoefficients(int numberOfValues, bool isColumnMajor,
                                         double* values, int valuesBegin, int valuesEnd,
                                         int* indexes, int indexesBegin, int indexesEnd,
                                         int* starts, int startsBegin, int startsEnd);

    bool setNumberOfQuadraticTerms(int nq);

    bool setQuadraticCoefficients(int number,
                                  int* rowIndexes, int* varOneIndexes, int* varTwoIndexes,
                                  double* coefficients, int begin, int end);


    bool setQuadraticTermsInNonlinearExpressions(int number,
            int* rowIndexes, int* varOneIndexes, int* varTwoIndexes, double* coefficients);

    bool setNonlinearExpressions(int nexpr, Nl** root);

    bool setMatrixNumber(int number);

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


    bool setConeNumber(int number);

    bool addCone(int index, int numberOfRows, int numberOfColumns, ENUM_CONE_TYPE coneType,
                 std::string name, int numberOfOtherIndexes = 0, int* otherIndexes = NULL);

    bool addCone(int index, int numberOfRows, int numberOfColumns, ENUM_CONE_TYPE coneType,
                 std::string name, int numberOfComponents, int* components, 
                 int numberOfOtherIndexes = 0, int* otherIndexes = NULL);

    bool addCone(int index, int numberOfRows, int numberOfColumns, ENUM_CONE_TYPE coneType,
                 std::string name, int referenceIdx, int numberOfOtherIndexes = 0, int* otherIndexes = NULL);

    bool addCone(int index, int numberOfRows, int numberOfColumns, ENUM_CONE_TYPE coneType,
                 std::string name, std::string semidefiniteness, int numberOfOtherIndexes = 0, int* otherIndexes = NULL);

    bool addCone(int index, int numberOfRows, int numberOfColumns, ENUM_CONE_TYPE coneType,
                 std::string name, int distortionMatrixIdx, double normFactor, int axisDirection, 
                 int numberOfOtherIndexes = 0, int* otherIndexes = NULL);

    bool addCone(int index, int numberOfRows, int numberOfColumns, ENUM_CONE_TYPE coneType,
                 std::string name, int distortionMatrixIdx, double normFactor, int firstAxisDirection, 
                 int secondAxisDirection, int numberOfOtherIndexes = 0, int* otherIndexes = NULL);

    bool addCone(int index, int numberOfRows, int numberOfColumns, ENUM_CONE_TYPE coneType,
                 std::string name, int distortionMatrixIdx, double normFactor, int axisDirection, double pNorm, 
                 int numberOfOtherIndexes = 0, int* otherIndexes = NULL);

    bool addCone(int index, int numberOfRows, int numberOfColumns, ENUM_CONE_TYPE coneType,
                 std::string name, int maxDegree, int numberOfUB, double* ub, int numberOfLB, double* lb,
                 int numberOfOtherIndexes = 0, int* otherIndexes = NULL);


    // methods to print the current model or parts of it

    std::string printModel( );

    std::string printModel( int rowIdx);



    // nonlinear API methods


    bool initializeNonLinearStructures( );

    double calculateFunctionValue(int idx, double* x, bool new_x);

    double *calculateAllConstraintFunctionValues(double* x, double *objLambda, double *conLambda,
            bool new_x, int highestOrder);

    double *calculateAllConstraintFunctionValues(double* x, bool new_x);

    double *calculateAllObjectiveFunctionValues(double* x, double *objLambda, double *conLambda,
            bool new_x, int highestOrder);

    double *calculateAllObjectiveFunctionValues(double* x, bool new_x);


    SparseJacobianMatrix *calculateAllConstraintFunctionGradients(double* x, double *objLambda,
            double *conLambda, bool new_x, int highestOrder);


    SparseVector *calculateConstraintFunctionGradient(double* x, double *objLambda, double *conLambda,
            int idx, bool new_x, int highestOrder);

    SparseVector *calculateConstraintFunctionGradient(double* x, int idx, bool new_x );

    double **calculateAllObjectiveFunctionGradients(double* x, double *objLambda, double *conLambda,
            bool new_x, int highestOrder);

    double *calculateObjectiveFunctionGradient(double* x, double *objLambda, double *conLambda,
            int objIdx, bool new_x, int highestOrder);

    double *calculateObjectiveFunctionGradient(double* x, int objIdx, bool new_x );

    SparseHessianMatrix *calculateLagrangianHessian( double* x, double *objLambda, double *conLambda,
            bool new_x, int highestOrder);

    SparseHessianMatrix *calculateHessian( double* x, int idx, bool new_x);


    bool getSparseJacobianFromColumnMajor();

    bool getSparseJacobianFromRowMajor();

    ScalarExpressionTree* getLagrangianExpTree( );

    std::map<int, int> getAllNonlinearVariablesIndexMap( );

    SparseHessianMatrix* getLagrangianHessianSparsityPattern();

    bool addQTermsToExressionTree();

    bool addQTermsToExpressionTree();

    SparseJacobianMatrix *getJacobianSparsityPattern();

    void duplicateExpressionTreesMap();

#ifdef OS_HAS_CPPAD

    CppAD::ADFun<double> *Fad;
#endif

    bool createOSADFun(std::vector<double> vdX );

    std::vector<double> forwardAD(int p, std::vector<double> vdX);

    std::vector<double> reverseAD(int p, std::vector<double> vdlambda);

    int  getADSparsityHessian();

    bool getIterateResults(double *x, double *objLambda, double *conLambda,
                           bool new_x, int highestOrder);



    bool getZeroOrderResults(double *x, double *objLambda, double *conLambda);

    bool getFirstOrderResults(double *x, double *objLambda, double *conLambda );

    bool getSecondOrderResults(double *x, double *objLambda, double *conLambda );


    bool initForAlgDiff();

    bool initObjGradients();


    bool bUseExpTreeForFunEval;


    bool setTimeDomain(std::string format);

    bool setTimeDomainStages(int number, std::string *names);

    bool setTimeDomainStageVariablesOrdered(int numberOfStages, int *numberOfVariables, int *startIdx);

    bool setTimeDomainStageVariablesUnordered(int numberOfStages, int *numberOfVariables, int **varIndex);

    bool setTimeDomainStageConstraintsOrdered(int numberOfStages, int *numberOfConstraints, int *startIdx);

    bool setTimeDomainStageConstraintsUnordered(int numberOfStages, int *numberOfConstraints, int **conIndex);

    bool setTimeDomainStageObjectivesOrdered(int numberOfStages, int *numberOfObjectives, int *startIdx);

    bool setTimeDomainStageObjectivesUnordered(int numberOfStages, int *numberOfObjectives, int **varIndex);

    bool setTimeDomainInterval(double start, double horizon);


}; //class OSInstance

#endif

---