Coeffmat.hxx

Go to the documentation of this file.

#ifndef CONICBUNDLE_COEFFMAT_HXX
#define CONICBUNDLE_COEFFMAT_HXX

#include <string>
#include <map>
#include "memarray.hxx"
#include "symmat.hxx"
#include "sparssym.hxx"
#include "CBout.hxx"


namespace ConicBundle {



enum Coeffmattype {
                  CM_unspec=0,      
                  CM_symdense=1,    
                  CM_symsparse=2,   
                  CM_lowrankdd=3,   
                  CM_lowranksd=4,   
                  CM_lowrankss=5,   
                  CM_gramdense=6,   
                  CM_gramsparse=7,  
                  CM_singleton=8,   
                  CM_gramsparsewd=9 
                 };



class CoeffmatInfo
{
protected:
  CH_Matrix_Classes::Real scalefactor; 
public:
  CoeffmatInfo(CH_Matrix_Classes::Real sf=1.):scalefactor(sf){}
  virtual ~CoeffmatInfo(){}

  virtual CoeffmatInfo* clone() const {return new CoeffmatInfo(scalefactor);}

  CH_Matrix_Classes::Real get_scalefactor() const {return scalefactor;}
  void set_scalefactor(CH_Matrix_Classes::Real sf){scalefactor=sf;}
  void multiply(CH_Matrix_Classes::Real sf){scalefactor*=sf;}
  virtual std::ostream& print_id(std::ostream& out) const {return out<<"NoInfo";}
};


  
class CMIName : public CoeffmatInfo
{
private:
  std::string name; 
public:
  CMIName(std::string in_name,CH_Matrix_Classes::Real sf=1.):CoeffmatInfo(sf),name(in_name){}
  ~CMIName(){}
  CoeffmatInfo* clone() const {return new CMIName(name,scalefactor);}
  std::ostream& print_id(std::ostream& out) const {return out<<name.c_str();}  
};



inline CoeffmatInfo* clone(const CoeffmatInfo* cip) 
{return (cip==0)? 0: cip->clone();} 




class Coeffmat: protected CH_Matrix_Classes::Memarrayuser
{
private:
  friend class CoeffmatPointer;
  mutable CH_Matrix_Classes::Integer use_cnt;
  bool deletion_by_CoeffmatPointer;
protected:
  Coeffmattype CM_type;  
  CoeffmatInfo*  infop;  
public:
  Coeffmat(bool del_by_CoeffmatPointer=true)
  {CM_type=CM_unspec;infop=0;use_cnt=0;deletion_by_CoeffmatPointer=del_by_CoeffmatPointer;}
  virtual ~Coeffmat(){delete infop;}

  void set_deletion_by_CoeffmatPointer(bool dbMP)
  {deletion_by_CoeffmatPointer=dbMP;}
  virtual Coeffmattype get_type() const {return CM_type;}
  virtual CoeffmatInfo* get_info() {return  infop;}
  virtual const CoeffmatInfo* get_info() const {return  infop;}
  virtual void set_info(CoeffmatInfo* cip) {delete infop; infop=cip;}


  virtual Coeffmat* clone() const =0;

  virtual CH_Matrix_Classes::Integer dim() const =0;
    
  virtual CH_Matrix_Classes::Real operator()(CH_Matrix_Classes::Integer i,CH_Matrix_Classes::Integer j) const =0;
    
  virtual void make_symmatrix(CH_Matrix_Classes::Symmatrix& S) const =0;

  virtual CH_Matrix_Classes::Real norm(void) const =0;

  
  virtual Coeffmat* subspace(const CH_Matrix_Classes::Matrix& P) const =0;
    
  virtual void multiply(CH_Matrix_Classes::Real d) =0;

  virtual CH_Matrix_Classes::Real ip(const CH_Matrix_Classes::Symmatrix& S) const =0;
    
  virtual CH_Matrix_Classes::Real gramip(const CH_Matrix_Classes::Matrix& P) const =0;

  virtual CH_Matrix_Classes::Real gramip(const CH_Matrix_Classes::Matrix& P,CH_Matrix_Classes::Integer start_row,const CH_Matrix_Classes::Matrix* Lam=0) const =0;

  virtual void addmeto(CH_Matrix_Classes::Symmatrix& S,CH_Matrix_Classes::Real d=1.) const =0;

  virtual void addprodto(CH_Matrix_Classes::Matrix& A,const CH_Matrix_Classes::Matrix& B,CH_Matrix_Classes::Real d=1.) const =0;

  virtual void addprodto(CH_Matrix_Classes::Matrix& A,const CH_Matrix_Classes::Sparsemat& B,CH_Matrix_Classes::Real d=1.) const =0;

  virtual void left_right_prod(const CH_Matrix_Classes::Matrix& P,const CH_Matrix_Classes::Matrix& Q,CH_Matrix_Classes::Matrix& R) const =0;

  virtual CH_Matrix_Classes::Integer prodvec_flops() const =0;

  virtual int dense() const =0;
    
  virtual int sparse() const =0;
    
  virtual int sparse(CH_Matrix_Classes::Indexmatrix& I,CH_Matrix_Classes::Indexmatrix& J,CH_Matrix_Classes::Matrix& val,CH_Matrix_Classes::Real d=1.)const=0;

  virtual int support_in(const CH_Matrix_Classes::Sparsesym& A) const =0;

  virtual CH_Matrix_Classes::Real ip(const CH_Matrix_Classes::Sparsesym& A) const =0;
    
  virtual void project(CH_Matrix_Classes::Symmatrix& S,const CH_Matrix_Classes::Matrix& P) const=0;
    
  virtual void add_projection(CH_Matrix_Classes::Symmatrix& S,const CH_Matrix_Classes::Matrix& P,CH_Matrix_Classes::Real alpha=1.,CH_Matrix_Classes::Integer start_row=0) const =0;

  virtual const CH_Matrix_Classes::Matrix& postgenmult(const CH_Matrix_Classes::Matrix& B,CH_Matrix_Classes::Matrix& C,
                             CH_Matrix_Classes::Real alpha=1.,CH_Matrix_Classes::Real beta=0.,int btrans=0) const =0;

  virtual const CH_Matrix_Classes::Matrix& pregenmult(const CH_Matrix_Classes::Matrix& B,CH_Matrix_Classes::Matrix& C,
                                                      CH_Matrix_Classes::Real alpha=1.,CH_Matrix_Classes::Real beta=0.,int btrans=0) const =0;

  virtual int equal(const Coeffmat* p,double tol=1e-6) const =0;

  virtual std::ostream& display(std::ostream& o) const =0;

  virtual std::ostream& out(std::ostream& o) const =0;
  
  virtual std::istream& in(std::istream& i) =0;

};



Coeffmat* coeffmat_read(std::istream& in);



class CoeffmatPointer{
private: 
  Coeffmat*  coeffmatp;

public:
  void init(Coeffmat* cfmp)
  {
    if ((coeffmatp)&&
        ( --(coeffmatp->use_cnt)<=0)&&
        (coeffmatp->deletion_by_CoeffmatPointer)){
      assert(coeffmatp->use_cnt==0);
      delete coeffmatp;
    }
    coeffmatp=cfmp;
    if (coeffmatp)
      coeffmatp->use_cnt++;
  }
      
  CoeffmatPointer():coeffmatp(0)
  {}

  CoeffmatPointer(Coeffmat* cfmp):coeffmatp(0)
  {
    init(cfmp);
  }

  CoeffmatPointer(const CoeffmatPointer& mp):coeffmatp(0)
  {
    init(mp.coeffmatp);
  }

  ~CoeffmatPointer()
  { init(0); }

  CoeffmatPointer& operator=(const CoeffmatPointer& mp)
  { init(mp.coeffmatp); return *this; }

  CoeffmatPointer& operator=(Coeffmat* cfmp)
  { init(cfmp); return *this; }

  bool operator==(const CoeffmatPointer& mp) const
  { return coeffmatp==mp.coeffmatp; }

  bool operator==(const Coeffmat* cfmp) const
  { return coeffmatp==cfmp; }

  bool operator!=(const CoeffmatPointer& mp) const
  { return coeffmatp!=mp.coeffmatp; }

  bool operator!=(const Coeffmat* cfmp) const
  { return coeffmatp!=cfmp; }

  bool operator<(const CoeffmatPointer& mp) const
  { return coeffmatp<mp.coeffmatp; }

  bool operator<(const Coeffmat* cfmp) const
  { return coeffmatp<cfmp; }

  bool operator>(const CoeffmatPointer& mp) const
  { return coeffmatp>mp.coeffmatp; }

  bool operator>(const Coeffmat* cfmp) const
  { return coeffmatp>cfmp; }

  Coeffmat& operator*() const
  {assert(coeffmatp); return *coeffmatp;}

  Coeffmat* operator->() const
  {assert(coeffmatp); return coeffmatp;}

  Coeffmat* ptr() const
  {return coeffmatp;}

};




}

#endif