WeightFunction_fwd.hpp

Go to the documentation of this file.

#ifndef MEDUSA_BITS_APPROXIMATIONS_WEIGHTFUNCTION_FWD_HPP_
#define MEDUSA_BITS_APPROXIMATIONS_WEIGHTFUNCTION_FWD_HPP_
 
#include <medusa/Config.hpp>
#include <array>
#include <iosfwd>
 
namespace mm {
 
template <class vec_t>
class NoWeight {
  public:
    typedef vec_t vector_t;   
    typedef typename vector_t::scalar_t scalar_t;   
    enum {  dim = vec_t::dim };
 
  public:
    scalar_t operator()(const vector_t& /* point */) const { return 1.0; }
 
    template <typename V>
    friend std::ostream& operator<<(std::ostream& os, const NoWeight<V>& m);
};
 
template <typename V>
std::ostream& operator<<(std::ostream& os, const NoWeight<V>& m) {
    return os << "NoWeight " << m.dim << "D";
}
 
template <class RBFType, class vec_t>
class RBFWeight {
    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:
    rbf_t rbf_;  
 
  public:
    RBFWeight() : rbf_() {}
    RBFWeight(const rbf_t& rbf) : rbf_(rbf) {}
    template <typename ...Args>
    RBFWeight(Args&&... args) : rbf_(std::forward<Args>(args)...) {}
 
    const rbf_t& rbf() const { return rbf_; }
 
    rbf_t& rbf() { return rbf_; }
 
    scalar_t operator()(const vector_t& point) const { return rbf_(point.squaredNorm()); }
 
    template <typename V, typename R>
    friend std::ostream& operator<<(std::ostream& os, const RBFWeight<V, R>& m);
};
 
// Convenience typedefs
 
template <typename S> class Gaussian;
template <typename V> using GaussianWeight = RBFWeight<Gaussian<typename V::scalar_t>, V>;
 
template <typename S> class Multiquadric;
template <typename V> using MQWeight = RBFWeight<Multiquadric<typename V::scalar_t>, V>;
 
template <typename S> class InverseMultiquadric;
template <typename V> using IMQWeight = RBFWeight<InverseMultiquadric<typename V::scalar_t>, V>;
 
template <typename S, int k> class Polyharmonic;
template <typename V> using PHWeight = RBFWeight<Polyharmonic<typename V::scalar_t, -1>, V>;
 
}  // namespace mm
 
#endif  // MEDUSA_BITS_APPROXIMATIONS_WEIGHTFUNCTION_FWD_HPP_