MatrixTraits.h

#ifndef _theplu_yat_utility_expression_matrix_traits
#define _theplu_yat_utility_expression_matrix_traits

// $Id: MatrixTraits.h 3999 2020-10-08 23:22:32Z peter $

/*
  Copyright (C) 2020 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 "ScaledMatrix.h"
#include "TransposedMatrix.h"

#include "yat/utility/BasicMatrix.h"
#include "yat/utility/MatrixExpression.h"

#include <gsl/gsl_blas_types.h>
#include <gsl/gsl_cblas.h>

namespace theplu {
namespace yat {
namespace utility {


  namespace expression {

    // A class that is used to de-couple a BasicMatrix<T> into a
    // scalar factor, transpose flag and the underlying matrix.
    template<class MATRIX>
    class MatrixTraits
    {
    public:
      typedef MATRIX base_type;
      double factor(const MATRIX&) const { return 1.0; }
      CBLAS_TRANSPOSE_t transpose_type(void) const { return CblasNoTrans; }
      const gsl_matrix* get_gsl_matrix_p(const MATRIX& m) const
      { return m.gsl_matrix_p(); }
    private:
    };


    // Specialization for ScaledMatrix<Derived>
    //
    // To allow unfolding of multiple layers of Scaled and Transposed
    // Matrix, all functions are calculated using
    // MatrixTraits<Derived>.
    //
    // ScaledMatrix only affects the scale factor so all functions
    // calls MatrixTraits<Derived> directly expect ::factor(void),
    // which multiplies with ScaledMatrix<Derived>::factor
    template<class Derived>
    class MatrixTraits<BasicMatrix<MatrixExpression<ScaledMatrix<Derived> > > >
    {
    public:
      typedef BasicMatrix<MatrixExpression<ScaledMatrix<Derived> > > MATRIX;

      double factor(const MATRIX& m) const
      {
        return static_cast<const ScaledMatrix<Derived>&>(m).factor() *
          sub_traits_.factor(base(m));
      }


      CBLAS_TRANSPOSE_t transpose_type(void) const
      {
        return sub_traits_.transpose_type();
      }


      const gsl_matrix* get_gsl_matrix_p(const MATRIX& m) const
      {
        return sub_traits_.get_gsl_matrix_p(base(m));
      }
    private:
      const Derived& base(const MATRIX& m) const
      { return static_cast<const ScaledMatrix<Derived>&>(m).base(); }
      MatrixTraits<Derived> sub_traits_;
    };


    // Specialization for TransposedMatrix
    //
    // To allow unfolding of multiple layers of Scaled and Transposed
    // Matrix, all functions are calculated using
    // MatrixTraits<Derived>.
    //
    // TransposedMatrix only affects the transpose flasg so all
    // functions calls MatrixTraits<Derived> directly, expect
    // ::transpose_type(void), which "negates" the value.
    template<class Derived>
    class MatrixTraits<BasicMatrix<MatrixExpression<TransposedMatrix<Derived> > > >
    {
    public:
      typedef BasicMatrix<MatrixExpression<TransposedMatrix<Derived> > > MATRIX;
      double factor(const MATRIX& m) const
      { return sub_traits_.factor(base(m)); }


      CBLAS_TRANSPOSE_t transpose_type(void) const
      {
        return sub_traits_.transpose_type() == CblasNoTrans ?
          CblasTrans : CblasNoTrans;
      }


      const gsl_matrix* get_gsl_matrix_p(const MATRIX& m) const
      { return sub_traits_.get_gsl_matrix_p(base(m)); }

    private:
      const Derived& base(const MATRIX& m) const
      { return static_cast<const TransposedMatrix<Derived>&>(m).base(); }
      MatrixTraits<Derived> sub_traits_;
    };

  }


}}} // end of namespace expression, utility, yat and theplu
#endif