AFTModification.hxx

Go to the documentation of this file.

#ifndef CONICBUNDLE_AFTMODIFICATION_HXX
#define CONICBUNDLE_AFTMODIFICATION_HXX


#include "Modification.hxx"

namespace ConicBundle {


  class AFTModification:public CBout, public OracleModification
{
protected:
  Modification mdf;

  CH_Matrix_Classes::Real factor;
  CH_Matrix_Classes::Real offset;

  bool ignore_gs_mdf;
  
  mutable int preserves_id_flag; 
  
public:
  //-----------------------------------------------------------------------


  AFTModification(CH_Matrix_Classes::Integer var_olddim=0,CH_Matrix_Classes::Integer row_olddim=0,bool ignore_groundset_modification=false);
  virtual ~AFTModification();

  void clear(CH_Matrix_Classes::Integer var_olddim,CH_Matrix_Classes::Integer row_olddim);

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

  
  int add_append_vars(CH_Matrix_Classes::Integer append_dim,
                      const CH_Matrix_Classes::Sparsemat* append_cols,
                      const CH_Matrix_Classes::Matrix* linear_costs)
  {preserves_id_flag=-1;return mdf.add_append_vars(append_dim,0,0,append_cols,0,linear_costs);}

  int add_reassign_vars(const CH_Matrix_Classes::Indexmatrix& map_to_old)
  {preserves_id_flag=-1;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)
  {preserves_id_flag=-1;return mdf.add_delete_vars(del_ind,map_to_old);}

  int add_append_rows(CH_Matrix_Classes::Integer append_dim,
                      const CH_Matrix_Classes::Sparsemat* append_rows,
                      const CH_Matrix_Classes::Matrix* append_rhs)
  {preserves_id_flag=-1;return mdf.add_append_rows(append_dim,append_rows,append_rhs,0);}

  int add_reassign_rows(const CH_Matrix_Classes::Indexmatrix& map_to_old)
  {preserves_id_flag=-1;return mdf.add_reassign_rows(map_to_old);}

  int add_delete_rows(const CH_Matrix_Classes::Indexmatrix& rows_del_ind,
                      CH_Matrix_Classes::Indexmatrix& rows_map_to_old)
  {preserves_id_flag=-1;return mdf.add_delete_rows(rows_del_ind,rows_map_to_old);}
 
  virtual int add_apply_factor(CH_Matrix_Classes::Real times_factor)
  {if (times_factor<0.) return 1; factor*=times_factor; return 0;}

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

 
  int incorporate(const AFTModification& m);


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

  int apply_to_costs(CH_Matrix_Classes::Matrix*& linear_cost) const;

  int apply_to_rows(CH_Matrix_Classes::Sparsemat*& rows,
                    CH_Matrix_Classes::Matrix*& rhs) const;

  int apply_to_factor(CH_Matrix_Classes::Real& f) const 
  {f*=factor;return 0;}

  int apply_to_offset(CH_Matrix_Classes::Real& o) const 
  {o+=offset;return 0;}

  const CH_Matrix_Classes::Matrix& apply_modified_transform(CH_Matrix_Classes::Matrix& out_y,
                               const CH_Matrix_Classes::Matrix &in_y,
                               const CH_Matrix_Classes::Sparsemat* arg_trafo,
                               const CH_Matrix_Classes::Matrix* arg_offset) const;

  //-----------------------------------------------------------------------
  
  virtual bool no_modification() const
  { return ((offset==0)&&(factor==1.)&&(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();}

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

  virtual bool ignore_groundset_modification() const
  {return ignore_gs_mdf;}

  virtual bool groundset_changes_suffice_for_identity();

  bool preserves_identity() const;

  
  bool no_additions_or_deletions_in_vars() const;

  bool no_additions_or_deletions_in_rows() const;

  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());}

  int incorporate(const OracleModification& m)
  { 
    const AFTModification* aftm=dynamic_cast<const AFTModification*>(&m);
    if (aftm) return incorporate(*aftm); 
    return 1;
  }

  OracleModification* new_initial_oraclemodification(int old_var_dim) const 
  {return new AFTModification(old_var_dim,old_rowdim());}
       
  int add_append_variables(int append_dim)
  {return add_append_vars(CH_Matrix_Classes::Integer(append_dim),0,0);}

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


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

  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();}

  CH_Matrix_Classes::Integer old_rowdim() const
  {return mdf.old_rowdim();}
   CH_Matrix_Classes::Integer new_rowdim() const
  {return mdf.new_rowdim();}
  CH_Matrix_Classes::Integer appended_rowdim() const
  {return mdf.appended_rowdim();}

  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();}

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

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

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

  CH_Matrix_Classes::Real get_additional_factor() const
  {return factor;}

  const CH_Matrix_Classes::Sparsemat* get_append_cols() const
  {return mdf.get_var_append_cols();}

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

  const CH_Matrix_Classes::Sparsemat* get_append_rows() const
  {return mdf.get_row_append_mat();}

  const CH_Matrix_Classes::Matrix* get_append_rhs() const
  {return mdf.get_row_append_rhslb();}


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

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


};




}

#endif