/home/fayn/OpenKraken-dev/OpenKN-math/src/MathIO.hpp

Go to the documentation of this file.

/***************************************************************************\
 * Copyright (C) by University Paris-Est - MISS team
 * MathIO.hpp created in 04 2009.
 * Mail : biri@univ-mlv.fr
 *
 * This file is part of the OpenKraken-math.
 *
 * The OpenKraken-math is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * The OpenKraken-math is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 *
\***************************************************************************/



/*
 * Anti-doublon
 */
#ifndef __OPENKN_MATH__MATH_IO_HPP__
#define __OPENKN_MATH__MATH_IO_HPP__

/*
 * External Includes
 */
#include <cstring>
#include <iostream>
#include <fstream>
#include <vector>

#include <sstream>

/*
 * Internal Includes
 */
#include "Matrix.hpp"
#include "MathException.hpp"

/*
 * Namespace
 */
namespace kn {

      bool readMatrixHeader(std::ifstream &matrixFile, unsigned int &row, unsigned int &column);


      template <class T>
      void exportMatrix(const Matrix<T> &M,
                        const std::string &fileName,
                        const bool &headerMode =  false,
                        const std::string &comments = ""){
          // open the file
          std::ofstream matrixFile(fileName.c_str());
          if(!matrixFile.is_open()){
             throw MathException("error opening file : " + fileName);
          }

          // write comments
          if(comments != "")
            matrixFile << "# " << comments << std::endl;

          // write header
          if(headerMode)
            matrixFile << "row " << M.rows() << std::endl
                       << "col " << M.columns() << std::endl;

          // additional line
          if(comments != "" || headerMode)
            matrixFile << std::endl;

          // write matrix content
          for (int i=0; i<M.rows(); ++i)
            {
              for (int j=0; j<M.columns(); ++j)
                  matrixFile << M[i][j] << " ";

              matrixFile << std::endl;
            }

          // close file
          matrixFile.close();
      }



      template <class T>
      void loadMatrix(Matrix<T> &M, const std::string &fileName){

          // open the file
          std::ifstream matrixFile(fileName.c_str());
          if(!matrixFile.is_open()){
             throw MathException("error opening file : " + fileName);
          }

          // read header
          unsigned int row    = 0;
          unsigned int column = 0;
          bool header = readMatrixHeader(matrixFile,row,column);

          // read the data
          if(header) readMatrixFromHeader(M,matrixFile,row,column);
          else readMatrix(M,matrixFile);

          // close
          matrixFile.close();
      }


      template <class T>
      void readMatrixFromHeader(Matrix<T> &M,
                                std::ifstream &matrixFile,
                                const unsigned int &row,
                                const unsigned int &column){
          // if the matrix is not build yet
          if(M.rows() == 0 && M.columns() == 0)
            M = Matrix<T>(row,column);

          // if the matrix is already build
          if(M.rows() != row || M.columns() != column)
            throw MathException("readMatrixFromHeader : incompatible matrix size");

          // read the matrix
          for(unsigned int i=0; i<row; ++i)
            for(unsigned int j=0; j<column; ++j)
              matrixFile >> M[i][j];
      }


      template <class T>
      void readMatrix(Matrix<T> &M, std::ifstream &matrixFile){
        unsigned int row = 0;
        int column = -1;        // unknown while you didn't read a line
        std::vector<T> content;
        std::string stringContent;

        // first read the matrix in a std::vector to check the consistency of the data
        do{ // for every line
          std::getline(matrixFile,stringContent);
          std::istringstream readContent(stringContent, std::istringstream::in);
          unsigned int index = 0;
          while(!readContent.eof()){ // for every element of a line
            T value;
            readContent >> value;
            content.push_back(value);
            index++;
          }

          // remove the eof
          content.erase(content.end()-1);
          index--;

          if(column == -1 && index != 0){   // 1st line : find 'column'
            column = index;
            row++;
          }
          else{
            if(index != 0){ // check empty line or invalid column
              if(column != index) throw MathException("readMatrix : invalid matrix file");
              else  row++;
            }
          }

        }while(!matrixFile.eof());


        // if the matrix is not build yet
        if(M.rows() == 0 && M.columns() == 0)
          M = Matrix<T>(row,column);

        // if the matrix is already build
        if(M.rows() != row || M.columns() != column)
          throw MathException("incompatible matrix size");

        // copy the data
        std::copy(content.begin(), content.end(), M.begin());
      }


  /*
   * End of Namespace
   */
}


/*
 * End of Anti-doublon
 */
#endif

---