VectorExpression.h

#ifndef _theplu_yat_utility_vector_expression
#define _theplu_yat_utility_vector_expression

// $Id: VectorExpression.h 3606 2017-01-27 05:37:37Z peter $

/*
  Copyright (C) 2017 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_public.h"

#include "BasicVector.h"
#include "MatrixExpression.h"
#include "yat_assert.h"

#include <gsl/gsl_blas.h>
#include <gsl/gsl_matrix.h>
#include <gsl/gsl_vector.h>

#include <utility>

namespace theplu {
namespace yat {
namespace utility {

  template<class Derived>
  class VectorExpression
    : public BasicVector<VectorExpression<Derived> >
  {
  public:
    typedef Derived derived_type;

    VectorExpression(void) : v_(NULL) {}

    ~VectorExpression(void)
    {
      delete_allocated_memory();
    }

    VectorExpression(const VectorExpression& other)
      : v_(NULL)
    {
      if (other.v_) {
        allocate_memory(other.size());
        if (gsl_vector_memcpy(v_, other.v_))
          throw GSL_error("VectorExpression: gsl_vector_memcpy failed");
      }
    }

#ifdef YAT_HAVE_RVALUE
    VectorExpression(VectorExpression&& other)
      : v_(NULL)
    {
      std::swap(v_, other.v_);
    }
#endif

    size_t size(void) const
    { return static_cast<const Derived*>(this)->size(); }

    double operator()(size_t i) const
    { return (*static_cast<const Derived*>(this))(i); }

    const gsl_vector* gsl_vector_p(void) const
    {
      if (!v_)
        static_cast<const Derived*>(this)->calculate_gsl_vector_p();
      return v_;
    }

    gsl_vector* gsl_vector_p(void)
    {
      if (!v_)
        static_cast<const Derived*>(this)->calculate_gsl_vector_p();
      return v_;
    }


    void gsl_vector_p(gsl_vector* v)
    {
      v_ = v;
    }

  protected:
    mutable gsl_vector* v_; // lazy eval

    void allocate_memory(size_t n) const
    {
      v_ = gsl_vector_alloc(n);
      if (!v_)
        throw GSL_error("Vector: failed to allocate memory");
    }

    void delete_allocated_memory(void)
    {
      if (v_)
        gsl_vector_free(v_);
      v_ = NULL;
    }

  private:
    // assignment not allowed
    VectorExpression& operator=(const VectorExpression& rhs);
  };


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

#endif