SparseCoeffmatMatrix.hxx

Go to the documentation of this file.

#ifndef CONICBUNDLE_SPARSECOEFFMATMATRIX_HXX
#define CONICBUNDLE_SPARSECOEFFMATMATRIX_HXX

#include "Coeffmat.hxx"

namespace ConicBundle {

  class PSCPrimal;


  typedef std::vector<CoeffmatPointer> CoeffmatVector;
  typedef std::map<CH_Matrix_Classes::Integer,CoeffmatPointer> SparseCoeffmatVector;

  class SparseCoeffmatMatrix : virtual public CBout
{
public:
  typedef std::map<CH_Matrix_Classes::Integer,SparseCoeffmatVector> SCMcolrep;

private:
  CH_Matrix_Classes::Indexmatrix block_dim; 
  CH_Matrix_Classes::Integer col_dim; 
  CH_Matrix_Classes::Indexmatrix dense_cnt; 
  
  typedef std::vector<SparseCoeffmatVector> SCMblockrep;
  SCMblockrep blockrep;

  
  mutable SCMcolrep* colrep; 

 
  void form_colrep() const;
  
    
public:
  SparseCoeffmatMatrix& operator=(const SparseCoeffmatMatrix& );

  void clear();

  int init(const CH_Matrix_Classes::Indexmatrix& block_dim,
           CH_Matrix_Classes::Integer col_dim,
           const CH_Matrix_Classes::Indexmatrix* block_ind=0,
           const CH_Matrix_Classes::Indexmatrix* col_ind=0,
           const CoeffmatVector* coeff_vec=0);

  SparseCoeffmatMatrix(const CBout* cb=0,
                       int incr=-1):
    CBout(cb,incr),col_dim(0),blockrep(),colrep(0)
  {clear();}

  SparseCoeffmatMatrix(const SparseCoeffmatMatrix& S,const CBout* cb=0,
                       int incr=-1):
    CBout(cb,incr),col_dim(0),blockrep(),colrep(0)
  { *this=S; }
  

  SparseCoeffmatMatrix(const CH_Matrix_Classes::Indexmatrix& in_block_dim,
                       CH_Matrix_Classes::Integer in_col_dim,
                       const CH_Matrix_Classes::Indexmatrix* block_ind=0,
                       const CH_Matrix_Classes::Indexmatrix* col_ind=0,
                       const CoeffmatVector* coeff_vec=0,
                       const CBout* cb=0,
                       int incr=-1):
    CBout(cb,incr),col_dim(0),blockrep(),colrep(0)
  { init(in_block_dim,in_col_dim,block_ind,col_ind,coeff_vec); }

  ~SparseCoeffmatMatrix();


  const CH_Matrix_Classes::Indexmatrix& blockdim() const {return block_dim;}
  CH_Matrix_Classes::Integer blockdim(CH_Matrix_Classes::Integer i) const;
  CH_Matrix_Classes::Integer coldim() const {return col_dim;}
  CH_Matrix_Classes::Integer rowdim() const {return block_dim.rowdim();}
  CH_Matrix_Classes::Integer nzcoldim() const
  {form_colrep(); return CH_Matrix_Classes::Integer(colrep->size()); }

  int set(CH_Matrix_Classes::Integer i,CH_Matrix_Classes::Integer j,const CoeffmatPointer& cm);

  int set(CH_Matrix_Classes::Integer i,CH_Matrix_Classes::Integer j,Coeffmat* cm)
  {CoeffmatPointer cmp(cm); return set(i,j,cmp);}

  CoeffmatPointer operator()(CH_Matrix_Classes::Integer i,CH_Matrix_Classes::Integer j) const;

  const SparseCoeffmatVector* block(CH_Matrix_Classes::Integer i) const;
  const SparseCoeffmatVector* column(CH_Matrix_Classes::Integer i) const;

  
  int append_blocks(const SparseCoeffmatMatrix& append_mat,
                    const CH_Matrix_Classes::Indexmatrix* blocks=0,
                    const CH_Matrix_Classes::Indexmatrix* cols=0);

  int append_columns(const SparseCoeffmatMatrix& append_mat,
                     const CH_Matrix_Classes::Indexmatrix* blocks=0,
                     const CH_Matrix_Classes::Indexmatrix* cols=0);
                    
  int reassign_blocks(const CH_Matrix_Classes::Indexmatrix& map_to_old);
  int reassign_columns(const CH_Matrix_Classes::Indexmatrix& map_to_old);
  
  int delete_blocks(const CH_Matrix_Classes::Indexmatrix& delete_indices, CH_Matrix_Classes::Indexmatrix* map_to_old=0);
  int delete_columns(const CH_Matrix_Classes::Indexmatrix& delete_indices, CH_Matrix_Classes::Indexmatrix* map_to_old=0);
  
  const SCMcolrep* get_colrep() const
  { form_colrep(); return colrep;}

  CH_Matrix_Classes::Integer get_dense_cnt(CH_Matrix_Classes::Integer i) const
  { return dense_cnt(i);}

  bool operator==(const SparseCoeffmatMatrix& mat) const;
  
  bool operator!=(const SparseCoeffmatMatrix& mat) const
  {return !(*this==mat);}

  int Gram_ip(CH_Matrix_Classes::Matrix& ipvec,const CH_Matrix_Classes::Matrix& P,const CH_Matrix_Classes::Matrix* Lam=0,const CH_Matrix_Classes::Indexmatrix* ind=0) const;

  int Gram_ip(CH_Matrix_Classes::Real& ipval,const CH_Matrix_Classes::Matrix& P,CH_Matrix_Classes::Integer j) const;

  int primal_ip(CH_Matrix_Classes::Matrix& ipvec,const PSCPrimal* primal,const CH_Matrix_Classes::Indexmatrix* ind=0) const;

  int primal_ip(CH_Matrix_Classes::Real& value,const PSCPrimal* primal,CH_Matrix_Classes::Integer j) const;
  
  int project(CH_Matrix_Classes::Symmatrix& S, const CH_Matrix_Classes::Matrix& P,const CH_Matrix_Classes::Integer j) const;
  
  
};


}

#endif