exponential.hpp

Go to the documentation of this file.

#pragma once

#include <Eigen/Core>
#include <unsupported/Eigen/MatrixFunctions>

#include "../../utilities/evaluations.hpp"

#include "../bases.hpp"


namespace waveblocks
{
  namespace potentials
  {
    namespace modules
    {
      namespace exponential
      {
        template <class Subtype, class Basis>
        class Abstract
        {
            using Self = Abstract<Subtype, Basis>;
            IMPORT_TYPES_FROM( Basis)

            potential_evaluation_type evaluate_exponential_at( const argument_type &arg,
                const real_t &factor = 1 ) const {
              static_cast<const Subtype*>(this)->evaluate_exponential_at_implementation( arg, factor );
            }

            template < template <typename...> class grid_in = std::vector,
                     template <typename...> class grid_out = grid_in >
            grid_out<potential_evaluation_type> evaluate_exponential(
              grid_in<argument_type > args,
              real_t factor = 1 ) const {
              return utilities::evaluate_function_in_grid < argument_type,
                     potential_evaluation_type,
                     grid_in,
                     grid_out,
                     function_t > (
                       std::bind( &Self::evaluate_exponential_at,
                                  this,
                                  std::placeholders::_1,
                                  factor ),
                       args );
            }
        };

        template <class EvalImpl, class Basis>
        struct Standard : public Abstract<Standard<EvalImpl, Basis>, Basis>,
          public EvalImpl {
          IMPORT_TYPES_FROM( Basis)

          Standard(potential_type pot) : EvalImpl(pot){}

          potential_evaluation_type evaluate_exponential_at_implementation(
            const argument_type &arg,
            real_t factor ) const {
            // Compute matrix
            auto values = evaluate_at( arg );
            potential_evaluation_type result;

            // Compute exponential
            return (factor * values).exp();
          }
        };

        template <class EvalImpl, template <int, int> class B, int D>
        struct Standard<EvalImpl, B<1, D>> : public Abstract<Standard<EvalImpl, B<1,D>>, B<1,D>>,
          public EvalImpl {
            using Basis = B<1,D>;
          IMPORT_TYPES_FROM( Basis)

          Standard(potential_type pot) : EvalImpl(pot){}

          potential_evaluation_type evaluate_exponential_at_implementation(
            const argument_type &arg,
            real_t factor ) const {
            // Compute matrix
            auto values = evaluate_at( arg );
            return std::exp(factor * values);
          }
        };
      }

      template <class Basis>
      using Exponential = exponential::Standard<Evaluation<Basis>, Basis>;
    }
  }
}