matfile/matfileInput.hh

Go to the documentation of this file.

#ifndef matfileinput_hh
#define matfileinput_hh

#include <sys/time.h>
#include "operator.hh"
//This have to be included, programmed when it was locally saved.
#include "matfile_concepts/Input"
#include "sparseIWrapper.hh"
#include "denseIWrapper.hh"
#include <typeinfo>

using namespace matfile;


namespace concepts{

  class MatfileInput {    
  public:
    MatfileInput(){
    idevice_=0;
    }

    
    
    MatfileInput(const std::string filename){
      idevice_= new matfile::InputDevice(matfileEnding_(filename.c_str()));
    }

    virtual ~MatfileInput(){
     delete(idevice_);
  }

 

    void openMatfileI(const std::string filename){
      delete(idevice_);
      idevice_ = new matfile::InputDevice( matfileEnding_(filename.c_str()) );
   }

     
  template<class T>
  concepts::SparseMatrix<T>* getSparse(const std::string matname){

     //Also tests for existence of matname-Matrix
    MatrixInfo minfo = (*idevice_)[matname];
    
    //test if datatypes does not fit or structure differs,  6 is matfile's "denseMatrix"
    if (   ( minfo.isComplex() && typeid(T)==typeid(concepts::Real) )
        || (!minfo.isComplex() && typeid(T)==typeid(concepts::Cmplx))
  || ( minfo.getClass() == 6)
       )
      return NULL;
    
    uint dim[2] = { minfo.getDimensions()[0], minfo.getDimensions()[1] };
   
    //CCS Format get by Wrapper
    concepts::Array<T> val;
    concepts::Array<miUINT32_t> col_ptr, row;
    
    SparseIWrapper<T> wrapper_sparse(val, col_ptr, row); 
    MatfileInput::idevice_->readArray(matname.c_str(), wrapper_sparse);
    wrapper_sparse.get_matrix();
    
    //CCS to SparseMatrix
   
    SparseMatrix<T>*
      matrix = new concepts::SparseMatrix<T>(dim[0],col_ptr.size()-1);
    const T* iv = (const T*)val;
    const miUINT32_t* ir =  (const miUINT32_t*)row;
    const miUINT32_t* ic =  (const miUINT32_t*)col_ptr;

    for(uint j = 0; j < col_ptr.size()-1; ++j)
      for(uint k = *ic++; k < *ic; ++k)
        (*matrix)(*ir++,j)=*iv++;
      
    return matrix;
   
  }
  

  template<class T>
  concepts::DenseMatrix<T>* getDense(const std::string matname) {
    // Also tests for existence of matname-Matrix
    MatrixInfo minfo = (*idevice_)[matname];
    
    
      //test if datatypes does not fit or structure differs,  5 is matfile's "SparseMatrix"
    if (   ( minfo.isComplex() && typeid(T)==typeid(concepts::Real) )
        || (!minfo.isComplex() && typeid(T)==typeid(concepts::Cmplx))
  || ( minfo.getClass() == 5)
       )
      return NULL;
    
    
    uint dim[2] = { minfo.getDimensions()[0], minfo.getDimensions()[1] };
    
    // Creating DenseMatrix with Wrapper
    concepts::DenseMatrix<T>* 
      matrix = new concepts::DenseMatrix<T>(dim[0], dim[1], true);
    DenseIWrapper<T>  wrapper_dense(*matrix);
    idevice_->readArray(matname.c_str(),wrapper_dense);
    wrapper_dense.get_matrix();   
    return matrix;
  }

  private:
    std::string matfileEnding_(const std::string& filename) {
      uint size = filename.size();
      if (size < 4 || std::string(filename, size - 4, 4) != ".mat")
        return (filename + ".mat");
      return filename;
    }
  
    matfile::InputDevice* idevice_;
  };

} // namespace concepts

#endif