source: trunk/yat/utility/Vector.cc @ 3743

// $Id: Vector.cc 3743 2018-07-12 00:43:25Z peter $

/*
  Copyright (C) 2003 Daniel Dalevi, Peter Johansson
  Copyright (C) 2004 Jari Häkkinen, Peter Johansson
  Copyright (C) 2005, 2006, 2007 Jari Häkkinen, Peter Johansson, Markus Ringnér
  Copyright (C) 2008 Jari Häkkinen, Peter Johansson
  Copyright (C) 2009, 2010, 2012, 2014, 2017, 2018 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 <config.h>

#include "Vector.h"
#include "utility.h"

#include <algorithm>
#include <cassert>
#include <cmath>
#include <iostream>
#include <string>
#include <sstream>
#include <utility>
#include <vector>

namespace theplu {
namespace yat {
namespace utility {


  Vector::Vector(void)
    : VectorMutable()
  {
  }


  Vector::Vector(size_t n, double init_value)
    : VectorMutable(detail::create_gsl_vector(n, init_value))
  {
    assert(n==0 || vec_);
    assert(n==0 || const_vec_);
  }


  Vector::Vector(const Vector& other)
    : VectorMutable(create_gsl_vector_copy(other))
  {
  }


#ifdef YAT_HAVE_RVALUE
  Vector::Vector(Vector&& other) noexcept
    : VectorMutable(other.vec_)
  {
    other.vec_ = NULL;
    other.const_vec_ = NULL;
  }
#endif


  Vector::Vector(const VectorBase& other)
    : VectorMutable(create_gsl_vector_copy(other))
  {
  }


  Vector::Vector(std::istream& is, char sep)
    throw (utility::IO_error, std::exception)
    : VectorMutable()
  {
    if (!is.good())
      throw utility::IO_error("Vector: istream is not good");

    // read the data file and store in stl vectors (dynamically
    // expandable)
    std::vector<std::vector<double> > data_matrix;
    try {
      load(is, data_matrix, sep, '\n', true);
    }
    catch (utility::IO_error& e) {
      std::stringstream ss(e.what());
      ss << "\nVector(std::istream&): invalid dimensions\n";
      throw IO_error(ss.str());
    }
    catch (runtime_error& e) {
      std::stringstream ss(e.what());
      ss << "\nVector(std::istream&): invalid vector element\n";
      throw IO_error(ss.str());
    }

    unsigned int nof_rows = data_matrix.size();
    // if stream was empty, create nothing
    if (!nof_rows)
      return;

    unsigned int nof_columns=data_matrix[0].size();

    if (!(nof_rows==1 || nof_columns==1)) {
      std::stringstream ss;
      ss << "\nVector(std::istream&) data file error:\n"
         << "    File has inconsistent number of rows (" << nof_rows
         << ") and columns (" << nof_columns
         << ").\n    Expected a row or column Vector.";
      throw IO_error(ss.str());
    }

    // convert the data to a gsl vector
    vec_ = detail::create_gsl_vector(nof_rows*nof_columns);
    size_t n=0;
    // 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_vector_set( vec_, n++, data_matrix[i][j] );
    const_vec_ = vec_;
  }


  Vector::~Vector(void)
  {
    delete_allocated_memory();
  }


  const Vector& Vector::assign(const gsl_vector* other)
  {
    // empty rhs
    if (other == NULL) {
      delete_allocated_memory();
      return *this;
    }

    if (size() != other->size) {
      gsl_vector* tmp = detail::create_gsl_vector_copy(other);
      // delete memory once we know created copy did not fail
      delete_allocated_memory();
      vec_ = tmp;
    }
    else { // same size, no allocation needed
      if (gsl_vector_memcpy(vec_, other))
        throw utility::GSL_error("Vector::assign memcpy failed");
    }

    const_vec_ = vec_;
    return *this;
  }


  const Vector& Vector::assign(const VectorBase& other)
  {
    // avoid self assignment
    if (this == &other)
      return *this;
    return assign(other.gsl_vector_p());
  }


  gsl_vector* Vector::create_gsl_vector_copy(const VectorBase& other) const
  {
    return detail::create_gsl_vector_copy(other.gsl_vector_p());
  }


  void Vector::delete_allocated_memory(void)
  {
    if (vec_)
      gsl_vector_free(vec_);
    const_vec_ = vec_ = NULL;
  }


  bool Vector::isview(void) const
  {
    return false;
  }


  void Vector::resize(size_t n, double init_value)
  {
    if (size() == n) {
      all(init_value);
      return;
    }
    if (!n) {
      delete_allocated_memory();
      return;
    }
    gsl_vector* tmp = detail::create_gsl_vector(n, init_value);
    delete_allocated_memory();
    const_vec_ = vec_ = tmp;
  }


  void swap(Vector& v, Vector& w)
  {
    assert(v.gsl_vector_p()); assert(w.gsl_vector_p());
    int status=gsl_vector_swap(v.gsl_vector_p(),w.gsl_vector_p());
    if (status)
      throw utility::GSL_error("swap(Vector&,Vector&)",status);
  }


  const Vector& Vector::operator=( const VectorBase& other )
  {
    return assign(other);
  }


  const Vector& Vector::operator=( const Vector& other )
  {
    return assign(other);
  }


#ifdef YAT_HAVE_RVALUE
  Vector& Vector::operator=(Vector&& other )
  {
    std::swap(vec_, other.vec_);
    std::swap(const_vec_, other.const_vec_);
    return *this;
  }
#endif


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