MinorantPointer.hxx

Go to the documentation of this file.

#ifndef CONICBUNDLE_MINORANTPOINTER_HXX
#define CONICBUNDLE_MINORANTPOINTER_HXX


#include "MinorantUseData.hxx"
#include "sparsmat.hxx"

namespace ConicBundle {

  class GroundsetModification;

  class MinorantPointer;

  typedef std::vector<MinorantPointer> MinorantBundle;

class MinorantPointer: public CBout
{
private:
  MinorantUseData* md;

  void delete_data();

  void new_data(MinorantUseData* in_md);

  int prepare_for_changes(CH_Matrix_Classes::Real factor=1.,bool with_primal=false);

public:  
  MinorantPointer& operator=(const MinorantPointer& mp);

  void init(const MinorantPointer& mp,CH_Matrix_Classes::Real factor=1.,bool enforce_copy=false);

  void init(Minorant* mp,CH_Matrix_Classes::Integer modification_id=-1,CH_Matrix_Classes::Real factor=1.);
  
  MinorantPointer():md(0)
  {}

  MinorantPointer(MinorantUseData* in_md):CBout(),md(0)
  {new_data(in_md);}

  MinorantPointer(const MinorantPointer& mp):CBout(mp),md(0)
  {new_data(mp.md);}

  MinorantPointer(const MinorantPointer& mp,CH_Matrix_Classes::Real factor):
    CBout(mp),md(0)
  {init(mp,factor);}
  
  MinorantPointer(Minorant* mnrt,CH_Matrix_Classes::Integer modification_id,CH_Matrix_Classes::Real factor=1.):
    CBout(),md(0)
  {init(mnrt,modification_id,factor);}
  
  virtual ~MinorantPointer(){ delete_data();}

  void clear() { delete_data();}

  int synchronize_ids(CH_Matrix_Classes::Integer new_modification_id,
                       CH_Matrix_Classes::Integer new_center_id,
                       CH_Matrix_Classes::Integer old_center_id,
                       CH_Matrix_Classes::Integer new_cand_id,
                       CH_Matrix_Classes::Integer old_cand_id,
                       CH_Matrix_Classes::Integer new_prex_id=0);

  bool empty() const {return (md==0);}

  bool valid() const {return (md!=0)&&(md->valid());}
 
  bool zero() const;
 
  bool aggregate() const;

  bool one_user() const;

  const Minorant* get_minorant() const
  {if (empty()) return 0; return md->get_minorant();}

  int get_scaleval_and_minorant(CH_Matrix_Classes::Real& sv,Minorant*& m)
  {if (empty()) { m=0;sv=0.;return 0;} return md->get_scaleval_and_minorant(sv,m);}

  const PrimalData* get_primal(); 

  CH_Matrix_Classes::Real offset() const;

  CH_Matrix_Classes::Real coeff(CH_Matrix_Classes::Integer i) const;

  CH_Matrix_Classes::Integer nonzeros() const
  {if (empty()) return 0; return md->get_minorant()->nonzeros();}

  int scale(CH_Matrix_Classes::Real val);

  int call_primal_extender(PrimalExtender& prex,CH_Matrix_Classes::Integer prex_id);

  int apply_modification(const GroundsetModification& gsmdf,
                         CH_Matrix_Classes::Integer mod_id,
                         MinorantExtender* mex,
                         bool apply_gsmdf_costs=false);

  CH_Matrix_Classes::Real evaluate(CH_Matrix_Classes::Integer yid,
                                   const CH_Matrix_Classes::Matrix& y,bool with_constant=true) const;
  
  int add_offset(CH_Matrix_Classes::Real offset);

  int get_minorant(CH_Matrix_Classes::Real& offset,
                   CH_Matrix_Classes::Matrix& mat,
                   CH_Matrix_Classes::Integer column,
                   CH_Matrix_Classes::Real alpha=1.,
                   bool add=false,
                   const CH_Matrix_Classes::Indexmatrix* skip_fixed=0,
                   const CH_Matrix_Classes::Matrix* fixed_vals=0) const; 


  int get_minorant(MinorantPointer& mp,
                   CH_Matrix_Classes::Real alpha=1.) const; 

  int get_minorant(MinorantPointer& mp,
                   CH_Matrix_Classes::Real alpha,
                   const CH_Matrix_Classes::Sparsemat* sp,
                   const CH_Matrix_Classes::Indexmatrix* provided_row_indices=0,
                   const CH_Matrix_Classes::Indexmatrix* needed_col_indices=0,
                   bool enforce_copy=false) const; 

  int aggregate(const MinorantBundle& minorants,const CH_Matrix_Classes::Matrix& coeff,CH_Matrix_Classes::Real factor=1.);

  int aggregate(const MinorantPointer& minorant,double itsfactor=1.);

  CH_Matrix_Classes::Real ip(const MinorantPointer& mp,const CH_Matrix_Classes::Indexmatrix* skip_fixed=0,const CH_Matrix_Classes::Matrix* ipdiag=0) const;

  CH_Matrix_Classes::Real ip(const CH_Matrix_Classes::Matrix& m,const CH_Matrix_Classes::Matrix* ipdiag=0,CH_Matrix_Classes::Integer startindex_m=0) const;

  bool operator<(const MinorantPointer& mp) const
  {return (md<mp.md);}  
  
  bool operator==(const MinorantPointer& mp) const
  {return (md==mp.md);}
 
  bool operator>(const MinorantPointer& mp) const
  {return (md>mp.md);}

  bool equals(const MinorantPointer& mp,CH_Matrix_Classes::Real tol=1e-10) const;

  CH_Matrix_Classes::Real norm_squared(const CH_Matrix_Classes::Matrix *D=0) const;

  CH_Matrix_Classes::Real dual_norm_squared(const CH_Matrix_Classes::Matrix *D=0) const;

  CH_Matrix_Classes::Matrix& left_genmult(const CH_Matrix_Classes::Matrix& B,
                                          CH_Matrix_Classes::Matrix& C,
                                          CH_Matrix_Classes::Real alpha=1.,
                                          CH_Matrix_Classes::Real beta=0.,
                                          int thistrans=0,
                                          int btrans=0,
                                          CH_Matrix_Classes::Integer thisindex=0) const;

  CH_Matrix_Classes::Matrix& right_genmult(const CH_Matrix_Classes::Matrix& A,
                                           CH_Matrix_Classes::Matrix& C,
                                           CH_Matrix_Classes::Real alpha=1.,
                                           CH_Matrix_Classes::Real beta=0.,
                                           int atrans=0,
                                           int thistrans=0,
                                           CH_Matrix_Classes::Integer thisindex=0) const;

  std::ostream& display(std::ostream& out,int precision=8) const;
};

  CH_Matrix_Classes::Matrix& genmult(const MinorantBundle& A,
                                     const CH_Matrix_Classes::Matrix& B,
                                     CH_Matrix_Classes::Matrix& C,
                                     CH_Matrix_Classes::Real alpha=1.,
                                     CH_Matrix_Classes::Real beta=0.,
                                     int Atrans=0,
                                     int Btrans=0,
                                     CH_Matrix_Classes::Matrix* Coffset=0);

  CH_Matrix_Classes::Matrix& genmult(const CH_Matrix_Classes::Matrix& A,
                                     const MinorantBundle& B,
                                     CH_Matrix_Classes::Matrix& C,
                                     CH_Matrix_Classes::Real alpha=1.,
                                     CH_Matrix_Classes::Real beta=0.,
                                     int Atrans=0,
                                     int Btrans=0,
                                     CH_Matrix_Classes::Matrix* Coffset=0);




}


#endif