problem.h

Go to the documentation of this file.

// Copyright (C) 2006 Ivo Nowak and Stefan Vigerske
// All Rights Reserved.
// This code is published under the Common Public License.
//
// Author: Ivo Nowak, Stefan Vigerske

#ifndef PROBLEM_H
#define PROBLEM_H

#include "standard.h"
#include "usermatrix.h"
#include "func.h"

class MinlpProblem {
   friend ostream& operator << (ostream &out, const MinlpProblem& a) {
     a.print(out); return out;
   };

   double compute_scale(char* option, int c, double eps, UserVector<double>& x);

   protected:
      int dim_;

   public:
      Pointer<ostream> out_problem_p;
      Pointer<ostream> out_problem_log_p;
#define out_problem if (out_problem_p) (*out_problem_p)

#define out_problem_log if (out_problem_log_p) (*out_problem_log_p)

                        typedef enum { QQP, MINLP } ptype;

      ptype problem_type;

      Pointer<char> prob_name;

      vector<ivector> block;

      vector<Pointer<char> > var_names;

      // definition of the optimization problem
      Pointer<SepQcFunc> obj;

      vector<Pointer<SepQcFunc> > con;

      vector<Pointer<char> > con_names;

      vector<bool> con_eq;

      vector<int> i_discr;

      vector<int> i_cont;

      vector<bool> discr;

      dvector lower;

      dvector upper;

      dvector primal_point;

      MinlpProblem(ptype p_type=MINLP, char* prob_name_=(char*)NULL, Pointer<ostream> out_problem_p_=out_out_p, Pointer<ostream> out_problem_log_p_=out_log_p)
      : problem_type(p_type), prob_name(prob_name_ ? strdup(prob_name_) : NULL), dim_(0), out_problem_p(out_problem_p_), out_problem_log_p(out_problem_log_p_)
      { };

      MinlpProblem(Pointer<SepQcFunc> obj_, const dvector &lower_, const dvector &upper_, bool discr_=false, Pointer<ostream> out_problem_p_=out_out_p, Pointer<ostream> out_problem_log_p_=out_log_p)
      : dim_(obj_->dim()), prob_name(0), problem_type(MINLP), out_problem_p(out_problem_p_), out_problem_log_p(out_problem_log_p_), block(obj_->block), discr(obj_->dim(), discr_), lower(lower_), upper(upper_), var_names(obj_->dim()), primal_point(obj_->dim())
      { if (discr_) for (int i=0; i<dim(); i++) i_discr.push_back(i);
                                else for (int i=0; i<dim(); i++) i_cont.push_back(i);
        add_obj(obj_);
      }

      MinlpProblem(const MinlpProblem &p)
      : dim_(p.dim()), block(p.block), var_names(p.var_names),
        obj(p.obj), con(p.con), con_names(p.con_names), con_eq(p.con_eq),
        i_discr(p.i_discr),i_cont(p.i_cont), discr(p.discr),
        lower(p.lower), upper(p.upper), primal_point(p.primal_point),
        problem_type(p.problem_type), prob_name(p.prob_name),
        out_problem_p(p.out_problem_p), out_problem_log_p(p.out_problem_log_p)
      { }

                        MinlpProblem(const MinlpProblem& p, int k);

      virtual ~MinlpProblem() { }

      int dim() const { return dim_; };

      virtual void add_var(int i_, int bnum, bool discr_, double lower_, double upper_, char* name=NULL);

      virtual void add_con(Pointer<SepQcFunc> f, bool eq=true, char* name=NULL);

      virtual void del_con(int connr);

      virtual void add_obj(Pointer<SepQcFunc> f) { obj=f; };

      void taylor_approx(UserVector<double>& point, const int degree=2);

      int feasible(const UserVector<double>& x, double tol, ostream* out=NULL);
      
      void print_most_violated_constraints(const UserVector<double>& x, ostream& out, int nr=5, double tol=1E-4);

      int scale(Pointer<Param> param=NULL) { return scale(primal_point, param); }

      int scale(UserVector<double>& x, Pointer<Param> param=NULL);

                        void get_sparsity(vector<Pointer<SparsityInfo> >& si) const;
                        Pointer<SparsityInfo> get_sparsity(int k) const;

      virtual void print(ostream& out) const;

                        void print_as_gams(ostream& out) const;
};


class MinlpPenaltyFunc: public Func {
  private:
    Pointer<MinlpProblem> minlp;

  public:
    dvector delta;

    MinlpPenaltyFunc(Pointer<MinlpProblem> minlp_, Pointer<Param> penalty_param=NULL)
    : Func(minlp_->dim()), minlp(minlp_), delta(minlp_->con.size(), 1000.)
    { if (penalty_param) {
                penalty_param->read();
              for (int i=0; i<minlp->con.size(); i++)
              delta[i]=penalty_param->get_d(minlp->con_names[i], 1000.);
      }
    }

    double eval(const UserVector<double>& x) const;
                using Func::eval;

    int valgrad(double& val, UserVector<double>& y, const UserVector<double>& x) const;
                using Func::valgrad;

    void grad(UserVector<double>& y, const UserVector<double>& x) const;
                using Func::grad;

    void HessMult(UserVector<double>& y, const UserVector<double>& z, const UserVector<double>& x) const;
                using Func::HessMult;

                virtual void set_curvature(CurvatureType ct) { out_err << "MinlpPenaltyFunc::set_curvature() not implemented. Aborting." << endl; exit (-1); };
                virtual CurvatureType get_curvature() const  { out_err << "MinlpPenaltyFunc::get_curvature() not implemented. Aborting." << endl; exit (-1); return Func::UNKNOWN; };

    void print(ostream& out) const {
      out << "MinlpPenaltyFunc: dim=" << dim() << endl;
      out << "delta-vector: " << delta;
    }

};


class MipProblem {
        public:
                typedef enum { CONTINUOUS, BINARY, INTEGER } VarType;

                friend ostream& operator<<(ostream& out, const VarType& type) {
                        switch (type) {
                                case CONTINUOUS: out << "Continuous"; break;
                                case BINARY: out << "Binary"; break;
                                case INTEGER: out << "Integer"; break;
                                default: out << "Unknown !!";
                        }
                        return out;
                }
                friend ostream& operator<<(ostream& out, const MipProblem& mip);

        private:
                int nr_col, nr_row;

        // Variables
                dvector col_lower, col_upper;
                vector<Pointer<char> > col_names;
                vector<VarType> col_types;

        // Objective function
                Pointer<UserVector<double> > obj;
                double obj_const;

        // Constraints
                SparseMatrix A;
                dvector row_lower, row_upper;
                vector<Pointer<char> > row_names;

        public:
                MipProblem(int nr_col=0, int nr_row=0);

                MipProblem(const dvector& lower, const dvector& upper, const vector<int>& i_discr=vector<int>(0), const vector<Pointer<char> >& names=vector<Pointer<char> >(0));

                MipProblem(const MinlpProblem& minlp);

                void reset();

                int dim() const { return nr_col; }
                int rows() const { return nr_row; }

                const SparseMatrix& getMatrix() const { return A; }
                const dvector& getRowLower() const { return row_lower; }
                const dvector& getRowUpper() const { return row_upper; }
                const dvector& getColLower() const { return col_lower; }
                const dvector& getColUpper() const { return col_upper; }
                const VarType& getColType(int i) const { assert(i<dim() && i>=0); return col_types[i]; }
                const UserVector<double>& getObj() const { assert(obj); return *obj; }
                double getObjConst() const { return obj_const; }

                void setColBounds(int index, double low, double up);
                void setColType(int index, VarType type);
                void setColName(int index, Pointer<char> name);
                void setCol(int index, double low, double up, VarType type=CONTINUOUS, Pointer<char> name=NULL);

                void setObj(Pointer<UserVector<double> > obj_, double obj_const_=0.);

                void setRow(int index, const UserVector<double>& row, double low, double up, Pointer<char> name=NULL);
                void setRow(int index, const UserVector<double>& row, const ivector& indices, double low, double up, Pointer<char> name=NULL);
                void setRowBounds(int index, double low, double up);

                void resize_col(int nr_col_);
                void resize_row(int nr_row_);

                void finish();
};

#endif // PROBLEM_H

---