TMINLP2TNLP.hpp

Go to the documentation of this file.
00001 // (C) Copyright International Business Machines Corporation and Carnegie Mellon University 2004
00002 // All Rights Reserved.
00003 // This code is published under the Common Public License.
00004 //
00005 // Authors :
00006 // Pierre Bonami, Carnegie Mellon University,
00007 // Carl D. Laird, Carnegie Mellon University,
00008 // Andreas Waechter, International Business Machines Corporation
00009 //
00010 // Date : 12/01/2004
00011 
00012 #ifndef __TMINLP2TNLP_HPP__
00013 #define __TMINLP2TNLP_HPP__
00014 
00015 #include "IpTNLP.hpp"
00016 #include "TMINLP.hpp"
00017 #include "IpSmartPtr.hpp"
00018 #include "IpIpoptApplication.hpp"
00019 #include "IpOptionsList.hpp"
00020 #include "IpoptInteriorWarmStarter.hpp"
00021 
00022 namespace Ipopt
00023 {
00030   class TMINLP2TNLP : public TNLP
00031   {
00032   public:
00035     TMINLP2TNLP(const SmartPtr<TMINLP> tminlp,
00036         const OptionsList& options);
00037 
00039     virtual ~TMINLP2TNLP();
00041 
00048     void copyUserModification(TMINLP2TNLP& other);
00049 
00050 
00051     DECLARE_STD_EXCEPTION(TMINLP_INVALID_VARIABLE_BOUNDS);
00052 
00055 
00057     Index num_variables()
00058     {
00059       return n_;
00060     }
00061 
00063     Index num_constraints()
00064     {
00065       return m_;
00066     }
00068     Index nnz_h_lag()
00069     {
00070       return nnz_h_lag_;
00071     }
00073     const TMINLP::VariableType* var_types()
00074     {
00075       return var_types_;
00076     }
00077 
00078     //Print variable types to screen
00079     void printVarTypes()
00080     {
00081       //       for (int i = 0 ; i < n_ ; i++)
00082       //        {
00083       //          std::cout<<i<<"\t"<<var_types_[i]<<std::endl;
00084       //        }
00085     }
00086 
00088     const Number* x_l()
00089     {
00090       return x_l_;
00091     }
00093     const Number* x_u()
00094     {
00095       return x_u_;
00096     }
00097 
00099     const Number* orig_x_l() const
00100     {
00101       return orig_x_l_;
00102     }
00104     const Number* orig_x_u() const
00105     {
00106       return orig_x_u_;
00107     }
00108 
00110     const Number* g_l()
00111     {
00112       return g_l_;
00113     }
00115     const Number* g_u()
00116     {
00117       return g_u_;
00118     }
00119 
00121     const Number * x_init() const
00122     {
00123       return x_init_;
00124     }
00125 
00127     const Number * duals_init() const
00128     {
00129       return duals_init_;
00130     }
00131 
00133     const Number* x_sol() const
00134     {
00135       return x_sol_;
00136     }
00137 
00139     const Number* g_sol() const
00140     {
00141       return g_sol_;
00142     }
00143 
00145     const Number* duals_sol() const
00146     {
00147       return duals_sol_;
00148     }
00149 
00151     SolverReturn optimization_status()
00152     {
00153       return return_status_;
00154     }
00155 
00157     Number obj_value()
00158     {
00159       return obj_value_;
00160     }
00161 
00163     void set_obj_value(Number value)
00164     {
00165       obj_value_ = value;
00166     }
00167 
00169     void force_fractionnal_sol();
00170 
00172     void SetVariableBounds(Index var_no, Number x_l, Number x_u);
00173 
00175     void SetVariableLowerBound(Index var_no, Number x_l);
00176 
00178     void SetVariableUpperBound(Index var_no, Number x_u);
00179 
00181     void SetStartingPoint(Index n, const Number* x_init);
00182 
00184     void resetStartingPoint();
00185 
00187     void setxInit(Index ind,const Number val);
00188 
00190     void setxInit(Index n,const Number* x_init);
00191 
00193     void setDualInit(Index ind, const Number val);
00194 
00196     void setDualsInit(Index n, const Number* duals_init);
00197 
00198 
00200     void Set_x_sol(Index n, const Number* x_sol);
00201 
00203     void SetVariableType(Index n, TMINLP::VariableType type);
00205 
00209     void outputDiffs(const std::string& probName, const std::string* varNames);
00210 
00214     virtual bool get_nlp_info(Index& n, Index& m, Index& nnz_jac_g,
00215         Index& nnz_h_lag,
00216         TNLP::IndexStyleEnum& index_style);
00217 
00221     virtual bool get_bounds_info(Index n, Number* x_l, Number* x_u,
00222         Index m, Number* g_l, Number* g_u);
00223 
00231     virtual bool get_starting_point(Index n, bool init_x, Number* x,
00232         bool init_z, Number* z_L, Number* z_U,
00233         Index m, bool init_lambda,
00234         Number* lambda);
00235 
00238     virtual bool get_warm_start_iterate(IteratesVector& warm_start_iterate);
00239 
00241     virtual bool eval_f(Index n, const Number* x, bool new_x,
00242         Number& obj_value);
00243 
00246     virtual bool eval_grad_f(Index n, const Number* x, bool new_x,
00247         Number* grad_f);
00248 
00250     virtual bool eval_g(Index n, const Number* x, bool new_x,
00251         Index m, Number* g);
00252 
00258     virtual bool eval_jac_g(Index n, const Number* x, bool new_x,
00259         Index m, Index nele_jac, Index* iRow,
00260         Index *jCol, Number* values);
00261 
00269     virtual bool eval_h(Index n, const Number* x, bool new_x,
00270         Number obj_factor, Index m, const Number* lambda,
00271         bool new_lambda, Index nele_hess,
00272         Index* iRow, Index* jCol, Number* values);
00274 
00278     virtual void finalize_solution(SolverReturn status,
00279         Index n, const Number* x, const Number* z_L, const Number* z_U,
00280         Index m, const Number* g, const Number* lambda,
00281         Number obj_value);
00285     virtual bool intermediate_callback(AlgorithmMode mode,
00286         Index iter, Number obj_value,
00287         Number inf_pr, Number inf_du,
00288         Number mu, Number d_norm,
00289         Number regularization_size,
00290         Number alpha_du, Number alpha_pr,
00291         Index ls_trials,
00292         const IpoptData* ip_data,
00293         IpoptCalculatedQuantities* ip_cq);
00295 
00298     bool checkZeroDimension(ApplicationReturnStatus& optimization_status);
00299 
00302     void SetWarmStarter(SmartPtr<IpoptInteriorWarmStarter> warm_starter)
00303     {
00304       curr_warm_starter_ = warm_starter;
00305     }
00306     SmartPtr<IpoptInteriorWarmStarter> GetWarmStarter()
00307     {
00308       return curr_warm_starter_;
00309     }
00311   protected:
00321     TMINLP2TNLP();
00322 
00324     TMINLP2TNLP(const TMINLP2TNLP&);
00325 
00327     void operator=(const TMINLP2TNLP&);
00329 
00331     SmartPtr<TMINLP> tminlp_;
00332 
00335 
00336     Index n_;
00338     Index m_;
00340     Index nnz_h_lag_;
00342     TNLP::IndexStyleEnum index_style_;
00344     TMINLP::VariableType* var_types_;
00346     Number* x_l_;
00348     Number* x_u_;
00350     Number* orig_x_l_;
00352     Number* orig_x_u_;
00354     Number* g_l_; // These are not modified, but a copy is kept for consistency
00356     Number* g_u_;
00358     Number* x_init_;
00360     Number * duals_init_;
00362     Number* x_init_user_;
00364     Number* x_sol_;
00366     Number * g_sol_;
00368     Number* duals_sol_;
00369 
00371     SolverReturn return_status_;
00373     Number obj_value_;
00375 
00379     SmartPtr<IpoptInteriorWarmStarter> curr_warm_starter_;
00381     Number nlp_lower_bound_inf_;
00383     Number nlp_upper_bound_inf_;
00387     bool warm_start_entire_iterate_;
00389     bool need_new_warm_starter_;
00391 
00392 
00395     void throw_exception_on_bad_variable_bound(Index i);
00396 
00397   };
00398 
00399 } // namespace Ipopt
00400 
00401 #endif

Generated on Fri May 16 21:06:02 2008 for Bonmin by  doxygen 1.4.7