Mathematical Operators

Collaboration diagram for Mathematical Operators:

template<class T , size_t d>
std::array< T, d >	operator+ (const std::array< T, d > &x, const std::array< T, d > &y)
template<class T , size_t d>
std::array< T, d >	operator+ (const std::array< T, d > &x, const T &y)
template<class T , size_t d>
std::array< T, d >	operator+ (const T &x, const std::array< T, d > &y)
template<class T , size_t d, size_t e>
std::array< std::array< T, e >, d >	operator+ (const T &x, const std::array< std::array< T, e >, d > &y)
template<class T , size_t d, size_t e>
std::array< std::array< T, e >, d >	operator+ (const std::array< std::array< T, e >, d > &x, const T &y)
template<class T , size_t d>
std::array< T, d > &	operator+= (std::array< T, d > &x, const std::array< T, d > &y)
template<class T , size_t d>
std::array< T, d > &	operator+= (std::array< T, d > &x, const T &y)
template<class T , size_t d, size_t e>
std::array< std::array< T, e >, d > &	operator+= (std::array< std::array< T, e >, d > &x, const T &y)
template<class T , size_t d>
std::array< T, d >	operator- (const std::array< T, d > &x, const std::array< T, d > &y)
template<class T , size_t d>
std::array< T, d >	operator- (const std::array< T, d > &x, const T &y)
template<class T , size_t d>
std::array< T, d >	operator- (const T &x, const std::array< T, d > &y)
template<class T , size_t d, size_t e>
std::array< std::array< T, e >, d >	operator- (const T &x, const std::array< std::array< T, e >, d > &y)
template<class T , size_t d, size_t e>
std::array< std::array< T, e >, d >	operator- (const std::array< std::array< T, e >, d > &x, const T &y)
template<class T , size_t d>
std::array< T, d > &	operator-= (std::array< T, d > &x, const std::array< T, d > &y)
template<class T , size_t d>
std::array< T, d > &	operator-= (std::array< T, d > &x, const T &y)
template<class T , size_t d, size_t e>
std::array< std::array< T, e >, d > &	operator-= (std::array< std::array< T, e >, d > &x, const T &y)
template<class T , size_t d>
std::array< T, d >	operator* (const std::array< T, d > &x, const std::array< T, d > &y)
template<class T , size_t d>
std::array< T, d >	operator* (const std::array< T, d > &x, const T &y)
template<class T , size_t d>
std::array< T, d >	operator* (const T &x, const std::array< T, d > &y)
template<class T , size_t d, size_t e>
std::array< std::array< T, e >, d >	operator* (const T &x, const std::array< std::array< T, e >, d > &y)
template<class T , size_t d, size_t e>
std::array< std::array< T, e >, d >	operator* (const std::array< std::array< T, e >, d > &x, const T &y)
template<class T , size_t d>
std::array< T, d > &	operator*= (std::array< T, d > &x, const std::array< T, d > &y)
template<class T , size_t d>
std::array< T, d > &	operator*= (std::array< T, d > &x, const T &y)
template<class T , size_t d, size_t e>
std::array< std::array< T, e >, d > &	operator*= (std::array< std::array< T, e >, d > &x, const T &y)
template<class T , size_t d>
std::array< T, d >	operator/ (const std::array< T, d > &x, const std::array< T, d > &y)
template<class T , size_t d>
std::array< T, d >	operator/ (const std::array< T, d > &x, const T &y)
template<class T , size_t d>
std::array< T, d >	operator/ (const T &x, const std::array< T, d > &y)
template<class T , size_t d, size_t e>
std::array< std::array< T, e >, d >	operator/ (const T &x, const std::array< std::array< T, e >, d > &y)
template<class T , size_t d, size_t e>
std::array< std::array< T, e >, d >	operator/ (const std::array< std::array< T, e >, d > &x, const T &y)
template<class T , size_t d>
std::array< T, d > &	operator/= (std::array< T, d > &x, const std::array< T, d > &y)
template<class T , size_t d>
std::array< T, d > &	operator/= (std::array< T, d > &x, const T &y)
template<class T , size_t d, size_t e>
std::array< std::array< T, e >, d > &	operator/= (std::array< std::array< T, e >, d > &x, const T &y)
template<class T >
std::vector< T >	operator+ (const std::vector< T > &x, const std::vector< T > &y)
template<class T >
std::vector< T >	operator+ (const std::vector< T > &x, const T &y)
template<class T >
std::vector< T >	operator+ (const T &x, const std::vector< T > &y)
template<class T >
std::vector< std::vector< T > >	operator+ (const std::vector< std::vector< T > > &x, const T &y)
template<class T >
std::vector< std::vector< T > >	operator+ (const T &x, const std::vector< std::vector< T > > &y)
template<class T >
std::vector< T > &	operator+= (std::vector< T > &x, const std::vector< T > &y)
template<class T >
std::vector< T > &	operator+= (std::vector< T > &x, const T &y)
template<class T >
std::vector< std::vector< T > > &	operator+= (std::vector< std::vector< T > > &x, const T &y)
template<class T >
std::vector< T >	operator- (const std::vector< T > &x, const std::vector< T > &y)
template<class T >
std::vector< T >	operator- (const std::vector< T > &x, const T &y)
template<class T >
std::vector< T >	operator- (const T &x, const std::vector< T > &y)
template<class T >
std::vector< std::vector< T > >	operator- (const T &x, const std::vector< std::vector< T > > &y)
template<class T >
std::vector< std::vector< T > >	operator- (const std::vector< std::vector< T > > &x, const T &y)
template<class T >
std::vector< T > &	operator-= (std::vector< T > &x, const std::vector< T > &y)
template<class T >
std::vector< T > &	operator-= (std::vector< T > &x, const T &y)
template<class T >
std::vector< std::vector< T > > &	operator-= (std::vector< std::vector< T > > &x, const T &y)
template<class T >
std::vector< T >	operator* (const std::vector< T > &x, const std::vector< T > &y)
template<class T >
std::vector< T >	operator* (const std::vector< T > &x, const T &y)
template<class T >
std::vector< T >	operator* (const T &x, const std::vector< T > &y)
template<class T >
std::vector< std::vector< T > >	operator* (const T &x, const std::vector< std::vector< T > > &y)
template<class T >
std::vector< std::vector< T > >	operator* (const std::vector< std::vector< T > > &x, const T &y)
template<class T >
std::vector< T > &	operator*= (std::vector< T > &x, const std::vector< T > &y)
template<class T >
std::vector< T > &	operator*= (std::vector< T > &x, const T &y)
template<class T >
std::vector< std::vector< T > > &	operator*= (std::vector< std::vector< T > > &x, const T &y)
template<class T >
std::vector< T >	operator/ (const std::vector< T > &x, const std::vector< T > &y)
template<class T >
std::vector< T >	operator/ (const std::vector< T > &x, const T &y)
template<class T >
std::vector< T >	operator/ (const T &x, const std::vector< T > &y)
template<class T >
std::vector< std::vector< T > >	operator/ (const T &x, const std::vector< std::vector< T > > &y)
template<class T >
std::vector< std::vector< T > >	operator/ (const std::vector< std::vector< T > > &x, const T &y)
template<class T >
std::vector< T > &	operator/= (std::vector< T > &x, const std::vector< T > &y)
template<class T >
std::vector< T > &	operator/= (std::vector< T > &x, const T &y)
template<class T >
std::vector< std::vector< T > > &	operator/= (std::vector< std::vector< T > > &x, const T &y)

Detailed Description

Function Documentation

operator*() [1/10]

template<class T , size_t d, size_t e>

std::array< std::array< T, e >, d > operator*	(	const std::array< std::array< T, e >, d > &	x,
		const T &	y )

Operator* for std::array.

Perform the element-wise product between a array of arrays (x) and a constant (y), and returns z s.t. z[i][j] = x[i][j] * y for all j = 0, ..., e-1, i = 0, ..., d-1 where d = x.size(). Template parameters, T, can by any type for which the operator* is defined.

The element-wise product is performed recursively, i.e. if x[i][j] and y are std::array, operator* calls itself to perform the element-wise product between x[i][j] and y.

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

array of arrays having the same dimensions of x and storing the element-wise product between x and y.

Definition at line 871 of file Operators_array.tpp.

operator*() [2/10]

template<class T , size_t d>

std::array< T, d > operator*	(	const std::array< T, d > &	x,
		const std::array< T, d > &	y )

Operator* for std::array.

Perform the element-wise product between two arrays (x and y) and returns a array z s.t. z[i] = x[i] * y[i] for all i = 0, ..., d-1 where d = min(x.size(), y.size(). Template parameters, T, can by any type for which the operator* is defined.

The element-wise product is performed recursively, i.e. if the i-th element of x and the i-th element of y are std::array, operator* calls itself to perform the element-wise product between x[i] and y[i].

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

array with d elements, storing the element-wise product between x and y.

Definition at line 715 of file Operators_array.tpp.

operator*() [3/10]

template<class T , size_t d>

std::array< T, d > operator*	(	const std::array< T, d > &	x,
		const T &	y )

Operator* for std::array.

Perform the element-wise product between a array (x) and a constant (y), and returns a array (z) s.t. z[i] = x[i] * y for all i = 0, ..., d-1 where d = x.size(). Template parameters, T, can by any type for which the operator* is defined.

The element-wise product is performed recursively, i.e. if the i-th element of x and y are std::array, operator* calls itself to perform the element-wise product between x[i] and y.

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

array with d elements, storing the element-wise product between x and y.

Definition at line 754 of file Operators_array.tpp.

operator*() [4/10]

template<class T >

std::vector< std::vector< T > > operator*	(	const std::vector< std::vector< T > > &	x,
		const T &	y )

Operator* for std::vector.

Perform the element-wise product between a vector of vectors (x) and a constant (y), and returns z s.t. z[i][j] = x[i][j] * y for all j = 0, ..., x[i].size()-1, i = 0, ..., n-1 where n = x.size(). Template parameters, T, can by any type for which the operator* is defined.

The element-wise product is performed recursively, i.e. if x[i][j] and y are std::vector, operator* calls itself to perform the element-wise product between x[i][j] and y.

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

vector of vectors having the same dimensions of x and storing the element-wise product between x and y.

Definition at line 862 of file Operators_vector.tpp.

operator*() [5/10]

template<class T >

std::vector< T > operator*	(	const std::vector< T > &	x,
		const std::vector< T > &	y )

Operator* for std::vector.

Perform the element-wise product between two vectors (x and y) and returns a vector z s.t. z[i] = x[i] * y[i] for all i = 0, ..., n-1 where n = min(x.size(), y.size(). Template parameters, T, can by any type for which the operator* is defined.

The element-wise product is performed recursively, i.e. if the i-th element of x and the i-th element of y are std::vector, operator* calls itself to perform the element-wise product between x[i] and y[i].

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

vector with n elements, storing the element-wise product between x and y.

Definition at line 703 of file Operators_vector.tpp.

operator*() [6/10]

template<class T >

std::vector< T > operator*	(	const std::vector< T > &	x,
		const T &	y )

Operator* for std::vector.

Perform the element-wise product between a vector (x) and a constant (y), and returns a vector (z) s.t. z[i] = x[i] * y for all i = 0, ..., n-1 where n = x.size(). Template parameters, T, can by any type for which the operator* is defined.

The element-wise product is performed recursively, i.e. if the i-th element of x and y are std::vector, operator* calls itself to perform the element-wise product between x[i] and y.

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

vector with n elements, storing the element-wise product between x and y.

Definition at line 743 of file Operators_vector.tpp.

operator*() [7/10]

template<class T , size_t d, size_t e>

std::array< std::array< T, e >, d > operator*	(	const T &	x,
		const std::array< std::array< T, e >, d > &	y )

Operator* for std::array.

Perform the element-wise product between a constant (y) and a array of arrays (y), and returns z s.t. z[i][j] = x * y[i][j] for all j = 0, ..., e-1, i = 0, ..., d-1 where d = y.size(). Template parameters, T, can by any type for which the operator* is defined.

The element-wise product is performed recursively, i.e. if y[i][j] and y are std::array, operator* calls itself to perform the element-wise product between y[i][j] and x.

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

array of arrays having the same dimensions of y and storing the element-wise product between x and y.

Definition at line 831 of file Operators_array.tpp.

operator*() [8/10]

template<class T , size_t d>

std::array< T, d > operator*	(	const T &	x,
		const std::array< T, d > &	y )

Operator* for std::array.

Perform the element-wise product between a constant (x), and a array (y) and returns a array (z) s.t. z[i] = x * y[i] for all i = 0, ..., d-1 where d = y.size(). Template parameters, T, can by any type for which the operator* is defined.

The element-wise product is performed recursively, i.e. if the i-th element of y and x are std::array, operator* calls itself to perform the element-wise product between x[i] and y.

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

array with d elements, storing the element-wise product between x and y.

Definition at line 793 of file Operators_array.tpp.

operator*() [9/10]

template<class T >

std::vector< std::vector< T > > operator*	(	const T &	x,
		const std::vector< std::vector< T > > &	y )

Operator* for std::vector.

Perform the element-wise product between a constant (y) and a vector of vectors (y), and returns z s.t. z[i][j] = x * y[i][j] for all j = 0, ..., y[i].size()-1, i = 0, ..., n-1 where n = y.size(). Template parameters, T, can by any type for which the operator* is defined.

The element-wise product is performed recursively, i.e. if y[i][j] and y are std::vector, operator* calls itself to perform the element-wise product between y[i][j] and x.

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

vector of vectors having the same dimensions of y and storing the element-wise product between x and y.

Definition at line 821 of file Operators_vector.tpp.

operator*() [10/10]

template<class T >

std::vector< T > operator*	(	const T &	x,
		const std::vector< T > &	y )

Operator* for std::vector.

Perform the element-wise product between a constant (x), and a vector (y) and returns a vector (z) s.t. z[i] = x * y[i] for all i = 0, ..., n-1 where n = y.size(). Template parameters, T, can by any type for which the operator* is defined.

The element-wise product is performed recursively, i.e. if the i-th element of y and x are std::vector, operator* calls itself to perform the element-wise product between x[i] and y.

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

vector with n elements, storing the element-wise product between x and y.

Definition at line 783 of file Operators_vector.tpp.

operator*=() [1/6]

template<class T , size_t d, size_t e>

std::array< std::array< T, e >, d > & operator*=	(	std::array< std::array< T, e >, d > &	x,
		const T &	y )

Operator*= for std::array.

Increment each element in the input array, using the value on the r.h.s. as increment, i.e.: x[i][j] *= y for all j = 0, ..., e-1, i = 0, ..., d-1 Template parameters, T, can by any type for which the operator*= is defined.

The element-wise increment is performed recursively, i.e. if x[i][j] and y are std::array, operator*= calls itself to increment x[i][j][k] by y[k], k = 0, ... , x.size()-1

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

first argument incremented with r.h.s. values.

Definition at line 987 of file Operators_array.tpp.

operator*=() [2/6]

template<class T , size_t d>

std::array< T, d > & operator*=	(	std::array< T, d > &	x,
		const std::array< T, d > &	y )

Operator*= for std::array.

Increment each element in the input array, using the corresping value on array at the r.h.s. as increment, i.e.: x[i] *= y[i] for all i = 0, ..., d-1 Template parameters, T, can by any type for which the operator+= is defined.

The element-wise increment is performed recursively, i.e. if the i-th element of x and the i-th element of y are std::array, operator*= calls itself to increment x[i][j] by y[i][j], j = 0, ..., x[i].size()-1

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

first argument incremented with r.h.s. values.

Definition at line 911 of file Operators_array.tpp.

operator*=() [3/6]

template<class T , size_t d>

std::array< T, d > & operator*=	(	std::array< T, d > &	x,
		const T &	y )

Operator*= for std::array.

Increment each element in the input array, using the value on the r.h.s. as increment, i.e.: x[i] *= y for all i = 0, ..., d-1 Template parameters, T, can by any type for which the operator*= is defined.

The element-wise increment is performed recursively, i.e. if the i-th element of x and y are std::array, operator*= calls itself to increment x[i][j] by y[j], j = 0, ... , x[i].size()-1

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

first argument incremented with r.h.s. values.

Definition at line 949 of file Operators_array.tpp.

operator*=() [4/6]

template<class T >

std::vector< std::vector< T > > & operator*=	(	std::vector< std::vector< T > > &	x,
		const T &	y )

Operator*= for std::vector.

Increment each element in the input vector, using the value on the r.h.s. as increment, i.e.: x[i][j] *= y for all j = 0, ..., x[i].size()-1, i = 0, ..., n-1 where n = x.size(). Template parameters, T, can by any type for which the operator*= is defined.

The element-wise increment is performed recursively, i.e. if x[i][j] and y are std::vector, operator*= calls itself to increment x[i][j][k] by y[k], k = 0, ... , min(x[i][j].size(), y.size())-1

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

first argument incremented with r.h.s. values.

Definition at line 979 of file Operators_vector.tpp.

operator*=() [5/6]

template<class T >

std::vector< T > & operator*=	(	std::vector< T > &	x,
		const std::vector< T > &	y )

Operator*= for std::vector.

Increment each element in the input vector, using the corresping value on vector at the r.h.s. as increment, i.e.: x[i] *= y[i] for all i = 0, ..., n-1 where n = min(x.size(), y.size(). Template parameters, T, can by any type for which the operator*= is defined.

The element-wise increment is performed recursively, i.e. if the i-th element of x and the i-th element of y are std::vector, operator*= calls itself to increment x[i][j] by y[i][j], j = 0, ..., min(x[i].size(), y[i].size())-1

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

first argument incremented with r.h.s. values.

Definition at line 901 of file Operators_vector.tpp.

operator*=() [6/6]

template<class T >

std::vector< T > & operator*=	(	std::vector< T > &	x,
		const T &	y )

Operator*= for std::vector.

Increment each element in the input vector, using the value on the r.h.s. as increment, i.e.: x[i] *= y for all i = 0, ..., n-1 where n = x.size(). Template parameters, T, can by any type for which the operator*= is defined.

The element-wise increment is performed recursively, i.e. if the i-th element of x and y are std::vector, operator*= calls itself to increment x[i][j] by y[j], j = 0, ... , min(x[i].size(), y.size())-1

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

first argument incremented with r.h.s. values.

Definition at line 940 of file Operators_vector.tpp.

operator+() [1/10]

template<class T , size_t d, size_t e>

std::array< std::array< T, e >, d > operator+	(	const std::array< std::array< T, e >, d > &	x,
		const T &	y )

Operator+ for std::array.

Perform the element-wise sum between a constant (y) and a array of arrays (y), and returns z s.t. z[i][j] = x + y[i][j] for all j = 0, ..., e-1, i = 0, ..., d-1 where d = y.size(). Template parameters, T, can by any type for which the operator+ is defined.

The element-wise sum is performed recursively, i.e. if y[i][j] and y are std::array, operator+ calls itself to perform the element-wise sum between y[i][j] and x.

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

array of arrays having the same dimensions of y and storing the element-wise sum of x and y.

Definition at line 230 of file Operators_array.tpp.

operator+() [2/10]

template<class T , size_t d>

std::array< T, d > operator+	(	const std::array< T, d > &	x,
		const std::array< T, d > &	y )

Operator+ for std::array

Perform the element-wise sum between two arrays (x and y) and returns a array z s.t. z[i] = x[i] + y[i] for all i = 0, ..., d where d = x.size() = y.size(). Template parameters, T, can by any type for which the operator+ is defined.

The element-wise sum is performed recursively, i.e. if the i-th element of x and the i-th element of y are std::array, operator+ calls itself to perform the element-wise sum between x[i] and y[i].

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

array with d elements, storing the element-wise sum of x and y.

Definition at line 74 of file Operators_array.tpp.

operator+() [3/10]

template<class T , size_t d>

std::array< T, d > operator+	(	const std::array< T, d > &	x,
		const T &	y )

Operator+ for std::array.

Perform the element-wise sum between a array (x) and a constant (y), and returns a array (z) s.t. z[i] = x[i] + y for all i = 0, ..., d where d = x.size(). Template parameters, T, can by any type for which the operator+ is defined.

The element-wise sum is performed recursively, i.e. if the i-th element of x and y are std::array, operator+ calls itself to perform the element-wise sum between x[i] and y.

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

array with d elements, storing the element-wise sum of x and y.

Definition at line 113 of file Operators_array.tpp.

operator+() [4/10]

template<class T >

std::vector< std::vector< T > > operator+	(	const std::vector< std::vector< T > > &	x,
		const T &	y )

Operator+ for std::vector.

Perform the element-wise sum between a vector of vectors (x) and a constant (y), and returns z s.t. z[i][j] = x[i][j] + y for all j = 0, ..., x[i].size()-1, i = 0, ..., n-1 where n = x.size(). Template parameters, T, can by any type for which the operator+ is defined.

The element-wise sum is performed recursively, i.e. if x[i][j] and y are std::vector, operator+ calls itself to perform the element-wise sum between x[i][j] and y.

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

vector of vectors having the same dimensions of x and storing the element-wise sum of x and y.

Definition at line 187 of file Operators_vector.tpp.

operator+() [5/10]

template<class T >

std::vector< T > operator+	(	const std::vector< T > &	x,
		const std::vector< T > &	y )

Operator+ for std::vector.

Perform the element-wise sum between two vectors (x and y) and returns a vector z s.t. z[i] = x[i] + y[i] for all i = 0, ..., n-1 where n = std::min(x.size(), y.size(). Template parameters, T, can by any type for which the operator+ is defined.

The element-wise sum is performed recursively, i.e. if the i-th element of x and the i-th element of y are std::vector, operator+ calls itself to perform the element-wise sum between x[i] and y[i].

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

vector with n elements, storing the element-wise sum of x and y.

Definition at line 69 of file Operators_vector.tpp.

operator+() [6/10]

template<class T >

std::vector< T > operator+	(	const std::vector< T > &	x,
		const T &	y )

Operator+ for std::vector.

Perform the element-wise sum between a vector (x) and a constant (y), and returns a vector (z) s.t. z[i] = x[i] + y for all i = 0, ..., n-1 where n = x.size(). Template parameters, T, can by any type for which the operator+ is defined.

The element-wise sum is performed recursively, i.e. if the i-th element of x and y are std::vector, operator+ calls itself to perform the element-wise sum between x[i] and y.

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

vector with n elements, storing the element-wise sum of x and y.

Definition at line 109 of file Operators_vector.tpp.

operator+() [7/10]

template<class T , size_t d, size_t e>

std::array< std::array< T, e >, d > operator+	(	const T &	x,
		const std::array< std::array< T, e >, d > &	y )

Operator+ for std::array.

Perform the element-wise sum between a array of arrays (x) and a constant (y), and returns z s.t. z[i][j] = x[i][j] + y for all j = 0, ..., e-1, i = 0, ..., d-1 where d = x.size(). Template parameters, T, can by any type for which the operator+ is defined.

The element-wise sum is performed recursively, i.e. if x[i][j] and y are std::array, operator+ calls itself to perform the element-wise sum between x[i][j] and y.

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

array of arrays having the same dimensions of x and storing the element-wise sum of x and y.

Definition at line 190 of file Operators_array.tpp.

operator+() [8/10]

template<class T , size_t d>

std::array< T, d > operator+	(	const T &	x,
		const std::array< T, d > &	y )

Operator+ for std::array.

Perform the element-wise sum between a constant (x), and a array (y) and returns a array (z) s.t. z[i] = x + y[i] for all i = 0, ..., d where d = y.size(). Template parameters, T, can by any type for which the operator+ is defined.

The element-wise sum is performed recursively, i.e. if the i-th element of y and x are std::array, operator+ calls itself to perform the element-wise sum between x[i] and y.

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

array with d elements, storing the element-wise sum of x and y.

Definition at line 152 of file Operators_array.tpp.

operator+() [9/10]

template<class T >

std::vector< std::vector< T > > operator+	(	const T &	x,
		const std::vector< std::vector< T > > &	y )

Operator+ for std::vector.

Perform the element-wise sum between a constant (y) and a vector of vectors (y), and returns z s.t. z[i][j] = x + y[i][j] for all j = 0, ..., y[i].size()-1, i = 0, ..., n-1 where n = y.size(). Template parameters, T, can by any type for which the operator+ is defined.

The element-wise sum is performed recursively, i.e. if y[i][j] and y are std::vector, operator+ calls itself to perform the element-wise sum between y[i][j] and x.

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

vector of vectors having the same dimensions of y and storing the element-wise sum of x and y.

Definition at line 228 of file Operators_vector.tpp.

operator+() [10/10]

template<class T >

std::vector< T > operator+	(	const T &	x,
		const std::vector< T > &	y )

Operator+ for std::vector.

Perform the element-wise sum between a constant (x), and a vector (y) and returns a vector (z) s.t. z[i] = x + y[i] for all i = 0, ..., n-1 where n = y.size(). Template parameters, T, can by any type for which the operator+ is defined.

The element-wise sum is performed recursively, i.e. if the i-th element of y and x are std::vector, operator+ calls itself to perform the element-wise sum between x[i] and y.

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

vector with n elements, storing the element-wise sum of x and y.

Definition at line 149 of file Operators_vector.tpp.

operator+=() [1/6]

template<class T , size_t d, size_t e>

std::array< std::array< T, e >, d > & operator+=	(	std::array< std::array< T, e >, d > &	x,
		const T &	y )

Operator+= for std::array.

Increment each element in the input array, using the value on the r.h.s. as increment, i.e.: x[i][j] += y for all j = 0, ..., e-1, i = 0, ..., d-1 Template parameters, T, can by any type for which the operator+= is defined.

The element-wise increment is performed recursively, i.e. if x[i][j] and y are std::array, operator+= calls itself to increment x[i][j][k] by y[k], k = 0, ... , x.size()-1

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

first argument incremented with r.h.s. values.

Definition at line 344 of file Operators_array.tpp.

operator+=() [2/6]

template<class T , size_t d>

std::array< T, d > & operator+=	(	std::array< T, d > &	x,
		const std::array< T, d > &	y )

Operator+= for std::array.

Increment each element in the input array, using the corresping value on array at the r.h.s. as increment, i.e.: x[i] += y[i] for all i = 0, ..., d-1 Template parameters, T, can by any type for which the operator+= is defined.

The element-wise increment is performed recursively, i.e. if the i-th element of x and the i-th element of y are std::array, operator+= calls itself to increment x[i][j] by y[i][j], j = 0, ..., x[i].size()-1

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

first argument incremented with r.h.s. values.

Definition at line 268 of file Operators_array.tpp.

operator+=() [3/6]

template<class T , size_t d>

std::array< T, d > & operator+=	(	std::array< T, d > &	x,
		const T &	y )

Operator+= for std::array.

Increment each element in the input array, using the value on the r.h.s. as increment, i.e.: x[i] += y for all i = 0, ..., d-1 Template parameters, T, can by any type for which the operator+= is defined.

The element-wise increment is performed recursively, i.e. if the i-th element of x and y are std::array, operator+= calls itself to increment x[i][j] by y[j], j = 0, ... , x[i].size()-1

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

first argument incremented with r.h.s. values.

Definition at line 306 of file Operators_array.tpp.

operator+=() [4/6]

template<class T >

std::vector< std::vector< T > > & operator+=	(	std::vector< std::vector< T > > &	x,
		const T &	y )

Operator+= for std::vector.

Increment each element in the input vector, using the value on the r.h.s. as increment, i.e.: x[i][j] += y for all j = 0, ..., x[i].size()-1, i = 0, ..., n-1 where n = x.size(). Template parameters, T, can by any type for which the operator+= is defined.

The element-wise increment is performed recursively, i.e. if x[i][j] and y are std::vector, operator+= calls itself to increment x[i][j][k] by y[k], k = 0, ... , min(x[i][j].size(), y.size())-1

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

first argument incremented with r.h.s. values.

Definition at line 345 of file Operators_vector.tpp.

operator+=() [5/6]

template<class T >

std::vector< T > & operator+=	(	std::vector< T > &	x,
		const std::vector< T > &	y )

Operator+= for std::vector.

Increment each element in the input vector, using the corresping value on vector at the r.h.s. as increment, i.e.: x[i] += y[i] for all i = 0, ..., n-1 where n = min(x.size(), y.size(). Template parameters, T, can by any type for which the operator+= is defined.

The element-wise increment is performed recursively, i.e. if the i-th element of x and the i-th element of y are std::vector, operator+= calls itself to increment x[i][j] by y[i][j], j = 0, ..., min(x[i].size(), y[i].size())-1

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

first argument incremented with r.h.s. values.

Definition at line 267 of file Operators_vector.tpp.

operator+=() [6/6]

template<class T >

std::vector< T > & operator+=	(	std::vector< T > &	x,
		const T &	y )

Operator+= for std::vector.

Increment each element in the input vector, using the value on the r.h.s. as increment, i.e.: x[i] += y for all i = 0, ..., n-1 where n = x.size(). Template parameters, T, can by any type for which the operator+= is defined.

The element-wise increment is performed recursively, i.e. if the i-th element of x and y are std::vector, operator+= calls itself to increment x[i][j] by y[j], j = 0, ... , min(x[i].size(), y.size())-1

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

first argument incremented with r.h.s. values.

Definition at line 306 of file Operators_vector.tpp.

operator-() [1/10]

template<class T , size_t d, size_t e>

std::array< std::array< T, e >, d > operator-	(	const std::array< std::array< T, e >, d > &	x,
		const T &	y )

Operator- for std::array.

Perform the element-wise difference between a array of arrays (x) and a constant (y), and returns z s.t. z[i][j] = x[i][j] - y for all j = 0, ..., e-1, i = 0, ..., d-1 where n = x.size(). Template parameters, T, can by any type for which the operator- is defined.

The element-wise difference is performed recursively, i.e. if x[i][j] and y are std::array, operator. calls itself to perform the element-wise difference between x[i][j] and y.

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

array of arrays having the same dimensions of x and storing the element-wise difference between x and y.

Definition at line 541 of file Operators_array.tpp.

operator-() [2/10]

template<class T , size_t d>

std::array< T, d > operator-	(	const std::array< T, d > &	x,
		const std::array< T, d > &	y )

Operator- for std::array.

Perform the element-wise difference between two arrays (x and y) and returns a array z s.t. z[i] = x[i] - y[i] for all i = 0, ..., d-1 where d = min(x.size(), y.size(). Template parameters, T, can by any type for which the operator- is defined.

The element-wise difference is performed recursively, i.e. if the i-th element of x and the i-th element of y are std::array, operator- calls itself to perform the element-wise difference between x[i] and y[i].

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

array with n elements, storing the element-wise difference between x and y.

Definition at line 385 of file Operators_array.tpp.

operator-() [3/10]

template<class T , size_t d>

std::array< T, d > operator-	(	const std::array< T, d > &	x,
		const T &	y )

Operator- for std::array.

Perform the element-wise difference between a array (x) and a constant (y), and returns a array (z) s.t. z[i] = x[i] - y for all i = 0, ..., d-1 where d = x.size(). Template parameters, T, can by any type for which the operator- is defined.

The element-wise difference is performed recursively, i.e. if the i-th element of x and y are std::array, operator- calls itself to perform the element-wise difference between x[i] and y.

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

array with d elements, storing the element-wise difference between x and y.

Definition at line 424 of file Operators_array.tpp.

operator-() [4/10]

template<class T >

std::vector< std::vector< T > > operator-	(	const std::vector< std::vector< T > > &	x,
		const T &	y )

Operator- for std::vector.

Perform the element-wise difference between a vector of vectors (x) and a constant (y), and returns z s.t. z[i][j] = x[i][j] - y for all j = 0, ..., x[i].size()-1, i = 0, ..., n-1 where n = x.size(). Template parameters, T, can by any type for which the operator- is defined.

The element-wise difference is performed recursively, i.e. if x[i][j] and y are std::vector, operator. calls itself to perform the element-wise difference between x[i][j] and y.

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

vector of vectors having the same dimensions of x and storing the element-wise difference between x and y.

Definition at line 545 of file Operators_vector.tpp.

operator-() [5/10]

template<class T >

std::vector< T > operator-	(	const std::vector< T > &	x,
		const std::vector< T > &	y )

Operator- for std::vector.

Perform the element-wise difference between two vectors (x and y) and returns a vector z s.t. z[i] = x[i] - y[i] for all i = 0, ..., n-1 where n = min(x.size(), y.size(). Template parameters, T, can by any type for which the operator- is defined.

The element-wise difference is performed recursively, i.e. if the i-th element of x and the i-th element of y are std::vector, operator- calls itself to perform the element-wise difference between x[i] and y[i].

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

vector with n elements, storing the element-wise difference between x and y.

Definition at line 386 of file Operators_vector.tpp.

operator-() [6/10]

template<class T >

std::vector< T > operator-	(	const std::vector< T > &	x,
		const T &	y )

Operator- for std::vector.

Perform the element-wise difference between a vector (x) and a constant (y), and returns a vector (z) s.t. z[i] = x[i] - y for all i = 0, ..., n-1 where n = x.size(). Template parameters, T, can by any type for which the operator- is defined.

The element-wise difference is performed recursively, i.e. if the i-th element of x and y are std::vector, operator- calls itself to perform the element-wise difference between x[i] and y.

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

vector with n elements, storing the element-wise difference between x and y.

Definition at line 426 of file Operators_vector.tpp.

operator-() [7/10]

template<class T , size_t d, size_t e>

std::array< std::array< T, e >, d > operator-	(	const T &	x,
		const std::array< std::array< T, e >, d > &	y )

Operator- for std::array.

Perform the element-wise difference between a constant (y) and a array of arrays (y), and returns z s.t. z[i][j] = x - y[i][j] for all j = 0, ..., e-1, i = 0, ..., d-1 where d = y.size(). Template parameters, T, can by any type for which the operator- is defined.

The element-wise difference is performed recursively, i.e. if y[i][j] and y are std::array, operator- calls itself to perform the element-wise difference between y[i][j] and x.

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

array of arrays having the same dimensions of y and storing the element-wise difference between x and y.

Definition at line 501 of file Operators_array.tpp.

operator-() [8/10]

template<class T , size_t d>

std::array< T, d > operator-	(	const T &	x,
		const std::array< T, d > &	y )

Operator- for std::array.

Perform the element-wise difference between a constant (x), and a array (y) and returns a array (z) s.t. z[i] = x - y[i] for all i = 0, ..., d-1 where d = y.size(). Template parameters, T, can by any type for which the operator- is defined.

The element-wise difference is performed recursively, i.e. if the i-th element of y and x are std::array, operator- calls itself to perform the element-wise difference between x[i] and y.

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

array with d elements, storing the element-wise difference between x and y.

Definition at line 463 of file Operators_array.tpp.

operator-() [9/10]

template<class T >

std::vector< std::vector< T > > operator-	(	const T &	x,
		const std::vector< std::vector< T > > &	y )

Operator- for std::vector.

Perform the element-wise difference between a constant (y) and a vector of vectors (y), and returns z s.t. z[i][j] = x - y[i][j] for all j = 0, ..., y[i].size()-1, i = 0, ..., n-1 where n = y.size(). Template parameters, T, can by any type for which the operator- is defined.

The element-wise difference is performed recursively, i.e. if y[i][j] and y are std::vector, operator- calls itself to perform the element-wise difference between y[i][j] and x.

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

vector of vectors having the same dimensions of y and storing the element-wise difference between x and y.

Definition at line 504 of file Operators_vector.tpp.

operator-() [10/10]

template<class T >

std::vector< T > operator-	(	const T &	x,
		const std::vector< T > &	y )

Operator- for std::vector.

Perform the element-wise difference between a constant (x), and a vector (y) and returns a vector (z) s.t. z[i] = x - y[i] for all i = 0, ..., n-1 where n = y.size(). Template parameters, T, can by any type for which the operator- is defined.

The element-wise difference is performed recursively, i.e. if the i-th element of y and x are std::vector, operator- calls itself to perform the element-wise difference between x[i] and y.

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

vector with n elements, storing the element-wise difference between x and y.

Definition at line 466 of file Operators_vector.tpp.

operator-=() [1/6]

template<class T , size_t d, size_t e>

std::array< std::array< T, e >, d > & operator-=	(	std::array< std::array< T, e >, d > &	x,
		const T &	y )

Operator-= for std::array.

Decrement each element in the input array, using the value on the r.h.s. as negative increment, i.e.: x[i][j] -= y for all j = 0, ..., e-1, i = 0, ..., d-1 Template parameters, T, can by any type for which the operator-= is defined.

The element-wise decrement is performed recursively, i.e. if x[i][j] and y are std::array, operator-= calls itself to decrement x[i][j][k] by y[k], k = 0, ... , x.size()-1

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

first argument decremented with r.h.s. values.

Definition at line 674 of file Operators_array.tpp.

operator-=() [2/6]

template<class T , size_t d>

std::array< T, d > & operator-=	(	std::array< T, d > &	x,
		const std::array< T, d > &	y )

Operator-= for std::array.

Decrement each element in the input array, using the corresping value on the array at the r.h.s. as negative increment, i.e.: x[i] -= y[i] for all i = 0, ..., d-1 Template parameters, T, can by any type for which the operator-= is defined.

The element-wise decrement is performed recursively, i.e. if the i-th element of x and the i-th element of y are std::array, operator-= calls itself to decrement x[i][j] by y[i][j], j = 0, ..., x[i].size()-1

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

first argument decremented with r.h.s. values.

Definition at line 579 of file Operators_array.tpp.

operator-=() [3/6]

template<class T , size_t d>

std::array< T, d > & operator-=	(	std::array< T, d > &	x,
		const T &	y )

Operator-= for std::array.

Decrement each element in the input array, using the value on the r.h.s. as negative increment, i.e.: x[i] -= y for all i = 0, ..., d-1 Template parameters, T, can by any type for which the operator-= is defined.

The element-wise decrement is performed recursively, i.e. if the i-th element of x and y are std::array, operator-= calls itself to decrement x[i][j] by y[j], j = 0, ... , x[i].size()-1

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

first argument decremented with r.h.s. values.

Definition at line 617 of file Operators_array.tpp.

operator-=() [4/6]

template<class T >

std::vector< std::vector< T > > & operator-=	(	std::vector< std::vector< T > > &	x,
		const T &	y )

Operator-= for std::vector.

Decrement each element in the input vector, using the value on the r.h.s. as negative increment, i.e.: x[i][j] -= y for all j = 0, ..., x[i].size()-1, i = 0, ..., n-1 where n = x.size(). Template parameters, T, can by any type for which the operator-= is defined.

The element-wise decrement is performed recursively, i.e. if x[i][j] and y are std::vector, operator-= calls itself to decrement x[i][j][k] by y[k], k = 0, ... , min(x[i][j].size(), y.size())-1

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

first argument decremented with r.h.s. values.

Definition at line 662 of file Operators_vector.tpp.

operator-=() [5/6]

template<class T >

std::vector< T > & operator-=	(	std::vector< T > &	x,
		const std::vector< T > &	y )

Operator-= for std::vector.

Decrement each element in the input vector, using the corresping value on vector at the r.h.s. as negative increment, i.e.: x[i] -= y[i] for all i = 0, ..., n-1 where n = min(x.size(), y.size(). Template parameters, T, can by any type for which the operator-= is defined.

The element-wise decrement is performed recursively, i.e. if the i-th element of x and the i-th element of y are std::vector, operator-= calls itself to decrement x[i][j] by y[i][j], j = 0, ..., min(x[i].size(), y[i].size())-1

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

first argument decremented with r.h.s. values.

Definition at line 584 of file Operators_vector.tpp.

operator-=() [6/6]

template<class T >

std::vector< T > & operator-=	(	std::vector< T > &	x,
		const T &	y )

Operator-= for std::vector.

Decrement each element in the input vector, using the value on the r.h.s. as negative increment, i.e.: x[i] -= y for all i = 0, ..., n-1 where n = x.size(). Template parameters, T, can by any type for which the operator-= is defined.

The element-wise decrement is performed recursively, i.e. if the i-th element of x and y are std::vector, operator-= calls itself to decrement x[i][j] by y[j], j = 0, ... , min(x[i].size(), y.size())-1

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

first argument decremented with r.h.s. values.

Definition at line 623 of file Operators_vector.tpp.

operator/() [1/10]

template<class T , size_t d, size_t e>

std::array< std::array< T, e >, d > operator/	(	const std::array< std::array< T, e >, d > &	x,
		const T &	y )

Operator/ for std::array.

Perform the element-wise division between a array of arrays (x) and a constant (y), and returns z s.t. z[i][j] = x[i][j] / y for all j = 0, ..., e-1, i = 0, ..., d-1 where d = x.size(). Template parameters, T, can by any type for which the operator/ is defined.

The element-wise division is performed recursively, i.e. if x[i][j] and y are std::array, operator/ calls itself to perform the element-wise division between x[i][j] and y.

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

array of arrays having the same dimensions of x and storing the element-wise division between x and y.

Definition at line 1191 of file Operators_array.tpp.

operator/() [2/10]

template<class T , size_t d>

std::array< T, d > operator/	(	const std::array< T, d > &	x,
		const std::array< T, d > &	y )

Operator/ for std::array.

Perform the element-wise division between two arrays (x and y) and returns a array z s.t. z[i] = x[i] / y[i] for all i = 0, ..., d-1 where d = min(x.size(), y.size(). Template parameters, T, can by any type for which the operator/ is defined.

The element-wise division is performed recursively, i.e. if the i-th element of x and the i-th element of y are std::array, operator/ calls itself to perform the element-wise division between x[i] and y[i].

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

array with d elements, storing the element-wise division between x and y.

Definition at line 1028 of file Operators_array.tpp.

operator/() [3/10]

template<class T , size_t d>

std::array< T, d > operator/	(	const std::array< T, d > &	x,
		const T &	y )

Operator/ for std::array.

Perform the element-wise division between a array (x) and a constant (y), and returns a array (z) s.t. z[i] = x[i] / y for all i = 0, ..., d-1 where d = x.size(). Template parameters, T, can by any type for which the operator/ is defined.

The element-wise division is performed recursively, i.e. if the i-th element of x and y are std::array, operator/ calls itself to perform the element-wise division between x[i] and y.

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

array with d elements, storing the element-wise division between x and y.

Definition at line 1067 of file Operators_array.tpp.

operator/() [4/10]

template<class T >

std::vector< std::vector< T > > operator/	(	const std::vector< std::vector< T > > &	x,
		const T &	y )

Operator/ for std::vector.

Perform the element-wise division between a vector of vectors (x) and a constant (y), and returns z s.t. z[i][j] = x[i][j] / y for all j = 0, ..., x[i].size()-1, i = 0, ..., n-1 where n = x.size(). Template parameters, T, can by any type for which the operator/ is defined.

The element-wise division is performed recursively, i.e. if x[i][j] and y are std::vector, operator/ calls itself to perform the element-wise division between x[i][j] and y.

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

vector of vectors having the same dimensions of x and storing the element-wise division between x and y.

Definition at line 1187 of file Operators_vector.tpp.

operator/() [5/10]

template<class T >

std::vector< T > operator/	(	const std::vector< T > &	x,
		const std::vector< T > &	y )

Operator/ for std::vector.

Perform the element-wise division between two vectors (x and y) and returns a vector z s.t. z[i] = x[i] / y[i] for all i = 0, ..., n-1 where n = min(x.size(), y.size(). Template parameters, T, can by any type for which the operator/ is defined.

The element-wise division is performed recursively, i.e. if the i-th element of x and the i-th element of y are std::vector, operator/ calls itself to perform the element-wise division between x[i] and y[i].

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

vector with n elements, storing the element-wise division between x and y.

Definition at line 1020 of file Operators_vector.tpp.

operator/() [6/10]

template<class T >

std::vector< T > operator/	(	const std::vector< T > &	x,
		const T &	y )

Operator/ for std::vector.

Perform the element-wise division between a vector (x) and a constant (y), and returns a vector (z) s.t. z[i] = x[i] / y for all i = 0, ..., n-1 where n = x.size(). Template parameters, T, can by any type for which the operator/ is defined.

The element-wise division is performed recursively, i.e. if the i-th element of x and y are std::vector, operator/ calls itself to perform the element-wise division between x[i] and y.

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

vector with n elements, storing the element-wise division between x and y.

Definition at line 1060 of file Operators_vector.tpp.

operator/() [7/10]

template<class T , size_t d, size_t e>

std::array< std::array< T, e >, d > operator/	(	const T &	x,
		const std::array< std::array< T, e >, d > &	y )

Operator/ for std::array.

Perform the element-wise division between a constant (y) and a array of arrays (y), and returns z s.t. z[i][j] = x / y[i][j] for all j = 0, ..., e-1, i = 0, ..., d-1 where d = y.size(). Template parameters, T, can by any type for which the operator/ is defined.

The element-wise division is performed recursively, i.e. if y[i][j] and y are std::array, operator/ calls itself to perform the element-wise division between y[i][j] and x.

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

array of arrays having the same dimensions of y and storing the element-wise division between x and y.

Definition at line 1151 of file Operators_array.tpp.

operator/() [8/10]

template<class T , size_t d>

std::array< T, d > operator/	(	const T &	x,
		const std::array< T, d > &	y )

Operator/ for std::array.

Perform the element-wise division between a constant (x), and a array (y) and returns a array (z) s.t. z[i] = x / y[i] for all i = 0, ..., d-1 where d = y.size(). Template parameters, T, can by any type for which the operator/ is defined.

The element-wise division is performed recursively, i.e. if the i-th element of y and x are std::array, operator/ calls itself to perform the element-wise division between x[i] and y.

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

array with d elements, storing the element-wise division between x and y.

Definition at line 1111 of file Operators_array.tpp.

operator/() [9/10]

template<class T >

std::vector< std::vector< T > > operator/	(	const T &	x,
		const std::vector< std::vector< T > > &	y )

Operator/ for std::vector.

Perform the element-wise division between a constant (y) and a vector of vectors (y), and returns z s.t. z[i][j] = x / y[i][j] for all j = 0, ..., y[i].size()-1, i = 0, ..., n-1 where n = y.size(). Template parameters, T, can by any type for which the operator/ is defined.

The element-wise division is performed recursively, i.e. if y[i][j] and y are std::vector, operator/ calls itself to perform the element-wise division between y[i][j] and x.

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

vector of vectors having the same dimensions of y and storing the element-wise division between x and y.

Definition at line 1146 of file Operators_vector.tpp.

operator/() [10/10]

template<class T >

std::vector< T > operator/	(	const T &	x,
		const std::vector< T > &	y )

Operator/ for std::vector.

Perform the element-wise division between a constant (x), and a vector (y) and returns a vector (z) s.t. z[i] = x / y[i] for all i = 0, ..., n-1 where n = y.size(). Template parameters, T, can by any type for which the operator/ is defined.

The element-wise division is performed recursively, i.e. if the i-th element of y and x are std::vector, operator/ calls itself to perform the element-wise division between x[i] and y.

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

vector with n elements, storing the element-wise division between x and y.

Definition at line 1105 of file Operators_vector.tpp.

operator/=() [1/6]

template<class T , size_t d, size_t e>

std::array< std::array< T, e >, d > & operator/=	(	std::array< std::array< T, e >, d > &	x,
		const T &	y )

Operator/= for std::array.

Increment each element in the input array, using the value on the r.h.s. as increment, i.e.: x[i][j] /= y for all j = 0, ..., e-1, i = 0, ..., d-1 Template parameters, T, can by any type for which the operator/= is defined.

The element-wise increment is performed recursively, i.e. if x[i][j] and y are std::array, operator/= calls itself to increment x[i][j][k] by y[k], k = 0, ... , x.size()-1

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

first argument incremented with r.h.s. values.

Definition at line 1291 of file Operators_array.tpp.

operator/=() [2/6]

template<class T , size_t d>

std::array< T, d > & operator/=	(	std::array< T, d > &	x,
		const std::array< T, d > &	y )

Operator/= for std::array.

Increment each element in the input array, using the corresping value on array at the r.h.s. as increment, i.e.: x[i] /= y[i] for all i = 0, ..., d-1 Template parameters, T, can by any type for which the operator/= is defined.

The element-wise increment is performed recursively, i.e. if the i-th element of x and the i-th element of y are std::array, operator/= calls itself to increment x[i][j] by y[i][j], j = 0, ..., x[i].size()-1

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

first argument incremented with r.h.s. values.

Definition at line 1231 of file Operators_array.tpp.

operator/=() [3/6]

template<class T , size_t d>

std::array< T, d > & operator/=	(	std::array< T, d > &	x,
		const T &	y )

Operator/= for std::array.

Increment each element in the input array, using the value on the r.h.s. as increment, i.e.: x[i] /= y for all i = 0, ..., d-1 Template parameters, T, can by any type for which the operator/= is defined.

The element-wise increment is performed recursively, i.e. if the i-th element of x and y are std::array, operator/= calls itself to increment x[i][j] by y[j], j = 0, ... , x[i].size()-1

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

first argument incremented with r.h.s. values.

Definition at line 1261 of file Operators_array.tpp.

operator/=() [4/6]

template<class T >

std::vector< std::vector< T > > & operator/=	(	std::vector< std::vector< T > > &	x,
		const T &	y )

Operator/= for std::vector.

Increment each element in the input vector, using the value on the r.h.s. as increment, i.e.: x[i][j] /= y for all j = 0, ..., x[i].size()-1, i = 0, ..., n-1 where n = x.size(). Template parameters, T, can by any type for which the operator/= is defined.

The element-wise increment is performed recursively, i.e. if x[i][j] and y are std::vector, operator/= calls itself to increment x[i][j][k] by y[k], k = 0, ... , min(x[i][j].size(), y.size())-1

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

first argument incremented with r.h.s. values.

Definition at line 1307 of file Operators_vector.tpp.

operator/=() [5/6]

template<class T >

std::vector< T > & operator/=	(	std::vector< T > &	x,
		const std::vector< T > &	y )

Operator/= for std::vector.

Increment each element in the input vector, using the corresping value on vector at the r.h.s. as increment, i.e.: x[i] /= y[i] for all i = 0, ..., n-1 where n = min(x.size(), y.size(). Template parameters, T, can by any type for which the operator/= is defined.

The element-wise increment is performed recursively, i.e. if the i-th element of x and the i-th element of y are std::vector, operator/= calls itself to increment x[i][j] by y[i][j], j = 0, ..., min(x[i].size(), y[i].size())-1

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

first argument incremented with r.h.s. values.

Definition at line 1229 of file Operators_vector.tpp.

operator/=() [6/6]

template<class T >

std::vector< T > & operator/=	(	std::vector< T > &	x,
		const T &	y )

Operator/= for std::vector.

Increment each element in the input vector, using the value on the r.h.s. as increment, i.e.: x[i] /= y for all i = 0, ..., n-1 where n = x.size(). Template parameters, T, can by any type for which the operator/= is defined.

The element-wise increment is performed recursively, i.e. if the i-th element of x and y are std::vector, operator/= calls itself to increment x[i][j] by y[j], j = 0, ... , min(x[i].size(), y.size())-1

Parameters

[in]	x	first argument
[in]	y	second argument

Returns

first argument incremented with r.h.s. values.

Definition at line 1268 of file Operators_vector.tpp.