MatrixMutable.h

#ifndef _theplu_yat_utility_matrix_mutable_
#define _theplu_yat_utility_matrix_mutable_

// $Id: MatrixMutable.h 4207 2022-08-26 04:36:28Z peter $

/*
  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, 2008, 2009 Jari Häkkinen, Peter Johansson
  Copyright (C) 2012, 2017, 2018, 2019, 2020, 2021, 2022 Peter Johansson

  This file is part of the yat library, https://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 <https://www.gnu.org/licenses/>.
*/

#include "Exception.h"
#include "MatrixBase.h"
#include "MatrixExpression.h"
#include "StrideIterator.h"
#include "Vector.h"
#include "VectorExpression.h"
#include "VectorView.h"
#include "yat_assert.h"

#include <gsl/gsl_matrix.h>

#include <cstddef> // size_t
#include <iosfwd>

namespace theplu {
namespace yat {
namespace utility {

  class VectorBase;

  namespace detail {
    class Mover;
  }

  class MatrixMutable : public MatrixBase
  {
  public:
    typedef double& reference;

    typedef Container2DIterator<MatrixMutable, double, double&> iterator;

    typedef StrideIterator<double*> column_iterator;

    typedef StrideIterator<double*> row_iterator;

    MatrixMutable(void);

    MatrixMutable(const MatrixMutable&) = delete;

    virtual ~MatrixMutable(void);

    void all(const double value);

    using MatrixBase::begin;
    using MatrixBase::begin_column;
    using MatrixBase::begin_row;

    iterator begin(void);

    column_iterator begin_column(size_t i);

    row_iterator begin_row(size_t i);

    VectorView column_view(size_t i);

    void div(const MatrixBase& b);

    using MatrixBase::end;
    using MatrixBase::end_column;
    using MatrixBase::end_row;

    iterator end(void);

    column_iterator end_column(size_t i);

    row_iterator end_row(size_t i);

    using MatrixBase::gsl_matrix_p;

    virtual gsl_matrix* gsl_matrix_p(void)=0;

    virtual const gsl_matrix* gsl_matrix_p(void) const=0;

    void mul(const MatrixBase& b);

    VectorView row_view(size_t);

    void swap_columns(const size_t i,const size_t j);

    void swap_rowcol(const size_t i,const size_t j);

    void swap_rows(const size_t i, const size_t j);

    double& operator()(size_t row,size_t column);

    // to allow overload from base class
    using MatrixBase::operator();

    MatrixMutable& operator=(const MatrixMutable& other);

    MatrixMutable& operator=(const MatrixBase& other);

    template<class T>
    MatrixMutable& operator=(const MatrixExpression<T>& rhs)
    {
      rhs.move(blas_result_);
      move_assign(std::move(blas_result_));
      return *this;
    }


    MatrixMutable& operator=(MatrixMutable&& other);

    template<class T>
    MatrixMutable& operator=(MatrixExpression<T>&& rhs)
    {
      // This function steals data from rhs into this, and give the old
      // m_ in return to rhs so destructor of rhs takes care of
      // deallocation.

      rhs.move(blas_result_);
      move_assign(std::move(blas_result_));
      return *this;
    }

    const MatrixMutable& operator+=(const MatrixBase& b);

    template<class T>
    MatrixMutable& operator+=(const MatrixExpression<T>& rhs)
    {
      *this = *this + rhs;
      return *this;
    }

    const MatrixMutable& operator+=(const double d);

    const MatrixMutable& operator-=(const MatrixBase&);

    template<class T>
    MatrixMutable& operator-=(const MatrixExpression<T>& rhs)
    {
      *this = *this - rhs;
      return *this;
    }

    const MatrixMutable& operator-=(const double d);

    const MatrixMutable& operator*=(double d);

  protected:
    gsl_matrix* blas_result_;

    void copy_assign(const MatrixBase& other);

    virtual void copy_assign(const gsl_matrix* rhs)=0;

    virtual void move_assign(MatrixMutable&& other);

    virtual void move_assign(gsl_matrix*&& rhs)=0;
  private:
    friend class detail::Mover;
    virtual void visit(detail::Mover& mover);
  };

  void swap(MatrixMutable&, MatrixMutable&);

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

#endif