OSInstance.h

Go to the documentation of this file.

/* $Id: OSInstance.h 5284 2017-12-08 13:52:50Z stefan $ */
#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