RBFFD_fwd.hpp

Go to the documentation of this file.

#ifndef MEDUSA_BITS_APPROXIMATIONS_RBFFD_FWD_HPP_
#define MEDUSA_BITS_APPROXIMATIONS_RBFFD_FWD_HPP_
 
#include <medusa/Config.hpp>
#include <medusa/bits/types/Range_fwd.hpp>
#include <Eigen/Core>
#include "RBFBasis_fwd.hpp"
#include "Monomials_fwd.hpp"
#include "ScaleFunction.hpp"
#include "RBFInterpolant_fwd.hpp"
 
namespace mm {
 
template <class RBFType, class vec_t, class scale_t = NoScale, class solver_t =
    Eigen::PartialPivLU<Eigen::Matrix<typename vec_t::scalar_t, Eigen::Dynamic, Eigen::Dynamic>>>
class RBFFD {
    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_;  
    Monomials<vec_t> mon_;  
    solver_t solver_;  
 
    vector_t point_;  
    scalar_t scale_;  
    Range<vec_t> support_;  
 
  public:
    explicit RBFFD(rbf_t rbf) : rbf_(rbf), mon_(), point_(NaN) {}
 
    RBFFD(rbf_t rbf, const Monomials<vec_t>& mon) : rbf_(rbf), mon_(mon), point_(NaN) {}
 
    const rbf_t& rbf() const { return rbf_; }
 
    const Monomials<vec_t>& monomials() const { return mon_; }
 
    int requiredSupportSize() const { return mon_.size(); }
 
    void compute(const vector_t& point, const std::vector<vector_t>& support);
 
    Eigen::Matrix<scalar_t, Eigen::Dynamic, 1> getShape() const;
 
    template <class operator_t>
    Eigen::Matrix<scalar_t, Eigen::Dynamic, 1> getShape(const operator_t& op) const;
 
    template <typename Derived>
    Eigen::Matrix<scalar_t, Eigen::Dynamic, 1> getShapeFromRhs(
            const Eigen::MatrixBase<Derived>& Lb) const;
 
  private:
    Eigen::Matrix<scalar_t, Eigen::Dynamic, Eigen::Dynamic> getMatrix(
            const std::vector<vector_t>& local_coordinates) const;
 
  public:
    vec_t center() const { return point_; }
 
    scalar_t scale() const { return scale_; }
 
    Range<vec_t> localCoordinates() const { return support_; }
 
    Eigen::Matrix<scalar_t, Eigen::Dynamic, Eigen::Dynamic> getMatrix() const {
        return getMatrix(support_);
    }
 
    const solver_t& solver() const { return solver_; }
 
    template <typename Derived>
    RBFInterpolant<rbf_t, vec_t> getApproximant(const vector_t& point,
            const std::vector<vector_t>& support, const Eigen::MatrixBase<Derived>& values) const;
 
    template <class R, class V, class S, class L>
    friend std::ostream& operator<<(std::ostream& os, const RBFFD<R, V, S, L>& e);
};
 
template <class R, class V, class S, class L>
std::ostream& operator<<(std::ostream& os, const RBFFD<R, V, S, L>& e) {
    os << "RBFFD approximation engine:\n"
       << "    dimension: " << e.dim << '\n';
    if (e.point_[0] != e.point_[0]) {
        os << "    last point: not used yet\n";
    } else {
        os << "    last point: " << e.point_ << '\n';
    }
    os << "    RBF: " << e.rbf_ << '\n'
       << "    Augmentation: " << e.mon_ << '\n'
       << "    scale: " << S();
    return os;
}
 
}  // namespace mm
 
#endif  // MEDUSA_BITS_APPROXIMATIONS_RBFFD_FWD_HPP_