RBFBasis_fwd.hpp

Go to the documentation of this file.

#ifndef MEDUSA_BITS_APPROXIMATIONS_RBFBASIS_FWD_HPP_
#define MEDUSA_BITS_APPROXIMATIONS_RBFBASIS_FWD_HPP_
 
#include <medusa/Config.hpp>
#include <iosfwd>
#include <array>
#include "Operators_fwd.hpp"
 
namespace mm {
 
template <class RBFType, class vec_t>
class RBFBasis {
    static_assert(std::is_same<typename vec_t::scalar_t, typename RBFType::scalar_t>::value,
                  "Basis and underlying RBF must have the same scalar type.");
  public:
    typedef RBFType rbf_t;   
    typedef vec_t vector_t;   
    typedef typename vector_t::scalar_t scalar_t;   
    enum {  dim = vec_t::dim };
 
  private:
    int size_;  
    rbf_t rbf_;  
 
  public:
    explicit RBFBasis(int basis_size) : size_(basis_size), rbf_() {}
    RBFBasis(int basis_size, const rbf_t& rbf) : size_(basis_size), rbf_(rbf) {}
 
    int size() const { return size_; }
 
    const rbf_t& rbf() const { return rbf_; }
 
    rbf_t& rbf() { return rbf_; }
 
 
    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 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>& support,
                       scalar_t scale = 1) const;
    scalar_t evalOpAt0(int index, const Der1<dim>& der1, const std::vector<vector_t>& support,
                       scalar_t scale = 1) const;
    scalar_t evalOpAt0(int index, const Der2<dim>& der2, const std::vector<vector_t>& support,
                       scalar_t scale = 1) const;
 
    template <typename V, typename R>
    friend std::ostream& operator<<(std::ostream& os, const RBFBasis<V, R>& m);
};
 
 
// Convenience typedefs
 
template <typename S> class Gaussian;
template <typename V> using Gaussians = RBFBasis<Gaussian<typename V::scalar_t>, V>;
 
template <typename S> class Multiquadric;
template <typename V> using MQs = RBFBasis<Multiquadric<typename V::scalar_t>, V>;
 
template <typename S> class InverseMultiquadric;
template <typename V> using IMQs = RBFBasis<InverseMultiquadric<typename V::scalar_t>, V>;
 
template <typename S, int K> class Polyharmonic;
template <typename V, int K = -1> using PHs = RBFBasis<Polyharmonic<typename V::scalar_t, K>, V>;
 
}  // namespace mm
 
#endif  // MEDUSA_BITS_APPROXIMATIONS_RBFBASIS_FWD_HPP_