matfile/sparseIWrapper.hh

Go to the documentation of this file.

#ifndef SPARSEIWRAPPER_HH
#define SPARSEIWRAPPER_HH

#include <complex>
#include "toolbox.hh"


#ifndef MATFILE_PROCESSED_BY_DOXYGEN
using namespace matfile;
namespace concepts {
#endif

template<class Scalar>
class SparseIWrapper
{

// Part 1: mandatory public typedef
public:
  typedef ArraySparseWrapper Type;

// Part 2: matrix typedef
public:
  typedef
    concepts::SparseMatrix<Scalar>  MatrixType;
    concepts::Array<Scalar> ValType;
    concepts::Array<miUINT32_t> CoordType;
    


// Part 3: internal scalar typedefs
private:
  typedef typename NumTraits<Scalar>::Real RealScalar;
  typedef std::complex<RealScalar> ComplexScalar;


// Part 4: matrix informations
private:
  bool isComplex_;
  miUINT32_t nnz_; //miUINT32_t
  miUINT32_t cols_;
  miUINT32_t rows_;
  MATtype realType_, imagType_;


// Part 5: other internal informations
private:
  
  
  concepts::Array<Scalar>& CCSval_;
  concepts::Array<miUINT32_t>& CCScol_;
  concepts::Array<miUINT32_t>& CCSrow_;
  //concepts::Array<miUINT32_t>& dimX_;
  
  bool matrixReady_;
  std::string prCopy_, piCopy_;


// Part 6: public methods
public:
  SparseIWrapper(concepts::Array<Scalar>& val, concepts::Array<miUINT32_t>& col,concepts::Array<miUINT32_t>& row)//, concepts::Array<miUINT32_t>& dimX) 
      :CCSval_(val), CCScol_(col), CCSrow_(row) {}//, dimX_(dimX){    }
  


public:
  void isComplex(bool isComplex) {
    isComplex_ = isComplex;
  }
  
  void nnz(const miUINT32_t& nnz) {
    nnz_ = nnz;
    CCSval_.resize(nnz); 
  }

  void size(const miUINT32_t& rows, const miUINT32_t& cols) {
    rows_ = rows;
    cols_ = cols;
    //dimX_.resize(1);
    //dimX_[0]=rows;
    CCScol_.resize(cols_+1);
    CCSrow_.resize(nnz_);
  }

  void name(const std::string&) { }

  miUINT32_t *ir() {  // row 
    
    return &CCSrow_[0];
  }

  miUINT32_t *jc() {  //column 
      return &CCScol_[0];
  }
  
    

  void realType(const MATtype& realType) {
    realType_ = realType;
  }

  byte *pr() {
    if (realType_ == NumTraits<Scalar>::MatType && NumTraits<Scalar>::isComplex == 0) {
      matrixReady_ = true;
      return reinterpret_cast<byte*>(&CCSval_[0]);  //CCSvalR_
    }
    matrixReady_ = false;
    
    
    prCopy_.reserve(nnz_*typeSize(realType_));
    return &prCopy_[0];
  }

  void imagType(const MATtype& imagType) {
    imagType_ = imagType;
  }

  byte *pi() {
    if (NumTraits<Scalar>::isComplex == 0)
      return NULL;
    
    piCopy_.reserve(nnz_*typeSize(imagType_));
    return &piCopy_[0];
  }

// Part 8: private internal methods
private:
  template<class Other> void copy(bool real = true) {
    if (NumTraits<Scalar>::isComplex != 0) {
      if (real) {
        Other *pr = reinterpret_cast<Other*>(&prCopy_[0]);
        ComplexScalar *v = reinterpret_cast<ComplexScalar*>(&(CCSval_[0]));  //CCSvalR_
        for (uint i = 0; i < nnz_; ++i)
          *v++ = *pr++;
      } else if (!real && isComplex_) {
        Other *pi = reinterpret_cast<Other*>(&piCopy_[0]);
        ComplexScalar *v = reinterpret_cast<ComplexScalar*>(&(CCSval_[0])); //CCSvalI_
        for (uint i = 0; i < nnz_; ++i)
          *v++ += ComplexScalar(0, *pi++);
      }
      return;
    }

    Other *pr = reinterpret_cast<Other*>(&prCopy_[0]);
    Scalar *v = reinterpret_cast<Scalar*>(&(CCSval_[0]));    //&matrix_.value_data()[0]
    for (uint i = 0; i < nnz_; ++i)
      *v++ = *pr++;   //*v++
  }





// Part 9: other public methods
public:
  void get_matrix() {
      
    if (matrixReady_){
      return;
    }
      //Real typ
    MATtype *nowCopy = &realType_;
    while (true) {
      bool real;
      if (nowCopy == &realType_)
        real = true;
      else
        real = false;

      switch(*nowCopy) {
      case miINT8:
        copy<miINT8_t>(real);
        break;
      case miUINT8:
        copy<miUINT8_t>(real);
        break;
      case miINT16:
        copy<miINT16_t>(real);
        break;
      case miUINT16:
        copy<miUINT16_t>(real);
        break;
      case miINT32:
        copy<miINT32_t>(real);
        break;
      case miUINT32:
        copy<miUINT32_t>(real);
        break;
      case miINT64:
        copy<miINT64_t>(real);
        break;
      case miUINT64:
        copy<miUINT64_t>(real);
        break;
      case miSINGLE:
        copy<miSINGLE_t>(real);
        break;
      case miDOUBLE:
        copy<miDOUBLE_t>(real);
        break;
      }

      if (real && isComplex_)
        nowCopy = &imagType_;
      else
        break;
    }
      
      return;
  }

};

}


#endif // SPARSEIWRAPPER_HH