#include <ArrayND.h>

Public Types
typedef ProperDblFromCmpl< Numeric >::type	proper_double

typedef Numeric	value_type

Public Member Functions
template<typename Num3 , typename Num2 , unsigned Len2, unsigned Dim2>
ArrayND &	addmul (const ArrayND< Num2, Len2, Dim2 > &r, const Num3 &c)

template<typename Num3 , typename Num2 , unsigned Len2, unsigned Dim2>
ArrayND< Numeric, Len, Dim > &	addmul (const ArrayND< Num2, Len2, Dim2 > &r, const Num3 &c)

template<class Functor >
ArrayND &	apply (Functor f)

template<class Functor >
ArrayND< Numeric, Len, Dim > &	apply (Functor f)

template<typename Num2 , unsigned Len2, unsigned Dim2, class Functor >
void	applySlice (ArrayND< Num2, Len2, Dim2 > &slice, const unsigned *fixedIndices, unsigned nFixedIndices, Functor binaryFunct)

	ArrayND ()

	ArrayND (const ArrayND &)

template<typename Num2 , unsigned Len2, unsigned Dim2>
	ArrayND (const ArrayND< Num2, Len2, Dim2 > &)

template<typename Num2 , unsigned Len2, unsigned Dim2, class Functor >
	ArrayND (const ArrayND< Num2, Len2, Dim2 > &, Functor f)

template<typename Num2 , unsigned Len2, unsigned Dim2>
	ArrayND (const ArrayND< Num2, Len2, Dim2 > &from, const ArrayRange &fromRange)

template<typename Num2 , unsigned Len2, unsigned Dim2, class Functor >
	ArrayND (const ArrayND< Num2, Len2, Dim2 > &from, const ArrayRange &fromRange, Functor f)

template<typename Num2 , unsigned Len2, unsigned Dim2>
	ArrayND (const ArrayND< Num2, Len2, Dim2 > &slicedArray, const unsigned *indices, unsigned nIndices)

template<typename Num1 , unsigned Len1, unsigned Dim1, typename Num2 , unsigned Len2, unsigned Dim2>
	ArrayND (const ArrayND< Num1, Len1, Dim1 > &a1, const ArrayND< Num2, Len2, Dim2 > &a2)

template<typename Num2 , unsigned Len2, unsigned Dim2, class Functor >
ArrayND &	assign (const ArrayND< Num2, Len2, Dim2 > &, Functor f)

template<typename Num2 , unsigned Len2, unsigned Dim2, class Functor >
ArrayND< Numeric, Len, Dim > &	assign (const ArrayND< Num2, Len2, Dim2 > &r, Functor f)

template<typename Num2 >
ArrayND	cdfArray (double scale=1.0) const

template<typename Accumulator >
ArrayND< Numeric, Len, Dim >	cdfArray (const double inscale) const

template<typename Num2 >
Num2	cdfValue (const unsigned *index, unsigned indexLen) const

template<typename Accumulator >
Accumulator	cdfValue (const unsigned *index, const unsigned indexLen) const

template<typename Num2 , unsigned Len2, unsigned Dim2, class Functor >
void	circularFlatScan (ArrayND< Num2, Len2, Dim2 > &other, const unsigned thisCorner, const unsigned range, const unsigned *otherCorner, unsigned arrLen, Functor binaryFunct)

ArrayND &	clear ()

ArrayND &	constFill (Numeric c)

ArrayND	contract (unsigned pos1, unsigned pos2) const

void	convertLinearIndex (unsigned long l, unsigned *index, unsigned indexLen) const

template<typename Num2 >
void	convertToLastDimCdf (ArrayND *sumSlice, bool useTrapezoids)

const Numeric *	data () const

template<typename Num2 >
ArrayND	derivative (double scale=1.0) const

template<typename Accumulator >
ArrayND< Numeric, Len, Dim >	derivative (const double inscale) const

template<typename Num2 , unsigned Len2, unsigned Dim2>
ArrayND	dot (const ArrayND< Num2, Len2, Dim2 > &r) const

template<typename Num2 , unsigned Len2, unsigned Dim2>
ArrayND< Numeric, Len, Dim >	dot (const ArrayND< Num2, Len2, Dim2 > &r) const

template<typename Num2 , unsigned Len2, unsigned Dim2, class Functor >
void	dualCircularScan (ArrayND< Num2, Len2, Dim2 > &other, const unsigned thisCorner, const unsigned range, const unsigned *otherCorner, unsigned arrLen, Functor binaryFunct)

template<typename Num2 >
void	exportMemSlice (Num2 buffer, unsigned long bufLen, const unsigned fixedIndices, const unsigned *fixedIndexValues, unsigned nFixedIndices) const

template<typename Num2 , unsigned Len2, unsigned Dim2>
void	exportSlice (ArrayND< Num2, Len2, Dim2 > slice, const unsigned fixedIndices, const unsigned *fixedIndexValues, unsigned nFixedIndices) const

template<typename Num2 , unsigned Len2, unsigned Dim2>
void	exportSubrange (const unsigned fromCorner, unsigned lenCorner, ArrayND< Num2, Len2, Dim2 > dest) const

template<typename Num2 , unsigned Len2, unsigned Dim2, class Functor >
void	flatCircularScan (ArrayND< Num2, Len2, Dim2 > &other, const unsigned thisCorner, const unsigned range, const unsigned *otherCorner, unsigned arrLen, Functor binaryFunct)

ArrayRange	fullRange () const

template<class Functor >
ArrayND &	functorFill (Functor f)

template<class Functor >
ArrayND< Numeric, Len, Dim > &	functorFill (Functor f)

template<typename Num2 >
void	importMemSlice (const Num2 buffer, unsigned long bufLen, const unsigned fixedIndices, const unsigned *fixedIndexValues, unsigned nFixedIndices)

template<typename Num2 , unsigned Len2, unsigned Dim2>
void	importSlice (const ArrayND< Num2, Len2, Dim2 > &slice, const unsigned fixedIndices, const unsigned fixedIndexValues, unsigned nFixedIndices)

template<typename Num2 , unsigned Len2, unsigned Dim2>
void	importSubrange (const unsigned *fromCorner, unsigned lenCorner, const ArrayND< Num2, Len2, Dim2 > &from)

template<typename Num2 , unsigned Len2, unsigned Dim2>
ArrayND &	inPlaceMul (const ArrayND< Num2, Len2, Dim2 > &r)

Numeric	interpolate1 (const double *x, unsigned xDim) const

Numeric	interpolate3 (const double *x, unsigned xDim) const

template<typename Num2 , unsigned Len2, unsigned Dim2>
bool	isClose (const ArrayND< Num2, Len2, Dim2 > &r, double eps) const

bool	isCompatible (const ArrayShape &shape) const

bool	isDensity () const

template<typename Num2 , unsigned Len2, unsigned Dim2>
bool	isShapeCompatible (const ArrayND< Num2, Len2, Dim2 > &r) const

bool	isShapeKnown () const

bool	isZero () const

template<typename Num2 , class Functor >
void	jointMemSliceScan (Num2 buffer, unsigned long bufLen, const unsigned fixedIndices, const unsigned *fixedIndexValues, unsigned nFixedIndices, Functor binaryFunct)

template<typename Num2 , unsigned Len2, unsigned Dim2, class Functor >
void	jointScan (ArrayND< Num2, Len2, Dim2 > &other, Functor binaryFunct)

template<typename Num2 , class Op >
void	jointSliceLoop (const unsigned level, const unsigned long idx0, const unsigned level1, const unsigned long idx1, Num2 sliceData, const unsigned long sliceStrides, const unsigned fixedIndices, const unsigned fixedIndexValues, const unsigned nFixedIndices, Op fcn)

template<typename Num2 , unsigned Len2, unsigned Dim2, class Functor >
void	jointSliceScan (ArrayND< Num2, Len2, Dim2 > &slice, const unsigned fixedIndices, const unsigned fixedIndexValues, unsigned nFixedIndices, Functor binaryFunct)

template<typename Num2 , unsigned Len2, unsigned Dim2, class Functor >
void	jointSubrangeScan (ArrayND< Num2, Len2, Dim2 > &other, const unsigned thisCorner, const unsigned range, const unsigned *otherCorner, unsigned arrLen, Functor binaryFunct)

unsigned long	length () const

ArrayND &	linearFill (const double *coeff, unsigned coeffLen, double c)

unsigned long	linearIndex (const unsigned *idx, unsigned idxLen) const

unsigned	makeCopulaSteps (double tolerance, unsigned maxIterations)

ArrayND &	makeNonNegative ()

ArrayND &	makeUnit ()

template<typename Num2 , unsigned Len2, unsigned Dim2>
ArrayND	marginalize (const ArrayND< Num2, Len2, Dim2 > &prior, const unsigned *indexMap, unsigned mapLen) const

template<typename Num2 , unsigned Len2, unsigned Dim2>
ArrayND< Numeric, StackLen, StackDim >	marginalize (const ArrayND< Num2, Len2, Dim2 > &prior, const unsigned *indexMap, const unsigned mapLen) const

Numeric	max () const

Numeric	max (unsigned *index, unsigned indexLen) const

template<unsigned Len2, unsigned Dim2>
double	maxAbsDifference (const ArrayND< Numeric, Len2, Dim2 > &) const

unsigned	maximumSpan () const

Numeric	min () const

Numeric	min (unsigned *index, unsigned indexLen) const

unsigned	minimumSpan () const

template<typename Num2 , unsigned Len2, unsigned Dim2>
void	multiMirror (ArrayND< Num2, Len2, Dim2 > *out) const

template<typename Num2 , unsigned Len2, unsigned Dim2>
ArrayND &	multiplyBySlice (const ArrayND< Num2, Len2, Dim2 > &slice, const unsigned *fixedIndices, unsigned nFixedIndices)

template<unsigned Len2, unsigned Dim2>
bool	operator!= (const ArrayND< Numeric, Len2, Dim2 > &) const

template<typename Num2 >
ArrayND	operator* (const Num2 &r) const

template<typename Num2 >
ArrayND< Numeric, Len, Dim >	operator* (const Num2 &r) const

template<typename Num2 >
ArrayND< Numeric, Len, Dim > &	operator*= (const Num2 &r)

ArrayND	operator+ () const

template<unsigned Len2, unsigned Dim2>
ArrayND	operator+ (const ArrayND< Numeric, Len2, Dim2 > &r) const

template<unsigned Len2, unsigned Dim2>
ArrayND< Numeric, Len, Dim >	operator+ (const ArrayND< Numeric, Len2, Dim2 > &r) const

template<typename Num2 , unsigned Len2, unsigned Dim2>
ArrayND< Numeric, Len, Dim > &	operator+= (const ArrayND< Num2, Len2, Dim2 > &r)

ArrayND	operator- () const

template<unsigned Len2, unsigned Dim2>
ArrayND	operator- (const ArrayND< Numeric, Len2, Dim2 > &r) const

template<unsigned Len2, unsigned Dim2>
ArrayND< Numeric, Len, Dim >	operator- (const ArrayND< Numeric, Len2, Dim2 > &r) const

template<typename Num2 , unsigned Len2, unsigned Dim2>
ArrayND< Numeric, Len, Dim > &	operator-= (const ArrayND< Num2, Len2, Dim2 > &r)

template<typename Num2 >
ArrayND	operator/ (const Num2 &r) const

template<typename Num2 >
ArrayND< Numeric, Len, Dim >	operator/ (const Num2 &r) const

template<typename Num2 >
ArrayND< Numeric, Len, Dim > &	operator/= (const Num2 &r)

ArrayND &	operator= (const ArrayND &)

template<typename Num2 , unsigned Len2, unsigned Dim2>
ArrayND &	operator= (const ArrayND< Num2, Len2, Dim2 > &)

template<typename Num2 , unsigned Len2, unsigned Dim2>
ArrayND< Numeric, Len, Dim > &	operator= (const ArrayND< Num2, Len2, Dim2 > &r)

template<unsigned Len2, unsigned Dim2>
bool	operator== (const ArrayND< Numeric, Len2, Dim2 > &) const

template<typename Num2 , unsigned Len2, unsigned Dim2>
ArrayND	outer (const ArrayND< Num2, Len2, Dim2 > &r) const

template<typename Num2 , unsigned Len2, unsigned Dim2>
ArrayND< Numeric, Len, Dim >	outer (const ArrayND< Num2, Len2, Dim2 > &r) const

template<typename Num2 , typename Integer >
void	processSubrange (AbsArrayProjector< Numeric, Num2 > &f, const BoxND< Integer > &subrange) const

unsigned	rank () const

template<typename Num2 , unsigned Len2, unsigned Dim2>
void	rotate (const unsigned shifts, unsigned lenShifts, ArrayND< Num2, Len2, Dim2 > rotated) const

template<class Functor >
ArrayND &	scanInPlace (Functor f)

template<class Functor >
ArrayND< Numeric, Len, Dim > &	scanInPlace (Functor f)

template<typename Num2 >
ArrayND &	setData (const Num2 *data, unsigned long dataLength)

template<typename Num2 >
ArrayND< Numeric, Len, Dim > &	setData (const Num2 *data, const unsigned long dataLength)

ArrayShape	shape () const

const unsigned *	shapeData () const

ArrayShape	sliceShape (const unsigned *fixedIndices, unsigned nFixedIndices) const

unsigned	span (unsigned dim) const

const unsigned long *	strides () const

template<typename Num2 >
Num2	sum () const

template<typename Num2 >
Num2	sumsq () const

ArrayND	transpose (unsigned pos1, unsigned pos2) const

ArrayND	transpose () const

ArrayND &	uninitialize ()

	~ArrayND ()


	ArrayND (const ArrayShape &shape)

	ArrayND (const unsigned *shape, unsigned dim)


	ArrayND (unsigned n0)

	ArrayND (unsigned n0, unsigned n1)

	ArrayND (unsigned n0, unsigned n1, unsigned n2)

	ArrayND (unsigned n0, unsigned n1, unsigned n2, unsigned n3)

	ArrayND (unsigned n0, unsigned n1, unsigned n2, unsigned n3, unsigned n4)

	ArrayND (unsigned n0, unsigned n1, unsigned n2, unsigned n3, unsigned n4, unsigned n5)

	ArrayND (unsigned n0, unsigned n1, unsigned n2, unsigned n3, unsigned n4, unsigned n5, unsigned n6)

	ArrayND (unsigned n0, unsigned n1, unsigned n2, unsigned n3, unsigned n4, unsigned n5, unsigned n6, unsigned n7)

	ArrayND (unsigned n0, unsigned n1, unsigned n2, unsigned n3, unsigned n4, unsigned n5, unsigned n6, unsigned n7, unsigned n8)

	ArrayND (unsigned n0, unsigned n1, unsigned n2, unsigned n3, unsigned n4, unsigned n5, unsigned n6, unsigned n7, unsigned n8, unsigned n9)


Numeric &	value (const unsigned *index, unsigned indexLen)

const Numeric &	value (const unsigned *index, unsigned indexLen) const


Numeric &	valueAt (const unsigned *index, unsigned indexLen)

const Numeric &	valueAt (const unsigned *index, unsigned indexLen) const


Numeric &	linearValue (unsigned long index)

const Numeric &	linearValue (unsigned long index) const


Numeric &	linearValueAt (unsigned long index)

const Numeric &	linearValueAt (unsigned long index) const


template<typename Num2 >
ArrayND &	operator*= (const Num2 &r)

template<typename Num2 >
ArrayND &	operator/= (const Num2 &r)

template<typename Num2 , unsigned Len2, unsigned Dim2>
ArrayND &	operator+= (const ArrayND< Num2, Len2, Dim2 > &r)

template<typename Num2 , unsigned Len2, unsigned Dim2>
ArrayND &	operator-= (const ArrayND< Num2, Len2, Dim2 > &r)


Numeric &	closest (const double *x, unsigned xDim)

const Numeric &	closest (const double *x, unsigned xDim) const


template<typename Num2 , unsigned Len2, unsigned Dim2, typename Num3 >
void	project (ArrayND< Num2, Len2, Dim2 > projection, AbsArrayProjector< Numeric, Num3 > &projector, const unsigned projectedIndices, unsigned nProjectedIndices) const

template<typename Num2 , unsigned Len2, unsigned Dim2, typename Num3 >
void	project (ArrayND< Num2, Len2, Dim2 > projection, AbsVisitor< Numeric, Num3 > &projector, const unsigned projectedIndices, unsigned nProjectedIndices) const


template<typename Num2 , unsigned Len2, unsigned Dim2, typename Num3 >
void	addToProjection (ArrayND< Num2, Len2, Dim2 > projection, AbsArrayProjector< Numeric, Num3 > &projector, const unsigned projectedIndices, unsigned nProjectedIndices) const

template<typename Num2 , unsigned Len2, unsigned Dim2, typename Num3 >
void	subtractFromProjection (ArrayND< Num2, Len2, Dim2 > projection, AbsArrayProjector< Numeric, Num3 > &projector, const unsigned projectedIndices, unsigned nProjectedIndices) const

template<typename Num2 , unsigned Len2, unsigned Dim2, typename Num3 >
void	addToProjection (ArrayND< Num2, Len2, Dim2 > projection, AbsVisitor< Numeric, Num3 > &projector, const unsigned projectedIndices, unsigned nProjectedIndices) const

template<typename Num2 , unsigned Len2, unsigned Dim2, typename Num3 >
void	subtractFromProjection (ArrayND< Num2, Len2, Dim2 > projection, AbsVisitor< Numeric, Num3 > &projector, const unsigned projectedIndices, unsigned nProjectedIndices) const


Numeric &	operator() ()

const Numeric &	operator() () const

Numeric &	operator() (unsigned i0)

const Numeric &	operator() (unsigned i0) const

Numeric &	operator() (unsigned i0, unsigned i1)

const Numeric &	operator() (unsigned i0, unsigned i1) const

Numeric &	operator() (unsigned i0, unsigned i1, unsigned i2)

const Numeric &	operator() (unsigned i0, unsigned i1, unsigned i2) const

Numeric &	operator() (unsigned i0, unsigned i1, unsigned i2, unsigned i3)

const Numeric &	operator() (unsigned i0, unsigned i1, unsigned i2, unsigned i3) const

Numeric &	operator() (unsigned i0, unsigned i1, unsigned i2, unsigned i3, unsigned i4)

const Numeric &	operator() (unsigned i0, unsigned i1, unsigned i2, unsigned i3, unsigned i4) const

Numeric &	operator() (unsigned i0, unsigned i1, unsigned i2, unsigned i3, unsigned i4, unsigned i5)

const Numeric &	operator() (unsigned i0, unsigned i1, unsigned i2, unsigned i3, unsigned i4, unsigned i5) const

Numeric &	operator() (unsigned i0, unsigned i1, unsigned i2, unsigned i3, unsigned i4, unsigned i5, unsigned i6)

const Numeric &	operator() (unsigned i0, unsigned i1, unsigned i2, unsigned i3, unsigned i4, unsigned i5, unsigned i6) const

Numeric &	operator() (unsigned i0, unsigned i1, unsigned i2, unsigned i3, unsigned i4, unsigned i5, unsigned i6, unsigned i7)

const Numeric &	operator() (unsigned i0, unsigned i1, unsigned i2, unsigned i3, unsigned i4, unsigned i5, unsigned i6, unsigned i7) const

Numeric &	operator() (unsigned i0, unsigned i1, unsigned i2, unsigned i3, unsigned i4, unsigned i5, unsigned i6, unsigned i7, unsigned i8)

const Numeric &	operator() (unsigned i0, unsigned i1, unsigned i2, unsigned i3, unsigned i4, unsigned i5, unsigned i6, unsigned i7, unsigned i8) const

Numeric &	operator() (unsigned i0, unsigned i1, unsigned i2, unsigned i3, unsigned i4, unsigned i5, unsigned i6, unsigned i7, unsigned i8, unsigned i9)

const Numeric &	operator() (unsigned i0, unsigned i1, unsigned i2, unsigned i3, unsigned i4, unsigned i5, unsigned i6, unsigned i7, unsigned i8, unsigned i9) const


Numeric &	at ()

const Numeric &	at () const

Numeric &	at (unsigned i0)

const Numeric &	at (unsigned i0) const

Numeric &	at (unsigned i0, unsigned i1)

const Numeric &	at (unsigned i0, unsigned i1) const

Numeric &	at (unsigned i0, unsigned i1, unsigned i2)

const Numeric &	at (unsigned i0, unsigned i1, unsigned i2) const

Numeric &	at (unsigned i0, unsigned i1, unsigned i2, unsigned i3)

const Numeric &	at (unsigned i0, unsigned i1, unsigned i2, unsigned i3) const

Numeric &	at (unsigned i0, unsigned i1, unsigned i2, unsigned i3, unsigned i4)

const Numeric &	at (unsigned i0, unsigned i1, unsigned i2, unsigned i3, unsigned i4) const

Numeric &	at (unsigned i0, unsigned i1, unsigned i2, unsigned i3, unsigned i4, unsigned i5)

const Numeric &	at (unsigned i0, unsigned i1, unsigned i2, unsigned i3, unsigned i4, unsigned i5) const

Numeric &	at (unsigned i0, unsigned i1, unsigned i2, unsigned i3, unsigned i4, unsigned i5, unsigned i6)

const Numeric &	at (unsigned i0, unsigned i1, unsigned i2, unsigned i3, unsigned i4, unsigned i5, unsigned i6) const

Numeric &	at (unsigned i0, unsigned i1, unsigned i2, unsigned i3, unsigned i4, unsigned i5, unsigned i6, unsigned i7)

const Numeric &	at (unsigned i0, unsigned i1, unsigned i2, unsigned i3, unsigned i4, unsigned i5, unsigned i6, unsigned i7) const

Numeric &	at (unsigned i0, unsigned i1, unsigned i2, unsigned i3, unsigned i4, unsigned i5, unsigned i6, unsigned i7, unsigned i8)

const Numeric &	at (unsigned i0, unsigned i1, unsigned i2, unsigned i3, unsigned i4, unsigned i5, unsigned i6, unsigned i7, unsigned i8) const

Numeric &	at (unsigned i0, unsigned i1, unsigned i2, unsigned i3, unsigned i4, unsigned i5, unsigned i6, unsigned i7, unsigned i8, unsigned i9)

const Numeric &	at (unsigned i0, unsigned i1, unsigned i2, unsigned i3, unsigned i4, unsigned i5, unsigned i6, unsigned i7, unsigned i8, unsigned i9) const


Numeric &	cl ()

const Numeric &	cl () const

Numeric &	cl (double x0)

const Numeric &	cl (double x0) const

Numeric &	cl (double x0, double x1)

const Numeric &	cl (double x0, double x1) const

Numeric &	cl (double x0, double x1, double x2)

const Numeric &	cl (double x0, double x1, double x2) const

Numeric &	cl (double x0, double x1, double x2, double x3)

const Numeric &	cl (double x0, double x1, double x2, double x3) const

Numeric &	cl (double x0, double x1, double x2, double x3, double x4)

const Numeric &	cl (double x0, double x1, double x2, double x3, double x4) const

Numeric &	cl (double x0, double x1, double x2, double x3, double x4, double x5)

const Numeric &	cl (double x0, double x1, double x2, double x3, double x4, double x5) const

Numeric &	cl (double x0, double x1, double x2, double x3, double x4, double x5, double x6)

const Numeric &	cl (double x0, double x1, double x2, double x3, double x4, double x5, double x6) const

Numeric &	cl (double x0, double x1, double x2, double x3, double x4, double x5, double x6, double x7)

const Numeric &	cl (double x0, double x1, double x2, double x3, double x4, double x5, double x6, double x7) const

Numeric &	cl (double x0, double x1, double x2, double x3, double x4, double x5, double x6, double x7, double x8)

const Numeric &	cl (double x0, double x1, double x2, double x3, double x4, double x5, double x6, double x7, double x8) const

Numeric &	cl (double x0, double x1, double x2, double x3, double x4, double x5, double x6, double x7, double x8, double x9)

const Numeric &	cl (double x0, double x1, double x2, double x3, double x4, double x5, double x6, double x7, double x8, double x9) const


gs::ClassId	classId () const

bool	write (std::ostream &of) const

Static Public Member Functions
static const char *	classname ()

static void	restore (const gs::ClassId &id, std::istream &in, ArrayND *array)

static unsigned	version ()

Private Member Functions
void	buildFromShapePtr (const unsigned *, unsigned)

void	buildStrides ()

template<typename Num2 , unsigned Len2, unsigned Dim2, class Functor >
void	circularFlatLoop (unsigned level, unsigned long idx0, unsigned long idx1, const unsigned thisCorner, const unsigned range, const unsigned *otherCorner, ArrayND< Num2, Len2, Dim2 > &other, Functor binaryFunct)

template<typename Num2 , unsigned Len2, unsigned Dim2, class Functor >
void	commonSubrangeLoop (unsigned level, unsigned long idx0, unsigned long idx1, const unsigned thisCorner, const unsigned range, const unsigned *otherCorner, ArrayND< Num2, Len2, Dim2 > &other, Functor binaryFunct)

void	contractLoop (unsigned thisLevel, unsigned resLevel, unsigned pos1, unsigned pos2, unsigned long idxThis, unsigned long idxRes, ArrayND &result) const

template<typename Accumulator >
void	convertToLastDimCdfLoop (ArrayND *sumSlice, unsigned level, unsigned long idx0, unsigned long idxSlice, bool useTrapezoids)

unsigned	coordToIndex (double coord, unsigned idim) const

template<typename Num2 , unsigned Len2, unsigned Dim2, class Functor >
void	copyRangeLoopFunct (unsigned level, unsigned long idx0, unsigned long idx1, const ArrayND< Num2, Len2, Dim2 > &r, const ArrayRange &range, Functor f)

template<typename Num2 , unsigned Len2, unsigned Dim2>
void	dotProductLoop (unsigned level, unsigned long idx0, unsigned long idx1, unsigned long idx2, const ArrayND< Num2, Len2, Dim2 > &r, ArrayND &result) const

template<typename Num2 , unsigned Len2, unsigned Dim2, class Functor >
void	dualCircularLoop (unsigned level, unsigned long idx0, unsigned long idx1, const unsigned thisCorner, const unsigned range, const unsigned *otherCorner, ArrayND< Num2, Len2, Dim2 > &other, Functor binaryFunct)

template<typename Num2 , unsigned Len2, unsigned Dim2, class Functor >
void	flatCircularLoop (unsigned level, unsigned long idx0, unsigned long idx1, const unsigned thisCorner, const unsigned range, const unsigned *otherCorner, ArrayND< Num2, Len2, Dim2 > &other, Functor binaryFunct)

template<class Functor >
void	functorFillLoop (unsigned level, unsigned long idx, Functor f, unsigned *farg)

Numeric	interpolateLoop (unsigned level, const double x, const Numeric base) const

template<typename Num2 , class Functor >
void	jointSliceLoop (unsigned level, unsigned long idx0, unsigned level1, unsigned long idx1, Num2 sliceData, const unsigned long sliceStrides, const unsigned fixedIndices, const unsigned fixedIndexValues, unsigned nFixedIndices, Functor binaryFunctor)

void	linearFillLoop (unsigned level, double s0, unsigned long idx, double shift, const double *coeffs)

template<typename Num2 , unsigned Len2, unsigned Dim2>
Numeric	marginalizeInnerLoop (unsigned long idx, unsigned levelPr, unsigned long idxPr, const ArrayND< Num2, Len2, Dim2 > &prior, const unsigned *indexMap) const

template<typename Num2 , unsigned Len2, unsigned Dim2>
void	marginalizeLoop (unsigned level, unsigned long idx, unsigned levelRes, unsigned long idxRes, const ArrayND< Num2, Len2, Dim2 > &prior, const unsigned *indexMap, ArrayND &res) const

template<typename Num1 , unsigned Len1, unsigned Dim1, typename Num2 , unsigned Len2, unsigned Dim2>
void	outerProductLoop (unsigned level, unsigned long idx0, unsigned long idx1, unsigned long idx2, const ArrayND< Num1, Len1, Dim1 > &a1, const ArrayND< Num2, Len2, Dim2 > &a2)

template<typename Num2 , typename Integer >
void	processSubrangeLoop (unsigned level, unsigned long idx0, unsigned *currentIndex, AbsArrayProjector< Numeric, Num2 > &f, const BoxND< Integer > &subrange) const

template<typename Num2 >
void	projectInnerLoop (unsigned level, unsigned long idx0, unsigned currentIndex, AbsArrayProjector< Numeric, Num2 > &projector, const unsigned projectedIndices, unsigned nProjectedIndices) const

template<typename Num2 >
void	projectInnerLoop2 (unsigned level, unsigned long idx0, AbsVisitor< Numeric, Num2 > &projector, const unsigned *projectedIndices, unsigned nProjectedIndices) const

template<typename Num2 , unsigned Len2, unsigned Dim2, typename Num3 , class Op >
void	projectLoop (unsigned level, unsigned long idx0, unsigned level1, unsigned long idx1, unsigned currentIndex, ArrayND< Num2, Len2, Dim2 > projection, AbsArrayProjector< Numeric, Num3 > &projector, const unsigned *projectedIndices, unsigned nProjectedIndices, Op fcn) const

template<typename Num2 , unsigned Len2, unsigned Dim2, typename Num3 , class Op >
void	projectLoop2 (unsigned level, unsigned long idx0, unsigned level1, unsigned long idx1, ArrayND< Num2, Len2, Dim2 > projection, AbsVisitor< Numeric, Num3 > &projector, const unsigned projectedIndices, unsigned nProjectedIndices, Op fcn) const

template<typename Num2 , class Functor >
void	scaleBySliceInnerLoop (unsigned level, unsigned long idx0, Num2 &scale, const unsigned *projectedIndices, unsigned nProjectedIndices, Functor binaryFunct)

template<typename Num2 , unsigned Len2, unsigned Dim2, class Functor >
void	scaleBySliceLoop (unsigned level, unsigned long idx0, unsigned level1, unsigned long idx1, ArrayND< Num2, Len2, Dim2 > &slice, const unsigned *fixedIndices, unsigned nFixedIndices, Functor binaryFunct)

template<typename Accumulator >
Accumulator	sumBelowLoop (unsigned level, unsigned long idx0, const unsigned *limit) const

void	transposeLoop (unsigned level, unsigned pos1, unsigned pos2, unsigned long idxThis, unsigned long idxRes, ArrayND &result) const

unsigned long	verifyBufferSliceCompatibility (unsigned long bufLen, const unsigned fixedIndices, const unsigned fixedIndexValues, unsigned nFixedIndices, unsigned long *sliceStrides) const

template<typename Num2 , unsigned Len2, unsigned Dim2>
void	verifyProjectionCompatibility (const ArrayND< Num2, Len2, Dim2 > &projection, const unsigned *projectedIndices, unsigned nProjectedIndices) const

template<typename Num2 , unsigned Len2, unsigned Dim2>
unsigned long	verifySliceCompatibility (const ArrayND< Num2, Len2, Dim2 > &slice, const unsigned fixedIndices, const unsigned fixedIndexValues, unsigned nFixedIndices) const

Private Attributes
Numeric *	data_

unsigned	dim_

unsigned long	len_

Numeric	localData_ [StackLen]

unsigned	localShape_ [StackDim]

unsigned long	localStrides_ [StackDim]

unsigned *	shape_

bool	shapeIsKnown_

unsigned long *	strides_

Friends
template<typename Num2 , unsigned Len2, unsigned Dim2>
class	ArrayND

Detailed Description

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>
class npstat::ArrayND< Numeric, StackLen, StackDim >

A class for multidimensional array manipulation. A number of methods of this class will work only if dimensionality is limited by CHAR_BIT*sizeof(unsigned long)-1 (which is 31 and 63 on 32- and 64-bit architectures, respectively).

Depending on how much space is provided with the "StackLen" template parameter, the array data will be placed either on the stack or on the heap. By default, array data leaves on the heap unless the array has rank 0.

Depending on how much space is provided with the "StackDim" template parameter, the array strides will be placed either on the stack or on the heap. By default, strides will be placed on the stack in case the array dimensionality is ten or less.

The "Numeric" type must have a default constructor (of course, pointers to arbitrary types can be used as well).

Both StackLen and StackDim parameters must be positive.

Definition at line 48 of file ArrayND.h.

Member Typedef Documentation

◆ proper_double

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

typedef ProperDblFromCmpl<Numeric>::type npstat::ArrayND< Numeric, StackLen, StackDim >::proper_double

Definition at line 54 of file ArrayND.h.

◆ value_type

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

typedef Numeric npstat::ArrayND< Numeric, StackLen, StackDim >::value_type

Definition at line 53 of file ArrayND.h.

Constructor & Destructor Documentation

◆ ArrayND() [1/20]

template<typename Numeric , unsigned StackLen, unsigned StackDim>

npstat::ArrayND< Numeric, StackLen, StackDim >::ArrayND ( )

inline

Default constructor creates an uninitialized array. Only three things can be done safely with such an array:

1) Assigning it from another array (initialized or not).

2) Passing it as an argument to the class static method "restore".

3) Calling the "uninitialize" method.

Any other operation results in an undefined behavior (often, an exception is thrown). Note that initialized array can not be assigned from uninitialized one.

Definition at line 2488 of file ArrayND.h.

       : data_(nullptr), strides_(nullptr), shape_(nullptr), len_(0UL), dim_(0U), shapeIsKnown_(false) {
     localData_[0] = Numeric();
     data_ = localData_;
   }

◆ ArrayND() [2/20]

template<typename Numeric , unsigned Len, unsigned Dim>

npstat::ArrayND< Numeric, Len, Dim >::ArrayND ( const ArrayShape & shape )

explicit

Constructor which creates arrays with the given shape. The array data remains undefined. Simple inilitalization of the data can be performed using methods clear() or constFill(SomeValue). More complicated initialization can be done by "linearFill", "functorFill", or by setting every array element to a desired value.

Definition at line 2664 of file ArrayND.h.

       : data_(nullptr), strides_(nullptr), shape_(nullptr), len_(1UL), shapeIsKnown_(true) {
     const unsigned sz = sh.size();
     buildFromShapePtr(sz ? &sh[0] : nullptr, sz);
   }

◆ ArrayND() [3/20]

template<typename Numeric , unsigned Len, unsigned Dim>

npstat::ArrayND< Numeric, Len, Dim >::ArrayND	(	const unsigned *	shape,
		unsigned	dim
	)

Definition at line 2671 of file ArrayND.h.

       : data_(0), strides_(nullptr), shape_(nullptr), len_(1UL), shapeIsKnown_(true) {
     buildFromShapePtr(sizes, dim);
   }

◆ ArrayND() [4/20]

template<typename Numeric , unsigned Len, unsigned Dim>

npstat::ArrayND< Numeric, Len, Dim >::ArrayND ( const ArrayND< Numeric, StackLen, StackDim > & r )

The copy constructor

Definition at line 2495 of file ArrayND.h.

       : data_(nullptr), strides_(nullptr), shape_(nullptr), len_(r.len_), dim_(r.dim_), shapeIsKnown_(r.shapeIsKnown_) {
     if (dim_) {
       // Copy the shape
       shape_ = makeBuffer(dim_, localShape_, Dim);
       copyBuffer(shape_, r.shape_, dim_);
 
       // Copy the strides
       strides_ = makeBuffer(dim_, localStrides_, Dim);
       copyBuffer(strides_, r.strides_, dim_);
 
       // Copy the data
       data_ = makeBuffer(len_, localData_, Len);
       copyBuffer(data_, r.data_, len_);
     } else {
       assert(len_ == 1UL);
       localData_[0] = r.localData_[0];
       data_ = localData_;
     }
   }

◆ ArrayND() [5/20]

template<typename Numeric , unsigned Len, unsigned Dim>

template<typename Num2 , unsigned Len2, unsigned Dim2>

npstat::ArrayND< Numeric, Len, Dim >::ArrayND ( const ArrayND< Num2, Len2, Dim2 > & r )

Converting constructor. It looks more general than the copy constructor, but the actual copy constructor has to be created anyway – otherwise the compiler will generate an incorrect default copy constructor. Note that existence of this constructor essentially disables data type safety for copying arrays – but the code significantly gains in convenience.

Definition at line 2518 of file ArrayND.h.

       : data_(0), strides_(nullptr), shape_(nullptr), len_(r.len_), dim_(r.dim_), shapeIsKnown_(r.shapeIsKnown_) {
     if (dim_) {
       // Copy the shape
       shape_ = makeBuffer(dim_, localShape_, Dim);
       copyBuffer(shape_, r.shape_, dim_);
 
       // Copy the strides
       strides_ = makeBuffer(dim_, localStrides_, Dim);
       copyBuffer(strides_, r.strides_, dim_);
 
       // Copy the data
       data_ = makeBuffer(len_, localData_, Len);
       copyBuffer(data_, r.data_, len_);
     } else {
       assert(len_ == 1UL);
       localData_[0] = static_cast<Numeric>(r.localData_[0]);
       data_ = localData_;
     }
   }

◆ ArrayND() [6/20]

template<typename Numeric , unsigned Len, unsigned Dim>

template<typename Num2 , unsigned Len2, unsigned Dim2, class Functor >

npstat::ArrayND< Numeric, Len, Dim >::ArrayND	(	const ArrayND< Num2, Len2, Dim2 > &	r,
		Functor	f
	)

Converting constructor where the array values are filled by a functor using values of another array as arguments

Definition at line 2541 of file ArrayND.h.

       : data_(0), strides_(nullptr), shape_(nullptr), len_(r.len_), dim_(r.dim_), shapeIsKnown_(r.shapeIsKnown_) {
     if (dim_) {
       // Copy the shape
       shape_ = makeBuffer(dim_, localShape_, Dim);
       copyBuffer(shape_, r.shape_, dim_);
 
       // Copy the strides
       strides_ = makeBuffer(dim_, localStrides_, Dim);
       copyBuffer(strides_, r.strides_, dim_);
 
       // Copy the data
       data_ = makeBuffer(len_, localData_, Len);
       for (unsigned long i = 0; i < len_; ++i)
         data_[i] = static_cast<Numeric>(f(r.data_[i]));
     } else {
       assert(len_ == 1UL);
       localData_[0] = static_cast<Numeric>(f(r.localData_[0]));
       data_ = localData_;
     }
   }

◆ ArrayND() [7/20]

template<typename Numeric , unsigned Len, unsigned Dim>

template<typename Num2 , unsigned Len2, unsigned Dim2>

npstat::ArrayND< Numeric, Len, Dim >::ArrayND	(	const ArrayND< Num2, Len2, Dim2 > &	from,
		const ArrayRange &	fromRange
	)

Constructor from a subrange of another array

Definition at line 2591 of file ArrayND.h.

       : data_(0), strides_(nullptr), shape_(nullptr), len_(r.len_), dim_(r.dim_), shapeIsKnown_(r.shapeIsKnown_) {
     if (!range.isCompatible(r.shape_, r.dim_))
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND subrange constructor: invalid subrange");
     if (dim_) {
       len_ = range.rangeSize();
       if (!len_)
         throw npstat::NpstatInvalidArgument("In npstat::ArrayND subrange constructor: empty subrange");
 
       // Figure out the shape
       shape_ = makeBuffer(dim_, localShape_, Dim);
       range.rangeLength(shape_, dim_);
 
       // Figure out the strides
       buildStrides();
 
       // Allocate the data array
       data_ = makeBuffer(len_, localData_, Len);
 
       // Copy the data
       if (dim_ > CHAR_BIT * sizeof(unsigned long))
         throw npstat::NpstatInvalidArgument(
             "In npstat::ArrayND subrange constructor: "
             "input array rank is too large");
       unsigned lolim[CHAR_BIT * sizeof(unsigned long)];
       range.lowerLimits(lolim, dim_);
       unsigned toBuf[CHAR_BIT * sizeof(unsigned long)];
       clearBuffer(toBuf, dim_);
       (const_cast<ArrayND<Num2, Len2, Dim2>&>(r))
           .commonSubrangeLoop(0U, 0UL, 0UL, lolim, shape_, toBuf, *this, scast_assign_right<Num2, Numeric>());
     } else {
       assert(len_ == 1UL);
       localData_[0] = static_cast<Numeric>(r.localData_[0]);
       data_ = localData_;
     }
   }

◆ ArrayND() [8/20]

template<typename Numeric , unsigned Len, unsigned Dim>

template<typename Num2 , unsigned Len2, unsigned Dim2, class Functor >

npstat::ArrayND< Numeric, Len, Dim >::ArrayND	(	const ArrayND< Num2, Len2, Dim2 > &	from,
		const ArrayRange &	fromRange,
		Functor	f
	)

Similar constructor with a transforming functor

Definition at line 2630 of file ArrayND.h.

       : data_(0), strides_(nullptr), shape_(nullptr), len_(r.len_), dim_(r.dim_), shapeIsKnown_(r.shapeIsKnown_) {
     if (!range.isCompatible(r.shape_, r.dim_))
       throw npstat::NpstatInvalidArgument(
           "In npstat::ArrayND transforming subrange constructor: "
           "incompatible subrange");
     if (dim_) {
       len_ = range.rangeSize();
       if (!len_)
         throw npstat::NpstatInvalidArgument(
             "In npstat::ArrayND transforming subrange constructor: "
             "empty subrange");
 
       // Figure out the shape
       shape_ = makeBuffer(dim_, localShape_, Dim);
       for (unsigned i = 0; i < dim_; ++i)
         shape_[i] = range[i].length();
 
       // Figure out the strides
       buildStrides();
 
       // Allocate the data array
       data_ = makeBuffer(len_, localData_, Len);
 
       // Transform the data
       copyRangeLoopFunct(0U, 0UL, 0UL, r, range, f);
     } else {
       assert(len_ == 1UL);
       localData_[0] = static_cast<Numeric>(f(r.localData_[0]));
       data_ = localData_;
     }
   }

◆ ArrayND() [9/20]

template<typename Numeric , unsigned StackLen, unsigned StackDim>

template<typename Num2 , unsigned Len2, unsigned Dim2>

npstat::ArrayND< Numeric, StackLen, StackDim >::ArrayND	(	const ArrayND< Num2, Len2, Dim2 > &	slicedArray,
		const unsigned *	indices,
		unsigned	nIndices
	)

Constructor from a slice of another array. The data of the constructed array remains undefined. The argument "indices" lists either the array indices whose numbers will be fixed when slicing is performed or the indices which will be iterated over during projections (for example, array values may be summed over these indices). These indices will be excluded from the constructed array. The created array can be subsequently used with methods "exportSlice", "importSlice", "project", etc. of the parent array "slicedArray".

Definition at line 1671 of file ArrayND.h.

       : data_(0),
         strides_(nullptr),
         shape_(nullptr),
         len_(1UL),
         dim_(slicedArray.dim_ - nFixedIndices),
         shapeIsKnown_(true) {
     if (nFixedIndices) {
       assert(fixedIndices);
       if (nFixedIndices > slicedArray.dim_)
         throw npstat::NpstatInvalidArgument("In npstat::ArrayND slicing constructor: too many fixed indices");
       if (!slicedArray.shapeIsKnown_)
         throw npstat::NpstatInvalidArgument(
             "In npstat::ArrayND slicing constructor: "
             "uninitialized argument array");
 
       // Check that the fixed indices are within range
       for (unsigned j = 0; j < nFixedIndices; ++j)
         if (fixedIndices[j] >= slicedArray.dim_)
           throw npstat::NpstatOutOfRange(
               "In npstat::ArrayND slicing "
               "constructor: fixed index out of range");
 
       // Build the shape for the slice
       shape_ = makeBuffer(dim_, localShape_, StackDim);
       unsigned idim = 0;
       for (unsigned i = 0; i < slicedArray.dim_; ++i) {
         bool fixed = false;
         for (unsigned j = 0; j < nFixedIndices; ++j)
           if (fixedIndices[j] == i) {
             fixed = true;
             break;
           }
         if (!fixed) {
           assert(idim < dim_);
           shape_[idim++] = slicedArray.shape_[i];
         }
       }
       assert(idim == dim_);
 
       if (dim_) {
         // Copy the array shape and figure out the array length
         for (unsigned i = 0; i < dim_; ++i)
           len_ *= shape_[i];
 
         // Figure out the array strides
         buildStrides();
 
         // Allocate the data array
         data_ = makeBuffer(len_, localData_, StackLen);
       } else {
         localData_[0] = Numeric();
         data_ = localData_;
       }
     } else {
       new (this) ArrayND(slicedArray);
     }
   }

◆ ArrayND() [10/20]

template<typename Numeric , unsigned Len, unsigned Dim>

template<typename Num1 , unsigned Len1, unsigned Dim1, typename Num2 , unsigned Len2, unsigned Dim2>

npstat::ArrayND< Numeric, Len, Dim >::ArrayND	(	const ArrayND< Num1, Len1, Dim1 > &	a1,
		const ArrayND< Num2, Len2, Dim2 > &	a2
	)

Outer product constructor

Definition at line 2869 of file ArrayND.h.

       : data_(0), strides_(nullptr), shape_(nullptr), len_(1UL), dim_(a1.dim_ + a2.dim_), shapeIsKnown_(true) {
     if (!(a1.shapeIsKnown_ && a2.shapeIsKnown_))
       throw npstat::NpstatInvalidArgument(
           "In npstat::ArrayND outer product constructor: "
           "uninitialized argument array");
     if (dim_) {
       shape_ = makeBuffer(dim_, localShape_, Dim);
       copyBuffer(shape_, a1.shape_, a1.dim_);
       copyBuffer(shape_ + a1.dim_, a2.shape_, a2.dim_);
 
       for (unsigned i = 0; i < dim_; ++i) {
         assert(shape_[i]);
         len_ *= shape_[i];
       }
 
       // Figure out the array strides
       buildStrides();
 
       // Allocate the data array
       data_ = makeBuffer(len_, localData_, Len);
 
       // Fill the data array
       if (a1.dim_ == 0) {
         for (unsigned long i = 0; i < len_; ++i)
           data_[i] = a1.localData_[0] * a2.data_[i];
       } else if (a2.dim_ == 0) {
         for (unsigned long i = 0; i < len_; ++i)
           data_[i] = a1.data_[i] * a2.localData_[0];
       } else
         outerProductLoop(0U, 0UL, 0UL, 0UL, a1, a2);
     } else {
       localData_[0] = a1.localData_[0] * a2.localData_[0];
       data_ = localData_;
     }
   }

◆ ArrayND() [11/20]

template<typename Numeric , unsigned Len, unsigned Dim>

npstat::ArrayND< Numeric, Len, Dim >::ArrayND ( unsigned n0 )

explicit

Constructor in which the spans are explicitly provided for each dimension. The array data remains undefined.

Definition at line 2677 of file ArrayND.h.

       : data_(0), strides_(nullptr), shape_(nullptr), len_(1UL), shapeIsKnown_(true) {
     const unsigned dim = 1U;
     unsigned sizes[dim];
     sizes[0] = n0;
     buildFromShapePtr(sizes, dim);
   }

◆ ArrayND() [12/20]

template<typename Numeric , unsigned Len, unsigned Dim>

npstat::ArrayND< Numeric, Len, Dim >::ArrayND	(	unsigned	n0,
		unsigned	n1
	)

Definition at line 2686 of file ArrayND.h.

       : data_(0), strides_(nullptr), shape_(nullptr), len_(1UL), shapeIsKnown_(true) {
     const unsigned dim = 2U;
     unsigned sizes[dim];
     sizes[0] = n0;
     sizes[1] = n1;
     buildFromShapePtr(sizes, dim);
   }

◆ ArrayND() [13/20]

template<typename Numeric , unsigned Len, unsigned Dim>

npstat::ArrayND< Numeric, Len, Dim >::ArrayND	(	unsigned	n0,
		unsigned	n1,
		unsigned	n2
	)

Definition at line 2696 of file ArrayND.h.

       : data_(0), strides_(nullptr), shape_(nullptr), len_(1UL), shapeIsKnown_(true) {
     const unsigned dim = 3U;
     unsigned sizes[dim];
     sizes[0] = n0;
     sizes[1] = n1;
     sizes[2] = n2;
     buildFromShapePtr(sizes, dim);
   }

◆ ArrayND() [14/20]

template<typename Numeric , unsigned Len, unsigned Dim>

npstat::ArrayND< Numeric, Len, Dim >::ArrayND	(	unsigned	n0,
		unsigned	n1,
		unsigned	n2,
		unsigned	n3
	)

Definition at line 2707 of file ArrayND.h.

       : data_(0), strides_(nullptr), shape_(nullptr), len_(1UL), shapeIsKnown_(true) {
     const unsigned dim = 4U;
     unsigned sizes[dim];
     sizes[0] = n0;
     sizes[1] = n1;
     sizes[2] = n2;
     sizes[3] = n3;
     buildFromShapePtr(sizes, dim);
   }

◆ ArrayND() [15/20]

template<typename Numeric , unsigned Len, unsigned Dim>

npstat::ArrayND< Numeric, Len, Dim >::ArrayND	(	unsigned	n0,
		unsigned	n1,
		unsigned	n2,
		unsigned	n3,
		unsigned	n4
	)

Definition at line 2719 of file ArrayND.h.

       : data_(0), strides_(nullptr), shape_(nullptr), len_(1UL), shapeIsKnown_(true) {
     const unsigned dim = 5U;
     unsigned sizes[dim];
     sizes[0] = n0;
     sizes[1] = n1;
     sizes[2] = n2;
     sizes[3] = n3;
     sizes[4] = n4;
     buildFromShapePtr(sizes, dim);
   }

◆ ArrayND() [16/20]

template<typename Numeric , unsigned Len, unsigned Dim>

npstat::ArrayND< Numeric, Len, Dim >::ArrayND	(	unsigned	n0,
		unsigned	n1,
		unsigned	n2,
		unsigned	n3,
		unsigned	n4,
		unsigned	n5
	)

Definition at line 2733 of file ArrayND.h.

       : data_(0), strides_(nullptr), shape_(nullptr), len_(1UL), shapeIsKnown_(true) {
     const unsigned dim = 6U;
     unsigned sizes[dim];
     sizes[0] = n0;
     sizes[1] = n1;
     sizes[2] = n2;
     sizes[3] = n3;
     sizes[4] = n4;
     sizes[5] = n5;
     buildFromShapePtr(sizes, dim);
   }

◆ ArrayND() [17/20]

template<typename Numeric , unsigned Len, unsigned Dim>

npstat::ArrayND< Numeric, Len, Dim >::ArrayND	(	unsigned	n0,
		unsigned	n1,
		unsigned	n2,
		unsigned	n3,
		unsigned	n4,
		unsigned	n5,
		unsigned	n6
	)

Definition at line 2748 of file ArrayND.h.

       : data_(0), strides_(nullptr), shape_(nullptr), len_(1UL), shapeIsKnown_(true) {
     const unsigned dim = 7U;
     unsigned sizes[dim];
     sizes[0] = n0;
     sizes[1] = n1;
     sizes[2] = n2;
     sizes[3] = n3;
     sizes[4] = n4;
     sizes[5] = n5;
     sizes[6] = n6;
     buildFromShapePtr(sizes, dim);
   }

◆ ArrayND() [18/20]

template<typename Numeric , unsigned Len, unsigned Dim>

npstat::ArrayND< Numeric, Len, Dim >::ArrayND	(	unsigned	n0,
		unsigned	n1,
		unsigned	n2,
		unsigned	n3,
		unsigned	n4,
		unsigned	n5,
		unsigned	n6,
		unsigned	n7
	)

Definition at line 2769 of file ArrayND.h.

       : data_(0), strides_(nullptr), shape_(nullptr), len_(1UL), shapeIsKnown_(true) {
     const unsigned dim = 8U;
     unsigned sizes[dim];
     sizes[0] = n0;
     sizes[1] = n1;
     sizes[2] = n2;
     sizes[3] = n3;
     sizes[4] = n4;
     sizes[5] = n5;
     sizes[6] = n6;
     sizes[7] = n7;
     buildFromShapePtr(sizes, dim);
   }

◆ ArrayND() [19/20]

template<typename Numeric , unsigned Len, unsigned Dim>

npstat::ArrayND< Numeric, Len, Dim >::ArrayND	(	unsigned	n0,
		unsigned	n1,
		unsigned	n2,
		unsigned	n3,
		unsigned	n4,
		unsigned	n5,
		unsigned	n6,
		unsigned	n7,
		unsigned	n8
	)

Definition at line 2792 of file ArrayND.h.

       : data_(0), strides_(nullptr), shape_(nullptr), len_(1UL), shapeIsKnown_(true) {
     const unsigned dim = 9U;
     unsigned sizes[dim];
     sizes[0] = n0;
     sizes[1] = n1;
     sizes[2] = n2;
     sizes[3] = n3;
     sizes[4] = n4;
     sizes[5] = n5;
     sizes[6] = n6;
     sizes[7] = n7;
     sizes[8] = n8;
     buildFromShapePtr(sizes, dim);
   }

◆ ArrayND() [20/20]

template<typename Numeric , unsigned Len, unsigned Dim>

npstat::ArrayND< Numeric, Len, Dim >::ArrayND	(	unsigned	n0,
		unsigned	n1,
		unsigned	n2,
		unsigned	n3,
		unsigned	n4,
		unsigned	n5,
		unsigned	n6,
		unsigned	n7,
		unsigned	n8,
		unsigned	n9
	)

Definition at line 2817 of file ArrayND.h.

       : data_(0), strides_(nullptr), shape_(nullptr), len_(1UL), shapeIsKnown_(true) {
     const unsigned dim = 10U;
     unsigned sizes[dim];
     sizes[0] = n0;
     sizes[1] = n1;
     sizes[2] = n2;
     sizes[3] = n3;
     sizes[4] = n4;
     sizes[5] = n5;
     sizes[6] = n6;
     sizes[7] = n7;
     sizes[8] = n8;
     sizes[9] = n9;
     buildFromShapePtr(sizes, dim);
   }

◆ ~ArrayND()

template<typename Numeric , unsigned Len, unsigned Dim>

npstat::ArrayND< Numeric, Len, Dim >::~ArrayND ( )

inline

Destructor

Definition at line 2907 of file ArrayND.h.

                                               {
     destroyBuffer(data_, localData_);
     destroyBuffer(strides_, localStrides_);
     destroyBuffer(shape_, localShape_);
   }

Member Function Documentation

◆ addmul() [1/2]

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

template<typename Num3 , typename Num2 , unsigned Len2, unsigned Dim2>

ArrayND& npstat::ArrayND< Numeric, StackLen, StackDim >::addmul	(	const ArrayND< Num2, Len2, Dim2 > &	r,
		const Num3 &	c
	)

This method is equivalent to (but faster than) += r*c

◆ addmul() [2/2]

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

template<typename Num3 , typename Num2 , unsigned Len2, unsigned Dim2>

ArrayND<Numeric, Len, Dim>& npstat::ArrayND< Numeric, StackLen, StackDim >::addmul	(	const ArrayND< Num2, Len2, Dim2 > &	r,
		const Num3 &	c
	)

Definition at line 4188 of file ArrayND.h.

                                                                                                                   {
     if (!isShapeCompatible(r))
       throw npstat::NpstatInvalidArgument(
           "In npstat::ArrayND::addmul: "
           "incompatible argument array shape");
     for (unsigned long i = 0; i < len_; ++i)
       data_[i] += r.data_[i] * c;
     return *this;
   }

◆ addToProjection() [1/2]

template<typename Numeric, unsigned StackLen, unsigned StackDim>

template<typename Num2 , unsigned Len2, unsigned Dim2, typename Num3 >

void npstat::ArrayND< Numeric, StackLen, StackDim >::addToProjection	(	ArrayND< Num2, Len2, Dim2 > *	projection,
		AbsArrayProjector< Numeric, Num3 > &	projector,
		const unsigned *	projectedIndices,
		unsigned	nProjectedIndices
	)		const

Similar method to "project", but projections are added to (or subtracted from) the existing projection data instead of replacing them

Definition at line 2129 of file ArrayND.h.

                                                                                                      {
     assert(projection);
     verifyProjectionCompatibility(*projection, projectedIndices, nProjectedIndices);
     unsigned ibuf[StackDim];
     unsigned* buf = makeBuffer(dim_, ibuf, StackDim);
     for (unsigned i = 0; i < dim_; ++i)
       buf[i] = 0U;
     projectLoop(0U,
                 0UL,
                 0U,
                 0UL,
                 buf,
                 projection,
                 projector,
                 projectedIndices,
                 nProjectedIndices,
                 scast_pluseq_left<Num2, Num3>());
     destroyBuffer(buf, ibuf);
   }

◆ addToProjection() [2/2]

template<typename Numeric, unsigned StackLen, unsigned StackDim>

template<typename Num2 , unsigned Len2, unsigned Dim2, typename Num3 >

void npstat::ArrayND< Numeric, StackLen, StackDim >::addToProjection	(	ArrayND< Num2, Len2, Dim2 > *	projection,
		AbsVisitor< Numeric, Num3 > &	projector,
		const unsigned *	projectedIndices,
		unsigned	nProjectedIndices
	)		const

Definition at line 2257 of file ArrayND.h.

                                                                                                      {
     assert(projection);
     verifyProjectionCompatibility(*projection, projectedIndices, nProjectedIndices);
     projectLoop2(
         0U, 0UL, 0U, 0UL, projection, projector, projectedIndices, nProjectedIndices, scast_pluseq_left<Num2, Num3>());
   }

◆ apply() [1/2]

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

template<class Functor >

ArrayND& npstat::ArrayND< Numeric, StackLen, StackDim >::apply ( Functor f )

This method applies a single-argument functor to each element of the array (in-place). The result returned by the functor becomes the new value of the element. There must be a conversion (static cast) from the functor result to the "Numeric" type. The method returns *this which allows for chaining of such methods. Use the transforming constructor if you want a new array instead.

Referenced by heavyIonTools.ConfigureHeavyIons::__call__(), coreTools.RunOnData::__call__(), trackTools.MakeAODTrackCandidates::__call__(), runJetUncertainties.RunJetUncertainties::__call__(), metTools.AddMETCollection::__call__(), heavyIonTools.ProductionDefaults::__call__(), cmsswVersionTools.PickRelValInputFiles::__call__(), coreTools.RemoveMCMatching::__call__(), trackTools.MakePATTrackCandidates::__call__(), trigTools.SwitchOnTrigger::__call__(), runMETCorrectionsAndUncertainties.RunMETCorrectionsAndUncertainties::__call__(), heavyIonTools.SelectionDefaults::__call__(), heavyIonTools.DisbaleMonteCarloDeps::__call__(), trigTools.SwitchOnTriggerStandAlone::__call__(), tauTools.AddTauCollection::__call__(), trackTools.MakeTrackCandidates::__call__(), trigTools.SwitchOnTriggerMatching::__call__(), trigTools.SwitchOnTriggerMatchingStandAlone::__call__(), trigTools.SwitchOnTriggerMatchEmbedding::__call__(), jetTools.AddJetCollection::__call__(), jetTools.SwitchJetCollection::__call__(), jetTools.UpdateJetCollection::__call__(), jetTools.AddJetID::__call__(), and jetTools.SetTagInfos::__call__().

◆ apply() [2/2]

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

template<class Functor >

ArrayND<Numeric, Len, Dim>& npstat::ArrayND< Numeric, StackLen, StackDim >::apply ( Functor f )

Definition at line 4323 of file ArrayND.h.

Referenced by heavyIonTools.ConfigureHeavyIons::__call__(), coreTools.RunOnData::__call__(), trackTools.MakeAODTrackCandidates::__call__(), runJetUncertainties.RunJetUncertainties::__call__(), metTools.AddMETCollection::__call__(), heavyIonTools.ProductionDefaults::__call__(), coreTools.RemoveMCMatching::__call__(), trackTools.MakePATTrackCandidates::__call__(), trigTools.SwitchOnTrigger::__call__(), runMETCorrectionsAndUncertainties.RunMETCorrectionsAndUncertainties::__call__(), heavyIonTools.SelectionDefaults::__call__(), heavyIonTools.DisbaleMonteCarloDeps::__call__(), trigTools.SwitchOnTriggerStandAlone::__call__(), tauTools.AddTauCollection::__call__(), trackTools.MakeTrackCandidates::__call__(), trigTools.SwitchOnTriggerMatching::__call__(), trigTools.SwitchOnTriggerMatchingStandAlone::__call__(), trigTools.SwitchOnTriggerMatchEmbedding::__call__(), jetTools.AddJetCollection::__call__(), jetTools.SwitchJetCollection::__call__(), jetTools.UpdateJetCollection::__call__(), jetTools.AddJetID::__call__(), and jetTools.SetTagInfos::__call__().

                                                                          {
     if (!shapeIsKnown_)
       throw npstat::NpstatInvalidArgument("Initialize npstat::ArrayND before calling method \"apply\"");
     for (unsigned long i = 0; i < len_; ++i)
       data_[i] = static_cast<Numeric>(f(data_[i]));
     return *this;
   }

◆ applySlice()

template<typename Numeric , unsigned StackLen, unsigned StackDim>

template<typename Num2 , unsigned Len2, unsigned Dim2, class Functor >

void npstat::ArrayND< Numeric, StackLen, StackDim >::applySlice	(	ArrayND< Num2, Len2, Dim2 > &	slice,
		const unsigned *	fixedIndices,
		unsigned	nFixedIndices,
		Functor	binaryFunct
	)

This method applies the values in the slice to all other coresponding values in the array. This can be used, for example, to multiply/divide by some factor which varies across the slice. The slice values will be used as the right functor argument.

Definition at line 2354 of file ArrayND.h.

Referenced by npstat::ArrayND< Numeric >::multiplyBySlice().

                                                                              {
     if (nFixedIndices) {
       verifyProjectionCompatibility(slice, fixedIndices, nFixedIndices);
       if (slice.dim_ == 0U)
         for (unsigned long i = 0; i < len_; ++i)
           binaryFunct(data_[i], slice.localData_[0]);
       else
         scaleBySliceLoop(0U, 0UL, 0U, 0UL, slice, fixedIndices, nFixedIndices, binaryFunct);
     } else
       jointScan(slice, binaryFunct);
   }

◆ assign() [1/2]

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

template<typename Num2 , unsigned Len2, unsigned Dim2, class Functor >

ArrayND& npstat::ArrayND< Numeric, StackLen, StackDim >::assign	(	const ArrayND< Num2, Len2, Dim2 > &	,
		Functor	f
	)

Converting assignment method with a transforming functor

◆ assign() [2/2]

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

template<typename Num2 , unsigned Len2, unsigned Dim2, class Functor >

ArrayND<Numeric, Len, Dim>& npstat::ArrayND< Numeric, StackLen, StackDim >::assign	(	const ArrayND< Num2, Len2, Dim2 > &	r,
		Functor	f
	)

Definition at line 2968 of file ArrayND.h.

                                                                                                               {
     if (shapeIsKnown_) {
       if (!r.shapeIsKnown_)
         throw npstat::NpstatInvalidArgument("In npstat::ArrayND::assign: uninitialized argument array");
       if (!isShapeCompatible(r))
         throw npstat::NpstatInvalidArgument("In npstat::ArrayND::assign: incompatible argument array shape");
       if (dim_)
         for (unsigned long i = 0; i < len_; ++i)
           data_[i] = static_cast<Numeric>(f(r.data_[i]));
       else
         localData_[0] = static_cast<Numeric>(f(r.localData_[0]));
     } else {
       // This object is uninitialized. If the object on the
       // right is itself initialized, build new array in place.
       if (r.shapeIsKnown_)
         new (this) ArrayND(r, f);
     }
     return *this;
   }

◆ at() [1/22]

template<typename Numeric , unsigned Len, unsigned Dim>

Numeric & npstat::ArrayND< Numeric, Len, Dim >::at ( )

Fortran-style subscripting with bounds checking (of course, with indices starting at 0).

Definition at line 3268 of file ArrayND.h.

                                           {
     if (!shapeIsKnown_)
       throw npstat::NpstatInvalidArgument("Initialize npstat::ArrayND before calling method \"at\"");
     if (dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::at: wrong # of args (not rank 0 array)");
     return localData_[0];
   }

◆ at() [2/22]

template<typename Numeric , unsigned Len, unsigned Dim>

const Numeric & npstat::ArrayND< Numeric, Len, Dim >::at ( ) const

Definition at line 3259 of file ArrayND.h.

                                                       {
     if (!shapeIsKnown_)
       throw npstat::NpstatInvalidArgument("Initialize npstat::ArrayND before calling method \"at\"");
     if (dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::at: wrong # of args (not rank 0 array)");
     return localData_[0];
   }

◆ at() [3/22]

template<typename Numeric , unsigned Len, unsigned Dim>

Numeric & npstat::ArrayND< Numeric, Len, Dim >::at ( unsigned i0 )

Definition at line 3286 of file ArrayND.h.

                                                            {
     if (1U != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::at: wrong # of args (not rank 1 array)");
     if (i0 >= shape_[0])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 0 out of range (rank 1)");
     return data_[i0];
   }

◆ at() [4/22]

template<typename Numeric , unsigned Len, unsigned Dim>

const Numeric & npstat::ArrayND< Numeric, Len, Dim >::at ( unsigned i0 ) const

Definition at line 3277 of file ArrayND.h.

                                                                        {
     if (1U != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::at: wrong # of args (not rank 1 array)");
     if (i0 >= shape_[0])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 0 out of range (rank 1)");
     return data_[i0];
   }

◆ at() [5/22]

template<typename Numeric , unsigned Len, unsigned Dim>

Numeric & npstat::ArrayND< Numeric, Len, Dim >::at	(	unsigned	i0,
		unsigned	i1
	)

Definition at line 3320 of file ArrayND.h.

                                                                               {
     if (2U != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::at: wrong # of args (not rank 2 array)");
     if (i0 >= shape_[0])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 0 out of range (rank 2)");
     if (i1 >= shape_[1])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 1 out of range (rank 2)");
     return data_[i0 * strides_[0] + i1];
   }

◆ at() [6/22]

template<typename Numeric , unsigned Len, unsigned Dim>

const Numeric & npstat::ArrayND< Numeric, Len, Dim >::at	(	unsigned	i0,
		unsigned	i1
	)		const

Definition at line 3309 of file ArrayND.h.

                                                                                           {
     if (2U != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::at: wrong # of args (not rank 2 array)");
     if (i0 >= shape_[0])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 0 out of range (rank 2)");
     if (i1 >= shape_[1])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 1 out of range (rank 2)");
     return data_[i0 * strides_[0] + i1];
   }

◆ at() [7/22]

template<typename Numeric , unsigned Len, unsigned Dim>

Numeric & npstat::ArrayND< Numeric, Len, Dim >::at	(	unsigned	i0,
		unsigned	i1,
		unsigned	i2
	)

Definition at line 3734 of file ArrayND.h.

                                                                                                  {
     if (3U != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::at: wrong # of args (not rank 3 array)");
     if (i0 >= shape_[0])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 0 out of range (rank 3)");
     if (i1 >= shape_[1])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 1 out of range (rank 3)");
     if (i2 >= shape_[2])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 2 out of range (rank 3)");
     return data_[i0 * strides_[0] + i1 * strides_[1] + i2];
   }

◆ at() [8/22]

template<typename Numeric , unsigned Len, unsigned Dim>

const Numeric & npstat::ArrayND< Numeric, Len, Dim >::at	(	unsigned	i0,
		unsigned	i1,
		unsigned	i2
	)		const

Definition at line 3531 of file ArrayND.h.

                                                                                                              {
     if (3U != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::at: wrong # of args (not rank 3 array)");
     if (i0 >= shape_[0])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 0 out of range (rank 3)");
     if (i1 >= shape_[1])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 1 out of range (rank 3)");
     if (i2 >= shape_[2])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 2 out of range (rank 3)");
     return data_[i0 * strides_[0] + i1 * strides_[1] + i2];
   }

◆ at() [9/22]

template<typename Numeric , unsigned Len, unsigned Dim>

Numeric & npstat::ArrayND< Numeric, Len, Dim >::at	(	unsigned	i0,
		unsigned	i1,
		unsigned	i2,
		unsigned	i3
	)

Definition at line 3747 of file ArrayND.h.

                                                                                                                     {
     if (4U != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::at: wrong # of args (not rank 4 array)");
     if (i0 >= shape_[0])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 0 out of range (rank 4)");
     if (i1 >= shape_[1])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 1 out of range (rank 4)");
     if (i2 >= shape_[2])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 2 out of range (rank 4)");
     if (i3 >= shape_[3])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 3 out of range (rank 4)");
     return data_[i0 * strides_[0] + i1 * strides_[1] + i2 * strides_[2] + i3];
   }

◆ at() [10/22]

template<typename Numeric , unsigned Len, unsigned Dim>

const Numeric & npstat::ArrayND< Numeric, Len, Dim >::at	(	unsigned	i0,
		unsigned	i1,
		unsigned	i2,
		unsigned	i3
	)		const

Definition at line 3544 of file ArrayND.h.

                                                                          {
     if (4U != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::at: wrong # of args (not rank 4 array)");
     if (i0 >= shape_[0])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 0 out of range (rank 4)");
     if (i1 >= shape_[1])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 1 out of range (rank 4)");
     if (i2 >= shape_[2])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 2 out of range (rank 4)");
     if (i3 >= shape_[3])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 3 out of range (rank 4)");
     return data_[i0 * strides_[0] + i1 * strides_[1] + i2 * strides_[2] + i3];
   }

◆ at() [11/22]

template<typename Numeric , unsigned Len, unsigned Dim>

Numeric & npstat::ArrayND< Numeric, Len, Dim >::at	(	unsigned	i0,
		unsigned	i1,
		unsigned	i2,
		unsigned	i3,
		unsigned	i4
	)

Definition at line 3762 of file ArrayND.h.

                                                                                                      {
     if (5U != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::at: wrong # of args (not rank 5 array)");
     if (i0 >= shape_[0])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 0 out of range (rank 5)");
     if (i1 >= shape_[1])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 1 out of range (rank 5)");
     if (i2 >= shape_[2])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 2 out of range (rank 5)");
     if (i3 >= shape_[3])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 3 out of range (rank 5)");
     if (i4 >= shape_[4])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 4 out of range (rank 5)");
     return data_[i0 * strides_[0] + i1 * strides_[1] + i2 * strides_[2] + i3 * strides_[3] + i4];
   }

◆ at() [12/22]

template<typename Numeric , unsigned Len, unsigned Dim>

const Numeric & npstat::ArrayND< Numeric, Len, Dim >::at	(	unsigned	i0,
		unsigned	i1,
		unsigned	i2,
		unsigned	i3,
		unsigned	i4
	)		const

Definition at line 3562 of file ArrayND.h.

                                                                                                            {
     if (5U != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::at: wrong # of args (not rank 5 array)");
     if (i0 >= shape_[0])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 0 out of range (rank 5)");
     if (i1 >= shape_[1])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 1 out of range (rank 5)");
     if (i2 >= shape_[2])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 2 out of range (rank 5)");
     if (i3 >= shape_[3])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 3 out of range (rank 5)");
     if (i4 >= shape_[4])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 4 out of range (rank 5)");
     return data_[i0 * strides_[0] + i1 * strides_[1] + i2 * strides_[2] + i3 * strides_[3] + i4];
   }

◆ at() [13/22]

template<typename Numeric , unsigned Len, unsigned Dim>

Numeric & npstat::ArrayND< Numeric, Len, Dim >::at	(	unsigned	i0,
		unsigned	i1,
		unsigned	i2,
		unsigned	i3,
		unsigned	i4,
		unsigned	i5
	)

Definition at line 3780 of file ArrayND.h.

                                                              {
     if (6U != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::at: wrong # of args (not rank 6 array)");
     if (i0 >= shape_[0])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 0 out of range (rank 6)");
     if (i1 >= shape_[1])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 1 out of range (rank 6)");
     if (i2 >= shape_[2])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 2 out of range (rank 6)");
     if (i3 >= shape_[3])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 3 out of range (rank 6)");
     if (i4 >= shape_[4])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 4 out of range (rank 6)");
     if (i5 >= shape_[5])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 5 out of range (rank 6)");
     return data_[i0 * strides_[0] + i1 * strides_[1] + i2 * strides_[2] + i3 * strides_[3] + i4 * strides_[4] + i5];
   }

◆ at() [14/22]

template<typename Numeric , unsigned Len, unsigned Dim>

const Numeric & npstat::ArrayND< Numeric, Len, Dim >::at	(	unsigned	i0,
		unsigned	i1,
		unsigned	i2,
		unsigned	i3,
		unsigned	i4,
		unsigned	i5
	)		const

Definition at line 3580 of file ArrayND.h.

                                                                          {
     if (6U != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::at: wrong # of args (not rank 6 array)");
     if (i0 >= shape_[0])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 0 out of range (rank 6)");
     if (i1 >= shape_[1])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 1 out of range (rank 6)");
     if (i2 >= shape_[2])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 2 out of range (rank 6)");
     if (i3 >= shape_[3])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 3 out of range (rank 6)");
     if (i4 >= shape_[4])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 4 out of range (rank 6)");
     if (i5 >= shape_[5])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 5 out of range (rank 6)");
     return data_[i0 * strides_[0] + i1 * strides_[1] + i2 * strides_[2] + i3 * strides_[3] + i4 * strides_[4] + i5];
   }

◆ at() [15/22]

template<typename Numeric , unsigned Len, unsigned Dim>

Numeric & npstat::ArrayND< Numeric, Len, Dim >::at	(	unsigned	i0,
		unsigned	i1,
		unsigned	i2,
		unsigned	i3,
		unsigned	i4,
		unsigned	i5,
		unsigned	i6
	)

Definition at line 3804 of file ArrayND.h.

                                                              {
     if (7U != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::at: wrong # of args (not rank 7 array)");
     if (i0 >= shape_[0])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 0 out of range (rank 7)");
     if (i1 >= shape_[1])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 1 out of range (rank 7)");
     if (i2 >= shape_[2])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 2 out of range (rank 7)");
     if (i3 >= shape_[3])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 3 out of range (rank 7)");
     if (i4 >= shape_[4])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 4 out of range (rank 7)");
     if (i5 >= shape_[5])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 5 out of range (rank 7)");
     if (i6 >= shape_[6])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 6 out of range (rank 7)");
     return data_[i0 * strides_[0] + i1 * strides_[1] + i2 * strides_[2] + i3 * strides_[3] + i4 * strides_[4] +
                  i5 * strides_[5] + i6];
   }

◆ at() [16/22]

template<typename Numeric , unsigned Len, unsigned Dim>

const Numeric & npstat::ArrayND< Numeric, Len, Dim >::at	(	unsigned	i0,
		unsigned	i1,
		unsigned	i2,
		unsigned	i3,
		unsigned	i4,
		unsigned	i5,
		unsigned	i6
	)		const

Definition at line 3604 of file ArrayND.h.

                                                                          {
     if (7U != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::at: wrong # of args (not rank 7 array)");
     if (i0 >= shape_[0])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 0 out of range (rank 7)");
     if (i1 >= shape_[1])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 1 out of range (rank 7)");
     if (i2 >= shape_[2])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 2 out of range (rank 7)");
     if (i3 >= shape_[3])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 3 out of range (rank 7)");
     if (i4 >= shape_[4])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 4 out of range (rank 7)");
     if (i5 >= shape_[5])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 5 out of range (rank 7)");
     if (i6 >= shape_[6])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 6 out of range (rank 7)");
     return data_[i0 * strides_[0] + i1 * strides_[1] + i2 * strides_[2] + i3 * strides_[3] + i4 * strides_[4] +
                  i5 * strides_[5] + i6];
   }

◆ at() [17/22]

template<typename Numeric , unsigned Len, unsigned Dim>

Numeric & npstat::ArrayND< Numeric, Len, Dim >::at	(	unsigned	i0,
		unsigned	i1,
		unsigned	i2,
		unsigned	i3,
		unsigned	i4,
		unsigned	i5,
		unsigned	i6,
		unsigned	i7
	)

Definition at line 3832 of file ArrayND.h.

                                                              {
     if (8U != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::at: wrong # of args (not rank 8 array)");
     if (i0 >= shape_[0])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 0 out of range (rank 8)");
     if (i1 >= shape_[1])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 1 out of range (rank 8)");
     if (i2 >= shape_[2])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 2 out of range (rank 8)");
     if (i3 >= shape_[3])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 3 out of range (rank 8)");
     if (i4 >= shape_[4])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 4 out of range (rank 8)");
     if (i5 >= shape_[5])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 5 out of range (rank 8)");
     if (i6 >= shape_[6])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 6 out of range (rank 8)");
     if (i7 >= shape_[7])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 7 out of range (rank 8)");
     return data_[i0 * strides_[0] + i1 * strides_[1] + i2 * strides_[2] + i3 * strides_[3] + i4 * strides_[4] +
                  i5 * strides_[5] + i6 * strides_[6] + i7];
   }

◆ at() [18/22]

template<typename Numeric , unsigned Len, unsigned Dim>

const Numeric & npstat::ArrayND< Numeric, Len, Dim >::at	(	unsigned	i0,
		unsigned	i1,
		unsigned	i2,
		unsigned	i3,
		unsigned	i4,
		unsigned	i5,
		unsigned	i6,
		unsigned	i7
	)		const

Definition at line 3632 of file ArrayND.h.

                                                                          {
     if (8U != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::at: wrong # of args (not rank 8 array)");
     if (i0 >= shape_[0])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 0 out of range (rank 8)");
     if (i1 >= shape_[1])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 1 out of range (rank 8)");
     if (i2 >= shape_[2])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 2 out of range (rank 8)");
     if (i3 >= shape_[3])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 3 out of range (rank 8)");
     if (i4 >= shape_[4])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 4 out of range (rank 8)");
     if (i5 >= shape_[5])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 5 out of range (rank 8)");
     if (i6 >= shape_[6])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 6 out of range (rank 8)");
     if (i7 >= shape_[7])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 7 out of range (rank 8)");
     return data_[i0 * strides_[0] + i1 * strides_[1] + i2 * strides_[2] + i3 * strides_[3] + i4 * strides_[4] +
                  i5 * strides_[5] + i6 * strides_[6] + i7];
   }

◆ at() [19/22]

template<typename Numeric , unsigned Len, unsigned Dim>

Numeric & npstat::ArrayND< Numeric, Len, Dim >::at	(	unsigned	i0,
		unsigned	i1,
		unsigned	i2,
		unsigned	i3,
		unsigned	i4,
		unsigned	i5,
		unsigned	i6,
		unsigned	i7,
		unsigned	i8
	)

Definition at line 3863 of file ArrayND.h.

                                                              {
     if (9U != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::at: wrong # of args (not rank 9 array)");
     if (i0 >= shape_[0])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 0 out of range (rank 9)");
     if (i1 >= shape_[1])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 1 out of range (rank 9)");
     if (i2 >= shape_[2])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 2 out of range (rank 9)");
     if (i3 >= shape_[3])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 3 out of range (rank 9)");
     if (i4 >= shape_[4])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 4 out of range (rank 9)");
     if (i5 >= shape_[5])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 5 out of range (rank 9)");
     if (i6 >= shape_[6])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 6 out of range (rank 9)");
     if (i7 >= shape_[7])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 7 out of range (rank 9)");
     if (i8 >= shape_[8])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 8 out of range (rank 9)");
     return data_[i0 * strides_[0] + i1 * strides_[1] + i2 * strides_[2] + i3 * strides_[3] + i4 * strides_[4] +
                  i5 * strides_[5] + i6 * strides_[6] + i7 * strides_[7] + i8];
   }

◆ at() [20/22]

template<typename Numeric , unsigned Len, unsigned Dim>

const Numeric & npstat::ArrayND< Numeric, Len, Dim >::at	(	unsigned	i0,
		unsigned	i1,
		unsigned	i2,
		unsigned	i3,
		unsigned	i4,
		unsigned	i5,
		unsigned	i6,
		unsigned	i7,
		unsigned	i8
	)		const

Definition at line 3663 of file ArrayND.h.

                                                                          {
     if (9U != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::at: wrong # of args (not rank 9 array)");
     if (i0 >= shape_[0])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 0 out of range (rank 9)");
     if (i1 >= shape_[1])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 1 out of range (rank 9)");
     if (i2 >= shape_[2])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 2 out of range (rank 9)");
     if (i3 >= shape_[3])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 3 out of range (rank 9)");
     if (i4 >= shape_[4])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 4 out of range (rank 9)");
     if (i5 >= shape_[5])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 5 out of range (rank 9)");
     if (i6 >= shape_[6])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 6 out of range (rank 9)");
     if (i7 >= shape_[7])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 7 out of range (rank 9)");
     if (i8 >= shape_[8])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 8 out of range (rank 9)");
     return data_[i0 * strides_[0] + i1 * strides_[1] + i2 * strides_[2] + i3 * strides_[3] + i4 * strides_[4] +
                  i5 * strides_[5] + i6 * strides_[6] + i7 * strides_[7] + i8];
   }

◆ at() [21/22]

template<typename Numeric , unsigned Len, unsigned Dim>

Numeric & npstat::ArrayND< Numeric, Len, Dim >::at	(	unsigned	i0,
		unsigned	i1,
		unsigned	i2,
		unsigned	i3,
		unsigned	i4,
		unsigned	i5,
		unsigned	i6,
		unsigned	i7,
		unsigned	i8,
		unsigned	i9
	)

Definition at line 3897 of file ArrayND.h.

                                                              {
     if (10U != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::at: wrong # of args (not rank 10 array)");
     if (i0 >= shape_[0])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 0 out of range (rank 10)");
     if (i1 >= shape_[1])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 1 out of range (rank 10)");
     if (i2 >= shape_[2])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 2 out of range (rank 10)");
     if (i3 >= shape_[3])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 3 out of range (rank 10)");
     if (i4 >= shape_[4])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 4 out of range (rank 10)");
     if (i5 >= shape_[5])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 5 out of range (rank 10)");
     if (i6 >= shape_[6])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 6 out of range (rank 10)");
     if (i7 >= shape_[7])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 7 out of range (rank 10)");
     if (i8 >= shape_[8])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 8 out of range (rank 10)");
     if (i9 >= shape_[9])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 9 out of range (rank 10)");
     return data_[i0 * strides_[0] + i1 * strides_[1] + i2 * strides_[2] + i3 * strides_[3] + i4 * strides_[4] +
                  i5 * strides_[5] + i6 * strides_[6] + i7 * strides_[7] + i8 * strides_[8] + i9];
   }

◆ at() [22/22]

template<typename Numeric , unsigned Len, unsigned Dim>

const Numeric & npstat::ArrayND< Numeric, Len, Dim >::at	(	unsigned	i0,
		unsigned	i1,
		unsigned	i2,
		unsigned	i3,
		unsigned	i4,
		unsigned	i5,
		unsigned	i6,
		unsigned	i7,
		unsigned	i8,
		unsigned	i9
	)		const

Definition at line 3697 of file ArrayND.h.

                                                                          {
     if (10U != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::at: wrong # of args (not rank 10 array)");
     if (i0 >= shape_[0])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 0 out of range (rank 10)");
     if (i1 >= shape_[1])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 1 out of range (rank 10)");
     if (i2 >= shape_[2])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 2 out of range (rank 10)");
     if (i3 >= shape_[3])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 3 out of range (rank 10)");
     if (i4 >= shape_[4])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 4 out of range (rank 10)");
     if (i5 >= shape_[5])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 5 out of range (rank 10)");
     if (i6 >= shape_[6])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 6 out of range (rank 10)");
     if (i7 >= shape_[7])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 7 out of range (rank 10)");
     if (i8 >= shape_[8])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 8 out of range (rank 10)");
     if (i9 >= shape_[9])
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::at: index 9 out of range (rank 10)");
     return data_[i0 * strides_[0] + i1 * strides_[1] + i2 * strides_[2] + i3 * strides_[3] + i4 * strides_[4] +
                  i5 * strides_[5] + i6 * strides_[6] + i7 * strides_[7] + i8 * strides_[8] + i9];
   }

◆ buildFromShapePtr()

template<typename Numeric , unsigned Len, unsigned Dim>

void npstat::ArrayND< Numeric, Len, Dim >::buildFromShapePtr	(	const unsigned *	sizes,
		unsigned	dim
	)

private

Definition at line 1641 of file ArrayND.h.

                                                                                               {
     dim_ = dim;
     if (dim_) {
       assert(sizes);
       for (unsigned i = 0; i < dim_; ++i)
         if (sizes[i] == 0)
           throw npstat::NpstatInvalidArgument(
               "In npstat::ArrayND::buildFromShapePtr: "
               "detected span of zero");
 
       // Copy the array shape and figure out the array length
       shape_ = makeBuffer(dim_, localShape_, Dim);
       for (unsigned i = 0; i < dim_; ++i) {
         shape_[i] = sizes[i];
         len_ *= shape_[i];
       }
 
       // Figure out the array strides
       buildStrides();
 
       // Allocate the data array
       data_ = makeBuffer(len_, localData_, Len);
     } else {
       localData_[0] = Numeric();
       data_ = localData_;
     }
   }

◆ buildStrides()

template<typename Numeric , unsigned Len, unsigned Dim>

void npstat::ArrayND< Numeric, Len, Dim >::buildStrides ( )

private

Definition at line 2478 of file ArrayND.h.

                                                 {
     assert(dim_);
     if (strides_ == nullptr)
       strides_ = makeBuffer(dim_, localStrides_, Dim);
     strides_[dim_ - 1] = 1UL;
     for (unsigned j = dim_ - 1; j > 0; --j)
       strides_[j - 1] = strides_[j] * shape_[j];
   }

◆ cdfArray() [1/2]

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

template<typename Num2 >

ArrayND npstat::ArrayND< Numeric, StackLen, StackDim >::cdfArray ( double scale = 1.0 ) const

The operation inverse to "derivative". Constructs multivariate cumulative density function.

◆ cdfArray() [2/2]

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

template<typename Accumulator >

ArrayND<Numeric, Len, Dim> npstat::ArrayND< Numeric, StackLen, StackDim >::cdfArray ( const double inscale ) const

Definition at line 4852 of file ArrayND.h.

                                                                                             {
     if (!shapeIsKnown_)
       throw npstat::NpstatInvalidArgument("Initialize npstat::ArrayND before calling method \"cdfArray\"");
     if (!dim_)
       throw npstat::NpstatInvalidArgument(
           "npstat::ArrayND::cdfArray method "
           "can not be used with array of 0 rank");
 
     const proper_double scale = inscale;
     const unsigned maxdim = CHAR_BIT * sizeof(unsigned long);
     if (dim_ >= maxdim)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::cdfArray: array rank is too large");
     const unsigned long maxcycle = 1UL << dim_;
 
     ArrayShape sh;
     sh.reserve(dim_);
     for (unsigned i = 0; i < dim_; ++i)
       sh.push_back(shape_[i] + 1U);
 
     ArrayND<Accumulator> result(sh);
 
     unsigned* psh = &sh[0];
     const unsigned long len = result.length();
     for (unsigned long ipre = 0; ipre < len; ++ipre) {
       result.convertLinearIndex(ipre, psh, dim_);
       Accumulator deriv = Accumulator();
       bool has0 = false;
       for (unsigned i = 0; i < dim_; ++i)
         if (psh[i]-- == 0U) {
           has0 = true;
           break;
         }
       if (!has0) {
         for (unsigned long icycle = 0UL; icycle < maxcycle; ++icycle) {
           unsigned long icell = 0UL;
           unsigned n1 = 0U;
           for (unsigned i = 0; i < dim_; ++i) {
             if (icycle & (1UL << i)) {
               ++n1;
               icell += result.strides_[i] * (psh[i] + 1);
             } else
               icell += result.strides_[i] * psh[i];
           }
           if (n1 < dim_) {
             if ((dim_ - n1) % 2U)
               deriv += result.data_[icell];
             else
               deriv -= result.data_[icell];
           }
         }
         deriv += static_cast<Accumulator>(value(psh, dim_) * scale);
       }
       result.data_[ipre] = deriv;
     }
 
     // The "return" will convert Accumulator type into Numeric
     return result;
   }

◆ cdfValue() [1/2]

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

template<typename Num2 >

Num2 npstat::ArrayND< Numeric, StackLen, StackDim >::cdfValue	(	const unsigned *	index,
		unsigned	indexLen
	)		const

Calculate just one multivariate cumulative density function value. Point with given index will be included in the sum.

◆ cdfValue() [2/2]

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

template<typename Accumulator >

Accumulator npstat::ArrayND< Numeric, StackLen, StackDim >::cdfValue	(	const unsigned *	index,
		const unsigned	indexLen
	)		const

Definition at line 4835 of file ArrayND.h.

                                                                                                        {
     if (!shapeIsKnown_)
       throw npstat::NpstatInvalidArgument("Initialize npstat::ArrayND before calling method \"cdfValue\"");
     if (!dim_)
       throw npstat::NpstatInvalidArgument(
           "npstat::ArrayND::cdfValue method "
           "can not be used with array of 0 rank");
     if (indexLen != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::cdfValue: incompatible index length");
     for (unsigned i = 0; i < indexLen; ++i)
       if (index[i] >= shape_[i])
         throw npstat::NpstatOutOfRange("In npstat::ArrayND::cdfValue: index out of range");
     return sumBelowLoop<Accumulator>(0, 0U, index);
   }

◆ circularFlatLoop()

template<typename Numeric , unsigned Len, unsigned Dim>

template<typename Num2 , unsigned Len2, unsigned Dim2, class Functor >

void npstat::ArrayND< Numeric, Len, Dim >::circularFlatLoop	(	unsigned	level,
		unsigned long	idx0,
		unsigned long	idx1,
		const unsigned *	thisCorner,
		const unsigned *	range,
		const unsigned *	otherCorner,
		ArrayND< Num2, Len2, Dim2 > &	other,
		Functor	binaryFunct
	)

private

Definition at line 1467 of file ArrayND.h.

                                                                          {
     const unsigned imax = range[level];
     const unsigned leftShift = thisCorner[level];
     const unsigned leftPeriod = shape_[level];
 
     if (level == dim_ - 1) {
       Numeric* left = data_ + idx0;
       Num2* right = r.data_ + (idx1 + otherCorner[level]);
       Num2* const rMax = r.data_ + (idx1 + r.shape_[level]);
 
       for (unsigned i = 0; i < imax && right < rMax; ++i)
         binaryFunct(left[(i + leftShift) % leftPeriod], *right++);
     } else {
       const unsigned long leftStride = strides_[level];
       const unsigned long rightStride = r.strides_[level];
       const unsigned long rightMax = idx1 + r.shape_[level] * rightStride;
       idx1 += otherCorner[level] * rightStride;
 
       for (unsigned i = 0; i < imax && idx1 < rightMax; ++i, idx1 += rightStride)
         circularFlatLoop(level + 1,
                          idx0 + ((i + leftShift) % leftPeriod) * leftStride,
                          idx1,
                          thisCorner,
                          range,
                          otherCorner,
                          r,
                          binaryFunct);
     }
   }

◆ circularFlatScan()

template<typename Numeric , unsigned Len, unsigned Dim>

template<typename Num2 , unsigned Len2, unsigned Dim2, class Functor >

void npstat::ArrayND< Numeric, Len, Dim >::circularFlatScan	(	ArrayND< Num2, Len2, Dim2 > &	other,
		const unsigned *	thisCorner,
		const unsigned *	range,
		const unsigned *	otherCorner,
		unsigned	arrLen,
		Functor	binaryFunct
	)

Method similar to "jointSubrangeScan" in which the topology of this array is assumed to be hypertoroidal and the other array flat

Definition at line 1508 of file ArrayND.h.

◆ cl() [1/22]

template<typename Numeric , unsigned Len, unsigned Dim>

Numeric & npstat::ArrayND< Numeric, Len, Dim >::cl ( )

inline

Subscripting by continuous coordinate. Works similar to the "closest" method.

Definition at line 5245 of file ArrayND.h.

                                                  {
     if (!shapeIsKnown_)
       throw npstat::NpstatInvalidArgument("Initialize npstat::ArrayND before calling method \"cl\"");
     if (dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::cl: wrong # of args (not rank 0 array)");
     return localData_[0];
   }

◆ cl() [2/22]

template<typename Numeric , unsigned Len, unsigned Dim>

const Numeric & npstat::ArrayND< Numeric, Len, Dim >::cl ( ) const

inline

Definition at line 5115 of file ArrayND.h.

                                                              {
     if (!shapeIsKnown_)
       throw npstat::NpstatInvalidArgument("Initialize npstat::ArrayND before calling method \"cl\"");
     if (dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::cl: wrong # of args (not rank 0 array)");
     return localData_[0];
   }

◆ cl() [3/22]

template<typename Numeric , unsigned Len, unsigned Dim>

Numeric & npstat::ArrayND< Numeric, Len, Dim >::cl ( double x0 )

inline

Definition at line 5254 of file ArrayND.h.

                                                                 {
     if (1U != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::cl: wrong # of args (not rank 1 array)");
     return data_[coordToIndex(i0, 0)];
   }

◆ cl() [4/22]

template<typename Numeric , unsigned Len, unsigned Dim>

const Numeric & npstat::ArrayND< Numeric, Len, Dim >::cl ( double x0 ) const

inline

Definition at line 5124 of file ArrayND.h.

                                                                             {
     if (1U != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::cl: wrong # of args (not rank 1 array)");
     return data_[coordToIndex(i0, 0)];
   }

◆ cl() [5/22]

template<typename Numeric , unsigned Len, unsigned Dim>

Numeric & npstat::ArrayND< Numeric, Len, Dim >::cl	(	double	x0,
		double	x1
	)

inline

Definition at line 5261 of file ArrayND.h.

                                                                                  {
     if (2U != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::cl: wrong # of args (not rank 2 array)");
     return data_[coordToIndex(i0, 0) * strides_[0] + coordToIndex(i1, 1)];
   }

◆ cl() [6/22]

template<typename Numeric , unsigned Len, unsigned Dim>

const Numeric & npstat::ArrayND< Numeric, Len, Dim >::cl	(	double	x0,
		double	x1
	)		const

inline

Definition at line 5131 of file ArrayND.h.

                                                                                              {
     if (2U != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::cl: wrong # of args (not rank 2 array)");
     return data_[coordToIndex(i0, 0) * strides_[0] + coordToIndex(i1, 1)];
   }

◆ cl() [7/22]

template<typename Numeric , unsigned Len, unsigned Dim>

Numeric & npstat::ArrayND< Numeric, Len, Dim >::cl	(	double	x0,
		double	x1,
		double	x2
	)

inline

Definition at line 5268 of file ArrayND.h.

                                                                                                   {
     if (3U != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::cl: wrong # of args (not rank 3 array)");
     return data_[coordToIndex(i0, 0) * strides_[0] + coordToIndex(i1, 1) * strides_[1] + coordToIndex(i2, 2)];
   }

◆ cl() [8/22]

template<typename Numeric , unsigned Len, unsigned Dim>

const Numeric & npstat::ArrayND< Numeric, Len, Dim >::cl	(	double	x0,
		double	x1,
		double	x2
	)		const

inline

Definition at line 5138 of file ArrayND.h.

                                                                                                               {
     if (3U != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::cl: wrong # of args (not rank 3 array)");
     return data_[coordToIndex(i0, 0) * strides_[0] + coordToIndex(i1, 1) * strides_[1] + coordToIndex(i2, 2)];
   }

◆ cl() [9/22]

template<typename Numeric , unsigned Len, unsigned Dim>

Numeric & npstat::ArrayND< Numeric, Len, Dim >::cl	(	double	x0,
		double	x1,
		double	x2,
		double	x3
	)

inline

Definition at line 5275 of file ArrayND.h.

                                                                                                                    {
     if (4U != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::cl: wrong # of args (not rank 4 array)");
     return data_[coordToIndex(i0, 0) * strides_[0] + coordToIndex(i1, 1) * strides_[1] +
                  coordToIndex(i2, 2) * strides_[2] + coordToIndex(i3, 3)];
   }

◆ cl() [10/22]

template<typename Numeric , unsigned Len, unsigned Dim>

const Numeric & npstat::ArrayND< Numeric, Len, Dim >::cl	(	double	x0,
		double	x1,
		double	x2,
		double	x3
	)		const

inline

Definition at line 5145 of file ArrayND.h.

                                                                               {
     if (4U != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::cl: wrong # of args (not rank 4 array)");
     return data_[coordToIndex(i0, 0) * strides_[0] + coordToIndex(i1, 1) * strides_[1] +
                  coordToIndex(i2, 2) * strides_[2] + coordToIndex(i3, 3)];
   }

◆ cl() [11/22]

template<typename Numeric , unsigned Len, unsigned Dim>

Numeric & npstat::ArrayND< Numeric, Len, Dim >::cl	(	double	x0,
		double	x1,
		double	x2,
		double	x3,
		double	x4
	)

inline

Definition at line 5283 of file ArrayND.h.

                                                                                            {
     if (5U != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::cl: wrong # of args (not rank 5 array)");
     return data_[coordToIndex(i0, 0) * strides_[0] + coordToIndex(i1, 1) * strides_[1] +
                  coordToIndex(i2, 2) * strides_[2] + coordToIndex(i3, 3) * strides_[3] + coordToIndex(i4, 4)];
   }

◆ cl() [12/22]

template<typename Numeric , unsigned Len, unsigned Dim>

const Numeric & npstat::ArrayND< Numeric, Len, Dim >::cl	(	double	x0,
		double	x1,
		double	x2,
		double	x3,
		double	x4
	)		const

inline

Definition at line 5156 of file ArrayND.h.

                                                                                                  {
     if (5U != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::cl: wrong # of args (not rank 5 array)");
     return data_[coordToIndex(i0, 0) * strides_[0] + coordToIndex(i1, 1) * strides_[1] +
                  coordToIndex(i2, 2) * strides_[2] + coordToIndex(i3, 3) * strides_[3] + coordToIndex(i4, 4)];
   }

◆ cl() [13/22]

template<typename Numeric , unsigned Len, unsigned Dim>

Numeric & npstat::ArrayND< Numeric, Len, Dim >::cl	(	double	x0,
		double	x1,
		double	x2,
		double	x3,
		double	x4,
		double	x5
	)

inline

Definition at line 5292 of file ArrayND.h.

                                                                                                             {
     if (6U != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::cl: wrong # of args (not rank 6 array)");
     return data_[coordToIndex(i0, 0) * strides_[0] + coordToIndex(i1, 1) * strides_[1] +
                  coordToIndex(i2, 2) * strides_[2] + coordToIndex(i3, 3) * strides_[3] +
                  coordToIndex(i4, 4) * strides_[4] + coordToIndex(i5, 5)];
   }

◆ cl() [14/22]

template<typename Numeric , unsigned Len, unsigned Dim>

const Numeric & npstat::ArrayND< Numeric, Len, Dim >::cl	(	double	x0,
		double	x1,
		double	x2,
		double	x3,
		double	x4,
		double	x5
	)		const

inline

Definition at line 5165 of file ArrayND.h.

                                                                                                                   {
     if (6U != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::cl: wrong # of args (not rank 6 array)");
     return data_[coordToIndex(i0, 0) * strides_[0] + coordToIndex(i1, 1) * strides_[1] +
                  coordToIndex(i2, 2) * strides_[2] + coordToIndex(i3, 3) * strides_[3] +
                  coordToIndex(i4, 4) * strides_[4] + coordToIndex(i5, 5)];
   }

◆ cl() [15/22]

template<typename Numeric , unsigned Len, unsigned Dim>

Numeric & npstat::ArrayND< Numeric, Len, Dim >::cl	(	double	x0,
		double	x1,
		double	x2,
		double	x3,
		double	x4,
		double	x5,
		double	x6
	)

inline

Definition at line 5302 of file ArrayND.h.

                                                                   {
     if (7U != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::cl: wrong # of args (not rank 7 array)");
     return data_[coordToIndex(i0, 0) * strides_[0] + coordToIndex(i1, 1) * strides_[1] +
                  coordToIndex(i2, 2) * strides_[2] + coordToIndex(i3, 3) * strides_[3] +
                  coordToIndex(i4, 4) * strides_[4] + coordToIndex(i5, 5) * strides_[5] + coordToIndex(i6, 6)];
   }

◆ cl() [16/22]

template<typename Numeric , unsigned Len, unsigned Dim>

const Numeric & npstat::ArrayND< Numeric, Len, Dim >::cl	(	double	x0,
		double	x1,
		double	x2,
		double	x3,
		double	x4,
		double	x5,
		double	x6
	)		const

inline

Definition at line 5175 of file ArrayND.h.

                                                                               {
     if (7U != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::cl: wrong # of args (not rank 7 array)");
     return data_[coordToIndex(i0, 0) * strides_[0] + coordToIndex(i1, 1) * strides_[1] +
                  coordToIndex(i2, 2) * strides_[2] + coordToIndex(i3, 3) * strides_[3] +
                  coordToIndex(i4, 4) * strides_[4] + coordToIndex(i5, 5) * strides_[5] + coordToIndex(i6, 6)];
   }

◆ cl() [17/22]

template<typename Numeric , unsigned Len, unsigned Dim>

Numeric & npstat::ArrayND< Numeric, Len, Dim >::cl	(	double	x0,
		double	x1,
		double	x2,
		double	x3,
		double	x4,
		double	x5,
		double	x6,
		double	x7
	)

inline

Definition at line 5317 of file ArrayND.h.

                                                                   {
     if (8U != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::cl: wrong # of args (not rank 8 array)");
     return data_[coordToIndex(i0, 0) * strides_[0] + coordToIndex(i1, 1) * strides_[1] +
                  coordToIndex(i2, 2) * strides_[2] + coordToIndex(i3, 3) * strides_[3] +
                  coordToIndex(i4, 4) * strides_[4] + coordToIndex(i5, 5) * strides_[5] +
                  coordToIndex(i6, 6) * strides_[6] + coordToIndex(i7, 7)];
   }

◆ cl() [18/22]

template<typename Numeric , unsigned Len, unsigned Dim>

const Numeric & npstat::ArrayND< Numeric, Len, Dim >::cl	(	double	x0,
		double	x1,
		double	x2,
		double	x3,
		double	x4,
		double	x5,
		double	x6,
		double	x7
	)		const

inline

Definition at line 5190 of file ArrayND.h.

                                                                               {
     if (8U != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::cl: wrong # of args (not rank 8 array)");
     return data_[coordToIndex(i0, 0) * strides_[0] + coordToIndex(i1, 1) * strides_[1] +
                  coordToIndex(i2, 2) * strides_[2] + coordToIndex(i3, 3) * strides_[3] +
                  coordToIndex(i4, 4) * strides_[4] + coordToIndex(i5, 5) * strides_[5] +
                  coordToIndex(i6, 6) * strides_[6] + coordToIndex(i7, 7)];
   }

◆ cl() [19/22]

template<typename Numeric , unsigned Len, unsigned Dim>

Numeric & npstat::ArrayND< Numeric, Len, Dim >::cl	(	double	x0,
		double	x1,
		double	x2,
		double	x3,
		double	x4,
		double	x5,
		double	x6,
		double	x7,
		double	x8
	)

inline

Definition at line 5334 of file ArrayND.h.

                                                                   {
     if (9U != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::cl: wrong # of args (not rank 9 array)");
     return data_[coordToIndex(i0, 0) * strides_[0] + coordToIndex(i1, 1) * strides_[1] +
                  coordToIndex(i2, 2) * strides_[2] + coordToIndex(i3, 3) * strides_[3] +
                  coordToIndex(i4, 4) * strides_[4] + coordToIndex(i5, 5) * strides_[5] +
                  coordToIndex(i6, 6) * strides_[6] + coordToIndex(i7, 7) * strides_[7] + coordToIndex(i8, 8)];
   }

◆ cl() [20/22]

template<typename Numeric , unsigned Len, unsigned Dim>

const Numeric & npstat::ArrayND< Numeric, Len, Dim >::cl	(	double	x0,
		double	x1,
		double	x2,
		double	x3,
		double	x4,
		double	x5,
		double	x6,
		double	x7,
		double	x8
	)		const

inline

Definition at line 5207 of file ArrayND.h.

                                                                               {
     if (9U != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::cl: wrong # of args (not rank 9 array)");
     return data_[coordToIndex(i0, 0) * strides_[0] + coordToIndex(i1, 1) * strides_[1] +
                  coordToIndex(i2, 2) * strides_[2] + coordToIndex(i3, 3) * strides_[3] +
                  coordToIndex(i4, 4) * strides_[4] + coordToIndex(i5, 5) * strides_[5] +
                  coordToIndex(i6, 6) * strides_[6] + coordToIndex(i7, 7) * strides_[7] + coordToIndex(i8, 8)];
   }

◆ cl() [21/22]

template<typename Numeric , unsigned Len, unsigned Dim>

Numeric & npstat::ArrayND< Numeric, Len, Dim >::cl	(	double	x0,
		double	x1,
		double	x2,
		double	x3,
		double	x4,
		double	x5,
		double	x6,
		double	x7,
		double	x8,
		double	x9
	)

inline

Definition at line 5352 of file ArrayND.h.

                                                                   {
     if (10U != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::cl: wrong # of args (not rank 10 array)");
     return data_[coordToIndex(i0, 0) * strides_[0] + coordToIndex(i1, 1) * strides_[1] +
                  coordToIndex(i2, 2) * strides_[2] + coordToIndex(i3, 3) * strides_[3] +
                  coordToIndex(i4, 4) * strides_[4] + coordToIndex(i5, 5) * strides_[5] +
                  coordToIndex(i6, 6) * strides_[6] + coordToIndex(i7, 7) * strides_[7] +
                  coordToIndex(i8, 8) * strides_[8] + coordToIndex(i9, 9)];
   }

◆ cl() [22/22]

template<typename Numeric , unsigned Len, unsigned Dim>

const Numeric & npstat::ArrayND< Numeric, Len, Dim >::cl	(	double	x0,
		double	x1,
		double	x2,
		double	x3,
		double	x4,
		double	x5,
		double	x6,
		double	x7,
		double	x8,
		double	x9
	)		const

inline

Definition at line 5225 of file ArrayND.h.

                                                                               {
     if (10U != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::cl: wrong # of args (not rank 10 array)");
     return data_[coordToIndex(i0, 0) * strides_[0] + coordToIndex(i1, 1) * strides_[1] +
                  coordToIndex(i2, 2) * strides_[2] + coordToIndex(i3, 3) * strides_[3] +
                  coordToIndex(i4, 4) * strides_[4] + coordToIndex(i5, 5) * strides_[5] +
                  coordToIndex(i6, 6) * strides_[6] + coordToIndex(i7, 7) * strides_[7] +
                  coordToIndex(i8, 8) * strides_[8] + coordToIndex(i9, 9)];
   }

◆ classId()

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

gs::ClassId npstat::ArrayND< Numeric, StackLen, StackDim >::classId ( ) const

inline

Methods related to "geners" I/O

Definition at line 1039 of file ArrayND.h.

1039 { return gs::ClassId(*this); }

◆ classname()

template<typename Numeric , unsigned StackLen, unsigned StackDim>

const char * npstat::ArrayND< Numeric, StackLen, StackDim >::classname ( )

static

Definition at line 5372 of file ArrayND.h.

                                                               {
     static const std::string name(gs::template_class_name<Numeric>("npstat::ArrayND"));
     return name.c_str();
   }

◆ clear()

template<typename Numeric , unsigned Len, unsigned Dim>

ArrayND< Numeric, Len, Dim > & npstat::ArrayND< Numeric, Len, Dim >::clear ( void )

inline

Zero the array out (every datum becomes Numeric())

Definition at line 4351 of file ArrayND.h.

                                                                        {
     return constFill(Numeric());
   }

◆ closest() [1/2]

template<typename Numeric , unsigned Len, unsigned Dim>

Numeric & npstat::ArrayND< Numeric, Len, Dim >::closest	(	const double *	x,
		unsigned	xDim
	)

inline

Closest value accessor (works as if the array allows access with non-integer indices). For example, the second point in some dimension will be accessed in case the coordinate in that dimension is between 0.5 and 1.5. This function can be used, for example, for implementing simple N-D histogramming or for closest value interpolation and extrapolation.

Definition at line 3173 of file ArrayND.h.

                                                                                          {
     if (!shapeIsKnown_)
       throw npstat::NpstatInvalidArgument("Initialize npstat::ArrayND before calling method \"closest\"");
     if (dim != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::closest: incompatible data length");
     if (dim) {
       assert(x);
       unsigned long idx = 0UL;
       for (unsigned i = 0; i < dim_; ++i)
         idx += coordToIndex(x[i], i) * strides_[i];
       return data_[idx];
     } else
       return localData_[0];
   }

◆ closest() [2/2]

template<typename Numeric , unsigned Len, unsigned Dim>

const Numeric & npstat::ArrayND< Numeric, Len, Dim >::closest	(	const double *	x,
		unsigned	xDim
	)		const

inline

Definition at line 3157 of file ArrayND.h.

                                                                                                      {
     if (!shapeIsKnown_)
       throw npstat::NpstatInvalidArgument("Initialize npstat::ArrayND before calling method \"closest\"");
     if (dim != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::closest: incompatible data length");
     if (dim) {
       assert(x);
       unsigned long idx = 0UL;
       for (unsigned i = 0; i < dim_; ++i)
         idx += coordToIndex(x[i], i) * strides_[i];
       return data_[idx];
     } else
       return localData_[0];
   }

◆ commonSubrangeLoop()

template<typename Numeric , unsigned Len, unsigned Dim>

template<typename Num2 , unsigned Len2, unsigned Dim2, class Functor >

void npstat::ArrayND< Numeric, Len, Dim >::commonSubrangeLoop	(	unsigned	level,
		unsigned long	idx0,
		unsigned long	idx1,
		const unsigned *	thisCorner,
		const unsigned *	range,
		const unsigned *	otherCorner,
		ArrayND< Num2, Len2, Dim2 > &	other,
		Functor	binaryFunct
	)

private

Definition at line 1359 of file ArrayND.h.

                                                                            {
     const unsigned imax = range[level];
 
     if (level == dim_ - 1) {
       Numeric* left = data_ + (idx0 + thisCorner[level]);
       Numeric* const lMax = data_ + (idx0 + shape_[level]);
       Num2* right = r.data_ + (idx1 + otherCorner[level]);
       Num2* const rMax = r.data_ + (idx1 + r.shape_[level]);
 
       for (unsigned i = 0; i < imax && left < lMax && right < rMax; ++i)
         binaryFunct(*left++, *right++);
     } else {
       const unsigned long leftStride = strides_[level];
       const unsigned long leftMax = idx0 + shape_[level] * leftStride;
       idx0 += thisCorner[level] * leftStride;
       const unsigned long rightStride = r.strides_[level];
       const unsigned long rightMax = idx1 + r.shape_[level] * rightStride;
       idx1 += otherCorner[level] * rightStride;
 
       for (unsigned i = 0; i < imax && idx0 < leftMax && idx1 < rightMax; ++i, idx0 += leftStride, idx1 += rightStride)
         commonSubrangeLoop(level + 1, idx0, idx1, thisCorner, range, otherCorner, r, binaryFunct);
     }
   }

◆ constFill()

template<typename Numeric, unsigned Len, unsigned Dim>

ArrayND< Numeric, Len, Dim > & npstat::ArrayND< Numeric, Len, Dim >::constFill ( Numeric c )

This method fills the array data with a constant value

Definition at line 4342 of file ArrayND.h.

Referenced by npstat::HistoND< Numeric, Axis >::setBinsToConst(), and npstat::HistoND< Numeric, Axis >::setOverflowsToConst().

                                                                                    {
     if (!shapeIsKnown_)
       throw npstat::NpstatInvalidArgument("Initialize npstat::ArrayND before calling method \"constFill\"");
     for (unsigned long i = 0; i < len_; ++i)
       data_[i] = c;
     return *this;
   }

◆ contract()

template<typename Numeric , unsigned Len, unsigned Dim>

ArrayND< Numeric, Len, Dim > npstat::ArrayND< Numeric, Len, Dim >::contract	(	unsigned	pos1,
		unsigned	pos2
	)		const

Contraction of a pair of indices. Note that the array length must be the same in both dimensions.

Definition at line 4590 of file ArrayND.h.

                                                                                                                 {
     if (!shapeIsKnown_)
       throw npstat::NpstatInvalidArgument("Initialize npstat::ArrayND before calling method \"contract\"");
     if (!(pos1 < dim_ && pos2 < dim_ && pos1 != pos2))
       throw npstat::NpstatInvalidArgument(
           "In npstat::ArrayND::contract: "
           "incompatible contraction indices");
     if (shape_[pos1] != shape_[pos2])
       throw npstat::NpstatInvalidArgument(
           "In npstat::ArrayND::contract: incompatible "
           "length of contracted dimensions");
 
     // Construct the new shape
     unsigned newshapeBuf[Dim];
     unsigned* newshape = makeBuffer(dim_ - 2, newshapeBuf, Dim);
     unsigned ishap = 0;
     for (unsigned i = 0; i < dim_; ++i)
       if (i != pos1 && i != pos2)
         newshape[ishap++] = shape_[i];
 
     // Form the result array
     ArrayND<Numeric, Len, Dim> result(newshape, ishap);
     if (ishap)
       contractLoop(0, 0, pos1, pos2, 0UL, 0UL, result);
     else {
       // We are just calculating the trace
       Numeric sum = Numeric();
       const unsigned imax = shape_[0];
       const unsigned long stride = strides_[0] + strides_[1];
       for (unsigned i = 0; i < imax; ++i)
         sum += data_[i * stride];
       result() = sum;
     }
 
     destroyBuffer(newshape, newshapeBuf);
     return result;
   }

◆ contractLoop()

template<typename Numeric , unsigned Len, unsigned Dim>

void npstat::ArrayND< Numeric, Len, Dim >::contractLoop	(	unsigned	thisLevel,
		unsigned	resLevel,
		unsigned	pos1,
		unsigned	pos2,
		unsigned long	idxThis,
		unsigned long	idxRes,
		ArrayND< Numeric, StackLen, StackDim > &	result
	)		const

private

Definition at line 4556 of file ArrayND.h.

                                                                        {
     while (thisLevel == pos1 || thisLevel == pos2)
       ++thisLevel;
     assert(thisLevel < dim_);
 
     if (resLevel == result.dim_ - 1) {
       const unsigned ncontract = shape_[pos1];
       const unsigned imax = result.shape_[resLevel];
       const unsigned long stride = strides_[pos1] + strides_[pos2];
       for (unsigned i = 0; i < imax; ++i) {
         const Numeric* tmp = data_ + (idxThis + i * strides_[thisLevel]);
         Numeric sum = Numeric();
         for (unsigned j = 0; j < ncontract; ++j)
           sum += tmp[j * stride];
         result.data_[idxRes + i] = sum;
       }
     } else {
       const unsigned imax = result.shape_[resLevel];
       assert(imax == shape_[thisLevel]);
       for (unsigned i = 0; i < imax; ++i) {
         contractLoop(thisLevel + 1, resLevel + 1, pos1, pos2, idxThis, idxRes, result);
         idxThis += strides_[thisLevel];
         idxRes += result.strides_[resLevel];
       }
     }
   }

◆ convertLinearIndex()

template<typename Numeric , unsigned Len, unsigned Dim>

void npstat::ArrayND< Numeric, Len, Dim >::convertLinearIndex	(	unsigned long	l,
		unsigned *	index,
		unsigned	indexLen
	)		const

Convert linear index into multidimensional index

Definition at line 3048 of file ArrayND.h.

Referenced by npstat::HistoND< Numeric, Axis >::HistoND().

                                                                                                                  {
     if (!shapeIsKnown_)
       throw npstat::NpstatInvalidArgument(
           "Initialize npstat::ArrayND before calling "
           "method \"convertLinearIndex\"");
     if (!dim_)
       throw npstat::NpstatInvalidArgument(
           "npstat::ArrayND::convertLinearIndex method "
           "can not be used with array of 0 rank");
     if (idxLen != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::convertLinearIndex: incompatible index length");
     if (l >= len_)
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::convertLinearIndex: linear index out of range");
     assert(idx);
 
     for (unsigned i = 0; i < dim_; ++i) {
       idx[i] = l / strides_[i];
       l -= (idx[i] * strides_[i]);
     }
   }

◆ convertToLastDimCdf()

template<typename Numeric , unsigned Len, unsigned Dim>

template<typename Accumulator >

void npstat::ArrayND< Numeric, Len, Dim >::convertToLastDimCdf	(	ArrayND< Numeric, StackLen, StackDim > *	sumSlice,
		bool	useTrapezoids
	)

inline

The next function turns the array data into the conditional cumulative density function for the last dimension. "Num2" is the type of accumulator class used. The cdf is stored in such a way that the cdf value of 0 is skipped (the first stored value is the sum which includes the 0th bin). The slice is filled with the sum of values. The "useTrapezoids" parameter specifies whether trapezoidal integration formula should be utilized (rectangular integration is used in case "useTrapezoids" value is "false").

Definition at line 4496 of file ArrayND.h.

                                                                                                          {
     if (!shapeIsKnown_)
       throw npstat::NpstatInvalidArgument(
           "Initialize npstat::ArrayND before calling "
           "method \"convertToLastDimCdf\"");
     if (!dim_)
       throw npstat::NpstatInvalidArgument(
           "npstat::ArrayND::convertToLastDimCdf method "
           "can not be used with array of 0 rank");
     assert(sumSlice);
     if (!sumSlice->shapeIsKnown_)
       throw npstat::NpstatInvalidArgument(
           "In npstat::ArrayND::convertToLastDimCdf: "
           "uninitialized argument array");
     convertToLastDimCdfLoop<Accumulator>(sumSlice, 0U, 0UL, 0UL, useTrapezoids);
   }

◆ convertToLastDimCdfLoop()

template<typename Numeric , unsigned Len, unsigned Dim>

template<typename Accumulator >

void npstat::ArrayND< Numeric, Len, Dim >::convertToLastDimCdfLoop	(	ArrayND< Numeric, StackLen, StackDim > *	sumSlice,
		unsigned	level,
		unsigned long	idx0,
		unsigned long	idxSlice,
		bool	useTrapezoids
	)

private

Definition at line 4457 of file ArrayND.h.

                                                                                                                      {
     static const proper_double half = 0.5;
     const unsigned imax = shape_[level];
     if (level == dim_ - 1) {
       Accumulator acc = Accumulator();
       Numeric* data = data_ + idx0;
       if (useTrapezoids) {
         Numeric oldval = Numeric();
         for (unsigned i = 0; i < imax; ++i) {
           acc += (data[i] + oldval) * half;
           oldval = data[i];
           data[i] = static_cast<Numeric>(acc);
         }
         acc += oldval * half;
       } else
         for (unsigned i = 0; i < imax; ++i) {
           acc += data[i];
           data[i] = static_cast<Numeric>(acc);
         }
       if (sumSlice->dim_)
         sumSlice->data_[idxSlice] = static_cast<Numeric>(acc);
       else
         sumSlice->localData_[0] = static_cast<Numeric>(acc);
     } else {
       const unsigned long stride = strides_[level];
       unsigned long sumStride = 0UL;
       if (sumSlice->dim_)
         sumStride = sumSlice->strides_[level];
       for (unsigned i = 0; i < imax; ++i) {
         convertToLastDimCdfLoop<Accumulator>(sumSlice, level + 1, idx0, idxSlice, useTrapezoids);
         idx0 += stride;
         idxSlice += sumStride;
       }
     }
   }

◆ coordToIndex()

template<typename Numeric , unsigned Len, unsigned Dim>

unsigned npstat::ArrayND< Numeric, Len, Dim >::coordToIndex	(	double	coord,
		unsigned	idim
	)		const

inlineprivate

Definition at line 3147 of file ArrayND.h.

                                                                                                     {
     if (x <= 0.0)
       return 0;
     else if (x >= static_cast<double>(shape_[idim] - 1))
       return shape_[idim] - 1;
     else
       return static_cast<unsigned>(std::floor(x + 0.5));
   }

◆ copyRangeLoopFunct()

template<typename Numeric , unsigned Len, unsigned Dim>

template<typename Num2 , unsigned Len2, unsigned Dim2, class Functor >

void npstat::ArrayND< Numeric, Len, Dim >::copyRangeLoopFunct	(	unsigned	level,
		unsigned long	idx0,
		unsigned long	idx1,
		const ArrayND< Num2, Len2, Dim2 > &	r,
		const ArrayRange &	range,
		Functor	f
	)

private

Definition at line 2565 of file ArrayND.h.

                                                                  {
     const unsigned imax = shape_[level];
     if (level == dim_ - 1) {
       Numeric* to = data_ + idx0;
       const Num2* from = r.data_ + (idx1 + range[level].min());
       for (unsigned i = 0; i < imax; ++i)
         *to++ = static_cast<Numeric>(f(*from++));
     } else {
       const unsigned long fromstride = r.strides_[level];
       const unsigned long tostride = strides_[level];
       idx1 += range[level].min() * fromstride;
       for (unsigned i = 0; i < imax; ++i) {
         copyRangeLoopFunct(level + 1, idx0, idx1, r, range, f);
         idx0 += tostride;
         idx1 += fromstride;
       }
     }
   }

◆ data()

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

const Numeric* npstat::ArrayND< Numeric, StackLen, StackDim >::data ( ) const

inline

Linearized data

Definition at line 236 of file ArrayND.h.

Referenced by npstat::LinInterpolatedTableND< Numeric, Axis >::invert1DResponse(), and npstat::Private::lind_invert1DSlice().

236 { return data_; }

npstat::ArrayND::data_

Numeric * data_

Definition: ArrayND.h:1049

◆ derivative() [1/2]

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

template<typename Num2 >

ArrayND npstat::ArrayND< Numeric, StackLen, StackDim >::derivative ( double scale = 1.0 ) const

Mixed derivative over all directions. Useful for generating densities from distribution functions. The resulting array will have one less point in each dimension. Class Num2 is used as accumulator for calculations. static_cast from Num2 to Numeric must exist. The result is multiplied by the scale factor provided.

◆ derivative() [2/2]

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

template<typename Accumulator >

ArrayND<Numeric, Len, Dim> npstat::ArrayND< Numeric, StackLen, StackDim >::derivative ( const double inscale ) const

Definition at line 4763 of file ArrayND.h.

                                                                                               {
     if (!shapeIsKnown_)
       throw npstat::NpstatInvalidArgument("Initialize npstat::ArrayND before calling method \"derivative\"");
     if (!dim_)
       throw npstat::NpstatInvalidArgument(
           "npstat::ArrayND::derivative method "
           "can not be used with array of 0 rank");
 
     const typename ProperDblFromCmpl<Accumulator>::type scale = inscale;
     const unsigned maxdim = CHAR_BIT * sizeof(unsigned long);
     if (dim_ >= maxdim)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::derivative: array rank is too large");
     const unsigned long maxcycle = 1UL << dim_;
 
     ArrayShape sh;
     sh.reserve(dim_);
     for (unsigned i = 0; i < dim_; ++i) {
       if (shape_[i] <= 1U)
         throw npstat::NpstatInvalidArgument(
             "In npstat::ArrayND::derivative: in some dimendions "
             "array size is too small");
       sh.push_back(shape_[i] - 1U);
     }
 
     ArrayND result(sh);
     const unsigned long rLen = result.length();
     for (unsigned long ilin = 0; ilin < rLen; ++ilin) {
       result.convertLinearIndex(ilin, &sh[0], dim_);
 
       Accumulator deriv = Accumulator();
       for (unsigned long icycle = 0UL; icycle < maxcycle; ++icycle) {
         unsigned long icell = 0UL;
         unsigned n1 = 0U;
         for (unsigned i = 0; i < dim_; ++i) {
           if (icycle & (1UL << i)) {
             ++n1;
             icell += strides_[i] * (sh[i] + 1);
           } else
             icell += strides_[i] * sh[i];
         }
         if ((dim_ - n1) % 2U)
           deriv -= data_[icell];
         else
           deriv += data_[icell];
       }
       result.data_[ilin] = static_cast<Numeric>(deriv * scale);
     }
 
     return result;
   }

◆ dot() [1/2]

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

template<typename Num2 , unsigned Len2, unsigned Dim2>

ArrayND npstat::ArrayND< Numeric, StackLen, StackDim >::dot ( const ArrayND< Num2, Len2, Dim2 > & r ) const

Here, dot product corresponds to outer product followed by the contraction over two indices – the last index of this object and the first index of the argument.

◆ dot() [2/2]

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

template<typename Num2 , unsigned Len2, unsigned Dim2>

ArrayND<Numeric, Len, Dim> npstat::ArrayND< Numeric, StackLen, StackDim >::dot ( const ArrayND< Num2, Len2, Dim2 > & r ) const

Definition at line 5052 of file ArrayND.h.

                                                                                                      {
     if (!dim_)
       throw npstat::NpstatInvalidArgument(
           "npstat::ArrayND::dot method "
           "can not be used with array of 0 rank");
     if (!r.dim_)
       throw npstat::NpstatInvalidArgument(
           "npstat::ArrayND::dot method "
           "can not be used with argument array of 0 rank");
     if (shape_[dim_ - 1] != r.shape_[0])
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::dot: incompatible argument array shape");
 
     if (dim_ == 1 && r.dim_ == 1) {
       // Special case: the result is of 0 rank
       ArrayND<Numeric, Len, Dim> result(static_cast<unsigned*>(nullptr), 0U);
       Numeric sum = Numeric();
       const unsigned imax = shape_[0];
       for (unsigned i = 0; i < imax; ++i)
         sum += data_[i] * r.data_[i];
       result() = sum;
       return result;
     } else {
       unsigned newshapeBuf[2 * Dim];
       unsigned* newshape = makeBuffer(dim_ + r.dim_ - 2, newshapeBuf, 2 * Dim);
       copyBuffer(newshape, shape_, dim_ - 1);
       copyBuffer(newshape + (dim_ - 1), r.shape_ + 1, r.dim_ - 1);
       ArrayND<Numeric, Len, Dim> result(newshape, dim_ + r.dim_ - 2);
 
       dotProductLoop(0U, 0UL, 0UL, 0UL, r, result);
 
       destroyBuffer(newshape, newshapeBuf);
       return result;
     }
   }

◆ dotProductLoop()

template<typename Numeric , unsigned Len, unsigned Dim>

template<typename Num2 , unsigned Len2, unsigned Dim2>

void npstat::ArrayND< Numeric, Len, Dim >::dotProductLoop	(	unsigned	level,
		unsigned long	idx0,
		unsigned long	idx1,
		unsigned long	idx2,
		const ArrayND< Num2, Len2, Dim2 > &	r,
		ArrayND< Numeric, StackLen, StackDim > &	result
	)		const

private

Definition at line 5019 of file ArrayND.h.

                                                                          {
     // idx0 -- this object
     // idx1 -- dot product argument
     // idx2 -- result
     if (level == result.dim_) {
       Numeric sum = Numeric();
       const unsigned imax = r.shape_[0];
       const unsigned rstride = r.strides_[0];
       const Numeric* l = data_ + idx0;
       const Num2* ri = r.data_ + idx1;
       for (unsigned i = 0; i < imax; ++i)
         sum += l[i] * ri[i * rstride];
       result.data_[idx2] = sum;
     } else {
       const unsigned imax = result.shape_[level];
       for (unsigned i = 0; i < imax; ++i) {
         dotProductLoop(level + 1, idx0, idx1, idx2, r, result);
         idx2 += result.strides_[level];
         if (level < dim_ - 1)
           idx0 += strides_[level];
         else
           idx1 += r.strides_[level + 2 - dim_];
       }
     }
   }

◆ dualCircularLoop()

template<typename Numeric , unsigned Len, unsigned Dim>

template<typename Num2 , unsigned Len2, unsigned Dim2, class Functor >

void npstat::ArrayND< Numeric, Len, Dim >::dualCircularLoop	(	unsigned	level,
		unsigned long	idx0,
		unsigned long	idx1,
		const unsigned *	thisCorner,
		const unsigned *	range,
		const unsigned *	otherCorner,
		ArrayND< Num2, Len2, Dim2 > &	other,
		Functor	binaryFunct
	)

private

Definition at line 1392 of file ArrayND.h.

                                                                          {
     const unsigned imax = range[level];
     const unsigned leftShift = thisCorner[level];
     const unsigned leftPeriod = shape_[level];
     const unsigned rightShift = otherCorner[level];
     const unsigned rightPeriod = r.shape_[level];
 
     if (level == dim_ - 1) {
       Numeric* left = data_ + idx0;
       Num2* right = r.data_ + idx1;
       for (unsigned i = 0; i < imax; ++i)
         binaryFunct(left[(i + leftShift) % leftPeriod], right[(i + rightShift) % rightPeriod]);
     } else {
       const unsigned long leftStride = strides_[level];
       const unsigned long rightStride = r.strides_[level];
       for (unsigned i = 0; i < imax; ++i)
         dualCircularLoop(level + 1,
                          idx0 + ((i + leftShift) % leftPeriod) * leftStride,
                          idx1 + ((i + rightShift) % rightPeriod) * rightStride,
                          thisCorner,
                          range,
                          otherCorner,
                          r,
                          binaryFunct);
     }
   }

◆ dualCircularScan()

template<typename Numeric , unsigned Len, unsigned Dim>

template<typename Num2 , unsigned Len2, unsigned Dim2, class Functor >

void npstat::ArrayND< Numeric, Len, Dim >::dualCircularScan	(	ArrayND< Num2, Len2, Dim2 > &	other,
		const unsigned *	thisCorner,
		const unsigned *	range,
		const unsigned *	otherCorner,
		unsigned	arrLen,
		Functor	binaryFunct
	)

Method similar to "jointSubrangeScan" in which the topology of both arrays is assumed to be hypertoroidal (circular buffer in every dimension)

Definition at line 1505 of file ArrayND.h.

◆ exportMemSlice()

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

template<typename Num2 >

void npstat::ArrayND< Numeric, StackLen, StackDim >::exportMemSlice	(	Num2 *	buffer,
		unsigned long	bufLen,
		const unsigned *	fixedIndices,
		const unsigned *	fixedIndexValues,
		unsigned	nFixedIndices
	)		const

inline

Convenience method for exporting a slice of this array into a memory buffer

Definition at line 710 of file ArrayND.h.

                                                              {
       (const_cast<ArrayND*>(this))
           ->jointMemSliceScan(
               buffer, bufLen, fixedIndices, fixedIndexValues, nFixedIndices, scast_assign_right<Numeric, Num2>());
     }

◆ exportSlice()

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

template<typename Num2 , unsigned Len2, unsigned Dim2>

void npstat::ArrayND< Numeric, StackLen, StackDim >::exportSlice	(	ArrayND< Num2, Len2, Dim2 > *	slice,
		const unsigned *	fixedIndices,
		const unsigned *	fixedIndexValues,
		unsigned	nFixedIndices
	)		const

inline

Convenience method for exporting a slice of this array

Definition at line 696 of file ArrayND.h.

                                                           {
       assert(slice);
       (const_cast<ArrayND*>(this))
           ->jointSliceScan(*slice, fixedIndices, fixedIndexValues, nFixedIndices, scast_assign_right<Numeric, Num2>());
     }

◆ exportSubrange()

template<typename Numeric , unsigned Len, unsigned StackDim>

template<typename Num2 , unsigned Len2, unsigned Dim2>

void npstat::ArrayND< Numeric, Len, StackDim >::exportSubrange	(	const unsigned *	fromCorner,
		unsigned	lenCorner,
		ArrayND< Num2, Len2, Dim2 > *	dest
	)		const

Copy a hyperrectangular subrange of this array potentially completely overwriting the destination array. The starting corner in this object where copying begins is provided by the first two arguments. The subrange size is defined by the shape of the destination array.

Definition at line 5418 of file ArrayND.h.

                                                                                              {
     if (!shapeIsKnown_)
       throw npstat::NpstatInvalidArgument("Initialize npstat::ArrayND before calling method \"exportSubrange\"");
     if (dim_ != lenCorner)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::exportSubrange: incompatible corner index length");
     assert(out);
     if (!out->shapeIsKnown_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::exportSubrange: uninitialized argument array");
     if (out->dim_ != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::exportSubrange: incompatible argument array rank");
 
     if (dim_) {
       assert(corner);
       if (dim_ > CHAR_BIT * sizeof(unsigned long))
         throw npstat::NpstatInvalidArgument(
             "In npstat::ArrayND::exportSubrange: "
             "array rank is too large");
       unsigned toBuf[CHAR_BIT * sizeof(unsigned long)];
       clearBuffer(toBuf, dim_);
       (const_cast<ArrayND*>(this))
           ->commonSubrangeLoop(0U, 0UL, 0UL, corner, out->shape_, toBuf, *out, scast_assign_right<Numeric, Num2>());
     } else
       out->localData_[0] = static_cast<Num2>(localData_[0]);
   }

◆ flatCircularLoop()

template<typename Numeric , unsigned Len, unsigned Dim>

template<typename Num2 , unsigned Len2, unsigned Dim2, class Functor >

void npstat::ArrayND< Numeric, Len, Dim >::flatCircularLoop	(	unsigned	level,
		unsigned long	idx0,
		unsigned long	idx1,
		const unsigned *	thisCorner,
		const unsigned *	range,
		const unsigned *	otherCorner,
		ArrayND< Num2, Len2, Dim2 > &	other,
		Functor	binaryFunct
	)

private

Definition at line 1428 of file ArrayND.h.

                                                                          {
     const unsigned imax = range[level];
     const unsigned rightShift = otherCorner[level];
     const unsigned rightPeriod = r.shape_[level];
 
     if (level == dim_ - 1) {
       Numeric* left = data_ + (idx0 + thisCorner[level]);
       Numeric* const lMax = data_ + (idx0 + shape_[level]);
       Num2* right = r.data_ + idx1;
 
       for (unsigned i = 0; i < imax && left < lMax; ++i)
         binaryFunct(*left++, right[(i + rightShift) % rightPeriod]);
     } else {
       const unsigned long leftStride = strides_[level];
       const unsigned long leftMax = idx0 + shape_[level] * leftStride;
       idx0 += thisCorner[level] * leftStride;
       const unsigned long rightStride = r.strides_[level];
 
       for (unsigned i = 0; i < imax && idx0 < leftMax; ++i, idx0 += leftStride)
         flatCircularLoop(level + 1,
                          idx0,
                          idx1 + ((i + rightShift) % rightPeriod) * rightStride,
                          thisCorner,
                          range,
                          otherCorner,
                          r,
                          binaryFunct);
     }
   }

◆ flatCircularScan()

template<typename Numeric , unsigned Len, unsigned Dim>

template<typename Num2 , unsigned Len2, unsigned Dim2, class Functor >

void npstat::ArrayND< Numeric, Len, Dim >::flatCircularScan	(	ArrayND< Num2, Len2, Dim2 > &	other,
		const unsigned *	thisCorner,
		const unsigned *	range,
		const unsigned *	otherCorner,
		unsigned	arrLen,
		Functor	binaryFunct
	)

Method similar to "jointSubrangeScan" in which the topology of this array is assumed to be flat and the other array hypertoroidal

Definition at line 1507 of file ArrayND.h.

◆ fullRange()

template<typename Numeric , unsigned Len, unsigned Dim>

ArrayRange npstat::ArrayND< Numeric, Len, Dim >::fullRange ( ) const

inline

Get the complete range

Definition at line 2996 of file ArrayND.h.

                                                                 {
     if (!shapeIsKnown_)
       throw npstat::NpstatInvalidArgument("Initialize npstat::ArrayND before calling method \"fullRange\"");
     ArrayRange range;
     if (dim_) {
       range.reserve(dim_);
       for (unsigned i = 0; i < dim_; ++i)
         range.push_back(Interval<unsigned>(0U, shape_[i]));
     }
     return range;
   }

◆ functorFill() [1/2]

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

template<class Functor >

ArrayND& npstat::ArrayND< Numeric, StackLen, StackDim >::functorFill ( Functor f )

This method fills the array from a functor which takes (const unsigned* index, unsigned indexLen) arguments. There must be a conversion (static cast) from the functor result to the "Numeric" type.

◆ functorFill() [2/2]

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

template<class Functor >

ArrayND<Numeric, Len, Dim>& npstat::ArrayND< Numeric, StackLen, StackDim >::functorFill ( Functor f )

Definition at line 4515 of file ArrayND.h.

                                                                                {
     if (!shapeIsKnown_)
       throw npstat::NpstatInvalidArgument("Initialize npstat::ArrayND before calling method \"functorFill\"");
     if (dim_) {
       unsigned localIndex[Dim];
       unsigned* index = makeBuffer(dim_, localIndex, Dim);
       functorFillLoop(0U, 0UL, f, index);
       destroyBuffer(index, localIndex);
     } else
       localData_[0] = static_cast<Numeric>(f(static_cast<unsigned*>(nullptr), 0U));
     return *this;
   }

◆ functorFillLoop()

template<typename Numeric , unsigned Len, unsigned Dim>

template<class Functor >

void npstat::ArrayND< Numeric, Len, Dim >::functorFillLoop	(	unsigned	level,
		unsigned long	idx,
		Functor	f,
		unsigned *	farg
	)

private

Definition at line 4434 of file ArrayND.h.

                                                                    {
     const unsigned imax = shape_[level];
     if (level == dim_ - 1) {
       Numeric* d = &data_[idx];
       const unsigned* myarg = farg;
       for (unsigned i = 0; i < imax; ++i) {
         farg[level] = i;
         d[i] = static_cast<Numeric>(f(myarg, dim_));
       }
     } else {
       const unsigned long stride = strides_[level];
       for (unsigned i = 0; i < imax; ++i) {
         farg[level] = i;
         functorFillLoop(level + 1, idx + i * stride, f, farg);
       }
     }
   }

◆ importMemSlice()

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

template<typename Num2 >

void npstat::ArrayND< Numeric, StackLen, StackDim >::importMemSlice	(	const Num2 *	buffer,
		unsigned long	bufLen,
		const unsigned *	fixedIndices,
		const unsigned *	fixedIndexValues,
		unsigned	nFixedIndices
	)

inline

Convenience method for importing a slice into this array from a memory buffer

Definition at line 738 of file ArrayND.h.

                                                        {
       jointMemSliceScan(const_cast<Num2*>(buffer),
                         bufLen,
                         fixedIndices,
                         fixedIndexValues,
                         nFixedIndices,
                         scast_assign_left<Numeric, Num2>());
     }

◆ importSlice()

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

template<typename Num2 , unsigned Len2, unsigned Dim2>

void npstat::ArrayND< Numeric, StackLen, StackDim >::importSlice	(	const ArrayND< Num2, Len2, Dim2 > &	slice,
		const unsigned *	fixedIndices,
		const unsigned *	fixedIndexValues,
		unsigned	nFixedIndices
	)

inline

Convenience method for importing a slice into this array

Definition at line 722 of file ArrayND.h.

                                                     {
       jointSliceScan(const_cast<ArrayND<Num2, Len2, Dim2>&>(slice),
                      fixedIndices,
                      fixedIndexValues,
                      nFixedIndices,
                      scast_assign_left<Numeric, Num2>());
     }

◆ importSubrange()

template<typename Numeric , unsigned Len, unsigned StackDim>

template<typename Num2 , unsigned Len2, unsigned Dim2>

void npstat::ArrayND< Numeric, Len, StackDim >::importSubrange	(	const unsigned *	fromCorner,
		unsigned	lenCorner,
		const ArrayND< Num2, Len2, Dim2 > &	from
	)

The inverse operation to "exportSubrange"

Definition at line 5447 of file ArrayND.h.

                                                                                               {
     if (!shapeIsKnown_)
       throw npstat::NpstatInvalidArgument("Initialize npstat::ArrayND before calling method \"importSubrange\"");
     if (dim_ != lenCorner)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::importSubrange: incompatible corner index length");
     if (!from.shapeIsKnown_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::importSubrange: uninitialized argument array");
     if (from.dim_ != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::importSubrange: incompatible argument array rank");
 
     if (dim_) {
       assert(corner);
       if (dim_ > CHAR_BIT * sizeof(unsigned long))
         throw npstat::NpstatInvalidArgument(
             "In npstat::ArrayND::importSubrange: "
             "array rank is too large");
       unsigned toBuf[CHAR_BIT * sizeof(unsigned long)];
       clearBuffer(toBuf, dim_);
       commonSubrangeLoop(0U,
                          0UL,
                          0UL,
                          corner,
                          from.shape_,
                          toBuf,
                          const_cast<ArrayND<Num2, Len2, Dim2>&>(from),
                          scast_assign_left<Numeric, Num2>());
     } else
       localData_[0] = static_cast<Numeric>(from.localData_[0]);
   }

◆ inPlaceMul()

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

template<typename Num2 , unsigned Len2, unsigned Dim2>

ArrayND& npstat::ArrayND< Numeric, StackLen, StackDim >::inPlaceMul ( const ArrayND< Num2, Len2, Dim2 > & r )

inline

Convenience method for element-by-element in-place multiplication

Definition at line 551 of file ArrayND.h.

                                                                    {
       jointScan(const_cast<ArrayND<Num2, Len2, Dim2>&>(r), multeq_left<Numeric, Num2>());
       return *this;
     }

◆ interpolate1()

template<typename Numeric , unsigned Len, unsigned Dim>

Numeric npstat::ArrayND< Numeric, Len, Dim >::interpolate1	(	const double *	x,
		unsigned	xDim
	)		const

Multilinear interpolation. Closest value extrapolation is used in case some index is outside of the array bounds. Note that this function works only if the array dimensionality is less than CHAR_BIT*sizeof(unsigned long). x is the "coordinate" which coincides with array index for x equal to unsigned integers.

Definition at line 4211 of file ArrayND.h.

                                                                                                  {
     if (!shapeIsKnown_)
       throw npstat::NpstatInvalidArgument("Initialize npstat::ArrayND before calling method \"interpolate1\"");
     if (dim != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::interpolate1: incompatible coordinate length");
     if (dim) {
       const unsigned maxdim = CHAR_BIT * sizeof(unsigned long);
       if (dim_ >= maxdim)
         throw npstat::NpstatInvalidArgument("In npstat::ArrayND::interpolate1: array rank is too large");
 
       double dx[maxdim];
       unsigned ix[maxdim];
       for (unsigned i = 0; i < dim; ++i) {
         const double x = coords[i];
         if (x <= 0.0) {
           ix[i] = 0;
           dx[i] = 0.0;
         } else if (x >= static_cast<double>(shape_[i] - 1)) {
           ix[i] = shape_[i] - 1;
           dx[i] = 0.0;
         } else {
           ix[i] = static_cast<unsigned>(std::floor(x));
           dx[i] = x - ix[i];
         }
       }
 
       Numeric sum = Numeric();
       const unsigned long maxcycle = 1UL << dim;
       for (unsigned long icycle = 0UL; icycle < maxcycle; ++icycle) {
         double w = 1.0;
         unsigned long icell = 0UL;
         for (unsigned i = 0; i < dim; ++i) {
           if (icycle & (1UL << i)) {
             w *= dx[i];
             icell += strides_[i] * (ix[i] + 1U);
           } else {
             w *= (1.0 - dx[i]);
             icell += strides_[i] * ix[i];
           }
         }
         if (w > 0.0)
           sum += data_[icell] * static_cast<proper_double>(w);
       }
       return sum;
     } else
       return localData_[0];
   }

◆ interpolate3()

template<typename Numeric , unsigned Len, unsigned Dim>

Numeric npstat::ArrayND< Numeric, Len, Dim >::interpolate3	(	const double *	x,
		unsigned	xDim
	)		const

inline

Multicubic interpolation. Closest value extrapolation is used in case some index is outside of the array bounds. This function is much slower than "interpolate1" (in the current implementation, a recursive algorithm is used).

Definition at line 4309 of file ArrayND.h.

                                                                                                         {
     if (!shapeIsKnown_)
       throw npstat::NpstatInvalidArgument("Initialize npstat::ArrayND before calling method \"interpolate3\"");
     if (dim != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::interpolate3: incompatible coordinate length");
     if (dim) {
       assert(coords);
       return interpolateLoop(0, coords, data_);
     } else
       return localData_[0];
   }

◆ interpolateLoop()

template<typename Numeric, unsigned Len, unsigned Dim>

Numeric npstat::ArrayND< Numeric, Len, Dim >::interpolateLoop	(	unsigned	level,
		const double *	x,
		const Numeric *	base
	)		const

private

Definition at line 4260 of file ArrayND.h.

                                                                                  {
     const unsigned npoints = shape_[level];
     const double x = coords[level];
 
     unsigned ix, npt = 1;
     double dx = 0.0;
     if (x < 0.0)
       ix = 0;
     else if (x > static_cast<double>(npoints - 1))
       ix = npoints - 1;
     else {
       ix = static_cast<unsigned>(std::floor(x));
       if (ix)
         --ix;
       unsigned imax = ix + 3;
       while (imax >= npoints) {
         if (ix)
           --ix;
         --imax;
       }
       dx = x - ix;
       npt = imax + 1 - ix;
     }
     assert(npt >= 1 && npt <= 4);
 
     Numeric fit[4];
     if (level < dim_ - 1)
       for (unsigned ipt = 0; ipt < npt; ++ipt)
         fit[ipt] = interpolateLoop(level + 1, coords, base + (ix + ipt) * strides_[level]);
 
     const Numeric* const v = (level == dim_ - 1 ? base + ix : fit);
     switch (npt) {
       case 1:
         return v[0];
       case 2:
         return interpolate_linear(dx, v[0], v[1]);
       case 3:
         return interpolate_quadratic(dx, v[0], v[1], v[2]);
       case 4:
         return interpolate_cubic(dx, v[0], v[1], v[2], v[3]);
       default:
         assert(0);
         return Numeric();
     }
   }

◆ isClose()

template<typename Numeric , unsigned Len, unsigned Dim>

template<typename Num2 , unsigned Len2, unsigned Dim2>

bool npstat::ArrayND< Numeric, Len, Dim >::isClose	(	const ArrayND< Num2, Len2, Dim2 > &	r,
		double	eps
	)		const

Check that all elements of this array differ from the corresponding elements of another array by at most "eps". Equivalent to maxAbsDifference(r) <= eps (but usually faster).

Definition at line 4530 of file ArrayND.h.

                                                                                                      {
     if (eps < 0.0)
       throw npstat::NpstatDomainError("In npstat::ArrayND::isClose: tolerance must not be negative");
     if (!isShapeCompatible(r))
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::isClose: incompatible argument array shape");
     if (dim_) {
       for (unsigned long i = 0; i < len_; ++i) {
         const Numeric rval = r.data_[i];
         if (static_cast<double>(absDifference(data_[i], rval)) > eps)
           return false;
       }
     } else {
       const Numeric rval = r.localData_[0];
       if (static_cast<double>(absDifference(localData_[0], rval)) > eps)
         return false;
     }
     return true;
   }

◆ isCompatible()

template<typename Numeric , unsigned StackLen, unsigned StackDim>

bool npstat::ArrayND< Numeric, StackLen, StackDim >::isCompatible ( const ArrayShape & shape ) const

inline

Check compatibility with another shape

Definition at line 2370 of file ArrayND.h.

                                                                                               {
     if (!shapeIsKnown_)
       return false;
     if (dim_ != shape.size())
       return false;
     if (dim_) {
       for (unsigned i = 0; i < dim_; ++i)
         if (shape_[i] != shape[i])
           return false;
     } else
       assert(len_ == 1UL);
     return true;
   }

◆ isDensity()

template<typename Numeric , unsigned Len, unsigned Dim>

bool npstat::ArrayND< Numeric, Len, Dim >::isDensity ( ) const

This method checks whether all array elements are non-negative and, in addition, there is at least one positive element

Definition at line 3009 of file ArrayND.h.

                                                    {
     if (!shapeIsKnown_)
       throw npstat::NpstatInvalidArgument("Initialize npstat::ArrayND before calling method \"isDensity\"");
     const Numeric zero = Numeric();
     bool hasPositive = false;
     if (dim_)
       for (unsigned long i = 0; i < len_; ++i) {
         // Don't make comparisons whose result can be
         // determined in advance by assuming that Numeric
         // is an unsigned type. Some compilers will
         // complain about it when this template is
         // instantiated with such a type.
         if (data_[i] == zero)
           continue;
         if (ComplexComparesFalse<Numeric>::less(zero, data_[i]))
           hasPositive = true;
         else
           return false;
       }
     else
       hasPositive = ComplexComparesFalse<Numeric>::less(zero, localData_[0]);
     return hasPositive;
   }

◆ isShapeCompatible()

template<typename Numeric , unsigned StackLen, unsigned StackDim>

template<typename Num2 , unsigned Len2, unsigned Dim2>

bool npstat::ArrayND< Numeric, StackLen, StackDim >::isShapeCompatible ( const ArrayND< Num2, Len2, Dim2 > & r ) const

inline

Check shape compatibility with another array. Equivalent to but faster than isCompatible(r.shape()).

Definition at line 2386 of file ArrayND.h.

                                                                                                               {
     if (!shapeIsKnown_)
       return false;
     if (!r.shapeIsKnown_)
       return false;
     if (dim_ != r.dim_)
       return false;
     if (len_ != r.len_)
       return false;
     if (dim_) {
       assert(shape_);
       assert(r.shape_);
       for (unsigned i = 0; i < dim_; ++i)
         if (shape_[i] != r.shape_[i])
           return false;
     } else
       assert(len_ == 1UL);
     return true;
   }

◆ isShapeKnown()

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

bool npstat::ArrayND< Numeric, StackLen, StackDim >::isShapeKnown ( ) const

inline

Check whether the array has been initialized

Definition at line 239 of file ArrayND.h.

239 { return shapeIsKnown_; }

npstat::ArrayND::shapeIsKnown_

bool shapeIsKnown_

Definition: ArrayND.h:1060

◆ isZero()

template<typename Numeric , unsigned Len, unsigned Dim>

bool npstat::ArrayND< Numeric, Len, Dim >::isZero ( ) const

Check if all array elements are zero

Definition at line 3034 of file ArrayND.h.

                                                 {
     if (!shapeIsKnown_)
       throw npstat::NpstatInvalidArgument("Initialize npstat::ArrayND before calling method \"isZero\"");
     const Numeric zero = Numeric();
     if (dim_) {
       for (unsigned long i = 0; i < len_; ++i)
         if (data_[i] != zero)
           return false;
     } else if (localData_[0] != zero)
       return false;
     return true;
   }

◆ jointMemSliceScan()

template<typename Numeric , unsigned StackLen, unsigned StackDim>

template<typename Num2 , class Functor >

void npstat::ArrayND< Numeric, StackLen, StackDim >::jointMemSliceScan	(	Num2 *	buffer,
		unsigned long	bufLen,
		const unsigned *	fixedIndices,
		const unsigned *	fixedIndexValues,
		unsigned	nFixedIndices,
		Functor	binaryFunct
	)

Joint cycle over a slice this array and some memory buffer. The length of the buffer must be equal to the length of the slice, as in "jointSliceScan". This method is to be used for import/export of slice data and in-place operations (addition, multiplication, etc) with memory managed not by ArrayND but in some other manner.

Definition at line 1948 of file ArrayND.h.

Referenced by npstat::ArrayND< Numeric >::importMemSlice().

                                                                                     {
     assert(slice);
     if (dim_ > CHAR_BIT * sizeof(unsigned long))
       throw npstat::NpstatInvalidArgument(
           "In npstat::ArrayND::jointMemSliceScan: "
           "rank of this array is too large");
     unsigned long sliceStrides[CHAR_BIT * sizeof(unsigned long)];
     const unsigned long idx =
         verifyBufferSliceCompatibility(len, fixedIndices, fixedIndexValues, nFixedIndices, sliceStrides);
     if (dim_ > nFixedIndices)
       jointSliceLoop(0U, idx, 0U, 0UL, slice, sliceStrides, fixedIndices, fixedIndexValues, nFixedIndices, binaryFunct);
     else
       binaryFunct(data_[idx], *slice);
   }

◆ jointScan()

template<typename Numeric , unsigned StackLen, unsigned StackDim>

template<typename Num2 , unsigned Len2, unsigned Dim2, class Functor >

void npstat::ArrayND< Numeric, StackLen, StackDim >::jointScan	(	ArrayND< Num2, Len2, Dim2 > &	other,
		Functor	binaryFunct
	)

Loop over all elements of two compatible arrays and apply a binary functor

Definition at line 2342 of file ArrayND.h.

Referenced by npstat::ArrayND< Numeric >::inPlaceMul().

                                                                                                         {
     if (!isShapeCompatible(r))
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::jointScan: incompatible argument array shape");
     if (dim_)
       for (unsigned long i = 0; i < len_; ++i)
         binaryFunct(data_[i], r.data_[i]);
     else
       binaryFunct(localData_[0], r.localData_[0]);
   }

◆ jointSliceLoop() [1/2]

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

template<typename Num2 , class Functor >

void npstat::ArrayND< Numeric, StackLen, StackDim >::jointSliceLoop	(	unsigned	level,
		unsigned long	idx0,
		unsigned	level1,
		unsigned long	idx1,
		Num2 *	sliceData,
		const unsigned long *	sliceStrides,
		const unsigned *	fixedIndices,
		const unsigned *	fixedIndexValues,
		unsigned	nFixedIndices,
		Functor	binaryFunctor
	)

private

◆ jointSliceLoop() [2/2]

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

template<typename Num2 , class Op >

void npstat::ArrayND< Numeric, StackLen, StackDim >::jointSliceLoop	(	const unsigned	level,
		const unsigned long	idx0,
		const unsigned	level1,
		const unsigned long	idx1,
		Num2 *	sliceData,
		const unsigned long *	sliceStrides,
		const unsigned *	fixedIndices,
		const unsigned *	fixedIndexValues,
		const unsigned	nFixedIndices,
		Op	fcn
	)

Definition at line 1886 of file ArrayND.h.

                                                                     {
     bool fixed = false;
     for (unsigned j = 0; j < nFixedIndices; ++j)
       if (fixedIndices[j] == level) {
         fixed = true;
         break;
       }
     if (fixed)
       jointSliceLoop(
           level + 1, idx0, level1, idx1, sliceData, sliceStrides, fixedIndices, fixedIndexValues, nFixedIndices, fcn);
     else {
       const unsigned imax = shape_[level];
       const unsigned long stride = strides_[level];
 
       if (level1 == dim_ - nFixedIndices - 1) {
         sliceData += idx1;
         Numeric* localData = data_ + idx0;
         for (unsigned i = 0; i < imax; ++i)
           fcn(localData[i * stride], sliceData[i]);
       } else {
         const unsigned long stride2 = sliceStrides[level1];
         for (unsigned i = 0; i < imax; ++i)
           jointSliceLoop(level + 1,
                          idx0 + i * stride,
                          level1 + 1,
                          idx1 + i * stride2,
                          sliceData,
                          sliceStrides,
                          fixedIndices,
                          fixedIndexValues,
                          nFixedIndices,
                          fcn);
       }
     }
   }

◆ jointSliceScan()

template<typename Numeric , unsigned StackLen, unsigned StackDim>

template<typename Num2 , unsigned Len2, unsigned Dim2, class Functor >

void npstat::ArrayND< Numeric, StackLen, StackDim >::jointSliceScan	(	ArrayND< Num2, Len2, Dim2 > &	slice,
		const unsigned *	fixedIndices,
		const unsigned *	fixedIndexValues,
		unsigned	nFixedIndices,
		Functor	binaryFunct
	)

Joint cycle over the data of this array and the slice. The array to which the "slice" argument refers should normally be created by the slicing constructor using this array as the argument. The "fixedIndices" argument should be the same as the "indices" argument in that constructor. This method is to be used for import/export of slice data and in-place operations (addition, multiplication, etc).

Definition at line 1933 of file ArrayND.h.

Referenced by npstat::ArrayND< Numeric >::importSlice().

                                                                                  {
     const unsigned long idx = verifySliceCompatibility(slice, fixedIndices, fixedIndexValues, nFixedIndices);
     if (slice.dim_)
       jointSliceLoop(
           0U, idx, 0U, 0UL, slice.data_, slice.strides_, fixedIndices, fixedIndexValues, nFixedIndices, binaryFunct);
     else
       binaryFunct(data_[idx], slice.localData_[0]);
   }

◆ jointSubrangeScan()

template<typename Numeric , unsigned Len, unsigned Dim>

template<typename Num2 , unsigned Len2, unsigned Dim2, class Functor >

void npstat::ArrayND< Numeric, Len, Dim >::jointSubrangeScan	(	ArrayND< Num2, Len2, Dim2 > &	other,
		const unsigned *	thisCorner,
		const unsigned *	range,
		const unsigned *	otherCorner,
		unsigned	arrLen,
		Functor	binaryFunct
	)

Loop over subranges in two arrays in such a way that the functor is called only if the indices on both sides are valid. The topology of both arrays is assumed to be box-like (flat). The starting corner in this object (where cycling begins) is provided by the argument "thisCorner". The "range" argument specifies the width of the processed patch in each dimension. The corner of the "other" array where cycling begins is provided by the "otherCorner" argument. The "arrLen" argument specifies the number of elements in "thisCorner", "range", and "otherCorner" arrays. It should be equal to the rank of either of the two ArrayND arrays.

Note that there is no good way for this method to assume constness of this or "other" array: this becomes apparent only after the functor has been specified. Apply const_cast judiciously as needed, other solutions of this problem are not any better.

Definition at line 1504 of file ArrayND.h.

◆ length()

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

unsigned long npstat::ArrayND< Numeric, StackLen, StackDim >::length ( ) const

inline

Total number of data array elements

Definition at line 233 of file ArrayND.h.

Referenced by npstat::HistoND< Numeric, Axis >::HistoND(), npstat::LinInterpolatedTableND< Numeric, Axis >::invert1DResponse(), npstat::LinInterpolatedTableND< Numeric, Axis >::length(), npstat::Private::lind_invert1DSlice(), and npstat::HistoND< Numeric, Axis >::nBins().

233 { return len_; }

npstat::ArrayND::len_

unsigned long len_

Definition: ArrayND.h:1057

◆ linearFill()

template<typename Numeric , unsigned Len, unsigned Dim>

ArrayND< Numeric, Len, Dim > & npstat::ArrayND< Numeric, Len, Dim >::linearFill	(	const double *	coeff,
		unsigned	coeffLen,
		double	c
	)

This method fills the array with a linear combination of the index values. For example, a 2-d array element with indices i, k will be set to (coeff[0]*i + coeff[1]*k + c). There must be a conversion (static cast) from double into "Numeric".

Definition at line 4416 of file ArrayND.h.

                                                                                          {
     // Make sure the object has been initialized
     if (!shapeIsKnown_)
       throw npstat::NpstatInvalidArgument("Initialize npstat::ArrayND before calling method \"linearFill\"");
     if (dim_ != dimCoeffs)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::linearFill: incompatible number of coefficients");
     if (dim_) {
       assert(coeffs);
       linearFillLoop(0U, 0.0, 0UL, shift, coeffs);
     } else
       localData_[0] = static_cast<Numeric>(shift);
     return *this;
   }

◆ linearFillLoop()

template<typename Numeric , unsigned Len, unsigned Dim>

void npstat::ArrayND< Numeric, Len, Dim >::linearFillLoop	(	unsigned	level,
		double	s0,
		unsigned long	idx,
		double	shift,
		const double *	coeffs
	)

private

Definition at line 4395 of file ArrayND.h.

                                                                                                                 {
     const unsigned imax = shape_[level];
     const double c = coeffs[level];
     if (level == dim_ - 1) {
       Numeric* d = &data_[idx];
       for (unsigned i = 0; i < imax; ++i) {
         // Note that we want to add "shift" only at the
         // very end. This might improve the numerical
         // precision of the result.
         const double sum = s0 + c * i + shift;
         d[i] = static_cast<Numeric>(sum);
       }
     } else {
       const unsigned long stride = strides_[level];
       for (unsigned i = 0; i < imax; ++i)
         linearFillLoop(level + 1, s0 + c * i, idx + i * stride, shift, coeffs);
     }
   }

◆ linearIndex()

template<typename Numeric , unsigned Len, unsigned Dim>

unsigned long npstat::ArrayND< Numeric, Len, Dim >::linearIndex	(	const unsigned *	idx,
		unsigned	idxLen
	)		const

Convert multidimensional index into linear index

Definition at line 3070 of file ArrayND.h.

                                                                                                     {
     if (!shapeIsKnown_)
       throw npstat::NpstatInvalidArgument("Initialize npstat::ArrayND before calling method \"linearIndex\"");
     if (!dim_)
       throw npstat::NpstatInvalidArgument(
           "npstat::ArrayND::linearIndex method "
           "can not be used with array of 0 rank");
     if (idxLen != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::linearIndex: incompatible index length");
     assert(index);
 
     unsigned long idx = 0UL;
     for (unsigned i = 0; i < dim_; ++i) {
       if (index[i] >= shape_[i])
         throw npstat::NpstatOutOfRange("In npstat::ArrayND::linearIndex: index out of range");
       idx += index[i] * strides_[i];
     }
     return idx;
   }

◆ linearValue() [1/2]

template<typename Numeric , unsigned Len, unsigned Dim>

Numeric & npstat::ArrayND< Numeric, Len, Dim >::linearValue ( unsigned long index )

inline

Element access using linear index (no bounds checking)

Definition at line 3123 of file ArrayND.h.

Referenced by npstat::HistoND< Numeric, Axis >::HistoND(), and npstat::HistoND< Numeric, Axis >::setLinearBin().

                                                                                    {
     return data_[index];
   }

◆ linearValue() [2/2]

template<typename Numeric , unsigned Len, unsigned Dim>

const Numeric & npstat::ArrayND< Numeric, Len, Dim >::linearValue ( unsigned long index ) const

inline

Definition at line 3128 of file ArrayND.h.

                                                                                                {
     return data_[index];
   }

◆ linearValueAt() [1/2]

template<typename Numeric , unsigned Len, unsigned Dim>

Numeric & npstat::ArrayND< Numeric, Len, Dim >::linearValueAt ( unsigned long index )

inline

Element access using linear index (with bounds checking)

Definition at line 3133 of file ArrayND.h.

Referenced by npstat::HistoND< Numeric, Axis >::setLinearBinAt().

                                                                                      {
     if (index >= len_)
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::linearValueAt: linear index out of range");
     return data_[index];
   }

◆ linearValueAt() [2/2]

template<typename Numeric , unsigned Len, unsigned Dim>

const Numeric & npstat::ArrayND< Numeric, Len, Dim >::linearValueAt ( unsigned long index ) const

inline

Definition at line 3140 of file ArrayND.h.

                                                                                                  {
     if (index >= len_)
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::linearValueAt: linear index out of range");
     return data_[index];
   }

◆ makeCopulaSteps()

template<typename Numeric , unsigned Len, unsigned Dim>

unsigned npstat::ArrayND< Numeric, Len, Dim >::makeCopulaSteps	(	double	tolerance,
		unsigned	maxIterations
	)

This method accumulates marginals and divides the array (treated as a distribution) by the product of the marginals. Several iterations like this turn the distribution into a copula. If the array contains negative elements, they are turned into zeros before the iterations are performed. The function returns the actual number of iteration performed when the given tolerance was reached for all marginals.

Definition at line 4073 of file ArrayND.h.

                                                                                                      {
     if (!shapeIsKnown_)
       throw npstat::NpstatInvalidArgument("Initialize npstat::ArrayND before calling method \"makeCopulaSteps\"");
     if (nCycles == 0U)
       return 0U;
     if (!dim_)
       throw npstat::NpstatInvalidArgument(
           "npstat::ArrayND::makeCopulaSteps method "
           "can not be used with array of 0 rank");
 
     const Numeric zero = Numeric();
     for (unsigned long i = 0; i < len_; ++i)
       if (!(ComplexComparesAbs<Numeric>::more(data_[i], zero)))
         data_[i] = zero;
 
     std::vector<Numeric*> axesPtrBuf(dim_);
     Numeric** axes = &axesPtrBuf[0];
     const Numeric one = static_cast<Numeric>(1);
 
     // Memory for the axis accumulators
     unsigned idxSum = 0;
     for (unsigned i = 0; i < dim_; ++i)
       idxSum += shape_[i];
     std::vector<Numeric> axesBuf(idxSum);
     axes[0] = &axesBuf[0];
     for (unsigned i = 1; i < dim_; ++i)
       axes[i] = axes[i - 1] + shape_[i - 1];
 
     // Accumulate axis projections
     unsigned icycle = 0;
     for (; icycle < nCycles; ++icycle) {
       for (unsigned i = 0; i < idxSum; ++i)
         axesBuf[i] = zero;
 
       // Accumulate sums for each axis
       for (unsigned long idat = 0; idat < len_; ++idat) {
         unsigned long l = idat;
         for (unsigned i = 0; i < dim_; ++i) {
           const unsigned idx = l / strides_[i];
           l -= (idx * strides_[i]);
           axes[i][idx] += data_[idat];
         }
       }
 
       // Make averages out of sums
       bool withinTolerance = true;
       Numeric totalSum = zero;
       for (unsigned i = 0; i < dim_; ++i) {
         Numeric axisSum = zero;
         const unsigned amax = shape_[i];
         for (unsigned a = 0; a < amax; ++a) {
           if (axes[i][a] == zero)
             throw npstat::NpstatRuntimeError(
                 "In npstat::ArrayND::makeCopulaSteps: "
                 "marginal density is zero");
           axisSum += axes[i][a];
         }
         totalSum += axisSum;
         const Numeric axisAverage = axisSum / static_cast<Numeric>(amax);
         for (unsigned a = 0; a < amax; ++a)
           axes[i][a] /= axisAverage;
         for (unsigned a = 0; a < amax && withinTolerance; ++a) {
           const double adelta = absDifference(axes[i][a], one);
           if (adelta > tolerance)
             withinTolerance = false;
         }
       }
 
       if (withinTolerance)
         break;
 
       const Numeric totalAverage = totalSum / static_cast<Numeric>(len_) / static_cast<Numeric>(dim_);
 
       // Run over all points again and divide by
       // the product of marginals
       for (unsigned long idat = 0; idat < len_; ++idat) {
         unsigned long l = idat;
         for (unsigned i = 0; i < dim_; ++i) {
           const unsigned idx = l / strides_[i];
           l -= (idx * strides_[i]);
           data_[idat] /= axes[i][idx];
         }
         data_[idat] /= totalAverage;
       }
     }
 
     return icycle;
   }

◆ makeNonNegative()

template<typename Numeric , unsigned Len, unsigned Dim>

ArrayND< Numeric, Len, Dim > & npstat::ArrayND< Numeric, Len, Dim >::makeNonNegative ( )

This method turns all negative elements into zeros

Definition at line 4059 of file ArrayND.h.

                                                                           {
     if (!shapeIsKnown_)
       throw npstat::NpstatInvalidArgument("Initialize npstat::ArrayND before calling method \"makeNonNegative\"");
     const Numeric zero = Numeric();
     if (dim_) {
       for (unsigned long i = 0; i < len_; ++i)
         if (!(ComplexComparesAbs<Numeric>::more(data_[i], zero)))
           data_[i] = zero;
     } else if (!(ComplexComparesAbs<Numeric>::more(localData_[0], zero)))
       localData_[0] = zero;
     return *this;
   }

◆ makeUnit()

template<typename Numeric , unsigned Len, unsigned Dim>

ArrayND< Numeric, Len, Dim > & npstat::ArrayND< Numeric, Len, Dim >::makeUnit ( )

This method can be used for arrays with rank of at least 2 whose length is the same in all dimensions. It puts static_cast<Numeric>(1) on the main diagonal and Numeric() everywhere else.

Definition at line 4371 of file ArrayND.h.

                                                                    {
     if (!shapeIsKnown_)
       throw npstat::NpstatInvalidArgument("Initialize npstat::ArrayND before calling method \"makeUnit\"");
     if (dim_ < 2)
       throw npstat::NpstatInvalidArgument(
           "npstat::ArrayND::makeUnit method "
           "can not be used with arrays of rank less than 2");
     constFill(Numeric());
     unsigned long stride = 0UL;
     const unsigned dimlen = shape_[0];
     for (unsigned i = 0; i < dim_; ++i) {
       if (shape_[i] != dimlen)
         throw npstat::NpstatInvalidArgument(
             "npstat::ArrayND::makeUnit method needs "
             "the array span to be the same in ech dimension");
       stride += strides_[i];
     }
     const Numeric one(static_cast<Numeric>(1));
     for (unsigned i = 0; i < dimlen; ++i)
       data_[i * stride] = one;
     return *this;
   }

◆ marginalize() [1/2]

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

template<typename Num2 , unsigned Len2, unsigned Dim2>

ArrayND npstat::ArrayND< Numeric, StackLen, StackDim >::marginalize	(	const ArrayND< Num2, Len2, Dim2 > &	prior,
		const unsigned *	indexMap,
		unsigned	mapLen
	)		const

The intent of this method is to marginalize over a set of indices with a prior. Essentially, we are calculating integrals akin to p(y) = Integral f(y|x) g(x) dx in which all functions are represented on an equidistant grid. If needed, multiplication of the result by the grid cell size should be performed after this function. "indexMap" specifies how the indices of the prior array (which is like g(x)) are mapped into the indices of this array (which is like f(y|x)). The number of elements in the map, "mapLen", must be equal to the rank of the prior. Dimension 0 of the prior corresponds to the dimension indexMap[0] of this array, dimension 1 corresponds to indexMap[1], etc.

◆ marginalize() [2/2]

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

template<typename Num2 , unsigned Len2, unsigned Dim2>

ArrayND<Numeric, StackLen, StackDim> npstat::ArrayND< Numeric, StackLen, StackDim >::marginalize	(	const ArrayND< Num2, Len2, Dim2 > &	prior,
		const unsigned *	indexMap,
		const unsigned	mapLen
	)		const

Definition at line 1575 of file ArrayND.h.

                                                                                                      {
     if (!shapeIsKnown_)
       throw npstat::NpstatInvalidArgument("Initialize npstat::ArrayND before calling method \"marginalize\"");
     if (!(prior.dim_ && prior.dim_ <= dim_))
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::marginalize: incompatible argument array rank");
     const unsigned resultDim = dim_ - prior.dim_;
 
     // Check that the index map is reasonable
     if (mapLen != prior.dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::marginalize: incompatible index map length");
     assert(indexMap);
     for (unsigned i = 0; i < mapLen; ++i) {
       const unsigned thisInd = indexMap[i];
       if (shape_[thisInd] != prior.shape_[i])
         throw npstat::NpstatInvalidArgument(
             "In npstat::ArrayND::marginalize: "
             "incompatible argument array dimensions");
       if (thisInd >= dim_)
         throw npstat::NpstatOutOfRange("In npstat::ArrayND::marginalize: index map entry out of range");
       for (unsigned j = 0; j < i; ++j)
         if (indexMap[j] == thisInd)
           throw npstat::NpstatInvalidArgument(
               "In npstat::ArrayND::marginalize: "
               "duplicate entry in the index map");
     }
 
     // Build the shape for the array of results
     ArrayShape newShape;
     newShape.reserve(resultDim);
     for (unsigned i = 0; i < dim_; ++i) {
       bool mapped = false;
       for (unsigned j = 0; j < mapLen; ++j)
         if (indexMap[j] == i) {
           mapped = true;
           break;
         }
       if (!mapped)
         newShape.push_back(shape_[i]);
     }
 
     ArrayND result(newShape);
     assert(result.dim_ == resultDim);
     bool calculated = false;
     if (resultDim == 0) {
       calculated = true;
       for (unsigned i = 0; i < dim_; ++i)
         if (indexMap[i] != i) {
           calculated = false;
           break;
         }
       if (calculated) {
         Numeric sum = Numeric();
         for (unsigned long i = 0; i < len_; ++i)
           sum += data_[i] * prior.data_[i];
         result.localData_[0] = sum;
       }
     }
 
     if (!calculated)
       marginalizeLoop(0U, 0UL, 0U, 0UL, prior, indexMap, result);
 
     return result;
   }

◆ marginalizeInnerLoop()

template<typename Numeric , unsigned StackLen, unsigned StackDim>

template<typename Num2 , unsigned Len2, unsigned Dim2>

Numeric npstat::ArrayND< Numeric, StackLen, StackDim >::marginalizeInnerLoop	(	unsigned long	idx,
		unsigned	levelPr,
		unsigned long	idxPr,
		const ArrayND< Num2, Len2, Dim2 > &	prior,
		const unsigned *	indexMap
	)		const

private

Definition at line 1512 of file ArrayND.h.

                                                                                                                  {
     Numeric sum = Numeric();
     const unsigned long myStride = strides_[indexMap[levelPr]];
     const unsigned imax = prior.shape_[levelPr];
     assert(imax == shape_[indexMap[levelPr]]);
     if (levelPr == prior.dim_ - 1) {
       for (unsigned i = 0; i < imax; ++i)
         sum += data_[idx + i * myStride] * prior.data_[idxPr++];
     } else {
       const unsigned long priorStride = prior.strides_[levelPr];
       for (unsigned i = 0; i < imax; ++i) {
         sum += marginalizeInnerLoop(idx, levelPr + 1U, idxPr, prior, indexMap);
         idx += myStride;
         idxPr += priorStride;
       }
     }
     return sum;
   }

◆ marginalizeLoop()

template<typename Numeric , unsigned StackLen, unsigned StackDim>

template<typename Num2 , unsigned Len2, unsigned Dim2>

void npstat::ArrayND< Numeric, StackLen, StackDim >::marginalizeLoop	(	unsigned	level,
		unsigned long	idx,
		unsigned	levelRes,
		unsigned long	idxRes,
		const ArrayND< Num2, Len2, Dim2 > &	prior,
		const unsigned *	indexMap,
		ArrayND< Numeric, StackLen, StackDim > &	res
	)		const

private

Definition at line 1537 of file ArrayND.h.

                                                                                     {
     if (level == dim_) {
       const Numeric res = marginalizeInnerLoop(idx, 0U, 0UL, prior, indexMap);
       if (result.dim_)
         result.data_[idxRes] = res;
       else
         result.localData_[0] = res;
     } else {
       // Check if this level is mapped or not
       bool mapped = false;
       for (unsigned i = 0; i < prior.dim_; ++i)
         if (level == indexMap[i]) {
           mapped = true;
           break;
         }
       if (mapped)
         marginalizeLoop(level + 1U, idx, levelRes, idxRes, prior, indexMap, result);
       else {
         const unsigned imax = shape_[level];
         const unsigned long myStride = strides_[level];
         const unsigned long resStride = result.strides_[levelRes];
         for (unsigned i = 0; i < imax; ++i) {
           marginalizeLoop(level + 1U, idx, levelRes + 1U, idxRes, prior, indexMap, result);
           idx += myStride;
           idxRes += resStride;
         }
       }
     }
   }

◆ max() [1/2]

template<typename Numeric , unsigned Len, unsigned Dim>

Numeric npstat::ArrayND< Numeric, Len, Dim >::max ( ) const

Maximum array element

Definition at line 4709 of file ArrayND.h.

                                                 {
     if (!shapeIsKnown_)
       throw npstat::NpstatInvalidArgument("Initialize npstat::ArrayND before calling method \"max\"");
     if (dim_) {
       Numeric maxval(data_[0]);
       for (unsigned long i = 1UL; i < len_; ++i)
         if (ComplexComparesAbs<Numeric>::less(maxval, data_[i]))
           maxval = data_[i];
       return maxval;
     } else
       return localData_[0];
   }

◆ max() [2/2]

template<typename Numeric , unsigned Len, unsigned Dim>

Numeric npstat::ArrayND< Numeric, Len, Dim >::max	(	unsigned *	index,
		unsigned	indexLen
	)		const

Maximum array element and its index

Definition at line 4723 of file ArrayND.h.

                                                                                         {
     if (!shapeIsKnown_)
       throw npstat::NpstatInvalidArgument("Initialize npstat::ArrayND before calling method \"max\"");
     if (indexLen != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::max: incompatible index length");
     if (dim_) {
       unsigned long maxind = 0UL;
       Numeric maxval(data_[0]);
       for (unsigned long i = 1UL; i < len_; ++i)
         if (ComplexComparesAbs<Numeric>::less(maxval, data_[i])) {
           maxval = data_[i];
           maxind = i;
         }
       convertLinearIndex(maxind, index, indexLen);
       return maxval;
     } else
       return localData_[0];
   }

◆ maxAbsDifference()

template<typename Numeric, unsigned Len, unsigned Dim>

template<unsigned Len2, unsigned Dim2>

double npstat::ArrayND< Numeric, Len, Dim >::maxAbsDifference ( const ArrayND< Numeric, Len2, Dim2 > & r ) const

Largest absolute difference with another bin-compatible array

Definition at line 3935 of file ArrayND.h.

                                                                                                  {
     if (!isShapeCompatible(r))
       throw npstat::NpstatInvalidArgument(
           "In npstat::ArrayND::maxAbsDifference: "
           "incompatible argument array shape");
     if (dim_) {
       double maxd = 0.0;
       for (unsigned long i = 0; i < len_; ++i) {
         const Numeric rval = r.data_[i];
         const double d = absDifference(data_[i], rval);
         if (d > maxd)
           maxd = d;
       }
       return maxd;
     } else {
       const Numeric rval = r.localData_[0];
       return absDifference(localData_[0], rval);
     }
   }

◆ maximumSpan()

template<typename Numeric , unsigned Len, unsigned Dim>

unsigned npstat::ArrayND< Numeric, Len, Dim >::maximumSpan ( ) const

Maximum span among all dimensions

Definition at line 5095 of file ArrayND.h.

                                                          {
     unsigned maxspan = 0;
     for (unsigned i = 0; i < dim_; ++i)
       if (shape_[i] > maxspan)
         maxspan = shape_[i];
     return maxspan;
   }

◆ min() [1/2]

template<typename Numeric , unsigned Len, unsigned Dim>

Numeric npstat::ArrayND< Numeric, Len, Dim >::min ( ) const

Minimum array element

Definition at line 4675 of file ArrayND.h.

                                                 {
     if (!shapeIsKnown_)
       throw npstat::NpstatInvalidArgument("Initialize npstat::ArrayND before calling method \"min\"");
     if (dim_) {
       Numeric minval(data_[0]);
       for (unsigned long i = 1UL; i < len_; ++i)
         if (ComplexComparesAbs<Numeric>::less(data_[i], minval))
           minval = data_[i];
       return minval;
     } else
       return localData_[0];
   }

◆ min() [2/2]

template<typename Numeric , unsigned Len, unsigned Dim>

Numeric npstat::ArrayND< Numeric, Len, Dim >::min	(	unsigned *	index,
		unsigned	indexLen
	)		const

Minimum array element and its index

Definition at line 4689 of file ArrayND.h.

                                                                                         {
     if (!shapeIsKnown_)
       throw npstat::NpstatInvalidArgument("Initialize npstat::ArrayND before calling method \"min\"");
     if (indexLen != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::min: incompatible index length");
     if (dim_) {
       unsigned long minind = 0UL;
       Numeric minval(data_[0]);
       for (unsigned long i = 1UL; i < len_; ++i)
         if (ComplexComparesAbs<Numeric>::less(data_[i], minval)) {
           minval = data_[i];
           minind = i;
         }
       convertLinearIndex(minind, index, indexLen);
       return minval;
     } else
       return localData_[0];
   }

◆ minimumSpan()

template<typename Numeric , unsigned Len, unsigned Dim>

unsigned npstat::ArrayND< Numeric, Len, Dim >::minimumSpan ( ) const

Minimum span among all dimensions

Definition at line 5104 of file ArrayND.h.

                                                          {
     if (dim_ == 0)
       return 0U;
     unsigned minspan = shape_[0];
     for (unsigned i = 1; i < dim_; ++i)
       if (shape_[i] < minspan)
         minspan = shape_[i];
     return minspan;
   }

◆ multiMirror()

template<typename Numeric , unsigned Len, unsigned Dim>

template<typename Num2 , unsigned Len2, unsigned Dim2>

void npstat::ArrayND< Numeric, Len, Dim >::multiMirror ( ArrayND< Num2, Len2, Dim2 > * out ) const

Fill another array with all possible mirror images of this one. This other array must have twice the span in each dimension.

Definition at line 4941 of file ArrayND.h.

                                                                                    {
     assert(out);
     if (!shapeIsKnown_)
       throw npstat::NpstatInvalidArgument("Initialize npstat::ArrayND before calling method \"multiMirror\"");
     if (!out->shapeIsKnown_)
       *out = ArrayND<Num2, Len2, Dim2>(doubleShape(shape()));
     if (dim_ != out->dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::multiMirror: incompatible argument array rank");
 
     if (dim_) {
       const unsigned* dshape = out->shape_;
       for (unsigned i = 0; i < dim_; ++i)
         if (dshape[i] != shape_[i] * 2U)
           throw npstat::NpstatInvalidArgument(
               "In npstat::ArrayND::multiMirror: "
               "incompatible argument array shape");
 
       if (dim_ >= CHAR_BIT * sizeof(unsigned long))
         throw npstat::NpstatInvalidArgument(
             "In npstat::ArrayND::multiMirror: "
             "array rank is too large");
       const unsigned long maxcycle = 1UL << dim_;
       std::vector<unsigned> indexbuf(dim_ * 2U);
       unsigned* idx = &indexbuf[0];
       unsigned* mirror = idx + dim_;
 
       for (unsigned long ipt = 0; ipt < len_; ++ipt) {
         unsigned long l = ipt;
         for (unsigned i = 0; i < dim_; ++i) {
           idx[i] = l / strides_[i];
           l -= (idx[i] * strides_[i]);
         }
         for (unsigned long icycle = 0UL; icycle < maxcycle; ++icycle) {
           for (unsigned i = 0; i < dim_; ++i) {
             if (icycle & (1UL << i))
               mirror[i] = dshape[i] - idx[i] - 1U;
             else
               mirror[i] = idx[i];
           }
           out->value(mirror, dim_) = data_[ipt];
         }
       }
     } else
       out->localData_[0] = static_cast<Num2>(localData_[0]);
   }

◆ multiplyBySlice()

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

template<typename Num2 , unsigned Len2, unsigned Dim2>

ArrayND& npstat::ArrayND< Numeric, StackLen, StackDim >::multiplyBySlice	(	const ArrayND< Num2, Len2, Dim2 > &	slice,
		const unsigned *	fixedIndices,
		unsigned	nFixedIndices
	)

inline

Convenience method which multiplies the array by a scale factor which varies across the slice

Definition at line 768 of file ArrayND.h.

                                                             {
       applySlice(
           const_cast<ArrayND<Num2, Len2, Dim2>&>(slice), fixedIndices, nFixedIndices, multeq_left<Numeric, Num2>());
       return *this;
     }

◆ operator!=()

template<typename Numeric, unsigned Len, unsigned Dim>

template<unsigned Len2, unsigned Dim2>

bool npstat::ArrayND< Numeric, Len, Dim >::operator!= ( const ArrayND< Numeric, Len2, Dim2 > & r ) const

inline

Logical negation of operator==

Definition at line 3977 of file ArrayND.h.

                                                                                                 {
     return !(*this == r);
   }

◆ operator()() [1/22]

template<typename Numeric , unsigned Len, unsigned Dim>

Numeric & npstat::ArrayND< Numeric, Len, Dim >::operator() ( )

inline

Fortran-style subscripting without bounds checking (of course, with indices starting at 0).

Definition at line 3227 of file ArrayND.h.

                                                          {
     if (!shapeIsKnown_)
       throw npstat::NpstatInvalidArgument("Initialize npstat::ArrayND before calling method \"operator()\"");
     if (dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::operator(): wrong # of args (not rank 0 array)");
     return localData_[0];
   }

◆ operator()() [2/22]

template<typename Numeric , unsigned Len, unsigned Dim>

const Numeric & npstat::ArrayND< Numeric, Len, Dim >::operator() ( ) const

inline

Definition at line 3236 of file ArrayND.h.

                                                                      {
     if (!shapeIsKnown_)
       throw npstat::NpstatInvalidArgument("Initialize npstat::ArrayND before calling method \"operator()\"");
     if (dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::operator(): wrong # of args (not rank 0 array)");
     return localData_[0];
   }

◆ operator()() [3/22]

template<typename Numeric , unsigned Len, unsigned Dim>

Numeric & npstat::ArrayND< Numeric, Len, Dim >::operator() ( unsigned i0 )

inline

Definition at line 3245 of file ArrayND.h.

                                                                          {
     if (1U != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::operator(): wrong # of args (not rank 1 array)");
     return data_[i];
   }

◆ operator()() [4/22]

template<typename Numeric , unsigned Len, unsigned Dim>

const Numeric & npstat::ArrayND< Numeric, Len, Dim >::operator() ( unsigned i0 ) const

inline

Definition at line 3252 of file ArrayND.h.

                                                                                      {
     if (1U != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::operator(): wrong # of args (not rank 1 array)");
     return data_[i];
   }

◆ operator()() [5/22]

template<typename Numeric , unsigned Len, unsigned Dim>

Numeric & npstat::ArrayND< Numeric, Len, Dim >::operator()	(	unsigned	i0,
		unsigned	i1
	)

inline

Definition at line 3295 of file ArrayND.h.

                                                                                              {
     if (2U != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::operator(): wrong # of args (not rank 2 array)");
     return data_[i0 * strides_[0] + i1];
   }

◆ operator()() [6/22]

template<typename Numeric , unsigned Len, unsigned Dim>

const Numeric & npstat::ArrayND< Numeric, Len, Dim >::operator()	(	unsigned	i0,
		unsigned	i1
	)		const

inline

Definition at line 3302 of file ArrayND.h.

                                                                                                          {
     if (2U != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::operator(): wrong # of args (not rank 2 array)");
     return data_[i0 * strides_[0] + i1];
   }

◆ operator()() [7/22]

template<typename Numeric , unsigned Len, unsigned Dim>

Numeric & npstat::ArrayND< Numeric, Len, Dim >::operator()	(	unsigned	i0,
		unsigned	i1,
		unsigned	i2
	)

inline

Definition at line 3432 of file ArrayND.h.

                                                                                                                 {
     if (3U != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::operator(): wrong # of args (not rank 3 array)");
     return data_[i0 * strides_[0] + i1 * strides_[1] + i2];
   }

◆ operator()() [8/22]

template<typename Numeric , unsigned Len, unsigned Dim>

const Numeric & npstat::ArrayND< Numeric, Len, Dim >::operator()	(	unsigned	i0,
		unsigned	i1,
		unsigned	i2
	)		const

inline

Definition at line 3331 of file ArrayND.h.

                                                                                         {
     if (3U != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::operator(): wrong # of args (not rank 3 array)");
     return data_[i0 * strides_[0] + i1 * strides_[1] + i2];
   }

◆ operator()() [9/22]

template<typename Numeric , unsigned Len, unsigned Dim>

Numeric & npstat::ArrayND< Numeric, Len, Dim >::operator()	(	unsigned	i0,
		unsigned	i1,
		unsigned	i2,
		unsigned	i3
	)

inline

Definition at line 3439 of file ArrayND.h.

                                                                             {
     if (4U != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::operator(): wrong # of args (not rank 4 array)");
     return data_[i0 * strides_[0] + i1 * strides_[1] + i2 * strides_[2] + i3];
   }

◆ operator()() [10/22]

template<typename Numeric , unsigned Len, unsigned Dim>

const Numeric & npstat::ArrayND< Numeric, Len, Dim >::operator()	(	unsigned	i0,
		unsigned	i1,
		unsigned	i2,
		unsigned	i3
	)		const

inline

Definition at line 3340 of file ArrayND.h.

                                                                                         {
     if (4U != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::operator(): wrong # of args (not rank 4 array)");
     return data_[i0 * strides_[0] + i1 * strides_[1] + i2 * strides_[2] + i3];
   }

◆ operator()() [11/22]

template<typename Numeric , unsigned Len, unsigned Dim>

Numeric & npstat::ArrayND< Numeric, Len, Dim >::operator()	(	unsigned	i0,
		unsigned	i1,
		unsigned	i2,
		unsigned	i3,
		unsigned	i4
	)

inline

Definition at line 3449 of file ArrayND.h.

                                                                                                      {
     if (5U != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::operator(): wrong # of args (not rank 5 array)");
     return data_[i0 * strides_[0] + i1 * strides_[1] + i2 * strides_[2] + i3 * strides_[3] + i4];
   }

◆ operator()() [12/22]

template<typename Numeric , unsigned Len, unsigned Dim>

const Numeric & npstat::ArrayND< Numeric, Len, Dim >::operator()	(	unsigned	i0,
		unsigned	i1,
		unsigned	i2,
		unsigned	i3,
		unsigned	i4
	)		const

inline

Definition at line 3350 of file ArrayND.h.

                                                                                                            {
     if (5U != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::operator(): wrong # of args (not rank 5 array)");
     return data_[i0 * strides_[0] + i1 * strides_[1] + i2 * strides_[2] + i3 * strides_[3] + i4];
   }

◆ operator()() [13/22]

template<typename Numeric , unsigned Len, unsigned Dim>

Numeric & npstat::ArrayND< Numeric, Len, Dim >::operator()	(	unsigned	i0,
		unsigned	i1,
		unsigned	i2,
		unsigned	i3,
		unsigned	i4,
		unsigned	i5
	)

inline

Definition at line 3457 of file ArrayND.h.

                                                                             {
     if (6U != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::operator(): wrong # of args (not rank 6 array)");
     return data_[i0 * strides_[0] + i1 * strides_[1] + i2 * strides_[2] + i3 * strides_[3] + i4 * strides_[4] + i5];
   }

◆ operator()() [14/22]

template<typename Numeric , unsigned Len, unsigned Dim>

const Numeric & npstat::ArrayND< Numeric, Len, Dim >::operator()	(	unsigned	i0,
		unsigned	i1,
		unsigned	i2,
		unsigned	i3,
		unsigned	i4,
		unsigned	i5
	)		const

inline

Definition at line 3358 of file ArrayND.h.

                                                                                         {
     if (6U != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::operator(): wrong # of args (not rank 6 array)");
     return data_[i0 * strides_[0] + i1 * strides_[1] + i2 * strides_[2] + i3 * strides_[3] + i4 * strides_[4] + i5];
   }

◆ operator()() [15/22]

template<typename Numeric , unsigned Len, unsigned Dim>

Numeric & npstat::ArrayND< Numeric, Len, Dim >::operator()	(	unsigned	i0,
		unsigned	i1,
		unsigned	i2,
		unsigned	i3,
		unsigned	i4,
		unsigned	i5,
		unsigned	i6
	)

inline

Definition at line 3469 of file ArrayND.h.

                                                                             {
     if (7U != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::operator(): wrong # of args (not rank 7 array)");
     return data_[i0 * strides_[0] + i1 * strides_[1] + i2 * strides_[2] + i3 * strides_[3] + i4 * strides_[4] +
                  i5 * strides_[5] + i6];
   }

◆ operator()() [16/22]

template<typename Numeric , unsigned Len, unsigned Dim>

const Numeric & npstat::ArrayND< Numeric, Len, Dim >::operator()	(	unsigned	i0,
		unsigned	i1,
		unsigned	i2,
		unsigned	i3,
		unsigned	i4,
		unsigned	i5,
		unsigned	i6
	)		const

inline

Definition at line 3370 of file ArrayND.h.

                                                                                         {
     if (7U != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::operator(): wrong # of args (not rank 7 array)");
     return data_[i0 * strides_[0] + i1 * strides_[1] + i2 * strides_[2] + i3 * strides_[3] + i4 * strides_[4] +
                  i5 * strides_[5] + i6];
   }

◆ operator()() [17/22]

template<typename Numeric , unsigned Len, unsigned Dim>

Numeric & npstat::ArrayND< Numeric, Len, Dim >::operator()	(	unsigned	i0,
		unsigned	i1,
		unsigned	i2,
		unsigned	i3,
		unsigned	i4,
		unsigned	i5,
		unsigned	i6,
		unsigned	i7
	)

inline

Definition at line 3483 of file ArrayND.h.

                                                                             {
     if (8U != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::operator(): wrong # of args (not rank 8 array)");
     return data_[i0 * strides_[0] + i1 * strides_[1] + i2 * strides_[2] + i3 * strides_[3] + i4 * strides_[4] +
                  i5 * strides_[5] + i6 * strides_[6] + i7];
   }

◆ operator()() [18/22]

template<typename Numeric , unsigned Len, unsigned Dim>

const Numeric & npstat::ArrayND< Numeric, Len, Dim >::operator()	(	unsigned	i0,
		unsigned	i1,
		unsigned	i2,
		unsigned	i3,
		unsigned	i4,
		unsigned	i5,
		unsigned	i6,
		unsigned	i7
	)		const

inline

Definition at line 3384 of file ArrayND.h.

                                                                                         {
     if (8U != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::operator(): wrong # of args (not rank 8 array)");
     return data_[i0 * strides_[0] + i1 * strides_[1] + i2 * strides_[2] + i3 * strides_[3] + i4 * strides_[4] +
                  i5 * strides_[5] + i6 * strides_[6] + i7];
   }

◆ operator()() [19/22]

template<typename Numeric , unsigned Len, unsigned Dim>

Numeric & npstat::ArrayND< Numeric, Len, Dim >::operator()	(	unsigned	i0,
		unsigned	i1,
		unsigned	i2,
		unsigned	i3,
		unsigned	i4,
		unsigned	i5,
		unsigned	i6,
		unsigned	i7,
		unsigned	i8
	)

inline

Definition at line 3498 of file ArrayND.h.

                                                                             {
     if (9U != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::operator(): wrong # of args (not rank 9 array)");
     return data_[i0 * strides_[0] + i1 * strides_[1] + i2 * strides_[2] + i3 * strides_[3] + i4 * strides_[4] +
                  i5 * strides_[5] + i6 * strides_[6] + i7 * strides_[7] + i8];
   }

◆ operator()() [20/22]

template<typename Numeric , unsigned Len, unsigned Dim>

const Numeric & npstat::ArrayND< Numeric, Len, Dim >::operator()	(	unsigned	i0,
		unsigned	i1,
		unsigned	i2,
		unsigned	i3,
		unsigned	i4,
		unsigned	i5,
		unsigned	i6,
		unsigned	i7,
		unsigned	i8
	)		const

inline

Definition at line 3399 of file ArrayND.h.

                                                                                         {
     if (9U != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::operator(): wrong # of args (not rank 9 array)");
     return data_[i0 * strides_[0] + i1 * strides_[1] + i2 * strides_[2] + i3 * strides_[3] + i4 * strides_[4] +
                  i5 * strides_[5] + i6 * strides_[6] + i7 * strides_[7] + i8];
   }

◆ operator()() [21/22]

template<typename Numeric , unsigned Len, unsigned Dim>

Numeric & npstat::ArrayND< Numeric, Len, Dim >::operator()	(	unsigned	i0,
		unsigned	i1,
		unsigned	i2,
		unsigned	i3,
		unsigned	i4,
		unsigned	i5,
		unsigned	i6,
		unsigned	i7,
		unsigned	i8,
		unsigned	i9
	)

inline

Definition at line 3514 of file ArrayND.h.

                                                                             {
     if (10U != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::operator(): wrong # of args (not rank 10 array)");
     return data_[i0 * strides_[0] + i1 * strides_[1] + i2 * strides_[2] + i3 * strides_[3] + i4 * strides_[4] +
                  i5 * strides_[5] + i6 * strides_[6] + i7 * strides_[7] + i8 * strides_[8] + i9];
   }

◆ operator()() [22/22]

template<typename Numeric , unsigned Len, unsigned Dim>

const Numeric & npstat::ArrayND< Numeric, Len, Dim >::operator()	(	unsigned	i0,
		unsigned	i1,
		unsigned	i2,
		unsigned	i3,
		unsigned	i4,
		unsigned	i5,
		unsigned	i6,
		unsigned	i7,
		unsigned	i8,
		unsigned	i9
	)		const

inline

Definition at line 3415 of file ArrayND.h.

                                                                                         {
     if (10U != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::operator(): wrong # of args (not rank 10 array)");
     return data_[i0 * strides_[0] + i1 * strides_[1] + i2 * strides_[2] + i3 * strides_[3] + i4 * strides_[4] +
                  i5 * strides_[5] + i6 * strides_[6] + i7 * strides_[7] + i8 * strides_[8] + i9];
   }

◆ operator*() [1/2]

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

template<typename Num2 >

ArrayND npstat::ArrayND< Numeric, StackLen, StackDim >::operator* ( const Num2 & r ) const

multiplication by a scalar

◆ operator*() [2/2]

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

template<typename Num2 >

ArrayND<Numeric, Len, Dim> npstat::ArrayND< Numeric, StackLen, StackDim >::operator* ( const Num2 & r ) const

Definition at line 3983 of file ArrayND.h.

                                                                                       {
     if (!shapeIsKnown_)
       throw npstat::NpstatInvalidArgument("Initialize npstat::ArrayND before calling method \"operator*\"");
     ArrayND<Numeric, Len, Dim> result(shape_, dim_);
     for (unsigned long i = 0; i < len_; ++i)
       result.data_[i] = data_[i] * r;
     return result;
   }

◆ operator*=() [1/2]

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

template<typename Num2 >

ArrayND& npstat::ArrayND< Numeric, StackLen, StackDim >::operator*= ( const Num2 & r )

In-place operators. Note that these work faster than the binary versions, i.e., A += B is much faster than A = A + B.

◆ operator*=() [2/2]

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

template<typename Num2 >

ArrayND<Numeric, Len, Dim>& npstat::ArrayND< Numeric, StackLen, StackDim >::operator*= ( const Num2 & r )

Definition at line 4050 of file ArrayND.h.

                                                                                   {
     if (!shapeIsKnown_)
       throw npstat::NpstatInvalidArgument("Initialize npstat::ArrayND before calling method \"operator*=\"");
     for (unsigned long i = 0; i < len_; ++i)
       data_[i] *= r;
     return *this;
   }

◆ operator+() [1/3]

template<typename Numeric , unsigned Len, unsigned Dim>

ArrayND< Numeric, Len, Dim > npstat::ArrayND< Numeric, Len, Dim >::operator+ ( ) const

inline

operator+ returns a copy of this array

Definition at line 4032 of file ArrayND.h.

                                                                                 {
     if (!shapeIsKnown_)
       throw npstat::NpstatInvalidArgument("Initialize npstat::ArrayND before calling method \"operator+\"");
     return *this;
   }

◆ operator+() [2/3]

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

template<unsigned Len2, unsigned Dim2>

ArrayND npstat::ArrayND< Numeric, StackLen, StackDim >::operator+ ( const ArrayND< Numeric, Len2, Dim2 > & r ) const

addition of two arrays

◆ operator+() [3/3]

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

template<unsigned Len2, unsigned Dim2>

ArrayND<Numeric, Len, Dim> npstat::ArrayND< Numeric, StackLen, StackDim >::operator+ ( const ArrayND< Numeric, Len2, Dim2 > & r ) const

Definition at line 4007 of file ArrayND.h.

                                                                                                               {
     if (!isShapeCompatible(r))
       throw npstat::NpstatInvalidArgument(
           "In npstat::ArrayND::operator+: "
           "incompatible argument array shape");
     ArrayND<Numeric, Len, Dim> result(shape_, dim_);
     for (unsigned long i = 0; i < len_; ++i)
       result.data_[i] = data_[i] + r.data_[i];
     return result;
   }

◆ operator+=() [1/2]

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

template<typename Num2 , unsigned Len2, unsigned Dim2>

ArrayND& npstat::ArrayND< Numeric, StackLen, StackDim >::operator+= ( const ArrayND< Num2, Len2, Dim2 > & r )

◆ operator+=() [2/2]

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

template<typename Num2 , unsigned Len2, unsigned Dim2>

ArrayND<Numeric, Len, Dim>& npstat::ArrayND< Numeric, StackLen, StackDim >::operator+= ( const ArrayND< Num2, Len2, Dim2 > & r )

Definition at line 4176 of file ArrayND.h.

                                                                                                        {
     if (!isShapeCompatible(r))
       throw npstat::NpstatInvalidArgument(
           "In npstat::ArrayND::operator+=: "
           "incompatible argument array shape");
     for (unsigned long i = 0; i < len_; ++i)
       data_[i] += r.data_[i];
     return *this;
   }

◆ operator-() [1/3]

template<typename Numeric , unsigned Len, unsigned Dim>

ArrayND< Numeric, Len, Dim > npstat::ArrayND< Numeric, Len, Dim >::operator- ( ) const

operator- applies the unary minus operator to every element

Definition at line 4039 of file ArrayND.h.

                                                                          {
     if (!shapeIsKnown_)
       throw npstat::NpstatInvalidArgument("Initialize npstat::ArrayND before calling method \"operator-\"");
     ArrayND<Numeric, Len, Dim> result(shape_, dim_);
     for (unsigned long i = 0; i < len_; ++i)
       result.data_[i] = -data_[i];
     return result;
   }

◆ operator-() [2/3]

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

template<unsigned Len2, unsigned Dim2>

ArrayND npstat::ArrayND< Numeric, StackLen, StackDim >::operator- ( const ArrayND< Numeric, Len2, Dim2 > & r ) const

subtraction of two arrays

◆ operator-() [3/3]

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

template<unsigned Len2, unsigned Dim2>

ArrayND<Numeric, Len, Dim> npstat::ArrayND< Numeric, StackLen, StackDim >::operator- ( const ArrayND< Numeric, Len2, Dim2 > & r ) const

Definition at line 4020 of file ArrayND.h.

                                                                                                               {
     if (!isShapeCompatible(r))
       throw npstat::NpstatInvalidArgument(
           "In npstat::ArrayND::operator-: "
           "incompatible argument array shape");
     ArrayND<Numeric, Len, Dim> result(shape_, dim_);
     for (unsigned long i = 0; i < len_; ++i)
       result.data_[i] = data_[i] - r.data_[i];
     return result;
   }

◆ operator-=() [1/2]

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

template<typename Num2 , unsigned Len2, unsigned Dim2>

ArrayND& npstat::ArrayND< Numeric, StackLen, StackDim >::operator-= ( const ArrayND< Num2, Len2, Dim2 > & r )

◆ operator-=() [2/2]

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

template<typename Num2 , unsigned Len2, unsigned Dim2>

ArrayND<Numeric, Len, Dim>& npstat::ArrayND< Numeric, StackLen, StackDim >::operator-= ( const ArrayND< Num2, Len2, Dim2 > & r )

Definition at line 4200 of file ArrayND.h.

                                                                                                        {
     if (!isShapeCompatible(r))
       throw npstat::NpstatInvalidArgument(
           "In npstat::ArrayND::operator-=: "
           "incompatible argument array shape");
     for (unsigned long i = 0; i < len_; ++i)
       data_[i] -= r.data_[i];
     return *this;
   }

◆ operator/() [1/2]

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

template<typename Num2 >

ArrayND npstat::ArrayND< Numeric, StackLen, StackDim >::operator/ ( const Num2 & r ) const

division by a scalar

◆ operator/() [2/2]

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

template<typename Num2 >

ArrayND<Numeric, Len, Dim> npstat::ArrayND< Numeric, StackLen, StackDim >::operator/ ( const Num2 & r ) const

Definition at line 3994 of file ArrayND.h.

                                                                                       {
     if (!shapeIsKnown_)
       throw npstat::NpstatInvalidArgument("Initialize npstat::ArrayND before calling method \"operator/\"");
     if (r == Num2())
       throw npstat::NpstatRuntimeError("In npstat::ArrayND::operator/: division by zero");
     ArrayND<Numeric, Len, Dim> result(shape_, dim_);
     for (unsigned long i = 0; i < len_; ++i)
       result.data_[i] = data_[i] / r;
     return result;
   }

◆ operator/=() [1/2]

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

template<typename Num2 >

ArrayND& npstat::ArrayND< Numeric, StackLen, StackDim >::operator/= ( const Num2 & r )

◆ operator/=() [2/2]

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

template<typename Num2 >

ArrayND<Numeric, Len, Dim>& npstat::ArrayND< Numeric, StackLen, StackDim >::operator/= ( const Num2 & r )

Definition at line 4164 of file ArrayND.h.

                                                                                   {
     if (!shapeIsKnown_)
       throw npstat::NpstatInvalidArgument("Initialize npstat::ArrayND before calling method \"operator/=\"");
     if (r == Num2())
       throw npstat::NpstatRuntimeError("In npstat::ArrayND::operator/=: division by zero");
     for (unsigned long i = 0; i < len_; ++i)
       data_[i] /= r;
     return *this;
   }

◆ operator=() [1/3]

template<typename Numeric , unsigned Len, unsigned Dim>

ArrayND< Numeric, Len, Dim > & npstat::ArrayND< Numeric, Len, Dim >::operator= ( const ArrayND< Numeric, StackLen, StackDim > & r )

Assignment operator. The shape of the array on the right must be compatible with the shape of the array on the left. The only exception is when the array on the left has no shape at all (i.e., it was created by the default constructor or its "uninitialize" method was called). In this case the array on the left will assume the shape of the array on the right.

Definition at line 2914 of file ArrayND.h.

                                                                                     {
     if (this == &r)
       return *this;
     if (shapeIsKnown_) {
       if (!r.shapeIsKnown_)
         throw npstat::NpstatInvalidArgument(
             "In npstat::ArrayND assignment operator: "
             "uninitialized argument array");
       if (!isShapeCompatible(r))
         throw npstat::NpstatInvalidArgument(
             "In npstat::ArrayND assignment operator: "
             "incompatible argument array shape");
       if (dim_)
         copyBuffer(data_, r.data_, len_);
       else
         localData_[0] = r.localData_[0];
     } else {
       // This object is uninitialized. If the object on the
       // right is itself initialized, make an in-place copy.
       if (r.shapeIsKnown_)
         new (this) ArrayND(r);
     }
     return *this;
   }

◆ operator=() [2/3]

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

template<typename Num2 , unsigned Len2, unsigned Dim2>

ArrayND& npstat::ArrayND< Numeric, StackLen, StackDim >::operator= ( const ArrayND< Num2, Len2, Dim2 > & )

Converting assignment operator

◆ operator=() [3/3]

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

template<typename Num2 , unsigned Len2, unsigned Dim2>

ArrayND<Numeric, Len, Dim>& npstat::ArrayND< Numeric, StackLen, StackDim >::operator= ( const ArrayND< Num2, Len2, Dim2 > & r )

Definition at line 2941 of file ArrayND.h.

                                                                                                       {
     if ((void*)this == (void*)(&r))
       return *this;
     if (shapeIsKnown_) {
       if (!r.shapeIsKnown_)
         throw npstat::NpstatInvalidArgument(
             "In npstat::ArrayND assignment operator: "
             "uninitialized argument array");
       if (!isShapeCompatible(r))
         throw npstat::NpstatInvalidArgument(
             "In npstat::ArrayND assignment operator: "
             "incompatible argument array shape");
       if (dim_)
         copyBuffer(data_, r.data_, len_);
       else
         localData_[0] = static_cast<Numeric>(r.localData_[0]);
     } else {
       // This object is uninitialized. If the object on the
       // right is itself initialized, make an in-place copy.
       if (r.shapeIsKnown_)
         new (this) ArrayND(r);
     }
     return *this;
   }

◆ operator==()

template<typename Numeric, unsigned Len, unsigned Dim>

template<unsigned Len2, unsigned Dim2>

bool npstat::ArrayND< Numeric, Len, Dim >::operator== ( const ArrayND< Numeric, Len2, Dim2 > & r ) const

Compare two arrays for equality

Definition at line 3957 of file ArrayND.h.

                                                                                          {
     if (shapeIsKnown_ != r.shapeIsKnown_)
       return false;
     if (r.dim_ != dim_)
       return false;
     if (r.len_ != len_)
       return false;
     for (unsigned i = 0; i < dim_; ++i)
       if (shape_[i] != r.shape_[i])
         return false;
     for (unsigned i = 0; i < dim_; ++i)
       assert(strides_[i] == r.strides_[i]);
     for (unsigned long j = 0; j < len_; ++j)
       if (data_[j] != r.data_[j])
         return false;
     return true;
   }

◆ outer() [1/2]

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

template<typename Num2 , unsigned Len2, unsigned Dim2>

ArrayND npstat::ArrayND< Numeric, StackLen, StackDim >::outer ( const ArrayND< Num2, Len2, Dim2 > & r ) const

Outer product as a method (see also the outer product constructor)

◆ outer() [2/2]

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

template<typename Num2 , unsigned Len2, unsigned Dim2>

ArrayND<Numeric, Len, Dim> npstat::ArrayND< Numeric, StackLen, StackDim >::outer ( const ArrayND< Num2, Len2, Dim2 > & r ) const

Definition at line 4551 of file ArrayND.h.

                                                                                                        {
     return ArrayND<Numeric, Len, Dim>(*this, r);
   }

◆ outerProductLoop()

template<typename Numeric , unsigned Len, unsigned Dim>

template<typename Num1 , unsigned Len1, unsigned Dim1, typename Num2 , unsigned Len2, unsigned Dim2>

void npstat::ArrayND< Numeric, Len, Dim >::outerProductLoop	(	unsigned	level,
		unsigned long	idx0,
		unsigned long	idx1,
		unsigned long	idx2,
		const ArrayND< Num1, Len1, Dim1 > &	a1,
		const ArrayND< Num2, Len2, Dim2 > &	a2
	)

private

Definition at line 2845 of file ArrayND.h.

                                                                                          {
     const unsigned imax = shape_[level];
     if (level == dim_ - 1) {
       for (unsigned i = 0; i < imax; ++i)
         data_[idx0 + i] = a1.data_[idx1] * a2.data_[idx2 + i];
     } else {
       for (unsigned i = 0; i < imax; ++i) {
         outerProductLoop(level + 1, idx0, idx1, idx2, a1, a2);
         idx0 += strides_[level];
         if (level < a1.dim_)
           idx1 += a1.strides_[level];
         else
           idx2 += a2.strides_[level - a1.dim_];
       }
     }
   }

◆ processSubrange()

template<typename Numeric, unsigned Len, unsigned StackDim>

template<typename Num2 , typename Integer >

void npstat::ArrayND< Numeric, Len, StackDim >::processSubrange	(	AbsArrayProjector< Numeric, Num2 > &	f,
		const BoxND< Integer > &	subrange
	)		const

This method runs over a subrange of the array and calls the argument functor on every point. This method will not call "clear" or "result" functions of the argument functor.

Definition at line 2447 of file ArrayND.h.

                                                                                               {
     if (!shapeIsKnown_)
       throw npstat::NpstatInvalidArgument("Initialize npstat::ArrayND before calling method \"processSubrange\"");
     if (!dim_)
       throw npstat::NpstatInvalidArgument(
           "npstat::ArrayND::processSubrange method "
           "can not be used with array of 0 rank");
     if (dim_ != subrange.dim())
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::processSubrange: incompatible subrange rank");
     unsigned ibuf[StackDim];
     unsigned* buf = makeBuffer(dim_, ibuf, StackDim);
     for (unsigned i = 0; i < dim_; ++i)
       buf[i] = 0U;
     processSubrangeLoop(0U, 0UL, buf, f, subrange);
     destroyBuffer(buf, ibuf);
   }

◆ processSubrangeLoop()

template<typename Numeric, unsigned Len, unsigned Dim>

template<typename Num2 , typename Integer >

void npstat::ArrayND< Numeric, Len, Dim >::processSubrangeLoop	(	unsigned	level,
		unsigned long	idx0,
		unsigned *	currentIndex,
		AbsArrayProjector< Numeric, Num2 > &	f,
		const BoxND< Integer > &	subrange
	)		const

private

Definition at line 2408 of file ArrayND.h.

                                                                                              {
     // Deal with possible negative limits first
     const Interval<Integer>& levelRange(subrange[level]);
     long long int iminl = static_cast<long long int>(levelRange.min());
     if (iminl < 0LL)
       iminl = 0LL;
     long long int imaxl = static_cast<long long int>(levelRange.max());
     if (imaxl < 0LL)
       imaxl = 0LL;
 
     // Now deal with possible out-of-range limits
     const unsigned imin = static_cast<unsigned>(iminl);
     unsigned imax = static_cast<unsigned>(imaxl);
     if (imax > shape_[level])
       imax = shape_[level];
 
     if (level == dim_ - 1) {
       idx0 += imin;
       for (unsigned i = imin; i < imax; ++i, ++idx0) {
         currentIndex[level] = i;
         f.process(currentIndex, dim_, idx0, data_[idx0]);
       }
     } else {
       const unsigned long stride = strides_[level];
       idx0 += imin * stride;
       for (unsigned i = imin; i < imax; ++i) {
         currentIndex[level] = i;
         processSubrangeLoop(level + 1U, idx0, currentIndex, f, subrange);
         idx0 += stride;
       }
     }
   }

◆ project() [1/2]

template<typename Numeric, unsigned StackLen, unsigned StackDim>

template<typename Num2 , unsigned Len2, unsigned Dim2, typename Num3 >

void npstat::ArrayND< Numeric, StackLen, StackDim >::project	(	ArrayND< Num2, Len2, Dim2 > *	projection,
		AbsArrayProjector< Numeric, Num3 > &	projector,
		const unsigned *	projectedIndices,
		unsigned	nProjectedIndices
	)		const

This method fills a projection. The array to which "projection" argument points should normally be created by the slicing constructor using this array as an argument. "projectedIndices" should be the same as "indices" specified during the slice creation.

Definition at line 2104 of file ArrayND.h.

                                                                                              {
     assert(projection);
     verifyProjectionCompatibility(*projection, projectedIndices, nProjectedIndices);
     unsigned ibuf[StackDim];
     unsigned* buf = makeBuffer(dim_, ibuf, StackDim);
     for (unsigned i = 0; i < dim_; ++i)
       buf[i] = 0U;
     projectLoop(0U,
                 0UL,
                 0U,
                 0UL,
                 buf,
                 projection,
                 projector,
                 projectedIndices,
                 nProjectedIndices,
                 scast_assign_left<Num2, Num3>());
     destroyBuffer(buf, ibuf);
   }

◆ project() [2/2]

template<typename Numeric, unsigned StackLen, unsigned StackDim>

template<typename Num2 , unsigned Len2, unsigned Dim2, typename Num3 >

void npstat::ArrayND< Numeric, StackLen, StackDim >::project	(	ArrayND< Num2, Len2, Dim2 > *	projection,
		AbsVisitor< Numeric, Num3 > &	projector,
		const unsigned *	projectedIndices,
		unsigned	nProjectedIndices
	)		const

Definition at line 2245 of file ArrayND.h.

                                                                                              {
     assert(projection);
     verifyProjectionCompatibility(*projection, projectedIndices, nProjectedIndices);
     projectLoop2(
         0U, 0UL, 0U, 0UL, projection, projector, projectedIndices, nProjectedIndices, scast_assign_left<Num2, Num3>());
   }

◆ projectInnerLoop()

template<typename Numeric, unsigned StackLen, unsigned StackDim>

template<typename Num2 >

void npstat::ArrayND< Numeric, StackLen, StackDim >::projectInnerLoop	(	unsigned	level,
		unsigned long	idx0,
		unsigned *	currentIndex,
		AbsArrayProjector< Numeric, Num2 > &	projector,
		const unsigned *	projectedIndices,
		unsigned	nProjectedIndices
	)		const

private

Definition at line 1970 of file ArrayND.h.

                                                                                                       {
     // level :  dimension number among indices which are being iterated
     const unsigned idx = projectedIndices[level];
     const unsigned imax = shape_[idx];
     const unsigned long stride = strides_[idx];
     const bool last = (level == nProjectedIndices - 1);
 
     for (unsigned i = 0; i < imax; ++i) {
       currentIndex[idx] = i;
       if (last)
         projector.process(currentIndex, dim_, idx0, data_[idx0]);
       else
         projectInnerLoop(level + 1, idx0, currentIndex, projector, projectedIndices, nProjectedIndices);
       idx0 += stride;
     }
   }

◆ projectInnerLoop2()

template<typename Numeric, unsigned StackLen, unsigned StackDim>

template<typename Num2 >

void npstat::ArrayND< Numeric, StackLen, StackDim >::projectInnerLoop2	(	unsigned	level,
		unsigned long	idx0,
		AbsVisitor< Numeric, Num2 > &	projector,
		const unsigned *	projectedIndices,
		unsigned	nProjectedIndices
	)		const

private

Definition at line 2179 of file ArrayND.h.

                                                                                                        {
     const unsigned idx = projectedIndices[level];
     const unsigned imax = shape_[idx];
     const unsigned long stride = strides_[idx];
     const bool last = (level == nProjectedIndices - 1);
 
     for (unsigned i = 0; i < imax; ++i) {
       if (last)
         projector.process(data_[idx0 + i * stride]);
       else
         projectInnerLoop2(level + 1, idx0 + i * stride, projector, projectedIndices, nProjectedIndices);
     }
   }

◆ projectLoop()

template<typename Numeric, unsigned StackLen, unsigned StackDim>

template<typename Num2 , unsigned Len2, unsigned Dim2, typename Num3 , class Op >

void npstat::ArrayND< Numeric, StackLen, StackDim >::projectLoop	(	unsigned	level,
		unsigned long	idx0,
		unsigned	level1,
		unsigned long	idx1,
		unsigned *	currentIndex,
		ArrayND< Num2, Len2, Dim2 > *	projection,
		AbsArrayProjector< Numeric, Num3 > &	projector,
		const unsigned *	projectedIndices,
		unsigned	nProjectedIndices,
		Op	fcn
	)		const

private

Definition at line 1994 of file ArrayND.h.

                                                                        {
     // level        : dimension number in this array
     // level1       : dimension number in the projection
     // idx0         : linear index in this array
     // idx1         : linear index in the projection
     // currentIndex : cycled over in this loop with the exception of the
     //                dimensions which are iterated over to build the
     //                projection
     if (level == dim_) {
       assert(level1 == projection->dim_);
       projector.clear();
       projectInnerLoop(0U, idx0, currentIndex, projector, projectedIndices, nProjectedIndices);
       if (projection->dim_)
         fcn(projection->data_[idx1], projector.result());
       else
         fcn(projection->localData_[0], projector.result());
     } else {
       bool iterated = false;
       for (unsigned j = 0; j < nProjectedIndices; ++j)
         if (projectedIndices[j] == level) {
           iterated = true;
           break;
         }
       if (iterated) {
         // This index will be iterated over inside "projectInnerLoop"
         projectLoop(
             level + 1, idx0, level1, idx1, currentIndex, projection, projector, projectedIndices, nProjectedIndices, fcn);
       } else {
         const unsigned imax = shape_[level];
         const unsigned long stride = strides_[level];
         // We will not be able to get here if projection->dim_ is 0.
         // Therefore, it is safe to access projection->strides_.
         const unsigned long stride2 = projection->strides_[level1];
         for (unsigned i = 0; i < imax; ++i) {
           currentIndex[level] = i;
           projectLoop(level + 1,
                       idx0 + i * stride,
                       level1 + 1,
                       idx1 + i * stride2,
                       currentIndex,
                       projection,
                       projector,
                       projectedIndices,
                       nProjectedIndices,
                       fcn);
         }
       }
     }
   }

◆ projectLoop2()

template<typename Numeric, unsigned StackLen, unsigned StackDim>

template<typename Num2 , unsigned Len2, unsigned Dim2, typename Num3 , class Op >

void npstat::ArrayND< Numeric, StackLen, StackDim >::projectLoop2	(	unsigned	level,
		unsigned long	idx0,
		unsigned	level1,
		unsigned long	idx1,
		ArrayND< Num2, Len2, Dim2 > *	projection,
		AbsVisitor< Numeric, Num3 > &	projector,
		const unsigned *	projectedIndices,
		unsigned	nProjectedIndices,
		Op	fcn
	)		const

private

Definition at line 2199 of file ArrayND.h.

                                                                         {
     if (level == dim_) {
       assert(level1 == projection->dim_);
       projector.clear();
       projectInnerLoop2(0U, idx0, projector, projectedIndices, nProjectedIndices);
       if (projection->dim_)
         fcn(projection->data_[idx1], projector.result());
       else
         fcn(projection->localData_[0], projector.result());
     } else {
       bool fixed = false;
       for (unsigned j = 0; j < nProjectedIndices; ++j)
         if (projectedIndices[j] == level) {
           fixed = true;
           break;
         }
       if (fixed) {
         projectLoop2(level + 1, idx0, level1, idx1, projection, projector, projectedIndices, nProjectedIndices, fcn);
       } else {
         const unsigned imax = shape_[level];
         const unsigned long stride = strides_[level];
         const unsigned long stride2 = projection->strides_[level1];
         for (unsigned i = 0; i < imax; ++i)
           projectLoop2(level + 1,
                        idx0 + i * stride,
                        level1 + 1,
                        idx1 + i * stride2,
                        projection,
                        projector,
                        projectedIndices,
                        nProjectedIndices,
                        fcn);
       }
     }
   }

◆ rank()

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

unsigned npstat::ArrayND< Numeric, StackLen, StackDim >::rank ( ) const

inline

The number of array dimensions

Definition at line 242 of file ArrayND.h.

Referenced by npstat::LinInterpolatedTableND< Numeric, Axis >::invert1DResponse(), and npstat::Private::lind_invert1DSlice().

242 { return dim_; }

npstat::ArrayND::dim_

unsigned dim_

Definition: ArrayND.h:1058

◆ restore()

template<typename Numeric , unsigned Len, unsigned Dim>

void npstat::ArrayND< Numeric, Len, Dim >::restore	(	const gs::ClassId &	id,
		std::istream &	in,
		ArrayND< Numeric, StackLen, StackDim > *	array
	)

static

Definition at line 5386 of file ArrayND.h.

Referenced by npstat::LinInterpolatedTableND< Numeric, Axis >::read(), and npstat::HistoND< Numeric, Axis >::read().

                                                                                               {
     static const gs::ClassId current(gs::ClassId::makeId<ArrayND<Numeric, Len, Dim> >());
     current.ensureSameId(id);
 
     ArrayShape rshape;
     gs::read_pod_vector(in, &rshape);
     if (in.fail())
       throw gs::IOReadFailure("In npstat::ArrayND::restore: input stream failure (checkpoint 0)");
 
     assert(array);
     array->uninitialize();
     array->dim_ = rshape.size();
     array->shapeIsKnown_ = true;
     array->len_ = 1UL;
     if (array->dim_) {
       array->shape_ = makeBuffer(array->dim_, array->localShape_, Dim);
       for (unsigned i = 0; i < array->dim_; ++i) {
         array->shape_[i] = rshape[i];
         assert(array->shape_[i]);
         array->len_ *= array->shape_[i];
       }
       array->buildStrides();
       array->data_ = makeBuffer(array->len_, array->localData_, Len);
       gs::read_array(in, array->data_, array->len_);
     } else
       gs::restore_item(in, array->localData_, false);
     if (in.fail())
       throw gs::IOReadFailure("In npstat::ArrayND::restore: input stream failure (checkpoint 1)");
   }

◆ rotate()

template<typename Numeric , unsigned Len, unsigned Dim>

template<typename Num2 , unsigned Len2, unsigned Dim2>

void npstat::ArrayND< Numeric, Len, Dim >::rotate	(	const unsigned *	shifts,
		unsigned	lenShifts,
		ArrayND< Num2, Len2, Dim2 > *	rotated
	)		const

Rotation. Place the result into another array. The elements with indices 0 in the current array will become elements with indices "shifts" in the rotated array.

Definition at line 4989 of file ArrayND.h.

                                                                                     {
     assert(rotated);
     if (!shapeIsKnown_)
       throw npstat::NpstatInvalidArgument("Initialize npstat::ArrayND before calling method \"rotate\"");
     // Can't rotate into itself -- it will be a mess
     if ((void*)rotated == (void*)this)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::rotate: can not rotate array into itself");
     if (!rotated->shapeIsKnown_)
       *rotated = *this;
     if (dim_ != rotated->dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::rotate: incompatible argument array rank");
     if (lenShifts != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::rotate: incompatible dimensionality of shifts");
 
     if (dim_) {
       assert(shifts);
       if (dim_ > CHAR_BIT * sizeof(unsigned long))
         throw npstat::NpstatInvalidArgument("In npstat::ArrayND::rotate: array rank is too large");
       unsigned buf[CHAR_BIT * sizeof(unsigned long)];
       clearBuffer(buf, dim_);
       (const_cast<ArrayND*>(this))
           ->flatCircularLoop(0U, 0UL, 0UL, buf, shape_, shifts, *rotated, scast_assign_right<Numeric, Num2>());
     } else
       rotated->localData_[0] = static_cast<Num2>(localData_[0]);
   }

◆ scaleBySliceInnerLoop()

template<typename Numeric , unsigned StackLen, unsigned StackDim>

template<typename Num2 , class Functor >

void npstat::ArrayND< Numeric, StackLen, StackDim >::scaleBySliceInnerLoop	(	unsigned	level,
		unsigned long	idx0,
		Num2 &	scale,
		const unsigned *	projectedIndices,
		unsigned	nProjectedIndices,
		Functor	binaryFunct
	)

private

Definition at line 2281 of file ArrayND.h.

                                                                                         {
     const unsigned idx = projectedIndices[level];
     const unsigned imax = shape_[idx];
     const unsigned long stride = strides_[idx];
 
     if (level == nProjectedIndices - 1) {
       Numeric* data = data_ + idx0;
       for (unsigned i = 0; i < imax; ++i)
         binaryFunct(data[i * stride], scale);
     } else
       for (unsigned i = 0; i < imax; ++i)
         scaleBySliceInnerLoop(level + 1, idx0 + i * stride, scale, projectedIndices, nProjectedIndices, binaryFunct);
   }

◆ scaleBySliceLoop()

template<typename Numeric , unsigned StackLen, unsigned StackDim>

template<typename Num2 , unsigned Len2, unsigned Dim2, class Functor >

void npstat::ArrayND< Numeric, StackLen, StackDim >::scaleBySliceLoop	(	unsigned	level,
		unsigned long	idx0,
		unsigned	level1,
		unsigned long	idx1,
		ArrayND< Num2, Len2, Dim2 > &	slice,
		const unsigned *	fixedIndices,
		unsigned	nFixedIndices,
		Functor	binaryFunct
	)

private

Definition at line 2302 of file ArrayND.h.

                                                                                    {
     if (level == dim_) {
       assert(level1 == slice.dim_);
       Num2& scaleFactor = slice.dim_ ? slice.data_[idx1] : slice.localData_[0];
       scaleBySliceInnerLoop(0U, idx0, scaleFactor, projectedIndices, nProjectedIndices, binaryFunct);
     } else {
       bool fixed = false;
       for (unsigned j = 0; j < nProjectedIndices; ++j)
         if (projectedIndices[j] == level) {
           fixed = true;
           break;
         }
       if (fixed) {
         scaleBySliceLoop(level + 1, idx0, level1, idx1, slice, projectedIndices, nProjectedIndices, binaryFunct);
       } else {
         const unsigned imax = shape_[level];
         const unsigned long stride = strides_[level];
         const unsigned long stride2 = slice.strides_[level1];
         for (unsigned i = 0; i < imax; ++i)
           scaleBySliceLoop(level + 1,
                            idx0 + i * stride,
                            level1 + 1,
                            idx1 + i * stride2,
                            slice,
                            projectedIndices,
                            nProjectedIndices,
                            binaryFunct);
       }
     }
   }

◆ scanInPlace() [1/2]

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

template<class Functor >

ArrayND& npstat::ArrayND< Numeric, StackLen, StackDim >::scanInPlace ( Functor f )

This method applies a single-argument functor to each element of the array. The result returned by the functor is ignored inside the scan. Depending on what the functor does, the array values may or may not be modified (they can be modified if the functor takes its argument via a non-const reference).

◆ scanInPlace() [2/2]

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

template<class Functor >

ArrayND<Numeric, Len, Dim>& npstat::ArrayND< Numeric, StackLen, StackDim >::scanInPlace ( Functor f )

Definition at line 4333 of file ArrayND.h.

                                                                                {
     if (!shapeIsKnown_)
       throw npstat::NpstatInvalidArgument("Initialize npstat::ArrayND before calling method \"scanInPlace\"");
     for (unsigned long i = 0; i < len_; ++i)
       f(data_[i]);
     return *this;
   }

◆ setData() [1/2]

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

template<typename Num2 >

ArrayND& npstat::ArrayND< Numeric, StackLen, StackDim >::setData	(	const Num2 *	data,
		unsigned long	dataLength
	)

This method modifies all the data in one statement

◆ setData() [2/2]

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

template<typename Num2 >

ArrayND<Numeric, Len, Dim>& npstat::ArrayND< Numeric, StackLen, StackDim >::setData	(	const Num2 *	data,
		const unsigned long	dataLength
	)

inline

Definition at line 2467 of file ArrayND.h.

                                                                                                          {
     if (!shapeIsKnown_)
       throw npstat::NpstatInvalidArgument("Initialize npstat::ArrayND before calling method \"setData\"");
     if (dataLength != len_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::setData: incompatible input data length");
     copyBuffer(data_, data, dataLength);
     return *this;
   }

◆ shape()

template<typename Numeric , unsigned Len, unsigned Dim>

ArrayShape npstat::ArrayND< Numeric, Len, Dim >::shape ( void ) const

inline

Get the complete shape

Definition at line 2989 of file ArrayND.h.

                                                             {
     if (!shapeIsKnown_)
       throw npstat::NpstatInvalidArgument("Initialize npstat::ArrayND before calling method \"shape\"");
     return ArrayShape(shape_, shape_ + dim_);
   }

◆ shapeData()

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

const unsigned* npstat::ArrayND< Numeric, StackLen, StackDim >::shapeData ( ) const

inline

Shape data as a C-style array

Definition at line 248 of file ArrayND.h.

248 { return shape_; }

npstat::ArrayND::shape_

unsigned * shape_

Definition: ArrayND.h:1055

◆ sliceShape()

template<typename Numeric , unsigned StackLen, unsigned StackDim>

ArrayShape npstat::ArrayND< Numeric, StackLen, StackDim >::sliceShape	(	const unsigned *	fixedIndices,
		unsigned	nFixedIndices
	)		const

Figure out the slice shape without actually making the slice

Definition at line 1733 of file ArrayND.h.

                                                                                                   {
     if (!shapeIsKnown_)
       throw npstat::NpstatInvalidArgument("Initialize npstat::ArrayND before calling method \"sliceShape\"");
     if (nFixedIndices) {
       assert(fixedIndices);
       if (nFixedIndices > dim_)
         throw npstat::NpstatInvalidArgument("In npstat::ArrayND::sliceShape: too many fixed indices");
       for (unsigned j = 0; j < nFixedIndices; ++j)
         if (fixedIndices[j] >= dim_)
           throw npstat::NpstatOutOfRange(
               "In npstat::ArrayND::sliceShape: "
               "fixed index out of range");
       ArrayShape sh;
       sh.reserve(dim_ - nFixedIndices);
       for (unsigned i = 0; i < dim_; ++i) {
         bool fixed = false;
         for (unsigned j = 0; j < nFixedIndices; ++j)
           if (fixedIndices[j] == i) {
             fixed = true;
             break;
           }
         if (!fixed)
           sh.push_back(shape_[i]);
       }
       return sh;
     } else
       return ArrayShape(shape_, shape_ + dim_);
   }

◆ span()

template<typename Numeric , unsigned Len, unsigned Dim>

unsigned npstat::ArrayND< Numeric, Len, Dim >::span ( unsigned dim ) const

inline

Get the number of elements in some particular dimension

Definition at line 5088 of file ArrayND.h.

                                                                            {
     if (dim >= dim_)
       throw npstat::NpstatOutOfRange("In npstat::ArrayND::span: dimension number is out of range");
     return shape_[dim];
   }

◆ strides()

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

const unsigned long* npstat::ArrayND< Numeric, StackLen, StackDim >::strides ( ) const

inline

Get the strides

Definition at line 263 of file ArrayND.h.

263 { return strides_; }

npstat::ArrayND::strides_

unsigned long * strides_

Definition: ArrayND.h:1052

◆ subtractFromProjection() [1/2]

template<typename Numeric, unsigned StackLen, unsigned StackDim>

template<typename Num2 , unsigned Len2, unsigned Dim2, typename Num3 >

void npstat::ArrayND< Numeric, StackLen, StackDim >::subtractFromProjection	(	ArrayND< Num2, Len2, Dim2 > *	projection,
		AbsArrayProjector< Numeric, Num3 > &	projector,
		const unsigned *	projectedIndices,
		unsigned	nProjectedIndices
	)		const

Definition at line 2154 of file ArrayND.h.

                                                                                                             {
     assert(projection);
     verifyProjectionCompatibility(*projection, projectedIndices, nProjectedIndices);
     unsigned ibuf[StackDim];
     unsigned* buf = makeBuffer(dim_, ibuf, StackDim);
     for (unsigned i = 0; i < dim_; ++i)
       buf[i] = 0U;
     projectLoop(0U,
                 0UL,
                 0U,
                 0UL,
                 buf,
                 projection,
                 projector,
                 projectedIndices,
                 nProjectedIndices,
                 scast_minuseq_left<Num2, Num3>());
     destroyBuffer(buf, ibuf);
   }

◆ subtractFromProjection() [2/2]

template<typename Numeric, unsigned StackLen, unsigned StackDim>

template<typename Num2 , unsigned Len2, unsigned Dim2, typename Num3 >

void npstat::ArrayND< Numeric, StackLen, StackDim >::subtractFromProjection	(	ArrayND< Num2, Len2, Dim2 > *	projection,
		AbsVisitor< Numeric, Num3 > &	projector,
		const unsigned *	projectedIndices,
		unsigned	nProjectedIndices
	)		const

Definition at line 2269 of file ArrayND.h.

                                                                                                             {
     assert(projection);
     verifyProjectionCompatibility(*projection, projectedIndices, nProjectedIndices);
     projectLoop2(
         0U, 0UL, 0U, 0UL, projection, projector, projectedIndices, nProjectedIndices, scast_minuseq_left<Num2, Num3>());
   }

◆ sum()

template<typename Numeric , unsigned Len, unsigned Dim>

template<typename Num2 >

Num2 npstat::ArrayND< Numeric, Len, Dim >::sum ( ) const

Sum of all array elements which uses Num2 type as accumulator. Typically, the precision and dynamic range of Num2 should be suitably larger than the precision and dynamic range of Numeric. For example, if Numeric is float then Num2 should be double, etc.

Definition at line 4652 of file ArrayND.h.

                                              {
     if (!shapeIsKnown_)
       throw npstat::NpstatInvalidArgument("Initialize npstat::ArrayND before calling method \"sum\"");
     Num2 sum = Num2();
     for (unsigned long i = 0; i < len_; ++i)
       sum += data_[i];
     return sum;
   }

◆ sumBelowLoop()

template<typename Numeric , unsigned Len, unsigned Dim>

template<typename Accumulator >

Accumulator npstat::ArrayND< Numeric, Len, Dim >::sumBelowLoop	(	unsigned	level,
		unsigned long	idx0,
		const unsigned *	limit
	)		const

private

Definition at line 4816 of file ArrayND.h.

                                                                                     {
     Accumulator cdf = Accumulator();
     const unsigned imax = limit[level] + 1U;
     if (level == dim_ - 1) {
       Numeric* base = data_ + idx0;
       for (unsigned i = 0; i < imax; ++i)
         cdf += base[i];
     } else {
       const unsigned long stride = strides_[level];
       for (unsigned i = 0; i < imax; ++i, idx0 += stride)
         cdf += sumBelowLoop<Accumulator>(level + 1, idx0, limit);
     }
     return cdf;
   }

◆ sumsq()

template<typename Numeric , unsigned Len, unsigned Dim>

template<typename Num2 >

Num2 npstat::ArrayND< Numeric, Len, Dim >::sumsq ( ) const

Sum of absolute values squared which uses Num2 as accumulator. Function std::abs(Numeric) must exist.

Definition at line 4663 of file ArrayND.h.

                                                {
     if (!shapeIsKnown_)
       throw npstat::NpstatInvalidArgument("Initialize npstat::ArrayND before calling method \"sumsq\"");
     Num2 sum = Num2();
     for (unsigned long i = 0; i < len_; ++i) {
       const Num2 absval = absValue(data_[i]);
       sum += absval * absval;
     }
     return sum;
   }

◆ transpose() [1/2]

template<typename Numeric , unsigned Len, unsigned Dim>

ArrayND< Numeric, Len, Dim > npstat::ArrayND< Numeric, Len, Dim >::transpose	(	unsigned	pos1,
		unsigned	pos2
	)		const

Transposed array

Definition at line 4912 of file ArrayND.h.

                                                                                                                  {
     if (!shapeIsKnown_)
       throw npstat::NpstatInvalidArgument("Initialize npstat::ArrayND before calling method \"transpose\"");
     if (!(pos1 < dim_ && pos2 < dim_ && pos1 != pos2))
       throw npstat::NpstatInvalidArgument(
           "In npstat::ArrayND::transpose: "
           "incompatible transposition indices");
     if (dim_ == 2)
       return transpose();
     else {
       // Construct the new shape
       unsigned newshapeBuf[Dim];
       unsigned* newshape = makeBuffer(dim_, newshapeBuf, Dim);
       copyBuffer(newshape, shape_, dim_);
       std::swap(newshape[pos1], newshape[pos2]);
 
       // Form the result array
       ArrayND<Numeric, Len, Dim> result(newshape, dim_);
 
       // Fill the result array
       transposeLoop(0, pos1, pos2, 0UL, 0UL, result);
 
       destroyBuffer(newshape, newshapeBuf);
       return result;
     }
   }

◆ transpose() [2/2]

template<typename Numeric , unsigned Len, unsigned Dim>

ArrayND< Numeric, Len, Dim > npstat::ArrayND< Numeric, Len, Dim >::transpose ( ) const

Transpose without arguments can be invoked for 2-d arrays only

Definition at line 4744 of file ArrayND.h.

                                                                          {
     if (dim_ != 2)
       throw npstat::NpstatInvalidArgument(
           "npstat::ArrayND::transpose method "
           "can not be used with arrays of rank other than 2");
     unsigned newshape[2];
     newshape[0] = shape_[1];
     newshape[1] = shape_[0];
     ArrayND<Numeric, Len, Dim> result(newshape, dim_);
     const unsigned imax = shape_[0];
     const unsigned jmax = shape_[1];
     for (unsigned i = 0; i < imax; ++i)
       for (unsigned j = 0; j < jmax; ++j)
         result.data_[j * imax + i] = data_[i * jmax + j];
     return result;
   }

◆ transposeLoop()

template<typename Numeric , unsigned Len, unsigned Dim>

void npstat::ArrayND< Numeric, Len, Dim >::transposeLoop	(	unsigned	level,
		unsigned	pos1,
		unsigned	pos2,
		unsigned long	idxThis,
		unsigned long	idxRes,
		ArrayND< Numeric, StackLen, StackDim > &	result
	)		const

private

Definition at line 4629 of file ArrayND.h.

                                                                         {
     const unsigned imax = shape_[level];
     const unsigned long mystride = strides_[level];
     const unsigned relevel = level == pos1 ? pos2 : (level == pos2 ? pos1 : level);
     const unsigned long restride = result.strides_[relevel];
     const bool ready = (level == dim_ - 1);
     for (unsigned i = 0; i < imax; ++i) {
       if (ready)
         result.data_[idxRes] = data_[idxThis];
       else
         transposeLoop(level + 1, pos1, pos2, idxThis, idxRes, result);
       idxThis += mystride;
       idxRes += restride;
     }
   }

◆ uninitialize()

template<typename Numeric , unsigned Len, unsigned Dim>

ArrayND< Numeric, Len, Dim > & npstat::ArrayND< Numeric, Len, Dim >::uninitialize ( )

The function which can "uninitialize" the array to the same state as produced by the default constructor. Can be applied in order to force the assignment operators to work.

Definition at line 4356 of file ArrayND.h.

                                                                        {
     destroyBuffer(data_, localData_);
     destroyBuffer(strides_, localStrides_);
     destroyBuffer(shape_, localShape_);
     localData_[0] = Numeric();
     data_ = localData_;
     strides_ = nullptr;
     shape_ = nullptr;
     len_ = 0;
     dim_ = 0;
     shapeIsKnown_ = false;
     return *this;
   }

◆ value() [1/2]

template<typename Numeric , unsigned Len, unsigned Dim>

Numeric & npstat::ArrayND< Numeric, Len, Dim >::value	(	const unsigned *	index,
		unsigned	indexLen
	)

inline

Element access using multidimensional array index (no bounds checking). The length of the index array must be equal to the rank of this object.

Definition at line 3091 of file ArrayND.h.

Referenced by average.Average::average().

                                                                                              {
     if (!shapeIsKnown_)
       throw npstat::NpstatInvalidArgument("Initialize npstat::ArrayND before calling method \"value\"");
     if (dim != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::value: incompatible index length");
     if (dim) {
       assert(index);
       unsigned long idx = 0UL;
       for (unsigned i = 0; i < dim_; ++i)
         idx += index[i] * strides_[i];
       return data_[idx];
     } else
       return localData_[0];
   }

◆ value() [2/2]

template<typename Numeric , unsigned Len, unsigned Dim>

const Numeric & npstat::ArrayND< Numeric, Len, Dim >::value	(	const unsigned *	index,
		unsigned	indexLen
	)		const

inline

Definition at line 3107 of file ArrayND.h.

Referenced by average.Average::average().

                                                                                                          {
     if (!shapeIsKnown_)
       throw npstat::NpstatInvalidArgument("Initialize npstat::ArrayND before calling method \"value\"");
     if (dim != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::value: incompatible index length");
     if (dim) {
       assert(index);
       unsigned long idx = 0UL;
       for (unsigned i = 0; i < dim_; ++i)
         idx += index[i] * strides_[i];
       return data_[idx];
     } else
       return localData_[0];
   }

◆ valueAt() [1/2]

template<typename Numeric , unsigned Len, unsigned Dim>

Numeric & npstat::ArrayND< Numeric, Len, Dim >::valueAt	(	const unsigned *	index,
		unsigned	indexLen
	)

inline

Element access using multidimensional array index (with bounds checking)

Definition at line 3208 of file ArrayND.h.

                                                                                                {
     if (!shapeIsKnown_)
       throw npstat::NpstatInvalidArgument("Initialize npstat::ArrayND before calling method \"valueAt\"");
     if (dim != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::valueAt: incompatible index length");
     if (dim) {
       assert(index);
       unsigned long idx = 0UL;
       for (unsigned i = 0; i < dim_; ++i) {
         if (index[i] >= shape_[i])
           throw npstat::NpstatOutOfRange("In npstat::ArrayND::valueAt: index out of range");
         idx += index[i] * strides_[i];
       }
       return data_[idx];
     } else
       return localData_[0];
   }

◆ valueAt() [2/2]

template<typename Numeric , unsigned Len, unsigned Dim>

const Numeric & npstat::ArrayND< Numeric, Len, Dim >::valueAt	(	const unsigned *	index,
		unsigned	indexLen
	)		const

inline

Definition at line 3189 of file ArrayND.h.

                                                                                                            {
     if (!shapeIsKnown_)
       throw npstat::NpstatInvalidArgument("Initialize npstat::ArrayND before calling method \"valueAt\"");
     if (dim != dim_)
       throw npstat::NpstatInvalidArgument("In npstat::ArrayND::valueAt: incompatible index length");
     if (dim) {
       assert(index);
       unsigned long idx = 0UL;
       for (unsigned i = 0; i < dim_; ++i) {
         if (index[i] >= shape_[i])
           throw npstat::NpstatOutOfRange("In npstat::ArrayND::valueAt: index out of range");
         idx += index[i] * strides_[i];
       }
       return data_[idx];
     } else
       return localData_[0];
   }

◆ verifyBufferSliceCompatibility()

template<typename Numeric , unsigned StackLen, unsigned StackDim>

unsigned long npstat::ArrayND< Numeric, StackLen, StackDim >::verifyBufferSliceCompatibility	(	unsigned long	bufLen,
		const unsigned *	fixedIndices,
		const unsigned *	fixedIndexValues,
		unsigned	nFixedIndices,
		unsigned long *	sliceStrides
	)		const

private

Definition at line 1822 of file ArrayND.h.

                                                                                                                         {
     if (!(nFixedIndices && nFixedIndices <= dim_))
       throw npstat::NpstatInvalidArgument(
           "In npstat::ArrayND::verifyBufferSliceCompatibility: "
           "invalid number of fixed indices");
     if (!shapeIsKnown_)
       throw npstat::NpstatInvalidArgument(
           "Initialize npstat::ArrayND before calling "
           "method \"verifyBufferSliceCompatibility\"");
     assert(fixedIndices);
     assert(fixedIndexValues);
 
     for (unsigned j = 0; j < nFixedIndices; ++j)
       if (fixedIndices[j] >= dim_)
         throw npstat::NpstatOutOfRange(
             "In npstat::ArrayND::verifyBufferSliceCompatibility: "
             "fixed index out of range");
 
     // Figure out slice shape. Store it, temporarily, in sliceStrides.
     unsigned long idx = 0UL;
     unsigned sliceDim = 0U;
     for (unsigned i = 0; i < dim_; ++i) {
       bool fixed = false;
       for (unsigned j = 0; j < nFixedIndices; ++j)
         if (fixedIndices[j] == i) {
           fixed = true;
           if (fixedIndexValues[j] >= shape_[i])
             throw npstat::NpstatOutOfRange(
                 "In npstat::ArrayND::verifyBufferSliceCompatibility:"
                 " fixed index value out of range");
           idx += fixedIndexValues[j] * strides_[i];
           break;
         }
       if (!fixed)
         sliceStrides[sliceDim++] = shape_[i];
     }
     assert(sliceDim + nFixedIndices == dim_);
 
     // Convert the slice shape into slice strides
     unsigned long expectedBufLen = 1UL;
     if (sliceDim) {
       unsigned long shapeJ = sliceStrides[sliceDim - 1];
       sliceStrides[sliceDim - 1] = 1UL;
       for (unsigned j = sliceDim - 1; j > 0; --j) {
         const unsigned long nextStride = sliceStrides[j] * shapeJ;
         shapeJ = sliceStrides[j - 1];
         sliceStrides[j - 1] = nextStride;
       }
       expectedBufLen = sliceStrides[0] * shapeJ;
     }
     if (expectedBufLen != bufLen)
       throw npstat::NpstatInvalidArgument(
           "In npstat::ArrayND::verifyBufferSliceCompatibility: "
           "invalid memory buffer length");
 
     return idx;
   }

◆ verifyProjectionCompatibility()

template<typename Numeric , unsigned StackLen, unsigned StackDim>

template<typename Num2 , unsigned Len2, unsigned Dim2>

void npstat::ArrayND< Numeric, StackLen, StackDim >::verifyProjectionCompatibility	(	const ArrayND< Num2, Len2, Dim2 > &	projection,
		const unsigned *	projectedIndices,
		unsigned	nProjectedIndices
	)		const

private

Definition at line 2055 of file ArrayND.h.

                                                                                                                    {
     if (!(nProjectedIndices && nProjectedIndices <= dim_))
       throw npstat::NpstatInvalidArgument(
           "In npstat::ArrayND::verifyProjectionCompatibility: "
           "invalid number of projected indices");
     if (!shapeIsKnown_)
       throw npstat::NpstatInvalidArgument(
           "Initialize npstat::ArrayND before calling "
           "method \"verifyProjectionCompatibility\"");
     if (!projection.shapeIsKnown_)
       throw npstat::NpstatInvalidArgument(
           "In npstat::ArrayND::verifyProjectionCompatibility: "
           "uninitialized argument array");
     if (projection.dim_ != dim_ - nProjectedIndices)
       throw npstat::NpstatInvalidArgument(
           "In npstat::ArrayND::verifyProjectionCompatibility: "
           "incompatible argument array rank");
     assert(projectedIndices);
 
     for (unsigned j = 0; j < nProjectedIndices; ++j)
       if (projectedIndices[j] >= dim_)
         throw npstat::NpstatOutOfRange(
             "In npstat::ArrayND::verifyProjectionCompatibility: "
             "projected index out of range");
 
     // Check projection shape compatibility
     unsigned sliceDim = 0U;
     for (unsigned i = 0; i < dim_; ++i) {
       bool fixed = false;
       for (unsigned j = 0; j < nProjectedIndices; ++j)
         if (projectedIndices[j] == i) {
           fixed = true;
           break;
         }
       if (!fixed) {
         if (shape_[i] != projection.shape_[sliceDim])
           throw npstat::NpstatInvalidArgument(
               "In npstat::ArrayND::verifyProjectionCompatibility: "
               "incompatible argument array dimensions");
         ++sliceDim;
       }
     }
     assert(sliceDim == projection.dim_);
   }

◆ verifySliceCompatibility()

template<typename Numeric , unsigned StackLen, unsigned StackDim>

template<typename Num2 , unsigned Len2, unsigned Dim2>

unsigned long npstat::ArrayND< Numeric, StackLen, StackDim >::verifySliceCompatibility	(	const ArrayND< Num2, Len2, Dim2 > &	slice,
		const unsigned *	fixedIndices,
		const unsigned *	fixedIndexValues,
		unsigned	nFixedIndices
	)		const

private

Definition at line 1765 of file ArrayND.h.

                                                                                                                    {
     if (!(nFixedIndices && nFixedIndices <= dim_))
       throw npstat::NpstatInvalidArgument(
           "In npstat::ArrayND::verifySliceCompatibility: "
           "invalid number of fixed indices");
     if (!shapeIsKnown_)
       throw npstat::NpstatInvalidArgument(
           "Initialize npstat::ArrayND before calling "
           "method \"verifySliceCompatibility\"");
     if (!slice.shapeIsKnown_)
       throw npstat::NpstatInvalidArgument(
           "In npstat::ArrayND::verifySliceCompatibility: "
           "uninitialized argument array");
     if (slice.dim_ != dim_ - nFixedIndices)
       throw npstat::NpstatInvalidArgument(
           "In npstat::ArrayND::verifySliceCompatibility: "
           "incompatible argument array rank");
     assert(fixedIndices);
     assert(fixedIndexValues);
 
     for (unsigned j = 0; j < nFixedIndices; ++j)
       if (fixedIndices[j] >= dim_)
         throw npstat::NpstatOutOfRange(
             "In npstat::ArrayND::verifySliceCompatibility: "
             "fixed index out of range");
 
     // Check slice shape compatibility
     unsigned long idx = 0UL;
     unsigned sliceDim = 0U;
     for (unsigned i = 0; i < dim_; ++i) {
       bool fixed = false;
       for (unsigned j = 0; j < nFixedIndices; ++j)
         if (fixedIndices[j] == i) {
           fixed = true;
           if (fixedIndexValues[j] >= shape_[i])
             throw npstat::NpstatOutOfRange(
                 "In npstat::ArrayND::verifySliceCompatibility: "
                 "fixed index value out of range");
           idx += fixedIndexValues[j] * strides_[i];
           break;
         }
       if (!fixed) {
         if (shape_[i] != slice.shape_[sliceDim])
           throw npstat::NpstatInvalidArgument(
               "In npstat::ArrayND::verifySliceCompatibility: "
               "incompatible argument array dimensions");
         ++sliceDim;
       }
     }
     assert(sliceDim == slice.dim_);
     return idx;
   }

◆ version()

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

static unsigned npstat::ArrayND< Numeric, StackLen, StackDim >::version ( )

inlinestatic

Definition at line 1044 of file ArrayND.h.

Referenced by validation.Sample::datasetpattern(), and validation.Sample::filename().

1044 { return 1; }

◆ write()

template<typename Numeric , unsigned StackLen, unsigned StackDim>

bool npstat::ArrayND< Numeric, StackLen, StackDim >::write ( std::ostream & of ) const

Definition at line 5378 of file ArrayND.h.

                                                                        {
     if (!shapeIsKnown_)
       throw npstat::NpstatInvalidArgument("Initialize npstat::ArrayND before calling method \"write\"");
     gs::write_pod_vector(os, shape());
     return !os.fail() && (dim_ ? gs::write_array(os, data_, len_) : gs::write_item(os, localData_[0], false));
   }

Friends And Related Function Documentation

◆ ArrayND

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

template<typename Num2 , unsigned Len2, unsigned Dim2>

friend class ArrayND

friend

Definition at line 50 of file ArrayND.h.

Member Data Documentation

◆ data_

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

Numeric* npstat::ArrayND< Numeric, StackLen, StackDim >::data_

private

Definition at line 1049 of file ArrayND.h.

Referenced by npstat::ArrayND< Numeric >::convertToLastDimCdfLoop(), npstat::ArrayND< Numeric >::data(), npstat::ArrayND< Numeric >::projectLoop(), and npstat::ArrayND< Numeric >::projectLoop2().

◆ dim_

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

unsigned npstat::ArrayND< Numeric, StackLen, StackDim >::dim_

private

Definition at line 1058 of file ArrayND.h.

Referenced by npstat::ArrayND< Numeric >::ArrayND(), npstat::ArrayND< Numeric >::convertToLastDimCdfLoop(), npstat::ArrayND< Numeric >::importSubrange(), npstat::ArrayND< Numeric >::projectLoop(), npstat::ArrayND< Numeric >::projectLoop2(), npstat::ArrayND< Numeric >::rank(), npstat::ArrayND< Numeric >::rotate(), and npstat::ArrayND< Numeric >::verifyProjectionCompatibility().

◆ len_

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

unsigned long npstat::ArrayND< Numeric, StackLen, StackDim >::len_

private

Definition at line 1057 of file ArrayND.h.

Referenced by npstat::ArrayND< Numeric >::length().

◆ localData_

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

Numeric npstat::ArrayND< Numeric, StackLen, StackDim >::localData_[StackLen]

private

Definition at line 1048 of file ArrayND.h.

Referenced by npstat::ArrayND< Numeric >::convertToLastDimCdfLoop(), npstat::ArrayND< Numeric >::importSubrange(), npstat::ArrayND< Numeric >::projectLoop(), npstat::ArrayND< Numeric >::projectLoop2(), and npstat::ArrayND< Numeric >::rotate().

◆ localShape_

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

unsigned npstat::ArrayND< Numeric, StackLen, StackDim >::localShape_[StackDim]

private

Definition at line 1054 of file ArrayND.h.

◆ localStrides_

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

unsigned long npstat::ArrayND< Numeric, StackLen, StackDim >::localStrides_[StackDim]

private

Definition at line 1051 of file ArrayND.h.

◆ shape_

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

unsigned* npstat::ArrayND< Numeric, StackLen, StackDim >::shape_

private

Definition at line 1055 of file ArrayND.h.

Referenced by npstat::ArrayND< Numeric >::ArrayND(), npstat::ArrayND< Numeric >::importSubrange(), npstat::ArrayND< Numeric >::shapeData(), and npstat::ArrayND< Numeric >::verifyProjectionCompatibility().

◆ shapeIsKnown_

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

bool npstat::ArrayND< Numeric, StackLen, StackDim >::shapeIsKnown_

private

Definition at line 1060 of file ArrayND.h.

Referenced by npstat::ArrayND< Numeric >::ArrayND(), npstat::ArrayND< Numeric >::convertToLastDimCdf(), npstat::ArrayND< Numeric >::importSubrange(), npstat::ArrayND< Numeric >::isShapeKnown(), npstat::ArrayND< Numeric >::rotate(), and npstat::ArrayND< Numeric >::verifyProjectionCompatibility().

◆ strides_

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>

unsigned long* npstat::ArrayND< Numeric, StackLen, StackDim >::strides_

private

Definition at line 1052 of file ArrayND.h.

Referenced by npstat::ArrayND< Numeric >::convertToLastDimCdfLoop(), npstat::ArrayND< Numeric >::projectLoop(), npstat::ArrayND< Numeric >::projectLoop2(), and npstat::ArrayND< Numeric >::strides().

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Friends

Detailed Description

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U> class npstat::ArrayND< Numeric, StackLen, StackDim >

Member Typedef Documentation

◆ proper_double

◆ value_type

Constructor & Destructor Documentation

◆ ArrayND() [1/20]

◆ ArrayND() [2/20]

◆ ArrayND() [3/20]

◆ ArrayND() [4/20]

◆ ArrayND() [5/20]

◆ ArrayND() [6/20]

◆ ArrayND() [7/20]

◆ ArrayND() [8/20]

◆ ArrayND() [9/20]

◆ ArrayND() [10/20]

◆ ArrayND() [11/20]

◆ ArrayND() [12/20]

◆ ArrayND() [13/20]

◆ ArrayND() [14/20]

◆ ArrayND() [15/20]

◆ ArrayND() [16/20]

◆ ArrayND() [17/20]

◆ ArrayND() [18/20]

◆ ArrayND() [19/20]

◆ ArrayND() [20/20]

◆ ~ArrayND()

Member Function Documentation

◆ addmul() [1/2]

◆ addmul() [2/2]

◆ addToProjection() [1/2]

◆ addToProjection() [2/2]

◆ apply() [1/2]

◆ apply() [2/2]

◆ applySlice()

◆ assign() [1/2]

◆ assign() [2/2]

◆ at() [1/22]

◆ at() [2/22]

◆ at() [3/22]

◆ at() [4/22]

◆ at() [5/22]

◆ at() [6/22]

◆ at() [7/22]

◆ at() [8/22]

◆ at() [9/22]

◆ at() [10/22]

◆ at() [11/22]

◆ at() [12/22]

◆ at() [13/22]

◆ at() [14/22]

◆ at() [15/22]

◆ at() [16/22]

◆ at() [17/22]

◆ at() [18/22]

◆ at() [19/22]

◆ at() [20/22]

◆ at() [21/22]

◆ at() [22/22]

◆ buildFromShapePtr()

◆ buildStrides()

◆ cdfArray() [1/2]

◆ cdfArray() [2/2]

◆ cdfValue() [1/2]

◆ cdfValue() [2/2]

◆ circularFlatLoop()

◆ circularFlatScan()

◆ cl() [1/22]

◆ cl() [2/22]

◆ cl() [3/22]

◆ cl() [4/22]

◆ cl() [5/22]

◆ cl() [6/22]

◆ cl() [7/22]

template<typename Numeric, unsigned StackLen = 1U, unsigned StackDim = 10U>
class npstat::ArrayND< Numeric, StackLen, StackDim >