gams.h

Go to the documentation of this file.
00001 // Copyright (C) 2006 Ivo Nowak and Stefan Vigerske
00002 // All Rights Reserved.
00003 // This code is published under the Common Public License.
00004 //
00005 // Author: Stefan Vigerske
00006 
00007 #ifndef GAMS_H
00008 #define GAMS_H
00009 
00010 #include "standard.h"
00011 #ifdef COIN_HAS_GAMSIO
00012 #define GDX_AVAILABLE
00013 
00014 #include "param.h"
00015 #include "problem.h"
00016 #include "opt.h"
00017 #include "preprocessapi.h"
00018 
00019 class gamsLocOpt;
00020 class SolCandidate;
00021 
00022 extern "C" struct dictRec;
00023 extern "C" struct gdxRec;
00024 
00027 class gams {
00028         friend class gamsLocOpt;
00029         friend class gamsFunc;
00030 
00031         private:
00032                 Pointer<Param> param;
00033 
00034                 // original types of constraints
00035                 ivector con_type;
00036 
00037                 dvector rhs;
00038                 dvector lower, upper;
00039                 bool is_minimization;
00040                 double obj_sign;
00041                 int objcon, objvar;
00042                 Pointer<char> objcon_name;
00043 
00044                 bool reformed;
00045 
00048                 multimap<double, Pointer<char> > written_gdx;
00049                 int written_gdx_limit;
00050 
00058                 char* getRowName (int i, char *name, int bufLen);
00059                 
00067                 char* getColName (int j, char *name, int bufLen);
00068 #ifdef GDX_AVAILABLE
00069                 struct gdxRec* gdxhandle;
00070                 
00071                 void gdx_error(int n);
00072 #endif
00073         public:
00074                 static void init_cplex_licence(int connr=0, int varnr=0, int nnz=0, int nlnz=0, int ndisc=0);
00075                 
00076                 void init_snopt_licence();
00077 
00078                 struct dictRec* dict;
00079 
00080                 gams(Pointer<Param> param_=NULL);
00081 
00082                 ~gams();
00083 
00084                 Pointer<MinlpProblem> get_problem(char* gamsfile);
00085 
00086                 void write_sol_file(const dvector& sol_point, int model_status, int solver_status, int iter, double time, Pointer<MinlpProblem> prob, double objest = -INFINITY);
00087                 void write_sol_set(const set<SolCandidate>& sol_set);
00088 
00089                 void write_matlab(const dvector& x, const char* filename, vector<Pointer<char> >& var_names);
00090 
00091                 void write_gams(const dvector& x, const char* filename, const vector<bool>& discr);
00092 #ifdef GDX_AVAILABLE
00093 
00095                 void write_gdx(const dvector& x, char* filename, double val);
00096                 void write_gdx(const dvector& x, char* filename);
00097                 void read_gdx(dvector& x, char* filename);
00098 #endif
00099 
00100                 void write_box(const dvector& lower, const dvector& upper);
00101 };
00102 
00103 // points to gams-interface; needed for gamsLocOpt
00104 extern gams* gamsptr;
00105 
00106 class gamsNLData {
00107 public: 
00109         unsigned int* instr;
00110         double* nlCons;
00111         int* startIdx;
00112         int* numInstr;
00113         
00115         int lenins;
00117         int maxins;
00118         
00120         double* s;
00121         double* sbar;
00122         double* resstack;
00123         int resstacksize;
00124                 
00125         int* jacNX;
00126         int* jacVR;
00127         double* jacVL;
00128         int* hesLagCL;
00129         int* hesLagRW;
00130         int* hesLagNX;
00131         double* hesLagVL;
00132         
00133         int jacOneLenMax;
00134         int hesLagHeadPtr;
00135         int hesOneLenMax;
00136         int hesLagLenMax;
00137         
00140         int domain_violations;
00141         
00142         gamsNLData()
00143         : instr(NULL), nlCons(NULL), startIdx(NULL), numInstr(NULL),
00144                 lenins(1), maxins(1), resstacksize(1),
00145                 s(NULL), sbar(NULL),
00146                 jacNX(NULL), jacVR(NULL), jacVL(NULL),
00147                 hesLagCL(NULL), hesLagRW(NULL), hesLagNX(NULL), hesLagVL(NULL),
00148                 jacOneLenMax(-1),
00149                 hesLagHeadPtr(-1), hesOneLenMax(-1), hesLagLenMax(-1),
00150                 domain_violations(0)
00151         { }
00152         
00153         ~gamsNLData() {
00154                 if (instr) delete[] instr;
00155                 if (nlCons) delete[] nlCons;
00156                 if (startIdx) delete[] startIdx;
00157                 if (numInstr) delete[] numInstr;
00158                 if (s) delete[] s;
00159                 if (sbar) delete[] sbar;
00160                 if (resstack) delete[] resstack;
00161                 if (jacNX) delete jacNX;
00162                 if (jacVR) delete jacVR;
00163                 if (jacVL) delete jacVL;
00164                 if (hesLagCL) delete hesLagCL;
00165                 if (hesLagRW) delete hesLagRW;
00166                 if (hesLagNX) delete hesLagNX;
00167                 if (hesLagVL) delete hesLagVL;
00168         }
00169 
00170 };
00171         
00172 class gamsFunc : public Func {
00173         private:
00174                 Pointer<gamsNLData> data;
00175         
00176                 int connr;
00177 
00178                 Func::CurvatureType curv_type;
00179 
00180         public:
00181                 gamsFunc(int n, int connr_, Pointer<gamsNLData> data_, Pointer<SparsityInfo> sparsity_=NULL)
00182                 : Func(n), connr(connr_), data(data_), curv_type(Func::UNKNOWN)
00183                 { sparsity=sparsity_; }
00184                 
00185                 double eval(const UserVector<double>& x) const {
00186                         return eval((Pointer<double>)x);
00187                 }
00188                 
00189                 double eval(const double* x) const;
00190                 
00191                 int valgrad(double& val, UserVector<double>& g, const UserVector<double>& x) const {
00192                         dvector g0(g.dim());
00193                         int ret=valgrad(val, (Pointer<double>)g0, (Pointer<double>)x);
00194                         g=g0;
00195                         return ret;
00196                 }
00197 
00198                 int valgrad(double& val, double* g, const double* x) const;
00199 
00200                 void grad(UserVector<double>& g, const UserVector<double>& x) const {
00201                         dvector g0(g.dim());
00202                         double val;
00203                         valgrad(val, (Pointer<double>)g0, (Pointer<double>)x);
00204                         g=g0;
00205                 }
00206 
00207                 void grad(dvector& g, const dvector& x) const {
00208                         double val;
00209                         valgrad(val, (Pointer<double>)g, (Pointer<double>)x);
00210                 }
00211 
00212                 void grad(double* g, const double* x) const {
00213                         double val;
00214                         valgrad(val, g, x);
00215                 }
00216                 using Func::grad;
00217 
00218                 void HessMult(UserVector<double>& y, const UserVector<double>& x, const UserVector<double>& z) const {
00219                         dvector y0(y.dim());
00220                         HessMult((Pointer<double>)y0, (Pointer<double>)x, (Pointer<double>)z);
00221                         y=y0;
00222                 }
00223                 
00224                 void HessMult(dvector& y, const dvector& x, const dvector& z) const {
00225                         HessMult((Pointer<double>)y, (Pointer<double>)x, (Pointer<double>)z);
00226                 }
00227                 
00228                 void HessMult(double* y, const double* x, const double* z) const;
00229                 using Func::HessMult;
00230 
00231 #ifdef FILIB_AVAILABLE
00232                 bool is_interval_compliant() const { return true; } // :-)
00233 
00234                 interval<double> eval(const IntervalVector& x) const;
00235 
00236                 int valgrad(interval<double>& val, IntervalVector& y, const IntervalVector& x) const;
00237 #endif
00238 
00239                 void set_curvature(CurvatureType ct) { curv_type=ct; };
00240                 CurvatureType get_curvature() const { return curv_type; };
00241 
00242                 void print(ostream& out) const {
00243                         out << "GamsFunc " << connr << endl;
00244                 }
00245 };
00246 
00277 class gamsLocOpt : public LocOpt {
00278         friend class gams;
00279         private:
00280                 Pointer<Param> param;
00281                 Pointer<MinlpProblem> prob;
00282                 bool second_run;
00283 
00284                 dvector lower_discr;
00285                 dvector upper_discr;
00286                 dvector lower;
00287                 dvector upper;
00288 
00289                 dvector con_val;
00290                 dvector duals_con;
00291                 dvector duals_var;
00292                 ivector basind_con;
00293                 ivector basind_var;
00294 
00295                 int model_status, solver_status;
00296 
00297                 int recent_calls;
00298                 Pointer<char> tmpsolfn; // temporary space to store solutionfilename
00299                 char** args; // arguments for subsolver-call
00300 
00301                 int optfile;
00302                 int subsolver;
00303                 Pointer<char> solvername;
00304                 void* iolibsave;
00305 
00308                 char** preprocessargs;
00309                 bool preprocess_keepgdx;
00310 
00311                 bool write_solcand;
00312                 bool write_startpoint;
00313 
00316                 double rd;
00317 
00321                 int do_preprocessing(const dvector& start);
00322 
00323                 static void* preprocess_handle;
00324 
00325                 LocOptPreprocessing* preprocessing;
00326 
00327         public:
00328                 gamsLocOpt(Pointer<MinlpProblem> prob_, Pointer<Param> param_, Pointer<ostream> out_solver_p_=out_out_p, Pointer<ostream> out_solver_log_p_=out_log_p);
00329         
00330           ~gamsLocOpt();
00331         
00332                 int solve() { return solve(prob->primal_point); }
00333         
00334                 int solve(dvector& start);
00335         
00336                 dvector get_lag_multipliers();
00337 };
00338 
00339 #endif // COIN_HAS_GAMSIO
00340 #endif

Generated on Mon Oct 20 03:12:05 2008 for LaGO by  doxygen 1.4.7