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