Operators_fwd.hpp

Go to the documentation of this file.

#ifndef MEDUSA_BITS_APPROXIMATIONS_OPERATORS_FWD_HPP_
#define MEDUSA_BITS_APPROXIMATIONS_OPERATORS_FWD_HPP_
 
#include <medusa/Config.hpp>
#include <array>
#include <vector>
#include <Eigen/Core>
#include "Monomials_fwd.hpp"
#include <medusa/bits/utils/assert.hpp>
 
namespace mm {
 
template <typename Derived>
struct Operator {
    typedef Derived operator_t;  
    static constexpr int size() { return 1; }   
    static constexpr int index(Derived) { return 0; }   
    std::string name() const { return Derived::name(); }   
    static std::string type_name() { return Derived::type_name(); }  
 
    std::array<Derived, 1> operators() const { return {*static_cast<const Derived*>(this)}; }
 
    template <typename basis_t>
    typename basis_t::scalar_t apply(
            const basis_t& basis, int index, typename basis_t::vector_t point,
            const std::vector<typename basis_t::vector_t>& support,
            typename basis_t::scalar_t scale) const;
 
    template <typename basis_t>
    typename basis_t::scalar_t applyAt0(
            const basis_t& basis, int index,
            const std::vector<typename basis_t::vector_t>& support,
            typename basis_t::scalar_t scale) const;
};
template <typename Derived>
std::ostream& operator<<(std::ostream& os, const Operator<Derived>& op) { return os << op.name(); }
 
template <int dimension>
struct Lap : public Operator<Lap<dimension>> {
    enum {  dim = dimension };
    static std::string name() { return format("Laplacian<%d>", dim); }  
    static std::string type_name() { return name(); }  
};
 
template <int dimension>
struct Der1s {
    enum {  dim = dimension };
    typedef Der1<dim> operator_t;  
    static int size() { return dim; }  
    static std::string name() { return format("Der1s<%d>", dim); }  
    static std::string type_name() { return name(); }  
 
    static std::array<Der1<dimension>, dimension> operators();
 
    static int index(Der1<dim> d) { return d.var; }
};
template <int d>
std::ostream& operator<<(std::ostream& os, const Der1s<d>& op) { return os << op.name(); }
 
template <int dimension>
struct Der2s {
    enum {  dim = dimension };
    typedef Der2<dim> operator_t;  
    static int size() { return dim * (dim + 1) / 2; }  
    static std::string name() { return format("Der2s<%d>", dim); }  
    static std::string type_name() { return name(); }  
 
    static std::array<Der2<dimension>, dimension * (dimension + 1) / 2> operators();
 
    static int index(Der2<dim> d) { return (d.var2 == 2 ? d.var1 + 1 : d.var1) + d.var2; }
};
template <int d>
std::ostream& operator<<(std::ostream& os, const Der2s<d>& op) { return os << op.name(); }
 
 
template <int dimension>
struct Der1 : public Operator<Der1<dimension>> {
    enum {  dim = dimension };
    int var;  
 
    Der1() : var(-1) {}
 
    Der1(int var);
 
    std::string name() const;
    static std::string type_name() { return format("Der1<%d>", dim); }
};
 
 
template <int dimension>
struct Der2 : public Operator<Der2<dimension>> {
    enum {  dim = dimension };
    int var1,  
        var2;  
 
    Der2() : var1(-1), var2(-1) {}
 
    Der2(int var1, int var2);
 
    Der2(int var) : Der2(var, var) {}
 
    std::string name() const;
    static std::string type_name() { return format("Der2<%d>", dim); }
};
 
 
template <int dimension>
struct Derivative : public Operator<Derivative<dimension>> {
    enum {  dim = dimension };
    std::array<int, dim> orders;  
 
    Derivative(const std::array<int, dim>& orders) : orders(orders) {}
 
    std::string name() { return format("Derivative<%d> wrt. %s", dim, orders); }
    static std::string type_name() { return format("Derivative<%d>", dim); }
};
 
}  // namespace mm
 
#endif  // MEDUSA_BITS_APPROXIMATIONS_OPERATORS_FWD_HPP_