PSCPrimal.hxx

Go to the documentation of this file.

#ifndef CONICBUNDLE_PSCPRIMAL_HXX
#define CONICBUNDLE_PSCPRIMAL_HXX

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

#include <map>
#include "CBout.hxx"
#include "PSCOracle.hxx"
#include "SparseCoeffmatMatrix.hxx"

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

namespace ConicBundle {


  class PSCPrimal: public PrimalData
  {

  public:
    virtual ~PSCPrimal(){}

    virtual PrimalData* clone_primal_data() const =0;  

    virtual int assign_Gram_matrix(const CH_Matrix_Classes::Matrix& P)=0;

    virtual int aggregate_primal_data(const PrimalData& pd,double factor=1.)=0;

    virtual int aggregate_Gram_matrix(const CH_Matrix_Classes::Matrix& P,double factor=1.)=0;
        
    virtual int scale_primal_data(double factor)=0;

    virtual int primal_ip(CH_Matrix_Classes::Real& value,
                          const SparseCoeffmatMatrix& A,
                          CH_Matrix_Classes::Integer column) const =0;
  };



  class DensePSCPrimal: public PSCPrimal, public CH_Matrix_Classes::Symmatrix
  {
  private:

  public:
    DensePSCPrimal(){}
    DensePSCPrimal(const DensePSCPrimal& symmat,double factor=1.) : PSCPrimal(), CH_Matrix_Classes::Symmatrix(symmat,factor) {}
    DensePSCPrimal(const CH_Matrix_Classes::Symmatrix& symmat,double factor=1.) : PSCPrimal(), CH_Matrix_Classes::Symmatrix(symmat,factor) {}
    DensePSCPrimal(CH_Matrix_Classes::Integer n) : PSCPrimal(), CH_Matrix_Classes::Symmatrix(n,0.) {}
    const DensePSCPrimal& operator=(const CH_Matrix_Classes::Symmatrix& symmat)
    { init(symmat); return *this; }
 
    virtual PrimalData* clone_primal_data() const
    { return new DensePSCPrimal(*this); }


    virtual int assign_Gram_matrix(const CH_Matrix_Classes::Matrix& P)
    { CH_Matrix_Classes::rankadd(P,*this); return 0; }
    
    virtual int aggregate_primal_data(const PrimalData& it,double factor=1.)
    { 
      const DensePSCPrimal* pd=dynamic_cast<const DensePSCPrimal*>(&it);
      assert(pd!=0);
      CH_Matrix_Classes::xbpeya(*this,*pd,factor,1.);
      return 0;
    }

    virtual int aggregate_Gram_matrix(const CH_Matrix_Classes::Matrix& P,double factor=1.)
    { CH_Matrix_Classes::rankadd(P,*this,factor,1.); return 0; }

    virtual int scale_primal_data(double factor)
    { assert(factor>=0.); *this *= factor; return 0;}
   
    virtual int primal_ip(CH_Matrix_Classes::Real& value,
                          const SparseCoeffmatMatrix& A,
                          CH_Matrix_Classes::Integer column) const 
    {
      if ((column<0)||(column>=A.coldim())||(A.blockdim().dim()!=1)||(A.blockdim()(0)!=rowdim())) 
        return 1;
      const SparseCoeffmatVector* block=A.block(0);
      if (block==0){
        value=0.;
      }
      else {
        SparseCoeffmatVector::const_iterator it=block->find(column);
        if (it==block->end())
          value=0.;
        else
          value=it->second->ip(*this);
      }
      return 0;
    }

  };


  class SparsePSCPrimal: public PSCPrimal, public CH_Matrix_Classes::Sparsesym
  {
  public:
    SparsePSCPrimal(const CH_Matrix_Classes::Sparsesym& sps,double factor=1.) : PSCPrimal(), CH_Matrix_Classes::Sparsesym(sps,factor) {}
    SparsePSCPrimal(const SparsePSCPrimal& pr,double factor=1.) : PSCPrimal(), CH_Matrix_Classes::Sparsesym(pr,factor)  {} 
    ~SparsePSCPrimal(){}
    SparsePSCPrimal& operator=(const CH_Matrix_Classes::Sparsesym& sdp)  
    { init(sdp); return *this; }
    
    PrimalData* clone_primal_data() const
    { return new SparsePSCPrimal(*this); }

    int assign_Gram_matrix(const CH_Matrix_Classes::Matrix& P)
    { CH_Matrix_Classes::support_rankadd(P,*this); return 0; }
    
    int aggregate_primal_data(const PrimalData& it,double factor=1.)
    {
      const SparsePSCPrimal* pd=dynamic_cast<const SparsePSCPrimal*>(&it);
      assert(pd!=0);
      this->support_xbpeya(*pd,factor,1.);
      return 0;
    }

    int aggregate_Gram_matrix(const CH_Matrix_Classes::Matrix& P,double factor=1.)
    { CH_Matrix_Classes::support_rankadd(P,*this,factor,1.); return 0; }

    virtual int scale_primal_data(double factor)
    { assert(factor>=0.); *this *= factor; return 0;}
   
    virtual int primal_ip(CH_Matrix_Classes::Real& value,
                          const SparseCoeffmatMatrix& A,
                          CH_Matrix_Classes::Integer column) const
    {
      if ((column<0)||(column>=A.coldim())||(A.blockdim().dim()!=1)||(A.blockdim()(0)!=rowdim())) 
        return 1;
      const SparseCoeffmatVector* block=A.block(0);
      if (block==0)
        value=0.;
      else {
        SparseCoeffmatVector::const_iterator it=block->find(column);
        if (it==block->end())
          value=0.;
        else {
          if (it->second->support_in(*this)==0){
            return 1;
          }
          value=it->second->ip(*this);
        }
      }
      return 0;
    }
  };
  

  class GramSparsePSCPrimal: public PSCPrimal, public CH_Matrix_Classes::Sparsesym
  {
   protected:
    CH_Matrix_Classes::Matrix gramblock; 

   public:
    GramSparsePSCPrimal(const CH_Matrix_Classes::Sparsesym& sps,double factor=1.) : PSCPrimal(), CH_Matrix_Classes::Sparsesym(sps,factor) {}
    GramSparsePSCPrimal(const GramSparsePSCPrimal& pr,double factor=1.) : 
      PSCPrimal(), 
      CH_Matrix_Classes::Sparsesym(pr,factor),
      gramblock(pr.gramblock,std::sqrt(factor))  {assert(factor>=0.);} 
    ~GramSparsePSCPrimal(){}
    GramSparsePSCPrimal& operator=(const CH_Matrix_Classes::Sparsesym& sdp)  
    { init(sdp); gramblock.init(0,0,0.); return *this; }
    GramSparsePSCPrimal& operator=(const GramSparsePSCPrimal& sdp)  
    { init(sdp); gramblock=sdp.gramblock; return *this; }
    
    const CH_Matrix_Classes::Matrix& get_grammatrix() const { return  gramblock; }
 
    PrimalData* clone_primal_data() const
    { return new GramSparsePSCPrimal(*this); }

    int assign_Gram_matrix(const CH_Matrix_Classes::Matrix& P)
    { gramblock=P; CH_Matrix_Classes::support_rankadd(CH_Matrix_Classes::Matrix(gramblock.rowdim(),1,0.),*this,0.); return 0; }
    
    int aggregate_primal_data(const PrimalData& it,double factor=1.)
    {
      assert(factor>=0.);
      const GramSparsePSCPrimal* pd=dynamic_cast<const GramSparsePSCPrimal*>(&it);
      if (pd!=0){
        this->support_xbpeya(*pd,factor,1.);
        if (pd->gramblock.dim()!=0) 
          CH_Matrix_Classes::support_rankadd(pd->gramblock,*this,factor);
        return 0;
      }
      const SparsePSCPrimal* ps=dynamic_cast<const SparsePSCPrimal*>(&it);
      if (ps!=0){
        this->support_xbpeya(*ps,factor,1.);
        return 0;
      }
      return 1;
    }

    int aggregate_Gram_matrix(const CH_Matrix_Classes::Matrix& P,double factor=1.)
    { 
      if (gramblock.dim()!=0) {
        CH_Matrix_Classes::support_rankadd(gramblock,*this);
        gramblock.init(0,0,0.);
      }
      CH_Matrix_Classes::support_rankadd(P,*this,factor,1.); 
      return 0; 
    }

    virtual int scale_primal_data(double factor)
    { assert(factor>=0.); *this *= factor; gramblock*=std::sqrt(factor); return 0;}

    virtual int primal_ip(CH_Matrix_Classes::Real& value,
                          const SparseCoeffmatMatrix& A,
                          CH_Matrix_Classes::Integer column) const
    {
      if ((column<0)||(column>=A.coldim())||(A.blockdim().dim()!=1)||(A.blockdim()(0)!=rowdim())) 
        return 1;
      const SparseCoeffmatVector* block=A.block(0);
      if (block==0){
        value=0.;
      }
      else {
        SparseCoeffmatVector::const_iterator it=block->find(column);
        if (it==block->end()) 
          value=0.;
        else {
          if (it->second->support_in(*this)==0){
            return 1;
          }
          value=it->second->ip(*this);
          if (gramblock.dim()>0)
            value+=it->second->gramip(gramblock);
        }
      }
      return 0;
    }
  };
  
  class BlockPSCPrimal: public PSCPrimal
  {
  private:
    CH_Matrix_Classes::Indexmatrix Xdim; 
    std::map<CH_Matrix_Classes::Integer,PSCPrimal*> primal; 
  public:
    BlockPSCPrimal(const BlockPSCPrimal& pr,double factor=1.);
    BlockPSCPrimal(const CH_Matrix_Classes::Indexmatrix& Xd,const std::map<CH_Matrix_Classes::Integer,PSCPrimal*>& pr,double factor=1.);
    ~BlockPSCPrimal();
 
    virtual PrimalData* clone_primal_data() const;

    virtual int assign_Gram_matrix(const CH_Matrix_Classes::Matrix& P);
    
    virtual int aggregate_primal_data(const PrimalData& it,double factor=1.);

    virtual int aggregate_Gram_matrix(const CH_Matrix_Classes::Matrix& P,double factor=1.);

    CH_Matrix_Classes::Integer get_nblocks() const {return Xdim.dim();}
    CH_Matrix_Classes::Integer blockdim(CH_Matrix_Classes::Integer i) const {return Xdim(i);}
    PSCPrimal* block(CH_Matrix_Classes::Integer i) const;

    virtual int scale_primal_data(double factor);

    virtual int primal_ip(CH_Matrix_Classes::Real& value,
                          const SparseCoeffmatMatrix& A,
                          CH_Matrix_Classes::Integer column) const;

  };


}


#endif