source: trunk/yat/utility/Matrix.cc @ 1682

// $Id: Matrix.cc 1682 2008-12-29 21:27:32Z peter $

/*
  Copyright (C) 2003 Daniel Dalevi, Peter Johansson
  Copyright (C) 2004 Jari Häkkinen, Peter Johansson
  Copyright (C) 2005, 2006 Jari Häkkinen, Peter Johansson, Markus Ringnér
  Copyright (C) 2007, 2008 Jari Häkkinen, Peter Johansson

  This file is part of the yat library, http://dev.thep.lu.se/yat

  The yat library is free software; you can redistribute it and/or
  modify it under the terms of the GNU General Public License as
  published by the Free Software Foundation; either version 3 of the
  License, or (at your option) any later version.

  The yat library 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
  General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with yat. If not, see <http://www.gnu.org/licenses/>.
*/

#include "Matrix.h"
#include "Vector.h"
#include "VectorBase.h"
#include "VectorConstView.h"
#include "VectorView.h"
#include "utility.h"

#include <cassert>
#include <cmath>
#include <sstream>
#include <vector>

#include <gsl/gsl_blas.h>

namespace theplu {
namespace yat {
namespace utility {


  Matrix::Matrix(void)
    : blas_result_(NULL), m_(NULL)
  {
  }


  Matrix::Matrix(const size_t& r, const size_t& c, double init_value)
    : blas_result_(NULL), m_(NULL)
  {
    resize(r,c,init_value);
  }


  Matrix::Matrix(const Matrix& o)
    : blas_result_(NULL), m_(o.create_gsl_matrix_copy())
  {
  }


  // Constructor that gets data from istream
  Matrix::Matrix(std::istream& is, char sep) 
    throw (utility::IO_error,std::exception)
    : blas_result_(NULL)
  {
    if (!is.good())
      throw utility::IO_error("Matrix: istream is not good");

    // read the data file and store in stl vectors (dynamically
    // expandable)
    std::vector<std::vector<double> > data_matrix;
    unsigned int nof_columns=0;
    unsigned int nof_rows = 0;
    std::string line;
    while(getline(is, line, '\n')){
      // Ignoring empty lines
      if (!line.size()) {
        continue;
      }
      nof_rows++;
      data_matrix.resize(data_matrix.size()+1);
      std::vector<double>& v=data_matrix.back();
      std::string element;
      std::stringstream ss(line);
      
      bool ok=true;
      while(ok) {
        if(sep=='\0')
          ok=(ss>>element);
        else
          ok=getline(ss, element, sep);
        if(!ok)
          break;
        
        if (!element.size())
          v.push_back(std::numeric_limits<double>::quiet_NaN());
        else {
          try {
            v.push_back(convert<double>(element));
          }
          catch (std::runtime_error& e) {
            std::stringstream ss(e.what());
            ss << "\nMatrix.cc: " << element 
               << " is not accepted as a matrix element\n";
            throw IO_error(ss.str());
          }
        }
      }           
      if(sep!='\0' && line[line.size()-1]==sep) // add NaN for final separator
          v.push_back(std::numeric_limits<double>::quiet_NaN());
      if (!nof_columns)
        nof_columns=v.size();
      else if (v.size()!=nof_columns) {
        std::ostringstream s;
        s << "Matrix::Matrix(std::istream&, char) data file error: "
          << "line " << nof_rows << " has " << v.size()
          << " columns; expected " << nof_columns << " columns.";
        throw utility::IO_error(s.str());
      }
    }

    // manipulate the state of the stream to be good
    is.clear(std::ios::goodbit);
    
    // if stream was empty, create nothing
    if (!nof_columns || !nof_rows)
      return;

    // convert the data to a gsl matrix
    m_ = gsl_matrix_alloc ( nof_rows, nof_columns );
    if (!m_)
      throw utility::GSL_error("Matrix::Matrix failed to allocate memory");

    // if gsl error handler disabled, out of bounds index will not
    // abort the program.
    for(size_t i=0;i<nof_rows;i++)
      for(size_t j=0;j<nof_columns;j++)
        gsl_matrix_set( m_, i, j, data_matrix[i][j] );
  }


  Matrix::~Matrix(void)
  {
    delete_allocated_memory();
    if (blas_result_)
      gsl_matrix_free(blas_result_);
    blas_result_=NULL;
  }


  void Matrix::all(const double value)
  {
    assert(m_);
    gsl_matrix_set_all(m_, value);
  }


  Matrix::iterator Matrix::begin(void)
  {
    return iterator(&(*this)(0,0), 1);
  }


  Matrix::const_iterator Matrix::begin(void) const
  {
    return const_iterator(&(*this)(0,0), 1);
  }


  Matrix::column_iterator Matrix::begin_column(size_t i)
  {
    return iterator(&(*this)(0,i), this->columns());
  }


  Matrix::const_column_iterator Matrix::begin_column(size_t i) const
  {
    return const_iterator(&(*this)(0,i), this->columns());
  }


  Matrix::row_iterator Matrix::begin_row(size_t i)
  {
    return iterator(&(*this)(i,0), 1);
  }


  Matrix::const_row_iterator Matrix::begin_row(size_t i) const
  {
    return const_iterator(&(*this)(i,0), 1);
  }


  VectorView Matrix::column_view(size_t col)
  {
    VectorView res(*this, col, false);
    return res;
  }


  const VectorConstView Matrix::column_const_view(size_t col) const
  {
    return VectorConstView(*this, col, false);
  }


  size_t Matrix::columns(void) const
  {
    return (m_ ? m_->size2 : 0);
  }


  gsl_matrix* Matrix::create_gsl_matrix_copy(void) const
  {
    if (!m_)
      return NULL;
    gsl_matrix* m = gsl_matrix_alloc(rows(),columns());
    if (!m)
      throw utility::GSL_error("Matrix::create_gsl_matrix_copy failed to allocate memory");
    if (gsl_matrix_memcpy(m,m_))
      throw utility::GSL_error("Matrix::create_gsl_matrix_copy dimension mis-match");
    return m;
  }


  void Matrix::delete_allocated_memory(void)
  {
    if (m_)
      gsl_matrix_free(m_);
    m_=NULL;
  }


  void Matrix::div(const Matrix& other)
  {
    assert(m_);
    int status=gsl_matrix_div_elements(m_, other.gsl_matrix_p());
    if (status)
      throw utility::GSL_error(std::string("matrix::div_elements",status));
  }


  Matrix::iterator Matrix::end(void)
  {
    return iterator(&(*this)(0,0)+rows()*columns(), 1);
  }


  Matrix::const_iterator Matrix::end(void) const
  {
    return const_iterator(&(*this)(0,0)+rows()*columns(), 1);
  }


  Matrix::column_iterator Matrix::end_column(size_t i)
  {
    return column_iterator(&(*this)(0,i)+rows()*columns(), this->columns());
  }


  Matrix::const_column_iterator Matrix::end_column(size_t i) const
  {
    return const_column_iterator(&(*this)(0,i)+rows()*columns(),this->columns());
  }


  Matrix::row_iterator Matrix::end_row(size_t i)
  {
    return row_iterator(&(*this)(i,0)+columns(), 1);
  }


  Matrix::const_row_iterator Matrix::end_row(size_t i) const
  {
    return const_row_iterator(&(*this)(i,0)+columns(), 1);
  }


  bool Matrix::equal(const Matrix& other, const double d) const
  {
    if (this==&other)
      return true;
    if (columns()!=other.columns() || rows()!=other.rows())
      return false;
    for (size_t i=0; i<rows(); i++)
      if (!row_const_view(i).equal(other.row_const_view(i), d))
        return false;
    return true;
  }


  const gsl_matrix* Matrix::gsl_matrix_p(void) const
  {
    return m_;
  }


  gsl_matrix* Matrix::gsl_matrix_p(void)
  {
    return m_;
  }


  void Matrix::mul(const Matrix& other)
  {
    assert(m_);
    int status=gsl_matrix_mul_elements(m_, other.gsl_matrix_p());
    if (status)
      throw utility::GSL_error(std::string("Matrix::mul_elements",status));
  }


  void Matrix::resize(size_t r, size_t c, double init_value)
  {
    delete_allocated_memory();

    assert( (r&&c) || (!r&&!c) );
    if (r && c){
      m_ = gsl_matrix_alloc(r,c);
      if (!m_)
        throw utility::GSL_error("Matrix::Matrix failed to allocate memory");
      all(init_value);
    }

    // no need to delete blas_result_ if the number of rows fit, it
    // may be useful later.
    if (blas_result_ && (blas_result_->size1!=rows())) {
      gsl_matrix_free(blas_result_);
      blas_result_=NULL;
    }
  }


  size_t Matrix::rows(void) const
  {
    return (m_ ? m_->size1 : 0);
  }


  const VectorConstView Matrix::row_const_view(size_t col) const
  {
    return VectorConstView(*this, col, true);
  }


  VectorView Matrix::row_view(size_t row)
  {
    VectorView res(*this, row, true);
    return res;
  }


  void Matrix::swap_columns(const size_t i, const size_t j)
  {
    assert(m_);
    int status=gsl_matrix_swap_columns(m_, i, j);
    if (status)
      throw utility::GSL_error(std::string("Matrix::swap_columns",status));
  }


  void Matrix::swap_rowcol(const size_t i, const size_t j)
  {
    assert(m_);
    int status=gsl_matrix_swap_rowcol(m_, i, j);
    if (status)
      throw utility::GSL_error(std::string("Matrix::swap_rowcol",status));
  }


  void Matrix::swap_rows(const size_t i, const size_t j)
  {
    assert(m_);
    int status=gsl_matrix_swap_rows(m_, i, j);
    if (status)
      throw utility::GSL_error(std::string("Matrix::swap_rows",status));
  }


  void Matrix::transpose(void)
  {
    assert(m_);
    if (columns()==rows())
      gsl_matrix_transpose(m_); // this never fails
    else {
      gsl_matrix* transposed = gsl_matrix_alloc(columns(),rows());
      if (!transposed)
        throw utility::GSL_error("Matrix::transpose failed to allocate memory");
      // next line never fails if allocation above succeeded.
      gsl_matrix_transpose_memcpy(transposed,m_);
      gsl_matrix_free(m_);
      m_ = transposed;
      if (blas_result_) {
        gsl_matrix_free(blas_result_);
        blas_result_=NULL;
      }
    }
  }


  double& Matrix::operator()(size_t row, size_t column)
  {
    assert(m_);
    assert(row<rows());
    assert(column<columns());
    double* d=gsl_matrix_ptr(m_, row, column);
    if (!d)
      throw utility::GSL_error("Matrix::operator()",GSL_EINVAL);
    return *d;
  }


  const double& Matrix::operator()(size_t row, size_t column) const
  {
    assert(row<rows());
    assert(column<columns());
    const double* d=gsl_matrix_const_ptr(m_, row, column);
    if (!d)
      throw utility::GSL_error("Matrix::operator()",GSL_EINVAL);
    return *d;
  }


  bool Matrix::operator==(const Matrix& other) const
  {
    return equal(other);
  }


  bool Matrix::operator!=(const Matrix& other) const
  {
    return !equal(other);
  }


  const Matrix& Matrix::operator=( const Matrix& other )
  {
    if (this!=&other) {
      if (rows()!=other.rows() || columns()!=other.columns())
        resize(other.rows(), other.columns());
        
      if (m_)
        if (gsl_matrix_memcpy(m_, other.gsl_matrix_p())) {
          std::string s="Matrix::operator=  assignment failed";
          throw utility::GSL_error(s);
        }
    }
    return *this;
  }


  const Matrix& Matrix::operator+=(const Matrix& other)
  {
    assert(m_);
    int status=gsl_matrix_add(m_, other.m_);
    if (status)
      throw utility::GSL_error(std::string("Matrix::operator+=", status));
    return *this;
  }


  const Matrix& Matrix::operator+=(const double d)
  {
    assert(m_);
    gsl_matrix_add_constant(m_, d);
    return *this;
  }


  const Matrix& Matrix::operator-=(const Matrix& other)
  {
    assert(m_);
    int status=gsl_matrix_sub(m_, other.m_);
    if (status)
      throw utility::GSL_error(std::string("Matrix::operator-=", status));
    return *this;
  }


  const Matrix& Matrix::operator-=(const double d)
  {
    assert(m_);
    gsl_matrix_add_constant(m_, -d);
    return *this;
  }


  const Matrix& Matrix::operator*=(const Matrix& other)
  {
    assert(m_);
    if ( blas_result_ && ((blas_result_->size1!=rows()) ||
                          (blas_result_->size2!=other.columns())) ) {
      gsl_matrix_free(blas_result_);
      blas_result_=NULL;
    }
    if (!blas_result_) {
      blas_result_ = gsl_matrix_alloc(rows(),other.columns());
      if (!blas_result_)
        throw utility::GSL_error("Matrix::operator*= failed to allocate memory");
    }
    gsl_blas_dgemm(CblasNoTrans, CblasNoTrans, 1.0, m_, other.m_, 0.0, blas_result_);
    gsl_matrix* tmp=m_;
    m_ = blas_result_;
    blas_result_=tmp;
    return *this;
  }


  const Matrix& Matrix::operator*=(const double d)
  {
    assert(m_);
    gsl_matrix_scale(m_, d);
    return *this;
  }


  bool isnull(const Matrix& other)
  {
    return gsl_matrix_isnull(other.gsl_matrix_p());
  }


  double max(const Matrix& other)
  {
    return gsl_matrix_max(other.gsl_matrix_p());
  }


  double min(const Matrix& other)
  {
    return gsl_matrix_min(other.gsl_matrix_p());
  }


  void minmax_index(const Matrix& other,
                    std::pair<size_t,size_t>& min, std::pair<size_t,size_t>& max)
  {
    gsl_matrix_minmax_index(other.gsl_matrix_p(), &min.first, &min.second,
                            &max.first, &max.second);
  }


  bool nan(const Matrix& templat, Matrix& flag)
  {
    size_t rows=templat.rows();
    size_t columns=templat.columns();
    if (rows!=flag.rows() && columns!=flag.columns())
      flag.resize(rows,columns,1.0);
    else
      flag.all(1.0);
    bool nan=false;
    for (size_t i=0; i<rows; i++)
      for (size_t j=0; j<columns; j++) 
        if (std::isnan(templat(i,j))) {
          flag(i,j)=0;
          nan=true;
        }
    return nan;
  }


  void swap(Matrix& a, Matrix& b)
  {
    assert(a.gsl_matrix_p()); assert(b.gsl_matrix_p());
    int status=gsl_matrix_swap(a.gsl_matrix_p(), b.gsl_matrix_p());
    if (status)
      throw utility::GSL_error(std::string("swap(Matrix&,Matrix&)",status));
  }


  std::ostream& operator<<(std::ostream& s, const Matrix& m)
  {
    s.setf(std::ios::dec);
    s.precision(12);
    for(size_t i=0, j=0; i<m.rows(); i++)
      for (j=0; j<m.columns(); j++) {
        s << m(i,j);
        if (j<m.columns()-1)
          s << s.fill();
        else if (i<m.rows()-1)
          s << "\n";
      }
    return s;
  }


  Vector operator*(const Matrix& m, const VectorBase& v)
  {
    utility::Vector res(m.rows());
    for (size_t i=0; i<res.size(); ++i)
      res(i) = VectorConstView(m,i) * v;
    return res;
  }


  Vector operator*(const VectorBase& v, const Matrix& m)
  {
    utility::Vector res(m.columns());
    for (size_t i=0; i<res.size(); ++i)
      res(i) = v * VectorConstView(m,i,false);
    return res;
  }

}}} // of namespace utility, yat and thep