WLS_fwd.hpp

Go to the documentation of this file.

#ifndef MEDUSA_BITS_APPROXIMATIONS_WLS_FWD_HPP_
#define MEDUSA_BITS_APPROXIMATIONS_WLS_FWD_HPP_
 
#include <medusa/Config.hpp>
#include <medusa/bits/types/Range_fwd.hpp>
#include <Eigen/Core>
#include <type_traits>
#include <iosfwd>
#include "WLSApproximant_fwd.hpp"
#include "Operators_fwd.hpp"
 
namespace mm {
 
template <typename scalar_t, int QRPreconditioner>
class JacobiSVDWrapper;
 
template <typename vec_t>
class NoWeight;
 
class NoScale;
 
template <class basis_t, class weight_t = NoWeight<typename basis_t::vector_t>,
          class scale_t = NoScale, class solver_t =
               JacobiSVDWrapper<typename basis_t::scalar_t,
                                Eigen::ColPivHouseholderQRPreconditioner>>
class WLS {
  public:
    static_assert(std::is_same<typename basis_t::vector_t, typename weight_t::vector_t>::value,
                  "Basis and weight functions must have the same vector type.");
 
    typedef typename basis_t::scalar_t scalar_t;
    typedef typename basis_t::vector_t vector_t;
    enum {  dim = vector_t::dim };
    typedef typename Eigen::Matrix<scalar_t, Eigen::Dynamic, Eigen::Dynamic> ei_matrix_t;
 
  private:
    basis_t basis_;  
    weight_t weight_;  
 
    Range<vector_t> local_coordinates_;  
    vector_t point_;  
    scalar_t scale_;  
    solver_t solver_;  
 
  public:
    explicit WLS(const basis_t& basis) : basis_(basis), scale_(NaN) {}
    WLS(const basis_t& basis, const weight_t& weight) :
            basis_(basis), weight_(weight), scale_(NaN) {}
 
  private:
    ei_matrix_t getMatrix(const std::vector<vector_t>& local_coordinates) const;
 
  public:
    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;
 
    int requiredSupportSize() const { return basis_.size(); }
    const basis_t& basis() const { return basis_; }
    const weight_t& weight() const { return weight_; }
 
    vector_t center() const { return point_; }
 
    scalar_t scale() const { return scale_; }
 
    Range<vector_t> localCoordinates() const { return local_coordinates_; }
 
    ei_matrix_t getMatrix() const { return getMatrix(local_coordinates_); }
 
    Eigen::Matrix<scalar_t, Eigen::Dynamic, 1> getWeights() const;
 
    const solver_t& solver() const { return solver_; }
 
    solver_t& solver() { return solver_; }
 
    template <typename Derived>
    WLSApproximant<basis_t> getApproximant(const vector_t& point,
            const std::vector<vector_t>& support, const Eigen::MatrixBase<Derived>& values) const;
 
    template <class B, class W, class S, class L>
    friend std::ostream& operator<<(std::ostream& os, const WLS<B, W, S, L>& wls);
};
 
}  // namespace mm
 
#endif  // MEDUSA_BITS_APPROXIMATIONS_WLS_FWD_HPP_