MAiNGOReaderWriter.h

/**********************************************************************************
 * Copyright (c) 2019 Process Systems Engineering (AVT.SVT), RWTH Aachen University
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License 2.0 which is available at
 * http://www.eclipse.org/legal/epl-2.0.
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 **********************************************************************************/

#pragma once

#include <ctime>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>

namespace maingo {

namespace readerWriter {

enum VT {
    VT_CONTINUOUS = 0, 
    VT_BINARY,         
    VT_INTEGER,        
    VT_FIXED           
};

enum CT {
    CT_EQ = 0, 
    CT_GINEQ,  
    CT_LINEQ   
};

struct OptimizationVariable {
    double lowerBound; 
    double upperBound; 
    VT variableType;   
    std::string name;  
};

struct Constraint {
    CT constraintType; 
    std::string lhs;   
    std::string rhs;   
    std::string name;  
};


class MAiNGOReaderWriter {
  public:
    MAiNGOReaderWriter();

    ~MAiNGOReaderWriter(){};

    void read_GAMS_convert_file(const std::string &gamsFileName = "gams.gms");

    void write_MAiNGO_problem_file(const std::string &problemFileName = "problem_gams", const std::string &dictFileName = "dict.txt");

    void write_ALE_problem_file(const std::string &problemFileName = "problem_gams", const std::string &dictFileName = "dict.txt");

    void print_problem_info_GAMS_file(std::ostream &outstream);

    void convert_GAMS_folder_to_MAiNGO_problem(const std::string &input, const std::string &output);

    void convert_GAMS_folder_to_ALE_problem(const std::string &input, const std::string &output);

    void print_problem_info_MAiNGO_log(std::ostream &outstream);

    void read_MAiNGO_log_file(const std::string &maingoFileName = "bab.log");

    unsigned int get_number_variables_GAMS_file();

    unsigned int get_number_cont_variables_GAMS_file();

    unsigned int get_number_bin_variables_GAMS_file();

    unsigned int get_number_int_variables_GAMS_file();

    unsigned int get_number_constraints_GAMS_file();

    unsigned int get_number_eq_constraints_GAMS_file();

    unsigned int get_number_gineq_constraints_GAMS_file();

    unsigned int get_number_lineq_constraints_GAMS_file();

    unsigned int get_number_fixed_variables_GAMS_file();

    unsigned int get_obj_variable_number_GAMS_file();

    std::string get_obj_variable_name_GAMS_file();

    bool get_minimizing_GAMS_file();

    unsigned int get_number_variables_MAiNGO_log();

    unsigned int get_number_equalities_MAiNGO_log();

    unsigned int get_number_inequalities_MAiNGO_log();

    unsigned int get_number_rel_only_eq_MAiNGO_log();

    unsigned int get_number_rel_only_ineq_MAiNGO_log();

    unsigned int get_number_ubd_solved_MAiNGO_log();

    unsigned int get_number_lbd_solved_MAiNGO_log();

    unsigned int get_number_iterations_MAiNGO_log();

    unsigned int get_number_nodes_in_memory_MAiNGO_log();

    unsigned int get_number_best_first_found_MAiNGO_log();

    double get_final_lbd_MAiNGO_log();

    double get_final_abs_gap_MAiNGO_log();

    double get_final_rel_gap_MAiNGO_log();

    double get_final_obj_val_MAiNGO_log();

    double get_cpu_time_needed_MAiNGO_log();

    double get_wall_time_needed_MAiNGO_log();

    bool get_feasibility_MAiNGO_log();

    std::vector<std::pair<std::string, double>> get_solution_point();

    std::vector<std::pair<std::string, double>> get_additional_output();

  private:
    void _read_problem_info();

    void _read_variable_bounds();

    void _read_initial_point();

    void _read_constraints();

    unsigned int _find_variable(const std::string &varName);

    void _set_variable_lower_bound(const std::string &varName, const double lowerBound);

    void _set_variable_upper_bound(const std::string &varName, const double upperBound);

    void _set_variable_initial_point(const std::string &varName, const double value);

    void _rename_powers(std::vector<Constraint> &constraints);

    void _rename_double_asterisk(std::string &str);

    void _rename_logs(std::vector<Constraint> &constraints);

    void _add_division_log10(std::string &str, const std::size_t posLog);

    void _remove_chars_from_string(std::string &str, const char *charsToRemove);

    void _replace_all_variables_in_constraint(std::string &constraint, const std::string &varName, const std::string &newName);

    void _rename_variables_and_constraints();

    void _write_MAiNGO_model(std::ofstream &outputFile, const std::string &problemName);

    void _write_MAiNGO_variables(std::ofstream &outputFile);

    void _write_MAiNGO_initial_point(std::ofstream &outputFile);

    void _write_MAiNGO_constructor(std::ofstream &outputFile);

    std::string _insert_line_breaks_in_string(const std::string &str, const size_t numberWhitespaces);

    void _write_MAiNGO_evaluate(std::ofstream &outputFile);

    void _write_ALE_variables(std::ofstream &outputFile);

    void _write_ALE_initial_point(std::ofstream &outputFile);

    void _write_ALE_functions(std::ofstream &outputFile);

    void _check_for_MAiNGO();

    void _remove_bab();

    void _check_feasibility();

    void _read_statistics();

    std::string _gamsFileName;      
    std::vector<std::string> _file; 
    std::vector<std::string> _dict; 
    unsigned int _nvar;     
    unsigned int _ncontVar; 
    unsigned int _nbinVar;  
    unsigned int _nintVar;  
    unsigned int _ncons;  
    unsigned int _neq;    
    unsigned int _nlineq; 
    unsigned int _ngineq; 
    unsigned int _nfixedVar;  
    unsigned int _objNr;      
    std::string _objName;     
    std::string _objFunction; 
    bool _objSingle;          
    bool _minimizing;         
    std::vector<OptimizationVariable> _contVariables; 
    std::vector<OptimizationVariable> _binVariables;  
    std::vector<OptimizationVariable> _intVariables;  
    std::vector<Constraint> _constraints;             
    std::vector<Constraint> _eqConstraints;           
    std::vector<Constraint> _gineqConstraints;        
    std::vector<Constraint> _lineqConstraints;        
    std::vector<double> _initialPointCont;            
    std::vector<unsigned int> _initialPointBin;       
    std::vector<int> _initialPointInt;                
    std::string _maingoFileName; 
    unsigned int _nvarM;                
    unsigned int _neqM;                 
    unsigned int _nineqM;               
    unsigned int _neqRelaxationOnlyM;   
    unsigned int _nineqRelaxationOnlyM; 
    unsigned int _ubdProblemsSolvedM; 
    unsigned int _lbdProblemsSolvedM; 
    unsigned int _niterationsM;       
    unsigned int _nnodesInMemoryM;    
    unsigned int _bestSolFirstFoundM; 
    double _finalLBDM;                                             
    double _finalAbsGapM;                                          
    double _finalRelGapM;                                          
    double _objValM;                                               
    double _cpuTimeNeededM;                                        
    double _wallTimeNeededM;                                       
    bool _feasibleM;                                               
    std::vector<std::pair<std::string, double>> _solutionPoint;    
    std::vector<std::pair<std::string, double>> _additionalOutput; 
    // Prevent use of default copy constructor and copy assignment operator by declaring them private:
    MAiNGOReaderWriter(const MAiNGOReaderWriter &);            
    MAiNGOReaderWriter &operator=(const MAiNGOReaderWriter &); 
};

}    // namespace readerWriter

}    // namespace maingo