#include <VectorHelper.hpp>

Inheritance diagram for VectorHelper:

Static Public Member Functions
static VectorInt	initVInt (int nval, int value=0.)

static VectorDouble	initVDouble (int nval, double value=0.)

static VectorVectorDouble	initVVDouble (int nval1, int nval2, double value=0.)

static VectorVectorInt	initVVInt (int nval1, int nval2, int value=0)

static VectorInt	initVInt (const int *values, int number)

static VectorDouble	initVDouble (const double *values, int number)

static VectorVectorDouble	initVVDouble (const double *value, int n1, int n2)

static VectorString	initVString (int ntab, char **names)

static void	display (const String &title, const VectorDouble &vect, bool skipLine=true)

static void	display (const String &title, const VectorVectorDouble &vect, bool skipLine=true)

static void	display (const String &title, const VectorString &vect, bool skipLine=true)

static void	display (const String &title, const VectorInt &vect, bool skipLine=true)

static void	dump (const String &title, const VectorDouble &vect)

static String	toStringAsSpan (constvect vec)

static String	toStringAsVD (const VectorDouble &vec)

static String	toStringAsVVD (const VectorVectorDouble &vec)

static String	toStringAsVS (const VectorString &vec)

static String	toStringAsVI (const VectorInt &vec)

static void	displayStats (const String &title, const VectorDouble &vect)

static void	displayRange (const String &title, const VectorDouble &vect)

static void	displayRange (const String &title, const VectorInt &vect)

static void	displayNNZ (const String &title, const VectorDouble &vect, int nclass=10)

static int	maximum (const VectorInt &vec, bool flagAbs=false)

static int	minimum (const VectorInt &vec, bool flagAbs=false)

static double	maximum (const VectorDouble &vec, bool flagAbs=false, const VectorDouble &aux=VectorDouble(), int mode=0)

static double	minimum (const VectorDouble &vec, bool flagAbs=false, const VectorDouble &aux=VectorDouble(), int mode=0)

static double	maximum (const VectorVectorDouble &vec, bool flagAbs=false)

static double	maximum (const std::vector< std::vector< double > > &vec, bool flagAbs=false)

static double	minimum (const VectorVectorDouble &vec, bool flagAbs=false)

static int	product (const VectorInt &vec)

static double	product (const VectorDouble &vec)

static int	countUndefined (const VectorDouble &vec)

static int	countDefined (const VectorDouble &vec)

static bool	hasUndefined (const VectorDouble &vec)

static double	extensionDiagonal (const VectorDouble &mini, const VectorDouble &maxi)

static int	count (const VectorVectorInt &vec)

static int	cumul (const VectorInt &vec)

static int	cumul (const VectorVectorInt &vec)

static double	cumul (const VectorDouble &vec)

static double	mean (const VectorDouble &vec)

static double	variance (const VectorDouble &vec, bool scaleByN=false)

static double	stdv (const VectorDouble &vec, bool scaleByN=false)

static double	norm (const VectorDouble &vec)

static double	normL1 (const VectorDouble &vec)

static double	norminf (const VectorDouble &vec)

static double	median (const VectorDouble &vec)

static double	normDistance (const VectorDouble &veca, const VectorDouble &vecb)

static double	correlation (const VectorDouble &veca, const VectorDouble &vecb)

static VectorDouble	quantiles (const VectorDouble &vec, const VectorDouble &probas)

static bool	isConstant (const VectorDouble &vect, double refval=TEST)

static bool	isConstant (const VectorInt &vect, int refval=ITEST)

static bool	isEqual (const VectorDouble &v1, const VectorDouble &v2, double eps=EPSILON10)

static bool	isEqual (const VectorInt &v1, const VectorInt &v2)

static bool	isEqualExtended (const VectorDouble &v1, const VectorDouble &v2, double eps=EPSILON10, bool flagRelative=true, bool flagAbsolute=false, const String &string="")
	Function checking that two values are equal This verbose option is essentially used in tests.

static VectorInt	sequence (int number, int ideb=0, int step=1)

static VectorDouble	sequence (double valFrom, double valTo, double valStep=1., double ratio=1.)

static void	fill (VectorDouble &vec, double v, int size=0)

static void	fill (VectorInt &vec, int v, int size=0)

static void	fill (VectorVectorDouble &vec, double value)

static void	fillUndef (VectorDouble &vec, double repl)

static void	addMultiplyConstantInPlace (double val1, const constvect in, vect out, int iad)

static double	innerProduct (const constvect veca, const constvect vecb)

static void	addMultiplyVectVectInPlace (const constvect in1, const constvect in2, vect out, int iad)

static void	addInPlace (constvect in, vect dest)

static VectorDouble	add (const VectorDouble &veca, const VectorDouble &vecb)

static void	addInPlace (VectorDouble &dest, const VectorDouble &src)

static void	addInPlace (VectorInt &dest, const VectorInt &src)

static void	addInPlace (std::vector< double > &dest, const std::vector< double > &src)

static void	addInPlace (const VectorDouble &veca, const VectorDouble &vecb, VectorDouble &res, int size=0)

static void	addInPlace (const double veca, const double vecb, double *res, int size)

static void	addInPlace (const VectorVectorDouble &in1, const VectorVectorDouble &in2, VectorVectorDouble &outv)

static void	addInPlace (const std::vector< std::vector< double > > &in1, const std::vector< std::vector< double > > &in2, std::vector< std::vector< double > > &outv)

static void	addSquareInPlace (VectorDouble &dest, const VectorDouble &src)

static VectorDouble	subtract (const VectorDouble &veca, const VectorDouble &vecb)

static VectorDouble	subtract (constvect veca, constvect vecb)

static VectorInt	subtract (const VectorInt &veca, const VectorInt &vecb)

static void	subtractInPlace (VectorDouble &dest, const VectorDouble &src)

static void	subtractInPlace (VectorInt &dest, const VectorInt &src)

static void	subtractInPlace (const VectorVectorDouble &in1, const VectorVectorDouble &in2, VectorVectorDouble &outv)

static void	subtractInPlace (const std::vector< std::vector< double > > &in1, const std::vector< std::vector< double > > &in2, std::vector< std::vector< double > > &outv)

static void	multiplyInPlace (VectorDouble &vec, const VectorDouble &v)

static void	divideInPlace (VectorDouble &vec, const VectorDouble &v)

static void	multiplyConstant (VectorDouble &vec, double v)

static void	multiplyConstantInPlace (const VectorDouble &vec, double v, VectorDouble &vecout)

static void	multiplyConstantSelfInPlace (VectorDouble &vec, double v)

static void	addMultiplyConstantInPlace (double val1, const VectorDouble &in1, VectorDouble &outv, int iad)

static void	addMultiplyConstantInPlace (double val1, const VectorVectorDouble &in1, VectorVectorDouble &outv)

static void	divideConstant (VectorDouble &vec, double v)

static void	copy (const VectorDouble &vecin, VectorDouble &vecout, int size=-1)

static void	copy (const VectorInt &vecin, VectorInt &vecout, int size=-1)

static void	copy (const VectorVectorDouble &inv, VectorVectorDouble &outv)

static void	copy (const std::vector< std::vector< double > > &inv, std::vector< std::vector< double > > &outv)

static void	addConstant (VectorDouble &vec, double v)

static void	addConstant (VectorInt &vec, int v)

static void	mean1AndMean2ToStdev (const VectorDouble &mean1, const VectorDouble &mean2, VectorDouble &std, int number)

static void	normalize (VectorDouble &vec, int norm=2)

static void	normalize (double *tab, int ntab)

static void	normalizeFromGaussianDistribution (VectorDouble &vec, double mini=0., double maxi=1.)

static VectorDouble	normalScore (const VectorDouble &data, const VectorDouble &wt=VectorDouble())

static VectorDouble	qnormVec (const VectorDouble &vec)

static VectorDouble	pnormVec (const VectorDouble &vec)

static VectorDouble	concatenate (const VectorDouble &veca, const VectorDouble &vecb)

static VectorDouble	power (const VectorDouble &vec, double power)

static VectorDouble	inverse (const VectorDouble &vec)

static double	innerProduct (const VectorDouble &veca, const VectorDouble &vecb, int size=-1)

static double	innerProduct (const double veca, const double vecb, int size)

static double	innerProduct (const VectorVectorDouble &x, const VectorVectorDouble &y)

static double	innerProduct (const std::vector< double > &veca, const std::vector< double > &vecb, int size=-1)

static void	divideInPlace (std::vector< double > &vec, const std::vector< double > &v)

static VectorDouble	crossProduct3D (const VectorDouble &veca, const VectorDouble &vecb)

static void	crossProduct3DInPlace (const double a, const double b, double *v)

static VectorDouble	cumsum (const VectorDouble &vecin, bool flagAddZero, bool revert=false)

static void	cumulateInPlace (VectorDouble &vec)

static void	cumulate (VectorDouble &veca, const VectorDouble &vecb, double coeff=1., double addval=0.)

static void	getMostSignificant (const VectorDouble &vec, double tol=EPSILON6, int nmax=-1)

static VectorDouble	simulateUniform (int n=1, double mini=0., double maxi=1.)

static VectorDouble	simulateBernoulli (int n=1, double proba=0.5, double vone=1., double velse=0.)

static VectorDouble	simulateGaussian (int n=1, double mean=0., double sigma=1.)

static void	simulateGaussianInPlace (VectorDouble &vec, double mean=0., double sigma=1.)

static VectorInt	sampleRanks (int ntotal, double proportion=0., int number=0, int seed=242141, int optSort=0)

static void	normalizeCodir (int ndim, VectorDouble &codir)

static bool	isInList (const VectorInt &vec, int item)

static VectorInt	sort (const VectorInt &vecin, bool ascending=true, int size=-1)

static VectorDouble	sort (const VectorDouble &vecin, bool ascending=true, int size=-1)

static void	sortInPlace (VectorInt &vecin, bool ascending=true, int size=-1)

static void	sortInPlace (VectorDouble &vecin, bool ascending=true, int size=-1)

static bool	isSorted (const VectorDouble &vec, bool ascending=true)

static VectorDouble	unique (const VectorDouble &vecin, int size=-1)

static VectorInt	unique (const VectorInt &vecin, int size=-1)

static VectorInt	orderRanks (const VectorInt &vecin, bool ascending=true, int size=-1)

static VectorInt	orderRanks (const VectorDouble &vecin, bool ascending=true, int size=-1)

static VectorInt	sortRanks (const VectorDouble &vecin, bool ascending=true, int size=-1)

static VectorInt	reorder (const VectorInt &vecin, const VectorInt &order, int size=-1)

static VectorDouble	reorder (const VectorDouble &vecin, const VectorInt &order, int size=-1)

static VectorDouble	revert (const VectorDouble &vecin)

static VectorInt	revert (const VectorInt &vecin)

static VectorDouble	sample (const VectorDouble &vecin, const VectorInt &indKeep)
	Create an output VectorDouble by selecting some indices of the Input VectorDouble 'vecin'.

static void	arrangeInPlace (int safe, VectorInt &ranks, VectorDouble &values, bool ascending=true, int size=-1)

static void	arrangeInPlace (int safe, VectorInt &ranks, VectorInt &values, bool ascending=true, int size=-1)

static VectorInt	filter (const VectorInt &vecin, int vmin=ITEST, int vmax=ITEST, bool ascending=true)

static VectorInt	complement (const VectorInt &vec, const VectorInt &sel)

static std::pair< double, double >	rangeVals (const VectorDouble &vec)

static void	unflattenInPlace (const std::vector< double > &vd, std::vector< std::vector< double > > &vvd)

static void	flattenInPlace (const std::vector< std::vector< double > > &vvd, std::vector< double > &vd)

static VectorDouble	flatten (const VectorVectorDouble &vvd)

static VectorVectorDouble	unflatten (const VectorDouble &vd, const VectorInt &sizes)

static std::vector< double >	flatten (const std::vector< std::vector< double > > &vvd)

static std::vector< std::vector< double > >	unflatten (const std::vector< double > &vd, const VectorInt &sizes)

static void	flattenInPlace (const VectorVectorDouble &vvd, VectorDouble &vd)

static void	linearCombinationInPlace (double val1, const VectorDouble &vd1, double val2, const VectorDouble &vd2, VectorDouble &outv)

static void	linearCombinationVVDInPlace (double val1, const VectorVectorDouble &vvd1, double val2, const VectorVectorDouble &vvd2, VectorVectorDouble &outv)

static double	innerProduct (const std::vector< std::vector< double > > &x, const std::vector< std::vector< double > > &y)

static void	linearCombinationVVDInPlace (double val1, const std::vector< std::vector< double > > &vvd1, double val2, const std::vector< std::vector< double > > &vvd2, std::vector< std::vector< double > > &outv)

static VectorDouble	suppressTest (const VectorDouble &vecin)

static void	extractInPlace (const VectorDouble &vecin, VectorDouble &vecout, int start)

static void	mergeInPlace (const VectorDouble &vecin, VectorDouble &vecout, int start)

static void	transformVD (VectorDouble &tab, int oper_choice=1)

static void	squeezeAndStretchInPlaceForward (const VectorDouble &vecin, VectorDouble &vecout, double origin, double mesh, double top, double bot)

static void	squeezeAndStretchInPlaceBackward (const VectorDouble &vecin, VectorDouble &vecout, double origin, double mesh, double top, double bot)

static int	whereMinimum (const VectorDouble &tab)

static int	whereMaximum (const VectorDouble &tab)

static int	whereElement (const VectorInt &tab, int target)

static double	norm (const std::vector< double > &vec)

static VectorDouble	reduceOne (const VectorDouble &vecin, int index)

static VectorDouble	reduce (const VectorDouble &vecin, const VectorInt &vindex)

static VectorDouble	compress (const VectorDouble &vecin, const VectorInt &vindex)

static void	truncateDecimalsInPlace (VectorDouble &vec, int ndec)

static void	truncateDigitsInPlace (VectorDouble &vec, int ndec)

static void	simulateGaussianInPlace (std::vector< double > &vec, double mean=0., double sigma=1.)

Member Function Documentation

◆ add()

VectorDouble VectorHelper::add	(	const VectorDouble &	veca,
		const VectorDouble &	vecb
	)

static

◆ addConstant() [1/2]

void VectorHelper::addConstant	(	VectorDouble &	vec,
		double	v
	)

static

◆ addConstant() [2/2]

void VectorHelper::addConstant	(	VectorInt &	vec,
		int	v
	)

static

◆ addInPlace() [1/8]

void VectorHelper::addInPlace	(	const double *	veca,
		const double *	vecb,
		double *	res,
		int	size
	)

static

◆ addInPlace() [2/8]

void VectorHelper::addInPlace	(	const std::vector< std::vector< double > > &	in1,
		const std::vector< std::vector< double > > &	in2,
		std::vector< std::vector< double > > &	outv
	)

static

◆ addInPlace() [3/8]

void VectorHelper::addInPlace	(	const VectorDouble &	veca,
		const VectorDouble &	vecb,
		VectorDouble &	res,
		int	size = `0`
	)

static

◆ addInPlace() [4/8]

void VectorHelper::addInPlace	(	const VectorVectorDouble &	in1,
		const VectorVectorDouble &	in2,
		VectorVectorDouble &	outv
	)

static

◆ addInPlace() [5/8]

void VectorHelper::addInPlace	(	constvect	in,
		vect	dest
	)

static

◆ addInPlace() [6/8]

void VectorHelper::addInPlace	(	std::vector< double > &	dest,
		const std::vector< double > &	src
	)

static

◆ addInPlace() [7/8]

void VectorHelper::addInPlace	(	VectorDouble &	dest,
		const VectorDouble &	src
	)

static

Performs: veca += vecb

Parameters

dest	Input/Output vector
src	Auxiliary vector

◆ addInPlace() [8/8]

void VectorHelper::addInPlace	(	VectorInt &	dest,
		const VectorInt &	src
	)

static

◆ addMultiplyConstantInPlace() [1/3]

void VectorHelper::addMultiplyConstantInPlace	(	double	val1,
		const constvect	in,
		vect	out,
		int	iad
	)

static

◆ addMultiplyConstantInPlace() [2/3]

void VectorHelper::addMultiplyConstantInPlace	(	double	val1,
		const VectorDouble &	in1,
		VectorDouble &	outv,
		int	iad
	)

static

◆ addMultiplyConstantInPlace() [3/3]

void VectorHelper::addMultiplyConstantInPlace	(	double	val1,
		const VectorVectorDouble &	in1,
		VectorVectorDouble &	outv
	)

static

◆ addMultiplyVectVectInPlace()

void VectorHelper::addMultiplyVectVectInPlace	(	const constvect	in1,
		const constvect	in2,
		vect	out,
		int	iad
	)

static

◆ addSquareInPlace()

void VectorHelper::addSquareInPlace	(	VectorDouble &	dest,
		const VectorDouble &	src
	)

static

Performs: veca += vecb**2

Parameters

dest	Input/Output vector
src	Auxiliary vector

◆ arrangeInPlace() [1/2]

void VectorHelper::arrangeInPlace	(	int	safe,
		VectorInt &	ranks,
		VectorDouble &	values,
		bool	ascending = `true`,
		int	size = `-1`
	)

static

Sorts the (double) array value() and the array ranks() if provided

Parameters

[in]	safe	1 if the value array if preserved 0 if the value array is also sorted
[in]	ascending	Sorting order
[in]	size	Optional vector dimension
[out]	ranks	input and output int array
[out]	values	input and output double array

Remarks: If ranks = NULL, ranks is ignored; When using 'size', the remaining part of arrays is unchanged

◆ arrangeInPlace() [2/2]

void VectorHelper::arrangeInPlace	(	int	safe,
		VectorInt &	ranks,
		VectorInt &	values,
		bool	ascending = `true`,
		int	size = `-1`
	)

static

Sorts the (int) array value() and the array ranks() if provided

Parameters

[in]	safe	1 if the value array if preserved 0 if the value array is also sorted
[in]	ascending	True for ascending order; False for descending order
[in]	size	Optional size
[out]	ranks	intput and output int array
[out]	values	input and output int array

Remarks: If ranks = NULL, ranks is ignored; When using 'size', the remaining part of arrays is unchanged

◆ complement()

VectorInt VectorHelper::complement	(	const VectorInt &	vec,
		const VectorInt &	sel
	)

static

Returns the list complementary to 'sel' within 'vecin'

Parameters

vec	Initial list
sel	Vector of forbidden elements

Returns: Complementary list

◆ compress()

VectorDouble VectorHelper::compress	(	const VectorDouble &	vecin,
		const VectorInt &	vindex
	)

static

Reduce the input vector 'vecin' by returning the only elements referred by 'index'

Parameters

vecin	Input vector (double)
vindex	Vector of indices to be kept

◆ concatenate()

VectorDouble VectorHelper::concatenate	(	const VectorDouble &	veca,
		const VectorDouble &	vecb
	)

static

◆ copy() [1/4]

void VectorHelper::copy	(	const std::vector< std::vector< double > > &	inv,
		std::vector< std::vector< double > > &	outv
	)

static

◆ copy() [2/4]

void VectorHelper::copy	(	const VectorDouble &	vecin,
		VectorDouble &	vecout,
		int	size = `-1`
	)

static

◆ copy() [3/4]

void VectorHelper::copy	(	const VectorInt &	vecin,
		VectorInt &	vecout,
		int	size = `-1`
	)

static

◆ copy() [4/4]

void VectorHelper::copy	(	const VectorVectorDouble &	inv,
		VectorVectorDouble &	outv
	)

static

◆ correlation()

double VectorHelper::correlation	(	const VectorDouble &	veca,
		const VectorDouble &	vecb
	)

static

◆ count()

int VectorHelper::count ( const VectorVectorInt & vec )

static

◆ countDefined()

int VectorHelper::countDefined ( const VectorDouble & vec )

static

◆ countUndefined()

int VectorHelper::countUndefined ( const VectorDouble & vec )

static

◆ crossProduct3D()

VectorDouble VectorHelper::crossProduct3D	(	const VectorDouble &	veca,
		const VectorDouble &	vecb
	)

static

Cross product (limited to 3D)

Parameters

veca	First vector
vecb	Second Vector

Returns

◆ crossProduct3DInPlace()

void VectorHelper::crossProduct3DInPlace	(	const double *	a,
		const double *	b,
		double *	v
	)

static

◆ cumsum()

VectorDouble VectorHelper::cumsum	(	const VectorDouble &	vecin,
		bool	flagAddZero,
		bool	revert = `false`
	)

static

◆ cumul() [1/3]

double VectorHelper::cumul ( const VectorDouble & vec )

static

◆ cumul() [2/3]

int VectorHelper::cumul ( const VectorInt & vec )

static

◆ cumul() [3/3]

int VectorHelper::cumul ( const VectorVectorInt & vec )

static

◆ cumulate()

void VectorHelper::cumulate	(	VectorDouble &	veca,
		const VectorDouble &	vecb,
		double	coeff = `1.`,
		double	addval = `0.`
	)

static

◆ cumulateInPlace()

void VectorHelper::cumulateInPlace ( VectorDouble & vec )

static

◆ display() [1/4]

void VectorHelper::display	(	const String &	title,
		const VectorDouble &	vect,
		bool	skipLine = `true`
	)

static

◆ display() [2/4]

void VectorHelper::display	(	const String &	title,
		const VectorInt &	vect,
		bool	skipLine = `true`
	)

static

◆ display() [3/4]

void VectorHelper::display	(	const String &	title,
		const VectorString &	vect,
		bool	skipLine = `true`
	)

static

◆ display() [4/4]

void VectorHelper::display	(	const String &	title,
		const VectorVectorDouble &	vect,
		bool	skipLine = `true`
	)

static

◆ displayNNZ()

void VectorHelper::displayNNZ	(	const String &	title,
		const VectorDouble &	vect,
		int	nclass = `10`
	)

static

◆ displayRange() [1/2]

void VectorHelper::displayRange	(	const String &	title,
		const VectorDouble &	vect
	)

static

◆ displayRange() [2/2]

void VectorHelper::displayRange	(	const String &	title,
		const VectorInt &	vect
	)

static

◆ displayStats()

void VectorHelper::displayStats	(	const String &	title,
		const VectorDouble &	vect
	)

static

◆ divideConstant()

void VectorHelper::divideConstant	(	VectorDouble &	vec,
		double	v
	)

static

◆ divideInPlace() [1/2]

void VectorHelper::divideInPlace	(	std::vector< double > &	vec,
		const std::vector< double > &	v
	)

static

◆ divideInPlace() [2/2]

void VectorHelper::divideInPlace	(	VectorDouble &	vec,
		const VectorDouble &	v
	)

static

◆ dump()

void VectorHelper::dump	(	const String &	title,
		const VectorDouble &	vect
	)

static

◆ extensionDiagonal()

double VectorHelper::extensionDiagonal	(	const VectorDouble &	mini,
		const VectorDouble &	maxi
	)

static

Calculate the diagonal of the box extension

Parameters

mini	Array of lower coordinates of the box
maxi	Array of upper coordinates of the box

Returns

Remarks: If one coordinate is undefined, TEST is returned.

◆ extractInPlace()

void VectorHelper::extractInPlace	(	const VectorDouble &	vecin,
		VectorDouble &	vecout,
		int	start
	)

static

Extract the part of a vector 'vecin' (dimensioned to dimension of 'vecout') starting at address 'istart' and copy it into 'vecout'

Parameters

vecin	Initial vector
vecout	Resulting vector (already allocated)
start	Starting address (within 'vecin')

◆ fill() [1/3]

void VectorHelper::fill	(	VectorDouble &	vec,
		double	v,
		int	size = `0`
	)

static

◆ fill() [2/3]

void VectorHelper::fill	(	VectorInt &	vec,
		int	v,
		int	size = `0`
	)

static

◆ fill() [3/3]

void VectorHelper::fill	(	VectorVectorDouble &	vec,
		double	value
	)

static

◆ fillUndef()

void VectorHelper::fillUndef	(	VectorDouble &	vec,
		double	repl
	)

static

◆ filter()

VectorInt VectorHelper::filter	(	const VectorInt &	vecin,
		int	vmin = `ITEST`,
		int	vmax = `ITEST`,
		bool	ascending = `true`
	)

static

From an input list, filter out all the elements which do no lie within [vmin, vmax[, suppress double occurrences and sort them out (ascending or descending)

Parameters

vecin	Input array (integer)
vmin	lower bound included (or ITEST)
vmax	upper bound excluded (or ITEST)
ascending	True for ascending order; False for descending order

Returns: Output array (integers)

◆ flatten() [1/2]

std::vector< double > VectorHelper::flatten ( const std::vector< std::vector< double > > & vvd )

static

◆ flatten() [2/2]

VectorDouble VectorHelper::flatten ( const VectorVectorDouble & vvd )

static

Method which flattens a VectorVectorDouble into a VectorDouble

Parameters

vvd	Input VectorVectorDouble

Returns: Returned VectorDouble

◆ flattenInPlace() [1/2]

void VectorHelper::flattenInPlace	(	const std::vector< std::vector< double > > &	vvd,
		std::vector< double > &	vd
	)

static

◆ flattenInPlace() [2/2]

void VectorHelper::flattenInPlace	(	const VectorVectorDouble &	vvd,
		VectorDouble &	vd
	)

static

◆ getMostSignificant()

void VectorHelper::getMostSignificant	(	const VectorDouble &	vec,
		double	tol = `EPSILON6`,
		int	nmax = `-1`
	)

static

Display the first significant values of the input vector. A "significant" value is a value larger than 'tol' in absolute value Values are listed by decreasing importance.

Parameters

vec	Input Vector
tol	Tolerance above which a value is significant (in absolute value)
nmax	Limit on the number of values printed (-1: no limit)

◆ hasUndefined()

bool VectorHelper::hasUndefined ( const VectorDouble & vec )

static

◆ initVDouble() [1/2]

VectorDouble VectorHelper::initVDouble	(	const double *	values,
		int	number
	)

static

◆ initVDouble() [2/2]

VectorDouble VectorHelper::initVDouble	(	int	nval,
		double	value = `0.`
	)

static

◆ initVInt() [1/2]

VectorInt VectorHelper::initVInt	(	const int *	values,
		int	number
	)

static

◆ initVInt() [2/2]

VectorInt VectorHelper::initVInt	(	int	nval,
		int	value = `0.`
	)

static

◆ initVString()

VectorString VectorHelper::initVString	(	int	ntab,
		char **	names
	)

static

◆ initVVDouble() [1/2]

VectorVectorDouble VectorHelper::initVVDouble	(	const double *	value,
		int	n1,
		int	n2
	)

static

◆ initVVDouble() [2/2]

VectorVectorDouble VectorHelper::initVVDouble	(	int	nval1,
		int	nval2,
		double	value = `0.`
	)

static

◆ initVVInt()

VectorVectorInt VectorHelper::initVVInt	(	int	nval1,
		int	nval2,
		int	value = `0`
	)

static

◆ innerProduct() [1/6]

double VectorHelper::innerProduct	(	const constvect	veca,
		const constvect	vecb
	)

static

◆ innerProduct() [2/6]

double VectorHelper::innerProduct	(	const double *	veca,
		const double *	vecb,
		int	size
	)

static

◆ innerProduct() [3/6]

double VectorHelper::innerProduct	(	const std::vector< double > &	veca,
		const std::vector< double > &	vecb,
		int	size = `-1`
	)

static

◆ innerProduct() [4/6]

double VectorHelper::innerProduct	(	const std::vector< std::vector< double > > &	x,
		const std::vector< std::vector< double > > &	y
	)

static

◆ innerProduct() [5/6]

double VectorHelper::innerProduct	(	const VectorDouble &	veca,
		const VectorDouble &	vecb,
		int	size = `-1`
	)

static

◆ innerProduct() [6/6]

double VectorHelper::innerProduct	(	const VectorVectorDouble &	x,
		const VectorVectorDouble &	y
	)

static

◆ inverse()

VectorDouble VectorHelper::inverse ( const VectorDouble & vec )

static

◆ isConstant() [1/2]

bool VectorHelper::isConstant	(	const VectorDouble &	vect,
		double	refval = `TEST`
	)

static

Check if the contents of a vector is constant (equal to 'refval' is defined)

Parameters

vect	Input vector
refval	Reference value (TEST if not defined)

Returns

◆ isConstant() [2/2]

bool VectorHelper::isConstant	(	const VectorInt &	vect,
		int	refval = `ITEST`
	)

static

Check if the contents of a vector is constant (equal to 'refval' is defined)

Parameters

vect	Input vector
refval	Reference value (ITEST if not defined)

Returns

◆ isEqual() [1/2]

bool VectorHelper::isEqual	(	const VectorDouble &	v1,
		const VectorDouble &	v2,
		double	eps = `EPSILON10`
	)

static

◆ isEqual() [2/2]

bool VectorHelper::isEqual	(	const VectorInt &	v1,
		const VectorInt &	v2
	)

static

◆ isEqualExtended()

bool VectorHelper::isEqualExtended	(	const VectorDouble &	v1,
		const VectorDouble &	v2,
		double	eps = `EPSILON10`,
		bool	flagRelative = `true`,
		bool	flagAbsolute = `false`,
		const String &	string = `""`
	)

static

Function checking that two values are equal This verbose option is essentially used in tests.

Parameters

v1	First value to be compared
v2	Second value to be compared
eps	Tolerance used for comparison
flagRelative	when True, the values are compared without paying attention to their sign
flagAbsolute	when True, test is run on absolute difference
string	Message to be displayed when the vectors are not similar

Returns: Boolean

Note: : When the two vectors do not share the same dimension, the test is not performed and a message is printed.

◆ isInList()

bool VectorHelper::isInList	(	const VectorInt &	vec,
		int	item
	)

static

◆ isSorted()

bool VectorHelper::isSorted	(	const VectorDouble &	vec,
		bool	ascending = `true`
	)

static

◆ linearCombinationInPlace()

void VectorHelper::linearCombinationInPlace	(	double	val1,
		const VectorDouble &	vd1,
		double	val2,
		const VectorDouble &	vd2,
		VectorDouble &	outv
	)

static

◆ linearCombinationVVDInPlace() [1/2]

void VectorHelper::linearCombinationVVDInPlace	(	double	val1,
		const std::vector< std::vector< double > > &	vvd1,
		double	val2,
		const std::vector< std::vector< double > > &	vvd2,
		std::vector< std::vector< double > > &	outv
	)

static

◆ linearCombinationVVDInPlace() [2/2]

void VectorHelper::linearCombinationVVDInPlace	(	double	val1,
		const VectorVectorDouble &	vvd1,
		double	val2,
		const VectorVectorDouble &	vvd2,
		VectorVectorDouble &	outv
	)

static

◆ maximum() [1/4]

double VectorHelper::maximum	(	const std::vector< std::vector< double > > &	vec,
		bool	flagAbs = `false`
	)

static

◆ maximum() [2/4]

double VectorHelper::maximum	(	const VectorDouble &	vec,
		bool	flagAbs = `false`,
		const VectorDouble &	aux = `VectorDouble()`,
		int	mode = `0`
	)

static

Calculate the maximum of 'vec' (conditionally to 'aux')

Parameters

vec	Target vector
flagAbs	When True, take the absolute value of 'vec' beforehand
aux	Conditional vector (see remarks)
mode	Comparison mode

Returns: Minimum value

Remarks: When 'aux' is defined, the maximum of 'vec' is conditional to 'aux'; - mode=0: statistics calculated only when 'vec' and 'aux' are both defined; - mode>0: statistics calculated only when 'vec' > 'aux'; - mode<0: statistics calculated only when 'vec' < 'aux'

◆ maximum() [3/4]

int VectorHelper::maximum	(	const VectorInt &	vec,
		bool	flagAbs = `false`
	)

static

◆ maximum() [4/4]

double VectorHelper::maximum	(	const VectorVectorDouble &	vec,
		bool	flagAbs = `false`
	)

static

◆ mean()

double VectorHelper::mean ( const VectorDouble & vec )

static

◆ mean1AndMean2ToStdev()

void VectorHelper::mean1AndMean2ToStdev	(	const VectorDouble &	mean1,
		const VectorDouble &	mean2,
		VectorDouble &	std,
		int	number
	)

static

◆ median()

double VectorHelper::median ( const VectorDouble & vec )

static

◆ mergeInPlace()

void VectorHelper::mergeInPlace	(	const VectorDouble &	vecin,
		VectorDouble &	vecout,
		int	start
	)

static

Merge 'vecin' into 'vecout' starting at address 'istart'

Parameters

vecin	Initial vector
vecout	Vector where 'vecin' should be copied
start	Starting address (in 'vecout')

◆ minimum() [1/3]

double VectorHelper::minimum	(	const VectorDouble &	vec,
		bool	flagAbs = `false`,
		const VectorDouble &	aux = `VectorDouble()`,
		int	mode = `0`
	)

static

Calculate the minimum of 'vec' (conditionally to 'aux')

Parameters

vec	Target vector
flagAbs	When True, take the absolute value of 'vec' beforehand
aux	Conditional vector (see remarks)
mode	Comparison mode

Returns: Minimum value

Remarks: When 'aux' is defined, the minimum of 'vec' is conditional to 'aux'; - mode=0: statistics calculated only when 'vec' and 'aux' are both defined; - mode>0: statistics calculated only when 'vec' > 'aux'; - mode<0: statistics calculated only when 'vec' < 'aux'

◆ minimum() [2/3]

int VectorHelper::minimum	(	const VectorInt &	vec,
		bool	flagAbs = `false`
	)

static

◆ minimum() [3/3]

double VectorHelper::minimum	(	const VectorVectorDouble &	vec,
		bool	flagAbs = `false`
	)

static

◆ multiplyConstant()

void VectorHelper::multiplyConstant	(	VectorDouble &	vec,
		double	v
	)

static

◆ multiplyConstantInPlace()

void VectorHelper::multiplyConstantInPlace	(	const VectorDouble &	vec,
		double	v,
		VectorDouble &	vecout
	)

static

◆ multiplyConstantSelfInPlace()

void VectorHelper::multiplyConstantSelfInPlace	(	VectorDouble &	vec,
		double	v
	)

static

◆ multiplyInPlace()

void VectorHelper::multiplyInPlace	(	VectorDouble &	vec,
		const VectorDouble &	v
	)

static

◆ norm() [1/2]

double VectorHelper::norm ( const std::vector< double > & vec )

static

◆ norm() [2/2]

double VectorHelper::norm ( const VectorDouble & vec )

static

◆ normalize() [1/2]

void VectorHelper::normalize	(	double *	tab,
		int	ntab
	)

static

◆ normalize() [2/2]

void VectorHelper::normalize	(	VectorDouble &	vec,
		int	norm = `2`
	)

static

◆ normalizeCodir()

void VectorHelper::normalizeCodir	(	int	ndim,
		VectorDouble &	codir
	)

static

Fix plausible values for the Direction coefficients. They must be defined and with norm equal to 1

Parameters

[in]	ndim	Space dimension
[in,out]	codir	Input/Output Direction coefficients

◆ normalizeFromGaussianDistribution()

void VectorHelper::normalizeFromGaussianDistribution	(	VectorDouble &	vec,
		double	mini = `0.`,
		double	maxi = `1.`
	)

static

◆ normalScore()

VectorDouble VectorHelper::normalScore	(	const VectorDouble &	data,
		const VectorDouble &	wt = `VectorDouble()`
	)

static

◆ normDistance()

double VectorHelper::normDistance	(	const VectorDouble &	veca,
		const VectorDouble &	vecb
	)

static

◆ norminf()

double VectorHelper::norminf ( const VectorDouble & vec )

static

◆ normL1()

double VectorHelper::normL1 ( const VectorDouble & vec )

static

◆ orderRanks() [1/2]

VectorInt VectorHelper::orderRanks	(	const VectorDouble &	vecin,
		bool	ascending = `true`,
		int	size = `-1`
	)

static

Returns the permutation which rearranges the input vector into any order

Parameters

vecin	Input vector
ascending	True for ascending order; False otherwise
size	Optional vector dimension

Returns: Vector of orders

◆ orderRanks() [2/2]

VectorInt VectorHelper::orderRanks	(	const VectorInt &	vecin,
		bool	ascending = `true`,
		int	size = `-1`
	)

static

Returns the permutation which rearranges the input vector into any order

Parameters

vecin	Input vector
ascending	True for ascending order; False otherwise
size	Optional dimension of the input vector

Returns: Vector of orders

◆ pnormVec()

VectorDouble VectorHelper::pnormVec ( const VectorDouble & vec )

static

◆ power()

VectorDouble VectorHelper::power	(	const VectorDouble &	vec,
		double	power
	)

static

◆ product() [1/2]

double VectorHelper::product ( const VectorDouble & vec )

static

◆ product() [2/2]

int VectorHelper::product ( const VectorInt & vec )

static

◆ qnormVec()

VectorDouble VectorHelper::qnormVec ( const VectorDouble & vec )

static

◆ quantiles()

VectorDouble VectorHelper::quantiles	(	const VectorDouble &	vec,
		const VectorDouble &	probas
	)

static

Calculate the quantiles

Parameters

vec	Array of values
probas	Array of probabilities (sorted by ascending order)

Returns: Vector of data values for the different probabilities

◆ rangeVals()

std::pair< double, double > VectorHelper::rangeVals ( const VectorDouble & vec )

static

◆ reduce()

VectorDouble VectorHelper::reduce	(	const VectorDouble &	vecin,
		const VectorInt &	vindex
	)

static

Reduce the input vector 'vecin' by suppressing the elements referred by 'index'

Parameters

vecin	Input vector (double)
vindex	Vector of indices to be suppressed

◆ reduceOne()

VectorDouble VectorHelper::reduceOne	(	const VectorDouble &	vecin,
		int	index
	)

static

Reduce the input vector 'vecin' by suppressing the element referred by 'index'

Parameters

vecin	Input vector (double)
index	Index to be suppressed

◆ reorder() [1/2]

VectorDouble VectorHelper::reorder	(	const VectorDouble &	vecin,
		const VectorInt &	order,
		int	size = `-1`
	)

static

◆ reorder() [2/2]

VectorInt VectorHelper::reorder	(	const VectorInt &	vecin,
		const VectorInt &	order,
		int	size = `-1`
	)

static

◆ revert() [1/2]

VectorDouble VectorHelper::revert ( const VectorDouble & vecin )

static

◆ revert() [2/2]

VectorInt VectorHelper::revert ( const VectorInt & vecin )

static

◆ sample()

VectorDouble VectorHelper::sample	(	const VectorDouble &	vecin,
		const VectorInt &	indKeep
	)

static

Create an output VectorDouble by selecting some indices of the Input VectorDouble 'vecin'.

Parameters

vecin	Input Rectangular Matrix
indKeep	Set of Indices to be kept (all if not defined)

◆ sampleRanks()

VectorInt VectorHelper::sampleRanks	(	int	ntotal,
		double	proportion = `0.`,
		int	number = `0`,
		int	seed = `242141`,
		int	optSort = `0`
	)

static

Sample a set of 'ntotal' ranks (unique occurrence)

Parameters

ntotal	Dimension to be sampled
proportion	Proportion of elected samples (in [0,1])
number	Number of elected samples
seed	Seed used for the random number generator
optSort	Sorting: 0 for None; 1 for Ascending; -1 for Descending

Returns: A vector of indices lying between 0 and ntotal-1. No duplicate.

Remarks: If 'proportion' and 'number' are not specified,; the output vector has dimension equal to 'ntotal'

◆ sequence() [1/2]

VectorDouble VectorHelper::sequence	(	double	valFrom,
		double	valTo,
		double	valStep = `1.`,
		double	ratio = `1.`
	)

static

Create an output vector going from 'valFrom' to 'ValTo' by step of 'valStep' Create a vector containing the a sequence of numbers

Parameters

valFrom	Starting value
valTo	Ending value
valStep	Step
ratio	The whole sequence can be ultimately scaled by 'ratio'

Returns

◆ sequence() [2/2]

VectorInt VectorHelper::sequence	(	int	number,
		int	ideb = `0`,
		int	step = `1`
	)

static

Create an output vector containing the 'number' consecutive numbers starting from 'ideb'

Parameters

number	Length of the output vector
ideb	Index of the first element of the output vector
step	Step between two consecutive values

◆ simulateBernoulli()

VectorDouble VectorHelper::simulateBernoulli	(	int	n = `1`,
		double	proba = `0.5`,
		double	vone = `1.`,
		double	velse = `0.`
	)

static

◆ simulateGaussian()

VectorDouble VectorHelper::simulateGaussian	(	int	n = `1`,
		double	mean = `0.`,
		double	sigma = `1.`
	)

static

◆ simulateGaussianInPlace() [1/2]

void VectorHelper::simulateGaussianInPlace	(	std::vector< double > &	vec,
		double	mean = `0.`,
		double	sigma = `1.`
	)

static

◆ simulateGaussianInPlace() [2/2]

void VectorHelper::simulateGaussianInPlace	(	VectorDouble &	vec,
		double	mean = `0.`,
		double	sigma = `1.`
	)

static

◆ simulateUniform()

VectorDouble VectorHelper::simulateUniform	(	int	n = `1`,
		double	mini = `0.`,
		double	maxi = `1.`
	)

static

◆ sort() [1/2]

VectorDouble VectorHelper::sort	(	const VectorDouble &	vecin,
		bool	ascending = `true`,
		int	size = `-1`
	)

static

◆ sort() [2/2]

VectorInt VectorHelper::sort	(	const VectorInt &	vecin,
		bool	ascending = `true`,
		int	size = `-1`
	)

static

◆ sortInPlace() [1/2]

void VectorHelper::sortInPlace	(	VectorDouble &	vecin,
		bool	ascending = `true`,
		int	size = `-1`
	)

static

◆ sortInPlace() [2/2]

void VectorHelper::sortInPlace	(	VectorInt &	vecin,
		bool	ascending = `true`,
		int	size = `-1`
	)

static

◆ sortRanks()

VectorInt VectorHelper::sortRanks	(	const VectorDouble &	vecin,
		bool	ascending = `true`,
		int	size = `-1`
	)

static

◆ squeezeAndStretchInPlaceBackward()

void VectorHelper::squeezeAndStretchInPlaceBackward	(	const VectorDouble &	vecin,
		VectorDouble &	vecout,
		double	origin,
		double	mesh,
		double	top,
		double	bot
	)

static

Operate the squeeze-and-stretch algorithm backward (see remarks)

Parameters

vecin	Input vector (in sugar box system)
vecout	Output vector (in structural system)
origin	Origin of the vertical axis (structural system)
mesh	Mesh of the vertical axis (structural system)
top	Elevation of the Top surface
bot	Elevation of the Bottom surface

Remarks: The information is contained in 'vecin' which is defined on a regular 1D grid; (characterized by 'base' and 'mesh'); Extend the relevant information, lying between 'bot' and 'top' in order to fill; the whole vector 'vecout'

◆ squeezeAndStretchInPlaceForward()

void VectorHelper::squeezeAndStretchInPlaceForward	(	const VectorDouble &	vecin,
		VectorDouble &	vecout,
		double	origin,
		double	mesh,
		double	top,
		double	bot
	)

static

Operate the squeeze-and-stretch algorithm forward (see remarks)

Parameters

vecin	Input vector (in structural system)
vecout	Output vector (in sugar box system)
origin	Origin of the vertical axis (structural system)
mesh	Mesh of the vertical axis (structural system)
top	Elevation of the Top surface
bot	Elevation of the Bottom surface

Remarks: The information is contained in 'vecin' which is defined on a regular 1D grid; in the structural system. The purpose is to sample the relevant sub-information; (between 'top' and 'bot') densely in 'vecout'

◆ stdv()

double VectorHelper::stdv	(	const VectorDouble &	vec,
		bool	scaleByN = `false`
	)

static

◆ subtract() [1/3]

VectorDouble VectorHelper::subtract	(	const VectorDouble &	veca,
		const VectorDouble &	vecb
	)

static

Return a vector containing vecb - veca

Parameters

veca	Input Vector
vecb	Input Vector

Returns

◆ subtract() [2/3]

VectorInt VectorHelper::subtract	(	const VectorInt &	veca,
		const VectorInt &	vecb
	)

static

Return a vector containing vecb - veca (integer version)

Parameters

veca	Input Vector
vecb	Input Vector

Returns

◆ subtract() [3/3]

VectorDouble VectorHelper::subtract	(	constvect	veca,
		constvect	vecb
	)

static

Return a vector containing vecb - veca

Parameters

veca	Input Vector
vecb	Input Vector

Returns

◆ subtractInPlace() [1/4]

void VectorHelper::subtractInPlace	(	const std::vector< std::vector< double > > &	in1,
		const std::vector< std::vector< double > > &	in2,
		std::vector< std::vector< double > > &	outv
	)

static

◆ subtractInPlace() [2/4]

void VectorHelper::subtractInPlace	(	const VectorVectorDouble &	in1,
		const VectorVectorDouble &	in2,
		VectorVectorDouble &	outv
	)

static

◆ subtractInPlace() [3/4]

void VectorHelper::subtractInPlace	(	VectorDouble &	dest,
		const VectorDouble &	src
	)

static

Performs: veca -= vecb

Parameters

dest	Input/Output vector
src	Auxiliary vector

◆ subtractInPlace() [4/4]

void VectorHelper::subtractInPlace	(	VectorInt &	dest,
		const VectorInt &	src
	)

static

◆ suppressTest()

VectorDouble VectorHelper::suppressTest ( const VectorDouble & vecin )

static

◆ toStringAsSpan()

String VectorHelper::toStringAsSpan ( constvect vec )

static

◆ toStringAsVD()

String VectorHelper::toStringAsVD ( const VectorDouble & vec )

static

◆ toStringAsVI()

String VectorHelper::toStringAsVI ( const VectorInt & vec )

static

◆ toStringAsVS()

String VectorHelper::toStringAsVS ( const VectorString & vec )

static

◆ toStringAsVVD()

String VectorHelper::toStringAsVVD ( const VectorVectorDouble & vec )

static

◆ transformVD()

void VectorHelper::transformVD	(	VectorDouble &	tab,
		int	oper_choice = `1`
	)

static

Transform a vector of double values as follows

Parameters

tab	Vector of double values
oper_choice	Operation on the diagonal term (see Utilities::operate_XXX)

◆ truncateDecimalsInPlace()

void VectorHelper::truncateDecimalsInPlace	(	VectorDouble &	vec,
		int	ndec
	)

static

◆ truncateDigitsInPlace()

void VectorHelper::truncateDigitsInPlace	(	VectorDouble &	vec,
		int	ndec
	)

static

◆ unflatten() [1/2]

std::vector< std::vector< double > > VectorHelper::unflatten	(	const std::vector< double > &	vd,
		const VectorInt &	sizes
	)

static

◆ unflatten() [2/2]

VectorVectorDouble VectorHelper::unflatten	(	const VectorDouble &	vd,
		const VectorInt &	sizes
	)

static

◆ unflattenInPlace()

void VectorHelper::unflattenInPlace	(	const std::vector< double > &	vd,
		std::vector< std::vector< double > > &	vvd
	)

static

◆ unique() [1/2]

VectorDouble VectorHelper::unique	(	const VectorDouble &	vecin,
		int	size = `-1`
	)

static

◆ unique() [2/2]

VectorInt VectorHelper::unique	(	const VectorInt &	vecin,
		int	size = `-1`
	)

static

◆ variance()

double VectorHelper::variance	(	const VectorDouble &	vec,
		bool	scaleByN = `false`
	)

static

◆ whereElement()

int VectorHelper::whereElement	(	const VectorInt &	tab,
		int	target
	)

static

◆ whereMaximum()

int VectorHelper::whereMaximum ( const VectorDouble & tab )

static

Find the location of the maximum value within a vector

Returns: Rank of the maximum value

Parameters

[in] tab Vector of values

◆ whereMinimum()

int VectorHelper::whereMinimum ( const VectorDouble & tab )

static

Find the location of the minimum value within a vector

Returns: Rank of the minimum value

Parameters

[in] tab Vector of values

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

include/Basic/VectorHelper.hpp
src/Basic/VectorHelper.cpp

Static Public Member Functions

Member Function Documentation

◆ add()

◆ addConstant() [1/2]

◆ addConstant() [2/2]

◆ addInPlace() [1/8]

◆ addInPlace() [2/8]

◆ addInPlace() [3/8]

◆ addInPlace() [4/8]

◆ addInPlace() [5/8]

◆ addInPlace() [6/8]

◆ addInPlace() [7/8]

◆ addInPlace() [8/8]

◆ addMultiplyConstantInPlace() [1/3]

◆ addMultiplyConstantInPlace() [2/3]

◆ addMultiplyConstantInPlace() [3/3]

◆ addMultiplyVectVectInPlace()

◆ addSquareInPlace()

◆ arrangeInPlace() [1/2]

◆ arrangeInPlace() [2/2]

◆ complement()

◆ compress()

◆ concatenate()

◆ copy() [1/4]

◆ copy() [2/4]

◆ copy() [3/4]

◆ copy() [4/4]

◆ correlation()

◆ count()

◆ countDefined()

◆ countUndefined()

◆ crossProduct3D()

◆ crossProduct3DInPlace()

◆ cumsum()

◆ cumul() [1/3]

◆ cumul() [2/3]

◆ cumul() [3/3]

◆ cumulate()

◆ cumulateInPlace()

◆ display() [1/4]

◆ display() [2/4]

◆ display() [3/4]

◆ display() [4/4]

◆ displayNNZ()

◆ displayRange() [1/2]

◆ displayRange() [2/2]

◆ displayStats()

◆ divideConstant()

◆ divideInPlace() [1/2]

◆ divideInPlace() [2/2]

◆ dump()

◆ extensionDiagonal()

◆ extractInPlace()

◆ fill() [1/3]

◆ fill() [2/3]

◆ fill() [3/3]

◆ fillUndef()

◆ filter()

◆ flatten() [1/2]

◆ flatten() [2/2]

◆ flattenInPlace() [1/2]

◆ flattenInPlace() [2/2]

◆ getMostSignificant()

◆ hasUndefined()

◆ initVDouble() [1/2]

◆ initVDouble() [2/2]

◆ initVInt() [1/2]

◆ initVInt() [2/2]

◆ initVString()

◆ initVVDouble() [1/2]

◆ initVVDouble() [2/2]

◆ initVVInt()

◆ innerProduct() [1/6]

◆ innerProduct() [2/6]

◆ innerProduct() [3/6]

◆ innerProduct() [4/6]

◆ innerProduct() [5/6]

◆ innerProduct() [6/6]

◆ inverse()

◆ isConstant() [1/2]