MatrixExpression.h

#ifndef _theplu_yat_utility_matrix_expression
#define _theplu_yat_utility_matrix_expression

// $Id: MatrixExpression.h 3656 2017-07-13 00:37:26Z 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 "BasicMatrix.h"
#include "yat_assert.h"

#include <gsl/gsl_matrix.h>

#include <cstddef>
#include <utility>

namespace theplu {
namespace yat {
namespace utility {

  template<class Derived>
  class MatrixExpression
    : public BasicMatrix<MatrixExpression<Derived> >
  {
  public:
    typedef Derived derived_type;

    MatrixExpression(void) : m_(NULL) {}

    ~MatrixExpression(void)
    {
      detail::deallocate(m_);
    }


    MatrixExpression(const MatrixExpression& other)
      : m_(NULL)
    {
      detail::copy(m_, other.m_);
    }

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

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


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


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


    void get(gsl_matrix*& m) const
    {
      static_cast<const Derived*>(this)->calculate_matrix(m);
    }


    void move(gsl_matrix*& m)
    {
      // If we already have m_, just steal it.
      if (m_) {
        YAT_ASSERT(m_ != m);
        std::swap(m_, m);
        return;
      }
      // Since *this is not supposed to be used after calling this
      // function, there is no reason to store access matrix in m_.
      get(m);
    }


    const gsl_matrix* gsl_matrix_p(void) const
    {
      if (!m_)
        this->get(m_);
      return m_;
    }



    gsl_matrix* gsl_matrix_p(void)
    {
      if (!m_)
        this->get(m_);
      return m_;
    }


  protected:
    mutable gsl_matrix* m_; // lazy eval

  private:
    // assignment not allowed
    MatrixExpression& operator=(const MatrixExpression& other);
  };

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

#endif