euclideanNorm.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_EUCLIDEAN_NORM_HH
#define RFFGEN_LINEAR_ALGEBRA_EUCLIDEAN_NORM_HH

#include <type_traits>

#include "../LinearAlgebra/extractRowsAndCols.hh"
#include "../MathematicalOperations/chain.hh"
#include "../CMath/pow.hh"
#include "../Util/staticChecks.hh"

namespace RFFGen
{
  namespace Concepts { template <class> struct MatrixConceptCheck; }
  namespace LinearAlgebra
  {
    namespace Detail
    {
      template < class Matrix , std::enable_if_t<Checks::isConstantSizeMatrix<Matrix>()> >
      inline auto computeSquareEuclideanNorm(const Matrix& A)
      {
        using Index = decltype(numberOfRows<Matrix>());
        auto result = decltype(at(A,0,0)){0.};
        for( Index i = 0; i < numberOfRows<Matrix>() ; ++i )
          for( Index j = 0 ; j < numberOfColumns<Matrix>() ; ++j )
            result += at(A,i,j) * at(A,i,j);
        return result;
      }

      template < class Vector , std::enable_if_t<Checks::isStaticVector<Vector>() && !Checks::isConstantSizeMatrix<Vector>()> >
      inline auto computeSquareEuclideanNorm(const Vector& A)
      {
        using Index = decltype(numberOfRows<Vector>());
        auto result = decltype(at(A,0)){0.};
        for( Index i = 0; i < numberOfRows<Vector>() ; ++i )
            result += at(A,i) * at(A,i);
        return result;
      }

      template < class Matrix , std::enable_if_t<Checks::isConstantSizeMatrix<Matrix>()> >
      inline auto computeEuclideanScalarProduct(const Matrix& A, const Matrix& B)
      {
        using Index = decltype(numberOfRows<Matrix>());
        auto result = decltype(at(A,0,0)){0.};
        for( Index i = 0; i < numberOfRows<Matrix>() ; ++i )
          for( Index j = 0 ; j < numberOfColumns<Matrix>() ; ++j )
            result += at(A,i,j) * at(B,i,j);
        return result;
      }

      template < class Vector , std::enable_if_t<Checks::isStaticVector<Vector>() && !Checks::isConstantSizeMatrix<Vector>()> >
      inline auto computeEuclideanScalarProduct(const Vector& v, const Vector& w)
      {
        using Index = decltype(numberOfRows<Vector>());
        auto result = at(v,0) * at(w,1);
        for( Index i = 1; i < numberOfRows<Vector>() ; ++i )
            result += at(v,i) * at(w,i);
        return result;
      }
    }
    template <class Matrix, class = Concepts::MatrixConceptCheck<Matrix> >
    struct SquaredEuclideanNorm : Base
    {
      SquaredEuclideanNorm() = default;

      explicit SquaredEuclideanNorm(const Matrix& A) { update(A); }

      void update(const Matrix& A)
      {
        A_ = A;
        resultOfD0 = computeSquareNorm(A_);
      }

      auto operator()() const noexcept
      {
        return d0();
      }

      auto d0() const noexcept
      {
        return resultOfD0;
      }

      template <int>
      auto d1(const Matrix& dA) const
      {
        return 2 * computeScalarProduct(A_,dA);
      }

      template <int,int>
      auto d2(const Matrix& dA1, const Matrix& dA2) const
      {
        return 2 * computeScalarProduct(dA1,dA2);
      }


    private:
      Matrix A_;
      std::remove_const_t< std::remove_reference_t< at_t<Matrix> > > resultOfD0;
    };

    template <class Matrix>
    using EuclideanNorm = MathematicalOperations::Chain< CMath::Sqrt , SquaredEuclideanNorm<Matrix> >;
  }
}

#endif // RFFGEN_LINEAR_ALGEBRA_EUCLIDEAN_NORM_HH