source: trunk/yat/utility/vector.cc @ 714

// $Id: vector.cc 714 2006-12-22 00:10:54Z jari $

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

  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 "vector.h"
#include "matrix.h"
#include "stl_utility.h"
#include "utility.h"

#include <iostream>
#include <sstream>
#include <vector>
#include <utility>

namespace theplu {
namespace yat {
namespace utility {


  vector::vector(void)
    : v_(NULL), v_const_(NULL), view_(NULL), view_const_(NULL), proxy_v_(NULL)
  {
  }


  vector::vector(size_t n, double init_value)
    : v_(gsl_vector_alloc(n)), v_const_(NULL), view_(NULL), view_const_(NULL),
      proxy_v_(v_)
  {
    set_all(init_value);
  }


  vector::vector(const vector& other)
    : v_(other.create_gsl_vector_copy()), v_const_(NULL), view_(NULL),
      view_const_(NULL), proxy_v_(v_)
  {
  }


  vector::vector(vector& v, size_t offset, size_t n, size_t stride)
    : v_const_(NULL), view_const_(NULL)
  {
    // Jari, exception handling needed here. Failure in setting up a
    // proper gsl_vector_view is communicated by NULL pointer in the
    // view structure (cf. GSL manual). How about GSL error state?
    view_ = new gsl_vector_view(gsl_vector_subvector_with_stride(v.v_,offset,
                                                                 stride,n));
    proxy_v_ = v_ = &(view_->vector);
  }


  vector::vector(const vector& v, size_t offset, size_t n, size_t stride)
    : v_(NULL), view_(NULL)
  {
    // Jari, exception handling needed here. Failure in setting up a
    // proper gsl_vector_view is communicated by NULL pointer in the
    // view structure (cf. GSL manual). How about GSL error state?
    view_const_ = new gsl_vector_const_view(
                   gsl_vector_const_subvector_with_stride(v.v_,offset,stride,n));
    proxy_v_ = v_const_ = &(view_const_->vector);
  }


  vector::vector(matrix& m, size_t i, bool row)
    : v_const_(NULL), view_const_(NULL)
  {
    view_=new gsl_vector_view(row ?
                              gsl_matrix_row   (m.gsl_matrix_p(),i) :
                              gsl_matrix_column(m.gsl_matrix_p(),i)  );
    proxy_v_ = v_ = &(view_->vector);
  }


  vector::vector(const matrix& m, size_t i, bool row)
    : v_(NULL), view_(NULL)
  {
    view_const_ = new gsl_vector_const_view(row ?
                                   gsl_matrix_const_row   (m.gsl_matrix_p(),i) :
                                   gsl_matrix_const_column(m.gsl_matrix_p(),i) );
    proxy_v_ = v_const_ = &(view_const_->vector);
  }


  vector::vector(std::istream& is, char sep)
    throw (utility::IO_error, std::exception)
    : v_const_(NULL), view_(NULL), view_const_(NULL)
  {
    // 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')) {
      // 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 an integer." << 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 (nof_rows && (nof_columns>1)) {
        std::ostringstream s;
        s << "vector::vector(std::istream&) data file error:\n"
          << "    File has inconsistent number of rows (" << nof_rows
          << ") and columns (" << nof_columns
          << ").\n    Expected a row or a column vector.";
        throw utility::IO_error(s.str());
      }
      else if (v.size()!=nof_columns) {
        std::ostringstream s;
        s << "vector::vector(std::istream&) data file error:\n"
          << "    Line " << nof_rows << " has " << v.size()
          << " columns; expected " << nof_columns << " column.";
        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 vector
    proxy_v_ = v_ = gsl_vector_alloc(nof_rows*nof_columns);
    size_t n=0;
    for (size_t i=0; i<nof_rows; i++)
      for (size_t j=0; j<nof_columns; j++) 
        gsl_vector_set( v_, n++, data_matrix[i][j] );
  }


  vector::~vector(void)
  {
    if (view_)
      delete view_;
    else if (view_const_)
      delete view_const_;
    else if (v_)
      gsl_vector_free(v_);
  }


  int vector::add(const vector& other)
  {
    return gsl_vector_add(v_,other.v_);
  }


  int vector::add(double term)
  {
    return gsl_vector_add_constant(v_,term);
  }


  gsl_vector* vector::create_gsl_vector_copy(void) const
  {
    gsl_vector* vec = gsl_vector_alloc(size());
    gsl_vector_memcpy(vec, proxy_v_);
    return vec;
  }


  int vector::div(const vector& other)
  {
    return gsl_vector_div(v_,other.v_);
  }


  const gsl_vector* vector::gsl_vector_p(void) const
  {
    return proxy_v_;
  }


  gsl_vector* vector::gsl_vector_p(void)
  {
    return v_;
  }


  bool vector::isnull(void) const
  {
    return gsl_vector_isnull(proxy_v_);
  }


  bool vector::isview(void) const
  {
    return view_ || view_const_;
  }


  double vector::max(void) const
  {
    return gsl_vector_max(proxy_v_);
  }


  size_t vector::max_index(void) const
  {
    return gsl_vector_max_index(proxy_v_);
  }


  double vector::min(void) const
  {
    return gsl_vector_min(proxy_v_);
  }


  size_t vector::min_index(void) const
  {
    return gsl_vector_min_index(proxy_v_);
  }


  std::pair<double,double> vector::minmax(void) const
  {
    double min, max;
    gsl_vector_minmax(proxy_v_, &min, &max);
    return std::pair<double,double>(min,max);
  }


  std::pair<size_t,size_t> vector::minmax_index(void) const
  {
    size_t min_index, max_index;
    gsl_vector_minmax_index(proxy_v_, &min_index, &max_index);
    return std::pair<size_t,size_t>(min_index,max_index);
  }


  int vector::mul(const vector& other)
  {
    return gsl_vector_mul(v_,other.v_);
  }


  int vector::reverse(void)
  {
    return gsl_vector_reverse(v_);
  }


  int vector::scale(double factor)
  {
    return gsl_vector_scale(v_,factor);
  }


  int vector::set(const vector& vec)
  {
    return gsl_vector_memcpy(v_,vec.v_);
  }


  void vector::set_all(const double& value)
  {
    gsl_vector_set_all(v_,value);
  }


  void vector::set_basis(const size_t i)
  {
    gsl_vector_set_basis(v_,i);
  }


  void vector::set_zero(void)
  {
    gsl_vector_set_zero(v_);
  }


  size_t vector::size(void) const
  {
    return proxy_v_->size;
  }


  void vector::sort(void)
  {
    gsl_sort_vector(v_);
  }


  int vector::sub(const vector& other)
  {
    return gsl_vector_sub(v_,other.v_);
  }


  double vector::sum(void) const
  {
    double sum = 0;
    for (size_t i=0; i<size(); i++)
      sum += (*this)(i);
    return( sum );
  }


  int vector::swap(vector& other)
  {
    return gsl_vector_swap(v_,other.v_);
  }


  int vector::swap_elements(size_t i, size_t j)
  {
    return gsl_vector_swap_elements(v_,i,j);
  }


  double& vector::operator()(size_t i)
  {
    return *gsl_vector_ptr(v_,i);
  }


  const double& vector::operator()(size_t i) const
  {
    return *gsl_vector_const_ptr(proxy_v_,i);
  }


  double& vector::operator[](size_t i)
  {
    return *gsl_vector_ptr(v_,i);
  }


  const double& vector::operator[](size_t i) const
  {
    return *gsl_vector_const_ptr(proxy_v_,i);
  }


  bool vector::operator==(const vector& a) const
  {
    if (size()!=a.size())
      return false;
    for (size_t i=0; i<size(); ++i)
      if (gsl_vector_get(proxy_v_,i)!=a(i))
        return false;
    return true;
  }


  double vector::operator*( const vector &other ) const
  {
    double res = 0.0;;
    for ( size_t i = 0; i < size(); ++i ) 
      res += other(i) * (*this)(i);
    return res;
  }


  const vector& vector::operator=( const vector& other )
  {
    if( this != &other ) {
      if (view_)
        delete view_;
      else if (view_const_)
        delete view_const_;
      else if ( v_ )
        gsl_vector_free( v_ );
      v_const_=NULL;
      proxy_v_ = v_ = other.create_gsl_vector_copy();
    }
    return *this;
  } 


  const vector& vector::operator+=(const vector& other)
  {
    gsl_vector_add(v_,other.v_);
    return *this;
  }


  const vector& vector::operator-=(const vector& other)
  {
    gsl_vector_sub(v_,other.v_);
    return *this;
  }


  const vector& vector::operator*=(const double d)
  {
    gsl_vector_scale(v_,d);
    return *this;
  }


  std::ostream& operator<<(std::ostream& s, const vector& a)
  {
    s.setf(std::ios::dec);
    s.precision(12);
    for (size_t j = 0; j < a.size(); ++j) {
      s << a[j];
      if ( (j+1)<a.size() )
        s << s.fill();
    }
    return s;
  }

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