GroundsetModification.hxx

Go to the documentation of this file.

#ifndef CONICBUNDLE_GROUNDSETMODIFICATION_HXX
#define CONICBUNDLE_GROUNDSETMODIFICATION_HXX


#include "Modification.hxx"

namespace ConicBundle {

  class Minorant; 


  class GroundsetModification: public CBout, public OracleModification
{
protected:
  Modification mdf;
  CH_Matrix_Classes::Real offset;
  
public:
  //-----------------------------------------------------------------------

  GroundsetModification(CH_Matrix_Classes::Integer var_olddim=0,const CBout* cbo=0,int incr=-1):
    CBout(cbo,incr),mdf(var_olddim,0),offset(0.){}

  void clear(CH_Matrix_Classes::Integer var_olddim)
  {mdf.clear(var_olddim,0);offset=0.;}


  virtual ~GroundsetModification();


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

  int add_append_vars(CH_Matrix_Classes::Integer append_dim,
                      const CH_Matrix_Classes::Matrix* start_val=0,
                      const CH_Matrix_Classes::Matrix* costs=0)
  {return mdf.add_append_vars(append_dim,0,0,0,start_val,costs);}


  int add_reassign_vars(const CH_Matrix_Classes::Indexmatrix& map_to_old)
  {return mdf.add_reassign_vars(map_to_old);}

  int add_delete_vars(const CH_Matrix_Classes::Indexmatrix& del_ind,
                      CH_Matrix_Classes::Indexmatrix& map_to_old)
  {return mdf.add_delete_vars(del_ind,map_to_old);}

  int add_offset(CH_Matrix_Classes::Real delta)
  {offset+=delta; return 0;}
 

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

  int apply_to_vars(CH_Matrix_Classes::Matrix& vars) const
  {return mdf.apply_to_vars(&vars,0,0,0);}

  int apply_to_costs(CH_Matrix_Classes::Matrix& costs,CH_Matrix_Classes::Real& in_offset) const
  {in_offset+=offset; return mdf.apply_to_vars(0,0,0,&costs);}


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


  bool no_modification() const
  {return mdf.no_modification();}

  int set_append_to_old(bool append_only)
  {return mdf.set_append_to_old(append_only);}
  bool append_to_old() const
  {return mdf.append_to_old();}

  bool no_additions_or_deletions_in_vars() const
  {
    return ((mdf.appended_vardim()==0)&&((mdf.map_to_old_variables()==0)||(mdf.map_to_old_variables()->dim()==mdf.old_vardim())));
  }

  bool deleted_variables_are_zero(const CH_Matrix_Classes::Matrix& oldpoint) const
  {return mdf.deleted_variables_are_zero(oldpoint);}

  bool new_variables_are_zero(const CH_Matrix_Classes::Matrix& newpoint) const
  {return mdf.new_variables_are_zero(newpoint);}

  bool mapped_variables_are_equal(const CH_Matrix_Classes::Matrix& newpoint,
                                  const CH_Matrix_Classes::Matrix& oldpoint) const
  {return mdf.mapped_variables_are_equal(newpoint,oldpoint);}


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

  int get_old_vardim() const {return mdf.old_vardim();}
  int get_new_vardim() const {return mdf.new_vardim();}
  int get_appended_vardim() const {return mdf.appended_vardim();}

  const int* get_map_to_old_variables() const
  {return (mdf.map_to_old_variables())==0?0:(const int*)(mdf.map_to_old_variables()->get_store());}

  CH_Matrix_Classes::Real get_add_offset() const
  {return offset;}

  const CH_Matrix_Classes::Matrix* get_append_costs() const
  {return mdf.get_var_append_costs();}

  int incorporate(const OracleModification& m)
  {
    const GroundsetModification* gm=dynamic_cast<const GroundsetModification*>(&m);
    if (gm) {offset+=gm->offset; return mdf.incorporate(gm->mdf);} 
    return 1;
  }

  OracleModification* new_initial_oraclemodification(int old_var_dim) const
  {return new GroundsetModification(old_var_dim);}
       
  int add_append_variables(int append_dim)
  { return add_append_vars(append_dim); }

  int add_reassign_variables(int new_dim,const int* map_to_old_indices)
  { CH_Matrix_Classes::Indexmatrix map_to_old(new_dim,1,map_to_old_indices);
    return add_reassign_vars(map_to_old); }


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

  CH_Matrix_Classes::Integer old_vardim() const {return mdf.old_vardim();}
  CH_Matrix_Classes::Integer new_vardim() const {return mdf.new_vardim();}
  CH_Matrix_Classes::Integer appended_vardim() const {return mdf.appended_vardim();}

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

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

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


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

  void set_out(std::ostream* out=0,int print_level=1)
  {CBout::set_out(out,print_level);mdf.set_out(out,print_level);}

  void set_cbout(const CBout* cb=0,int incr=-1)
  {CBout::set_cbout(cb,incr);mdf.set_cbout(this,0);}


};




}

#endif