dualqqp.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 DUALQQP_H
#define DUALQQP_H

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

class DualFunc: public Func {
   public:
      MinlpProblem &qqp;

      vector<double> dual_bounds;

      Param &param;

      DualFunc(MinlpProblem &qqp_, Param &param_, Pointer<ostream> out_func_p_=out_out_p, Pointer<ostream> out_func_log_p_=out_log_p)
      : Func(0, out_func_p_, out_func_log_p_), qqp(qqp_), param(param_)
      { }

      int primal_dim() const { return qqp.dim(); };

      virtual dvector get_dual_point() const=0;

      virtual double get_dual_val() const=0;

      virtual dvector get_orig_point(int i=0) const=0;

      virtual int nr_of_orig_points() const { return 1; }

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

class QqpMatrix;
class QqpExtMatrix;

class QqpDualFunc: public DualFunc {
    friend class QqpMatrix;
    friend class QqpExtMatrix;

                protected:
                        typedef enum { LIN, QUAD, EXTQUAD } b_type;

      vector<b_type> block_type;

      ivector i_ext;

      int num_ext;

      ivector i_q;

      int n_q;

      dvector mid_point;

      BlockMatrix W;

      dvector radius;

      vector<bool> ball_con;

//      vector<bool> diag_scale;

      vector<dvector> b_con;

      dvector b_obj;

      dvector c_con;

      double c_obj;

      vector<Pointer<UserMatrix> > A_lag;

      mutable vector<dvector> b_lag;

      mutable double c_lag;

      mutable dvector x_lag;

      mutable double dual_val;

      mutable dvector subgrad;

      mutable vector<vector<double> > eig_val;

      mutable vector<vector<dvector> > eig_vec;

      int num_qbox() const { return n_q+num_ext; }

      int num_blocks() const { return qqp.block.size(); };

      void init_ext();

      void init();

      void set_ball_con();

      void get_bc(double &c_,dvector &b_,SepQcFunc &q);

      void set_bc();

      int set_dual_val() const;

      double eval_mod_con(int con_nr) const;

      double eval_mod_obj() const;

      void set_subgrad() const;

    public:
      int num_matmult;
      mutable double eig_time;

      mutable dvector dual_point;

      QqpDualFunc(MinlpProblem &qqp_, Param &param_, Pointer<ostream> out_func_p_=out_out_p, Pointer<ostream> out_func_log_p_=out_log_p)
      : DualFunc(qqp_, param_, out_func_p_, out_func_log_p_), num_matmult(0), eig_time(0),
        eig_vec(qqp_.block.size()), eig_val(qqp_.block.size()),
        radius(qqp_.block.size()), ball_con(qqp_.block.size()),
        block_type(qqp_.block.size()), i_ext(qqp_.block.size()), i_q(qqp_.block.size()),
        c_con(qqp_.con.size()), b_obj(qqp_.dim()), b_con(qqp_.con.size()),
        A_lag(qqp.block.size()), b_lag(qqp.block.size()),
        mid_point(qqp_.dim()), W(qqp_.block)
      { init();
      };

      virtual int valgrad(double& val, UserVector<double>& g, const UserVector<double>& z) const;

                        using DualFunc::valgrad;

      double eval(const UserVector<double>& z) const {
        assert(z.dim() == dim());
                          dual_point=z;
                          set_dual_val();
                          return dual_val;
                        }

                        using DualFunc::eval;
/*
      double eval(const UserVector<double>& z) const {
        dvector z0(z);
        return eval(z0);
      }
*/
/*      void grad(dvector& g, const dvector& x) const {
        double val;
        valgrad(val, g, x);
      }
*/
      void grad(UserVector<double>& g, const UserVector<double>& x) const {
                                double val;
                                valgrad(val, g, x);
      }
                        
                        using Func::grad;

//      virtual void HessMult(dvector &y, const dvector &x, const dvector &z) const { };

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

//      void set_qbox_dual_point(dvector &x,dvector &g);

      dvector get_dual_point() const;

      dvector get_dual_point(dvector& ext_dual_point) const {
        if (!(ext_dual_point==dual_point)) eval(ext_dual_point);
        return get_dual_point();
      }

      double get_dual_val() const { return dual_val; }

      double get_dual_val(dvector& ext_dual_point) const {
        if (!(ext_dual_point==dual_point)) eval(ext_dual_point);
        return get_dual_val();
                        }

      dvector get_orig_point(int use_eig_vec=0) const;

      dvector get_orig_point(dvector& ext_dual_point, int use_eig_vec=0) const {
        if (!(ext_dual_point==dual_point)) eval(ext_dual_point);
        return get_orig_point(use_eig_vec);
      }

      int nr_of_orig_points() const { return eig_vec[0].size(); }

      void print(ostream &out) const;
};

/*
class QqpDualFunc2: public QqpDualFunc {
   public:
/*      QqpDualFunc2(MinlpReform &qqp_,Param &param_, Pointer<ostream> out_func_p_=out_out_p, Pointer<ostream> out_func_log_p_=out_log_p, Pointer<ostream> out_dualval_p_=NULL)
      : QqpDualFunc(qqp_,param_, out_func_p_, out_func_log_p_, out_dualval_p_)
      {  };

/*      int dim() const {
        return QqpDualFunc::dim()-primal_dim();
      };

/*      int valgrad(double &val,dvector &g,const dvector &z);
};
*/
// reduced dual function
/*
class QqpDualFunc3: public QqpDualFunc
   {
   int dual_dim; // dimension of the full dual space

   vector<int> i_dual; // indice of actual dual variables
   dvector red_dual_bounds; // lower bounds of the reduced dual func.
   bool full_dual_space; // true if the full dual space is used
   void set_full_dual_space()
   {  full_dual_space=true;dim_=dual_dim;  };
   void set_reduced_dual_space(vector<int> &iv)
   {  i_dual=iv; dim_=iv.size(); full_dual_space=false;
   red_dual_bounds.resize(dim());
   for(int i=0;i<dim();i++)
   red_dual_bounds[i]=qqp.dual_bounds[i_dual[i]];  };
   void valgrad(double &val,dvector &g,dvector &z);
   };
*/

class QqpMatrix: public UserMatrix {
   protected:
      int b_num;
   public:
      QqpDualFunc &d;

      // methods
      QqpMatrix(QqpDualFunc &d_,int b_num_)
      : UserMatrix(d_.qqp.block[b_num_].size()), d(d_), b_num(b_num_)
      { };

      void MultV(dvector &y,const dvector &x) const;

      void MultV(UserVector<double>& y, const UserVector<double>& x) const {
        dvector x0(x);
        dvector y0(y.size());
        MultV(y0,x0);
        y=y0;
      }
                        
                        using UserMatrix::MultV;
};

class QqpExtMatrix : public UserMatrix {
   protected:
      int b_num;
   public:
      QqpDualFunc &d;

      QqpExtMatrix(QqpDualFunc &d_,int b_num_)
      : UserMatrix(d_.qqp.block[b_num_].size()+1), d(d_), b_num(b_num_)
      { };

      void MultV(dvector &y, const dvector &x) const;

      void MultV(UserVector<double>& y, const UserVector<double>& x) const {
        dvector x0(x);
        dvector y0(y.size());
        MultV(y0,x0);
        y=y0;
      }
                        
                        using UserMatrix::MultV;
};

#endif // DUALQQP_H

---