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
120
121#define DEFAULT_OUTPUT_LEVEL ENUM_OUTPUT_LEVEL_error
122
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
558
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
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
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
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
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 */
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
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)
ENUM_NL_EXPR_SHAPE
@ ENUM_NL_EXPR_SHAPE_general
@ ENUM_NL_EXPR_SHAPE_convex
@ ENUM_NL_EXPR_SHAPE_constant
@ ENUM_NL_EXPR_SHAPE_linear
@ ENUM_NL_EXPR_SHAPE_quadratic
bool verifyMatrixSymmetry(std::string symmetry)
std::string returnConReferenceValueTypeString(ENUM_CONREFERENCE_VALUETYPE valueType)
ENUM_TIMECATEGORY
@ ENUM_TIMECATEGORY_optimization
@ ENUM_TIMECATEGORY_other
@ ENUM_TIMECATEGORY_preprocessing
@ ENUM_TIMECATEGORY_postprocessing
@ ENUM_TIMECATEGORY_input
@ ENUM_TIMECATEGORY_total
@ ENUM_TIMECATEGORY_output
const int OSINT_MAX
bool verifyBasisStatus(std::string status)
ENUM_SOLUTION_SUBSTATUSTYPE
@ ENUM_SOLUTION_SUBSTATUSTYPE_stoppedByLimit
@ ENUM_SOLUTION_SUBSTATUSTYPE_other
@ ENUM_SOLUTION_SUBSTATUSTYPE_stoppedByBounds
std::string OSgetVersionInfo()
int returnTransportType(std::string type)
ENUM_GENERAL_RESULT_STATUS
@ ENUM_GENERAL_RESULT_STATUS_normal
@ ENUM_GENERAL_RESULT_STATUS_error
@ ENUM_GENERAL_RESULT_STATUS_warning
bool verifyMatrixConstructorType(std::string type)
int returnVarType(char vt)
bool verifySolutionSubstatusType(std::string type)
ENUM_JOB_STATUS
@ ENUM_JOB_STATUS_finished
@ ENUM_JOB_STATUS_killed
@ ENUM_JOB_STATUS_waiting
@ ENUM_JOB_STATUS_running
@ ENUM_JOB_STATUS_unknown
bool verifyMatrixType(std::string type)
int returnTimeUnit(std::string unit)
int returnGeneralResultStatus(std::string status)
bool verifyVarType(char vt)
int returnServiceType(std::string type)
int returnStorageUnit(std::string unit)
bool verifyTransportType(std::string type)
bool verifySolutionStatus(std::string status)
std::string returnExprShapeString(ENUM_NL_EXPR_SHAPE shape)
int returnCPUSpeedUnit(std::string unit)
std::string returnMatrixSymmetryString(ENUM_MATRIX_SYMMETRY symmetry)
int returnLocationType(std::string type)
bool verifyCPUSpeedUnit(std::string unit)
const double OSDBL_MAX
int returnNlExprShape(std::string shape)
ENUM_COMBINE_ARRAYS
An enum to streamline set() methods of vectors.
@ ENUM_COMBINE_ARRAYS_replace
@ ENUM_COMBINE_ARRAYS_throw
@ ENUM_COMBINE_ARRAYS_merge
@ ENUM_COMBINE_ARRAYS_ignore
bool verifyLocationType(std::string type)
int returnSystemCurrentState(std::string status)
int returnBasisStatus(std::string status)
bool verifyNlExprShape(std::string shape)
bool verifyConReferenceValueType(std::string valueType)
ENUM_LOCATIONTYPE
@ ENUM_LOCATIONTYPE_ftp
@ ENUM_LOCATIONTYPE_http
@ ENUM_LOCATIONTYPE_local
ENUM_CPUSPEEDUNIT
@ ENUM_CPUSPEEDUNIT_flops
@ ENUM_CPUSPEEDUNIT_gigaflops
@ ENUM_CPUSPEEDUNIT_megaflops
@ ENUM_CPUSPEEDUNIT_megahertz
@ ENUM_CPUSPEEDUNIT_teraflops
@ ENUM_CPUSPEEDUNIT_gigahertz
@ ENUM_CPUSPEEDUNIT_hertz
@ ENUM_CPUSPEEDUNIT_kiloflops
@ ENUM_CPUSPEEDUNIT_petaflops
@ ENUM_CPUSPEEDUNIT_kilohertz
@ ENUM_CPUSPEEDUNIT_terahertz
bool verifyConeType(std::string type)
std::string returnMatrixTypeString(ENUM_MATRIX_TYPE type)
int returnSolutionSubstatusType(std::string type)
int returnMatrixType(std::string type)
ENUM_STORAGEUNIT
@ ENUM_STORAGEUNIT_petabyte
@ ENUM_STORAGEUNIT_gigabyte
@ ENUM_STORAGEUNIT_byte
@ ENUM_STORAGEUNIT_zettabyte
@ ENUM_STORAGEUNIT_megabyte
@ ENUM_STORAGEUNIT_kilobyte
@ ENUM_STORAGEUNIT_yottabyte
@ ENUM_STORAGEUNIT_terabyte
@ ENUM_STORAGEUNIT_exabyte
bool verifyJobStatus(std::string status)
int returnMatrixSymmetry(std::string symmetry)
bool verifySystemCurrentState(std::string status)
ENUM_CONE_TYPE
@ ENUM_CONE_TYPE_rotatedNormed
@ ENUM_CONE_TYPE_orthant
@ ENUM_CONE_TYPE_dual
@ ENUM_CONE_TYPE_nonnegative
@ ENUM_CONE_TYPE_product
@ ENUM_CONE_TYPE_quadratic
@ ENUM_CONE_TYPE_nonnegativePolynomials
@ ENUM_CONE_TYPE_nonpositive
@ ENUM_CONE_TYPE_rotatedQuadratic
@ ENUM_CONE_TYPE_intersection
@ ENUM_CONE_TYPE_unknown
@ ENUM_CONE_TYPE_normed
@ ENUM_CONE_TYPE_moments
@ ENUM_CONE_TYPE_copositiveMatrices
@ ENUM_CONE_TYPE_sumOfSquaresPolynomials
@ ENUM_CONE_TYPE_semidefinite
@ ENUM_CONE_TYPE_polyhedral
@ ENUM_CONE_TYPE_completelyPositiveMatrices
@ ENUM_CONE_TYPE_polar
@ ENUM_CONE_TYPE_hyperbolicity
ENUM_SYSTEM_CURRENT_STATE
@ ENUM_SYSTEM_CURRENT_STATE_busyButAccepting
@ ENUM_SYSTEM_CURRENT_STATE_busy
@ ENUM_SYSTEM_CURRENT_STATE_idle
@ ENUM_SYSTEM_CURRENT_STATE_noResponse
@ ENUM_SYSTEM_CURRENT_STATE_idleButNotAccepting
ENUM_OUTPUT_LEVEL
Enumeration for the different verbosity levels that can be used in producing output.
@ ENUM_OUTPUT_LEVEL_detailed_trace
@ ENUM_OUTPUT_LEVEL_debug
@ ENUM_OUTPUT_LEVEL_trace
@ ENUM_OUTPUT_LEVEL_error
@ ENUM_OUTPUT_LEVEL_info
@ ENUM_OUTPUT_LEVEL_summary
@ ENUM_OUTPUT_LEVEL_NUMBER_OF_LEVELS
@ ENUM_OUTPUT_LEVEL_always
@ ENUM_OUTPUT_LEVEL_warning
std::string returnBasisStatusString(ENUM_BASIS_STATUS status)
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...
@ ENUM_MATRIX_TYPE_linear
@ ENUM_MATRIX_TYPE_varReference
@ ENUM_MATRIX_TYPE_string
@ ENUM_MATRIX_TYPE_constant
@ ENUM_MATRIX_TYPE_conReference
@ ENUM_MATRIX_TYPE_general
@ ENUM_MATRIX_TYPE_unknown
@ ENUM_MATRIX_TYPE_mixedRowReference
@ ENUM_MATRIX_TYPE_quadratic
@ ENUM_MATRIX_TYPE_empty
@ ENUM_MATRIX_TYPE_objReference
bool verifyTimeUnit(std::string unit)
bool verifyTimeType(std::string type)
bool verifyGeneralResultStatus(std::string status)
ENUM_MATRIX_SYMMETRY
@ ENUM_MATRIX_SYMMETRY_upper
@ ENUM_MATRIX_SYMMETRY_lower
@ ENUM_MATRIX_SYMMETRY_skewLower
@ ENUM_MATRIX_SYMMETRY_skewUpper
@ ENUM_MATRIX_SYMMETRY_none
@ ENUM_MATRIX_SYMMETRY_HermitianLower
@ ENUM_MATRIX_SYMMETRY_HermitianUpper
ENUM_SERVICE_TYPE
@ ENUM_SERVICE_TYPE_solver
@ ENUM_SERVICE_TYPE_registry
@ ENUM_SERVICE_TYPE_modeler
@ ENUM_SERVICE_TYPE_simulations
@ ENUM_SERVICE_TYPE_analyzer
@ ENUM_SERVICE_TYPE_scheduler
@ ENUM_SERVICE_TYPE_agent
int returnTimeType(std::string type)
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.
double OSNaN()
returns the value for NaN used in OS
ENUM_PATHPAIR
@ ENUM_PATHPAIR_output_dir
@ ENUM_PATHPAIR_input_dir
@ ENUM_PATHPAIR_output_file
@ ENUM_PATHPAIR_input_file
int returnMatrixConstructorType(std::string cType)
int returnJobStatus(std::string status)
int returnSolutionStatus(std::string status)
ENUM_MATRIX_CONSTRUCTOR_TYPE
@ ENUM_MATRIX_CONSTRUCTOR_TYPE_mixedRowRefElements
@ ENUM_MATRIX_CONSTRUCTOR_TYPE_generalElements
@ ENUM_MATRIX_CONSTRUCTOR_TYPE_varRefElements
@ ENUM_MATRIX_CONSTRUCTOR_TYPE_transformation
@ ENUM_MATRIX_CONSTRUCTOR_TYPE_objRefElements
@ ENUM_MATRIX_CONSTRUCTOR_TYPE_conRefElements
@ ENUM_MATRIX_CONSTRUCTOR_TYPE_stringValuedElements
@ ENUM_MATRIX_CONSTRUCTOR_TYPE_unknown
@ ENUM_MATRIX_CONSTRUCTOR_TYPE_blocks
@ ENUM_MATRIX_CONSTRUCTOR_TYPE_linearElements
@ ENUM_MATRIX_CONSTRUCTOR_TYPE_block
@ ENUM_MATRIX_CONSTRUCTOR_TYPE_matrix
@ ENUM_MATRIX_CONSTRUCTOR_TYPE_constantElements
@ ENUM_MATRIX_CONSTRUCTOR_TYPE_baseMatrix
ENUM_TIMETYPE
@ ENUM_TIMETYPE_elapsedTime
@ ENUM_TIMETYPE_cpuTime
@ ENUM_TIMETYPE_other
ENUM_SOLUTION_STATUS
@ ENUM_SOLUTION_STATUS_bestSoFar
@ ENUM_SOLUTION_STATUS_unbounded
@ ENUM_SOLUTION_STATUS_locallyOptimal
@ ENUM_SOLUTION_STATUS_feasible
@ ENUM_SOLUTION_STATUS_other
@ ENUM_SOLUTION_STATUS_optimal
@ ENUM_SOLUTION_STATUS_error
@ ENUM_SOLUTION_STATUS_unsure
@ ENUM_SOLUTION_STATUS_infeasible
@ ENUM_SOLUTION_STATUS_globallyOptimal
ENUM_TIMEUNIT
@ ENUM_TIMEUNIT_millisecond
@ ENUM_TIMEUNIT_week
@ ENUM_TIMEUNIT_year
@ ENUM_TIMEUNIT_tick
@ ENUM_TIMEUNIT_hour
@ ENUM_TIMEUNIT_minute
@ ENUM_TIMEUNIT_day
@ ENUM_TIMEUNIT_second
@ ENUM_TIMEUNIT_month
ENUM_BASIS_STATUS
Enumeration for the different states that can be used in representating a basis The last state,...
@ ENUM_BASIS_STATUS_isFree
@ ENUM_BASIS_STATUS_unknown
@ ENUM_BASIS_STATUS_basic
@ ENUM_BASIS_STATUS_NUMBER_OF_STATES
@ ENUM_BASIS_STATUS_atLower
@ ENUM_BASIS_STATUS_atEquality
@ ENUM_BASIS_STATUS_superbasic
@ ENUM_BASIS_STATUS_atUpper
bool verifyServiceType(std::string type)
ENUM_OUTPUT_AREA
Enumeration for the different areas that can produce output.
@ ENUM_OUTPUT_AREA_OSMatrix
@ ENUM_OUTPUT_AREA_NUMBER_OF_AREAS
@ ENUM_OUTPUT_AREA_OSoLwriter
@ ENUM_OUTPUT_AREA_OSrL_parser
@ ENUM_OUTPUT_AREA_OSGeneral
@ ENUM_OUTPUT_AREA_OSSolverInterfaces
@ ENUM_OUTPUT_AREA_OSOption
@ ENUM_OUTPUT_AREA_OSAgent
@ ENUM_OUTPUT_AREA_OSResult
@ ENUM_OUTPUT_AREA_OSiLwriter
@ ENUM_OUTPUT_AREA_OSUtils
@ ENUM_OUTPUT_AREA_OSrLwriter
@ ENUM_OUTPUT_AREA_Command_line_parser
@ ENUM_OUTPUT_AREA_main
@ ENUM_OUTPUT_AREA_OSiL_parser
@ ENUM_OUTPUT_AREA_OSoL_parser
@ ENUM_OUTPUT_AREA_OSInstance
@ ENUM_OUTPUT_AREA_OSModelInterfaces
ENUM_PROBLEM_COMPONENT
@ ENUM_PROBLEM_COMPONENT_objectives
@ ENUM_PROBLEM_COMPONENT_constraints
@ ENUM_PROBLEM_COMPONENT_variables
ENUM_CONREFERENCE_VALUETYPE
An enum to track the type of value contained in a reference to a constraint.
@ ENUM_CONREFERENCE_VALUETYPE_shortage
@ ENUM_CONREFERENCE_VALUETYPE_surplus
@ ENUM_CONREFERENCE_VALUETYPE_status
@ ENUM_CONREFERENCE_VALUETYPE_value
bool verifyTimeCategory(std::string category)
int returnConReferenceValueType(std::string valueType)
ENUM_TRANSPORT_TYPE
@ ENUM_TRANSPORT_TYPE_http
@ ENUM_TRANSPORT_TYPE_smtp
@ ENUM_TRANSPORT_TYPE_osp
@ ENUM_TRANSPORT_TYPE_other
@ ENUM_TRANSPORT_TYPE_ftp
bool verifyStorageUnit(std::string unit)
ENUM_VARTYPE
@ ENUM_VARTYPE_integer
@ ENUM_VARTYPE_continuous
@ ENUM_VARTYPE_binary
@ ENUM_VARTYPE_semicontinuous
@ ENUM_VARTYPE_semiinteger
@ ENUM_VARTYPE_string
int returnTimeCategory(std::string category)