This graph shows which files directly or indirectly include this file:

Classes
class	Feel::Symbols

struct	Feel::vf::map_scalar_field< Order >
	defines a dictionary of scalar fields More...

struct	Feel::vf::map_scalar_fields< Order >

struct	Feel::vf::map_vector_field< M, N, Order >
	defines a dictionary of vector fields More...

struct	Feel::vf::map_vector_fields< M, N, Order >

Namespaces
namespace	Feel
	-- mode: c++; coding: utf-8; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; show-trailing-whitespace: t --

Typedefs
template<int M, int N, int Order = 2>
using	Feel::vf::map_matrix_field = map_vector_field< M, N, Order >
	define a matrix field map. More...

typedef std::map< std::string, Expr< GinacEx< 2 > > >	Feel::vf::map_scalar_field_type

template<int M, int N, int Order = 2>
using	Feel::vf::matrix_field_expression = vector_field_expression< M, N, Order >

template<int Order = 2>
using	Feel::vf::scalar_field_expression = Expr< GinacEx< Order > >

template<int M, int N = 1, int Order = 2>
using	Feel::vf::vector_field_expression = Expr< GinacMatrix< M, N, Order > >

Functions
matrix	GiNaC::curl (ex const &f, std::vector< symbol > const &l)

template<int M = 1, int Order = 2>
Expr< GinacMatrix< M, 1, Order > >	Feel::vf::curl (Expr< GinacEx< Order > > const &s, std::string filename="", WorldComm const &world=Environment::worldComm(), std::string const &dirLibExpr="")

template<int Order = 2>
Expr< GinacMatrix< 2, 1, Order > >	Feel::vf::curl (Expr< GinacMatrix< 1, 1, Order > > const &s, std::string filename="", WorldComm const &world=Environment::worldComm(), std::string const &dirLibExpr="")

template<int M, int Order = 2>
Expr< GinacMatrix< 1, M, Order > >	Feel::vf::curl (Expr< GinacMatrix< 1, M, Order > > const &s, std::string filename="", WorldComm const &world=Environment::worldComm(), std::string const &dirLibExpr="")

template<int M, int Order = 2>
Expr< GinacMatrix<((M==2)?1:3), 1, Order > >	Feel::vf::curl (Expr< GinacMatrix< M, 1, Order > > const &s, std::string filename="", WorldComm const &world=Environment::worldComm(), std::string const &dirLibExpr="")

matrix	GiNaC::curl (matrix const &f, std::vector< symbol > const &l)

matrix	GiNaC::diff (ex const &f, symbol const &l, const int n)

template<int Order, typename SymbolsExprType >
Expr< GinacExVF< Order, SymbolsExprType > >	Feel::vf::diff (Expr< GinacExVF< Order, SymbolsExprType > > const &s, std::string const &diffVariable, int diffOrder=1, std::string filename="", WorldComm const &world=Environment::worldComm(), std::string const &dirLibExpr="")

template<int M, int N, int Order, typename SymbolsExprType >
Expr< GinacMatrix< M, N, Order, SymbolsExprType > >	Feel::vf::diff (Expr< GinacMatrix< M, N, Order, SymbolsExprType > > const &s, std::string const &diffVariable, int diffOrder=1, std::string filename="", WorldComm const &world=Environment::worldComm(), std::string const &dirLibExpr="")

matrix	GiNaC::diff (matrix const &f, symbol const &l, const int n)

template<typename ExprT , int Order = 2>
Expr< GinacExVF< Order, symbols_expression_t< SymbolExpr< ExprT > > > >	Feel::vf::diff (std::string const &s, std::string const &ds, std::string const &se, ExprT const &e, std::string filename="", WorldComm const &world=Environment::worldComm(), std::string const &dirLibExpr="")
	Create an Feel++ expression from a GiNaC expression as a string. More...

matrix	GiNaC::div (ex const &f, std::vector< symbol > const &l)

template<int M = 1, int Order = 2>
FEELPP_DEPRECATED Expr< GinacMatrix< M, 1, Order > >	Feel::vf::div (Expr< GinacEx< Order > > const &s, std::string filename="", WorldComm const &world=Environment::worldComm(), std::string const &dirLibExpr="")

template<int M, int Order, typename SymbolsExprType >
Expr< GinacMatrix< 1, 1, Order, SymbolsExprType > >	Feel::vf::div (Expr< GinacMatrix< 1, M, Order, SymbolsExprType > > const &s, std::string filename="", WorldComm const &world=Environment::worldComm(), std::string const &dirLibExpr="")

template<int M, int Order, typename SymbolsExprType >
Expr< GinacMatrix< 1, 1, Order, SymbolsExprType > >	Feel::vf::div (Expr< GinacMatrix< M, 1, Order, SymbolsExprType > > const &s, std::string filename="", WorldComm const &world=Environment::worldComm(), std::string const &dirLibExpr="")

template<int M, int N, int Order, typename SymbolsExprType >
Expr< GinacMatrix< M, 1, Order, SymbolsExprType > >	Feel::vf::div (Expr< GinacMatrix< M, M, Order, SymbolsExprType > > const &s, std::string filename="", WorldComm const &world=Environment::worldComm(), std::string const &dirLibExpr="")

matrix	GiNaC::div (matrix const &f, std::vector< symbol > const &l)

Expr< GinacEx< 2 > >	Feel::vf::expr (const char *s_, std::string filename="", WorldComm const &world=Environment::worldComm(), std::string const &dirLibExpr="")
	Create an Feel++ expression from a GiNaC expression as a string. More...

Expr< GinacEx<> >	Feel::vf::expr (double value)
	Create an Feel++ expression from a GiNaC expression as a string. More...

template<typename ExprT , int Order = 2>
Expr< GinacExVF< Order, symbols_expression_t< SymbolExpr< ExprT > > > >	Feel::vf::expr (ex const &myexpr, std::vector< GiNaC::symbol > const &syms, GiNaC::symbol const &s, ExprT const &e, std::string filename="", WorldComm const &world=Environment::worldComm(), std::string const &dirLibExpr="")

template<typename ExprT , int Order = 2>
Expr< GinacExVF< Order, symbols_expression_t< SymbolExpr< ExprT > > > >	Feel::vf::expr (ex const &myexpr, std::vector< GiNaC::symbol > const &syms, std::initializer_list< GiNaC::symbol > const &s, std::initializer_list< ExprT > const &e, std::string filename="", WorldComm const &world=Environment::worldComm(), std::string const &dirLibExpr="")

template<typename ExprT , int Order = 2>
Expr< GinacExVF< Order, symbols_expression_t< SymbolExpr< ExprT > > > >	Feel::vf::expr (ex const &myexpr, std::vector< GiNaC::symbol > const &syms, std::vector< GiNaC::symbol > const &s, std::vector< ExprT > const &e, std::string filename="", WorldComm const &world=Environment::worldComm(), std::string const &dirLibExpr="")

template<int Order, typename... ExprT>
Expr< GinacExVF< Order, symbols_expression_t< ExprT... > > >	Feel::vf::expr (Expr< GinacEx< Order > > const &s, const ExprT &... expr)

template<int M, int N, int Order, typename... ExprT>
Expr< GinacMatrix< M, N, Order, symbols_expression_t< ExprT... > > >	Feel::vf::expr (Expr< GinacMatrix< M, N, Order > > const &s, const ExprT &... expr)

template<int Order>
Expr< GinacEx< Order > >	Feel::vf::expr (GiNaC::ex const &f, std::vector< GiNaC::symbol > const &lsym, std::string const &exprDesc="", std::string filename="", WorldComm const &world=Environment::worldComm(), std::string const &dirLibExpr="")

template<int M, int N, int Order>
Expr< GinacMatrix< M, N, Order > >	Feel::vf::expr (GiNaC::ex const &f, std::vector< GiNaC::symbol > const &lsym, std::string const &exprDesc="", std::string filename="", WorldComm const &world=Environment::worldComm(), std::string const &dirLibExpr="")

Expr< GinacEx< 2 > >	Feel::vf::expr (GiNaC::ex const &f, std::vector< GiNaC::symbol > const &lsym, std::string filename="", WorldComm const &world=Environment::worldComm(), std::string const &dirLibExpr="")

template<int Order>
Expr< GinacEx< Order > >	Feel::vf::expr (GiNaC::ex const &f, std::vector< GiNaC::symbol > const &lsym, std::string filename="", WorldComm const &world=Environment::worldComm(), std::string const &dirLibExpr="")
	functor enabling ginac

template<int M, int N, int Order>
Expr< GinacMatrix< M, N, Order > >	Feel::vf::expr (GiNaC::matrix const &f, std::vector< GiNaC::symbol > const &lsym, std::string const &exprDesc="", std::string filename="", WorldComm const &world=Environment::worldComm(), std::string const &dirLibExpr="")
	functor enabling ginac

Expr< GinacMatrix< 1, 1, 2 > >	Feel::vf::expr (GiNaC::matrix const &f, std::vector< GiNaC::symbol > const &lsym, std::string filename="", WorldComm const &world=Environment::worldComm(), std::string const &dirLibExpr="")

template<typename ExprT , int Order = 2>
FEELPP_DEPRECATED Expr< GinacExVF< Order, symbols_expression_t< SymbolExpr< ExprT > > > >	Feel::vf::expr (std::string const &myexpr, std::vector< GiNaC::symbol > const &syms, std::vector< GiNaC::symbol > const &s, std::vector< ExprT > const &e, std::string filename="", WorldComm const &world=Environment::worldComm(), std::string const &dirLibExpr="")

template<typename ExprT , int Order = 2>
Expr< GinacExVF< Order, symbols_expression_t< SymbolExpr< ExprT > > > >	Feel::vf::expr (std::string const &s, std::initializer_list< std::string > const &se, std::initializer_list< ExprT > const &e, std::string filename="", WorldComm const &world=Environment::worldComm(), std::string const &dirLibExpr="")

Expr< GinacEx< 2 > >	Feel::vf::expr (std::string const &s, std::map< std::string, double > const &mp, std::string filename="", WorldComm const &world=Environment::worldComm(), std::string const &dirLibExpr="")
	Create an Feel++ expression from a GiNaC expression as a string. More...

template<int Order>
Expr< GinacEx< Order > >	Feel::vf::expr (std::string const &s, std::map< std::string, double > const &mp, std::string filename="", WorldComm const &world=Environment::worldComm(), std::string const &dirLibExpr="")
	Create an Feel++ expression from a GiNaC expression as a string. More...

template<int M, int N, int Order = 2>
Expr< GinacMatrix< M, N, Order > >	Feel::vf::expr (std::string const &s, std::map< std::string, double > const &mp, std::string filename="", WorldComm const &world=Environment::worldComm(), std::string const &dirLibExpr="")

template<int Order>
Expr< GinacEx< Order > >	Feel::vf::expr (std::string const &s, std::pair< std::string, double > const &mp, std::string filename="", WorldComm const &world=Environment::worldComm(), std::string const &dirLibExpr="")

template<int M, int N, int Order = 2>
Expr< GinacMatrix< M, N, Order > >	Feel::vf::expr (std::string const &s, std::pair< std::string, double > const &mp, std::string filename="", WorldComm const &world=Environment::worldComm(), std::string const &dirLibExpr="")

Expr< GinacEx< 2 > >	Feel::vf::expr (std::string const &s, std::string const &filename="", WorldComm const &world=Environment::worldComm(), std::string const &dirLibExpr="")
	Create an Feel++ expression from a GiNaC expression as a string. More...

template<typename ExprT , int Order = 2>
Expr< GinacExVF< Order, symbols_expression_t< SymbolExpr< ExprT > > > >	Feel::vf::expr (std::string const &s, std::string const &se, ExprT const &e, std::string filename="", WorldComm const &world=Environment::worldComm(), std::string const &dirLibExpr="")
	Create an Feel++ expression from a GiNaC expression as a string. More...

template<int Order>
Expr< GinacEx< Order > >	Feel::vf::expr (std::string const &s, std::string filename="", WorldComm const &world=Environment::worldComm(), std::string const &dirLibExpr="")
	Create an Feel++ expression from a GiNaC expression as a string. More...

template<int M, int N, int Order = 2>
Expr< GinacMatrix< M, N, Order > >	Feel::vf::expr (std::string const &s, std::string filename="", WorldComm const &world=Environment::worldComm(), std::string const &dirLibExpr="")
	Create an Feel++ expression from a GiNaC expression as a string. More...

template<typename ExprT , int Order = 2>
Expr< GinacExVF< Order, symbols_expression_t< SymbolExpr< ExprT > > > >	Feel::vf::expr (std::string const &s, std::vector< GiNaC::symbol > const &lsym, std::pair< GiNaC::symbol, ExprT > const &e, std::string filename="", WorldComm const &world=Environment::worldComm(), std::string const &dirLibExpr="")

Expr< GinacEx< 2 > >	Feel::vf::expr (std::string const &s, std::vector< GiNaC::symbol > const &lsym, std::string filename="", WorldComm const &world=Environment::worldComm(), std::string const &dirLibExpr="")

template<int Order>
Expr< GinacEx< Order > >	Feel::vf::expr (std::string const &s, std::vector< GiNaC::symbol > const &lsym, std::string filename="", WorldComm const &world=Environment::worldComm(), std::string const &dirLibExpr="")

template<typename ExprT , int Order = 2>
Expr< GinacExVF< Order, symbols_expression_t< SymbolExpr< ExprT > > > >	Feel::vf::expr (std::string const &s, std::vector< std::string > const &se, std::vector< ExprT > const &e, std::string filename="", WorldComm const &world=Environment::worldComm(), std::string const &dirLibExpr="")

template<int Order>
Expr< GinacEx< Order > >	Feel::vf::expr_mult (Expr< GinacEx< Order > > const &e1, double e2, std::string filename="", WorldComm const &world=Environment::worldComm(), std::string const &dirLibExpr="")

template<int Order, int Order1, int Order2>
Expr< GinacEx< Order > >	Feel::vf::expr_mult (Expr< GinacEx< Order1 > > const &e1, Expr< GinacEx< Order2 > > const &e2, std::string filename="", WorldComm const &world=Environment::worldComm(), std::string const &dirLibExpr="")

template<int M, int N, int Order>
Expr< GinacMatrix< M, N, Order > > &	Feel::vf::expression (std::pair< const std::string, std::pair< Expr< GinacMatrix< M, N, Order > >, std::set< std::string > > > &p)

template<int M, int N, int Order>
Expr< GinacMatrix< M, N, Order > > const &	Feel::vf::expression (std::pair< const std::string, std::pair< Expr< GinacMatrix< M, N, Order > >, std::set< std::string > > > const &p)

template<int M, int N, int Order, typename SymbExpr >
auto	Feel::vf::expression (std::pair< const std::string, std::pair< Expr< GinacMatrix< M, N, Order > >, std::set< std::string > > > const &p, SymbExpr const &se)

template<int Order>
scalar_field_expression< Order > &	Feel::vf::expression (std::pair< const std::string, std::pair< scalar_field_expression< Order >, std::set< std::string > > > &p)

template<int Order>
scalar_field_expression< Order > const &	Feel::vf::expression (std::pair< const std::string, std::pair< scalar_field_expression< Order >, std::set< std::string > > > const &p)

template<int Order, typename SymbExpr >
auto	Feel::vf::expression (std::pair< const std::string, std::pair< scalar_field_expression< Order >, std::set< std::string > > > const &p, SymbExpr const &se)

template<int Order>
std::vector< scalar_field_expression< Order > > &	Feel::vf::expression (std::pair< const std::string, std::pair< std::vector< scalar_field_expression< Order > >, std::set< std::string > > > &p)

template<int Order>
std::vector< scalar_field_expression< Order > > const &	Feel::vf::expression (std::pair< const std::string, std::pair< std::vector< scalar_field_expression< Order > >, std::set< std::string > > > const &p)

template<int M, int N, int Order>
Expr< GinacMatrix< M, N, Order > > &	Feel::vf::expression1 (std::pair< const std::string, std::pair< std::vector< Expr< GinacMatrix< M, N, Order > > >, std::set< std::string > > > &p)

template<int M, int N, int Order>
Expr< GinacMatrix< M, N, Order > > const &	Feel::vf::expression1 (std::pair< const std::string, std::pair< std::vector< Expr< GinacMatrix< M, N, Order > > >, std::set< std::string > > > const &p)

template<int M, int N, int Order, typename SymbExpr >
auto	Feel::vf::expression1 (std::pair< const std::string, std::pair< std::vector< Expr< GinacMatrix< M, N, Order > > >, std::set< std::string > > > const &p, SymbExpr const &se)

template<int Order>
scalar_field_expression< Order > &	Feel::vf::expression1 (std::pair< const std::string, std::pair< std::vector< scalar_field_expression< Order > >, std::set< std::string > > > &p)

template<int Order>
scalar_field_expression< Order > const &	Feel::vf::expression1 (std::pair< const std::string, std::pair< std::vector< scalar_field_expression< Order > >, std::set< std::string > > > const &p)

template<int Order, typename SymbExpr >
auto	Feel::vf::expression1 (std::pair< const std::string, std::pair< std::vector< scalar_field_expression< Order > >, std::set< std::string > > > const &p, SymbExpr const &se)

template<int M, int N, int Order>
Expr< GinacMatrix< M, N, Order > > &	Feel::vf::expression2 (std::pair< const std::string, std::pair< std::vector< Expr< GinacMatrix< M, N, Order > > >, std::set< std::string > > > &p)

template<int M, int N, int Order>
Expr< GinacMatrix< M, N, Order > > const &	Feel::vf::expression2 (std::pair< const std::string, std::pair< std::vector< Expr< GinacMatrix< M, N, Order > > >, std::set< std::string > > > const &p)

template<int M, int N, int Order, typename SymbExpr >
auto	Feel::vf::expression2 (std::pair< const std::string, std::pair< std::vector< Expr< GinacMatrix< M, N, Order > > >, std::set< std::string > > > const &p, SymbExpr const &se)

template<int Order>
scalar_field_expression< Order > &	Feel::vf::expression2 (std::pair< const std::string, std::pair< std::vector< scalar_field_expression< Order > >, std::set< std::string > > > &p)

template<int Order>
scalar_field_expression< Order > const &	Feel::vf::expression2 (std::pair< const std::string, std::pair< std::vector< scalar_field_expression< Order > >, std::set< std::string > > > const &p)

template<int Order, typename SymbExpr >
auto	Feel::vf::expression2 (std::pair< const std::string, std::pair< std::vector< scalar_field_expression< Order > >, std::set< std::string > > > const &p, SymbExpr const &se)

matrix	GiNaC::grad (ex const &f, std::vector< symbol > const &l)

template<int Dim, int M, int N, int Order, typename SymbolsExprType >
auto	Feel::vf::grad (Expr< GinacMatrix< M, N, Order, SymbolsExprType > > const &s, std::string filename="", WorldComm const &world=Environment::worldComm(), std::string const &dirLibExpr="")

template<int Dim, int M, int N, int Order, typename SymbolsExprType >
auto	Feel::vf::grad (Expr< GinacMatrix< M, N, Order, SymbolsExprType > > const &s, std::vector< std::string > const &gradSymbols, std::string filename="", WorldComm const &world=Environment::worldComm(), std::string const &dirLibExpr="")

matrix	GiNaC::grad (matrix const &f, std::vector< symbol > const &l)

matrix	GiNaC::grad (std::string const &s, std::vector< symbol > const &l)

matrix	GiNaC::laplacian (ex const &f, std::vector< symbol > const &l)

template<int Order, typename SymbolsExprType >
Expr< GinacMatrix< 1, 1, Order, SymbolsExprType > >	Feel::vf::laplacian (Expr< GinacExVF< Order, SymbolsExprType > > const &s, std::string filename="", WorldComm const &world=Environment::worldComm(), std::string const &dirLibExpr="")

template<int M, int N, int Order, typename SymbolsExprType >
Expr< GinacMatrix< M, N, Order, SymbolsExprType > >	Feel::vf::laplacian (Expr< GinacMatrix< M, N, Order, SymbolsExprType > > const &s, std::string filename="", WorldComm const &world=Environment::worldComm(), std::string const &dirLibExpr="")

matrix	GiNaC::laplacian (matrix const &f, std::vector< symbol > const &l)

matrix	GiNaC::laplacian (std::string const &s, std::vector< symbol > const &l)

ex	GiNaC::laplacian (std::string const &s, std::vector< symbol > const &l, std::vector< symbol > const &p)

template<int M, int N, int Order>
std::string const &FEELPP_DEPRECATED	Feel::vf::marker (std::pair< const std::string, std::pair< Expr< GinacMatrix< M, N, Order > >, std::set< std::string > > > const &p)

template<int Order>
std::string const &FEELPP_DEPRECATED	Feel::vf::marker (std::pair< const std::string, std::pair< scalar_field_expression< Order >, std::set< std::string > > > const &p)

template<int M, int N, int Order>
std::string const &FEELPP_DEPRECATED	Feel::vf::marker (std::pair< const std::string, std::pair< std::vector< Expr< GinacMatrix< M, N, Order > > >, std::set< std::string > > > const &p)

template<int Order>
std::string const &FEELPP_DEPRECATED	Feel::vf::marker (std::pair< const std::string, std::pair< std::vector< scalar_field_expression< Order > >, std::set< std::string > > > const &p)

template<int M, int N, int Order>
std::set< std::string > const &	Feel::vf::markers (std::pair< const std::string, std::pair< Expr< GinacMatrix< M, N, Order > >, std::set< std::string > > > const &p)

template<int Order>
std::set< std::string > const &	Feel::vf::markers (std::pair< const std::string, std::pair< scalar_field_expression< Order >, std::set< std::string > > > const &p)

template<int M, int N, int Order>
std::set< std::string > const &	Feel::vf::markers (std::pair< const std::string, std::pair< std::vector< Expr< GinacMatrix< M, N, Order > > >, std::set< std::string > > > const &p)

template<int Order>
std::set< std::string > const &	Feel::vf::markers (std::pair< const std::string, std::pair< std::vector< scalar_field_expression< Order > >, std::set< std::string > > > const &p)

template<int M, int N, int Order>
std::string const &	Feel::vf::name (std::pair< const std::string, std::pair< Expr< GinacMatrix< M, N, Order > >, std::set< std::string > > > const &p)

template<int Order>
std::string const &	Feel::vf::name (std::pair< const std::string, std::pair< scalar_field_expression< Order >, std::set< std::string > > > const &p)

template<int M, int N, int Order>
std::string const &	Feel::vf::name (std::pair< const std::string, std::pair< std::vector< Expr< GinacMatrix< M, N, Order > > >, std::set< std::string > > > const &p)

template<int Order>
std::string const &	Feel::vf::name (std::pair< const std::string, std::pair< std::vector< scalar_field_expression< Order > >, std::set< std::string > > > const &p)

int	Feel::vf::nbComp (std::string expression)

ex	GiNaC::parse (std::string const &str, std::vector< symbol > const &syms, std::vector< symbol > const &params)

std::string	GiNaC::str (ex &&f)

std::string	GiNaC::str (ex const &f)

ex	GiNaC::substitute (ex const &f, symbol const &s, const double val)

ex	GiNaC::substitute (ex const &f, symbol const &s, ex const &g)

matrix	GiNaC::substitute (matrix const &f, symbol const &s, const double val)

matrix	GiNaC::substitute (matrix const &f, symbol const &s, ex const &g)

template<int Dim>
std::vector< symbol >	Feel::symbols ()

std::vector< symbol >	Feel::symbols (std::initializer_list< std::string > l)

std::vector< symbol >	Feel::symbols (std::vector< std::string > const &symbNames, std::vector< GiNaC::symbol > const &symbExisting)

std::vector< symbol >	Feel::symbols (std::vector< std::string > l)

template<>
std::vector< symbol >	Feel::symbols< 1 > ()

template<>
std::vector< symbol >	Feel::symbols< 2 > ()

template<>
std::vector< symbol >	Feel::symbols< 3 > ()

std::vector< std::pair< bool, double > >	GiNaC::toNumericValues (ex const &expr)
	get real values of an expression (can be a list) if it is a numeric expression More...

int	GiNaC::totalDegree (ex const &expr, std::vector< std::pair< symbol, Feel::uint16_type > > const &symbolsDegree)
	get total degree of a polynomial More...

Detailed Description

Author: Christophe Prud'homme chris.nosp@m.toph.nosp@m.e.pru.nosp@m.dhom.nosp@m.me@fe.nosp@m.elpp.nosp@m..org

Date: 2012-10-15

Typedef Documentation

◆ map_matrix_field

template<int M, int N, int Order = 2>

using Feel::vf::map_matrix_field = typedef map_vector_field<M,N,Order>

define a matrix field map.

providing M and N is required

Function Documentation

◆ diff()

template<typename ExprT , int Order = 2>

Expr< GinacExVF< Order, symbols_expression_t< SymbolExpr< ExprT > > > > Feel::vf::diff	(	std::string const &	s,
		std::string const &	ds,
		std::string const &	se,
		ExprT const &	e,
		std::string	filename = `""`,
		WorldComm const &	world = `Environment::worldComm()`,
		std::string const &	dirLibExpr = `""`
	)

Create an Feel++ expression from a GiNaC expression as a string.

Template Parameters

Order Expression order

Parameters

s	String containing the ginac expression and symbols
ds	String containing the ginac symbol with respect to which `s` is differentiated
se	String containing the ginac symbol associated to a Feel++ expression (e.g. a finite element field)
filename	Shared file

Returns: Feel++ Expression

References Feel::expr().

◆ expr() [1/8]

Expr< GinacEx< 2 > > Feel::vf::expr	(	const char *	s_,
		std::string	filename = `""`,
		WorldComm const &	world = `Environment::worldComm()`,
		std::string const &	dirLibExpr = `""`
	)

Create an Feel++ expression from a GiNaC expression as a string.

Parameters

s	String containing the ginac expression and symbols
filename	Shared file

Returns: Feel++ Expression

◆ expr() [2/8]

Expr< GinacEx<> > Feel::vf::expr ( double value )

Create an Feel++ expression from a GiNaC expression as a string.

Parameters

value The value of the expression

Returns: Feel++ Expression

◆ expr() [3/8]

Expr< GinacEx< 2 > > Feel::vf::expr	(	std::string const &	s,
		std::map< std::string, double > const &	mp,
		std::string	filename = `""`,
		WorldComm const &	world = `Environment::worldComm()`,
		std::string const &	dirLibExpr = `""`
	)

Create an Feel++ expression from a GiNaC expression as a string.

Parameters

s	String containing the ginac expression and symbols
mp	Map containing cst symbol and their values to apply
filename	Shared file

Returns: Feel++ Expression

References Feel::expr().

◆ expr() [4/8]

template<int Order>

Expr< GinacEx< Order > > Feel::vf::expr	(	std::string const &	s,
		std::map< std::string, double > const &	mp,
		std::string	filename = `""`,
		WorldComm const &	world = `Environment::worldComm()`,
		std::string const &	dirLibExpr = `""`
	)

Create an Feel++ expression from a GiNaC expression as a string.

Template Parameters

Order Expression order

Parameters

s	String containing the ginac expression and symbols
mp	Map containing cst symbol and their values to apply
filename	Shared file

Returns: Feel++ Expression

◆ expr() [5/8]

Expr< GinacEx< 2 > > Feel::vf::expr	(	std::string const &	s,
		std::string const &	filename = `""`,
		WorldComm const &	world = `Environment::worldComm()`,
		std::string const &	dirLibExpr = `""`
	)

Create an Feel++ expression from a GiNaC expression as a string.

Parameters

s	String containing the ginac expression and symbols
filename	Shared file

Returns: Feel++ Expression

◆ expr() [6/8]

template<typename ExprT , int Order = 2>

Expr< GinacExVF< Order, symbols_expression_t< SymbolExpr< ExprT > > > > Feel::vf::expr	(	std::string const &	s,
		std::string const &	se,
		ExprT const &	e,
		std::string	filename = `""`,
		WorldComm const &	world = `Environment::worldComm()`,
		std::string const &	dirLibExpr = `""`
	)

Create an Feel++ expression from a GiNaC expression as a string.

Template Parameters

Order Expression order

Parameters

s	String containing the ginac expression and symbols
se	String containing the ginac symbol associated to a Feel++ expression (e.g. a finite element field)
filename	Shared file

Returns: Feel++ Expression

◆ expr() [7/8]

template<int Order>

Expr< GinacEx< Order > > Feel::vf::expr	(	std::string const &	s,
		std::string	filename = `""`,
		WorldComm const &	world = `Environment::worldComm()`,
		std::string const &	dirLibExpr = `""`
	)

Create an Feel++ expression from a GiNaC expression as a string.

Template Parameters

Order Expression order

Parameters

s	String containing the ginac expression and symbols
filename	Shared file

Returns: Feel++ Expression

◆ expr() [8/8]

template<int M, int N, int Order = 2>

Expr< GinacMatrix< M, N, Order > > Feel::vf::expr	(	std::string const &	s,
		std::string	filename = `""`,
		WorldComm const &	world = `Environment::worldComm()`,
		std::string const &	dirLibExpr = `""`
	)

Create an Feel++ expression from a GiNaC expression as a string.

Template Parameters

Order Expression order

Parameters

s	String containing the ginac expression and symbols
filename	Shared file

Returns: Feel++ Expression

◆ toNumericValues()

std::vector< std::pair< bool, double > > GiNaC::toNumericValues ( ex const & expr )

get real values of an expression (can be a list) if it is a numeric expression

Parameters

expr	: the expression to test

Returns: vector of ( is numeric, value )

References GiNaC::toNumericValues().

Referenced by GiNaC::toNumericValues().

◆ totalDegree()

int GiNaC::totalDegree	(	ex const &	expr,
		std::vector< std::pair< symbol, Feel::uint16_type > > const &	symbolsDegree
	)

get total degree of a polynomial

Parameters

expr	: a polynom expression
symbolsDegree	: vector of (symbol, unit degree for the symbol) which impact the total degree of polynomial

Returns: total degree of a polynomial

Classes

Namespaces

Typedefs

Functions

Detailed Description

Typedef Documentation

◆ map_matrix_field

Function Documentation

◆ diff()

◆ expr() [1/8]

◆ expr() [2/8]

◆ expr() [3/8]

◆ expr() [4/8]

◆ expr() [5/8]

◆ expr() [6/8]

◆ expr() [7/8]

◆ expr() [8/8]

◆ toNumericValues()

◆ totalDegree()