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