gsQuasiInterpolate.h

Go to the documentation of this file.

 
#pragma once
 
#include <gsCore/gsForwardDeclarations.h>
 
namespace gismo {
 
template <class T>
struct gsQuasiInterpolate
{
 
    /*
    enum method
    {
        Taylor     = 1, ///< Taylor
        Schoenberg = 2, ///< Schoenberg
        EvalBased  = 3
    };
 
    switch(type)
    {
    case(1): gsQuasiInterpolate<T>::Schoenberg(*basis, fun, coefs); expConvRate = 2.0; break;
    case(2): gsQuasiInterpolate<T>::Taylor(*basis, fun, deg, coefs); expConvRate = (deg+1); break;
    case(3): gsQuasiInterpolate<T>::EvalBased(*basis, fun, true, coefs); expConvRate = (deg+1); break;
    case(0): gsQuasiInterpolate<T>::EvalBased(*basis, fun, false, coefs); expConvRate = (deg+1); break;
    default: GISMO_ERROR("invalid option");
    }
    */
 
    static gsMatrix<T> localIntpl(const gsBasis<T> &b,
                                  const gsFunction<T> &fun,
                                  index_t i,
                                  const gsMatrix<T> &ab);
 
    static gsMatrix<T> localIntpl(const gsBasis<T> &b,
                                  const gsFunction<T> &fun,
                                  index_t i);
 
    template<short_t d>
    static gsMatrix<T> localIntpl(const gsHTensorBasis<d,T> &b,
                                  const gsFunction<T> &fun,
                                  index_t i);
 
 
    static void localIntpl(const gsBasis<T> &b,
                           const gsFunction<T> &fun,
                           gsMatrix<T> &result);
 
 
    static void Taylor(const gsBasis<T> &bb, const gsFunction<T> &fun, const int &r, gsMatrix<T> &result);
 
 
    static void Schoenberg(const gsBasis<T> &b, const gsFunction<T> &fun,
                           gsMatrix<T> &result);
 
    static gsMatrix<T> Schoenberg(const gsBasis<T> &b, const gsFunction<T> &fun, index_t i);
 
 
    static void EvalBased(const gsBasis<T> &bb, const gsFunction<T> &fun, const bool specialCase, gsMatrix<T> &result);
 
 
    /*
    static void qiCwiseData(const gsTensorBSplineBasis<T,2> & tbsp,
                            const gsVector<index_t> & ind,
                            std::vector<gsMatrix<T> > & qiNodes,
                            std::vector<gsMatrix<T> > & qiWeights);
 
    static void compute(const gsTensorBSplineBasis<T,2> & tbsp,
                        const gsFunction<T> & fun,
                        gsTensorBSpline<T> & res);
    */
 
protected:
 
    static T derivProd(const std::vector<T> &zeros, const int &order, const T &x);
 
 
    static void distributePoints(T a, T b, int n, gsMatrix<T> &points);
 
 
    static void computeWeights(const gsMatrix<T> &points, const gsKnotVector<T> &knots, const int &pos, gsMatrix<T> &weights);
 
 
    static gsMatrix<T> computeControlPoints(const gsMatrix<T> &weights, const gsFunction<T> &fun, const gsMatrix<T> &xik);
 
    static int greatestSubInterval(const gsKnotVector<T> &knots, const int &posStart, const int &posEnd);
 
 
}; //struct
 
} // gismo
 
#ifndef GISMO_BUILD_LIB
#include GISMO_HPP_HEADER(gsQuasiInterpolate.hpp)
#endif