shiftedInvariant.hh

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/*                                                                             */
/*   This file is part of the C++-library RFFGen.                              */
/*   Copyright 2015 Lars Lubkoll                                               */
/*                                                                             */
/*   RFFGen 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.                                       */
/*                                                                             */
/*   RFFGen 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 RFFGen.  If not, see <http://www.gnu.org/licenses/>.           */
/*                                                                             */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

#ifndef RFFGEN_LINEAR_ALGEBRA_SHIFTED_INVARIANT_HH
#define RFFGEN_LINEAR_ALGEBRA_SHIFTED_INVARIANT_HH

#include <type_traits>

#include "../constant.hh"
#include "../Util/base.hh"
#include "../Util/derivativeWrappers.hh"
#include "../Util/evaluateIfPresent.hh"
#include "../Util/indexedType.hh"

namespace RFFGen
{
  namespace LinearAlgebra
  {
    template <class Invariant, int offset>
    class ShiftedInvariant : Base
    {
    public:
      ShiftedInvariant() = default;

      template <class Matrix>
      ShiftedInvariant(Matrix const& A) : inv(A)
      {
        update(A);
      }

      template <class Matrix>
      ShiftedInvariant(const Matrix& A, const Constant<Matrix>& M) : inv(A,M)
      {
        update(A);
      }

      template <class Matrix>
      ShiftedInvariant(const Matrix& A, const Matrix& M) : ShiftedInvariant(A,Constant<Matrix>(M))
      {}

      template <class Matrix>
      void update(Matrix const& A)
      {
        inv.update(A);
        resultOfD0 = inv.d0() - offset;
      }

      auto d0() const noexcept
      {
        return resultOfD0;
      }

      template < int id , class Arg ,
                 class IndexedArg = IndexedType<Arg,id> ,
                 class = std::enable_if_t<EvaluateIfPresent< D1<Invariant,IndexedArg> >::present> >
      auto d1(const Arg& dA1) const
      {
        return EvaluateIfPresent< D1<Invariant,IndexedArg> > ( inv, dA1 )();
      }

      template < int idx, int idy, class ArgX , class ArgY ,
                 class IndexedArgX = IndexedType<ArgX,idx> ,
                 class IndexedArgY = IndexedType<ArgY,idx> ,
                 class = std::enable_if_t<EvaluateIfPresent< D2<Invariant,IndexedArgX,IndexedArgY> >::present> >
      auto d2(const ArgX& dA1, const ArgY& dA2) const
      {
        return EvaluateIfPresent< D2<Invariant,IndexedArgX,IndexedArgY> >(inv,dA1,dA2)();
      }

      template < int idx , int idy , int idz , class ArgX , class ArgY , class ArgZ ,
                 class IndexedArgX = IndexedType<ArgX,idx> ,
                 class IndexedArgY = IndexedType<ArgY,idy> ,
                 class IndexedArgZ = IndexedType<ArgZ,idz> ,
                 class = std::enable_if_t< EvaluateIfPresent< D3<Invariant,IndexedArgX,IndexedArgY,IndexedArgZ> >::present > >
      auto d3(ArgX const& dA1, ArgY const& dA2, ArgZ const& dA3) const
      {
        return EvaluateIfPresent< D3<Invariant,IndexedArgX,IndexedArgY,IndexedArgZ> >(inv,dA1,dA2,dA3)();
      }

    private:
      Invariant inv;
      std::remove_const_t<std::remove_reference_t<decltype(std::declval<Invariant>().d0())> > resultOfD0 = 0.;
    };
  }
}

#endif // RFFGEN_LINEAR_ALGEBRA_SHIFTED_INVARIANT_HH