gsFunctionExpr.h

Go to the documentation of this file.

#pragma once

#include <gsCore/gsFunction.h>

namespace gismo
{

template<typename T>
class gsFunctionExpr : public gsFunction<T>
{
public:
    typedef T Scalar_t;

    typedef memory::shared_ptr< gsFunctionExpr > Ptr;

    typedef memory::unique_ptr<gsFunctionExpr> uPtr;

public:

    gsFunctionExpr();

    gsFunctionExpr(const std::string & expression_string, short_t ddim);

    gsFunctionExpr(const std::string & expression_string1,
                   const std::string & expression_string2,
                   short_t ddim);

    gsFunctionExpr(const std::string & expression_string1,
                   const std::string & expression_string2,
                   const std::string & expression_string3,
                   short_t ddim);

    gsFunctionExpr(const std::string & expression_string1,
                   const std::string & expression_string2,
                   const std::string & expression_string3,
                   const std::string & expression_string4,
                   short_t ddim);

    gsFunctionExpr(const std::string & expression_string1,
                   const std::string & expression_string2,
                   const std::string & expression_string3,
                   const std::string & expression_string4,
                   const std::string & expression_string5,
                   const std::string & expression_string6,
                   const std::string & expression_string7,
                   const std::string & expression_string8,
                   const std::string & expression_string9,
                   short_t ddim);

    gsFunctionExpr(const std::vector<std::string> & expression_string, short_t ddim);

    gsFunctionExpr(const gsFunctionExpr& other);

    static uPtr make(const std::string & expression_string, short_t ddim)
    { return uPtr(new gsFunctionExpr(expression_string, ddim)); }

    static uPtr make(const std::string & expression_string1, const std::string & expression_string2, short_t ddim)
    { return uPtr(new gsFunctionExpr(expression_string1, expression_string2, ddim)); }

    static uPtr make(const std::string & expression_string1, const std::string & expression_string2,
                     const std::string & expression_string3, short_t ddim)
    { return uPtr(new gsFunctionExpr(expression_string1, expression_string2, expression_string3, ddim)); }

    static uPtr make(const std::string & expression_string1, const std::string & expression_string2,
                     const std::string & expression_string3, const std::string & expression_string4, short_t ddim)
    { return uPtr(new gsFunctionExpr(expression_string1, expression_string2, expression_string3, expression_string4, ddim)); }

    static uPtr make(const std::string & expression_string1, const std::string & expression_string2,
                     const std::string & expression_string3, const std::string & expression_string4,
                     const std::string & expression_string5, const std::string & expression_string6,
                     const std::string & expression_string7, const std::string & expression_string8,
                     const std::string & expression_string9, short_t ddim)
    { return uPtr(new gsFunctionExpr(expression_string1, expression_string2, expression_string3, expression_string4,
                expression_string5, expression_string6, expression_string7, expression_string8, expression_string9, ddim)); }

#if EIGEN_HAS_RVALUE_REFERENCES
    gsFunctionExpr(gsFunctionExpr&& other);

    gsFunctionExpr& operator=(const gsFunctionExpr& other);

    gsFunctionExpr& operator=(gsFunctionExpr&& other);
#else
    gsFunctionExpr& operator=(gsFunctionExpr other);
#endif

    ~gsFunctionExpr();

    GISMO_CLONE_FUNCTION(gsFunctionExpr)

    
    void addComponent(const std::string & strExpression);

private:

    // initializes the symbol table
    void init(const short_t dim);

public:

    // Function expression can be used as a global function defined
    // for any real value, on any subdomain
    virtual const gsFunctionExpr & piece(const index_t) const
    {
        return *this;
    }

    // Documented in gsFunction class
    short_t domainDim() const;

    // Documented in gsFunction class
    short_t targetDim() const;

    // returns the string expression for component \a i
    const std::string & expression(int i = 0) const;

    void set_x (T const & v) const;
    void set_y (T const & v) const;
    void set_z (T const & v) const;
    void set_w (T const & v) const;
    void set_u (T const & v) const;
    void set_v (T const & v) const;
    void set_t (T const & t) const;

    // see gsFunction for documentation
    virtual void eval_into(const gsMatrix<T>& u, gsMatrix<T>& result) const;

    // see gsFunction for documentation
    virtual void eval_component_into(const gsMatrix<T>& u,
                                     const index_t comp,
                                     gsMatrix<T>& result) const;

    // see gsFunction for documentation
    virtual void deriv_into(const gsMatrix<T>& u,
                            gsMatrix<T>& result) const;

    // see gsFunction for documentation
    virtual void deriv2_into(const gsMatrix<T>& u,
                             gsMatrix<T>& result) const;

    // see gsFunction for documentation
    gsMatrix<T> hess(const gsMatrix<T>& u, unsigned coord = 0) const;

    // see gsFunction for documentation
    gsMatrix<T> laplacian(const gsMatrix<T>& u) const;

    gsMatrix<T> * mderiv(const gsMatrix<T>& u, const index_t k, const index_t j) const;

    // see gsFunction for documentation
    std::ostream &print(std::ostream &os) const;

    void swap(gsFunctionExpr& other)
    { std::swap(this->my, other.my); }

// Data members
private:
    class gsFunctionExprPrivate;
    typedef gsFunctionExprPrivate PrivateData_t;

    PrivateData_t * my;

}; // class gsFunctionExpr


#ifdef GISMO_WITH_PYBIND11

  void pybind11_init_gsFunctionExpr(pybind11::module &m);

#endif // GISMO_WITH_PYBIND11

} // namespace gismo


#ifndef GISMO_BUILD_LIB
#include GISMO_HPP_HEADER(gsFunctionExpr.hpp)
#endif