MAiNGO
maingo::MAiNGO Class Reference

This class is the MAiNGO solver holding the B&B tree, upper bounding solver, lower bounding solver and settings. More...

#include <MAiNGO.h>

Public Member Functions

 MAiNGO (std::shared_ptr< MAiNGOmodel > myModel)
 Constructor which initializes models and solvers. More...
 
 ~MAiNGO ()
 Destructor. More...
 
void set_model (std::shared_ptr< MAiNGOmodel > myModel)
 Initializes model. More...
 
RETCODE solve ()
 Solves the problem. More...
 
RETCODE solve_epsilon_constraint ()
 Solve a multi-objective problem using the epsilon-constraint method. More...
 
bool set_option (const std::string option, const double value)
 Sets an option. More...
 
void read_settings (std::string settingsFile)
 Reads settings from text file. More...
 
void set_log_file_name (std::string logFileName="bab")
 Sets name of the log file. More...
 
void set_res_file_name (std::string resFileName="MAiNGO_res")
 Sets name of the res file. More...
 
void set_csv_file_name (std::string csvIterationsName="bab_Report_Iterations", std::string csvGeneralName="bab_Report_General")
 Sets names of the csv files. More...
 
void set_output_stream (std::ostream *outputStream)
 Sets output stream. More...
 
void parse_maingo_to_other_language (const PARSING_LANGUAGE parsing_language, const std::string fileName="MAiNGO_parsed_file", const std::string solverName="SCIP", const bool useMinMax=true, const bool useTrig=true, const bool ignoreBoundingFuncs=false, const bool writeRelaxationOnly=true)
 Writes MAiNGO model to a different modeling language. More...
 
void print_MAiNGO (std::ostream &outstream=std::cout)
 Function printing an ASCII MAiNGO with copyright. More...
 
MAiNGO getter functions
double get_objective_value () const
 Function returning objective value. More...
 
std::vector< double > get_solution_point () const
 Function returning solution point. More...
 
double get_cpu_solution_time () const
 Function returning CPU solution time. More...
 
double get_wallclock_solution_time () const
 Function returning wallclock solution time. More...
 
double get_iterations () const
 Function returning the number of iterations. More...
 
double get_max_nodes_in_memory () const
 Function returning the maximum number of nodes in memory. More...
 
double get_UBP_count () const
 Function returning number of UBD problems solved. More...
 
double get_LBP_count () const
 Function returning number of LBD problems solved. More...
 
double get_final_LBD () const
 Function returning the final LBD. More...
 
double get_final_abs_gap () const
 Function returning the final absolute gap. More...
 
double get_final_rel_gap () const
 Function returning the final relative gap. More...
 
RETCODE get_status () const
 Funcition returning whether MAiNGO solved the problem or not. More...
 
std::vector< std::pair< std::string, double > > get_additional_outputs_at_solution_point ()
 Function returning the additional model outputs at solution point. More...
 
std::vector< double > get_model_at_solution_point ()
 Function returning all model function values at solution point. The ordering of the returned vector is: vector[0]: objective vector[1 to (1+ineq)]: inequalities ( + constant inequalities ) vector[(1+ineq) to (1+ineq+eq)]: equalities ( + constant equalities ) vector[(1+ineq+eq) to (1+ineq+eq+ineqRelOnly)]: relaxation only inequalities ( + constant rel only inequalities ) vector[(1+ineq+eq+ineqRelOnly) to (1+ineq+eq+ineqRelOnly+eqRelOnly)]: relaxation only equalities ( + constant rel only equalities ) vector[(1+ineq+eq+ineqRelOnly+eqRelOnly) to (1+ineq+eq+ineqRelOnly+eqRelOnly+ineqSquash)]: squash inequalities ( + constant squash inequalities ) More...
 
bool get_model_at_point (const std::vector< double > &point, std::vector< double > &returnResult)
 Function telling whether a point is feasible or not and returning values of the set model of the objective and all constraints at a point. The ordering of the vector returnResult is: vector[0]: objective vector[1 to (1+ineq)]: inequalities ( + constant inequalities ) vector[(1+ineq) to (1+ineq+eq)]: equalities ( + constant equalities ) vector[(1+ineq+eq) to (1+ineq+eq+ineqRelOnly)]: relaxation only inequalities ( + constant rel only inequalities ) vector[(1+ineq+eq+ineqRelOnly) to (1+ineq+eq+ineqRelOnly+eqRelOnly)]: relaxation only equalities ( + constant rel only equalities ) vector[(1+ineq+eq+ineqRelOnly+eqRelOnly) to (1+ineq+eq+ineqRelOnly+eqRelOnly+ineqSquash)]: squash inequalities ( + constant squash inequalities ) More...
 
std::vector< std::pair< std::string, double > > get_additional_outputs_at_point (const std::vector< double > &point)
 Function returning values of the additional outputs of the set model at a point. More...
 

Private Member Functions

 MAiNGO ()
 Preventing use of default constructor. More...
 
 MAiNGO (const MAiNGO &)
 Preventing use of default copy constructor. More...
 
MAiNGOoperator= (const MAiNGO &)
 Preventing use of default copy assignment. More...
 
RETCODE _analyze_and_solve_problem ()
 Internal function conducts structure recognition, sets constraint properties, and invokes the correct solution routine. More...
 
RETCODE _solve_MIQP ()
 Solves an LP, MIP, QP or MIQP. More...
 
RETCODE _solve_MINLP ()
 Solves an NLP or MINLP. More...
 
void _construct_DAG ()
 Construct DAG. More...
 
void _classify_constraints (std::vector< mc::FFVar > &tmpFunctions, const std::vector< mc::FFVar > &tmpDAGVars)
 Fills the constraints vectors (original, constant, non-constant) and outputs and writes non-constant functions and outputs to the provided vectors This function DOES NOT classify auxiliary relaxation only equalities as this is done in _add_auxiliary_variables_to_lbd_dag. More...
 
bool _check_for_hidden_zero_constraints (const std::vector< mc::FFVar > &tmpDAGVars, std::vector< mc::FFVar > &tmpDAGFunctions, std::vector< mc::FFVar > &tmpDAGoutputFunctions)
 Checks if the constraints are non-zero (constant) after the DAG has been constructed (this may happen if some FFVars are equal). Fills tmpDAGFunctions and tmpDAGoutputFunctions. More...
 
void _add_auxiliary_variables_to_lbd_dag ()
 Modifies the lower bound DAG _DAGlbd by adding auxiliary optimization variables for intermediate factors occuring multiple times. More...
 
void _initialize_solve ()
 Initializes subsolvers and internal solution variables for the solution of an LP, MIP, QP or MIQP. More...
 
void _root_obbt_feasibility ()
 Conducts feasibility-based bound tightening at the root node. More...
 
void _root_obbt_feasibility_optimality ()
 Conducts feasibility- and optimality-based bound tightening at the root node. More...
 
void _root_constraint_propagation ()
 Conducts feasibility- and optimality-based bound tightening at the root node. More...
 
void _root_multistart ()
 Conducts multistart local search at the root node. More...
 
void _recognize_structure ()
 Uses mc::FFDep properties and the DAG to obtain information on the structure of the underlying problem. More...
 
void _set_constraint_properties ()
 Uses mc::FFDep properties and the DAG to obtain information on the properties of constraints. More...
 
bool _check_feasibility_of_relaxation_only_constraints (const std::vector< double > &solutionPoint, std::string &str, const std::string &whitespaces)
 Checks whether the current incumbent satisfies relaxation only constraints and gives a warning if not. More...
 
void _print_MAiNGO_header ()
 Write MAiNGO header. More...
 
void _print_message (const std::string &message)
 Prints message with beautiful '*' box. More...
 
void _write_epsilon_constraint_result (const std::vector< std::vector< double >> &objectiveValues, const std::vector< std::vector< double >> &solutionPoints)
 Function for writing the pareto front to MAiNGO_epsilon_constraint_objective_values.csv and the corresponding solution points to MAiNGO_epsilon_constraint_solution_points.csv. More...
 
bool _get_model_at_point (const std::vector< double > &point, std::vector< double > &returnResult)
 Function telling whether a point is feasible or not and returning values of the set model of the objective and all constraints at a point. The ordering of the vector returnResult is: vector[0]: objective vector[1 to (1+ineq)]: inequalities vector[(1+ineq) to (1+ineq+eq)]: equalities vector[(1+ineq+eq) to (1+ineq+eq+ineqRelOnly)]: relaxation only inequalities vector[(1+ineq+eq+ineqRelOnly) to (1+ineq+eq+ineqRelOnly+eqRelOnly)]: relaxation only equalities vector[(1+ineq+eq+ineqRelOnly+eqRelOnly) to (1+ineq+eq+ineqRelOnly+eqRelOnly+ineqSquash)]: squash inequalities ( + constant squash inequalities ) More...
 
std::vector< std::pair< std::string, double > > _get_additional_outputs (const std::vector< double > &point)
 Function returning values of the additional outputs of the set model at a point. More...
 
MAiNGO printing functions
void _print_statistics ()
 Prints problem & solution statistics on screen. More...
 
void _print_solution ()
 Prints solution on screen. More...
 
void _print_time ()
 Prints solution time on screen. More...
 
void _print_additional_output ()
 Prints additional model output on screen. More...
 
MAiNGO file writing functions
void _write_files ()
 Writes logging and csv information to disk. More...
 
void _write_files_error (const std::string &error)
 Writes logging and csv information to disk when an error occurs. More...
 
void _write_csv_general ()
 Write csv summaries to disk. More...
 
void _write_res_file ()
 Write res file to disk containing non-standard model information such as, e.g., residuals It will be only written if the problem has been solved successfully. More...
 
MAiNGO to other language functions
void _write_gams_file (const std::string gamsFileName="MAiNGO_GAMS_file", const std::string solverName="SCIP", const bool writeRelaxationOnly=false)
 Writes MAiNGO problem to GAMS file. More...
 
void _write_gams_variables (std::ofstream &gamsFile)
 Function writing variables, variable bounds and a initial point in the gams file. More...
 
void _write_gams_functions (std::ofstream &gamsFile, bool writeRelaxationOnly)
 Function writing functions into the gams file. More...
 
void _write_gams_options (std::ofstream &gamsFile, std::string solverName="SCIP")
 Function writing options and model information into gams file. More...
 
void _add_linebreaks_to_gams_string (std::string &str)
 Function for adding linebreaks in gams string. Older GAMS versions allow only for 40000 characters in one line. More...
 
void _write_ale_file (const std::string aleFileName="MAiNGO_ALE_file", const std::string solverName="SCIP", const bool writeRelaxationOnly=false)
 Writes MAiNGO problem to ALE file. More...
 
void _write_ale_variables (std::ofstream &aleFile)
 Function writing variables, variable bounds and a initial point in the ale file. More...
 
void _write_ale_functions (std::ofstream &aleFile, bool writeRelaxationOnly)
 Function writing functions into the ale file. More...
 
void _write_ale_options (std::ofstream &aleFile, std::string solverName="SCIP")
 Function writing options and model information into ale file. More...
 
void _print_MAiNGO_header_for_other_modeling_language (const PARSING_LANGUAGE parsing_language, std::ofstream &file)
 Write MAiNGO header for a different modeling language. More...
 

Private Attributes

Settings _maingoSettings
 
Settings _maingoOriginalSettings
 
Logger _logger
 
Internal variables for storing information on the problem
mc::FFGraph _DAG
 
std::vector< mc::FFVar > _DAGvars
 
std::vector< mc::FFVar > _DAGfunctions
 
std::vector< mc::FFVar > _DAGoutputFunctions
 
std::vector< mc::FFVar > _resultVars
 
std::vector< OptimizationVariable_originalVariables
 
std::vector< OptimizationVariable * > _infeasibleVariables
 
std::vector< OptimizationVariable_variables
 
std::vector< bool > _removedVariables
 
std::vector< std::string > _uniqueNamesOriginal
 
std::vector< std::string > _uniqueNames
 
std::vector< double > _initialPointOriginal
 
std::vector< double > _initialPoint
 
unsigned _nvarOriginal
 
unsigned _nvar
 
unsigned _nineq
 
unsigned _neq
 
unsigned _nineqRelaxationOnly
 
unsigned _neqRelaxationOnly
 
unsigned _nineqSquash
 
unsigned _noutputVariables
 
unsigned _nconstantIneq
 
unsigned _nconstantEq
 
unsigned _nconstantIneqRelOnly
 
unsigned _nconstantEqRelOnly
 
unsigned _nconstantIneqSquash
 
unsigned _nconstantOutputVariables
 
std::vector< std::string > _outputNames
 
std::shared_ptr< MAiNGOmodel_myFFVARmodel
 
EvaluationContainer _modelOutput
 
bool _readyToSolve
 
bool _DAGconstructed
 
bool _variablesFeasible
 
bool _constantConstraintsFeasible
 
std::vector< Constraint_originalConstraints
 
std::vector< Constraint_constantConstraints
 
std::vector< Constraint_nonconstantConstraints
 
std::vector< Constraint_nonconstantConstraintsUBP
 
std::vector< Constraint_constantOutputs
 
std::vector< Constraint_nonconstantOutputs
 
Internal variables for storing information when auxiliary variables shall be added to the DAG
mc::FFGraph _DAGlbd
 
std::vector< mc::FFVar > _DAGvarsLbd
 
std::vector< mc::FFVar > _DAGfunctionsLbd
 
std::vector< mc::FFVar > _DAGoutputFunctionsLbd
 
std::vector< OptimizationVariable_variablesLbd
 
unsigned _nvarLbd
 
unsigned _nauxiliaryRelOnlyEqs
 
Auxiliaries variables for storing information on the optimization
std::vector< double > _solutionPoint
 
double _solutionValue
 
double _solutionTime
 
double _preprocessTime
 
double _babTime
 
double _outputTime
 
double _solutionTimeWallClock
 
RETCODE _maingoStatus
 
PROBLEM_STRUCTURE _problemStructure
 
TIGHTENING_RETCODE _rootObbtStatus
 
TIGHTENING_RETCODE _rootConPropStatus
 
SUBSOLVER_RETCODE _rootMultistartStatus
 
SUBSOLVER_RETCODE _miqpStatus
 
babBase::BabNode _rootNode
 
babBase::enums::BAB_RETCODE _babStatus
 
LowerBoundingSolver, UpperBoundingSolver and the B&B solver
std::shared_ptr< lbp::LowerBoundingSolver_myLBS
 
std::shared_ptr< ubp::UpperBoundingSolver_myUBSPre
 
std::shared_ptr< ubp::UpperBoundingSolver_myUBSBab
 
std::shared_ptr< bab::BranchAndBound_myBaB
 
Auxiliaries variables for storing output and logging information
std::vector< double > _objectivesAtRoot
 
std::vector< SUBSOLVER_RETCODE_feasibleAtRoot
 
bool _initialPointFeasible
 
bool _inMAiNGOsolve = false
 

Detailed Description

This class is the MAiNGO solver holding the B&B tree, upper bounding solver, lower bounding solver and settings.

This class is used to instantiate a MAiNGO object. It is used to solve a given MAiNGOmodel by doing pre-processing, holding the B&B tree, upper bounding solvers, a lower bounding solver and settings

Constructor & Destructor Documentation

◆ MAiNGO() [1/3]

MAiNGO::MAiNGO ( std::shared_ptr< MAiNGOmodel myModel)

Constructor which initializes models and solvers.

◆ ~MAiNGO()

maingo::MAiNGO::~MAiNGO ( )
inline

Destructor.

◆ MAiNGO() [2/3]

maingo::MAiNGO::MAiNGO ( )
private

Preventing use of default constructor.

◆ MAiNGO() [3/3]

maingo::MAiNGO::MAiNGO ( const MAiNGO )
private

Preventing use of default copy constructor.

Member Function Documentation

◆ _add_auxiliary_variables_to_lbd_dag()

void MAiNGO::_add_auxiliary_variables_to_lbd_dag ( )
private

Modifies the lower bound DAG _DAGlbd by adding auxiliary optimization variables for intermediate factors occuring multiple times.

◆ _add_linebreaks_to_gams_string()

void MAiNGO::_add_linebreaks_to_gams_string ( std::string &  str)
private

Function for adding linebreaks in gams string. Older GAMS versions allow only for 40000 characters in one line.

Parameters
[in]stris the string where linebreaks shall be added

◆ _analyze_and_solve_problem()

RETCODE MAiNGO::_analyze_and_solve_problem ( )
private

Internal function conducts structure recognition, sets constraint properties, and invokes the correct solution routine.

◆ _check_feasibility_of_relaxation_only_constraints()

bool MAiNGO::_check_feasibility_of_relaxation_only_constraints ( const std::vector< double > &  solutionPoint,
std::string &  str,
const std::string &  whitespaces 
)
private

Checks whether the current incumbent satisfies relaxation only constraints and gives a warning if not.

Parameters
[in]solutionPointis the current incumbent which is to be checked
[in,out]stris a string which is used to write the warning into, it will be modified such that you can add whitespace to it before passing it to this function
[in]whitespacesshould be a string holding only whitespaces. This is used for a nicer output
Returns
returns true if the point is feasible w.r.t. relaxation only constraints and false otherwise

◆ _check_for_hidden_zero_constraints()

bool MAiNGO::_check_for_hidden_zero_constraints ( const std::vector< mc::FFVar > &  tmpDAGVars,
std::vector< mc::FFVar > &  tmpDAGFunctions,
std::vector< mc::FFVar > &  tmpDAGoutputFunctions 
)
private

Checks if the constraints are non-zero (constant) after the DAG has been constructed (this may happen if some FFVars are equal). Fills tmpDAGFunctions and tmpDAGoutputFunctions.

Parameters
[in]tmpDAGVarsholds all DAG variables
[in,out]tmpDAGFunctionsholds all DAG functions (no additional outputs!)
[in,out]tmpDAGoutputFunctionsholds all DAG additional outputs

◆ _classify_constraints()

void MAiNGO::_classify_constraints ( std::vector< mc::FFVar > &  tmpFunctions,
const std::vector< mc::FFVar > &  tmpDAGVars 
)
private

Fills the constraints vectors (original, constant, non-constant) and outputs and writes non-constant functions and outputs to the provided vectors This function DOES NOT classify auxiliary relaxation only equalities as this is done in _add_auxiliary_variables_to_lbd_dag.

Parameters
[out]tmpFunctionsholds all non-constant constraints (and objective(s))
[in]tmpDAGVarsholds all DAG variables

◆ _construct_DAG()

void MAiNGO::_construct_DAG ( )
private

Construct DAG.

◆ _get_additional_outputs()

std::vector< std::pair< std::string, double > > MAiNGO::_get_additional_outputs ( const std::vector< double > &  point)
private

Function returning values of the additional outputs of the set model at a point.

Parameters
[in]pointis the point to be evaluated

◆ _get_model_at_point()

bool MAiNGO::_get_model_at_point ( const std::vector< double > &  point,
std::vector< double > &  returnResult 
)
private

Function telling whether a point is feasible or not and returning values of the set model of the objective and all constraints at a point. The ordering of the vector returnResult is: vector[0]: objective vector[1 to (1+ineq)]: inequalities vector[(1+ineq) to (1+ineq+eq)]: equalities vector[(1+ineq+eq) to (1+ineq+eq+ineqRelOnly)]: relaxation only inequalities vector[(1+ineq+eq+ineqRelOnly) to (1+ineq+eq+ineqRelOnly+eqRelOnly)]: relaxation only equalities vector[(1+ineq+eq+ineqRelOnly+eqRelOnly) to (1+ineq+eq+ineqRelOnly+eqRelOnly+ineqSquash)]: squash inequalities ( + constant squash inequalities )

Parameters
[in]pointis the point to be evaluated
[out]returnResultholds the objective and constraints as described above
Returns
returns whether the point is feasible or not

◆ _initialize_solve()

void MAiNGO::_initialize_solve ( )
private

Initializes subsolvers and internal solution variables for the solution of an LP, MIP, QP or MIQP.

◆ _print_additional_output()

void MAiNGO::_print_additional_output ( )
private

Prints additional model output on screen.

◆ _print_MAiNGO_header()

void MAiNGO::_print_MAiNGO_header ( )
private

Write MAiNGO header.

◆ _print_MAiNGO_header_for_other_modeling_language()

void MAiNGO::_print_MAiNGO_header_for_other_modeling_language ( const PARSING_LANGUAGE  parsing_language,
std::ofstream &  file 
)
private

Write MAiNGO header for a different modeling language.

Parameters
[in]parsing_languageis the desired modeling language
[in,out]fileis the file to be written to

◆ _print_message()

void MAiNGO::_print_message ( const std::string &  message)
private

Prints message with beautiful '*' box.

Parameters
[in]messageto be printed

◆ _print_solution()

void MAiNGO::_print_solution ( )
private

Prints solution on screen.

◆ _print_statistics()

void MAiNGO::_print_statistics ( )
private

Prints problem & solution statistics on screen.

◆ _print_time()

void MAiNGO::_print_time ( )
private

Prints solution time on screen.

◆ _recognize_structure()

void MAiNGO::_recognize_structure ( )
private

Uses mc::FFDep properties and the DAG to obtain information on the structure of the underlying problem.

◆ _root_constraint_propagation()

void MAiNGO::_root_constraint_propagation ( )
private

Conducts feasibility- and optimality-based bound tightening at the root node.

◆ _root_multistart()

void MAiNGO::_root_multistart ( )
private

Conducts multistart local search at the root node.

◆ _root_obbt_feasibility()

void MAiNGO::_root_obbt_feasibility ( )
private

Conducts feasibility-based bound tightening at the root node.

◆ _root_obbt_feasibility_optimality()

void MAiNGO::_root_obbt_feasibility_optimality ( )
private

Conducts feasibility- and optimality-based bound tightening at the root node.

◆ _set_constraint_properties()

void MAiNGO::_set_constraint_properties ( )
private

Uses mc::FFDep properties and the DAG to obtain information on the properties of constraints.

◆ _solve_MINLP()

RETCODE MAiNGO::_solve_MINLP ( )
private

Solves an NLP or MINLP.

◆ _solve_MIQP()

RETCODE MAiNGO::_solve_MIQP ( )
private

Solves an LP, MIP, QP or MIQP.

◆ _write_ale_file()

void MAiNGO::_write_ale_file ( const std::string  aleFileName = "MAiNGO_ALE_file",
const std::string  solverName = "SCIP",
const bool  writeRelaxationOnly = false 
)
private

Writes MAiNGO problem to ALE file.

Parameters
[in]aleFileNameis the file name. If it is empty, the default name "MAiNGO_ALE_file.txt" will be used instead.
[in]solverNameis the solver name. If it is empty, the default solver SCIP will be called in the gams file.
[in]writeRelaxationOnlyif true then relaxation-only equalities and inequalities will be written into the ALE file as well

◆ _write_ale_functions()

void MAiNGO::_write_ale_functions ( std::ofstream &  aleFile,
bool  writeRelaxationOnly 
)
private

Function writing functions into the ale file.

Parameters
[in]aleFileis an open ale file
[in]writeRelaxationOnlyif true then relaxation-only equalities and inequalities will be written into the ALE file as well.

◆ _write_ale_options()

void maingo::MAiNGO::_write_ale_options ( std::ofstream &  aleFile,
std::string  solverName = "SCIP" 
)
private

Function writing options and model information into ale file.

Parameters
[in]aleFileis an open ale file
[in]solverNameis the name of the solver called in the gams file. Default is SCIP

◆ _write_ale_variables()

void MAiNGO::_write_ale_variables ( std::ofstream &  aleFile)
private

Function writing variables, variable bounds and a initial point in the ale file.

Parameters
[in]aleFileis an open ale file

◆ _write_csv_general()

void MAiNGO::_write_csv_general ( )
private

Write csv summaries to disk.

◆ _write_epsilon_constraint_result()

void MAiNGO::_write_epsilon_constraint_result ( const std::vector< std::vector< double >> &  objectiveValues,
const std::vector< std::vector< double >> &  solutionPoints 
)
private

Function for writing the pareto front to MAiNGO_epsilon_constraint_objective_values.csv and the corresponding solution points to MAiNGO_epsilon_constraint_solution_points.csv.

Parameters
[in]objectiveValuesholds the objective value vectors
[in]solutionPointsholds the corresponding solution points

◆ _write_files()

void MAiNGO::_write_files ( )
private

Writes logging and csv information to disk.

◆ _write_files_error()

void MAiNGO::_write_files_error ( const std::string &  error)
private

Writes logging and csv information to disk when an error occurs.

◆ _write_gams_file()

void MAiNGO::_write_gams_file ( const std::string  gamsFileName = "MAiNGO_GAMS_file",
const std::string  solverName = "SCIP",
const bool  writeRelaxationOnly = false 
)
private

Writes MAiNGO problem to GAMS file.

Parameters
[in]gamsFileNameis the file name. If it is empty, the default name "MAiNGO_GAMS_file.gms" will be used instead.
[in]solverNameis the solver name. If it is empty, the default solver SCIP will be called in the gams file.
[in]writeRelaxationOnlyif true then relaxation-only equalities and inequalities will be written into the GAMS file as well

◆ _write_gams_functions()

void MAiNGO::_write_gams_functions ( std::ofstream &  gamsFile,
bool  writeRelaxationOnly 
)
private

Function writing functions into the gams file.

Parameters
[in]gamsFileis an open gams file
[in]writeRelaxationOnlyif true then relaxation-only equalities and inequalities will be written into the gams file as well.

◆ _write_gams_options()

void MAiNGO::_write_gams_options ( std::ofstream &  gamsFile,
std::string  solverName = "SCIP" 
)
private

Function writing options and model information into gams file.

Parameters
[in]gamsFileis an open gams file
[in]solverNameis the name of the solver called in the gams file. Default is SCIP

◆ _write_gams_variables()

void MAiNGO::_write_gams_variables ( std::ofstream &  gamsFile)
private

Function writing variables, variable bounds and a initial point in the gams file.

Parameters
[in]gamsFileis an open gams file

◆ _write_res_file()

void MAiNGO::_write_res_file ( )
private

Write res file to disk containing non-standard model information such as, e.g., residuals It will be only written if the problem has been solved successfully.

◆ get_additional_outputs_at_point()

std::vector< std::pair< std::string, double > > MAiNGO::get_additional_outputs_at_point ( const std::vector< double > &  point)

Function returning values of the additional outputs of the set model at a point.

Parameters
[in]pointis the point to be evaluated

◆ get_additional_outputs_at_solution_point()

std::vector< std::pair< std::string, double > > MAiNGO::get_additional_outputs_at_solution_point ( )

Function returning the additional model outputs at solution point.

◆ get_cpu_solution_time()

double MAiNGO::get_cpu_solution_time ( ) const

Function returning CPU solution time.

◆ get_final_abs_gap()

double MAiNGO::get_final_abs_gap ( ) const

Function returning the final absolute gap.

◆ get_final_LBD()

double MAiNGO::get_final_LBD ( ) const

Function returning the final LBD.

◆ get_final_rel_gap()

double MAiNGO::get_final_rel_gap ( ) const

Function returning the final relative gap.

◆ get_iterations()

double MAiNGO::get_iterations ( ) const

Function returning the number of iterations.

◆ get_LBP_count()

double MAiNGO::get_LBP_count ( ) const

Function returning number of LBD problems solved.

◆ get_max_nodes_in_memory()

double MAiNGO::get_max_nodes_in_memory ( ) const

Function returning the maximum number of nodes in memory.

◆ get_model_at_point()

bool MAiNGO::get_model_at_point ( const std::vector< double > &  point,
std::vector< double > &  returnResult 
)

Function telling whether a point is feasible or not and returning values of the set model of the objective and all constraints at a point. The ordering of the vector returnResult is: vector[0]: objective vector[1 to (1+ineq)]: inequalities ( + constant inequalities ) vector[(1+ineq) to (1+ineq+eq)]: equalities ( + constant equalities ) vector[(1+ineq+eq) to (1+ineq+eq+ineqRelOnly)]: relaxation only inequalities ( + constant rel only inequalities ) vector[(1+ineq+eq+ineqRelOnly) to (1+ineq+eq+ineqRelOnly+eqRelOnly)]: relaxation only equalities ( + constant rel only equalities ) vector[(1+ineq+eq+ineqRelOnly+eqRelOnly) to (1+ineq+eq+ineqRelOnly+eqRelOnly+ineqSquash)]: squash inequalities ( + constant squash inequalities )

Parameters
[in]pointis the point to be evaluated
[out]returnResultholds the objective and constraints as described above
Returns
returns whether the point is feasible or not

◆ get_model_at_solution_point()

std::vector< double > MAiNGO::get_model_at_solution_point ( )

Function returning all model function values at solution point. The ordering of the returned vector is: vector[0]: objective vector[1 to (1+ineq)]: inequalities ( + constant inequalities ) vector[(1+ineq) to (1+ineq+eq)]: equalities ( + constant equalities ) vector[(1+ineq+eq) to (1+ineq+eq+ineqRelOnly)]: relaxation only inequalities ( + constant rel only inequalities ) vector[(1+ineq+eq+ineqRelOnly) to (1+ineq+eq+ineqRelOnly+eqRelOnly)]: relaxation only equalities ( + constant rel only equalities ) vector[(1+ineq+eq+ineqRelOnly+eqRelOnly) to (1+ineq+eq+ineqRelOnly+eqRelOnly+ineqSquash)]: squash inequalities ( + constant squash inequalities )

◆ get_objective_value()

double MAiNGO::get_objective_value ( ) const

Function returning objective value.

◆ get_solution_point()

std::vector< double > MAiNGO::get_solution_point ( ) const

Function returning solution point.

◆ get_status()

RETCODE MAiNGO::get_status ( ) const

Funcition returning whether MAiNGO solved the problem or not.

◆ get_UBP_count()

double MAiNGO::get_UBP_count ( ) const

Function returning number of UBD problems solved.

◆ get_wallclock_solution_time()

double MAiNGO::get_wallclock_solution_time ( ) const

Function returning wallclock solution time.

◆ operator=()

MAiNGO& maingo::MAiNGO::operator= ( const MAiNGO )
private

Preventing use of default copy assignment.

◆ parse_maingo_to_other_language()

void MAiNGO::parse_maingo_to_other_language ( const PARSING_LANGUAGE  parsing_language,
const std::string  fileName = "MAiNGO_parsed_file",
const std::string  solverName = "SCIP",
const bool  useMinMax = true,
const bool  useTrig = true,
const bool  ignoreBoundingFuncs = false,
const bool  writeRelaxationOnly = true 
)

Writes MAiNGO model to a different modeling language.

Parameters
[in]parsing_languageis the modeling language to which the MAiNGO model is parsed.
[in]fileNameis the file name. If it is empty, the default name "MAiNGO_parsed_file" will be used instead.
[in]solverNameis the solver name. If it is empty, the default solver SCIP will be called in the gams file.
[in]useMinMaxif true then min/max is used when writing output, otherwise the equivalent abs forms are used.
[in]useTrigif true then sinh, cosh, tanh is used when writing output, otherwise the equivalent exp forms are used.
[in]ignoreBoundingFuncsif true then squash_node, pos, neg, bounding_func, lb_func and ub_func are ignored otherwise they will be simply written into the file.
[in]writeRelaxationOnlyif true then relaxation-only equalities and inequalities will be written into the file as well.

◆ print_MAiNGO()

void MAiNGO::print_MAiNGO ( std::ostream &  outstream = std::cout)

Function printing an ASCII MAiNGO with copyright.

◆ read_settings()

void MAiNGO::read_settings ( std::string  settingsFile)

Reads settings from text file.

Parameters
[in]settingsFileis the file name. If it is empty, the default file name "MAiNGOSettings.txt" will be used instead.

◆ set_csv_file_name()

void MAiNGO::set_csv_file_name ( std::string  csvIterationsName = "bab_Report_Iterations",
std::string  csvGeneralName = "bab_Report_General" 
)

Sets names of the csv files.

Parameters
[in]csvIterationsNameis the file name, where B&B iterations are written. If it is empty, the default file name "bab_Report_Iterations" will be used instead.
[in]csvGeneralNameis the file name, where general optimization information are written. If it is empty, the default file name "bab_Report_General" will be used instead.

◆ set_log_file_name()

void MAiNGO::set_log_file_name ( std::string  logFileName = "bab")

Sets name of the log file.

Parameters
[in]logFileNameis the file name. If it is empty, the default file name "bab.log" will be used instead.

◆ set_model()

void MAiNGO::set_model ( std::shared_ptr< MAiNGOmodel myModel)

Initializes model.

◆ set_option()

bool MAiNGO::set_option ( const std::string  option,
const double  value 
)

Sets an option.

Parameters
[in]optionis the option name
[in]valueis the option value

◆ set_output_stream()

void MAiNGO::set_output_stream ( std::ostream *  outputStream)

Sets output stream.

Parameters
[in,out]outputStreamis the new output stream to be used by MAiNGO.

◆ set_res_file_name()

void MAiNGO::set_res_file_name ( std::string  resFileName = "MAiNGO_res")

Sets name of the res file.

Parameters
[in]resFileNameis the file name. If it is empty, the default file name "MAiNGO_res.txt" will be used instead.

◆ solve()

RETCODE MAiNGO::solve ( )

Solves the problem.

◆ solve_epsilon_constraint()

RETCODE MAiNGO::solve_epsilon_constraint ( )

Solve a multi-objective problem using the epsilon-constraint method.

Member Data Documentation

◆ _babStatus

babBase::enums::BAB_RETCODE maingo::MAiNGO::_babStatus
private

flag indicating the return status of the branch-and-bound problem

◆ _babTime

double maingo::MAiNGO::_babTime
private

double holding the solution time in CPU s for B&B only

◆ _constantConstraints

std::vector<Constraint> maingo::MAiNGO::_constantConstraints
private

vector holding all constant constraints. This is used for convenient printing and writing of output

◆ _constantConstraintsFeasible

bool maingo::MAiNGO::_constantConstraintsFeasible
private

flag indicating whether the constant constraints are feasible

◆ _constantOutputs

std::vector<Constraint> maingo::MAiNGO::_constantOutputs
private

vector holding all constant outputs

◆ _DAG

mc::FFGraph maingo::MAiNGO::_DAG
private

the actual DAG

◆ _DAGconstructed

bool maingo::MAiNGO::_DAGconstructed
private

flag storing whether the DAG has already been constructed

◆ _DAGfunctions

std::vector<mc::FFVar> maingo::MAiNGO::_DAGfunctions
private

list of all non-constant functions in the DAG except for additional output

◆ _DAGfunctionsLbd

std::vector<mc::FFVar> maingo::MAiNGO::_DAGfunctionsLbd
private

list of all functions in the DAG except for additional output for the lower bounding problem when auxiliary variables have been added

◆ _DAGlbd

mc::FFGraph maingo::MAiNGO::_DAGlbd
private

DAG used for the lower bounding problem when auxiliary variables have been added

◆ _DAGoutputFunctions

std::vector<mc::FFVar> maingo::MAiNGO::_DAGoutputFunctions
private

list of all constant functions needed for additional output computation

◆ _DAGoutputFunctionsLbd

std::vector<mc::FFVar> maingo::MAiNGO::_DAGoutputFunctionsLbd
private

list of all functions needed for additional output computation for the lower bounding problem when auxiliary variables have been added

◆ _DAGvars

std::vector<mc::FFVar> maingo::MAiNGO::_DAGvars
private

DAG variables

◆ _DAGvarsLbd

std::vector<mc::FFVar> maingo::MAiNGO::_DAGvarsLbd
private

DAG variables for the lower bounding problem when auxiliary variables have been added

◆ _feasibleAtRoot

std::vector<SUBSOLVER_RETCODE> maingo::MAiNGO::_feasibleAtRoot
private

contains information about which local optimization at the root node yielded a feasible point

◆ _infeasibleVariables

std::vector<OptimizationVariable *> maingo::MAiNGO::_infeasibleVariables
private

vector containing pointers to variables in _originalVariables with empty host set

◆ _initialPoint

std::vector<double> maingo::MAiNGO::_initialPoint
private

vector holding the initial point

◆ _initialPointFeasible

bool maingo::MAiNGO::_initialPointFeasible
private

whether or not the user-specified initial point was found to be feasible

◆ _initialPointOriginal

std::vector<double> maingo::MAiNGO::_initialPointOriginal
private

vector holding the original initial point

◆ _inMAiNGOsolve

bool maingo::MAiNGO::_inMAiNGOsolve = false
private

flag used in MAiNGO to other language writing denoting whether the function is called from a MAiNGO solve or not

◆ _logger

Logger maingo::MAiNGO::_logger
private

object taking care of printing and saving information to logs

◆ _maingoOriginalSettings

Settings maingo::MAiNGO::_maingoOriginalSettings
private

object storing original settings

◆ _maingoSettings

Settings maingo::MAiNGO::_maingoSettings
private

object storing settings, may change during solution

◆ _maingoStatus

RETCODE maingo::MAiNGO::_maingoStatus
private

flag storing the return status of MAiNGO

◆ _miqpStatus

SUBSOLVER_RETCODE maingo::MAiNGO::_miqpStatus
private

flag indicating whether CPLEX found a problem classified as LP, QP, MIP, or MIQP as infeasible or feasible

◆ _modelOutput

EvaluationContainer maingo::MAiNGO::_modelOutput
private

object holding the actual modelOutput in mc::FFVar, it is needed to not lose information on pointers

◆ _myBaB

std::shared_ptr<bab::BranchAndBound> maingo::MAiNGO::_myBaB
private

pointer to B&B solver

◆ _myFFVARmodel

std::shared_ptr<MAiNGOmodel> maingo::MAiNGO::_myFFVARmodel
private

pointer to a MAiNGOmodel object which will be evaluated with mc::FFVar variables

◆ _myLBS

std::shared_ptr<lbp::LowerBoundingSolver> maingo::MAiNGO::_myLBS
private

pointer to lower bounding solver

◆ _myUBSBab

std::shared_ptr<ubp::UpperBoundingSolver> maingo::MAiNGO::_myUBSBab
private

pointer to upper bounding solver to be used in B&B

◆ _myUBSPre

std::shared_ptr<ubp::UpperBoundingSolver> maingo::MAiNGO::_myUBSPre
private

pointer to upper bounding solver to be used during pre-processing

◆ _nauxiliaryRelOnlyEqs

unsigned maingo::MAiNGO::_nauxiliaryRelOnlyEqs
private

number of relaxation only equalities introduced for auxiliary variables

◆ _nconstantEq

unsigned maingo::MAiNGO::_nconstantEq
private

number of constant equalities

◆ _nconstantEqRelOnly

unsigned maingo::MAiNGO::_nconstantEqRelOnly
private

number of constant relaxation only equalities

◆ _nconstantIneq

unsigned maingo::MAiNGO::_nconstantIneq
private

number of constant inequalities

◆ _nconstantIneqRelOnly

unsigned maingo::MAiNGO::_nconstantIneqRelOnly
private

number of constant relaxation only inequalities

◆ _nconstantIneqSquash

unsigned maingo::MAiNGO::_nconstantIneqSquash
private

number of constant inequalities used when the squash_node function is applied in the model

◆ _nconstantOutputVariables

unsigned maingo::MAiNGO::_nconstantOutputVariables
private

number of constant output variables

◆ _neq

unsigned maingo::MAiNGO::_neq
private

number of non-constant equalities

◆ _neqRelaxationOnly

unsigned maingo::MAiNGO::_neqRelaxationOnly
private

number of non-constant relaxation only equalities

◆ _nineq

unsigned maingo::MAiNGO::_nineq
private

number of non-constant inequalities

◆ _nineqRelaxationOnly

unsigned maingo::MAiNGO::_nineqRelaxationOnly
private

number of non-constant relaxation only inequalities

◆ _nineqSquash

unsigned maingo::MAiNGO::_nineqSquash
private

number of non-constant inequalities used when the squash_node function is applied in the model

◆ _nonconstantConstraints

std::vector<Constraint> maingo::MAiNGO::_nonconstantConstraints
private

vector holding all non-constant constraints. The pointer to this vector is provided to the underlying LBD wrapper to ease work with constraints.

◆ _nonconstantConstraintsUBP

std::vector<Constraint> maingo::MAiNGO::_nonconstantConstraintsUBP
private

vector holding all non-constant constraints for the UBS solver. This vector has only obj, ineq, squash ineq and eq (in this order) and is passed to the UBD wrappers.

◆ _nonconstantOutputs

std::vector<Constraint> maingo::MAiNGO::_nonconstantOutputs
private

vector holding all non-constant outputs

◆ _noutputVariables

unsigned maingo::MAiNGO::_noutputVariables
private

number of non-constant output variables

◆ _nvar

unsigned maingo::MAiNGO::_nvar
private

number of not-removed optimization variables participating in the problem

◆ _nvarLbd

unsigned maingo::MAiNGO::_nvarLbd
private

number of not-removed optimization variables participating in the problem + number of auxiliary variables added

◆ _nvarOriginal

unsigned maingo::MAiNGO::_nvarOriginal
private

number of original user-defined optimization variables

◆ _objectivesAtRoot

std::vector<double> maingo::MAiNGO::_objectivesAtRoot
private

contains the objective values of the new incumbents found at the root node

◆ _originalConstraints

std::vector<Constraint> maingo::MAiNGO::_originalConstraints
private

vector holding all constraint (constant and non-constant) as they were read in by the MAiNGOModel evaluate() function. This is used when printing to other language

◆ _originalVariables

std::vector<OptimizationVariable> maingo::MAiNGO::_originalVariables
private

vector holding the original user-defined optimization variables (initial bounds, variable type, name, branching priority)

◆ _outputNames

std::vector<std::string> maingo::MAiNGO::_outputNames
private

strings for output variables

◆ _outputTime

double maingo::MAiNGO::_outputTime
private

double holding the time in CPU s for final output only

◆ _preprocessTime

double maingo::MAiNGO::_preprocessTime
private

double holding the solution time in CPU s for pre-processing only

◆ _problemStructure

PROBLEM_STRUCTURE maingo::MAiNGO::_problemStructure
private

flag storing the problem structure

◆ _readyToSolve

bool maingo::MAiNGO::_readyToSolve
private

flag storing whether a model has been successfully specified and is ready to solve

◆ _removedVariables

std::vector<bool> maingo::MAiNGO::_removedVariables
private

vector holding the information on which variable has been removed from the problem

◆ _resultVars

std::vector<mc::FFVar> maingo::MAiNGO::_resultVars
private

vector holding evaluated FFVar Objects to not lose pointers

◆ _rootConPropStatus

TIGHTENING_RETCODE maingo::MAiNGO::_rootConPropStatus
private

flag indicating whether constrained propagation at the root node found problem to be infeasible

◆ _rootMultistartStatus

SUBSOLVER_RETCODE maingo::MAiNGO::_rootMultistartStatus
private

flag indicating whether a feasible point was found during multistart at root node

◆ _rootNode

babBase::BabNode maingo::MAiNGO::_rootNode
private

root node of the branch-and-bound problem. Can be modified during pre-processing

◆ _rootObbtStatus

TIGHTENING_RETCODE maingo::MAiNGO::_rootObbtStatus
private

flag indicating whether optimization-based bound tightening at the root node found problem to be infeasible

◆ _solutionPoint

std::vector<double> maingo::MAiNGO::_solutionPoint
private

vector holding the the solution point

◆ _solutionTime

double maingo::MAiNGO::_solutionTime
private

double holding the solution time in CPU s

◆ _solutionTimeWallClock

double maingo::MAiNGO::_solutionTimeWallClock
private

double holding the solution time in wall clock s

◆ _solutionValue

double maingo::MAiNGO::_solutionValue
private

double holding the solution value

◆ _uniqueNames

std::vector<std::string> maingo::MAiNGO::_uniqueNames
private

auxiliary needed for parsing MAiNGO to a different modeling language since in most cases unique variable names are required. It is holding the not removed variables

◆ _uniqueNamesOriginal

std::vector<std::string> maingo::MAiNGO::_uniqueNamesOriginal
private

auxiliary needed for parsing MAiNGO to a different modeling language since in most cases unique variable names are required

◆ _variables

std::vector<OptimizationVariable> maingo::MAiNGO::_variables
private

vector holding the optimization variables participating in the problem (initial bounds, variable type, name, branching priority)

◆ _variablesFeasible

bool maingo::MAiNGO::_variablesFeasible
private

flag indicating whether the variable bounds define a non-empty set

◆ _variablesLbd

std::vector<OptimizationVariable> maingo::MAiNGO::_variablesLbd
private

vector holding the optimization variables participating in the problem and auxiliary variables (initial bounds, variable type, name, branching priority)


The documentation for this class was generated from the following files: