Modification.hxx

Go to the documentation of this file.

#ifndef CONICBUNDLE_MODIFICATION_HXX
#define CONICBUNDLE_MODIFICATION_HXX


#include <map>
#include "ModificationBase.hxx"
#include "CBSolver.hxx"
#include "sparsmat.hxx"

namespace ConicBundle {


class Modification: public ModificationBase
{
private:
  typedef std::map<CH_Matrix_Classes::Integer,CH_Matrix_Classes::Real> Realmap;

  bool append_only;

  //first execute the changes in the variables then in the constrains

  //------ changes in variable space
  //first carry out the append step, afterwards the delete/reassign step, finally the bound changes

  //-----------------------------------------------------------------------

  CH_Matrix_Classes::Integer var_olddim;
  CH_Matrix_Classes::Integer var_newdim;

  Realmap* var_set_lb; 
  Realmap* var_set_ub; 
  CH_Matrix_Classes::Integer var_append_dim;
  CH_Matrix_Classes::Matrix* var_append_lb;
  CH_Matrix_Classes::Matrix* var_append_ub;
  CH_Matrix_Classes::Sparsemat* var_append_cols;
  CH_Matrix_Classes::Matrix* var_start_val;
  CH_Matrix_Classes::Matrix* var_append_costs;
  CH_Matrix_Classes::Indexmatrix* var_del_ind;
  CH_Matrix_Classes::Indexmatrix* var_map_to_old;
  CH_Matrix_Classes::Indexmatrix* var_new_ind;


  //------ changes in row space
  //first carry out the append step, afterwards the reassign/delete step

  //-----------------------------------------------------------------------

  CH_Matrix_Classes::Integer row_olddim;
  CH_Matrix_Classes::Integer row_newdim;

  Realmap* row_set_rhslb; 
  Realmap* row_set_rhsub; 
  CH_Matrix_Classes::Integer row_append_dim;
  CH_Matrix_Classes::Sparsemat* row_append_mat;
  CH_Matrix_Classes::Matrix* row_append_rhslb;
  CH_Matrix_Classes::Matrix* row_append_rhsub;
  CH_Matrix_Classes::Indexmatrix* row_del_ind;
  CH_Matrix_Classes::Indexmatrix* row_map_to_old;
  CH_Matrix_Classes::Indexmatrix* row_new_ind;


  //-----------------------------------------------------------------------
  bool enforce_bounds_consistency; 
  bool enforce_start_val_box_feasibility; 
  CH_Matrix_Classes::Real start_val_default; 
  CH_Matrix_Classes::Real bounds_minus_infinity;    
  CH_Matrix_Classes::Real bounds_plus_infinity;    
  CH_Matrix_Classes::Real rhs_minus_infinity; 
  CH_Matrix_Classes::Real rhs_plus_infinity; 
  CH_Matrix_Classes::Real cost_default; 



public:

  //-----------------------------------------------------------------------

  virtual ~Modification();


  Modification(CH_Matrix_Classes::Integer var_olddim,
               CH_Matrix_Classes::Integer row_olddim,
               const CBout* cb=0,
               int incr=-1,
               bool ensure_start_val_box_feasibility=false,
               bool ensure_bounds_consistency=true,
               CH_Matrix_Classes::Real start_val_def=0.,
               CH_Matrix_Classes::Real bounds_minus_infty=CB_minus_infinity,
               CH_Matrix_Classes::Real bounds_plus_infty=CB_plus_infinity,
               CH_Matrix_Classes::Real rhs_minus_infty=CB_minus_infinity,
               CH_Matrix_Classes::Real rhs_plus_infty=CB_plus_infinity,
               CH_Matrix_Classes::Real cost_def=0.);

  int clear(CH_Matrix_Classes::Integer var_olddim,
            CH_Matrix_Classes::Integer row_olddim,
            bool ensure_start_val_box_feasibility=false,
            bool ensure_bounds_consistency=true,
            CH_Matrix_Classes::Real start_val_def=0.,
            CH_Matrix_Classes::Real bounds_minus_infty=CB_minus_infinity,
            CH_Matrix_Classes::Real bounds_plus_infty=CB_plus_infinity,
            CH_Matrix_Classes::Real rhs_minus_infty=CB_minus_infinity,
            CH_Matrix_Classes::Real rhs_plus_infty=CB_plus_infinity,
            CH_Matrix_Classes::Real cost_def=0.);
  
  
  //-----------------------------------------------------------------------
  
  int add_set_lb(CH_Matrix_Classes::Integer ind,CH_Matrix_Classes::Real lb);

  int add_set_ub(CH_Matrix_Classes::Integer ind,CH_Matrix_Classes::Real ub);

  int add_append_vars(CH_Matrix_Classes::Integer append_dim,
                      const CH_Matrix_Classes::Matrix* append_lb,
                      const CH_Matrix_Classes::Matrix* append_ub,
                      const CH_Matrix_Classes::Sparsemat* append_cols,
                      const CH_Matrix_Classes::Matrix* append_start_val,
                      const CH_Matrix_Classes::Matrix* append_linear_costs);

  int add_reassign_vars(const CH_Matrix_Classes::Indexmatrix& map_to_old);

  int add_delete_vars(const CH_Matrix_Classes::Indexmatrix& del_ind,
                      CH_Matrix_Classes::Indexmatrix& map_to_old);



  int add_set_rhslb(CH_Matrix_Classes::Integer ind,CH_Matrix_Classes::Real rhslb);

  int add_set_rhsub(CH_Matrix_Classes::Integer ind,CH_Matrix_Classes::Real rhsub);

  int add_append_rows(CH_Matrix_Classes::Integer append_dim,
                      const CH_Matrix_Classes::Sparsemat* append_rows,
                      const CH_Matrix_Classes::Matrix* append_rhslb,
                      const CH_Matrix_Classes::Matrix* append_rhsub);

  int add_reassign_rows(const CH_Matrix_Classes::Indexmatrix& map_to_old);

  int add_delete_rows(const CH_Matrix_Classes::Indexmatrix& del_ind,
                      CH_Matrix_Classes::Indexmatrix& map_to_old);

  virtual int incorporate(const Modification& m);


  //-----------------------------------------------------------------------

  int apply_to_vars(CH_Matrix_Classes::Matrix* vars,
                    CH_Matrix_Classes::Matrix* lb,
                    CH_Matrix_Classes::Matrix* ub,
                    CH_Matrix_Classes::Matrix* cost) const;

  int apply_to_rows(CH_Matrix_Classes::Sparsemat* rows,
                    CH_Matrix_Classes::Matrix* rhslb,
                    CH_Matrix_Classes::Matrix* rhsub) const;


  //-----------------------------------------------------------------------

  bool no_modification() const;
  int set_append_to_old(bool append_only);
  bool append_to_old() const
    {return append_only;}
  bool deleted_variables_are_zero(const CH_Matrix_Classes::Matrix& oldpoint) const;
  bool new_variables_are_zero(const CH_Matrix_Classes::Matrix& newpoint) const;
  bool mapped_variables_are_equal(const CH_Matrix_Classes::Matrix& newpoint,
                                  const CH_Matrix_Classes::Matrix& oldpoint) const;


  //-----------------------------------------------------------------------

  CH_Matrix_Classes::Integer old_vardim() const {return var_olddim;} 
  CH_Matrix_Classes::Integer new_vardim() const {return var_newdim;}
  CH_Matrix_Classes::Integer appended_vardim() const {return var_append_dim;} 

  CH_Matrix_Classes::Integer old_rowdim() const {return row_olddim;} 
  CH_Matrix_Classes::Integer new_rowdim() const {return row_newdim;} 
  CH_Matrix_Classes::Integer appended_rowdim() const {return row_append_dim;} 


  const CH_Matrix_Classes::Indexmatrix* map_to_old_variables() const
  {return var_map_to_old;}

  const CH_Matrix_Classes::Indexmatrix* deleted_var_indices() const
  {return var_del_ind;}

  const CH_Matrix_Classes::Indexmatrix* new_var_indices() const
  {return var_new_ind;}

  const CH_Matrix_Classes::Indexmatrix* map_to_old_rows() const
  {return row_map_to_old;}

  const CH_Matrix_Classes::Indexmatrix* deleted_row_indices() const
  {return row_del_ind;}

  const CH_Matrix_Classes::Indexmatrix* new_row_indices() const
  {return row_new_ind;}

  const std::map<CH_Matrix_Classes::Integer,CH_Matrix_Classes::Real>*
  get_var_set_lb() const
  {return var_set_lb;}
  const std::map<CH_Matrix_Classes::Integer,CH_Matrix_Classes::Real>*
  get_var_set_ub() const
  {return var_set_ub;}
  const CH_Matrix_Classes::Sparsemat* get_var_append_cols() const
  {return var_append_cols;}
  const CH_Matrix_Classes::Matrix* get_var_append_lb() const
  {return var_append_lb;}
  const CH_Matrix_Classes::Matrix* get_var_append_ub() const
  {return var_append_ub;}
  const CH_Matrix_Classes::Matrix* get_var_start_val() const
  {return var_start_val;}
  const std::map<CH_Matrix_Classes::Integer,CH_Matrix_Classes::Real>*
  get_row_set_rhslb() const
  {return row_set_rhslb;}
  const std::map<CH_Matrix_Classes::Integer,CH_Matrix_Classes::Real>*
  get_row_set_rhsub() const
  {return row_set_rhsub;}
  const CH_Matrix_Classes::Matrix* get_var_append_costs() const
  {return var_append_costs;}
  const CH_Matrix_Classes::Sparsemat* get_row_append_mat() const
  {return row_append_mat;}
  const CH_Matrix_Classes::Matrix* get_row_append_rhslb() const
  {return row_append_rhslb;}
  const CH_Matrix_Classes::Matrix* get_row_append_rhsub() const
  {return row_append_rhsub;}


};






}

#endif