codac2::FunctionBase< E > Class Template Reference

A base class for functions (either analytic functions, or set functions). More...

#include <codac2_FunctionBase.h>

Collaboration diagram for codac2::FunctionBase< E >:

Public Member Functions
	FunctionBase (const std::vector< std::reference_wrapper< VarBase > > &args, const std::shared_ptr< E > &y)
	Constructs a FunctionBase with a list of arguments and a shared pointer to an output expression.
	FunctionBase (const FunctionArgsList &args, const std::shared_ptr< E > &y)
	Constructs a FunctionBase with a list of arguments and a shared pointer to an output expression.
	FunctionBase (const FunctionBase< E > &f)
	Copy constructor.
virtual	~FunctionBase ()
	Virtual destructor.
const FunctionArgsList &	args () const
	Returns the arguments of the function.
const std::shared_ptr< E > &	expr () const
	Returns the expression associated with the function.
template<typename... X>
std::shared_ptr< E >	operator() (const X &... x) const
	Applies this function to the arguments and returns the resulting expression.
std::shared_ptr< E >	operator() (const std::vector< std::shared_ptr< ExprBase > > &x) const
	Applies this function to the arguments and returns the resulting expression.
Index	input_size () const
	Calculates the total size of the function arguments, as the sum of the sizes of each argument.

Protected Member Functions
template<typename X>
std::shared_ptr< X >	__get_copy (std::shared_ptr< X > x) const
	Helper function to get a copy of a an expression.
template<typename X>
std::shared_ptr< ExprBase >	__get_copy (const AnalyticExprWrapper< X > &x) const
	Helper function to get a copy of an AnalyticExprWrapper.
template<typename A>
auto	__get_copy (const A &x) const
	Helper function to get a copy of various expression types.

Protected Attributes
const std::shared_ptr< E >	_y
	expression that defines the function
const FunctionArgsList	_args
	arguments of the function

Detailed Description

template<typename E>
class codac2::FunctionBase< E >

A base class for functions (either analytic functions, or set functions).

The FunctionBase class represents a generic function that operates on expressions. It allows defining functions that take a list of arguments and apply a specific expression to those arguments.

This class serves as a base for creating specific types of functions by providing the mechanism to handle arguments and perform the function application.

Note that a function may be invoked in another expression, by using the operator() which allows compositions of functions. For such call, the arguments of this operator are either other function variables or any expressions.

Template Parameters

E	The type of the output expression of this function.

Constructor & Destructor Documentation

FunctionBase() [1/3]

template<typename E>

codac2::FunctionBase< E >::FunctionBase ( const std::vector< std::reference_wrapper< VarBase > > & args, const std::shared_ptr< E > & y )

inline

Constructs a FunctionBase with a list of arguments and a shared pointer to an output expression.

The arguments are stored as a FunctionArgsList, and the expression is deep-copied.

Parameters

args	A reference to a vector of VarBase references representing the function's arguments.
y	A shared pointer to the expression that defines the function.

        : FunctionBase(FunctionArgsList(args),y)
      { }

FunctionBase() [2/3]

template<typename E>

codac2::FunctionBase< E >::FunctionBase ( const FunctionArgsList & args, const std::shared_ptr< E > & y )

inline

Constructs a FunctionBase with a list of arguments and a shared pointer to an output expression.

The expression is deep-copied.

Parameters

args	A FunctionArgsList containing the function's arguments.
y	A shared pointer to the function's expression.

        : _y(std::dynamic_pointer_cast<E>(y->copy())), _args(args)
      { }

FunctionBase() [3/3]

template<typename E>

codac2::FunctionBase< E >::FunctionBase ( const FunctionBase< E > & f )

inline

Copy constructor.

The expression is deep-copied.

Parameters

f	The FunctionBase instance to copy.

        : _y(std::dynamic_pointer_cast<E>(f.expr()->copy())), _args(f.args()) // todo: keep this dynamic_pointer_cast?
      { }

~FunctionBase()

template<typename E>

virtual codac2::FunctionBase< E >::~FunctionBase ( )

inlinevirtual

Virtual destructor.

The destructor is virtual to ensure proper cleanup of derived classes when an object of a derived class is deleted through a pointer to FunctionBase.

      { }

Member Function Documentation

args()

template<typename E>

const FunctionArgsList & codac2::FunctionBase< E >::args ( ) const

inline

Returns the arguments of the function.

Returns

A constant reference to the FunctionArgsList containing the function's arguments.

      {
        return _args;
      }

expr()

template<typename E>

const std::shared_ptr< E > & codac2::FunctionBase< E >::expr ( ) const

inline

Returns the expression associated with the function.

Returns

A constant reference to the shared pointer to the function's expression.

      {
        return _y;
      }

operator()() [1/2]

template<typename E>

template<typename... X>

std::shared_ptr< E > codac2::FunctionBase< E >::operator() ( const X &... x ) const

inline

Applies this function to the arguments and returns the resulting expression.

The method deep-copies the expressions provided as arguments and replaces the arguments in the expression with the provided ones.

Parameters

x	The arguments to apply to the function, for instance expressions or variables.

Returns

A shared pointer to the resulting expression after the arguments have been replaced.

      {
        auto expr_copy = expr()->copy();
        size_t i = 0;
        (expr_copy->replace_arg(_args[i++]->unique_id(), this->__get_copy(x)), ...);
        assert_release(i == this->args().size() && 
          "Invalid arguments: wrong number of input arguments");
        return std::dynamic_pointer_cast<E>(expr_copy);
      }

operator()() [2/2]

template<typename E>

std::shared_ptr< E > codac2::FunctionBase< E >::operator() ( const std::vector< std::shared_ptr< ExprBase > > & x ) const

inline

Applies this function to the arguments and returns the resulting expression.

The method deep-copies the expressions provided as arguments and replaces the arguments in the expression with the provided ones.

This method is mainly used for Python binding.

Parameters

x	A vector of shared pointers to arguments to apply to the function, for instance expressions or variables.

Returns

A shared pointer to the resulting expression after the arguments have been replaced.

      {
        assert_release(x.size() == this->args().size() && 
          "Invalid arguments: wrong number of input arguments");
        auto expr_copy = expr()->copy();
        for(size_t i = 0 ; i < x.size() ; i++)
          expr_copy->replace_arg(_args[i]->unique_id(), x[i]->copy());
        return std::dynamic_pointer_cast<E>(expr_copy);
      }

input_size()

template<typename E>

Index codac2::FunctionBase< E >::input_size ( ) const

inline

Calculates the total size of the function arguments, as the sum of the sizes of each argument.

Returns

The sum of the sizes of all arguments.

      {
        return this->_args.total_size();
      }

__get_copy() [1/3]

template<typename E>

template<typename X>

std::shared_ptr< X > codac2::FunctionBase< E >::__get_copy ( std::shared_ptr< X > x ) const

inlineprotected

Helper function to get a copy of a an expression.

Template Parameters

X	The type of the expression to copy.

Parameters

x	A shared pointer to the expression to copy.

Returns

A shared pointer to the copied expression.

      {
        return std::dynamic_pointer_cast<X>(x->copy());
      }

__get_copy() [2/3]

template<typename E>

template<typename X>

std::shared_ptr< ExprBase > codac2::FunctionBase< E >::__get_copy ( const AnalyticExprWrapper< X > & x ) const

inlineprotected

Helper function to get a copy of an AnalyticExprWrapper.

Template Parameters

X	The type of the expression to copy.

Parameters

x	The AnalyticExprWrapper to copy.

Returns

A shared pointer to the copied expression.

      {
        return x->copy();
      }

__get_copy() [3/3]

template<typename E>

template<typename A>

auto codac2::FunctionBase< E >::__get_copy ( const A & x ) const

inlineprotected

Helper function to get a copy of various expression types.

Template Parameters

A	The type of the expression.

Parameters

x	The expression to copy.

Returns

A shared pointer to the copied expression.

      {
        if constexpr(std::is_base_of_v<VarBase,A>)
          return std::dynamic_pointer_cast<A>(x.copy());
        else
        {
          // todo: make this generic (analytic / set):
          return const_value(x);
        }
      }

---

The documentation for this class was generated from the following file:

• /home/simon/codac-simon/src/core/functions/codac2_FunctionBase.h