matfile/denseIWrapper.hh

Go to the documentation of this file.

#ifndef DENSEIWRAPPER_HH
#define DENSEIWRAPPER_HH

#include <complex>
#include <string>
#include <algorithm>

using namespace matfile;
namespace concepts {

template<class Scalar>
class DenseIWrapper
{
  
public:
  typedef ArrayDenseWrapper Type;

public:
  typedef concepts::DenseMatrix<Scalar> MatrixType;

private:
  typedef typename NumTraits<Scalar>::Real RealScalar;
  typedef std::complex<RealScalar> ComplexScalar;

private:
  bool isComplex_;
  MATtype realType_, imagType_;
  miINT32_t rows_, cols_;

private:
  MatrixType& matrix_;
  bool matrixPrepared;

private:
  std::string prCopy_, piCopy_;

public:
  DenseIWrapper(MatrixType& matrix): matrix_(matrix) { }

  void isComplex(bool isComplex) {
    isComplex_ = isComplex;
  }

  void size(const miINT32_t& rows, const miINT32_t& cols) {
    rows_ = rows; cols_ = cols;
    
     /*if(rows_==cols_)
      std::cout<< "entering" << std::endl;
    matrix_.transpose();
    */
    //matrix_.resize(rows_,cols_);
    //matrix_.resize(rows, cols, false);
  }

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

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

  byte *pr() {
    if (realType_ == NumTraits<Scalar>::MatType && NumTraits<Scalar>::isComplex == 0) {
      matrixPrepared = true;
      return reinterpret_cast<byte*>(&matrix_(0,0));
    }
    matrixPrepared = false;
    prCopy_.reserve(rows_*cols_*typeSize(realType_));
    return &prCopy_[0];
  }

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

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

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*>(&matrix_(0,0));
        for (miINT32_t i = 0; i < rows_*cols_; ++i)
          *v++ = *pr++;
      } else if (!real && isComplex_) {
        Other *pi = reinterpret_cast<Other*>(&piCopy_[0]);
        ComplexScalar *v = reinterpret_cast<ComplexScalar*>(&matrix_(0,0));
        for (miINT32_t i = 0; i < rows_*cols_; ++i)
          *v++ += ComplexScalar(0, *pi++);
      }
      return;
    }

    Other *pr = reinterpret_cast<Other*>(&prCopy_[0]);
    Scalar *v = reinterpret_cast<Scalar*>(&matrix_(0,0));
    for (miINT32_t i = 0; i < rows_*cols_; ++i)
      *v++ = *pr++;
  }

public:
  void get_matrix() {
    if (matrixPrepared)
      return /* matrix_ */;

    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 //DENSEIWRAPPER_HH