OS  2.10.2
OSInstance.h
Go to the documentation of this file.
1 /* $Id: OSInstance.h 5284 2017-12-08 13:52:50Z stefan $ */
29 #ifndef OSINSTANCE_H
30 #define OSINSTANCE_H
31 #include "OSConfig.h"
32 #include "OSParameters.h"
33 #include "OSGeneral.h"
34 #include "OSMatrix.h"
35 #include "OSnLNode.h"
36 #include "OSExpressionTree.h"
37 #include <string>
38 #include <map>
39 
40 
44 class Variable
45 {
46 public:
49 
52 
56  double lb;
57 
61  double ub;
62 
66  char type;
67 
71  std::string name;
72 
76  bool IsEqual(Variable *that);
77 }; // class Variable
78 
79 
83 class Variables
84 {
85 public:
86 
89 
92 
95 
98 
102  bool IsEqual(Variables *that);
103 }; // class Variables
104 
105 
110 class ObjCoef
111 {
112 public:
113 
116 
119 
123  int idx;
124 
128  double value;
129 
133  bool IsEqual(ObjCoef *that);
134 };//class ObjCoef
135 
136 
142 {
143 public:
144 
147 
150 
152  std::string name;
153 
157  std::string maxOrMin;
158 
162  double constant;
163 
167  double weight;
168 
173 
177 
181  bool IsEqual(Objective *that);
182 };//class Objective
183 
189 {
190 public:
191 
194 
197 
202 
206 
210  bool IsEqual(Objectives *that);
211 };//class Objectives
212 
213 
219 {
220 public:
221 
224 
227 
229  std::string name;
230 
232  double constant;
233 
235  double lb;
236 
238  double ub;
239 
243  bool IsEqual(Constraint *that);
244 };//class Constraint
245 
246 
252 {
253 public:
254 
257 
260 
265 
269 
273  bool IsEqual(Constraints *that);
274 };//class Constraints
275 
276 
289 {
290 public:
291 
294 
297 
302 
307 
310 
313 
323 
328 };//class LinearConstraintCoefficients
329 
330 
341 {
342 public:
343 
346 
349 
353  int idx;
354 
358  int idxOne;
359 
363  int idxTwo;
364 
366  double coef;
367 
371  bool IsEqual(QuadraticTerm *that);
372 }; // QuadraticTerm
373 
374 
381 {
382 public:
383 
386 
389 
394 
398 
403 }; // QuadraticCoefficients
404 
405 
410 class Nl
411 {
412 public:
414  int idx;
415 
421 
428 
431 
435  Nl();
436 
440  ~Nl();
441 
445  bool IsEqual(Nl *that);
446 };//end Nl
447 
453 {
454 public:
455 
458 
461 
467 
469  Nl **nl;
470 
475 }; // NonlinearExpressions
476 
477 
482 class Matrices
483 {
484 public:
485 
488 
491 
497 
500 
504  bool IsEqual(Matrices *that);
505 
515  bool setRandom(double density, bool conformant, int iMin, int iMax);
516 
522  bool deepCopyFrom(Matrices *that);
523 }; // Matrices
524 
525 
530 class Cone
531 {
532 public:
533 
535  Cone();
536 
538  virtual ~Cone();
539 
545 
554 
557 
559  std::string name;
560 
562  int idx;
563 
567  virtual std::string getConeName();
568 
575  virtual std::string getConeInXML() = 0;
576 
577 
581  bool IsEqual(Cone *that);
582 
592  bool setRandom(double density, bool conformant, int iMin, int iMax);
593 
599  bool deepCopyFrom(Cone *that);
600 }; // Cone
601 
609 class NonnegativeCone : public Cone
610 {
611 public:
616 
621 
625  virtual std::string getConeName();
626 
633  virtual std::string getConeInXML();
634 
639 
649  bool setRandom(double density, bool conformant, int iMin, int iMax);
650 
657 
658 };//end NonnegativeCone
659 
667 class NonpositiveCone : public Cone
668 {
669 public:
674 
679 
683  virtual std::string getConeName();
684 
691  virtual std::string getConeInXML();
692 
697 
707  bool setRandom(double density, bool conformant, int iMin, int iMax);
708 
715 
716 };//end NonpositiveCone
717 
718 
726 class OrthantCone : public Cone
727 {
728 public:
733  double* ub;
734  double* lb;
735 
740 
745 
749  virtual std::string getConeName();
750 
757  virtual std::string getConeInXML();
758 
762  bool IsEqual(OrthantCone *that);
763 
773  bool setRandom(double density, bool conformant, int iMin, int iMax);
774 
781 };//end OrthantCone
782 
786 class PolyhedralCone : public Cone
787 {
788 public:
789 
792 
795 
801 
809 
811  int coneType;
812 
814  int idx;
815 
818 
822  virtual std::string getConeName();
823 
830  virtual std::string getConeInXML();
831 
835  bool IsEqual(PolyhedralCone *that);
836 
846  bool setRandom(double density, bool conformant, int iMin, int iMax);
847 
854 }; // PolyhedralCone
855 
856 
860 class QuadraticCone : public Cone
861 {
862 public:
863 
866 
869 
875 
883 
885  int coneType;
886 
888  int idx;
889 
898 
909 
913  virtual std::string getConeName();
914 
921  virtual std::string getConeInXML();
922 
926  bool IsEqual(QuadraticCone *that);
927 
937  bool setRandom(double density, bool conformant, int iMin, int iMax);
938 
945 }; // QuadraticCone
946 
947 
952 {
953 public:
954 
957 
960 
966 
974 
976  int coneType;
977 
979  int idx;
980 
989 
1001 
1005  virtual std::string getConeName();
1006 
1013  virtual std::string getConeInXML();
1014 
1019 
1029  bool setRandom(double density, bool conformant, int iMin, int iMax);
1030 
1037 }; // RotatedQuadraticCone
1038 
1039 /* Not yet implemented:
1040  ENUM_CONE_TYPE_normed,
1041 */
1042 
1046 class SemidefiniteCone : public Cone
1047 {
1048 public:
1049 
1052 
1055 
1061 
1069 
1072 
1074  int idx;
1075 
1077  std::string semidefiniteness;
1078 
1081 
1085  virtual std::string getConeName();
1086 
1093  virtual std::string getConeInXML();
1094 
1099 
1109  bool setRandom(double density, bool conformant, int iMin, int iMax);
1110 
1117 }; // SemidefiniteCone
1118 
1119 
1128 {
1129 public:
1134 
1139 
1143  virtual std::string getConeName();
1144 
1151  virtual std::string getConeInXML();
1152 
1157 
1167  bool setRandom(double density, bool conformant, int iMin, int iMax);
1168 
1175 
1176 };//end CopositiveMatricesCone
1177 
1178 
1187 {
1188 public:
1194 
1199 
1203  virtual std::string getConeName();
1204 
1212  virtual std::string getConeInXML();
1213 
1218 
1228  bool setRandom(double density, bool conformant, int iMin, int iMax);
1229 
1236 
1237 };//end CompletelyPositiveMatricesCone
1238 
1239 /* Not yet implemented:
1240  ENUM_CONE_TYPE_hyperbolicity,
1241  ENUM_CONE_TYPE_nonnegativePolynomials,
1242  ENUM_CONE_TYPE_moments,
1243 */
1244 
1248 class ProductCone : public Cone
1249 {
1250 public:
1251 
1254 
1257 
1263 
1271 
1274 
1276  int idx;
1277 
1282 
1286  virtual std::string getConeName();
1287 
1294  virtual std::string getConeInXML();
1295 
1299  bool IsEqual(ProductCone *that);
1300 
1310  bool setRandom(double density, bool conformant, int iMin, int iMax);
1311 
1312 
1319 }; // ProductCone
1320 
1324 class IntersectionCone : public Cone
1325 {
1326 public:
1327 
1330 
1333 
1339 
1347 
1350 
1352  int idx;
1353 
1358 
1362  virtual std::string getConeName();
1363 
1370  virtual std::string getConeInXML();
1371 
1376 
1386  bool setRandom(double density, bool conformant, int iMin, int iMax);
1387 
1394 }; // IntersectionCone
1395 
1396 
1400 class DualCone : public Cone
1401 {
1402 public:
1403 
1406 
1409 
1415 
1423 
1426 
1428  int idx;
1429 
1432 
1436  virtual std::string getConeName();
1437 
1441  bool IsEqual(DualCone *that);
1442 
1452  bool setRandom(double density, bool conformant, int iMin, int iMax);
1453 
1459  bool deepCopyFrom(DualCone *that);
1460 }; // DualCone
1461 
1465 class PolarCone : public Cone
1466 {
1467 public:
1468 
1471 
1474 
1480 
1488 
1491 
1493  int idx;
1494 
1497 
1501  virtual std::string getConeName();
1502 
1506  bool IsEqual(PolarCone *that);
1507 
1517  bool setRandom(double density, bool conformant, int iMin, int iMax);
1518 
1525 }; // PolarCone
1526 
1527 
1532 class Cones
1533 {
1534 public:
1535 
1538 
1541 
1547 
1550 
1554  bool IsEqual(Cones *that);
1555 
1564  bool setRandom(double density, bool conformant, int iMin, int iMax);
1565 
1571  bool deepCopyFrom(Cones *that);
1572 }; // Cones
1573 
1574 
1580 {
1581 public:
1584 
1587 
1592 
1597 
1600 
1603 
1606 
1609 
1611  std::string name;
1612 
1616  char varType;
1617 
1620 
1623 
1627  bool IsEqual(MatrixVar *that);
1628 }; // MatrixVar
1629 
1630 
1636 {
1637 public:
1640 
1643 
1646 
1649 
1654 }; // MatrixVariables
1655 
1656 
1662 {
1663 public:
1666 
1669 
1674 
1679 
1684 
1687 
1689  std::string name;
1690 
1693 
1696 
1700  bool IsEqual(MatrixObj *that);
1701 }; // MatrixObj
1702 
1703 
1709 {
1710 public:
1711 
1714 
1717 
1720 
1723 
1724 
1729 }; // MatrixObjectives
1730 
1731 
1737 {
1738 public:
1741 
1744 
1749 
1754 
1757 
1760 
1763 
1766 
1768  std::string name;
1769 
1772 
1775 
1779  bool IsEqual(MatrixCon *that);
1780 }; // MatrixCon
1781 
1782 
1788 {
1789 public:
1790 
1793 
1796 
1799 
1802 
1803 
1808 }; // MatrixConstraints
1809 
1817 {
1818 public:
1820  int idx;
1821 
1827 
1830 
1837 
1840 
1843 
1848 }; // MatrixExpression
1849 
1850 
1856 {
1857 public:
1860 
1865 
1868 
1871 
1876 }; // MatrixExpressions
1877 
1883 {
1884 public:
1887 
1890 
1893 
1896 
1899 
1902 
1903 
1908 
1918  bool setRandom(double density, bool conformant, int iMin, int iMax);
1919 
1926 }; // MatrixProgramming
1927 
1928 
1934 {
1935 public:
1936 
1939 
1942 
1944  int idx;
1945 }; // TimeDomainStageVar
1946 
1952 {
1953 public:
1954 
1957 
1960 
1963 
1966 
1969 }; // TimeDomainStageVariables
1970 
1971 
1977 {
1978 public:
1979 
1982 
1985 
1987  int idx;
1988 }; // TimeDomainStageCon
1989 
1995 {
1996 public:
1997 
2000 
2003 
2006 
2009 
2012 }; // TimeDomainStageConstraints
2013 
2014 
2020 {
2021 public:
2022 
2025 
2028 
2030  int idx;
2031 }; // TimeDomainStageObj
2032 
2038 {
2039 public:
2040 
2043 
2046 
2049 
2052 
2055 }; // TimeDomainStageObjectives
2056 
2057 
2063 {
2064 public:
2065 
2068 
2071 
2075  std::string name;
2076 
2079 
2082 
2085 }; // TimeDomainStage
2086 
2092 {
2093 public:
2094 
2097 
2100 
2105 
2108 }; // Stages
2109 
2115 {
2116 public:
2117 
2120 
2123 
2127  double start;
2128 
2132  double horizon;
2133 }; // Interval
2134 
2140 {
2141 public:
2142 
2145 
2148 
2152 
2156 }; // TimeDomain
2157 
2175 {
2176 public:
2177 
2180 
2183 
2186 
2189 
2192 
2197 
2202 
2207 
2212 
2217 
2222 
2227 
2231  bool IsEqual(InstanceData *that);
2232 }; // class InstanceData
2233 
2234 
2263 {
2264 public:
2265 
2268 
2271 
2276 
2279 
2283  bool IsEqual(OSInstance *that);
2284 
2289 
2294 
2299 
2304 
2305 private:
2310  std::string m_sInstanceName;
2314  std::string m_sInstanceSource;
2318  std::string m_sInstanceDescription;
2322  std::string m_sInstanceCreator;
2326  std::string m_sInstanceLicence;
2327 
2328 
2333  bool m_bProcessVariables;
2334 
2338  int m_iVariableNumber;
2339 
2343  int m_iNumberOfIntegerVariables;
2344 
2348  int m_iNumberOfBinaryVariables;
2349 
2353  int m_iNumberOfSemiContinuousVariables;
2354 
2358  int m_iNumberOfSemiIntegerVariables;
2359 
2363  int m_iNumberOfStringVariables;
2364 
2368  std::string* m_msVariableNames;
2369 
2374  char* m_mcVariableTypes;
2375 
2379  double* m_mdVariableLowerBounds;
2380 
2384  double* m_mdVariableUpperBounds;
2385 
2386 
2391  bool m_bProcessObjectives;
2392 
2396  int m_iObjectiveNumber;
2397 
2401  int m_iObjectiveNumberNonlinear;
2402 
2406  std::string* m_msObjectiveNames;
2407 
2411  std::string* m_msMaxOrMins;
2412 
2416  int* m_miNumberOfObjCoef;
2417 
2421  double* m_mdObjectiveConstants;
2422 
2426  double* m_mdObjectiveWeights;
2427 
2432  SparseVector** m_mObjectiveCoefficients;
2433 
2437  bool m_bGetDenseObjectives;
2438 
2443  double** m_mmdDenseObjectiveCoefficients;
2444 
2445 
2450  bool m_bProcessConstraints;
2451 
2455  int m_iConstraintNumber;
2456 
2460  int m_iConstraintNumberNonlinear;
2461 
2465  std::string* m_msConstraintNames;
2466 
2470  double* m_mdConstraintLowerBounds;
2471 
2475  double* m_mdConstraintUpperBounds;
2476 
2481  double* m_mdConstraintConstants;
2482 
2487  char* m_mcConstraintTypes;
2488 
2489 
2495  bool m_bProcessLinearConstraintCoefficients;
2496 
2501  int m_iLinearConstraintCoefficientNumber;
2502 
2507  bool m_bColumnMajor;
2508 
2514  SparseMatrix* m_linearConstraintCoefficientsInColumnMajor;
2515 
2521  SparseMatrix* m_linearConstraintCoefficientsInRowMajor;
2522 
2523 
2528  int m_iNumberOfQuadraticRowIndexes;
2529 
2533  bool m_bQuadraticRowIndexesProcessed;
2534 
2538  int *m_miQuadRowIndexes;
2539 
2543  bool m_bProcessQuadraticTerms;
2544 
2549  int m_iQuadraticTermNumber;
2550 
2555  QuadraticTerms* m_quadraticTerms;
2556 
2559  bool m_bQTermsAdded;
2560 
2561 
2567  int m_iNumberOfNonlinearExpressionTreeIndexes;
2568 
2573  bool m_bNonlinearExpressionTreeIndexesProcessed;
2574 
2580  int *m_miNonlinearExpressionTreeIndexes;
2581 
2587  int m_iNumberOfNonlinearExpressionTreeModIndexes;
2588 
2593  bool m_bNonlinearExpressionTreeModIndexesProcessed;
2594 
2599  int *m_miNonlinearExpressionTreeModIndexes;
2600 
2601 
2606  bool m_binitForAlgDiff;
2607 
2612  unsigned int m_iNumberOfNonlinearVariables;
2613 
2617  bool m_bProcessNonlinearExpressions;
2618 
2622  int m_iNonlinearExpressionNumber;
2623 
2628  int* m_miNonlinearExpressionIndexes;
2629 
2633  bool m_bProcessExpressionTrees;
2634 
2638  bool m_bProcessExpressionTreesMod;
2639 
2644  double *m_mdConstraintFunctionValues;
2645 
2650  double *m_mdObjectiveFunctionValues;
2651 
2655  int m_iJacValueSize;
2656 
2660  int *m_miJacStart;
2661 
2665  int *m_miJacIndex;
2666 
2670  double *m_mdJacValue;
2671 
2676  int *m_miJacNumConTerms;
2677 
2681  SparseJacobianMatrix *m_sparseJacMatrix;
2682 
2687  int m_iHighestTaylorCoeffOrder;
2688 
2697  std::map<int, ScalarExpressionTree*> m_mapExpressionTrees;
2698 
2703  std::map<int, int> m_mapOSADFunRangeIndex;
2704 
2713  std::map<int, MatrixExpressionTree*> m_mapMatrixExpressionTrees;
2714 
2719  ScalarExpressionTree *m_LagrangianExpTree;
2720 
2724  bool m_bLagrangianExpTreeCreated;
2725 
2729  SparseHessianMatrix* m_LagrangianSparseHessian;
2730 
2735  bool m_bLagrangianSparseHessianCreated;
2736 
2740  std::map<int, int> m_mapAllNonlinearVariablesIndex;
2741 
2746  int *m_miNonLinearVarsReverseMap;
2747 
2752  bool m_bAllNonlinearVariablesIndex;
2753 
2761  std::map<int, ScalarExpressionTree*> m_mapExpressionTreesMod ;
2762 
2768  bool m_bOSADFunIsCreated;
2769 
2774  bool m_bCppADTapesBuilt;
2775 
2780  bool m_bCppADMustReTape;
2781 
2785  bool m_bDuplicateExpressionTreesMap;
2786 
2790  bool m_bNonLinearStructuresInitialized;
2791 
2795  bool m_bSparseJacobianCalculated;
2796 
2802  std::map<int, std::vector<OSnLNode*> > m_mapExpressionTreesInPostfix ;
2803 
2808  int m_iHighestOrderEvaluated;
2809 
2814  double **m_mmdObjGradient;
2815 
2816 
2821  std::vector<double> m_vdX;
2822 
2826  std::vector<double> m_vdYval;
2827 
2832  std::vector<bool> m_vbLagHessNonz;
2833 
2837  std::vector<double> m_vdYjacval;
2838 
2842  std::vector<double> m_vdw;
2843 
2847  std::vector<double> m_vdLambda;
2848 
2852  std::vector<double> m_vdDomainUnitVec;
2853 
2857  std::vector<double> m_vdRangeUnitVec;
2858 
2859 
2864  bool m_bProcessMatrices;
2865 
2869  int m_iMatrixNumber;
2870 
2875  ENUM_MATRIX_SYMMETRY* m_miMatrixSymmetry;
2876 
2881  ENUM_MATRIX_TYPE* m_miMatrixType;
2882 
2886  int* m_miMatrixNumberOfColumns;
2887 
2891  int* m_miMatrixNumberOfRows;
2892 
2896  std::string* m_msMatrixNames;
2897 
2905  OSMatrix** m_mMatrix;
2906 
2907 #if 0
2930  GeneralSparseMatrix** m_mExpandedMatricesInColumnMajor;
2931 
2935  GeneralSparseMatrix** m_mExpandedMatricesInRowMajor;
2936 
2942  ExpandedMatrixBlocks** m_mMatrixBlocksInColumnMajor;
2943 
2949  OSnLMNode *m_mMatrixTransformation;
2950 #endif
2951 
2956  int m_iMatrixVarNumber;
2957 
2961  int m_iMatrixObjNumber;
2962 
2966  int m_iMatrixConNumber;
2967 
2971  int m_iMatrixExpressionNumber;
2972 
2973 
2978  bool m_bProcessTimeDomain;
2979 
2983  bool m_bProcessTimeStages;
2984 
2988  bool m_bProcessTimeInterval;
2989 
2993  bool m_bFiniteTimeStages;
2994 
2998  int m_iNumberOfTimeStages;
2999 
3003  std::string m_sTimeDomainFormat;
3004 
3008  std::string* m_msTimeDomainStageNames;
3009 
3010 
3011 
3012 
3016  int* m_miTimeDomainStageVariableNumber;
3017 
3021  int** m_mmiTimeDomainStageVarList;
3022 
3026  int* m_miTimeDomainStageConstraintNumber;
3027 
3031  int** m_mmiTimeDomainStageConList;
3032 
3036  int* m_miTimeDomainStageObjectiveNumber;
3037 
3041  int** m_mmiTimeDomainStageObjList;
3042 
3043 
3050  bool processVariables();
3051 
3058  bool processObjectives();
3059 
3066  bool processConstraints();
3067 
3074  bool processLinearConstraintCoefficients();
3075 
3082  bool processMatrices();
3083 
3084 public:
3085 
3090  std::string getInstanceName();
3091 
3096  std::string getInstanceSource();
3097 
3103  std::string getInstanceDescription();
3104 
3109  std::string getInstanceCreator();
3110 
3116  std::string getInstanceLicence();
3117 
3118 
3125 
3132  std::string* getVariableNames();
3133 
3141  //double* getVariableInitialValues();
3142 
3150  //std::string* getVariableInitialStringValues();
3151 
3164 
3170 
3176 
3182 
3188 
3194 
3202 
3210 
3217 
3218 
3225  std::string* getObjectiveNames();
3226 
3233  std::string* getObjectiveMaxOrMins();
3234 
3235 
3245 
3253 
3261 
3273 
3281 
3288 
3295  std::string* getConstraintNames();
3296 
3304 
3312 
3320 
3335 
3342 
3343 
3351 
3352 
3360 
3368 
3375 
3385 
3394 
3401 
3402 
3403 /*********************************************************************
3404  * *
3405  * Here we have a number of methods for dealing with *
3406  * scalar-valued expression trees. *
3407  * Even though the tree can contain OSnLMNodes (e.g., to compute *
3408  * the trace of a matrix), the root of the tree is of type OSnLNode. *
3409  * *
3410  *********************************************************************/
3411 
3418 
3425 
3432 
3440 
3449  std::vector<ExprNode*> getNonlinearExpressionTreeInPostfix( int rowIdx);
3450 
3458  std::vector<ExprNode*> getNonlinearExpressionTreeModInPostfix( int rowIdx);
3459 
3466  std::vector<ExprNode*> getNonlinearExpressionTreeInPrefix( int rowIdx);
3467 
3475  std::string getNonlinearExpressionTreeInInfix( int rowIdx);
3476 
3477 
3485  std::vector<ExprNode*> getNonlinearExpressionTreeModInPrefix( int rowIdx);
3486 
3487 
3492 
3497 
3503  std::map<int, ScalarExpressionTree* > getAllNonlinearExpressionTrees();
3504 
3508  std::map<int, ScalarExpressionTree* > getAllNonlinearExpressionTreesMod();
3509 
3517 
3518 
3525 
3526 
3535 
3543 
3550 
3564 
3575 
3583 // int getNumberOfBlocksForMatrix(int n);
3584 
3593 
3602 
3611 
3619  std::string getMatrixName(int n);
3620 
3627  bool matrixHasBase(int n);
3628  bool matrixHasElements(int n);
3630  bool matrixHasBlocks(int n);
3634 
3643 
3652 
3661 
3669 // SymmetricMatrixBlocks* getSymmetricMatrixBlocks(int n);
3670 
3682  GeneralSparseMatrix* getMatrixBlockInColumnMajorForm(int n, int columnIdx, int rowIdx);
3683 
3684 
3685 /***********************************************************************
3686  * *
3687  * Here we have a number of methods for dealing with *
3688  * matrix programming and matrix-valued expression trees. *
3689  * Even though the tree can contain OSnLNodes (e.g., to compute the *
3690  * scalar multiple of a matrix), the root of the tree is an OSnLMNode. *
3691  * *
3692  ***********************************************************************/
3693 
3700 
3707 
3714 
3721 
3728 
3735 
3742  std::vector<ExprNode*> getMatrixExpressionTreeInPostfix( int rowIdx);
3743 
3751  std::vector<ExprNode*> getMatrixExpressionTreeModInPostfix( int rowIdx);
3752 
3759  std::vector<ExprNode*> getMatrixExpressionTreeInPrefix( int rowIdx);
3760 
3768  std::string getMatrixExpressionTreeInInfix( int rowIdx);
3769 
3770 
3774  std::map<int, MatrixExpressionTree* > getAllMatrixExpressionTrees();
3775 
3776 
3780  std::map<int, MatrixExpressionTree* > getAllMatrixExpressionTreesMod();
3781 
3789 
3790 
3797 
3798 //===============================================
3799 
3805  std::string getTimeDomainFormat();
3806 
3813 
3819  std::string* getTimeDomainStageNames();
3820 
3827 
3828 
3835 
3842 
3849 
3856 
3863 
3870 
3877 
3878 
3879 
3880  // the set() methods
3881 
3882 
3889  bool setInstanceName(std::string name);
3890 
3897  bool setInstanceSource(std::string source);
3898 
3905  bool setInstanceDescription(std::string description);
3906 
3913  bool setInstanceCreator(std::string fileCreator);
3914 
3921  bool setInstanceLicence(std::string licence);
3922 
3923 
3930  bool setVariableNumber(int number);
3931 
3947  bool addVariable(int index, std::string name, double lowerBound, double upperBound, char type);
3948 
3968  bool setVariables(int number, std::string* names, double* lowerBounds,
3969  double* upperBounds, char* types);
3970 
3971 
3978  bool setObjectiveNumber(int number);
3979 
3997  bool addObjective(int index, std::string name, std::string maxOrMin, double constant, double weight, SparseVector* objectiveCoefficients);
3998 
4014  bool setObjectives(int number, std::string *names, std::string *maxOrMins, double *constants, double *weights, SparseVector **objectitiveCoefficients);
4015 
4022  bool setConstraintNumber(int number);
4023 
4037  bool addConstraint(int index, std::string name, double lowerBound, double upperBound, double constant);
4038 
4052  bool setConstraints(int number, std::string* names, double* lowerBounds, double* upperBounds, double* constants);
4053 
4072  bool setLinearConstraintCoefficients(int numberOfValues, bool isColumnMajor,
4073  double* values, int valuesBegin, int valuesEnd,
4074  int* indexes, int indexesBegin, int indexesEnd,
4075  int* starts, int startsBegin, int startsEnd);
4076 
4095  bool copyLinearConstraintCoefficients(int numberOfValues, bool isColumnMajor,
4096  double* values, int valuesBegin, int valuesEnd,
4097  int* indexes, int indexesBegin, int indexesEnd,
4098  int* starts, int startsBegin, int startsEnd);
4099 
4109 
4126  bool setQuadraticCoefficients(int number,
4127  int* rowIndexes, int* varOneIndexes, int* varTwoIndexes,
4128  double* coefficients, int begin, int end);
4129 
4130 
4145  int* rowIndexes, int* varOneIndexes, int* varTwoIndexes, double* coefficients);
4146 
4156  bool setNonlinearExpressions(int nexpr, Nl** root);
4157 
4164  bool setMatrixNumber(int number);
4165 
4188  bool addMatrix(int index, std::string name, int numberOfRows, int numberOfColumns,
4189  ENUM_MATRIX_SYMMETRY symmetry, ENUM_MATRIX_TYPE matrixType,
4190  unsigned int inumberOfChildren, MatrixNode **m_mChildren);
4191 
4192 
4199  bool setConeNumber(int number);
4200 
4227  bool addCone(int index, int numberOfRows, int numberOfColumns, ENUM_CONE_TYPE coneType,
4228  std::string name, int numberOfOtherIndexes = 0, int* otherIndexes = NULL);
4229 
4256  bool addCone(int index, int numberOfRows, int numberOfColumns, ENUM_CONE_TYPE coneType,
4257  std::string name, int numberOfComponents, int* components,
4258  int numberOfOtherIndexes = 0, int* otherIndexes = NULL);
4259 
4286  bool addCone(int index, int numberOfRows, int numberOfColumns, ENUM_CONE_TYPE coneType,
4287  std::string name, int referenceIdx, int numberOfOtherIndexes = 0, int* otherIndexes = NULL);
4288 
4314  bool addCone(int index, int numberOfRows, int numberOfColumns, ENUM_CONE_TYPE coneType,
4315  std::string name, std::string semidefiniteness, int numberOfOtherIndexes = 0, int* otherIndexes = NULL);
4316 
4343  bool addCone(int index, int numberOfRows, int numberOfColumns, ENUM_CONE_TYPE coneType,
4344  std::string name, int distortionMatrixIdx, double normFactor, int axisDirection,
4345  int numberOfOtherIndexes = 0, int* otherIndexes = NULL);
4346 
4374  bool addCone(int index, int numberOfRows, int numberOfColumns, ENUM_CONE_TYPE coneType,
4375  std::string name, int distortionMatrixIdx, double normFactor, int firstAxisDirection,
4376  int secondAxisDirection, int numberOfOtherIndexes = 0, int* otherIndexes = NULL);
4377 
4404  bool addCone(int index, int numberOfRows, int numberOfColumns, ENUM_CONE_TYPE coneType,
4405  std::string name, int distortionMatrixIdx, double normFactor, int axisDirection, double pNorm,
4406  int numberOfOtherIndexes = 0, int* otherIndexes = NULL);
4407 
4438  bool addCone(int index, int numberOfRows, int numberOfColumns, ENUM_CONE_TYPE coneType,
4439  std::string name, int maxDegree, int numberOfUB, double* ub, int numberOfLB, double* lb,
4440  int numberOfOtherIndexes = 0, int* otherIndexes = NULL);
4441 
4442 
4443  // methods to print the current model or parts of it
4444 
4449  std::string printModel( );
4450 
4458  std::string printModel( int rowIdx);
4459 
4460 
4461 
4462  // nonlinear API methods
4463 
4464 
4471 
4485  double calculateFunctionValue(int idx, double* x, bool new_x);
4486 
4501  double *calculateAllConstraintFunctionValues(double* x, double *objLambda, double *conLambda,
4502  bool new_x, int highestOrder);
4503 
4517  double *calculateAllConstraintFunctionValues(double* x, bool new_x);
4518 
4534  double *calculateAllObjectiveFunctionValues(double* x, double *objLambda, double *conLambda,
4535  bool new_x, int highestOrder);
4536 
4550  double *calculateAllObjectiveFunctionValues(double* x, bool new_x);
4551 
4552 
4568  double *conLambda, bool new_x, int highestOrder);
4569 
4570 
4586  SparseVector *calculateConstraintFunctionGradient(double* x, double *objLambda, double *conLambda,
4587  int idx, bool new_x, int highestOrder);
4588 
4602  SparseVector *calculateConstraintFunctionGradient(double* x, int idx, bool new_x );
4603 
4618  double **calculateAllObjectiveFunctionGradients(double* x, double *objLambda, double *conLambda,
4619  bool new_x, int highestOrder);
4620 
4636  double *calculateObjectiveFunctionGradient(double* x, double *objLambda, double *conLambda,
4637  int objIdx, bool new_x, int highestOrder);
4638 
4652  double *calculateObjectiveFunctionGradient(double* x, int objIdx, bool new_x );
4653 
4671  SparseHessianMatrix *calculateLagrangianHessian( double* x, double *objLambda, double *conLambda,
4672  bool new_x, int highestOrder);
4673 
4686  SparseHessianMatrix *calculateHessian( double* x, int idx, bool new_x);
4687 
4688 
4694 
4700 
4706 
4711  std::map<int, int> getAllNonlinearVariablesIndexMap( );
4712 
4718 
4726 
4734 
4740 
4746 
4747 #ifdef OS_HAS_CPPAD
4752  CppAD::ADFun<double> *Fad;
4753 #endif
4765  bool createOSADFun(std::vector<double> vdX );
4766 
4777  std::vector<double> forwardAD(int p, std::vector<double> vdX);
4778 
4789  std::vector<double> reverseAD(int p, std::vector<double> vdlambda);
4790 
4804 
4824  bool getIterateResults(double *x, double *objLambda, double *conLambda,
4825  bool new_x, int highestOrder);
4826 
4827 
4828 
4841  bool getZeroOrderResults(double *x, double *objLambda, double *conLambda);
4842 
4855  bool getFirstOrderResults(double *x, double *objLambda, double *conLambda );
4856 
4869  bool getSecondOrderResults(double *x, double *objLambda, double *conLambda );
4870 
4871 
4882 
4893 
4894 
4900 
4901 
4905  bool setTimeDomain(std::string format);
4906 
4910  bool setTimeDomainStages(int number, std::string *names);
4911 
4918  bool setTimeDomainStageVariablesOrdered(int numberOfStages, int *numberOfVariables, int *startIdx);
4919 
4926  bool setTimeDomainStageVariablesUnordered(int numberOfStages, int *numberOfVariables, int **varIndex);
4927 
4933  bool setTimeDomainStageConstraintsOrdered(int numberOfStages, int *numberOfConstraints, int *startIdx);
4934 
4940  bool setTimeDomainStageConstraintsUnordered(int numberOfStages, int *numberOfConstraints, int **conIndex);
4941 
4947  bool setTimeDomainStageObjectivesOrdered(int numberOfStages, int *numberOfObjectives, int *startIdx);
4948 
4954  bool setTimeDomainStageObjectivesUnordered(int numberOfStages, int *numberOfObjectives, int **varIndex);
4955 
4959  bool setTimeDomainInterval(double start, double horizon);
4960 
4961 
4962 }; //class OSInstance
4963 
4964 #endif
4965 
ENUM_NL_EXPR_SHAPE
Definition: OSParameters.h:831
ENUM_CONE_TYPE
Definition: OSParameters.h:866
ENUM_MATRIX_TYPE
An enum to track the many different types of values that a matrix can contain Note that these types a...
Definition: OSParameters.h:600
ENUM_MATRIX_SYMMETRY
Definition: OSParameters.h:736
This file defines the OSnLNode class along with its derived classes.
The CompletelyPositiveMatricesCone Class.
Definition: OSInstance.h:1187
bool setRandom(double density, bool conformant, int iMin, int iMax)
A function to make a random instance of this class.
~CompletelyPositiveMatricesCone()
default destructor.
CompletelyPositiveMatricesCone()
default constructor.
bool deepCopyFrom(CompletelyPositiveMatricesCone *that)
A function to make a deep copy of an instance of this class.
virtual std::string getConeName()
virtual std::string getConeInXML()
Write a CompletelyPositiveMatricesCone object in XML format.
bool IsEqual(CompletelyPositiveMatricesCone *that)
A function to check for the equality of two objects.
The in-memory representation of a generic cone Specific cone types are derived from this generic clas...
Definition: OSInstance.h:531
int numberOfOtherIndexes
Cones can also be formed by Multidimensional tensors.
Definition: OSInstance.h:552
virtual std::string getConeInXML()=0
Write a Cone object in XML format.
std::string name
The cone can have a name for easier identification.
Definition: OSInstance.h:559
int idx
cones are referenced by an (automatically created) index
Definition: OSInstance.h:562
bool IsEqual(Cone *that)
A function to check for the equality of two objects.
bool setRandom(double density, bool conformant, int iMin, int iMax)
A function to make a random instance of this class.
ENUM_CONE_TYPE coneType
The type of the cone.
Definition: OSInstance.h:556
bool deepCopyFrom(Cone *that)
A function to make a deep copy of an instance of this class.
virtual std::string getConeName()
int * otherIndexes
Definition: OSInstance.h:553
int numberOfRows
Every cone has (at least) two dimensions; no distinction is made between vector cones and matrix cone...
Definition: OSInstance.h:543
Cone()
The Cone class constructor.
int numberOfColumns
Definition: OSInstance.h:544
virtual ~Cone()
The Cone class destructor.
The in-memory representation of the <cones> element.
Definition: OSInstance.h:1533
~Cones()
The Cones class destructor.
Cone ** cone
cone is pointer to an array of Cone object pointers
Definition: OSInstance.h:1549
bool setRandom(double density, bool conformant, int iMin, int iMax)
A function to make a random instance of this class.
bool IsEqual(Cones *that)
A function to check for the equality of two objects.
Cones()
The Cones class constructor.
bool deepCopyFrom(Cones *that)
A function to make a deep copy of an instance of this class.
int numberOfCones
numberOfCones is the number of <nl> elements in the <cones> element.
Definition: OSInstance.h:1546
The in-memory representation of the <con> element.
Definition: OSInstance.h:219
double constant
constant is a value that is added to the constraint
Definition: OSInstance.h:232
double ub
ub is the upper bound on the constraint
Definition: OSInstance.h:238
bool IsEqual(Constraint *that)
A function to check for the equality of two objects.
double lb
lb is the lower bound on the constraint
Definition: OSInstance.h:235
Constraint()
The Constraint class constructor.
~Constraint()
The Constraint class destructor.
std::string name
name is the name of the constraint
Definition: OSInstance.h:229
The in-memory representation of the <constraints> element.
Definition: OSInstance.h:252
int numberOfConstraints
numberOfConstraints is the number of constraints in the instance
Definition: OSInstance.h:264
Constraint ** con
con is pointer to an array of Constraint object pointers
Definition: OSInstance.h:268
~Constraints()
The Constraints class destructor.
Constraints()
The Constraints class constructor.
bool IsEqual(Constraints *that)
A function to check for the equality of two objects.
The CopositiveMatricesCone Class.
Definition: OSInstance.h:1128
bool setRandom(double density, bool conformant, int iMin, int iMax)
A function to make a random instance of this class.
CopositiveMatricesCone()
default constructor.
bool deepCopyFrom(CopositiveMatricesCone *that)
A function to make a deep copy of an instance of this class.
bool IsEqual(CopositiveMatricesCone *that)
A function to check for the equality of two objects.
~CopositiveMatricesCone()
default destructor.
virtual std::string getConeName()
virtual std::string getConeInXML()
Write a CopositiveMatricesCone object in XML format.
a double vector data structure
Definition: OSGeneral.h:610
The in-memory representation of a dual cone.
Definition: OSInstance.h:1401
int coneType
The type of the cone (one of the values in ENUM_CONE_TYPE)
Definition: OSInstance.h:1425
int numberOfOtherIndexes
Multidimensional tensors can also form cones (the Kronecker product, for instance,...
Definition: OSInstance.h:1421
int numberOfColumns
Definition: OSInstance.h:1414
int referenceConeIdx
Dual cones use a reference to another, previously defined cone.
Definition: OSInstance.h:1431
~DualCone()
The DualCone class destructor.
virtual std::string getConeName()
int numberOfRows
Every cone has (at least) two dimensions; no distinction is made between vector cones and matrix cone...
Definition: OSInstance.h:1413
int idx
cones are referenced by an (automatically created) index
Definition: OSInstance.h:1428
bool IsEqual(DualCone *that)
A function to check for the equality of two objects.
bool setRandom(double density, bool conformant, int iMin, int iMax)
A function to make a random instance of this class.
int * otherIndexes
Definition: OSInstance.h:1422
bool deepCopyFrom(DualCone *that)
A function to make a deep copy of an instance of this class.
DualCone()
The DualCone class constructor.
a sparse matrix data structure for matrices that can hold nonconstant values and have block structure...
Definition: OSMatrix.h:1769
a data structure that holds general information about files that conform to one of the OSxL schemas
Definition: OSGeneral.h:33
a sparse matrix data structure for matrices that can hold nonconstant values
Definition: OSMatrix.h:1655
The in-memory representation of the <instanceData> element.
Definition: OSInstance.h:2175
Cones * cones
cones is a pointer to a Cones object
Definition: OSInstance.h:2216
Objectives * objectives
objectives is a pointer to a Objectives object
Definition: OSInstance.h:2188
Constraints * constraints
constraints is a pointer to a Constraints object
Definition: OSInstance.h:2191
Variables * variables
variables is a pointer to a Variables object
Definition: OSInstance.h:2185
MatrixProgramming * matrixProgramming
matrixProgramming is a pointer to a MatrixProgramming object
Definition: OSInstance.h:2221
QuadraticCoefficients * quadraticCoefficients
quadraticCoefficients is a pointer to a QuadraticCoefficients object
Definition: OSInstance.h:2201
LinearConstraintCoefficients * linearConstraintCoefficients
linearConstraintCoefficients is a pointer to a LinearConstraintCoefficients object
Definition: OSInstance.h:2196
TimeDomain * timeDomain
timeDomain is a pointer to a TimeDomain object
Definition: OSInstance.h:2226
bool IsEqual(InstanceData *that)
A function to check for the equality of two objects.
InstanceData()
The InstanceData class constructor.
Matrices * matrices
matrices is a pointer to a Matrices object
Definition: OSInstance.h:2211
~InstanceData()
The InstanceData class destructor.
NonlinearExpressions * nonlinearExpressions
nonlinearExpressions is a pointer to a NonlinearExpressions object
Definition: OSInstance.h:2206
an integer Vector data structure
Definition: OSGeneral.h:470
The in-memory representation of an intersection cone.
Definition: OSInstance.h:1325
~IntersectionCone()
The IntersectionCone class destructor.
bool deepCopyFrom(IntersectionCone *that)
A function to make a deep copy of an instance of this class.
int coneType
The type of the cone (one of the values in ENUM_CONE_TYPE)
Definition: OSInstance.h:1349
virtual std::string getConeName()
IntersectionCone()
The IntersectionCone class constructor.
bool IsEqual(IntersectionCone *that)
A function to check for the equality of two objects.
int numberOfOtherIndexes
Multidimensional tensors can also form cones (the Kronecker product, for instance,...
Definition: OSInstance.h:1345
int idx
cones are referenced by an (automatically created) index
Definition: OSInstance.h:1352
bool setRandom(double density, bool conformant, int iMin, int iMax)
A function to make a random instance of this class.
IntVector * components
the list of components contributing to the intersection each component contains a reference to a prev...
Definition: OSInstance.h:1357
virtual std::string getConeInXML()
Write an IntersectionCone object in XML format.
int numberOfRows
Every cone has (at least) two dimensions; no distinction is made between vector cones and matrix cone...
Definition: OSInstance.h:1337
The in-memory representation of the <linearConstraintCoefficients> element.
Definition: OSInstance.h:289
int iNumberOfStartElements
iNumberOfStartElements counts the number of elements in the <start> section of <linearConstraintCoeff...
Definition: OSInstance.h:322
int numberOfValues
numberOfValues is the number of nonzero elements stored in the <linearConstraintCoefficients> element
Definition: OSInstance.h:301
~LinearConstraintCoefficients()
The LinearConstraintCoefficients class destructor.
bool IsEqual(LinearConstraintCoefficients *that)
A function to check for the equality of two objects.
IntVector * start
a pointer to the start of each row or column stored in sparse format
Definition: OSInstance.h:306
IntVector * colIdx
a pointer of column indices if the problem is stored by row
Definition: OSInstance.h:312
IntVector * rowIdx
a pointer of row indices if the problem is stored by column
Definition: OSInstance.h:309
LinearConstraintCoefficients()
The LinearConstraintCoefficients class constructor.
DoubleVector * value
a pointer to the array of nonzero values being stored
Definition: OSInstance.h:315
The in-memory representation of the <matrices> element.
Definition: OSInstance.h:483
bool setRandom(double density, bool conformant, int iMin, int iMax)
A function to make a random instance of this class.
bool IsEqual(Matrices *that)
A function to check for the equality of two objects.
~Matrices()
The Matrices class destructor.
int numberOfMatrices
numberOfMatrices is the number of <nl> elements in the <matrices> element.
Definition: OSInstance.h:496
OSMatrix ** matrix
matrix is a pointer to an array of OSMatrix object pointers
Definition: OSInstance.h:499
Matrices()
The Matrices class constructor.
bool deepCopyFrom(Matrices *that)
A function to make a deep copy of an instance of this class.
The in-memory representation of the <matrixCon> element.
Definition: OSInstance.h:1737
MatrixCon()
The MatrixCon class constructor.
int numberOfColumns
numberOfColumns gives the number of columns of this matrix
Definition: OSInstance.h:1743
~MatrixCon()
The MatrixCon class destructor.
std::string name
an optional name to this MatrixCon
Definition: OSInstance.h:1768
int lbConeIdx
lbConeIdx gives a cone that must contain matrixCon - lbMatrix
Definition: OSInstance.h:1759
int ubConeIdx
ubConeIdx gives a cone that must contain ubMatrix - matrixCon
Definition: OSInstance.h:1765
int lbMatrixIdx
lbMatrixIdx gives a lower bound for this matrixCon
Definition: OSInstance.h:1756
int numberOfRows
numberOfRows gives the number of rows of this matrix
Definition: OSInstance.h:1740
int templateMatrixIdx
templateMatrixIdx refers to a matrix that describes the locations in this matrixVar that are allowed ...
Definition: OSInstance.h:1748
bool IsEqual(MatrixCon *that)
A function to check for the equality of two objects.
int conReferenceMatrixIdx
conReferenceMatrixIdx allows some or all of the components of this matrixCon to be copied from constr...
Definition: OSInstance.h:1753
int ubMatrixIdx
ubMatrixIdx gives an upper bound for this matrixCon
Definition: OSInstance.h:1762
The in-memory representation of the <matrixConstraints> element.
Definition: OSInstance.h:1788
~MatrixConstraints()
The MatrixConstraints class destructor.
int numberOfMatrixCon
numberOfMatrixCon gives the number of <matrixCon> children
Definition: OSInstance.h:1798
bool IsEqual(MatrixConstraints *that)
A function to check for the equality of two objects.
MatrixConstraints()
The MatrixConstraints class constructor.
MatrixCon ** matrixCon
matrixCon is an array of pointers to the <matrixCon> children
Definition: OSInstance.h:1801
Used to hold the instance in memory.
The in-memory representation of the <expr> element, which is like a nonlinear expression,...
Definition: OSInstance.h:1817
int idx
idx holds the row index of the nonlinear expression
Definition: OSInstance.h:1820
bool IsEqual(MatrixExpression *that)
A function to check for the equality of two objects.
MatrixExpressionTree * matrixExpressionTree
matrixExpressionTree contains the root of the MatrixExpressionTree
Definition: OSInstance.h:1829
~MatrixExpression()
The MatrixExpression class destructor.
bool m_bDeleteExpressionTree
if m_bDeleteExpressionTree is true during garbage collection, we should delete the osExpression tree ...
Definition: OSInstance.h:1836
MatrixExpression()
The MatrixExpression class constructor.
ENUM_NL_EXPR_SHAPE shape
shape holds the shape of the nonlinear expression (linear/quadratic/convex/general) (see further up i...
Definition: OSInstance.h:1826
The in-memory representation of the <matrixExpressions> element.
Definition: OSInstance.h:1856
int numberOfExpr
numberOfExpr gives the number of expressions
Definition: OSInstance.h:1859
bool IsEqual(MatrixExpressions *that)
A function to check for the equality of two objects.
MatrixExpressions()
The MatrixExpressions class constructor.
MatrixExpression ** expr
a pointer to an array of linear and nonlinear expressions that evaluate to matrices
Definition: OSInstance.h:1864
~MatrixExpressions()
The MatrixExpressions class destructor.
a generic class from which we derive matrix constructors (BaseMatrix, MatrixElements,...
Definition: OSMatrix.h:51
The in-memory representation of the <matrixObj> element.
Definition: OSInstance.h:1662
int numberOfColumns
numberOfColumns gives the number of columns of this matrix
Definition: OSInstance.h:1668
int numberOfRows
numberOfRows gives the number of rows of this matrix
Definition: OSInstance.h:1665
bool IsEqual(MatrixObj *that)
A function to check for the equality of two objects.
int orderConeIdx
orderConeIdx gives a cone that expresses preferences during the optimization x is (weakly) preferred ...
Definition: OSInstance.h:1683
MatrixObj()
The MatrixVar class constructor.
int constantMatrixIdx
constantMatrixIdx gives a constant added to the matrixObj
Definition: OSInstance.h:1686
~MatrixObj()
The MatrixVar class destructor.
int templateMatrixIdx
templateMatrixIdx refers to a matrix that describes the locations in this matrixObj that are allowed ...
Definition: OSInstance.h:1673
std::string name
an optional name to this matrixObj
Definition: OSInstance.h:1689
int objReferenceMatrixIdx
objReferenceMatrixIdx allows some or all of the components of this matrixObj to be copied from object...
Definition: OSInstance.h:1678
The in-memory representation of the <matrixObjectives> element.
Definition: OSInstance.h:1709
~MatrixObjectives()
The MatrixObjectives class destructor.
bool IsEqual(MatrixObjectives *that)
A function to check for the equality of two objects.
MatrixObjectives()
The MatrixObjectives class constructor.
int numberOfMatrixObj
numberOfMatrixObj gives the number of <matrixObj> children
Definition: OSInstance.h:1719
MatrixObj ** matrixObj
matrixObj is an array of pointers to the <matrixObj> children
Definition: OSInstance.h:1722
The in-memory representation of the <matrixProgramming> element.
Definition: OSInstance.h:1883
MatrixObjectives * matrixObjectives
a pointer to the matrixObjectives object
Definition: OSInstance.h:1895
bool setRandom(double density, bool conformant, int iMin, int iMax)
A function to make a random instance of this class.
~MatrixProgramming()
The MatrixProgramming class destructor.
bool deepCopyFrom(MatrixProgramming *that)
A function to make a deep copy of an instance of this class.
MatrixProgramming()
The MatrixProgramming class constructor.
MatrixConstraints * matrixConstraints
a pointer to the matrixConstraints object
Definition: OSInstance.h:1898
bool IsEqual(MatrixProgramming *that)
A function to check for the equality of two objects.
MatrixExpressions * matrixExpressions
a pointer to the matrixExpressions object
Definition: OSInstance.h:1901
MatrixVariables * matrixVariables
a pointer to the matrixVariables object
Definition: OSInstance.h:1892
The in-memory representation of the <matrixVar> element.
Definition: OSInstance.h:1580
int ubConeIdx
ubConeIdx gives a cone that must contain ubMatrix - matrixVar
Definition: OSInstance.h:1608
bool IsEqual(MatrixVar *that)
A function to check for the equality of two objects.
char varType
an optional variable type (C, B, I, D, J, S).
Definition: OSInstance.h:1616
int lbMatrixIdx
lbMatrixIdx gives a lower bound for this matrixVar
Definition: OSInstance.h:1599
~MatrixVar()
The MatrixVar class destructor.
std::string name
an optional name to this matrixVar
Definition: OSInstance.h:1611
int lbConeIdx
lbConeIdx gives a cone that must contain matrixVar - lbMatrix
Definition: OSInstance.h:1602
int numberOfRows
numberOfRows gives the number of rows of this matrix
Definition: OSInstance.h:1583
int varReferenceMatrixIdx
varReferenceMatrixIdx allows some or all of the components of this matrix variable to be copied from ...
Definition: OSInstance.h:1596
int numberOfColumns
numberOfColumns gives the number of columns of this matrix
Definition: OSInstance.h:1586
MatrixVar()
The MatrixVar class constructor.
int ubMatrixIdx
ubMatrixIdx gives an upper bound for this matrixVar
Definition: OSInstance.h:1605
int templateMatrixIdx
templateMatrixIdx refers to a matrix that describes the locations in this matrixVar that are allowed ...
Definition: OSInstance.h:1591
The in-memory representation of the <matrixVariables> element.
Definition: OSInstance.h:1636
MatrixVariables()
The MatrixVariables class constructor.
MatrixVar ** matrixVar
matrixVar is an array of pointers to the <matrixVar> children
Definition: OSInstance.h:1642
bool IsEqual(MatrixVariables *that)
A function to check for the equality of two objects.
~MatrixVariables()
The MatrixVariables class destructor.
int numberOfMatrixVar
numberOfMatrixVar gives the number of <matrixVar> children
Definition: OSInstance.h:1639
The in-memory representation of the <nl> element.
Definition: OSInstance.h:411
int idx
idx holds the row index of the nonlinear expression
Definition: OSInstance.h:414
ScalarExpressionTree * osExpressionTree
osExpressionTree contains the root of the ScalarExpressionTree
Definition: OSInstance.h:430
ENUM_NL_EXPR_SHAPE shape
shape holds the shape of the nonlinear expression (linear/quadratic/convex/general) (see further up i...
Definition: OSInstance.h:420
bool IsEqual(Nl *that)
A function to check for the equality of two objects.
~Nl()
default destructor.
Nl()
default constructor.
bool m_bDeleteExpressionTree
m_bDeleteExpressionTree is true, if in garbage collection, we should delete the osExpression tree obj...
Definition: OSInstance.h:427
The in-memory representation of the <nonlinearExpressions> element.
Definition: OSInstance.h:453
~NonlinearExpressions()
The NonlinearExpressions class destructor.
Nl ** nl
nl is pointer to an array of Nl object pointers
Definition: OSInstance.h:469
int numberOfNonlinearExpressions
numberOfNonlinearExpressions is the number of <nl> elements in the <nonlinearExpressions> element.
Definition: OSInstance.h:466
NonlinearExpressions()
The NonlinearExpressions class constructor.
bool IsEqual(NonlinearExpressions *that)
A function to check for the equality of two objects.
The NonnegativeCone Class.
Definition: OSInstance.h:610
virtual std::string getConeInXML()
Write a NonnegativeCone object in XML format.
virtual std::string getConeName()
bool setRandom(double density, bool conformant, int iMin, int iMax)
A function to make a random instance of this class.
bool deepCopyFrom(NonnegativeCone *that)
A function to make a deep copy of an instance of this class.
bool IsEqual(NonnegativeCone *that)
A function to check for the equality of two objects.
NonnegativeCone()
default constructor.
~NonnegativeCone()
default destructor.
The NonpositiveCone Class.
Definition: OSInstance.h:668
bool IsEqual(NonpositiveCone *that)
A function to check for the equality of two objects.
virtual std::string getConeName()
virtual std::string getConeInXML()
Write a NonpositiveCone object in XML format.
bool setRandom(double density, bool conformant, int iMin, int iMax)
A function to make a random instance of this class.
bool deepCopyFrom(NonpositiveCone *that)
A function to make a deep copy of an instance of this class.
~NonpositiveCone()
default destructor.
NonpositiveCone()
default constructor.
The in-memory representation of an OSiL instance.
Definition: OSInstance.h:2263
bool getIterateResults(double *x, double *objLambda, double *conLambda, bool new_x, int highestOrder)
end revised AD code
int getNumberOfColumnsForMatrix(int n)
Get the number of blocks in the matrix.
bool setTimeDomain(std::string format)
This sets the format of the time domain ("stages"/"interval"/"none")
std::string getTimeDomainFormat()
Get the format of the time domain ("stages"/"interval")
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)
add a cone.
int * getQuadraticRowIndexes()
Get the indexes of rows which have a quadratic term.
SparseMatrix * getLinearConstraintCoefficientsInRowMajor()
Get linear constraint coefficients in row major.
SparseHessianMatrix * getLagrangianHessianSparsityPattern()
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)
add a cone.
std::vector< ExprNode * > getMatrixExpressionTreeInPrefix(int rowIdx)
Get the prefix tokens for a given row index.
int getNumberOfQuadraticTerms()
Get the number of specified (usually nonzero) qTerms in the quadratic coefficients.
bool setInstanceLicence(std::string licence)
set the instance licence.
Nl ** getNonlinearExpressions()
Get the pointers to the roots of all expression trees.
double * getObjectiveConstants()
Get objective constants.
std::string * getVariableNames()
Get variable names.
bool copyLinearConstraintCoefficients(int numberOfValues, bool isColumnMajor, double *values, int valuesBegin, int valuesEnd, int *indexes, int indexesBegin, int indexesEnd, int *starts, int startsBegin, int startsEnd)
copy linear constraint coefficients: perform a deep copy of the sparse matrix
bool setConstraintNumber(int number)
set the number of constraints.
std::vector< ExprNode * > getMatrixExpressionTreeInPostfix(int rowIdx)
Get the postfix tokens for a given row index.
SparseVector * calculateConstraintFunctionGradient(double *x, int idx, bool new_x)
Calculate the gradient of the constraint function indexed by idx this function is overloaded.
bool setTimeDomainStages(int number, std::string *names)
This sets the number (and optionally names) of the time stages.
bool matrixHasBase(int n)
Several tools to parse the constructor list of a matrix.
bool bVariablesModified
bVariablesModified is true if the variables data has been modified.
Definition: OSInstance.h:2288
bool setInstanceCreator(std::string fileCreator)
set the instance creator.
double * calculateAllObjectiveFunctionValues(double *x, double *objLambda, double *conLambda, bool new_x, int highestOrder)
Calculate all of the objective function values.
bool matrixHasTransformations(int n)
GeneralSparseMatrix * getMatrixBlockInColumnMajorForm(int n, int columnIdx, int rowIdx)
Get the (nonzero) elements of the matrix in symmetric block form.
int getNumberOfBlocksConstructors(int n)
bool bObjectivesModified
bObjectivesModified is true if the objective function data has been modified.
Definition: OSInstance.h:2293
int getADSparsityHessian()
end revised AD code
std::string printModel(int rowIdx)
Print the infix representation of the row (which could be an an objective function row) indexed by ro...
bool addQTermsToExressionTree()
bool addVariable(int index, std::string name, double lowerBound, double upperBound, char type)
add a variable.
bool bAMatrixModified
bAMatrixModified is true if the A matrix data has been modified.
Definition: OSInstance.h:2303
bool setTimeDomainStageConstraintsUnordered(int numberOfStages, int *numberOfConstraints, int **conIndex)
This sets the constraints associated with each time domain stage in srbitrary order.
std::string printModel()
Print the infix representation of the problem.
int * getTimeDomainStageNumberOfVariables()
Get the number of variables contained in each time stage.
int getNumberOfNonlinearExpressionTreeIndexes()
Get the number of unique nonlinear expression tree indexes.
int getNumberOfNonlinearExpressionTreeModIndexes()
Get the number of unique nonlinear expression tree indexes after modifying the expression tree to con...
bool getZeroOrderResults(double *x, double *objLambda, double *conLambda)
Calculate function values.
int getTimeDomainStageNumber()
Get the number of stages that make up the time domain.
int getNumberOfIntegerVariables()
getNumberOfIntegerVariables
bool getSparseJacobianFromColumnMajor()
std::string getInstanceName()
Get instance name.
OSMatrix * getMatrix(int n)
Get the list of constructors of the matrix.
bool bUseExpTreeForFunEval
bUseExpTreeForFunEval is set to true if you wish to use the OS Expression Tree for function evaluatio...
Definition: OSInstance.h:4899
ScalarExpressionTree * getLagrangianExpTree()
bool setNumberOfQuadraticTerms(int nq)
set the number of quadratic terms
bool setConeNumber(int number)
set the number of cones
bool getFirstOrderResults(double *x, double *objLambda, double *conLambda)
Calculate first derivatives.
bool addConstraint(int index, std::string name, double lowerBound, double upperBound, double constant)
add a constraint.
double getTimeDomainIntervalHorizon()
Get the horizon for the time domain interval.
int getNumberOfBinaryVariables()
getNumberOfBinaryVariables
std::string getInstanceLicence()
Get instance licence.
double * getConstraintLowerBounds()
Get constraint lower bounds.
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)
add a cone.
int getNumberOfNonlinearObjectives()
bool setQuadraticTermsInNonlinearExpressions(int number, int *rowIndexes, int *varOneIndexes, int *varTwoIndexes, double *coefficients)
set quadratic terms in nonlinearExpressions
std::string * getTimeDomainStageNames()
Get the names of the stages (NULL or empty string ("") if a stage has not been given a name.
bool setNonlinearExpressions(int nexpr, Nl **root)
set nonlinear expressions
SparseJacobianMatrix * getJacobianSparsityPattern()
bool matrixHasElements(int n)
ScalarExpressionTree * getNonlinearExpressionTreeMod(int rowIdx)
Get the expression tree for a given row index for the modified expression trees (quadratic terms adde...
bool getLinearConstraintCoefficientMajor()
Get whether the constraint coefficients is in column major (true) or row major (false).
bool addCone(int index, int numberOfRows, int numberOfColumns, ENUM_CONE_TYPE coneType, std::string name, int numberOfOtherIndexes=0, int *otherIndexes=NULL)
add a cone.
ENUM_MATRIX_TYPE getMatrixType(int n)
Get the matrix type.
std::vector< double > reverseAD(int p, std::vector< double > vdlambda)
Perform an AD reverse sweep.
bool initObjGradients()
This should be called by initForAlgDiff()
bool addCone(int index, int numberOfRows, int numberOfColumns, ENUM_CONE_TYPE coneType, std::string name, int referenceIdx, int numberOfOtherIndexes=0, int *otherIndexes=NULL)
add a cone.
std::string getInstanceDescription()
Get instance description.
int getNumberOfMatrixVariables()
Get the number of matrix variables.
std::vector< ExprNode * > getNonlinearExpressionTreeModInPostfix(int rowIdx)
Get the postfix tokens for a given row index for the modified Expression Tree (quadratic terms added)...
int getConstraintNumber()
Get number of constraints.
int ** getTimeDomainStageObjList()
Get the list of objectives in each stage.
double * getVariableLowerBounds()
Get variable lower bounds.
double * calculateAllConstraintFunctionValues(double *x, double *objLambda, double *conLambda, bool new_x, int highestOrder)
Calculate all of the constraint function values.
bool setQuadraticCoefficients(int number, int *rowIndexes, int *varOneIndexes, int *varTwoIndexes, double *coefficients, int begin, int end)
set quadratic coefficients into the QuadraticCoefficients->qTerm data structure
int getNumberOfMatrixExpressionTreeIndexes()
Get the number of unique matrix expression tree indexes.
char * getVariableTypes()
Get variable initial values.
int getNumberOfStringVariables()
getNumberOfStringVariables
double ** calculateAllObjectiveFunctionGradients(double *x, double *objLambda, double *conLambda, bool new_x, int highestOrder)
Calculate the gradient of all objective functions.
bool bConstraintsModified
bConstraintsModified is true if the constraints data has been modified.
Definition: OSInstance.h:2298
int * getMatrixExpressionTreeIndexes()
Get all the matrix expression tree indexes, i.e.
std::map< int, MatrixExpressionTree * > getAllMatrixExpressionTreesMod()
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)
add a cone.
int getLinearConstraintCoefficientNumber()
Get number of specified (usually nonzero) linear constraint coefficient values.
int getNumberOfSemiIntegerVariables()
getNumberOfSemiIntegerVariables
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)
add a matrix.
std::vector< ExprNode * > getNonlinearExpressionTreeModInPrefix(int rowIdx)
Get the prefix tokens for a given row index for the modified Expression Tree (quadratic terms added).
int getNumberOfMatrixConstraints()
Get the number of matrix constraints.
double calculateFunctionValue(int idx, double *x, bool new_x)
Calculate the function value for function (constraint or objective) indexed by idx.
double getTimeDomainIntervalStart()
Get the start for the time domain interval.
std::string * getObjectiveMaxOrMins()
Get objective maxOrMins.
std::vector< ExprNode * > getNonlinearExpressionTreeInPrefix(int rowIdx)
Get the prefix tokens for a given row index.
SparseVector ** getObjectiveCoefficients()
Get objective coefficients.
int getNumberOfValuesForMatrix(int n)
Get the number of (nonzero) values in the matrix.
bool matrixHasBlocks(int n)
std::vector< ExprNode * > getNonlinearExpressionTreeInPostfix(int rowIdx)
Get the postfix tokens for a given row index.
int getNumberOfQuadraticRowIndexes()
Get the number of rows which have a quadratic term.
ENUM_MATRIX_SYMMETRY getMatrixSymmetry(int n)
Get the matrix symmetry.
bool getSparseJacobianFromRowMajor()
GeneralSparseMatrix * getMatrixCoefficientsInColumnMajor(int n)
Get the (nonzero) elements of the matrix in column major form.
std::map< int, ScalarExpressionTree * > getAllNonlinearExpressionTreesMod()
SparseHessianMatrix * calculateHessian(double *x, int idx, bool new_x)
Calculate the Hessian of a constraint or objective function.
ScalarExpressionTree * getNonlinearExpressionTree(int rowIdx)
Get the expression tree for a given row index.
int getNumberOfSemiContinuousVariables()
getNumberOfSemiContinuousVariables
int getMatrixNumber()
Get the number of matrices.
bool setTimeDomainStageConstraintsOrdered(int numberOfStages, int *numberOfConstraints, int *startIdx)
This sets the constraints associated with each time domain stage in temporal order.
bool setVariables(int number, std::string *names, double *lowerBounds, double *upperBounds, char *types)
set all the variable related elements.
bool createOSADFun(std::vector< double > vdX)
Create the a CppAD Function object: this is a function where the domain is the set of variables for t...
int * getNonlinearExpressionTreeModIndexes()
Get all the nonlinear expression tree indexes, i.e., indexes of rows (objectives or constraints) that...
std::vector< ExprNode * > getMatrixExpressionTreeModInPostfix(int rowIdx)
Get the postfix tokens for a given row index for the modified Expression Tree (quadratic terms added)...
bool setTimeDomainStageVariablesOrdered(int numberOfStages, int *numberOfVariables, int *startIdx)
This sets the variables associated with each time domain stage in temporal order.
bool setInstanceSource(std::string source)
set the instance source.
bool setTimeDomainStageVariablesUnordered(int numberOfStages, int *numberOfVariables, int **varIndex)
This sets the variables associated with each time domain stage in srbitrary order.
int ** getTimeDomainStageVarList()
Get the list of variables in each stage.
bool initForAlgDiff()
This should be called by nonlinear solvers using callback functions.
double * calculateAllConstraintFunctionValues(double *x, bool new_x)
Calculate all of the constraint function values, we are overloading this function and this version of...
GeneralFileHeader * instanceHeader
the instanceHeader is implemented as a general file header object to allow sharing of classes between...
Definition: OSInstance.h:2275
SparseJacobianMatrix * calculateAllConstraintFunctionGradients(double *x, double *objLambda, double *conLambda, bool new_x, int highestOrder)
Calculate the gradient of all constraint functions.
std::string getInstanceSource()
Get instance source.
double * calculateObjectiveFunctionGradient(double *x, int objIdx, bool new_x)
Calculate the gradient of the objective function indexed by objIdx this function is overloaded.
std::map< int, int > getAllNonlinearVariablesIndexMap()
char * getConstraintTypes()
Get constraint types.
bool setLinearConstraintCoefficients(int numberOfValues, bool isColumnMajor, double *values, int valuesBegin, int valuesEnd, int *indexes, int indexesBegin, int indexesEnd, int *starts, int startsBegin, int startsEnd)
set linear constraint coefficients
int getNumberOfElementConstructors(int n)
double * getConstraintUpperBounds()
Get constraint upper bounds.
OSInstance()
The OSInstance class constructor.
SparseVector * calculateConstraintFunctionGradient(double *x, double *objLambda, double *conLambda, int idx, bool new_x, int highestOrder)
Calculate the gradient of the constraint function indexed by idx.
int * getTimeDomainStageNumberOfObjectives()
Get the number of objectives contained in each time stage.
double * getConstraintConstants()
Get constraint constants.
std::string * getConstraintNames()
Get constraint names.
std::string getMatrixExpressionTreeInInfix(int rowIdx)
Get the infix representation for a given row (or objective function) index.
int getNumberOfNonlinearExpressions()
Get number of nonlinear expressions.
InstanceData * instanceData
A pointer to an InstanceData object.
Definition: OSInstance.h:2278
double ** getDenseObjectiveCoefficients()
getDenseObjectiveCoefficients.
bool addCone(int index, int numberOfRows, int numberOfColumns, ENUM_CONE_TYPE coneType, std::string name, std::string semidefiniteness, int numberOfOtherIndexes=0, int *otherIndexes=NULL)
add a cone.
double * getObjectiveWeights()
Get objective weights.
std::map< int, MatrixExpressionTree * > getAllMatrixExpressionTrees()
SparseHessianMatrix * calculateLagrangianHessian(double *x, double *objLambda, double *conLambda, bool new_x, int highestOrder)
Calculate the Hessian of the Lagrangian Expression Tree This method will build the CppAD expression t...
int * getObjectiveCoefficientNumbers()
Get objective coefficient number.
double * calculateAllObjectiveFunctionValues(double *x, bool new_x)
Calculate all of the objective function values, we are overloading this function and this version of ...
int getNumberOfMatrixObjectives()
Get the number of matrix objectives.
QuadraticTerms * getQuadraticTerms()
Get all the quadratic terms in the instance.
int getVariableNumber()
Get number of variables.
double * getVariableUpperBounds()
Get variable upper bounds.
std::map< int, ScalarExpressionTree * > getAllNonlinearExpressionTrees()
~OSInstance()
The OSInstance class destructor.
bool setTimeDomainStageObjectivesOrdered(int numberOfStages, int *numberOfObjectives, int *startIdx)
This sets the objectives associated with each time domain stage in temporal order.
bool setInstanceDescription(std::string description)
set the instance description.
bool setTimeDomainInterval(double start, double horizon)
This sets the start and end of the time interval.
int * getNonlinearExpressionTreeIndexes()
Get all the nonlinear expression tree indexes, i.e., indexes of rows (objectives or constraints) that...
bool setObjectives(int number, std::string *names, std::string *maxOrMins, double *constants, double *weights, SparseVector **objectitiveCoefficients)
set all the objectives related elements.
int getNumberOfRowsForMatrix(int n)
Get the number of rows in the matrix.
bool setTimeDomainStageObjectivesUnordered(int numberOfStages, int *numberOfObjectives, int **varIndex)
This sets the objectives associated with each time domain stage in arbitrary order.
MatrixExpression ** getMatrixExpressions()
Get the pointers to the roots of all matrix expression trees.
double * calculateObjectiveFunctionGradient(double *x, double *objLambda, double *conLambda, int objIdx, bool new_x, int highestOrder)
Calculate the gradient of the objective function indexed by objIdx.
MatrixExpressionTree * getMatrixExpressionTree(int rowIdx)
Get the matrix expression tree for a given row index.
int getNumberOfTransformationConstructors(int n)
int getNumberOfMatrixExpressions()
Get the number of matrix-valued expressions.
std::string * getObjectiveNames()
Get objective names.
bool addQTermsToExpressionTree()
This method adds quadratic terms into the array of expression trees.
std::string getInstanceCreator()
Get instance fileCreator.
bool setInstanceName(std::string name)
set the instance name.
bool addObjective(int index, std::string name, std::string maxOrMin, double constant, double weight, SparseVector *objectiveCoefficients)
add an objective.
bool setConstraints(int number, std::string *names, double *lowerBounds, double *upperBounds, double *constants)
set all the constraint related elements.
bool setObjectiveNumber(int number)
set the number of objectives.
int ** getTimeDomainStageConList()
Get the list of constraints in each stage.
std::string getNonlinearExpressionTreeInInfix(int rowIdx)
Get the infix representation for a given row (or objective function) index.
bool setMatrixNumber(int number)
set the number of matrices
bool setVariableNumber(int number)
set the number of variables.
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)
add a cone.
bool initializeNonLinearStructures()
Initialize the data structures for the nonlinear API.
int getObjectiveNumber()
Get number of objectives.
int * getTimeDomainStageNumberOfConstraints()
Get the number of constraints contained in each time stage.
bool getSecondOrderResults(double *x, double *objLambda, double *conLambda)
Calculate second derivatives.
GeneralSparseMatrix * getMatrixCoefficientsInRowMajor(int n)
Get the (nonzero) elements of the matrix in row major form.
SparseMatrix * getLinearConstraintCoefficientsInColumnMajor()
Get linear constraint coefficients in column major.
bool IsEqual(OSInstance *that)
A function to check for the equality of two objects.
std::string getMatrixName(int n)
Get the name of the matrix.
int getNumberOfNonlinearConstraints()
void duplicateExpressionTreesMap()
duplicate the map of expression trees.
std::vector< double > forwardAD(int p, std::vector< double > vdX)
Perform an AD forward sweep.
a data structure to represent a matrix object (derived from MatrixType)
Definition: OSMatrix.h:2186
The OSnLMNode Class for nonlinear expressions involving matrices.
Definition: OSnLNode.h:1761
The in-memory representation of the objective function <coef> element.
Definition: OSInstance.h:111
bool IsEqual(ObjCoef *that)
A function to check for the equality of two objects.
double value
value is the value of the objective function coefficient corresponding to the variable with index idx
Definition: OSInstance.h:128
ObjCoef()
The ObjCoef class constructor.
int idx
idx is the index of the variable corresponding to the coefficient
Definition: OSInstance.h:123
~ObjCoef()
The ObjCoef class destructor.
The in-memory representation of the <obj> element.
Definition: OSInstance.h:142
ObjCoef ** coef
coef is pointer to an array of ObjCoef object pointers
Definition: OSInstance.h:176
double constant
constant is the constant term added to the objective function, 0 by default
Definition: OSInstance.h:162
double weight
weight is the weight applied to the given objective function, 1.0 by default
Definition: OSInstance.h:167
bool IsEqual(Objective *that)
A function to check for the equality of two objects.
int numberOfObjCoef
numberOfObjCoef is the number of variables with a nonzero objective function coefficient
Definition: OSInstance.h:172
~Objective()
The Objective class destructor.
Objective()
The Objective class constructor.
std::string name
the name of the objective function
Definition: OSInstance.h:152
std::string maxOrMin
declare the objective function to be a max or a min
Definition: OSInstance.h:157
The in-memory representation of the <objectives> element.
Definition: OSInstance.h:189
bool IsEqual(Objectives *that)
A function to check for the equality of two objects.
Objective ** obj
coef is pointer to an array of ObjCoef object pointers
Definition: OSInstance.h:205
int numberOfObjectives
numberOfObjectives is the number of objective functions in the instance
Definition: OSInstance.h:201
Objectives()
The Objectives class constructor.
~Objectives()
The Objectives class destructor.
The OrthantCone Class.
Definition: OSInstance.h:727
bool setRandom(double density, bool conformant, int iMin, int iMax)
A function to make a random instance of this class.
OrthantCone()
default constructor.
~OrthantCone()
default destructor.
bool IsEqual(OrthantCone *that)
A function to check for the equality of two objects.
virtual std::string getConeInXML()
Write an OrthantCone object in XML format.
virtual std::string getConeName()
bool deepCopyFrom(OrthantCone *that)
A function to make a deep copy of an instance of this class.
double * ub
For each dimension of the cone, give the upper and lower bounds The upper bound can be only zero or +...
Definition: OSInstance.h:733
double * lb
Definition: OSInstance.h:734
The in-memory representation of a polar cone.
Definition: OSInstance.h:1466
int numberOfOtherIndexes
Multidimensional tensors can also form cones (the Kronecker product, for instance,...
Definition: OSInstance.h:1486
bool IsEqual(PolarCone *that)
A function to check for the equality of two objects.
int referenceConeIdx
Polar cones use a reference to another, previously defined cone.
Definition: OSInstance.h:1496
PolarCone()
The PolarCone class constructor.
int numberOfColumns
Definition: OSInstance.h:1479
int * otherIndexes
Definition: OSInstance.h:1487
int idx
cones are referenced by an (automatically created) index
Definition: OSInstance.h:1493
bool setRandom(double density, bool conformant, int iMin, int iMax)
A function to make a random instance of this class.
int numberOfRows
Every cone has (at least) two dimensions; no distinction is made between vector cones and matrix cone...
Definition: OSInstance.h:1478
virtual std::string getConeName()
~PolarCone()
The PolarCone class destructor.
int coneType
The type of the cone (one of the values in ENUM_CONE_TYPE)
Definition: OSInstance.h:1490
bool deepCopyFrom(PolarCone *that)
A function to make a deep copy of an instance of this class.
The in-memory representation of a polyhedral cone.
Definition: OSInstance.h:787
bool deepCopyFrom(PolyhedralCone *that)
A function to make a deep copy of an instance of this class.
int idx
cones are referenced by an (automatically created) index
Definition: OSInstance.h:814
~PolyhedralCone()
The PolyhedralCone class destructor.
int numberOfOtherIndexes
Multidimensional tensors can also form cones (the Kronecker product, for instance,...
Definition: OSInstance.h:807
int * otherIndexes
Definition: OSInstance.h:808
int numberOfRows
Every cone has (at least) two dimensions; no distinction is made between vector cones and matrix cone...
Definition: OSInstance.h:799
int coneType
The type of the cone (one of the values in ENUM_CONE_TYPE)
Definition: OSInstance.h:811
bool IsEqual(PolyhedralCone *that)
A function to check for the equality of two objects.
PolyhedralCone()
The PolyhedralCone class constructor.
virtual std::string getConeName()
int referenceMatrixIdx
Polyhedral cones use a reference to a previously defined matrix for the extreme rays.
Definition: OSInstance.h:817
virtual std::string getConeInXML()
Write a PolyhedralCone object in XML format.
bool setRandom(double density, bool conformant, int iMin, int iMax)
A function to make a random instance of this class.
The in-memory representation of a product cone.
Definition: OSInstance.h:1249
virtual std::string getConeInXML()
Write a ProductCone object in XML format.
~ProductCone()
The ProductCone class destructor.
IntVector * factors
the list of "factors" contributing to the product each factor contains a reference to a previously de...
Definition: OSInstance.h:1281
virtual std::string getConeName()
int coneType
The type of the cone (one of the values in ENUM_CONE_TYPE)
Definition: OSInstance.h:1273
ProductCone()
The ProductCone class constructor.
int * otherIndexes
Definition: OSInstance.h:1270
int numberOfColumns
Definition: OSInstance.h:1262
bool deepCopyFrom(ProductCone *that)
A function to make a deep copy of an instance of this class.
bool setRandom(double density, bool conformant, int iMin, int iMax)
A function to make a random instance of this class.
int numberOfOtherIndexes
Multidimensional tensors can also form cones (the Kronecker product, for instance,...
Definition: OSInstance.h:1269
int numberOfRows
Every cone has (at least) two dimensions; no distinction is made between vector cones and matrix cone...
Definition: OSInstance.h:1261
bool IsEqual(ProductCone *that)
A function to check for the equality of two objects.
int idx
cones are referenced by an (automatically created) index
Definition: OSInstance.h:1276
The in-memory representation of the <quadraticCoefficients> element.
Definition: OSInstance.h:381
QuadraticTerm ** qTerm
qTerm is a pointer to an array of QuadraticTerm object pointers
Definition: OSInstance.h:397
bool IsEqual(QuadraticCoefficients *that)
A function to check for the equality of two objects.
QuadraticCoefficients()
The QuadraticCoefficients class constructor.
int numberOfQuadraticTerms
numberOfQuadraticTerms is the number of quadratic terms in the <quadraticCoefficients> element.
Definition: OSInstance.h:393
~QuadraticCoefficients()
The QuadraticCoefficients class destructor.
The in-memory representation of a quadratic cone.
Definition: OSInstance.h:861
bool deepCopyFrom(QuadraticCone *that)
A function to make a deep copy of an instance of this class.
virtual std::string getConeName()
int numberOfOtherIndexes
Multidimensional tensors can also form cones (the Kronecker product, for instance,...
Definition: OSInstance.h:881
int * otherIndexes
Definition: OSInstance.h:882
bool setRandom(double density, bool conformant, int iMin, int iMax)
A function to make a random instance of this class.
int numberOfColumns
Definition: OSInstance.h:874
~QuadraticCone()
The QuadraticCone class destructor.
int axisDirection
The index of the first component can be changed Since there are possibly many dimensions,...
Definition: OSInstance.h:908
int coneType
The type of the cone (one of the values in ENUM_CONE_TYPE)
Definition: OSInstance.h:885
bool IsEqual(QuadraticCone *that)
A function to check for the equality of two objects.
int numberOfRows
Every cone has (at least) two dimensions; no distinction is made between vector cones and matrix cone...
Definition: OSInstance.h:873
int distortionMatrixIdx
Definition: OSInstance.h:897
int idx
cones are referenced by an (automatically created) index
Definition: OSInstance.h:888
QuadraticCone()
The QuadraticCone class constructor.
double normScaleFactor
quadratic cones normally are of the form x0 >= x1^2 + x2^2 + ...
Definition: OSInstance.h:896
virtual std::string getConeInXML()
Write a QuadraticCone object in XML format.
The in-memory representation of the <qTerm> element.
Definition: OSInstance.h:341
double coef
coef is the coefficient of the quadratic term
Definition: OSInstance.h:366
int idxOne
idxOne is the index of the first variable in the quadratic term
Definition: OSInstance.h:358
~QuadraticTerm()
The QuadraticTerm class destructor.
QuadraticTerm()
The QuadraticTerm class constructor.
bool IsEqual(QuadraticTerm *that)
A function to check for the equality of two objects.
int idx
idx is the index of the row in which the quadratic term appears
Definition: OSInstance.h:353
int idxTwo
idxTwo is the index of the second variable in the quadratic term
Definition: OSInstance.h:363
a data structure for holding quadratic terms
Definition: OSGeneral.h:432
The in-memory representation of a rotated quadratic cone.
Definition: OSInstance.h:952
virtual std::string getConeInXML()
Write a RotatedQuadraticCone object in XML format.
int numberOfOtherIndexes
Multidimensional tensors can also form cones (the Kronecker product, for instance,...
Definition: OSInstance.h:972
bool IsEqual(RotatedQuadraticCone *that)
A function to check for the equality of two objects.
~RotatedQuadraticCone()
The RotatedQuadraticCone class destructor.
bool setRandom(double density, bool conformant, int iMin, int iMax)
A function to make a random instance of this class.
double normScaleFactor
rotated quadratic cones normally are of the form x0x1 >= x2^2 + x3^2 + ...
Definition: OSInstance.h:987
int coneType
The type of the cone (one of the values in ENUM_CONE_TYPE)
Definition: OSInstance.h:976
int idx
cones are referenced by an (automatically created) index
Definition: OSInstance.h:979
bool deepCopyFrom(RotatedQuadraticCone *that)
A function to make a deep copy of an instance of this class.
virtual std::string getConeName()
RotatedQuadraticCone()
The RotatedQuadraticCone class constructor.
int firstAxisDirection
The indices of the first two component can be changed Since there are possibly many dimensions,...
Definition: OSInstance.h:999
int numberOfRows
Every cone has (at least) two dimensions; no distinction is made between vector cones and matrix cone...
Definition: OSInstance.h:964
Used to hold part of the instance in memory.
The in-memory representation of a cone of semidefinite matrices.
Definition: OSInstance.h:1047
~SemidefiniteCone()
The SemidefiniteCone class destructor.
bool isPositiveSemiDefinite
information about semidefiniteness is also tracked in a boolean variable
Definition: OSInstance.h:1080
int coneType
The type of the cone (one of the values in ENUM_CONE_TYPE)
Definition: OSInstance.h:1071
SemidefiniteCone()
The SemidefiniteCone class constructor.
bool setRandom(double density, bool conformant, int iMin, int iMax)
A function to make a random instance of this class.
int numberOfOtherIndexes
Multidimensional tensors can also form cones (the Kronecker product, for instance,...
Definition: OSInstance.h:1067
int idx
cones are referenced by an (automatically created) index
Definition: OSInstance.h:1074
virtual std::string getConeInXML()
Write a SemidefiniteCone object in XML format.
bool deepCopyFrom(SemidefiniteCone *that)
A function to make a deep copy of an instance of this class.
std::string semidefiniteness
we need to distinguish positive and negative semidefiniteness
Definition: OSInstance.h:1077
int numberOfRows
Every cone has (at least) two dimensions; no distinction is made between vector cones and matrix cone...
Definition: OSInstance.h:1059
bool IsEqual(SemidefiniteCone *that)
A function to check for the equality of two objects.
virtual std::string getConeName()
The in-memory representation of a SparseHessianMatrix.
Definition: OSGeneral.h:377
a sparse Jacobian matrix data structure
Definition: OSGeneral.h:301
a sparse matrix data structure
Definition: OSGeneral.h:224
a sparse vector data structure
Definition: OSGeneral.h:123
~TimeDomainInterval()
The Interval class destructor.
double start
start is the start of the planning period in the <interval> element.
Definition: OSInstance.h:2127
double horizon
horizon is the end of the planning period in the <interval> element.
Definition: OSInstance.h:2132
TimeDomainInterval()
The Interval class constructor.
The in-memory representation of the <con> element.
Definition: OSInstance.h:1977
int idx
idx gives the index of this constraint
Definition: OSInstance.h:1987
~TimeDomainStageCon()
The TimeDomainStageCon class destructor.
TimeDomainStageCon()
The TimeDomainStageCon class constructor.
The in-memory representation of the <constraints> child of the <stage> element.
Definition: OSInstance.h:1995
int numberOfConstraints
numberOfConstraints gives the number of constraints contained in this stage
Definition: OSInstance.h:2005
~TimeDomainStageConstraints()
The TimeDomainStageConstraints class destructor.
TimeDomainStageConstraints()
The TimeDomainStageConstraints class constructor.
TimeDomainStageCon ** con
con is a pointer to an array of TimeDomainStageCon object pointers
Definition: OSInstance.h:2011
int startIdx
startdIdx gives the number of the first constraint contained in this stage
Definition: OSInstance.h:2008
The in-memory representation of the <obj> element.
Definition: OSInstance.h:2020
int idx
idx gives the index of this variable
Definition: OSInstance.h:2030
~TimeDomainStageObj()
The TimeDomainStageObj class destructor.
TimeDomainStageObj()
The TimeDomainStageObj class constructor.
The in-memory representation of the <objectives> child of the <stage> element.
Definition: OSInstance.h:2038
int startIdx
startdIdx gives the number of the first objective contained in this stage
Definition: OSInstance.h:2051
TimeDomainStageObjectives()
The TimeDomainStageObjectives class constructor.
int numberOfObjectives
numberOfObjectives gives the number of objectives contained in this stage
Definition: OSInstance.h:2048
TimeDomainStageObj ** obj
obj is a pointer to an array of TimeDomainStageObj object pointers
Definition: OSInstance.h:2054
~TimeDomainStageObjectives()
The TimeDomainStageObjectives class destructor.
The in-memory representation of the element.
Definition: OSInstance.h:1934
TimeDomainStageVar()
The TimeDomainStageVar class constructor.
int idx
idx gives the index of this variable
Definition: OSInstance.h:1944
~TimeDomainStageVar()
The TimeDomainStageVar class destructor.
The in-memory representation of the <variables> child of the <stage> element.
Definition: OSInstance.h:1952
TimeDomainStageVariables()
The TimeDomainStageVariables class constructor.
int numberOfVariables
numberOfVariables gives the number of variables contained in this stage
Definition: OSInstance.h:1962
int startIdx
startdIdx gives the number of the first variable contained in this stage
Definition: OSInstance.h:1965
~TimeDomainStageVariables()
The TimeDomainStageVariables class destructor.
TimeDomainStageVar ** var
var is a pointer to an array of TimeDomainStageVar object pointers
Definition: OSInstance.h:1968
The in-memory representation of the <stage> element.
Definition: OSInstance.h:2063
TimeDomainStageObjectives * objectives
objectives is a pointer to a TimeDomainObjectives object
Definition: OSInstance.h:2084
std::string name
name corresponds to the optional attribute that holds the name of the stage; the default value is emp...
Definition: OSInstance.h:2075
~TimeDomainStage()
The TimeDomainStage class destructor.
TimeDomainStageVariables * variables
variables is a pointer to a TimeDomainVariables object
Definition: OSInstance.h:2078
TimeDomainStageConstraints * constraints
constraints is a pointer to a TimeDomainConstraints object
Definition: OSInstance.h:2081
TimeDomainStage()
The TimeDomainStage class constructor.
The in-memory representation of the <stages> element.
Definition: OSInstance.h:2092
TimeDomainStages()
The Stages class constructor.
int numberOfStages
numberOfStages is the number of stages in the <stages> element.
Definition: OSInstance.h:2104
TimeDomainStage ** stage
stage is pointer to an array of stage object pointers
Definition: OSInstance.h:2107
~TimeDomainStages()
The Stages class destructor.
The in-memory representation of the <timeDomain> element.
Definition: OSInstance.h:2140
TimeDomainStages * stages
stages is a pointer to a Stages object
Definition: OSInstance.h:2151
TimeDomainInterval * interval
interval is a pointer to an Interval object
Definition: OSInstance.h:2155
TimeDomain()
The TimeDomain class constructor.
~TimeDomain()
The TimeDomain class destructor.
The in-memory representation of the variable element.
Definition: OSInstance.h:45
bool IsEqual(Variable *that)
A function to check for the equality of two objects.
Variable()
The Variable class constructor.
double ub
ub corresponds to the optional attribute that holds the variable upper bound.
Definition: OSInstance.h:61
std::string name
name corresponds to the optional attribute that holds the variable name, the default value is empty
Definition: OSInstance.h:71
~Variable()
The Variable class destructor.
double lb
lb corresponds to the optional attribute that holds the variable lower bound.
Definition: OSInstance.h:56
char type
type corresponds to the attribute that holds the variable type: C (Continuous), B (binary),...
Definition: OSInstance.h:66
The in-memory representation of the variables element.
Definition: OSInstance.h:84
bool IsEqual(Variables *that)
A function to check for the equality of two objects.
Variables()
The Variables class constructor.
~Variables()
The Variables class destructor.
int numberOfVariables
numberOfVariables is the number of variables in the instance
Definition: OSInstance.h:94
Variable ** var
Here we define a pointer to an array of var pointers.
Definition: OSInstance.h:97