ADORe
ADORe is a modular open source software library and toolkit for decision making, planning, control and simulation of automated vehicles
adore::mad::LLinearPiecewiseFunctionM< T, n > Class Template Reference

#include <llinearpiecewisefunction.h>

Inheritance diagram for adore::mad::LLinearPiecewiseFunctionM< T, n >:
Inheritance graph
Collaboration diagram for adore::mad::LLinearPiecewiseFunctionM< T, n >:
Collaboration graph

Classes

class  OneDimension
 

Public Types

typedef adoreMatrix< T, n, 1 > CT
 
typedef AScalarToN< T, n >::DT DT
 
- Public Types inherited from adore::mad::AScalarToN< T, n >
typedef T DT
 
typedef adoreMatrix< T, N, 1 > CT
 
typedef ALFunction< DT, T > SUBFUN
 

Public Member Functions

adoreMatrix< T, n+1, 0 > & getData ()
 
const adoreMatrix< T, n+1, 0 > & getData () const
 
unsigned int findIndex (DT x, DT precision=0.001) const
 
virtual CT f (DT x) const override
 
virtual DT limitHi () const override
 
virtual DT limitLo () const override
 
virtual void setLimits (DT lo, DT hi) override
 
virtual ALFunction< DT, CT > * create_derivative () override
 
virtual void bound (const DT &xmin, const DT &xmax, CT &ymin, CT &ymax) override
 
virtual double limit_s_to_bounds (double s) const
 shifts s to be in between limitLo and limitHi More...
 
virtual void invertDomain ()
 
virtual void startDomainAtZero ()
 
void shiftDomain (DT dx)
 
virtual void stretchDomain (DT x0, DT x1)
 
void shiftCodomain (CT dy)
 
void shiftCodomain (T dy, int i=0)
 
void rotateXY (double angle, double x0=0.0, double y0=0.0)
 
virtual T fi (DT x, int row) const override
 
virtual T dfidx (DT x, int row)
 
void sample_dfidx (DT *xvec, T *yvec, int count, int row)
 
virtual ALFunction< DT, T > * dimension (int i) override
 
 LLinearPiecewiseFunctionM ()
 
LLinearPiecewiseFunctionMoperator= (const LLinearPiecewiseFunctionM &other)
 
 LLinearPiecewiseFunctionM (const LLinearPiecewiseFunctionM &other)
 
 LLinearPiecewiseFunctionM (const adoreMatrix< T, n+1, 0 > &data)
 
 LLinearPiecewiseFunctionM (const adoreMatrix< T, 1, 0 > &xdata, const adoreMatrix< T, n, 0 > &ydata)
 
 LLinearPiecewiseFunctionM (const int nc, T value)
 
virtual ~LLinearPiecewiseFunctionM ()
 
virtual ALFunction< DT, CT > * clone () override
 
void setData (const adoreMatrix< T, n+1, 0 > &data)
 
virtual void multiply (adoreMatrix< T, 0, 0 > A, int rowi, int rowj) override
 
virtual void add (adoreMatrix< T, 0, 1 > b, int rowi, int rowj) override
 
std::vector< std::pair< T, T > > * getIntersections2d (LLinearPiecewiseFunctionM< T, n > *other, int dim1, int dim2)
 
std::vector< std::pair< T, T > > * getIntersections2d (LLinearPiecewiseFunctionM< T, n > *other)
 
bool getFirstIntersection2d (LLinearPiecewiseFunctionM< T, n > *other, int dim1, int dim2, std::pair< T, T > &result)
 
bool getFirstIntersection2d (LLinearPiecewiseFunctionM< T, n > *other, std::pair< T, T > &result)
 
bool getFirstIntersection1d (T y_cross, int dimension, T &x)
 
bool getFirstIntersection1d (T y_cross, T &x)
 
bool getFirstIntersection1d (LLinearPiecewiseFunctionM< T, n > *other, int dim, std::pair< T, T > &result)
 
bool getNextIntersectionWithLine2d (T x0, T px, T py, T vx, T vy, int d1, int d2, T &x_result, T &distance, bool extend_fringes=false, bool inside_input_line=false)
 
bool getNextIntersectionWithLine2d (T x0, T px, T py, T vx, T vy, T &x_result, T &distance, bool extend_fringes=false)
 
bool getNextIntersectionWithVector2d (T x0, T px, T py, T vx, T vy, T &x_result, T &distance, T max_distance, bool extend_fringes=false)
 
int countIntersectionsWithRay2d (T px, T py, int d1, int d2, T ex, T ey, bool inverted=false)
 
double getPositionOfPoint (T px, T py, int d1, int d2, T &d_tangential_min, T &d_normal_min)
 
double getClosestParameter (T px, T py, int d1, int d2, T &n_min) const
 
double getClosestParameter_local (T px, T py, int d1, int d2, T x0, T *n_min=nullptr) const
 
double getClosestParameter (T px, T py, int d1, int d2) const
 
bool isPointEnclosed (LLinearPiecewiseFunctionM< T, n > *other, T px, T py, int d1, int d2, bool invert_this=false, bool invert_other=true)
 
getXAfterNPoints (T xstart, int N)
 
void writePointsToArray (int i, int j, T *m)
 
void writePointsToArray (int i, int j, int d, T *m)
 
int export_points (adoreMatrix< double, 0, 0 > &target, double x0, double x1, double precision)
 
- Public Member Functions inherited from adore::mad::AScalarToN< T, n >
void toArray (DT *xvec, T *yvec, unsigned int count)
 
void toArray (DT *xvec, T *yvec, unsigned int count, unsigned int row)
 
virtual T fi (DT x, int dim) const=0
 
virtual void operator*= (adoreMatrix< T, N, N > A)
 
virtual void operator+= (adoreMatrix< T, N, 1 > b)
 
virtual void operator-= (adoreMatrix< T, N, 1 > b)
 
- Public Member Functions inherited from adore::mad::ALFunction< T, adoreMatrix< T, N, 1 > >
virtual void setLimits (T lo, T hi)=0
 
virtual adoreMatrix< T, N, 1 > f (T x) const=0
 
virtual void f (T *xvec, adoreMatrix< T, N, 1 > *yvec, unsigned int count) const
 
virtual void bound (const T &xmin, const T &xmax, adoreMatrix< T, N, 1 > &ymin, adoreMatrix< T, N, 1 > &ymax)=0
 
void bound (adoreMatrix< T, N, 1 > &ymin, adoreMatrix< T, N, 1 > &ymax)
 
virtual ~ALFunction ()
 
 ALFunction ()
 
const adoreMatrix< T, N, 1 > operator() (T x) const
 
bool isInDomain (T x)
 
adoreMatrix< T, N, 1 > f_bounded (T x)
 
void invalidateCachedBounds ()
 

Private Attributes

adoreMatrix< T, n+1, 0 > m_data
 
unsigned int m_searchIndex
 
OneDimension single_dimensions [n]
 

Detailed Description

template<typename T, int n>
class adore::mad::LLinearPiecewiseFunctionM< T, n >

LPiecewiseFunction - a linear interpolation function based on a matrix object, f: DT^1 --> T^n

Member Typedef Documentation

◆ CT

template<typename T , int n>
typedef adoreMatrix<T, n, 1> adore::mad::LLinearPiecewiseFunctionM< T, n >::CT

◆ DT

template<typename T , int n>
typedef AScalarToN<T,n>::DT adore::mad::LLinearPiecewiseFunctionM< T, n >::DT

Constructor & Destructor Documentation

◆ LLinearPiecewiseFunctionM() [1/5]

template<typename T , int n>
adore::mad::LLinearPiecewiseFunctionM< T, n >::LLinearPiecewiseFunctionM ( )
inline

constructor without initialization

◆ LLinearPiecewiseFunctionM() [2/5]

template<typename T , int n>
adore::mad::LLinearPiecewiseFunctionM< T, n >::LLinearPiecewiseFunctionM ( const LLinearPiecewiseFunctionM< T, n > &  other)
inline

copy constructor

◆ LLinearPiecewiseFunctionM() [3/5]

template<typename T , int n>
adore::mad::LLinearPiecewiseFunctionM< T, n >::LLinearPiecewiseFunctionM ( const adoreMatrix< T, n+1, 0 > &  data)
inline

constructor: initialize with data matrix containing domain and codomain

◆ LLinearPiecewiseFunctionM() [4/5]

template<typename T , int n>
adore::mad::LLinearPiecewiseFunctionM< T, n >::LLinearPiecewiseFunctionM ( const adoreMatrix< T, 1, 0 > &  xdata,
const adoreMatrix< T, n, 0 > &  ydata 
)
inline

constructor: initialize with two data matrices containing domain and codomain separately

◆ LLinearPiecewiseFunctionM() [5/5]

template<typename T , int n>
adore::mad::LLinearPiecewiseFunctionM< T, n >::LLinearPiecewiseFunctionM ( const int  nc,
value 
)
inline

constructor: dynamically sized matrix, initialized with a single value

◆ ~LLinearPiecewiseFunctionM()

template<typename T , int n>
virtual adore::mad::LLinearPiecewiseFunctionM< T, n >::~LLinearPiecewiseFunctionM ( )
inlinevirtual

Member Function Documentation

◆ add()

template<typename T , int n>
virtual void adore::mad::LLinearPiecewiseFunctionM< T, n >::add ( adoreMatrix< T, 0, 1 >  b,
int  rowi,
int  rowj 
)
inlineoverridevirtual

apply operation to function sub-dimensions: add vector b to dimensions rowi to rowj

Implements adore::mad::AScalarToN< T, n >.

Here is the caller graph for this function:

◆ bound()

template<typename T , int n>
virtual void adore::mad::LLinearPiecewiseFunctionM< T, n >::bound ( const DT xmin,
const DT xmax,
CT ymin,
CT ymax 
)
inlineoverridevirtual
Here is the call graph for this function:
Here is the caller graph for this function:

◆ clone()

template<typename T , int n>
virtual ALFunction<DT, CT>* adore::mad::LLinearPiecewiseFunctionM< T, n >::clone ( )
inlineoverridevirtual

create a copy of child class object - is used for function operations

Implements adore::mad::ALFunction< T, adoreMatrix< T, N, 1 > >.

Here is the caller graph for this function:

◆ countIntersectionsWithRay2d()

template<typename T , int n>
int adore::mad::LLinearPiecewiseFunctionM< T, n >::countIntersectionsWithRay2d ( px,
py,
int  d1,
int  d2,
ex,
ey,
bool  inverted = false 
)
inline

countIntersectionsWithRay2d - sends a ray starting at px,py in direction of x axis and counts intersections with the lines of this object. dimensions d1 and d2 are used. furthermore, an extension point (ex,ey) is given, which allows to test another line from last point to (ex,ey) The method can be used to test for a point (px,py) whether it is inside the polygon defined by this function object: Unequal number of intersections <=> point is inside specify (ex,ey) as first point of this function object to close the loop of the line sequence. specify (ex,ey) as first point fo next function object to test line sequence consisting of multiple function objects https://en.wikipedia.org/wiki/Point_in_polygon

Here is the caller graph for this function:

◆ create_derivative()

template<typename T , int n>
virtual ALFunction<DT, CT>* adore::mad::LLinearPiecewiseFunctionM< T, n >::create_derivative ( )
inlineoverridevirtual

create a new function object, which is the derivative function

Implements adore::mad::ALFunction< T, adoreMatrix< T, N, 1 > >.

◆ dfidx()

template<typename T , int n>
virtual T adore::mad::LLinearPiecewiseFunctionM< T, n >::dfidx ( DT  x,
int  row 
)
inlinevirtual

numerical gradient: get a singular value from vector codomain type

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

◆ dimension()

template<typename T , int n>
virtual ALFunction<DT, T>* adore::mad::LLinearPiecewiseFunctionM< T, n >::dimension ( int  i)
inlineoverridevirtual

get access to a scalar version of this function

Implements adore::mad::AScalarToN< T, n >.

Here is the caller graph for this function:

◆ export_points()

template<typename T , int n>
int adore::mad::LLinearPiecewiseFunctionM< T, n >::export_points ( adoreMatrix< double, 0, 0 > &  target,
double  x0,
double  x1,
double  precision 
)
inline

export points between x0 and x1 values to a matrix

Here is the call graph for this function:

◆ f()

template<typename T , int n>
virtual CT adore::mad::LLinearPiecewiseFunctionM< T, n >::f ( DT  x) const
inlineoverridevirtual
Here is the call graph for this function:
Here is the caller graph for this function:

◆ fi()

template<typename T , int n>
virtual T adore::mad::LLinearPiecewiseFunctionM< T, n >::fi ( DT  x,
int  row 
) const
inlineoverridevirtual

get a singular value from vector codomain type

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

◆ findIndex()

template<typename T , int n>
unsigned int adore::mad::LLinearPiecewiseFunctionM< T, n >::findIndex ( DT  x,
DT  precision = 0.001 
) const
inline
Here is the call graph for this function:
Here is the caller graph for this function:

◆ getClosestParameter() [1/2]

template<typename T , int n>
double adore::mad::LLinearPiecewiseFunctionM< T, n >::getClosestParameter ( px,
py,
int  d1,
int  d2 
) const
inline
Here is the call graph for this function:

◆ getClosestParameter() [2/2]

template<typename T , int n>
double adore::mad::LLinearPiecewiseFunctionM< T, n >::getClosestParameter ( px,
py,
int  d1,
int  d2,
T &  n_min 
) const
inline

returns the parameter of the function value at dimensions d1,d2 with closest euclidean distance to px,py

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

◆ getClosestParameter_local()

template<typename T , int n>
double adore::mad::LLinearPiecewiseFunctionM< T, n >::getClosestParameter_local ( px,
py,
int  d1,
int  d2,
x0,
T *  n_min = nullptr 
) const
inline

returns the parameter of the function value at dimensions d1,d2 with closest euclidean distance to px,py, local search starting at x0

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

◆ getData() [1/2]

template<typename T , int n>
adoreMatrix<T, n + 1, 0>& adore::mad::LLinearPiecewiseFunctionM< T, n >::getData ( )
inline

◆ getData() [2/2]

template<typename T , int n>
const adoreMatrix<T, n + 1, 0>& adore::mad::LLinearPiecewiseFunctionM< T, n >::getData ( ) const
inline

◆ getFirstIntersection1d() [1/3]

template<typename T , int n>
bool adore::mad::LLinearPiecewiseFunctionM< T, n >::getFirstIntersection1d ( LLinearPiecewiseFunctionM< T, n > *  other,
int  dim,
std::pair< T, T > &  result 
)
inline

one dimensional intersection test

Parameters
dimdimension to be tested
resultfirst intersection: domain values of intersection point
Returns
true if other and this intersect in dimension dim
Here is the call graph for this function:

◆ getFirstIntersection1d() [2/3]

template<typename T , int n>
bool adore::mad::LLinearPiecewiseFunctionM< T, n >::getFirstIntersection1d ( y_cross,
int  dimension,
T &  x 
)
inline

getFirstIntersection1d - zero crossing test returns true, if a "zero" crossing happens tests for crossing y_cross value in dimension "dimension" the x coordinate is written in x, if a crossing occurs

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

◆ getFirstIntersection1d() [3/3]

template<typename T , int n>
bool adore::mad::LLinearPiecewiseFunctionM< T, n >::getFirstIntersection1d ( y_cross,
T &  x 
)
inline
Here is the call graph for this function:

◆ getFirstIntersection2d() [1/2]

template<typename T , int n>
bool adore::mad::LLinearPiecewiseFunctionM< T, n >::getFirstIntersection2d ( LLinearPiecewiseFunctionM< T, n > *  other,
int  dim1,
int  dim2,
std::pair< T, T > &  result 
)
inline

computes the first intersection between two line sequences, with first seen from perspective of this returns true if an intersection was found and then writes domain values for intersection into result, with first for this and second for other.

Here is the caller graph for this function:

◆ getFirstIntersection2d() [2/2]

template<typename T , int n>
bool adore::mad::LLinearPiecewiseFunctionM< T, n >::getFirstIntersection2d ( LLinearPiecewiseFunctionM< T, n > *  other,
std::pair< T, T > &  result 
)
inline
Here is the call graph for this function:

◆ getIntersections2d() [1/2]

template<typename T , int n>
std::vector<std::pair<T, T> >* adore::mad::LLinearPiecewiseFunctionM< T, n >::getIntersections2d ( LLinearPiecewiseFunctionM< T, n > *  other)
inline
Here is the call graph for this function:

◆ getIntersections2d() [2/2]

template<typename T , int n>
std::vector<std::pair<T, T> >* adore::mad::LLinearPiecewiseFunctionM< T, n >::getIntersections2d ( LLinearPiecewiseFunctionM< T, n > *  other,
int  dim1,
int  dim2 
)
inline

test whether this and other intersect in dimension d1 and d2 - a vector of pairs of x-values (domain) is returned, with one entry for every intersection and the first entry in a pair for this and the second entry for other

Here is the caller graph for this function:

◆ getNextIntersectionWithLine2d() [1/2]

template<typename T , int n>
bool adore::mad::LLinearPiecewiseFunctionM< T, n >::getNextIntersectionWithLine2d ( x0,
px,
py,
vx,
vy,
int  d1,
int  d2,
T &  x_result,
T &  distance,
bool  extend_fringes = false,
bool  inside_input_line = false 
)
inline

getNextIntersectionWithLine2d - returns the next x-position after x0, at which the line with start (px,py) and direction (vx,vy) intersects this in dimensions d1,d2. returns true if an intersection was found after x0 sets x_result to the parametrization of this at which intersection occurs, e.g. ip = f_d1d2(x_result); sets distance to the parameter required to achieve the intersection point via the given line, e.g. ip=(px,py) + (vx,vy)*distance; extend_fringes - if extend_fringes is true, the function is extrapolated in order to provide intersection points beyond its domain

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

◆ getNextIntersectionWithLine2d() [2/2]

template<typename T , int n>
bool adore::mad::LLinearPiecewiseFunctionM< T, n >::getNextIntersectionWithLine2d ( x0,
px,
py,
vx,
vy,
T &  x_result,
T &  distance,
bool  extend_fringes = false 
)
inline
Here is the call graph for this function:

◆ getNextIntersectionWithVector2d()

template<typename T , int n>
bool adore::mad::LLinearPiecewiseFunctionM< T, n >::getNextIntersectionWithVector2d ( x0,
px,
py,
vx,
vy,
T &  x_result,
T &  distance,
max_distance,
bool  extend_fringes = false 
)
inline
Here is the call graph for this function:
Here is the caller graph for this function:

◆ getPositionOfPoint()

template<typename T , int n>
double adore::mad::LLinearPiecewiseFunctionM< T, n >::getPositionOfPoint ( px,
py,
int  d1,
int  d2,
T &  d_tangential_min,
T &  d_normal_min 
)
inline

getPositionOfPoint - returns best-fit d_tangential and d_normal: if d_tangential>1 or d_tangential<0, the point is not projected onto function interval the according function parameter for given point is returned

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

◆ getXAfterNPoints()

template<typename T , int n>
T adore::mad::LLinearPiecewiseFunctionM< T, n >::getXAfterNPoints ( xstart,
int  N 
)
inline

returns the x-value if going forward N points

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

◆ invertDomain()

template<typename T , int n>
virtual void adore::mad::LLinearPiecewiseFunctionM< T, n >::invertDomain ( )
inlinevirtual

retains the overall domain between lo and hi, but inverts direction in between

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

◆ isPointEnclosed()

template<typename T , int n>
bool adore::mad::LLinearPiecewiseFunctionM< T, n >::isPointEnclosed ( LLinearPiecewiseFunctionM< T, n > *  other,
px,
py,
int  d1,
int  d2,
bool  invert_this = false,
bool  invert_other = true 
)
inline

isPointEnclosed - Returns true if a point x is enclosed by the two line segments this, other and the lines connecting this' and other's endpoints. This and other have to form a counter clockwise loop if their endpoints are connected, so that the interior of the loop is well defined. If this and other do not form a ccw loop, use invert_this or invert_other to temporarily change directions, to achieve ccw loop. https://en.wikipedia.org/wiki/Point_in_polygon

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

◆ limit_s_to_bounds()

template<typename T , int n>
virtual double adore::mad::LLinearPiecewiseFunctionM< T, n >::limit_s_to_bounds ( double  s) const
inlinevirtual

shifts s to be in between limitLo and limitHi

Parameters
s
Returns
double
See also
limitLo(), limitHi()
Here is the call graph for this function:

◆ limitHi()

template<typename T , int n>
virtual DT adore::mad::LLinearPiecewiseFunctionM< T, n >::limitHi ( ) const
inlineoverridevirtual

query upper limit of the domain

Implements adore::mad::ALFunction< T, adoreMatrix< T, N, 1 > >.

Here is the caller graph for this function:

◆ limitLo()

template<typename T , int n>
virtual DT adore::mad::LLinearPiecewiseFunctionM< T, n >::limitLo ( ) const
inlineoverridevirtual

lower limit of the domain

Implements adore::mad::ALFunction< T, adoreMatrix< T, N, 1 > >.

◆ multiply()

template<typename T , int n>
virtual void adore::mad::LLinearPiecewiseFunctionM< T, n >::multiply ( adoreMatrix< T, 0, 0 >  A,
int  rowi,
int  rowj 
)
inlineoverridevirtual

apply operation to function sub-dimensions: multiply with matrix of lower dimension in range rowi to rowj, with A.nc==A.nr==rowj-rowi+1

Implements adore::mad::AScalarToN< T, n >.

Here is the caller graph for this function:

◆ operator=()

template<typename T , int n>
LLinearPiecewiseFunctionM& adore::mad::LLinearPiecewiseFunctionM< T, n >::operator= ( const LLinearPiecewiseFunctionM< T, n > &  other)
inline

◆ rotateXY()

template<typename T , int n>
void adore::mad::LLinearPiecewiseFunctionM< T, n >::rotateXY ( double  angle,
double  x0 = 0.0,
double  y0 = 0.0 
)
inline

rotate codomain in 2D

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

◆ sample_dfidx()

template<typename T , int n>
void adore::mad::LLinearPiecewiseFunctionM< T, n >::sample_dfidx ( DT xvec,
T *  yvec,
int  count,
int  row 
)
inline

sapmle a range of x values and evaluate gradient for one row of the vector only

Here is the call graph for this function:

◆ setData()

template<typename T , int n>
void adore::mad::LLinearPiecewiseFunctionM< T, n >::setData ( const adoreMatrix< T, n+1, 0 > &  data)
inline

set the domain and codomain from data matrix

Here is the caller graph for this function:

◆ setLimits()

template<typename T , int n>
virtual void adore::mad::LLinearPiecewiseFunctionM< T, n >::setLimits ( DT  lo,
DT  hi 
)
inlineoverridevirtual
Here is the caller graph for this function:

◆ shiftCodomain() [1/2]

template<typename T , int n>
void adore::mad::LLinearPiecewiseFunctionM< T, n >::shiftCodomain ( CT  dy)
inline

shifts the codomain of the function (move graph up or down)

Here is the caller graph for this function:

◆ shiftCodomain() [2/2]

template<typename T , int n>
void adore::mad::LLinearPiecewiseFunctionM< T, n >::shiftCodomain ( dy,
int  i = 0 
)
inline

shift a single dimension of the codomain

◆ shiftDomain()

template<typename T , int n>
void adore::mad::LLinearPiecewiseFunctionM< T, n >::shiftDomain ( DT  dx)
inline

shifts the domain of the function by dx (move graph left or right)

Here is the caller graph for this function:

◆ startDomainAtZero()

template<typename T , int n>
virtual void adore::mad::LLinearPiecewiseFunctionM< T, n >::startDomainAtZero ( )
inlinevirtual

shifts the function in such a way that the domain starts at 0

Here is the call graph for this function:

◆ stretchDomain()

template<typename T , int n>
virtual void adore::mad::LLinearPiecewiseFunctionM< T, n >::stretchDomain ( DT  x0,
DT  x1 
)
inlinevirtual

stretches domain to fit interval [x0,x1]

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

◆ writePointsToArray() [1/2]

template<typename T , int n>
void adore::mad::LLinearPiecewiseFunctionM< T, n >::writePointsToArray ( int  i,
int  j,
int  d,
T *  m 
)
inline

writes j-i points into an array m, for dimension d, using the natural stepsize

◆ writePointsToArray() [2/2]

template<typename T , int n>
void adore::mad::LLinearPiecewiseFunctionM< T, n >::writePointsToArray ( int  i,
int  j,
T *  m 
)
inline

writes j-i points into an array m, using the natural stepsize

Member Data Documentation

◆ m_data

template<typename T , int n>
adoreMatrix<T, n + 1, 0> adore::mad::LLinearPiecewiseFunctionM< T, n >::m_data
private

◆ m_searchIndex

template<typename T , int n>
unsigned int adore::mad::LLinearPiecewiseFunctionM< T, n >::m_searchIndex
mutableprivate

◆ single_dimensions

template<typename T , int n>
OneDimension adore::mad::LLinearPiecewiseFunctionM< T, n >::single_dimensions[n]
private

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