matfile/sparseOWrapper.hh

Go to the documentation of this file.

#ifndef SPARSEOWRAPPER_HPP_
#define SPARSEOWRAPPER_HPP_

#include <cstring>
#include <vector>

#include "operator.hh"
#include "basics.hh"
#include <complex>


using namespace matfile;

namespace concepts {

class SparseOWrapper {

public:

  /*
   *Information about the matrix.
   */
  typedef ArraySparseWrapper Type;

  /*
   *\brief Constructor: Creates a sparseOWrapper by a given concepts::SparseMatrix.
   *@param sparse the matrix which should be wrapped
   */
  template<class T>
  SparseOWrapper(SparseMatrix<T>& sparse);

  /*
   *Destructor
   */
  virtual ~SparseOWrapper() {
    delete (valReal_);
    delete (conceptsCol_);
    delete (conceptsRow_);

    if (isComplex_)
      delete (valCmplx_);
  }
  ;

  /*
   *\brief Getter
   *@return \c true if the wrapped matrix has complex entries, false elsewise.
   */
  bool isComplex() const {
    return isComplex_;
  }

  /*
   *\brief Getter
   *@return \c number_of_non_zeros the number of non zero elements in the sparse matrix.
   */
  miINT32_t nnz() const {
    return nnz_;
  }

  /*
   *\brief Getter
   *@return \c row_pointer
   */
  const char *ir() const {
    return ir_;
  }

  /*
   *\brief Getter
   *@return real col vector
   */
  const char *jc() const {
    return jc_;
  }

  /*
   *Size: sets the value of rows on number of Rows and the value of cols on the number of cols.
   *@param rows pointer which will point on an miINT32 (kind of int), the number of rows.
   *@param cols pointer which will point on an miINT32 (kind of int), the number of colums.
   */
  void size(miINT32_t& rows, miINT32_t& cols) const {
    rows = rows_;
    cols = cols_;
  }

  const MATtype realType() const {
    return type_;
  }

  const MATtype imagType() const {
    return type_;
  }

  const char *pr() const {
    return pr_;
  }

  const char *pi() const {
    return pi_;
  }

private:

  bool isComplex_;

  //Number of rows, colums, nnz_
  miINT32_t rows_, cols_, nnz_;

  //Row and Colums CCS format
  const char *ir_, *jc_;

  //Data real and imaginär
  const char *pr_, *pi_;

  //Benoetigt Concepts CCS
  double *valReal_, *valCmplx_;
  int *conceptsCol_, *conceptsRow_;

  MATtype type_;
};

template<class T>
SparseOWrapper::SparseOWrapper(SparseMatrix<T>& matrix) {
  isComplex_ = (NumTraits<T>::isComplex == 1);
  rows_ = matrix.dimX();
  cols_ = matrix.dimY();
  nnz_ = 0; //matrix.used();

  //we need that because concepts::sparseMatrix does not have a nnz function
  typename concepts::SparseMatrix<T>::iterator iter = matrix.begin();
  for (; iter != matrix.end(); ++iter)
    ++nnz_;

  type_ = NumTraits<T>::MatType;

  if (!isComplex_) {

    const SparseMatrix<Real>* mat =
        dynamic_cast<const SparseMatrix<Real>*> (&matrix);

    //if case add to fix a bug that occures if
    //empty sparse matrices have been stored
    if (nnz_ == 0) {
      nnz_ = 1;
      valReal_ = new double[nnz_];
      valReal_[0] = 0;
      valCmplx_ = NULL;
      conceptsRow_ = new int[nnz_];
      conceptsRow_[0] = 0;
      conceptsCol_ = new int[cols_ + 1];
      conceptsCol_[0] = 0;
      for (int i = 1; i <= cols_; ++i)
        conceptsCol_[i] = 1;
    } else {

      valReal_ = new double[nnz_];
      valCmplx_ = NULL;
      conceptsRow_ = new int[nnz_];
      conceptsCol_ = new int[cols_ + 1];

      // Erstelle CCS Format und schreibe die Daten in matfile format
      mat->convertCCS(valReal_, conceptsRow_, conceptsCol_);
    }
    ir_ = reinterpret_cast<const char*> (conceptsRow_);
    jc_ = reinterpret_cast<const char*> (conceptsCol_);
    pr_ = reinterpret_cast<const char*> (valReal_);
    pi_ = NULL;

  } else {

    const SparseMatrix<Cmplx>* mat =
        dynamic_cast<const SparseMatrix<Cmplx>*> (&matrix);

    if (nnz_ == 0) {
      nnz_ = 1;
      valReal_ = new double[nnz_];
      valReal_[0] = 0;
      valCmplx_ = new double[nnz_];
      valCmplx_[0] = 0;
      conceptsRow_ = new int[nnz_];
      conceptsRow_[0] = 0;
      conceptsCol_ = new int[cols_ + 1];
      conceptsCol_[0] = 0;
      for (int i = 1; i <= cols_; ++i)
        conceptsCol_[i] = 1;
    } else {

      // C arrays for CCS format.
      std::complex<double> *val = new std::complex<double>[nnz_];
      conceptsCol_ = new int[cols_ + 1];
      conceptsRow_ = new int[nnz_];
      valReal_ = new double[nnz_];
      valCmplx_ = new double[nnz_];

      mat->convertCCS(val, conceptsRow_, conceptsCol_);

      //Copy all that stuff is not the work of a wrapper , probobly change methods in CCS Convertable
      for (int i = 0; i < nnz_; ++i) {
        valReal_[i] = val[i].real();
        valCmplx_[i] = val[i].imag();
      }

      //Val will never be used again
      delete (val);
    }

      ir_ = reinterpret_cast<const char*> (conceptsRow_);
      jc_ = reinterpret_cast<const char*> (conceptsCol_);
      pr_ = reinterpret_cast<const char*> (valReal_);
      pi_ = reinterpret_cast<const char*> (valCmplx_);
    }

  }

  //SparseOWrapper::~SparseOWrapper(){


  //}

}//End namespace Concepts
#endif