My Project
OSParameters.h
Go to the documentation of this file.
1/* $Id$ */
16//kipp fix up the infinity issue
17//kipp define OSINFINITY to COIN_DBL_MAX
18
19#ifndef OSPARAMETERS
20#define OSPARAMETERS
21
22#include "OSConfig.h"
23
24#include <string>
25#include <limits>
26
27#define OS_PLUS 1001
28#define OS_SUM 1002
29#define OS_MINUS 1003
30#define OS_NEGATE 1004
31#define OS_TIMES 1005
32#define OS_DIVIDE 1006
33#define OS_POWER 1009
34#define OS_PRODUCT 1010
35#define OS_ABS 2001
36#define OS_SQUARE 2005
37#define OS_SQRT 2006
38#define OS_LN 2007
39#define OS_EXP 2010
40#define OS_ERF 2023
41#define OS_SIN 3001
42#define OS_COS 3002
43#define OS_MIN 4010
44#define OS_MAX 4011
45#define OS_NUMBER 5001
46#define OS_PI 5003
47#define OS_E 5004
48#define OS_VARIABLE 6001
49#define OS_IF 7001
50#define OS_ALLDIFF 7016
51
52#define OS_MATRIX_DETERMINANT 8001
53#define OS_MATRIX_TRACE 8002
54#define OS_MATRIX_TO_SCALAR 8003
55
56
57#define OS_MATRIX_PLUS 8501
58#define OS_MATRIX_SUM 8502
59#define OS_MATRIX_MINUS 8503
60#define OS_MATRIX_NEGATE 8504
61#define OS_MATRIX_TIMES 8505
62#define OS_MATRIX_PRODUCT 8506
63#define OS_MATRIX_INVERSE 8510
64#define OS_MATRIX_TRANSPOSE 8515
65#define OS_MATRIX_SCALARTIMES 8518
66#define OS_MATRIX_DOTTIMES 8520
67#define OS_IDENTITY_MATRIX 8536
68#define OS_MATRIX_LOWERTRIANGLE 8537
69#define OS_MATRIX_UPPERTRIANGLE 8538
70#define OS_MATRIX_DIAGONAL 8539
71#define OS_DIAGONAL_MATRIX_FROM_VECTOR 8540
72#define OS_MATRIX_REFERENCE 8541
73#define OS_MATRIX_SUBMATRIX_AT 8544
74#define OS_MATRIX_VAR 8601
75#define OS_MATRIX_OBJ 8602
76#define OS_MATRIX_CON 8603
77
78
79
80#define OS_E_VALUE exp(1.0)
81#define OS_PI_VALUE 2*asin(1.0)
82
83#define OS_SCHEMA_VERSION "2.0"
84
89#define OS_NEAR_EQUAL 1e-2
90
91#define OS_EPS 1e-12
92
93const double OSDBL_MAX = std::numeric_limits<double>::max();
94const int OSINT_MAX = std::numeric_limits<int>::max();
95
97extern "C" bool OSIsnan(double x);
99extern "C" double OSNaN();
100
101std::string OSgetVersionInfo();
102
108{
117
118 ENUM_OUTPUT_LEVEL_NUMBER_OF_LEVELS // insert other values above this one...
120
121#define DEFAULT_OUTPUT_LEVEL ENUM_OUTPUT_LEVEL_error
122
129{
147
148 ENUM_OUTPUT_AREA_NUMBER_OF_AREAS // insert other values above this one...
150
151/****************************************************************************************
152 * In the OSxL schemas there is a growing number of string elements that can only take *
153 * a small number of values. In C++ this can be implemented using enumerations, but the *
154 * elements appear in the schemas as strings, so they must be stored internally *
155 * as strings also. Below we list the enumerations and provide two utility methods *
156 * that make working with them convenient: *
157 * return...() functions that return the integer value associated with that enumeration *
158 * verify...() functions that check that a string has a legal value for the enumeration *
159 ****************************************************************************************/
160
162{
175
176inline int returnCPUSpeedUnit(std::string unit)
177{
178 if (unit == "hertz" ) return ENUM_CPUSPEEDUNIT_hertz;
179 if (unit == "kilohertz") return ENUM_CPUSPEEDUNIT_kilohertz;
180 if (unit == "megahertz") return ENUM_CPUSPEEDUNIT_megahertz;
181 if (unit == "gigahertz") return ENUM_CPUSPEEDUNIT_gigahertz;
182 if (unit == "terahertz") return ENUM_CPUSPEEDUNIT_terahertz;
183 if (unit == "flops" ) return ENUM_CPUSPEEDUNIT_flops;
184 if (unit == "kiloflops") return ENUM_CPUSPEEDUNIT_kiloflops;
185 if (unit == "megaflops") return ENUM_CPUSPEEDUNIT_megaflops;
186 if (unit == "gigaflops") return ENUM_CPUSPEEDUNIT_gigaflops;
187 if (unit == "teraflops") return ENUM_CPUSPEEDUNIT_teraflops;
188 if (unit == "petaflops") return ENUM_CPUSPEEDUNIT_petaflops;
189 return 0;
190}//returnCPUSpeedUnit
191
192inline bool verifyCPUSpeedUnit(std::string unit)
193{
194 return (returnCPUSpeedUnit(unit) > 0);
195}//verifyCPUSpeedUnit
196
198{
209
210inline int returnStorageUnit(std::string unit)
211{
212 if (unit == "byte" ) return ENUM_STORAGEUNIT_byte;
213 if (unit == "kilobyte" ) return ENUM_STORAGEUNIT_kilobyte;
214 if (unit == "megabyte" ) return ENUM_STORAGEUNIT_megabyte;
215 if (unit == "gigabyte" ) return ENUM_STORAGEUNIT_gigabyte;
216 if (unit == "terabyte" ) return ENUM_STORAGEUNIT_terabyte;
217 if (unit == "petabyte" ) return ENUM_STORAGEUNIT_petabyte;
218 if (unit == "exabyte" ) return ENUM_STORAGEUNIT_exabyte;
219 if (unit == "zettabyte") return ENUM_STORAGEUNIT_zettabyte;
220 if (unit == "yottabyte") return ENUM_STORAGEUNIT_yottabyte;
221 return 0;
222}//returnStorageUnit
223
224inline bool verifyStorageUnit(std::string unit)
225{
226 return (returnStorageUnit(unit) > 0);
227}//verifyCPUSpeedUnit
228
230{
241
242inline int returnTimeUnit(std::string unit)
243{
244 if (unit == "tick" ) return ENUM_TIMEUNIT_tick;
245 if (unit == "millisecond") return ENUM_TIMEUNIT_millisecond;
246 if (unit == "second" ) return ENUM_TIMEUNIT_second;
247 if (unit == "minute" ) return ENUM_TIMEUNIT_minute;
248 if (unit == "hour" ) return ENUM_TIMEUNIT_hour;
249 if (unit == "day" ) return ENUM_TIMEUNIT_day;
250 if (unit == "week" ) return ENUM_TIMEUNIT_week;
251 if (unit == "month" ) return ENUM_TIMEUNIT_month;
252 if (unit == "year" ) return ENUM_TIMEUNIT_year;
253 return 0;
254}//returnTimeUnit
255
256inline bool verifyTimeUnit(std::string unit)
257{
258 return (returnTimeUnit(unit) > 0);
259}//verifyTimeUnit
260
262{
267
268inline int returnTimeType(std::string type)
269{
270 if (type == "cpuTime" ) return ENUM_TIMETYPE_cpuTime;
271 if (type == "elapsedTime") return ENUM_TIMETYPE_elapsedTime;
272 if (type == "other" ) return ENUM_TIMETYPE_other;
273 return 0;
274}//returnTimeType
275
276inline bool verifyTimeType(std::string type)
277{
278 return (returnTimeType(type) > 0);
279}//verifyTimeType
280
282{
291
292inline int returnTimeCategory(std::string category)
293{
294 if (category == "total" ) return ENUM_TIMECATEGORY_total;
295 if (category == "input" ) return ENUM_TIMECATEGORY_input;
296 if (category == "preprocessing" ) return ENUM_TIMECATEGORY_preprocessing;
297 if (category == "optimization" ) return ENUM_TIMECATEGORY_optimization;
298 if (category == "postprocessing") return ENUM_TIMECATEGORY_postprocessing;
299 if (category == "output" ) return ENUM_TIMECATEGORY_output;
300 if (category == "other" ) return ENUM_TIMECATEGORY_other;
301 return 0;
302}//returnTimeCategory
303
304inline bool verifyTimeCategory(std::string category)
305{
306 return (returnTimeCategory(category) > 0);
307}//verifyTimeCategory
308
310{
315
316inline int returnLocationType(std::string type)
317{
318 if (type == "local") return ENUM_LOCATIONTYPE_local;
319 if (type == "http" ) return ENUM_LOCATIONTYPE_http;
320 if (type == "ftp" ) return ENUM_LOCATIONTYPE_ftp;
321 return 0;
322}//returnLocationType
323
324inline bool verifyLocationType(std::string type)
325{
326 return (returnLocationType(type) > 0);
327}//verifyLocationType
328
330{
337
338inline int returnTransportType(std::string type)
339{
340 if (type == "osp" ) return ENUM_TRANSPORT_TYPE_osp;
341 if (type == "http" ) return ENUM_TRANSPORT_TYPE_http;
342 if (type == "smtp" ) return ENUM_TRANSPORT_TYPE_smtp;
343 if (type == "ftp" ) return ENUM_TRANSPORT_TYPE_ftp;
344 if (type == "other") return ENUM_TRANSPORT_TYPE_other;
345 return 0;
346}//returnTransportType
347
348inline bool verifyTransportType(std::string type)
349{
350 return (returnTransportType(type) > 0);
351}//verifyTransportType
352
354{
363
364inline int returnServiceType(std::string type)
365{
366 if (type == "analyzer" ) return ENUM_SERVICE_TYPE_analyzer;
367 if (type == "solver" ) return ENUM_SERVICE_TYPE_solver;
368 if (type == "scheduler" ) return ENUM_SERVICE_TYPE_scheduler;
369 if (type == "modeler" ) return ENUM_SERVICE_TYPE_modeler;
370 if (type == "registry" ) return ENUM_SERVICE_TYPE_registry;
371 if (type == "agent" ) return ENUM_SERVICE_TYPE_agent;
372 if (type == "simulations") return ENUM_SERVICE_TYPE_simulations;
373 return 0;
374}//returnServiceType
375
376inline bool verifyServiceType(std::string type)
377{
378 return (returnServiceType(type) > 0);
379}//verifyServiceType
380
382{
387
388inline int returnGeneralResultStatus(std::string status)
389{
390 if (status == "error" ) return ENUM_GENERAL_RESULT_STATUS_error;
391 if (status == "warning") return ENUM_GENERAL_RESULT_STATUS_warning;
392 if (status == "normal" ) return ENUM_GENERAL_RESULT_STATUS_normal;
393 return 0;
394}//returnGeneralResultStatus
395
396inline bool verifyGeneralResultStatus(std::string status)
397{
398 return (returnGeneralResultStatus(status) > 0);
399}//verifyGeneralResultStatus
400
402{
409
410inline int returnSystemCurrentState(std::string status)
411{
412 if (status == "busy" ) return ENUM_SYSTEM_CURRENT_STATE_busy;
413 if (status == "busyButAccepting" ) return ENUM_SYSTEM_CURRENT_STATE_busyButAccepting;
414 if (status == "idle" ) return ENUM_SYSTEM_CURRENT_STATE_idle;
415 if (status == "idleButNotAccepting") return ENUM_SYSTEM_CURRENT_STATE_idleButNotAccepting;
416 if (status == "noResponse" ) return ENUM_SYSTEM_CURRENT_STATE_noResponse;
417 return 0;
418}//returnSystemCurrentState
419
420inline bool verifySystemCurrentState(std::string status)
421{
422 return (returnSystemCurrentState(status) > 0);
423}//verifySystemCurrentState
424
426{
433
434inline int returnJobStatus(std::string status)
435{
436 if (status == "waiting" ) return ENUM_JOB_STATUS_waiting;
437 if (status == "running" ) return ENUM_JOB_STATUS_running;
438 if (status == "killed" ) return ENUM_JOB_STATUS_killed;
439 if (status == "finished") return ENUM_JOB_STATUS_finished;
440 if (status == "unknown" ) return ENUM_JOB_STATUS_unknown;
441 return 0;
442}//returnJobStatus
443
444inline bool verifyJobStatus(std::string status)
445{
446 return (returnJobStatus(status) > 0);
447}//verifyJobStatus
448
457{
467
468inline int returnBasisStatus(std::string status)
469{
470 if (status == "basic" ) return ENUM_BASIS_STATUS_basic;
471 if (status == "atLower" ) return ENUM_BASIS_STATUS_atLower;
472 if (status == "atUpper" ) return ENUM_BASIS_STATUS_atUpper;
473 if (status == "atEquality") return ENUM_BASIS_STATUS_atEquality;
474 if (status == "isFree" ) return ENUM_BASIS_STATUS_isFree;
475 if (status == "superBasic") return ENUM_BASIS_STATUS_superbasic;
476 if (status == "unknown" ) return ENUM_BASIS_STATUS_unknown;
477 return 0;
478}//returnBasisStatus
479
480inline bool verifyBasisStatus(std::string status)
481{
482 return (returnBasisStatus(status) > 0);
483}//verifyBasisStatus
484
486{
487 if (status == ENUM_BASIS_STATUS_basic ) return "basic";
488 if (status == ENUM_BASIS_STATUS_atLower ) return "atLower";
489 if (status == ENUM_BASIS_STATUS_atUpper ) return "atUpper";
490 if (status == ENUM_BASIS_STATUS_atEquality) return "atEquality";
491 if (status == ENUM_BASIS_STATUS_isFree ) return "isFree";
492 if (status == ENUM_BASIS_STATUS_superbasic) return "superBasic";
493 if (status == ENUM_BASIS_STATUS_unknown ) return "unknown";
494 return "status???";
495}//returnBasisStatus
496
497
499{
511
512inline int returnSolutionStatus(std::string status)
513{
514 if (status == "unbounded" ) return ENUM_SOLUTION_STATUS_unbounded;
515 if (status == "globallyOptimal") return ENUM_SOLUTION_STATUS_globallyOptimal;
516 if (status == "locallyOptimal" ) return ENUM_SOLUTION_STATUS_locallyOptimal;
517 if (status == "optimal" ) return ENUM_SOLUTION_STATUS_optimal;
518 if (status == "bestSoFar" ) return ENUM_SOLUTION_STATUS_bestSoFar;
519 if (status == "feasible" ) return ENUM_SOLUTION_STATUS_feasible;
520 if (status == "infeasible" ) return ENUM_SOLUTION_STATUS_infeasible;
521 if (status == "unsure" ) return ENUM_SOLUTION_STATUS_unsure;
522 if (status == "error" ) return ENUM_SOLUTION_STATUS_error;
523 if (status == "other" ) return ENUM_SOLUTION_STATUS_other;
524 return 0;
525}//returnSolutionStatus
526
527inline bool verifySolutionStatus(std::string status)
528{
529 return (returnSolutionStatus(status) > 0);
530}//verifySolutionStatus
531
533{
538
539inline int returnSolutionSubstatusType(std::string type)
540{
541 if (type == "stoppedByLimit" ) return ENUM_SOLUTION_SUBSTATUSTYPE_stoppedByLimit;
542 if (type == "stoppedByBounds") return ENUM_SOLUTION_SUBSTATUSTYPE_stoppedByBounds;
543 if (type == "other" ) return ENUM_SOLUTION_SUBSTATUSTYPE_other;
544 return 0;
545}//returnSolutionSubstatusType
546
547inline bool verifySolutionSubstatusType(std::string type)
548{
549 return (returnSolutionSubstatusType(type) > 0);
550}//verifySolutionSubstatusType
551
553{
558
560{
568
569inline int returnVarType(char vt)
570{
571 if (vt == 'C') return ENUM_VARTYPE_continuous;
572 if (vt == 'B') return ENUM_VARTYPE_binary;
573 if (vt == 'I') return ENUM_VARTYPE_integer;
574 if (vt == 'S') return ENUM_VARTYPE_string;
575 if (vt == 'D') return ENUM_VARTYPE_semicontinuous;
576 if (vt == 'J') return ENUM_VARTYPE_semiinteger;
577 return 0;
578}//returnVarType
579
580inline bool verifyVarType(char vt)
581{
582 return (returnVarType(vt) > 0);
583}//verifyVarType
584
585
587{
593
600{
601 ENUM_MATRIX_TYPE_empty = 1, // matrix has no elements (i.e., zero matrix)
602
603 ENUM_MATRIX_TYPE_constant = 10, // matrix elements contain constant values (i.e., real numbers)
604 ENUM_MATRIX_TYPE_varReference, // matrix elements contain indexes of variables in the core
605 ENUM_MATRIX_TYPE_linear, // matrix contains linear expressions
606 ENUM_MATRIX_TYPE_quadratic, // matrix contains quadratic expressions
607 ENUM_MATRIX_TYPE_general, // matrix contains general nonlinear expressions
608
609 ENUM_MATRIX_TYPE_objReference = 20, // matrix elements contain indexes of constraints in the core
610 ENUM_MATRIX_TYPE_conReference, // matrix elements contain indexes of objectives in the core
611 ENUM_MATRIX_TYPE_mixedRowReference, // mixed reference to objectives and constraints
612
613 ENUM_MATRIX_TYPE_string, // matrix elements contain string values
614
617
618inline int returnMatrixType(std::string type)
619{
620 if (type == "empty" ) return ENUM_MATRIX_TYPE_empty;
621 if (type == "constant" ) return ENUM_MATRIX_TYPE_constant;
622 if (type == "varReference" ) return ENUM_MATRIX_TYPE_varReference;
623 if (type == "linear" ) return ENUM_MATRIX_TYPE_linear;
624 if (type == "quadratic" ) return ENUM_MATRIX_TYPE_quadratic;
625 if (type == "general" ) return ENUM_MATRIX_TYPE_general;
626
627 if (type == "objReference" ) return ENUM_MATRIX_TYPE_objReference;
628 if (type == "conReference" ) return ENUM_MATRIX_TYPE_conReference;
629 if (type == "mixedRowReference") return ENUM_MATRIX_TYPE_mixedRowReference;
630
631 if (type == "string" ) return ENUM_MATRIX_TYPE_string;
632
633 if (type == "unknown" ) return ENUM_MATRIX_TYPE_unknown;
634 return 0;
635}//returnMatrixType
636
638{
639 if (type == ENUM_MATRIX_TYPE_empty) return "empty";
640 if (type == ENUM_MATRIX_TYPE_constant) return "constant";
641 if (type == ENUM_MATRIX_TYPE_varReference) return "varReference";
642 if (type == ENUM_MATRIX_TYPE_linear) return "linear";
643 if (type == ENUM_MATRIX_TYPE_quadratic) return "quadratic";
644 if (type == ENUM_MATRIX_TYPE_general) return "general";
645 if (type == ENUM_MATRIX_TYPE_objReference) return "objReference";
646 if (type == ENUM_MATRIX_TYPE_conReference) return "conReference";
647 if (type == ENUM_MATRIX_TYPE_mixedRowReference) return "mixedRowReference";
648 if (type == ENUM_MATRIX_TYPE_unknown) return "unknown";
649 if (type == ENUM_MATRIX_TYPE_string) return "string";
650 return "unknown";
651}//returnMatrixTypeString
652
653inline bool verifyMatrixType(std::string type)
654{
655 return (returnMatrixType(type) > 0);
656}//verifyMatrixType
657
662{
663 // two matrices of same type
664 if (type1 == type2) return type1;
665
666 if (type1 == ENUM_MATRIX_TYPE_string || type2 == ENUM_MATRIX_TYPE_string)
668
669 if (type1 == ENUM_MATRIX_TYPE_unknown) return type2;
670 if (type2 == ENUM_MATRIX_TYPE_unknown) return type1;
671 if (type1 == ENUM_MATRIX_TYPE_empty) return type2;
672 if (type2 == ENUM_MATRIX_TYPE_empty) return type1;
673
674 // column and objective references can be mixed
675 if (type1 >= ENUM_MATRIX_TYPE_conReference) // row reference (objective or constraint)
676 {
679 else
681 }
682 else // type1 is a linear or nonlinear expression
683 {
685 else // varReference must be treated like linear if it is mixed with any other remaining type
686 if (type1 < type2)
689 else
690 return type2;
691 else
694 else
695 return type1;
696 }
698}//end of mergeMatrixType
699
704{
710
712{
713 if (valueType == ENUM_CONREFERENCE_VALUETYPE_value ) return "none";
714 if (valueType == ENUM_CONREFERENCE_VALUETYPE_status ) return "status";
715 if (valueType == ENUM_CONREFERENCE_VALUETYPE_surplus ) return "surplus";
716 if (valueType == ENUM_CONREFERENCE_VALUETYPE_shortage) return "shortage";
717 return "none";
718}//returnConReferenceValueTypeString
719
720inline int returnConReferenceValueType(std::string valueType)
721{
722 if (valueType == "value" ) return ENUM_CONREFERENCE_VALUETYPE_value;
723 if (valueType == "status" ) return ENUM_CONREFERENCE_VALUETYPE_status;
724 if (valueType == "surplus" ) return ENUM_CONREFERENCE_VALUETYPE_surplus;
725 if (valueType == "shortage" ) return ENUM_CONREFERENCE_VALUETYPE_shortage;
726 return 0;
727}//returnConReferenceValueType
728
729inline bool verifyConReferenceValueType(std::string valueType)
730{
731 return (returnConReferenceValueType(valueType) > 0);
732}//verifyConReferenceValueType
733
734
736{
745
747{
748 if (symmetry == ENUM_MATRIX_SYMMETRY_none ) return "none";
749 if (symmetry == ENUM_MATRIX_SYMMETRY_upper ) return "upper";
750 if (symmetry == ENUM_MATRIX_SYMMETRY_lower ) return "lower";
751 if (symmetry == ENUM_MATRIX_SYMMETRY_skewUpper ) return "skewUpper";
752 if (symmetry == ENUM_MATRIX_SYMMETRY_skewLower ) return "skewLower";
753 if (symmetry == ENUM_MATRIX_SYMMETRY_HermitianLower) return "HermitianLower";
754 if (symmetry == ENUM_MATRIX_SYMMETRY_HermitianLower) return "HermitianLower";
755 return "none";
756}//returnMatrixSymmetryString
757
758inline int returnMatrixSymmetry(std::string symmetry)
759{
760 if (symmetry == "none" ) return ENUM_MATRIX_SYMMETRY_none;
761 if (symmetry == "upper" ) return ENUM_MATRIX_SYMMETRY_upper;
762 if (symmetry == "lower" ) return ENUM_MATRIX_SYMMETRY_lower;
763 if (symmetry == "skewUpper" ) return ENUM_MATRIX_SYMMETRY_skewUpper;
764 if (symmetry == "skewLower" ) return ENUM_MATRIX_SYMMETRY_skewLower;
765 if (symmetry == "HermitianLower") return ENUM_MATRIX_SYMMETRY_HermitianLower;
766 if (symmetry == "HermitianLower") return ENUM_MATRIX_SYMMETRY_HermitianLower;
767 return 0;
768}//returnMatrixSymmetry
769
770inline bool verifyMatrixSymmetry(std::string symmetry)
771{
772 return (returnMatrixSymmetry(symmetry) > 0);
773}//verifyMatrixSymmetry
774
775
777{
793
794inline int returnMatrixConstructorType(std::string cType)
795{
796 if (cType == "baseMatrix" ) return ENUM_MATRIX_CONSTRUCTOR_TYPE_baseMatrix;
797 if (cType == "constantElements" ) return ENUM_MATRIX_CONSTRUCTOR_TYPE_constantElements;
798 if (cType == "varRefElements" ) return ENUM_MATRIX_CONSTRUCTOR_TYPE_varRefElements;
799 if (cType == "linearElements" ) return ENUM_MATRIX_CONSTRUCTOR_TYPE_linearElements;
800 if (cType == "generalElements" ) return ENUM_MATRIX_CONSTRUCTOR_TYPE_generalElements;
801 if (cType == "objRefElements" ) return ENUM_MATRIX_CONSTRUCTOR_TYPE_objRefElements;
802 if (cType == "conRefElements" ) return ENUM_MATRIX_CONSTRUCTOR_TYPE_conRefElements;
803 if (cType == "stringElements" ) return ENUM_MATRIX_CONSTRUCTOR_TYPE_stringValuedElements;
804 if (cType == "transformation" ) return ENUM_MATRIX_CONSTRUCTOR_TYPE_transformation;
805 if (cType == "blocks" ) return ENUM_MATRIX_CONSTRUCTOR_TYPE_blocks;
806 if (cType == "block" ) return ENUM_MATRIX_CONSTRUCTOR_TYPE_block;
807 if (cType == "matrix" ) return ENUM_MATRIX_CONSTRUCTOR_TYPE_matrix;
808 return 0;
809}//returnMatrixConstructorType
810
811inline bool verifyMatrixConstructorType(std::string type)
812{
813 return (returnMatrixConstructorType(type) > 0);
814}//verifyMatrixConstructorType
815
816
821{
822 ENUM_COMBINE_ARRAYS_replace, // silently replace previous data (if any)
823 ENUM_COMBINE_ARRAYS_merge, // merge two vectors into one
824 ENUM_COMBINE_ARRAYS_ignore, // silently ignore current vector if previous data exist
825 ENUM_COMBINE_ARRAYS_throw // throw an error if previous data detected
827
828
829/* An enumeration to track the shape of a nonlinear expression */
831{
838
839inline int returnNlExprShape(std::string shape)
840{
841 if (shape == "general" ) return ENUM_NL_EXPR_SHAPE_general;
842 if (shape == "convex" ) return ENUM_NL_EXPR_SHAPE_convex;
843 if (shape == "quadratic") return ENUM_NL_EXPR_SHAPE_quadratic;
844 if (shape == "linear" ) return ENUM_NL_EXPR_SHAPE_linear;
845 if (shape == "constant" ) return ENUM_NL_EXPR_SHAPE_constant;
846 return 1;
847}//returnNlExprShape
848
850{
851 if (shape == ENUM_NL_EXPR_SHAPE_general ) return "general";
852 if (shape == ENUM_NL_EXPR_SHAPE_convex ) return "convex";
853 if (shape == ENUM_NL_EXPR_SHAPE_quadratic) return "quadratic";
854 if (shape == ENUM_NL_EXPR_SHAPE_linear ) return "linear";
855 if (shape == ENUM_NL_EXPR_SHAPE_constant ) return "constant";
856 return "";
857}//returnExprShapeString
858
859inline bool verifyNlExprShape(std::string shape)
860{
861 return (returnNlExprShape(shape) > 0);
862}//verifyNlExprShape
863
864
866{
888
889inline int returnConeType(std::string type)
890{
891 if (type == "nonnegative" ) return ENUM_CONE_TYPE_nonnegative;
892 if (type == "nonpositive" ) return ENUM_CONE_TYPE_nonpositive;
893 if (type == "orthant" ) return ENUM_CONE_TYPE_orthant;
894 if (type == "polyhedral" ) return ENUM_CONE_TYPE_polyhedral;
895 if (type == "quadratic" ) return ENUM_CONE_TYPE_quadratic;
896
897 if (type == "rotatedQuadratic" ) return ENUM_CONE_TYPE_rotatedQuadratic;
898 if (type == "normed" ) return ENUM_CONE_TYPE_normed;
899 if (type == "rotatedNormed" ) return ENUM_CONE_TYPE_rotatedNormed;
900 if (type == "semidefinite" ) return ENUM_CONE_TYPE_semidefinite;
901 if (type == "copositiveMatrices" ) return ENUM_CONE_TYPE_copositiveMatrices;
902 if (type == "completelyPositiveMatrices") return ENUM_CONE_TYPE_completelyPositiveMatrices;
903 if (type == "hyperbolicity" ) return ENUM_CONE_TYPE_hyperbolicity;
904 if (type == "sumOfSquaresPolynomials" ) return ENUM_CONE_TYPE_sumOfSquaresPolynomials;
905 if (type == "nonnegativePolynomials" ) return ENUM_CONE_TYPE_nonnegativePolynomials;
906 if (type == "moments" ) return ENUM_CONE_TYPE_moments;
907 if (type == "product" ) return ENUM_CONE_TYPE_product;
908 if (type == "intersection" ) return ENUM_CONE_TYPE_intersection;
909 if (type == "dual" ) return ENUM_CONE_TYPE_dual;
910 if (type == "polar" ) return ENUM_CONE_TYPE_polar;
911 if (type == "unknown" ) return ENUM_CONE_TYPE_unknown;
912 return 0;
913}//returnConeType
914
915inline bool verifyConeType(std::string type)
916{
917 return (returnConeType(type) > 0);
918}//verifyConeType
919
920
921#endif
int returnConeType(std::string type)
Definition: OSParameters.h:889
ENUM_NL_EXPR_SHAPE
Definition: OSParameters.h:831
@ ENUM_NL_EXPR_SHAPE_general
Definition: OSParameters.h:832
@ ENUM_NL_EXPR_SHAPE_convex
Definition: OSParameters.h:833
@ ENUM_NL_EXPR_SHAPE_constant
Definition: OSParameters.h:836
@ ENUM_NL_EXPR_SHAPE_linear
Definition: OSParameters.h:835
@ ENUM_NL_EXPR_SHAPE_quadratic
Definition: OSParameters.h:834
bool verifyMatrixSymmetry(std::string symmetry)
Definition: OSParameters.h:770
std::string returnConReferenceValueTypeString(ENUM_CONREFERENCE_VALUETYPE valueType)
Definition: OSParameters.h:711
ENUM_TIMECATEGORY
Definition: OSParameters.h:282
@ ENUM_TIMECATEGORY_optimization
Definition: OSParameters.h:286
@ ENUM_TIMECATEGORY_other
Definition: OSParameters.h:289
@ ENUM_TIMECATEGORY_preprocessing
Definition: OSParameters.h:285
@ ENUM_TIMECATEGORY_postprocessing
Definition: OSParameters.h:287
@ ENUM_TIMECATEGORY_input
Definition: OSParameters.h:284
@ ENUM_TIMECATEGORY_total
Definition: OSParameters.h:283
@ ENUM_TIMECATEGORY_output
Definition: OSParameters.h:288
const int OSINT_MAX
Definition: OSParameters.h:94
bool verifyBasisStatus(std::string status)
Definition: OSParameters.h:480
ENUM_SOLUTION_SUBSTATUSTYPE
Definition: OSParameters.h:533
@ ENUM_SOLUTION_SUBSTATUSTYPE_stoppedByLimit
Definition: OSParameters.h:534
@ ENUM_SOLUTION_SUBSTATUSTYPE_other
Definition: OSParameters.h:536
@ ENUM_SOLUTION_SUBSTATUSTYPE_stoppedByBounds
Definition: OSParameters.h:535
std::string OSgetVersionInfo()
int returnTransportType(std::string type)
Definition: OSParameters.h:338
ENUM_GENERAL_RESULT_STATUS
Definition: OSParameters.h:382
@ ENUM_GENERAL_RESULT_STATUS_normal
Definition: OSParameters.h:385
@ ENUM_GENERAL_RESULT_STATUS_error
Definition: OSParameters.h:383
@ ENUM_GENERAL_RESULT_STATUS_warning
Definition: OSParameters.h:384
bool verifyMatrixConstructorType(std::string type)
Definition: OSParameters.h:811
int returnVarType(char vt)
Definition: OSParameters.h:569
bool verifySolutionSubstatusType(std::string type)
Definition: OSParameters.h:547
ENUM_JOB_STATUS
Definition: OSParameters.h:426
@ ENUM_JOB_STATUS_finished
Definition: OSParameters.h:430
@ ENUM_JOB_STATUS_killed
Definition: OSParameters.h:429
@ ENUM_JOB_STATUS_waiting
Definition: OSParameters.h:427
@ ENUM_JOB_STATUS_running
Definition: OSParameters.h:428
@ ENUM_JOB_STATUS_unknown
Definition: OSParameters.h:431
bool verifyMatrixType(std::string type)
Definition: OSParameters.h:653
int returnTimeUnit(std::string unit)
Definition: OSParameters.h:242
int returnGeneralResultStatus(std::string status)
Definition: OSParameters.h:388
bool verifyVarType(char vt)
Definition: OSParameters.h:580
int returnServiceType(std::string type)
Definition: OSParameters.h:364
int returnStorageUnit(std::string unit)
Definition: OSParameters.h:210
bool verifyTransportType(std::string type)
Definition: OSParameters.h:348
bool verifySolutionStatus(std::string status)
Definition: OSParameters.h:527
std::string returnExprShapeString(ENUM_NL_EXPR_SHAPE shape)
Definition: OSParameters.h:849
int returnCPUSpeedUnit(std::string unit)
Definition: OSParameters.h:176
std::string returnMatrixSymmetryString(ENUM_MATRIX_SYMMETRY symmetry)
Definition: OSParameters.h:746
int returnLocationType(std::string type)
Definition: OSParameters.h:316
bool verifyCPUSpeedUnit(std::string unit)
Definition: OSParameters.h:192
const double OSDBL_MAX
Definition: OSParameters.h:93
int returnNlExprShape(std::string shape)
Definition: OSParameters.h:839
ENUM_COMBINE_ARRAYS
An enum to streamline set() methods of vectors.
Definition: OSParameters.h:821
@ ENUM_COMBINE_ARRAYS_replace
Definition: OSParameters.h:822
@ ENUM_COMBINE_ARRAYS_throw
Definition: OSParameters.h:825
@ ENUM_COMBINE_ARRAYS_merge
Definition: OSParameters.h:823
@ ENUM_COMBINE_ARRAYS_ignore
Definition: OSParameters.h:824
bool verifyLocationType(std::string type)
Definition: OSParameters.h:324
int returnSystemCurrentState(std::string status)
Definition: OSParameters.h:410
int returnBasisStatus(std::string status)
Definition: OSParameters.h:468
bool verifyNlExprShape(std::string shape)
Definition: OSParameters.h:859
bool verifyConReferenceValueType(std::string valueType)
Definition: OSParameters.h:729
ENUM_LOCATIONTYPE
Definition: OSParameters.h:310
@ ENUM_LOCATIONTYPE_ftp
Definition: OSParameters.h:313
@ ENUM_LOCATIONTYPE_http
Definition: OSParameters.h:312
@ ENUM_LOCATIONTYPE_local
Definition: OSParameters.h:311
ENUM_CPUSPEEDUNIT
Definition: OSParameters.h:162
@ ENUM_CPUSPEEDUNIT_flops
Definition: OSParameters.h:168
@ ENUM_CPUSPEEDUNIT_gigaflops
Definition: OSParameters.h:171
@ ENUM_CPUSPEEDUNIT_megaflops
Definition: OSParameters.h:170
@ ENUM_CPUSPEEDUNIT_megahertz
Definition: OSParameters.h:165
@ ENUM_CPUSPEEDUNIT_teraflops
Definition: OSParameters.h:172
@ ENUM_CPUSPEEDUNIT_gigahertz
Definition: OSParameters.h:166
@ ENUM_CPUSPEEDUNIT_hertz
Definition: OSParameters.h:163
@ ENUM_CPUSPEEDUNIT_kiloflops
Definition: OSParameters.h:169
@ ENUM_CPUSPEEDUNIT_petaflops
Definition: OSParameters.h:173
@ ENUM_CPUSPEEDUNIT_kilohertz
Definition: OSParameters.h:164
@ ENUM_CPUSPEEDUNIT_terahertz
Definition: OSParameters.h:167
bool verifyConeType(std::string type)
Definition: OSParameters.h:915
std::string returnMatrixTypeString(ENUM_MATRIX_TYPE type)
Definition: OSParameters.h:637
int returnSolutionSubstatusType(std::string type)
Definition: OSParameters.h:539
int returnMatrixType(std::string type)
Definition: OSParameters.h:618
ENUM_STORAGEUNIT
Definition: OSParameters.h:198
@ ENUM_STORAGEUNIT_petabyte
Definition: OSParameters.h:204
@ ENUM_STORAGEUNIT_gigabyte
Definition: OSParameters.h:202
@ ENUM_STORAGEUNIT_byte
Definition: OSParameters.h:199
@ ENUM_STORAGEUNIT_zettabyte
Definition: OSParameters.h:206
@ ENUM_STORAGEUNIT_megabyte
Definition: OSParameters.h:201
@ ENUM_STORAGEUNIT_kilobyte
Definition: OSParameters.h:200
@ ENUM_STORAGEUNIT_yottabyte
Definition: OSParameters.h:207
@ ENUM_STORAGEUNIT_terabyte
Definition: OSParameters.h:203
@ ENUM_STORAGEUNIT_exabyte
Definition: OSParameters.h:205
bool verifyJobStatus(std::string status)
Definition: OSParameters.h:444
int returnMatrixSymmetry(std::string symmetry)
Definition: OSParameters.h:758
bool verifySystemCurrentState(std::string status)
Definition: OSParameters.h:420
ENUM_CONE_TYPE
Definition: OSParameters.h:866
@ ENUM_CONE_TYPE_rotatedNormed
Definition: OSParameters.h:874
@ ENUM_CONE_TYPE_orthant
Definition: OSParameters.h:869
@ ENUM_CONE_TYPE_dual
Definition: OSParameters.h:884
@ ENUM_CONE_TYPE_nonnegative
Definition: OSParameters.h:867
@ ENUM_CONE_TYPE_product
Definition: OSParameters.h:882
@ ENUM_CONE_TYPE_quadratic
Definition: OSParameters.h:871
@ ENUM_CONE_TYPE_nonnegativePolynomials
Definition: OSParameters.h:880
@ ENUM_CONE_TYPE_nonpositive
Definition: OSParameters.h:868
@ ENUM_CONE_TYPE_rotatedQuadratic
Definition: OSParameters.h:872
@ ENUM_CONE_TYPE_intersection
Definition: OSParameters.h:883
@ ENUM_CONE_TYPE_unknown
Definition: OSParameters.h:886
@ ENUM_CONE_TYPE_normed
Definition: OSParameters.h:873
@ ENUM_CONE_TYPE_moments
Definition: OSParameters.h:881
@ ENUM_CONE_TYPE_copositiveMatrices
Definition: OSParameters.h:876
@ ENUM_CONE_TYPE_sumOfSquaresPolynomials
Definition: OSParameters.h:879
@ ENUM_CONE_TYPE_semidefinite
Definition: OSParameters.h:875
@ ENUM_CONE_TYPE_polyhedral
Definition: OSParameters.h:870
@ ENUM_CONE_TYPE_completelyPositiveMatrices
Definition: OSParameters.h:877
@ ENUM_CONE_TYPE_polar
Definition: OSParameters.h:885
@ ENUM_CONE_TYPE_hyperbolicity
Definition: OSParameters.h:878
ENUM_SYSTEM_CURRENT_STATE
Definition: OSParameters.h:402
@ ENUM_SYSTEM_CURRENT_STATE_busyButAccepting
Definition: OSParameters.h:404
@ ENUM_SYSTEM_CURRENT_STATE_busy
Definition: OSParameters.h:403
@ ENUM_SYSTEM_CURRENT_STATE_idle
Definition: OSParameters.h:405
@ ENUM_SYSTEM_CURRENT_STATE_noResponse
Definition: OSParameters.h:407
@ ENUM_SYSTEM_CURRENT_STATE_idleButNotAccepting
Definition: OSParameters.h:406
ENUM_OUTPUT_LEVEL
Enumeration for the different verbosity levels that can be used in producing output.
Definition: OSParameters.h:108
@ ENUM_OUTPUT_LEVEL_detailed_trace
Definition: OSParameters.h:116
@ ENUM_OUTPUT_LEVEL_debug
Definition: OSParameters.h:114
@ ENUM_OUTPUT_LEVEL_trace
Definition: OSParameters.h:115
@ ENUM_OUTPUT_LEVEL_error
Definition: OSParameters.h:110
@ ENUM_OUTPUT_LEVEL_info
Definition: OSParameters.h:113
@ ENUM_OUTPUT_LEVEL_summary
Definition: OSParameters.h:111
@ ENUM_OUTPUT_LEVEL_NUMBER_OF_LEVELS
Definition: OSParameters.h:118
@ ENUM_OUTPUT_LEVEL_always
Definition: OSParameters.h:109
@ ENUM_OUTPUT_LEVEL_warning
Definition: OSParameters.h:112
std::string returnBasisStatusString(ENUM_BASIS_STATUS status)
Definition: OSParameters.h:485
bool OSIsnan(double x)
checks whether a given double is NaN
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_TYPE_linear
Definition: OSParameters.h:605
@ ENUM_MATRIX_TYPE_varReference
Definition: OSParameters.h:604
@ ENUM_MATRIX_TYPE_string
Definition: OSParameters.h:613
@ ENUM_MATRIX_TYPE_constant
Definition: OSParameters.h:603
@ ENUM_MATRIX_TYPE_conReference
Definition: OSParameters.h:610
@ ENUM_MATRIX_TYPE_general
Definition: OSParameters.h:607
@ ENUM_MATRIX_TYPE_unknown
Definition: OSParameters.h:615
@ ENUM_MATRIX_TYPE_mixedRowReference
Definition: OSParameters.h:611
@ ENUM_MATRIX_TYPE_quadratic
Definition: OSParameters.h:606
@ ENUM_MATRIX_TYPE_empty
Definition: OSParameters.h:601
@ ENUM_MATRIX_TYPE_objReference
Definition: OSParameters.h:609
bool verifyTimeUnit(std::string unit)
Definition: OSParameters.h:256
bool verifyTimeType(std::string type)
Definition: OSParameters.h:276
bool verifyGeneralResultStatus(std::string status)
Definition: OSParameters.h:396
ENUM_MATRIX_SYMMETRY
Definition: OSParameters.h:736
@ ENUM_MATRIX_SYMMETRY_upper
Definition: OSParameters.h:738
@ ENUM_MATRIX_SYMMETRY_lower
Definition: OSParameters.h:739
@ ENUM_MATRIX_SYMMETRY_skewLower
Definition: OSParameters.h:741
@ ENUM_MATRIX_SYMMETRY_skewUpper
Definition: OSParameters.h:740
@ ENUM_MATRIX_SYMMETRY_none
Definition: OSParameters.h:737
@ ENUM_MATRIX_SYMMETRY_HermitianLower
Definition: OSParameters.h:742
@ ENUM_MATRIX_SYMMETRY_HermitianUpper
Definition: OSParameters.h:743
ENUM_SERVICE_TYPE
Definition: OSParameters.h:354
@ ENUM_SERVICE_TYPE_solver
Definition: OSParameters.h:356
@ ENUM_SERVICE_TYPE_registry
Definition: OSParameters.h:359
@ ENUM_SERVICE_TYPE_modeler
Definition: OSParameters.h:358
@ ENUM_SERVICE_TYPE_simulations
Definition: OSParameters.h:361
@ ENUM_SERVICE_TYPE_analyzer
Definition: OSParameters.h:355
@ ENUM_SERVICE_TYPE_scheduler
Definition: OSParameters.h:357
@ ENUM_SERVICE_TYPE_agent
Definition: OSParameters.h:360
int returnTimeType(std::string type)
Definition: OSParameters.h:268
ENUM_MATRIX_TYPE mergeMatrixType(ENUM_MATRIX_TYPE type1, ENUM_MATRIX_TYPE type2)
A function to merge two matrix types so we can infer the type of a matrix recursively.
Definition: OSParameters.h:661
double OSNaN()
returns the value for NaN used in OS
ENUM_PATHPAIR
Definition: OSParameters.h:587
@ ENUM_PATHPAIR_output_dir
Definition: OSParameters.h:591
@ ENUM_PATHPAIR_input_dir
Definition: OSParameters.h:588
@ ENUM_PATHPAIR_output_file
Definition: OSParameters.h:590
@ ENUM_PATHPAIR_input_file
Definition: OSParameters.h:589
int returnMatrixConstructorType(std::string cType)
Definition: OSParameters.h:794
int returnJobStatus(std::string status)
Definition: OSParameters.h:434
int returnSolutionStatus(std::string status)
Definition: OSParameters.h:512
ENUM_MATRIX_CONSTRUCTOR_TYPE
Definition: OSParameters.h:777
@ ENUM_MATRIX_CONSTRUCTOR_TYPE_mixedRowRefElements
Definition: OSParameters.h:786
@ ENUM_MATRIX_CONSTRUCTOR_TYPE_generalElements
Definition: OSParameters.h:783
@ ENUM_MATRIX_CONSTRUCTOR_TYPE_varRefElements
Definition: OSParameters.h:781
@ ENUM_MATRIX_CONSTRUCTOR_TYPE_transformation
Definition: OSParameters.h:788
@ ENUM_MATRIX_CONSTRUCTOR_TYPE_objRefElements
Definition: OSParameters.h:784
@ ENUM_MATRIX_CONSTRUCTOR_TYPE_conRefElements
Definition: OSParameters.h:785
@ ENUM_MATRIX_CONSTRUCTOR_TYPE_stringValuedElements
Definition: OSParameters.h:787
@ ENUM_MATRIX_CONSTRUCTOR_TYPE_unknown
Definition: OSParameters.h:778
@ ENUM_MATRIX_CONSTRUCTOR_TYPE_blocks
Definition: OSParameters.h:789
@ ENUM_MATRIX_CONSTRUCTOR_TYPE_linearElements
Definition: OSParameters.h:782
@ ENUM_MATRIX_CONSTRUCTOR_TYPE_block
Definition: OSParameters.h:790
@ ENUM_MATRIX_CONSTRUCTOR_TYPE_matrix
Definition: OSParameters.h:791
@ ENUM_MATRIX_CONSTRUCTOR_TYPE_constantElements
Definition: OSParameters.h:780
@ ENUM_MATRIX_CONSTRUCTOR_TYPE_baseMatrix
Definition: OSParameters.h:779
ENUM_TIMETYPE
Definition: OSParameters.h:262
@ ENUM_TIMETYPE_elapsedTime
Definition: OSParameters.h:264
@ ENUM_TIMETYPE_cpuTime
Definition: OSParameters.h:263
@ ENUM_TIMETYPE_other
Definition: OSParameters.h:265
ENUM_SOLUTION_STATUS
Definition: OSParameters.h:499
@ ENUM_SOLUTION_STATUS_bestSoFar
Definition: OSParameters.h:504
@ ENUM_SOLUTION_STATUS_unbounded
Definition: OSParameters.h:500
@ ENUM_SOLUTION_STATUS_locallyOptimal
Definition: OSParameters.h:502
@ ENUM_SOLUTION_STATUS_feasible
Definition: OSParameters.h:505
@ ENUM_SOLUTION_STATUS_other
Definition: OSParameters.h:509
@ ENUM_SOLUTION_STATUS_optimal
Definition: OSParameters.h:503
@ ENUM_SOLUTION_STATUS_error
Definition: OSParameters.h:508
@ ENUM_SOLUTION_STATUS_unsure
Definition: OSParameters.h:507
@ ENUM_SOLUTION_STATUS_infeasible
Definition: OSParameters.h:506
@ ENUM_SOLUTION_STATUS_globallyOptimal
Definition: OSParameters.h:501
ENUM_TIMEUNIT
Definition: OSParameters.h:230
@ ENUM_TIMEUNIT_millisecond
Definition: OSParameters.h:232
@ ENUM_TIMEUNIT_week
Definition: OSParameters.h:237
@ ENUM_TIMEUNIT_year
Definition: OSParameters.h:239
@ ENUM_TIMEUNIT_tick
Definition: OSParameters.h:231
@ ENUM_TIMEUNIT_hour
Definition: OSParameters.h:235
@ ENUM_TIMEUNIT_minute
Definition: OSParameters.h:234
@ ENUM_TIMEUNIT_day
Definition: OSParameters.h:236
@ ENUM_TIMEUNIT_second
Definition: OSParameters.h:233
@ ENUM_TIMEUNIT_month
Definition: OSParameters.h:238
ENUM_BASIS_STATUS
Enumeration for the different states that can be used in representating a basis The last state,...
Definition: OSParameters.h:457
@ ENUM_BASIS_STATUS_isFree
Definition: OSParameters.h:462
@ ENUM_BASIS_STATUS_unknown
Definition: OSParameters.h:464
@ ENUM_BASIS_STATUS_basic
Definition: OSParameters.h:458
@ ENUM_BASIS_STATUS_NUMBER_OF_STATES
Definition: OSParameters.h:465
@ ENUM_BASIS_STATUS_atLower
Definition: OSParameters.h:459
@ ENUM_BASIS_STATUS_atEquality
Definition: OSParameters.h:461
@ ENUM_BASIS_STATUS_superbasic
Definition: OSParameters.h:463
@ ENUM_BASIS_STATUS_atUpper
Definition: OSParameters.h:460
bool verifyServiceType(std::string type)
Definition: OSParameters.h:376
ENUM_OUTPUT_AREA
Enumeration for the different areas that can produce output.
Definition: OSParameters.h:129
@ ENUM_OUTPUT_AREA_OSMatrix
Definition: OSParameters.h:140
@ ENUM_OUTPUT_AREA_NUMBER_OF_AREAS
Definition: OSParameters.h:148
@ ENUM_OUTPUT_AREA_OSoLwriter
Definition: OSParameters.h:142
@ ENUM_OUTPUT_AREA_OSrL_parser
Definition: OSParameters.h:135
@ ENUM_OUTPUT_AREA_OSGeneral
Definition: OSParameters.h:136
@ ENUM_OUTPUT_AREA_OSSolverInterfaces
Definition: OSParameters.h:145
@ ENUM_OUTPUT_AREA_OSOption
Definition: OSParameters.h:138
@ ENUM_OUTPUT_AREA_OSAgent
Definition: OSParameters.h:131
@ ENUM_OUTPUT_AREA_OSResult
Definition: OSParameters.h:139
@ ENUM_OUTPUT_AREA_OSiLwriter
Definition: OSParameters.h:141
@ ENUM_OUTPUT_AREA_OSUtils
Definition: OSParameters.h:146
@ ENUM_OUTPUT_AREA_OSrLwriter
Definition: OSParameters.h:143
@ ENUM_OUTPUT_AREA_Command_line_parser
Definition: OSParameters.h:132
@ ENUM_OUTPUT_AREA_main
Definition: OSParameters.h:130
@ ENUM_OUTPUT_AREA_OSiL_parser
Definition: OSParameters.h:133
@ ENUM_OUTPUT_AREA_OSoL_parser
Definition: OSParameters.h:134
@ ENUM_OUTPUT_AREA_OSInstance
Definition: OSParameters.h:137
@ ENUM_OUTPUT_AREA_OSModelInterfaces
Definition: OSParameters.h:144
ENUM_PROBLEM_COMPONENT
Definition: OSParameters.h:553
@ ENUM_PROBLEM_COMPONENT_objectives
Definition: OSParameters.h:555
@ ENUM_PROBLEM_COMPONENT_constraints
Definition: OSParameters.h:556
@ ENUM_PROBLEM_COMPONENT_variables
Definition: OSParameters.h:554
ENUM_CONREFERENCE_VALUETYPE
An enum to track the type of value contained in a reference to a constraint.
Definition: OSParameters.h:704
@ ENUM_CONREFERENCE_VALUETYPE_shortage
Definition: OSParameters.h:708
@ ENUM_CONREFERENCE_VALUETYPE_surplus
Definition: OSParameters.h:707
@ ENUM_CONREFERENCE_VALUETYPE_status
Definition: OSParameters.h:706
@ ENUM_CONREFERENCE_VALUETYPE_value
Definition: OSParameters.h:705
bool verifyTimeCategory(std::string category)
Definition: OSParameters.h:304
int returnConReferenceValueType(std::string valueType)
Definition: OSParameters.h:720
ENUM_TRANSPORT_TYPE
Definition: OSParameters.h:330
@ ENUM_TRANSPORT_TYPE_http
Definition: OSParameters.h:332
@ ENUM_TRANSPORT_TYPE_smtp
Definition: OSParameters.h:333
@ ENUM_TRANSPORT_TYPE_osp
Definition: OSParameters.h:331
@ ENUM_TRANSPORT_TYPE_other
Definition: OSParameters.h:335
@ ENUM_TRANSPORT_TYPE_ftp
Definition: OSParameters.h:334
bool verifyStorageUnit(std::string unit)
Definition: OSParameters.h:224
ENUM_VARTYPE
Definition: OSParameters.h:560
@ ENUM_VARTYPE_integer
Definition: OSParameters.h:563
@ ENUM_VARTYPE_continuous
Definition: OSParameters.h:561
@ ENUM_VARTYPE_binary
Definition: OSParameters.h:562
@ ENUM_VARTYPE_semicontinuous
Definition: OSParameters.h:565
@ ENUM_VARTYPE_semiinteger
Definition: OSParameters.h:566
@ ENUM_VARTYPE_string
Definition: OSParameters.h:564
int returnTimeCategory(std::string category)
Definition: OSParameters.h:292