Monomials_fwd.hpp

Go to the documentation of this file.

#ifndef MEDUSA_BITS_APPROXIMATIONS_MONOMIALS_FWD_HPP_
#define MEDUSA_BITS_APPROXIMATIONS_MONOMIALS_FWD_HPP_
 
#include <medusa/Config.hpp>
#include <cmath>
#include <array>
#include <Eigen/Core>
#include <iosfwd>
 
namespace mm {
 
template <int dimension>
struct Lap;
template <int dimension>
struct Der1;
template <int dimension>
struct Der2;
template <int dimension>
struct Derivative;
 
template <class vec_t>
class Monomials {
  public:
    typedef vec_t vector_t;   
    typedef typename vector_t::scalar_t scalar_t;   
    enum {  dim = vec_t::dim };
 
  private:
    Eigen::Matrix<int, dim, Eigen::Dynamic> powers_;
 
    void setFromPowers(const std::vector<std::vector<int>>& powers);
 
    static std::vector<std::vector<int>> generatePowers(int max_order, int dim);
 
  public:
    Monomials() = default;
 
    Monomials(int order);
 
    Monomials(const std::vector<std::vector<int>>& powers) { setFromPowers(powers); }
 
    static Monomials<vec_t> tensorBasis(int order);
 
    int size() const { return powers_.cols(); }
 
    const Eigen::Matrix<int, dim, Eigen::Dynamic>& powers() const { return powers_; }
 
    scalar_t eval(int index, const vector_t& point,
                  const std::vector<vector_t>& /* support */ = {}) const;
 
    template <typename operator_t>
    scalar_t evalOp(int index, const vector_t& point, operator_t op,
                    const std::vector<vector_t>& support = {}, scalar_t scale = 1) const;
    scalar_t evalOp(int index, const vector_t& point, Lap<dim> op,
                    const std::vector<vector_t>& support = {}, scalar_t scale = 1) const;
    scalar_t evalOp(int index, const vector_t& point, Der1<dim> op,
                    const std::vector<vector_t>& support = {}, scalar_t scale = 1) const;
    scalar_t evalOp(int index, const vector_t& point, Der2<dim> op,
                    const std::vector<vector_t>& support = {}, scalar_t scale = 1) const;
    scalar_t evalOp(int index, const vector_t& point, Derivative<dim> op,
                    const std::vector<vector_t>& support = {}, scalar_t scale = 1) const;
 
    scalar_t evalAt0(int index, const std::vector<vector_t>& /* support */ = {}) const;
    template <typename operator_t>
    scalar_t evalOpAt0(int index, const operator_t& op, const std::vector<vector_t>& support = {},
                       scalar_t scale = 1) const {
        return op.applyAt0(*this, index, support, scale);
    }
    scalar_t evalOpAt0(int index, const Lap<dim>& lap, const std::vector<vector_t>& = {},
                       scalar_t scale = 1) const;
    scalar_t evalOpAt0(int index, const Der1<dim>& der1, const std::vector<vector_t>& = {},
                       scalar_t scale = 1) const;
    scalar_t evalOpAt0(int index, const Der2<dim>& der2, const std::vector<vector_t>& = {},
                       scalar_t scale = 1) const;
 
    scalar_t evalOpAt0(int index, const Derivative<dim>& der, const std::vector<vector_t>& = {},
                       scalar_t scale = 1) const;
 
    template <class V>
    friend std::ostream& operator<<(std::ostream& os, const Monomials<V>& m);
};
 
}  // namespace mm
 
#endif  // MEDUSA_BITS_APPROXIMATIONS_MONOMIALS_FWD_HPP_