ADORe
ADORe is a modular open source software library and toolkit for decision making, planning, control and simulation of automated vehicles
adore::mad::funop Namespace Reference

Functions

template<typename DT , typename CT >
ALFunction< DT, CT > * add (ALFunction< DT, CT > *a, ALFunction< DT, CT > *b)
 
template<typename DT , typename CT , typename CTa , typename CTb >
ALFunction< DT, CT > * multiply (ALFunction< DT, CTa > *a, ALFunction< DT, CTb > *b)
 
template<typename T , int N, int M, int K>
ALFunction< T, adoreMatrix< T, N, K > > * mmultiply (ALFunction< T, adoreMatrix< T, N, M > > *a, ALFunction< T, adoreMatrix< T, M, K > > *b)
 
template<typename DT , typename CT , typename CTa , typename CTb >
FunctionCombination_MultiplicationConst< DT, CT, CTa, CTb > * minus (ALFunction< DT, CTb > *b)
 
template<typename DTa , typename CTa , typename DTb >
ALFunction< DTb, CTa > * chain (ALFunction< DTa, CTa > *a, ALFunction< DTb, DTa > *b)
 
template<typename T , int Na, int Nb>
ALFunction< T, adoreMatrix< T, Na+Nb, 1 > > * stack (ALFunction< T, adoreMatrix< T, Na, 1 >> *a, ALFunction< T, adoreMatrix< T, Nb, 1 >> *b)
 
template<typename T >
AScalarToN< T, 2 > * stack (ALFunction< T, T > *a, ALFunction< T, T > *b)
 
template<typename DT , typename CT >
ALFunction< DT, CT > * stretch (ALFunction< DT, CT > *f, DT from, DT to)
 
template<typename T >
ALFunction< T, T > * reciprocal (ALFunction< T, T > *divisor)
 
template<typename T >
ALFunction< T, T > * heading (AScalarToN< T, 2 > *df)
 
template<typename T >
ALFunction< T, adoreMatrix< T, 2, 1 > > * rotate (ALFunction< T, T > *angle, ALFunction< T, adoreMatrix< T, 2, 1 >> *vector)
 

Function Documentation

◆ add()

template<typename DT , typename CT >
ALFunction<DT, CT>* adore::mad::funop::add ( ALFunction< DT, CT > *  a,
ALFunction< DT, CT > *  b 
)

addition of two functions a,b:DT->CT

Here is the caller graph for this function:

◆ chain()

template<typename DTa , typename CTa , typename DTb >
ALFunction<DTb, CTa>* adore::mad::funop::chain ( ALFunction< DTa, CTa > *  a,
ALFunction< DTb, DTa > *  b 
)

chaining of functions a: DTI->CT, b: DT->DTI , f(x) = a(b(x)), f: DT->CT

Here is the caller graph for this function:

◆ heading()

template<typename T >
ALFunction<T, T>* adore::mad::funop::heading ( AScalarToN< T, 2 > *  df)

computes the heading of arbitrary (differentiable) paths

Here is the caller graph for this function:

◆ minus()

template<typename DT , typename CT , typename CTa , typename CTb >
FunctionCombination_MultiplicationConst<DT, CT, CTa, CTb>* adore::mad::funop::minus ( ALFunction< DT, CTb > *  b)

the negative of a function

◆ mmultiply()

template<typename T , int N, int M, int K>
ALFunction<T, adoreMatrix<T,N,K> >* adore::mad::funop::mmultiply ( ALFunction< T, adoreMatrix< T, N, M > > *  a,
ALFunction< T, adoreMatrix< T, M, K > > *  b 
)

matrix multiplication of two functions a:DT->CTa, b:DT->CTb. Make sure that CT is chosen so that a(x)*b(x) \in CT

◆ multiply()

template<typename DT , typename CT , typename CTa , typename CTb >
ALFunction<DT, CT>* adore::mad::funop::multiply ( ALFunction< DT, CTa > *  a,
ALFunction< DT, CTb > *  b 
)

multiplication (and matrix multiplication) of two functions a:DT->CTa, b:DT->CTb. Make sure that CT is chosen so that a(x)*b(x) \in CT

◆ reciprocal()

template<typename T >
ALFunction<T, T>* adore::mad::funop::reciprocal ( ALFunction< T, T > *  divisor)

◆ rotate()

template<typename T >
ALFunction<T, adoreMatrix<T, 2, 1> >* adore::mad::funop::rotate ( ALFunction< T, T > *  angle,
ALFunction< T, adoreMatrix< T, 2, 1 >> *  vector 
)

rotate a 2d vector function

Here is the caller graph for this function:

◆ stack() [1/2]

template<typename T , int Na, int Nb>
ALFunction<T, adoreMatrix<T, Na + Nb, 1> >* adore::mad::funop::stack ( ALFunction< T, adoreMatrix< T, Na, 1 >> *  a,
ALFunction< T, adoreMatrix< T, Nb, 1 >> *  b 
)

stack - row-wise combination of functions: a:T->T^Na, b:T->T^Nb => f:T->T^(Na+Nb)

Here is the caller graph for this function:

◆ stack() [2/2]

template<typename T >
AScalarToN<T, 2>* adore::mad::funop::stack ( ALFunction< T, T > *  a,
ALFunction< T, T > *  b 
)

◆ stretch()

template<typename DT , typename CT >
ALFunction<DT, CT>* adore::mad::funop::stretch ( ALFunction< DT, CT > *  f,
DT  from,
DT  to 
)

stretch - relocate the function's output to a different interval of input values if from > to, the direction of the function is inverted

Here is the call graph for this function:
Here is the caller graph for this function: