OSInstance.h

Go to the documentation of this file.

#ifndef OSINSTANCE_H
#define OSINSTANCE_H
#include "OSParameters.h"
#include "OSDataStructures.h"
#include "OSnLNode.h"
#include "OSExpressionTree.h"
#include <string>
#include <map>


class InstanceHeader{
public:

        InstanceHeader();
        
        ~InstanceHeader();
        
        std::string description;
        
        std::string name;
        
        std::string source;             
};//class InstanceHeader



class Variable{
public:
        Variable();
        
        ~Variable();

        double lb;

        double ub;
        
        //double init;
        
        char type;
        
        std::string name;
        
        //std::string initString;
}; // class Variable


class Variables{
public:

        Variables();
        
        ~Variables();
        
        int numberOfVariables;
        
        Variable **var;
}; // class Variables


class ObjCoef{
public:

        ObjCoef();
        
        ~ObjCoef();
        
        int idx;
        
        double value;
};//class Coef

class Constraint{
public:

        Constraint();
        
        ~Constraint();
        
        std::string name;
        
        double constant;
        
        double lb;
        
        double ub;
};//class Constraint


class Constraints{
public:

        Constraints();
        
        ~Constraints();
        
        int numberOfConstraints;
        
        Constraint **con;
};//class Constraints



class Objective{
public:

        Objective();
        
        ~Objective();
        
        std::string name;
        
        std::string maxOrMin;
        
        double constant;
        
        double weight;
        
        int numberOfObjCoef;
        
        ObjCoef **coef;
};//class Objective

class Objectives{
public:

        Objectives();
        
        ~Objectives();
        
        int numberOfObjectives;
        
        Objective **obj;
};//class Objectives

class LinearConstraintCoefficients{
public:

        LinearConstraintCoefficients();
        
        ~LinearConstraintCoefficients();
        
        int numberOfValues;
        
        IntVector *start;
        
        IntVector *rowIdx;
        
        IntVector *colIdx;
        
        DoubleVector *value;
        int iNumberOfStartElements;
};//class LinearConstraintCoefficients


class QuadraticTerm{
public:
    
        QuadraticTerm();
        
        ~QuadraticTerm();
        
        int idx;
        
    int idxOne;
    
    int idxTwo;
    
    double coef;
}; // QuadraticTerm




class QuadraticCoefficients {
public:
    
        QuadraticCoefficients();
        
        ~QuadraticCoefficients();
        
        int numberOfQuadraticTerms;
        
    QuadraticTerm** qTerm;
}; // QuadraticCoefficients


class Nl{  
public: 
        int idx;

        bool m_bDeleteExpressionTree;
        
        OSExpressionTree *osExpressionTree;
        
        Nl();

        ~Nl();
};//end Nl

class NonlinearExpressions {
public:
    
        NonlinearExpressions();
        
        ~NonlinearExpressions();
        
        int numberOfNonlinearExpressions;
        
    Nl **nl;
}; // NonlinearExpression



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;
        
        TimeDomain* timeDomain;
}; // class InstanceData


class OSInstance {
public:

        OSInstance(); 
        
        ~OSInstance();
        
        InstanceHeader *instanceHeader;
        
        InstanceData *instanceData;

private:
        std::string m_sInstanceName;
        std::string m_sInstanceSource;  
        std::string m_sInstanceDescription;
        
        bool m_bProcessVariables ;
        
        int m_iVariableNumber;
        
        int m_iNumberOfIntegerVariables;
        
        int m_iNumberOfBinaryVariables;
        
        int m_iNumberOfQuadraticRowIndexes;
        
        bool m_bQuadraticRowIndexesProcessed;

        int *m_miQuadRowIndexes;
        
        int m_iNumberOfNonlinearExpressionTreeIndexes;
        
        bool m_bNonlinearExpressionTreeIndexesProcessed;

        int *m_miNonlinearExpressionTreeIndexes;
        
        int m_iNumberOfNonlinearExpressionTreeModIndexes;
        
        bool m_bNonlinearExpressionTreeModIndexesProcessed;

        int *m_miNonlinearExpressionTreeModIndexes;
        
        std::string* m_msVariableNames;
        
        //double* m_mdVariableInitialValues ;

        //std::string* m_msVariableInitialStringValues;

        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;
        
        bool m_binitForAlgDiff;


        SparseMatrix* m_linearConstraintCoefficientsInColumnMajor ;

        SparseMatrix* m_linearConstraintCoefficientsInRowMajor ;

        
        bool m_bProcessQuadraticTerms ;

        int m_iQuadraticTermNumber ;

    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;
        
         QuadraticTerms* m_quadraticTerms;
         
         bool m_bQTermsAdded;
         
        unsigned int m_iNumberOfNonlinearVariables ;
         
        bool m_bProcessNonlinearExpressions ;
        
        int m_iNonlinearExpressionNumber;

        int* m_miNonlinearExpressionIndexes ;
        
        bool m_bProcessExpressionTrees;
        
        bool m_bProcessExpressionTreesMod;
        
        std::map<int, OSExpressionTree*> m_mapExpressionTrees ;
        
        
        
        std::map<int, int> m_mapOSADFunRangeIndex ;
        
        OSExpressionTree *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, OSExpressionTree*> 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;
        
        //define the vectors    

        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_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();
        
        
public:

        std::string getInstanceName();
                

        std::string getInstanceSource();
        
        
        std::string getInstanceDescription();
        
        int getVariableNumber();
        
        std::string* getVariableNames();
        
        //double* getVariableInitialValues();
        
        //std::string* getVariableInitialStringValues();
        
        char* getVariableTypes();
        
        int getNumberOfIntegerVariables();
        
        int getNumberOfBinaryVariables();
        
        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();
        
        char* getConstraintTypes();
        
        int getLinearConstraintCoefficientNumber();
        

        bool getLinearConstraintCoefficientMajor();
        
        
        SparseMatrix* getLinearConstraintCoefficientsInColumnMajor();
        
        SparseMatrix* getLinearConstraintCoefficientsInRowMajor();
        
        int getNumberOfQuadraticTerms();
        
        QuadraticTerms* getQuadraticTerms();
        
        int* getQuadraticRowIndexes();
        
        int getNumberOfQuadraticRowIndexes();
        
        int getNumberOfNonlinearExpressions();
        
        
        OSExpressionTree* getNonlinearExpressionTree(int rowIdx);
        
        OSExpressionTree* getNonlinearExpressionTreeMod(int rowIdx);
        
        std::vector<OSnLNode*> getNonlinearExpressionTreeInPostfix( int rowIdx); 
        
        std::vector<OSnLNode*> getNonlinearExpressionTreeModInPostfix( int rowIdx);  
        
        std::vector<OSnLNode*> getNonlinearExpressionTreeInPrefix( int rowIdx);  
        
        std::vector<OSnLNode*> getNonlinearExpressionTreeModInPrefix( int rowIdx);      

        
        int getNumberOfNonlinearObjectives();

        int getNumberOfNonlinearConstraints();
        
        std::map<int, OSExpressionTree* > getAllNonlinearExpressionTrees();
        
        
        std::map<int, OSExpressionTree* > getAllNonlinearExpressionTreesMod();
        
        int* getNonlinearExpressionTreeIndexes(); 
        
        
        int getNumberOfNonlinearExpressionTreeIndexes(); 
        
        
        int* getNonlinearExpressionTreeModIndexes(); 
        
        
        int getNumberOfNonlinearExpressionTreeModIndexes(); 
        
        
        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 setInstanceSource(std::string source);
        
        bool setInstanceDescription(std::string description);
        
                                        
        bool setInstanceName(std::string name);
        
        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 setQuadraticTerms(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);
                
                
                
        // 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();
        
        OSExpressionTree* getLagrangianExpTree( );

        std::map<int, int> getAllNonlinearVariablesIndexMap( ); 
        
        SparseHessianMatrix* getLagrangianHessianSparsityPattern();
        
        bool addQTermsToExressionTree();
        
        SparseJacobianMatrix *getJacobianSparsityPattern();
        
        void duplicateExpressionTreesMap();
        
#ifdef COIN_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