source: trunk/yat/utility/matrix.cc @ 755

// $Id: matrix.cc 755 2007-02-18 00:01:39Z jari $

/*
  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 Jari Häkkinen

  This file is part of the yat library, http://lev.thep.lu.se/trac/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 2 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 this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  02111-1307, USA.
*/

#include "matrix.h"
#include "vector.h"
#include "utility.h"

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

#include <gsl/gsl_blas.h>

namespace theplu {
namespace yat {
namespace utility {


  matrix::matrix(void)
    : m_(NULL), view_(NULL)
  {
  }


  matrix::matrix(const size_t& r, const size_t& c, double init_value)
    : m_(gsl_matrix_alloc(r,c)), view_(NULL)
  {
    if (!m_)
      throw utility::GSL_error("matrix::matrix failed to allocate memory");
    set_all(init_value);
  }


  matrix::matrix(const matrix& o)
    : m_(o.create_gsl_matrix_copy()), view_(NULL)
  {
  }


  matrix::matrix(matrix& m, size_t offset_row, size_t offset_column,
                 size_t n_row, size_t n_column)
  {
    view_ = new gsl_matrix_view(gsl_matrix_submatrix(m.m_,
                                                     offset_row,offset_column,
                                                     n_row,n_column));
    if (!view_)
      throw utility::GSL_error("matrix::matrix failed to setup view");
    m_ = &(view_->matrix);
  }


  // Constructor that gets data from istream
  matrix::matrix(std::istream& is, char sep) 
    throw (utility::IO_error,std::exception)
    : view_(NULL)
  {
    // Markus to Jari, somewhere we should check that quiet_NaNs are supported
    // std::numeric_limits<double>::has_quiet_NaN has to be true.
    // Also in vector

    // read the data file and store in stl vectors (dynamically
    // expandable)
    std::vector<std::vector<double> > data_matrix;
    u_int nof_columns=0;
    u_int nof_rows = 0;
    std::string line;
    while(getline(is, line, '\n')){
      // Ignoring empty lines
      if (!line.size()) {
        continue;
      }
      nof_rows++;
      std::vector<double> v;
      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(utility::is_double(element)) {
          v.push_back(atof(element.c_str()));
        }
        else if (!element.size() || utility::is_nan(element)) {
          v.push_back(std::numeric_limits<double>::quiet_NaN());
        }
        else {
          // Jari, this should be communicated with as an exception.
          std::cerr << "Warning: '" << element 
                    << "' is not accepted as a matrix element." << std::endl;
        }
      }           
      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());
      }
      data_matrix.push_back(v);
    }

    // manipulate the state of the stream to be good
    is.clear(std::ios::goodbit);
    // 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(u_int i=0;i<nof_rows;i++)
      for(u_int j=0;j<nof_columns;j++)
        gsl_matrix_set( m_, i, j, data_matrix[i][j] );
  }


  matrix::~matrix(void)
  {
    if (view_)
      delete view_;
    else if (m_)
      gsl_matrix_free(m_);
    m_=NULL;
  }


  void matrix::add(const matrix& b)
  {
    int status=gsl_matrix_add(m_, b.m_);
    if (status)
      throw utility::GSL_error(std::string("matrix::add",status));
  }


  void matrix::add(double d)
  {
    gsl_matrix_add_constant(m_, d);
  }


  size_t matrix::columns(void) const
  {
    if (!m_)
      return 0;
    return m_->size2;
  }


  gsl_matrix* matrix::create_gsl_matrix_copy(void) const
  {
    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::div_elements(const matrix& b)
  {
    int status=gsl_matrix_div_elements(m_, b.m_);
    if (status)
      throw utility::GSL_error(std::string("matrix::div_elements",status));
  }


  bool matrix::equal(const matrix& other, const double d) const
  {
    if (columns()!=other.columns() || rows()!=other.rows())
      return false;
    for (size_t i=0; i<rows(); i++)
      for (size_t j=0; j<columns(); j++)
        // The two last condition checks are needed for NaN detection
        if (fabs( (*this)(i,j)-other(i,j) ) > d ||
            (*this)(i,j)!=(*this)(i,j) || other(i,j)!=other(i,j))
          return false;
    return true;
  }


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


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


  bool matrix::isnull(void) const
  {
    return gsl_matrix_isnull(m_);
  }


  bool matrix::isview(void) const
  {
    return view_;
  }


  double matrix::max(void) const
  {
    return gsl_matrix_max(m_);
  }


  double matrix::min(void) const
  {
    return gsl_matrix_min(m_);
  }


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


  bool matrix::nan(matrix &m) const
  {
    m=matrix(rows(),columns(),1.0);
    bool nan=false;
    for (size_t i=0; i<rows(); i++)
      for (size_t j=0; j<columns(); j++) 
        if (std::isnan(operator()(i,j))) {
          m(i,j)=0;
          nan=true;
        }
    return nan;
  }


  void matrix::mul_elements(const matrix& b)
  {
    int status=gsl_matrix_mul_elements(m_, b.m_);
    if (status)
      throw utility::GSL_error(std::string("matrix::mul_elements",status));
    
  }


  size_t matrix::rows(void) const
  {
    if (!m_)
      return 0;
    return m_->size1;
  }


  void matrix::scale(const double d)
  {
    gsl_matrix_scale(m_, d);
  }


  void matrix::set(const matrix& mat)
  {
    if (gsl_matrix_memcpy(m_, mat.m_))
      throw utility::GSL_error("matrix::create_gsl_matrix_copy dimension mis-match");
  }


  void matrix::set_all(const double value)
  {
    gsl_matrix_set_all(m_, value);
  }


  void matrix::set_column(const size_t column, const vector& vec)
  {
    int status=gsl_matrix_set_col(m_, column, vec.gsl_vector_p());
    if (status)
      throw utility::GSL_error(std::string("matrix::set_column",status));
  }


  void matrix::set_row(const size_t row, const vector& vec)
  {
    int status=gsl_matrix_set_row(m_, row, vec.gsl_vector_p());
    if (status)
      throw utility::GSL_error(std::string("matrix::set_row",status));
  }


  void matrix::sub(const matrix& b)
  {
    int status=gsl_matrix_sub(m_, b.m_);
    if (status)
      throw utility::GSL_error(std::string("matrix::sub",status));
  }


  void matrix::swap(matrix& other)
  {
    int status=gsl_matrix_swap(m_, other.m_);
    if (status)
      throw utility::GSL_error(std::string("matrix::swap",status));
  }


  void matrix::swap_columns(const size_t i, const size_t j)
  {
    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)
  {
    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)
  {
    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)
  {
    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;
    }
  }


  double& matrix::operator()(size_t row, size_t column)
  {
    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
  {
    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 (view_)
        delete view_;
      else if (m_)
        gsl_matrix_free(m_);
      m_ = other.create_gsl_matrix_copy();
    }
    return *this;
  }


  const matrix& matrix::operator+=(const matrix& m)
  {
    add(m);
    return *this;
  }


  const matrix& matrix::operator+=(const double d)
  {
    add(d);
    return *this;
  }


  const matrix& matrix::operator-=(const matrix& m)
  {
    sub(m);
    return *this;
  }


  const matrix& matrix::operator*=(const matrix& other)
  {
    gsl_matrix* result = gsl_matrix_alloc(rows(),other.columns());
    if (!result)
      throw utility::GSL_error("matrix::operator*= failed to allocate memory");
    gsl_blas_dgemm(CblasNoTrans, CblasNoTrans, 1.0, m_, other.m_, 0.0, result);
    gsl_matrix_free(m_);
    m_=result;
    return *this;
  }


  const matrix& matrix::operator*=(const double d)
  {
    scale(d);
    return *this;
  }


  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 vector& v)
  {
    utility::vector res(m.rows());
    for (size_t i=0; i<res.size(); ++i)
      res(i) = vector(m,i) * v;
    return res;
  }


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

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