Classes
class	ColumnIterator

class	ColumnVector
	This class realizes a vector without its own container, which is a reference to a subset of other object with his own container. A typical situation is a column of matrix which can be considered as a vector. More...

class	const_ColumnIterator

class	Container
	class Container together with suitable iterators The container has fixed size specified by a template argument 'capacity' More...

class	Container< Scalar, 0 >
	Specialization for capacity=0 This container allocates objects on a storage. More...

struct	Convert

struct	Convert< ResultType, ScalarType, false >

struct	Convert< ResultType, ScalarType, true >

class	EuclLNorm
	Euclidean Logarithmic Norm. More...

class	EuclNorm
	Euclidean norm. More...

class	Matrix

class	MatrixContainer
	This class inherits form general Container class and provides constructors and methods specific for two dimensional data. More...

class	MatrixContainer< Scalar, 0, 0 >

class	MaxLNorm
	$L_\infty$ Logarithmic Norm More...

class	MaxNorm
	$L_\infty$ norm (max norm) More...

class	Multiindex
	For a Multiindex mi, mi[p] is a number of differentiation with respect to i-th variable. For example, a Multipointer mp=(0,0,2,3) in 5-dimensional space corresponds to the Multiindex mi=(2,0,1,1,0). Hence, Multiindex agrees with standard notation and it contains an additional information about the dimension of the domain of the function. More...

class	Multipointer
	Multipointer always contains nondecreasing list of indexes of variables. More...

class	Norm
	A general abstract norm. More...

class	RowVector
	RowVector class realizes a vector without its own container. He is just a reference to a part of other object (i.e. Matrix of Vector) with his own container. More...

class	SumLNorm
	Logarytmic norm More...

class	SumNorm
	norm More...

class	Vector

Typedefs
typedef unsigned	__size_type

typedef int	__difference_type

typedef Vector< double, CAPD_DEFAULT_DIMENSION >	DVector

typedef Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	IMatrix

typedef Matrix< capd::DInterval::BoundType, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	DMatrix

typedef Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION >	IVector

typedef Vector< long double, CAPD_DEFAULT_DIMENSION >	LDVector

Functions
template<typename T >
T	euclNorm (::capd::fields::Complex< T > &x)

template<typename Object >
void	clear (Object &u)
	Assign zero to each coordinate. More...

template<typename Object >
Object::ScalarType	euclNorm (const Object &u)
	Computes euclidean norm of any vector. More...

template<typename Object >
bool	normalize (Object &u)
	normalize a vector with respect to euclidean norm if impossible returns false More...

template<typename ResultType , typename Object >
ResultType	absoluteValue (const Object &v)

template<typename ResultType , typename Object >
ResultType	unaryMinus (const Object &v)

template<typename ResultType , typename T1 , typename T2 >
void	addObjects (const T1 &v1, const T2 &v2, ResultType &result)
	this procedure can be use to add two vector-like objects: More...

template<typename ResultType , typename T1 , typename T2 >
ResultType	addObjects (const T1 &v1, const T2 &v2)

template<typename ResultType , typename T1 , typename T2 >
void	subtractObjects (const T1 &v1, const T2 &v2, ResultType &result)
	this procedure can be use to subtract two vector-like objects: More...

template<typename ResultType , typename T1 , typename T2 >
ResultType	subtractObjects (const T1 &v1, const T2 &v2)

template<typename T1 , typename T2 >
T1::ScalarType	scalarProduct (const T1 &v1, const T2 &v2)
	this procedure can be use to compute scalar product of two vector-like objects: More...

template<typename ResultType , typename Object , typename FactorType >
ResultType	multiplyObjectScalar (const Object &v, const FactorType &s)
	this procedure can be use to multiply by a scalar any element of vector-like objects as a result we may obtain object of different type, multiplication of column of matrix and scalar gives vector result = v * s More...

template<typename ResultType , typename Object , typename FactorType >
ResultType	divideObjectScalar (const Object &v, const FactorType &s)
	this procedure can be use to divide by a scalar any element of vector-like objects as a result we may obtain object of different type, dividing of column of matrix by scalar gives vector result = v / s More...

template<typename ResultType , typename Object , typename FactorType >
ResultType	addObjectScalar (const Object &v, const FactorType &s)
	this procedure can be use to add a scalar to any element of vector-like objects result[i] = v[i] + s More...

template<typename ResultType , typename Object , typename FactorType >
ResultType	subtractObjectScalar (const Object &v, const FactorType &s)
	this procedure can be used to substract a scalar from any element of vector-like objects result[i] = v[i] - s More...

template<typename ResultType , typename MatrixType , typename VectorType >
void	matrixByVector (const MatrixType &m, const VectorType &u, ResultType &result)
	this procedure realizes multiplication of matrix-like object by vector-like object result = m*v More...

template<typename ResultType , typename MatrixType , typename VectorType >
ResultType	matrixByVector (const MatrixType &m, const VectorType &u)

template<typename ResultType , typename Matrix1 , typename Matrix2 >
void	matrixByMatrix (const Matrix1 &a1, const Matrix2 &a2, ResultType &result)
	this procedure realizes multiplication of two matrix-like objects result = m1*m2 More...

template<typename ResultType , typename Matrix1 , typename Matrix2 >
ResultType	matrixByMatrix (const Matrix1 &a1, const Matrix2 &a2)

template<typename T1 , typename T2 >
T1 &	assignObjectObject (T1 &u, const T2 &v)
	this procedure can be use to assign one vector-like objects from the other. More...

template<typename T1 , typename T2 >
T1 &	addAssignObjectObject (T1 &u, const T2 &v)
	this procedure can be use to add of two vector-like objects result is stored in the first argument u += v More...

template<typename T1 , typename T2 >
T1 &	subtractAssignObjectObject (T1 &u, const T2 &v)
	this procedure can be use to subtract of two vector-like objects result is stored in the first argument u -= v More...

template<typename Object , typename Scalar >
Object &	assignFromScalar (Object &u, const Scalar &s)
	this procedure can be use to assign each element of a vector-like object to be equal to a given scalar u[i] = s More...

template<typename Object , typename Scalar >
Object &	addAssignObjectScalar (Object &u, const Scalar &s)
	this procedure can be use to add a scalar to each element of a vector-like object u[i] += s More...

template<typename Object , typename Scalar >
Object &	subtractAssignObjectScalar (Object &u, const Scalar &s)
	this procedure can be use to subtract a scalar from each element of a vector-like object u[i] -= s More...

template<typename Object , typename Scalar >
Object &	multiplyAssignObjectScalar (Object &u, const Scalar &s)
	this procedure can be use to multiply by a scalar each element of a vector-like object u[i] *= s More...

template<typename Object , typename Object2 , typename Scalar >
Object &	multiplyAssignObjectScalarAddObject (Object &u, const Scalar &s, const Object2 &v)
	this procedure can be use to multiply by a scalar each element of a vector-like object and then add compoent-wise elements of second vector-like object u[i] = u[i]*s+v[i] More...

template<typename V , typename M , typename V2 >
V &	addAssignMatrixByVector (V &u, const M &A, const V2 &v)
	This procedure computes u += A*v where u,v are vectors and A is a matrix. More...

template<typename V , typename M , typename V2 >
V &	subtractAssignMatrixByVector (V &u, const M &A, const V2 &v)
	This procedure computes u -= A*v where u,v are vectors and A is a matrix. More...

template<typename Object , typename Scalar >
Object &	divideAssignObjectScalar (Object &u, const Scalar &s)
	this procedure can be use to divide by a scalar any element of two vector-like objects u[i] /= s More...

template<class Object , class Scalar >
void	evalPolynomial (Object *c, Scalar t, Object &result, int n)
	Evaluates polynomial p:R->R^n at some argument. More...

template<typename T1 , typename T2 >
bool	lessThan (const T1 &v1, const T2 &v2)

template<typename T1 , typename T2 >
bool	greaterThan (const T1 &v1, const T2 &v2)

template<typename T1 , typename T2 >
bool	lessEqual (const T1 &v1, const T2 &v2)

template<typename T1 , typename T2 >
bool	greaterEqual (const T1 &v1, const T2 &v2)

template<typename T1 , typename T2 >
bool	equal (const T1 &v1, const T2 &v2)

template<typename T1 , typename T2 >
bool	notEqual (const T1 &v1, const T2 &v2)

template<typename ResultType , typename Object , typename FactorType >
void	multiplyObjectScalar (const Object &v, const FactorType &s, ResultType &result)
	this procedure can be use to multiply by a scalar any element of vector-like objects as a result we may obtain object of different type, multiplication of column of matrix and scalar gives vector result = v * s More...

template<typename Scalar , __size_type rows>
std::ostream &	operator<< (std::ostream &out, const ColumnVector< Scalar, rows > &s)

template<typename Scalar , __size_type rows>
Vector< Scalar, rows >	operator+ (const Vector< Scalar, rows > &u, const ColumnVector< Scalar, rows > &v)

template<typename Scalar , __size_type rows>
Vector< Scalar, rows >	operator+ (const ColumnVector< Scalar, rows > &v, const Vector< Scalar, rows > &u)

template<typename Scalar , __size_type rows>
Vector< Scalar, rows >	operator+ (const ColumnVector< Scalar, rows > &u, const ColumnVector< Scalar, rows > &v)

template<typename Scalar , __size_type rows>
Vector< Scalar, rows >	operator- (const Vector< Scalar, rows > &u, const ColumnVector< Scalar, rows > &v)

template<typename Scalar , __size_type rows>
Vector< Scalar, rows >	operator- (const ColumnVector< Scalar, rows > &v, const Vector< Scalar, rows > &u)

template<typename Scalar , __size_type rows>
Vector< Scalar, rows >	operator- (const ColumnVector< Scalar, rows > &u, const ColumnVector< Scalar, rows > &v)

template<typename Scalar , __size_type rows>
Scalar	operator* (const Vector< Scalar, rows > &u, const ColumnVector< Scalar, rows > &v)

template<typename Scalar , __size_type rows>
Scalar	operator* (const ColumnVector< Scalar, rows > &v, const Vector< Scalar, rows > &u)

template<typename Scalar , __size_type rows>
Scalar	operator* (const ColumnVector< Scalar, rows > &v, const ColumnVector< Scalar, rows > &u)

template<typename Scalar , __size_type rows>
Vector< Scalar, rows >	operator- (const ColumnVector< Scalar, rows > &u)

template<typename Scalar , __size_type rows>
Vector< Scalar, rows >	operator* (const Scalar &s, const ColumnVector< Scalar, rows > &u)

template<typename Scalar , __size_type rows>
Vector< Scalar, rows >	operator* (const ColumnVector< Scalar, rows > &u, const Scalar &s)

template<typename Scalar , __size_type rows>
Vector< Scalar, rows >	operator/ (const ColumnVector< Scalar, rows > &u, const Scalar &s)

template<typename Scalar , __size_type rows>
std::string	cppReprezentation (const ColumnVector< Scalar, rows > &A, const std::string &varName, const std::string &typeName)
	It serializes a matrix - gives text reprezentation which can be compiled. More...

template<typename SourceIterator , typename Iterator1 , typename Iterator2 >
void	split (SourceIterator sourceBegin, SourceIterator sourceEnd, Iterator1 center, Iterator2 diameter)
	splits source object given by [sourceBegin, sourceEnd] into form center + diameter where diameter = [-radius,radius] on each coordinatedimension More...

template<typename IntervalObject1 , typename IntervalObject2 >
void	split (IntervalObject1 &v, IntervalObject2 &rv)
	splits IntervalObject v into form center + [-radius, radius] form More...

template<typename IntervalObject , typename CenterType >
void	split (const IntervalObject &v, CenterType &center, IntervalObject &diameter)
	splits IntervalObject v into form center + diameter where diameter = [-radius,radius] on each coordinate More...

template<typename IObject >
IObject::ScalarType	maxDiam (const IObject &v)
	returns the upper bound for the biggest diameter of IntervalObject (vector or matrix) coordinates More...

template<typename IObject >
capd::TypeTraits< typename IObject::ScalarType >::Real	maxWidth (const IObject &v)
	returns the biggest diameter of the interval object (vector or matrix) coordinates (non-rigorous) More...

template<typename IntervalObject >
bool	containsZero (const IntervalObject &v)
	checks if IntervalObject v contains zero on all coordinates More...

template<typename IntervalObject >
bool	subset (const IntervalObject &v1, const IntervalObject &v2)
	checks if IntervalObject v1 is contained in IntervalObject v2 More...

template<typename IntervalObject >
bool	subsetInterior (const IntervalObject &v1, const IntervalObject &v2)
	checks if IntervalObject v1 is contained in interior of IntervalObject v2 More...

template<typename Iterator1 , typename Iterator2 , typename ResultIterator >
bool	intersection (Iterator1 b1, Iterator2 b2, ResultIterator b, ResultIterator e)
	intersection of two interval objects (vectors, matrices) More...

template<typename IntervalObject1 , typename IntervalObject2 , typename IntervalObject3 >
bool	intersection (const IntervalObject1 &v1, const IntervalObject2 &v2, IntervalObject3 &result)
	intersection of two interval objects (vectors, matrices) More...

template<typename Iterator1 , typename Iterator2 >
bool	intersectionIsEmpty (Iterator1 b, Iterator1 e, Iterator2 b1)
	checks if intersection of two interval vectors is empty More...

template<typename IntervalObject1 , typename IntervalObject2 >
bool	intersectionIsEmpty (const IntervalObject1 &v, const IntervalObject2 &w)
	checks if intersection of two interval vectors is empty More...

template<typename IntervalObject >
void	intervalHull (const IntervalObject &v1, const IntervalObject &v2, IntervalObject &result)

template<typename IntervalObject , typename ResultContainer >
void	diameter (const IntervalObject &v, ResultContainer &result)

template<typename IntervalObject , typename ResultType >
void	mid (const IntervalObject &v, ResultType &result)

template<typename ResultType , typename IntervalObject >
ResultType	midObject (const IntervalObject &v)

template<typename ResultType , typename IntervalObject >
void	leftObject (const IntervalObject &v, ResultType &result)

template<typename ResultType , typename IntervalObject >
ResultType	leftObject (const IntervalObject &v)

template<typename ResultType , typename IntervalObject >
void	rightObject (const IntervalObject &v, ResultType &result)

template<typename ResultType , typename IntervalObject >
ResultType	rightObject (const IntervalObject &v)

template<typename ResultType , typename ScalarType >
ResultType	convertScalar (const ScalarType &v)

template<typename ResultType , typename ContainerType >
ResultType	convertObject (const ContainerType &v)

template<typename VectorType >
VectorType	conjVector (const VectorType &v)

template<typename ResultType , typename IObject >
ResultType	getWidths (const IObject &v)

template<typename IObject >
IObject::template rebind< typename capd::TypeTraits< typename IObject::ScalarType >::Real >::other	widths (const IObject &v)

template<typename Scalar , __size_type rows, __size_type cols1, __size_type cols2>
Matrix< Scalar, rows, cols2 >	operator* (const Matrix< Scalar, rows, cols1 > &, const Matrix< Scalar, cols1, cols2 > &)

template<typename Scalar , __size_type rows, __size_type cols>
Matrix< Scalar, cols, rows >	transpose (const Matrix< Scalar, rows, cols > &)

template<typename Scalar , __size_type rows, __size_type cols>
Matrix< Scalar, cols, rows >	Transpose (const Matrix< Scalar, rows, cols > &)

template<typename Scalar , __size_type rows, __size_type cols>
std::ostream &	operator<< (std::ostream &, const Matrix< Scalar, rows, cols > &)

template<typename Scalar , __size_type rows, __size_type cols>
std::istream &	operator>> (std::istream &, Matrix< Scalar, rows, cols > &)

template<typename Scalar , __size_type rows, __size_type cols>
Matrix< Scalar, cols, rows >::ScalarType	trace (const Matrix< Scalar, cols, rows > &A)
	Computes Trace of a given matrix. More...

template<typename Scalar , __size_type rows, __size_type cols>
Matrix< Scalar, cols, rows >::ScalarType	secondTrace (const Matrix< Scalar, cols, rows > &A)
	It returns a sum of determinants of all 2x2 matrix. More...

template<typename Scalar , __size_type rows, __size_type cols>
std::string	cppReprezentation (const Matrix< Scalar, cols, rows > &A, const std::string &varName, const std::string &typeName)
	It serializes a matrix - gives text reprezentation which can be compiled. More...

template<typename Scalar , __size_type rows, __size_type cols>
void	setDimensionInArray (Matrix< Scalar, rows, cols > *, __size_type, __size_type, __size_type)

template<typename Scalar >
void	setDimensionInArray (Matrix< Scalar, 0, 0 > *t, __size_type N, __size_type r, __size_type c)

template<typename Scalar , __size_type rows, __size_type cols>
Vector< Scalar, rows >	operator* (const Matrix< Scalar, rows, cols > &m, const Vector< Scalar, cols > &v)

template<typename Scalar , __size_type rows, __size_type cols>
Vector< Scalar, rows >	operator* (const Matrix< Scalar, rows, cols > &a, const ColumnVector< Scalar, cols > &v)

template<typename Scalar , __size_type rows, __size_type cols>
Vector< Scalar, rows >	operator* (const Matrix< Scalar, rows, cols > &m, const RowVector< Scalar, cols > &u)

template<typename Scalar , __size_type rows, __size_type cols>
Matrix< Scalar, rows, cols >	abs (const Matrix< Scalar, rows, cols > &m)

template<typename Scalar , __size_type rows, __size_type cols>
Matrix< Scalar, rows, cols >	operator- (const Matrix< Scalar, rows, cols > &m)

template<typename Scalar , __size_type rows, __size_type cols>
Matrix< Scalar, rows, cols >	operator+ (const Matrix< Scalar, rows, cols > &m1, const Matrix< Scalar, rows, cols > &m2)

template<typename Scalar , __size_type rows, __size_type cols>
Matrix< Scalar, rows, cols >	operator- (const Matrix< Scalar, rows, cols > &m1, const Matrix< Scalar, rows, cols > &m2)

template<typename Scalar , __size_type rows, __size_type cols>
Matrix< Scalar, rows, cols >	operator* (const Matrix< Scalar, rows, cols > &m, const Scalar &s)

template<typename Scalar , __size_type rows, __size_type cols>
Matrix< Scalar, rows, cols >	operator* (const Scalar &s, const Matrix< Scalar, rows, cols > &m)

template<typename Scalar , __size_type rows, __size_type cols>
Matrix< Scalar, rows, cols >	operator/ (const Matrix< Scalar, rows, cols > &m, const Scalar &s)

template<typename Scalar , __size_type rows, __size_type cols>
Matrix< Scalar, rows, cols >	operator+ (const Matrix< Scalar, rows, cols > &m, const Scalar &s)

template<typename Scalar , __size_type rows, __size_type cols>
Matrix< Scalar, rows, cols >	operator- (const Matrix< Scalar, rows, cols > &m, const Scalar &s)

template<typename Scalar , __size_type rows, __size_type cols>
bool	operator< (const Matrix< Scalar, rows, cols > &m1, const Matrix< Scalar, rows, cols > &m2)

template<typename Scalar , __size_type rows, __size_type cols>
bool	operator> (const Matrix< Scalar, rows, cols > &m1, const Matrix< Scalar, rows, cols > &m2)

template<typename Scalar , __size_type rows, __size_type cols>
bool	operator<= (const Matrix< Scalar, rows, cols > &m1, const Matrix< Scalar, rows, cols > &m2)

template<typename Scalar , __size_type rows, __size_type cols>
bool	operator>= (const Matrix< Scalar, rows, cols > &m1, const Matrix< Scalar, rows, cols > &m2)

template<typename Scalar , __size_type rows, __size_type cols>
bool	operator== (const Matrix< Scalar, rows, cols > &a1, const Matrix< Scalar, rows, cols > &a2)

template<typename Scalar , __size_type rows, __size_type cols>
bool	operator!= (const Matrix< Scalar, rows, cols > &a1, const Matrix< Scalar, rows, cols > &a2)

template<typename IMatrixType >
IMatrixType	midMatrix (const IMatrixType &v)

Multipointer	sumMultipointers (const Multipointer &, const Multipointer &)

Multipointer	addIndex (const Multipointer &mp, int index)
	returns new multipointer which is multiindex mp with index added in correct place More...

Multipointer	push_back (const Multipointer &mp, int index)
	appends index to the end of multipointer mp More...

bool	hasIndex (const Multipointer &mp, int index)
	checks if muiltipointer contains index More...

int	indexCount (const Multipointer &mp, int index)
	returns the number of occurences of index in the multipointer More...

Multipointer	removeIndex (const Multipointer &mp, int index)
	returns a multipointer with removed index More...

template<typename Scalar , __size_type cols>
Vector< Scalar, cols >	diam (const RowVector< Scalar, cols > &v)

template<typename Scalar , __size_type cols>
Vector< Scalar, cols >	operator+ (const Vector< Scalar, cols > &u1, const RowVector< Scalar, cols > &u2)

template<typename Scalar , __size_type cols>
Vector< Scalar, cols >	operator+ (const RowVector< Scalar, cols > &u1, const Vector< Scalar, cols > &u2)

template<typename Scalar , __size_type cols>
Vector< Scalar, cols >	operator+ (const RowVector< Scalar, cols > &u1, const RowVector< Scalar, cols > &u2)

template<typename Scalar , __size_type cols>
Vector< Scalar, cols >	operator- (const Vector< Scalar, cols > &u1, const RowVector< Scalar, cols > &u2)

template<typename Scalar , __size_type cols>
Vector< Scalar, cols >	operator- (const RowVector< Scalar, cols > &u1, const Vector< Scalar, cols > &u2)

template<typename Scalar , __size_type cols>
Vector< Scalar, cols >	operator- (const RowVector< Scalar, cols > &u1, const RowVector< Scalar, cols > &u2)

template<typename Scalar , __size_type cols>
Scalar	operator* (const Vector< Scalar, cols > &u1, const RowVector< Scalar, cols > &u2)

template<typename Scalar , __size_type cols>
Scalar	operator* (const RowVector< Scalar, cols > &u1, const Vector< Scalar, cols > &u2)

template<typename Scalar , __size_type cols>
Scalar	operator* (const RowVector< Scalar, cols > &u1, const RowVector< Scalar, cols > &u2)

template<typename Scalar , __size_type cols>
Vector< Scalar, cols >	operator- (const RowVector< Scalar, cols > &u)

template<typename Scalar , __size_type cols>
Vector< Scalar, cols >	operator* (const Scalar &s, const RowVector< Scalar, cols > &u)

template<typename Scalar , __size_type cols>
Vector< Scalar, cols >	operator* (const RowVector< Scalar, cols > &u, const Scalar &s)

template<typename Scalar , __size_type cols>
Vector< Scalar, cols >	operator/ (const RowVector< Scalar, cols > &u, const Scalar &s)

template<typename Scalar , __size_type cols>
std::ostream &	operator<< (std::ostream &out, const RowVector< Scalar, cols > &u)

template<typename VectorType1 , typename VectorType2 >
void	intersectionWithSubvector (const VectorType1 &src, VectorType2 &target, int start, int stop)
	Intersection of src with target[start..stop] is returned in target. More...

template<typename VectorType1 , typename VectorType2 >
void	copyToSubvector (const VectorType1 &src, VectorType2 &target, int start, int stop)
	it copies src into target[start..stop] More...

template<typename VectorType1 , typename VectorType2 >
void	copyFromSubvector (const VectorType1 &src, VectorType2 &target, int start, int stop)
	it copies src[start..stop] into target More...

template<typename MatrixType1 , typename MatrixType2 >
void	intersectionWithSubmatrix (const MatrixType1 &src, MatrixType2 &target, int startRow, int stopRow, int startCol, int stopCol)
	intersection of src with target[startRow..stopRow][startCol..stopCol] is returned in target More...

template<typename MatrixType1 , typename MatrixType2 >
void	copyToSubmatrix (const MatrixType1 &src, MatrixType2 &target, int startRow, int stopRow, int startCol, int stopCol)
	it copies src into target[startRow..stopRow)[startCol..stopCol) More...

template<typename MatrixType1 , typename MatrixType2 >
void	copyFromSubmatrix (const MatrixType1 &src, MatrixType2 &target, int startRow, int stopRow, int startCol, int stopCol)
	it copies src[startRow..stopRow)[startCol..stopCol) into target More...

template<typename Scalar , __size_type dim>
std::ostream &	operator<< (std::ostream &out, const Vector< Scalar, dim > &v)

template<typename Scalar , __size_type dim>
std::istream &	operator>> (std::istream &inp, Vector< Scalar, dim > &v)

template<typename Vector >
std::string	vectorToString (const Vector &v, int firstIndex=0, int lastIndex=-1, int precision=-1)

template<typename Vector >
std::ostream &	printVector (std::ostream &str, const Vector &v, int firstIndex=0, int lastIndex=-1)

template<typename Scalar , __size_type dim>
std::ostream &	print (std::ostream &str, const Vector< Scalar, dim > &v, int firstIndex=0, int lastIndex=-1)

template<typename Scalar , __size_type dim>
std::string	cppReprezentation (const Vector< Scalar, dim > &A, const std::string &varName, const std::string &typeName)
	It serializes a matrix - gives text reprezentation which can be compiled. More...

template<typename Scalar , __size_type dim>
void	setDimensionInArray (Vector< Scalar, dim > *, __size_type, __size_type)

template<typename Scalar >
void	setDimensionInArray (Vector< Scalar, 0 > *t, __size_type N, __size_type _dim)

template<typename Scalar , __size_type dim>
Vector< Scalar, dim >	abs (const Vector< Scalar, dim > &v)

template<typename Scalar , __size_type dim>
Vector< Scalar, dim >	operator- (const Vector< Scalar, dim > &v)

template<typename Scalar , __size_type dim>
Vector< Scalar, dim >	operator+ (const Vector< Scalar, dim > &v1, const Vector< Scalar, dim > &v2)

template<typename Scalar , __size_type dim>
Vector< Scalar, dim >	operator- (const Vector< Scalar, dim > &v1, const Vector< Scalar, dim > &v2)

template<typename Scalar , __size_type dim>
Scalar	operator* (const Vector< Scalar, dim > &v1, const Vector< Scalar, dim > &v2)

template<typename Scalar , __size_type dim>
Vector< Scalar, dim >	operator+ (const Vector< Scalar, dim > &v, const Scalar &s)

template<typename Scalar , __size_type dim>
Vector< Scalar, dim >	operator- (const Vector< Scalar, dim > &v, const Scalar &s)

template<typename Scalar , typename FactorType , __size_type dim>
Vector< Scalar, dim >	operator* (const Vector< Scalar, dim > &v, const FactorType &s)

template<typename Scalar , typename FactorType , __size_type dim>
Vector< Scalar, dim >	operator* (const FactorType &s, const Vector< Scalar, dim > &v)

template<typename Scalar , typename FactorType , __size_type dim>
Vector< Scalar, dim >	operator/ (const Vector< Scalar, dim > &v, const FactorType &s)

template<typename Scalar , __size_type dim>
bool	operator< (const Vector< Scalar, dim > &v1, const Vector< Scalar, dim > &v2)

template<typename Scalar , __size_type dim>
bool	operator> (const Vector< Scalar, dim > &v1, const Vector< Scalar, dim > &v2)

template<typename Scalar , __size_type dim>
bool	operator<= (const Vector< Scalar, dim > &v1, const Vector< Scalar, dim > &v2)

template<typename Scalar , __size_type dim>
bool	operator>= (const Vector< Scalar, dim > &v1, const Vector< Scalar, dim > &v2)

template<typename Scalar , __size_type dim>
bool	operator== (const Vector< Scalar, dim > &v1, const Vector< Scalar, dim > &v2)

template<typename Scalar , __size_type dim>
bool	operator!= (const Vector< Scalar, dim > &v1, const Vector< Scalar, dim > &v2)

template<typename IVector >
IVector	leftVector (const IVector &u)

template<typename IVector >
IVector	rightVector (const IVector &u)

template<typename IVector >
IVector::ScalarType	maxDiam (const IVector &)

template<typename IVector >
IVector	intervalBall (const IVector &, const typename IVector::ScalarType &r)

template<typename IVector >
IVector::ScalarType	solveAffineInclusion (const IVector &, const IVector &, const IVector &)

template<typename IVector >
IVector::ScalarType	solveAffineInclusion (const IVector &, const IVector &, const IVector &, int &)

template<typename IVector >
IVector	intervalHull (const IVector &, const IVector &)

template<typename IVector >
IVector	midVector (const IVector &)

template<typename IVector >
IVector	diam (const IVector &)

template<typename IVector >
IVector	intersection (const IVector &, const IVector &)

template<typename IVectorType >
IVectorType	diam (const IVectorType &v)

template<typename IVectorType >
IVectorType	intersection (const IVectorType &v1, const IVectorType &v2)

template<typename IVectorType >
IVectorType	midVector (const IVectorType &v)

template<typename IVectorType >
IVectorType	intervalHull (const IVectorType &v1, const IVectorType &v2)

template<typename IVectorType >
IVectorType	intervalBall (const IVectorType &iv, const typename IVectorType::ScalarType &r)

template<typename IVectorType >
IVectorType::ScalarType	solveAffineInclusion (const IVectorType &a, const IVectorType &p, const IVectorType &c)

template<typename IVectorType >
IVectorType::ScalarType	solveAffineInclusion (const IVectorType &a, const IVectorType &p, const IVectorType &c, int &dir)

template Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	abs< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	operator-<double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	operator+<double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	operator-<double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	operator*<double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template Vector< double, CAPD_DEFAULT_DIMENSION >	operator*<double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Vector< double, CAPD_DEFAULT_DIMENSION > &)

template Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	operator*<double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const double &)

template Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	operator*<double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const double &, const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	operator/<double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const double &)

template Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	operator+<double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const double &)

template Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	operator-<double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const double &)

template bool	operator<<double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template bool	operator><double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template bool	operator<=< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template bool	operator>=< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	Transpose< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template std::ostream &	operator<<< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (std::ostream &, const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template std::istream &	operator>>< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (std::istream &, Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template void	matrixByVector (const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Vector< double, CAPD_DEFAULT_DIMENSION > &, Vector< double, CAPD_DEFAULT_DIMENSION > &)

template void	matrixByVector (const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< double, CAPD_DEFAULT_DIMENSION > &, Vector< double, CAPD_DEFAULT_DIMENSION > &)

template void	matrixByVector (const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &, Vector< long double, CAPD_DEFAULT_DIMENSION > &)

template void	matrixByMatrix (const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template void	matrixByMatrix (const Matrix< int, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< int, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, Matrix< int, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template void	matrixByVector (const Matrix< int, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Vector< int, CAPD_DEFAULT_DIMENSION > &, Vector< int, CAPD_DEFAULT_DIMENSION > &)

template void	matrixByVector (const Matrix< int, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< int, CAPD_DEFAULT_DIMENSION > &, Vector< int, CAPD_DEFAULT_DIMENSION > &)

template void	subtractObjects (const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &v1, const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &v2, Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &result)

template void	addObjects (const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &v1, const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &v2, Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &result)

template Vector< double, CAPD_DEFAULT_DIMENSION > &	addAssignMatrixByVector (Vector< double, CAPD_DEFAULT_DIMENSION > &u, const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &A, const Vector< double, CAPD_DEFAULT_DIMENSION > &v)

template Vector< double, CAPD_DEFAULT_DIMENSION > &	subtractAssignMatrixByVector (Vector< double, CAPD_DEFAULT_DIMENSION > &u, const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &A, const Vector< double, CAPD_DEFAULT_DIMENSION > &v)

template Vector< double, CAPD_DEFAULT_DIMENSION >	operator+<double, CAPD_DEFAULT_DIMENSION > (const Vector< double, CAPD_DEFAULT_DIMENSION > &, const RowVector< double, CAPD_DEFAULT_DIMENSION > &)

template Vector< double, CAPD_DEFAULT_DIMENSION >	operator+<double, CAPD_DEFAULT_DIMENSION > (const RowVector< double, CAPD_DEFAULT_DIMENSION > &, const Vector< double, CAPD_DEFAULT_DIMENSION > &)

template Vector< double, CAPD_DEFAULT_DIMENSION >	operator+<double, CAPD_DEFAULT_DIMENSION > (const RowVector< double, CAPD_DEFAULT_DIMENSION > &, const RowVector< double, CAPD_DEFAULT_DIMENSION > &)

template Vector< double, CAPD_DEFAULT_DIMENSION >	operator-<double, CAPD_DEFAULT_DIMENSION > (const Vector< double, CAPD_DEFAULT_DIMENSION > &, const RowVector< double, CAPD_DEFAULT_DIMENSION > &)

template Vector< double, CAPD_DEFAULT_DIMENSION >	operator-<double, CAPD_DEFAULT_DIMENSION > (const RowVector< double, CAPD_DEFAULT_DIMENSION > &, const Vector< double, CAPD_DEFAULT_DIMENSION > &)

template Vector< double, CAPD_DEFAULT_DIMENSION >	operator-<double, CAPD_DEFAULT_DIMENSION > (const RowVector< double, CAPD_DEFAULT_DIMENSION > &, const RowVector< double, CAPD_DEFAULT_DIMENSION > &)

template double	operator*<double, CAPD_DEFAULT_DIMENSION > (const Vector< double, CAPD_DEFAULT_DIMENSION > &, const RowVector< double, CAPD_DEFAULT_DIMENSION > &)

template double	operator*<double, CAPD_DEFAULT_DIMENSION > (const RowVector< double, CAPD_DEFAULT_DIMENSION > &, const Vector< double, CAPD_DEFAULT_DIMENSION > &)

template double	operator*<double, CAPD_DEFAULT_DIMENSION > (const RowVector< double, CAPD_DEFAULT_DIMENSION > &, const RowVector< double, CAPD_DEFAULT_DIMENSION > &)

template Vector< double, CAPD_DEFAULT_DIMENSION >	operator-<double, CAPD_DEFAULT_DIMENSION > (const RowVector< double, CAPD_DEFAULT_DIMENSION > &)

template Vector< double, CAPD_DEFAULT_DIMENSION >	operator*<double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const RowVector< double, CAPD_DEFAULT_DIMENSION > &)

template Vector< double, CAPD_DEFAULT_DIMENSION >	operator*<double, CAPD_DEFAULT_DIMENSION > (const double &, const RowVector< double, CAPD_DEFAULT_DIMENSION > &)

template Vector< double, CAPD_DEFAULT_DIMENSION >	operator*<double, CAPD_DEFAULT_DIMENSION > (const RowVector< double, CAPD_DEFAULT_DIMENSION > &, const double &)

template Vector< double, CAPD_DEFAULT_DIMENSION >	operator/<double, CAPD_DEFAULT_DIMENSION > (const RowVector< double, CAPD_DEFAULT_DIMENSION > &, const double &)

template std::ostream &	operator<<< double, CAPD_DEFAULT_DIMENSION > (std::ostream &, const RowVector< double, CAPD_DEFAULT_DIMENSION > &)

template Vector< double, CAPD_DEFAULT_DIMENSION >	operator+<double, CAPD_DEFAULT_DIMENSION > (const Vector< double, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< double, CAPD_DEFAULT_DIMENSION > &)

template Vector< double, CAPD_DEFAULT_DIMENSION >	operator+<double, CAPD_DEFAULT_DIMENSION > (const ColumnVector< double, CAPD_DEFAULT_DIMENSION > &, const Vector< double, CAPD_DEFAULT_DIMENSION > &)

template Vector< double, CAPD_DEFAULT_DIMENSION >	operator+<double, CAPD_DEFAULT_DIMENSION > (const ColumnVector< double, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< double, CAPD_DEFAULT_DIMENSION > &)

template Vector< double, CAPD_DEFAULT_DIMENSION >	operator-<double, CAPD_DEFAULT_DIMENSION > (const Vector< double, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< double, CAPD_DEFAULT_DIMENSION > &)

template Vector< double, CAPD_DEFAULT_DIMENSION >	operator-<double, CAPD_DEFAULT_DIMENSION > (const ColumnVector< double, CAPD_DEFAULT_DIMENSION > &, const Vector< double, CAPD_DEFAULT_DIMENSION > &)

template Vector< double, CAPD_DEFAULT_DIMENSION >	operator-<double, CAPD_DEFAULT_DIMENSION > (const ColumnVector< double, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< double, CAPD_DEFAULT_DIMENSION > &)

template double	operator*<double, CAPD_DEFAULT_DIMENSION > (const Vector< double, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< double, CAPD_DEFAULT_DIMENSION > &)

template double	operator*<double, CAPD_DEFAULT_DIMENSION > (const ColumnVector< double, CAPD_DEFAULT_DIMENSION > &, const Vector< double, CAPD_DEFAULT_DIMENSION > &)

template double	operator*<double, CAPD_DEFAULT_DIMENSION > (const ColumnVector< double, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< double, CAPD_DEFAULT_DIMENSION > &)

template Vector< double, CAPD_DEFAULT_DIMENSION >	operator-<double, CAPD_DEFAULT_DIMENSION > (const ColumnVector< double, CAPD_DEFAULT_DIMENSION > &)

template Vector< double, CAPD_DEFAULT_DIMENSION >	operator*<double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< double, CAPD_DEFAULT_DIMENSION > &)

template Vector< double, CAPD_DEFAULT_DIMENSION >	operator*<double, CAPD_DEFAULT_DIMENSION > (const double &, const ColumnVector< double, CAPD_DEFAULT_DIMENSION > &)

template Vector< double, CAPD_DEFAULT_DIMENSION >	operator*<double, CAPD_DEFAULT_DIMENSION > (const ColumnVector< double, CAPD_DEFAULT_DIMENSION > &, const double &)

template Vector< double, CAPD_DEFAULT_DIMENSION >	operator/<double, CAPD_DEFAULT_DIMENSION > (const ColumnVector< double, CAPD_DEFAULT_DIMENSION > &, const double &)

template std::ostream &	operator<<< double, CAPD_DEFAULT_DIMENSION > (std::ostream &, const ColumnVector< double, CAPD_DEFAULT_DIMENSION > &)

template Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	multiplyAssignObjectScalarAddObject (Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, double const &, Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > const &)

template Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	multiplyAssignObjectScalarAddObject (Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, long double const &, Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > const &)

template std::string	cppReprezentation (Matrix< int, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > const &, std::string const &, std::string const &)

template std::string	cppReprezentation (Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > const &, std::string const &, std::string const &)

template Vector< double, CAPD_DEFAULT_DIMENSION >	abs< double, CAPD_DEFAULT_DIMENSION > (const Vector< double, CAPD_DEFAULT_DIMENSION > &v)

template Vector< double, CAPD_DEFAULT_DIMENSION >	operator-<double, CAPD_DEFAULT_DIMENSION > (const Vector< double, CAPD_DEFAULT_DIMENSION > &v)

template Vector< double, CAPD_DEFAULT_DIMENSION >	operator+<double, CAPD_DEFAULT_DIMENSION > (const Vector< double, CAPD_DEFAULT_DIMENSION > &v1, const Vector< double, CAPD_DEFAULT_DIMENSION > &v2)

template Vector< double, CAPD_DEFAULT_DIMENSION >	operator-<double, CAPD_DEFAULT_DIMENSION > (const Vector< double, CAPD_DEFAULT_DIMENSION > &v1, const Vector< double, CAPD_DEFAULT_DIMENSION > &v2)

template double	operator*<double, CAPD_DEFAULT_DIMENSION > (const Vector< double, CAPD_DEFAULT_DIMENSION > &v1, const Vector< double, CAPD_DEFAULT_DIMENSION > &v2)

template Vector< double, CAPD_DEFAULT_DIMENSION >	operator*<double, double, CAPD_DEFAULT_DIMENSION > (const Vector< double, CAPD_DEFAULT_DIMENSION > &v, const double &s)

template Vector< double, CAPD_DEFAULT_DIMENSION >	operator*<double, double, CAPD_DEFAULT_DIMENSION > (const double &s, const Vector< double, CAPD_DEFAULT_DIMENSION > &v)

template Vector< double, CAPD_DEFAULT_DIMENSION >	operator/<double, double, CAPD_DEFAULT_DIMENSION > (const Vector< double, CAPD_DEFAULT_DIMENSION > &v, const double &s)

template Vector< double, CAPD_DEFAULT_DIMENSION >	operator*<double, long, CAPD_DEFAULT_DIMENSION > (const Vector< double, CAPD_DEFAULT_DIMENSION > &v, const long &s)

template Vector< double, CAPD_DEFAULT_DIMENSION >	operator*<double, long, CAPD_DEFAULT_DIMENSION > (const long &s, const Vector< double, CAPD_DEFAULT_DIMENSION > &v)

template Vector< double, CAPD_DEFAULT_DIMENSION >	operator/<double, long, CAPD_DEFAULT_DIMENSION > (const Vector< double, CAPD_DEFAULT_DIMENSION > &v, const long &s)

template Vector< double, CAPD_DEFAULT_DIMENSION >	operator*<double, int, CAPD_DEFAULT_DIMENSION > (const Vector< double, CAPD_DEFAULT_DIMENSION > &v, const int &s)

template Vector< double, CAPD_DEFAULT_DIMENSION >	operator*<double, int, CAPD_DEFAULT_DIMENSION > (const int &s, const Vector< double, CAPD_DEFAULT_DIMENSION > &v)

template Vector< double, CAPD_DEFAULT_DIMENSION >	operator/<double, int, CAPD_DEFAULT_DIMENSION > (const Vector< double, CAPD_DEFAULT_DIMENSION > &v, const int &s)

template Vector< double, CAPD_DEFAULT_DIMENSION >	operator+<double, CAPD_DEFAULT_DIMENSION > (const Vector< double, CAPD_DEFAULT_DIMENSION > &v, const double &s)

template Vector< double, CAPD_DEFAULT_DIMENSION >	operator-<double, CAPD_DEFAULT_DIMENSION > (const Vector< double, CAPD_DEFAULT_DIMENSION > &v, const double &s)

template bool	operator<<double, CAPD_DEFAULT_DIMENSION > (const Vector< double, CAPD_DEFAULT_DIMENSION > &v1, const Vector< double, CAPD_DEFAULT_DIMENSION > &v2)

template bool	operator><double, CAPD_DEFAULT_DIMENSION > (const Vector< double, CAPD_DEFAULT_DIMENSION > &v1, const Vector< double, CAPD_DEFAULT_DIMENSION > &v2)

template bool	operator<=< double, CAPD_DEFAULT_DIMENSION > (const Vector< double, CAPD_DEFAULT_DIMENSION > &v1, const Vector< double, CAPD_DEFAULT_DIMENSION > &v2)

template bool	operator>=< double, CAPD_DEFAULT_DIMENSION > (const Vector< double, CAPD_DEFAULT_DIMENSION > &v1, const Vector< double, CAPD_DEFAULT_DIMENSION > &v2)

template std::ostream &	operator<<< double, CAPD_DEFAULT_DIMENSION > (std::ostream &out, const Vector< double, CAPD_DEFAULT_DIMENSION > &v)

template std::istream &	operator>>< double, CAPD_DEFAULT_DIMENSION > (std::istream &inp, Vector< double, CAPD_DEFAULT_DIMENSION > &v)

template void	subtractObjects (const Vector< double, CAPD_DEFAULT_DIMENSION > &v1, const Vector< double, CAPD_DEFAULT_DIMENSION > &v2, Vector< double, CAPD_DEFAULT_DIMENSION > &result)

template void	addObjects (const Vector< double, CAPD_DEFAULT_DIMENSION > &v1, const Vector< double, CAPD_DEFAULT_DIMENSION > &v2, Vector< double, CAPD_DEFAULT_DIMENSION > &result)

template RowVector< double, CAPD_DEFAULT_DIMENSION > &	assignObjectObject (RowVector< double, CAPD_DEFAULT_DIMENSION > &, RowVector< double, CAPD_DEFAULT_DIMENSION > const &)

template RowVector< long double, CAPD_DEFAULT_DIMENSION > &	assignObjectObject (RowVector< long double, CAPD_DEFAULT_DIMENSION > &, RowVector< long double, CAPD_DEFAULT_DIMENSION > const &)

template ColumnVector< double, CAPD_DEFAULT_DIMENSION > &	assignObjectObject (ColumnVector< double, CAPD_DEFAULT_DIMENSION > &, ColumnVector< double, CAPD_DEFAULT_DIMENSION > const &)

template ColumnVector< double, CAPD_DEFAULT_DIMENSION > &	assignObjectObject (ColumnVector< double, CAPD_DEFAULT_DIMENSION > &, Vector< double, CAPD_DEFAULT_DIMENSION > const &)

template ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &	assignObjectObject (ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &, ColumnVector< long double, CAPD_DEFAULT_DIMENSION > const &)

template ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &	assignObjectObject (ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &, Vector< long double, CAPD_DEFAULT_DIMENSION > const &)

template Vector< double, CAPD_DEFAULT_DIMENSION > &	assignObjectObject (Vector< double, CAPD_DEFAULT_DIMENSION > &, Vector< double, CAPD_DEFAULT_DIMENSION > const &)

template Vector< double, CAPD_DEFAULT_DIMENSION >	multiplyObjectScalar (RowVector< double, CAPD_DEFAULT_DIMENSION > const &, double const &)

template Vector< long double, CAPD_DEFAULT_DIMENSION >	multiplyObjectScalar (RowVector< long double, CAPD_DEFAULT_DIMENSION > const &, long double const &)

template RowVector< double, CAPD_DEFAULT_DIMENSION > &	divideAssignObjectScalar (RowVector< double, CAPD_DEFAULT_DIMENSION > &, double const &)

template RowVector< long double, CAPD_DEFAULT_DIMENSION > &	divideAssignObjectScalar (RowVector< long double, CAPD_DEFAULT_DIMENSION > &, long double const &)

template Vector< double, CAPD_DEFAULT_DIMENSION >	divideObjectScalar< Vector< double, CAPD_DEFAULT_DIMENSION >, Vector< double, CAPD_DEFAULT_DIMENSION >, long > (Vector< double, CAPD_DEFAULT_DIMENSION > const &, long const &)

template Vector< long double, CAPD_DEFAULT_DIMENSION >	divideObjectScalar< Vector< long double, CAPD_DEFAULT_DIMENSION >, Vector< long double, CAPD_DEFAULT_DIMENSION >, long > (Vector< long double, CAPD_DEFAULT_DIMENSION > const &, long const &)

template Vector< double, CAPD_DEFAULT_DIMENSION >	unaryMinus (ColumnVector< double, CAPD_DEFAULT_DIMENSION > const &)

template Vector< long double, CAPD_DEFAULT_DIMENSION >	unaryMinus (ColumnVector< long double, CAPD_DEFAULT_DIMENSION > const &)

template std::ostream &	printVector (std::ostream &str, const ColumnVector< double, CAPD_DEFAULT_DIMENSION > &, int, int)

template std::ostream &	printVector (std::ostream &str, const ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &, int, int)

template std::string	cppReprezentation (Vector< double, CAPD_DEFAULT_DIMENSION > const &, std::string const &, std::string const &)

template std::string	cppReprezentation (Vector< long double, CAPD_DEFAULT_DIMENSION > const &, std::string const &, std::string const &)

template Vector< double, CAPD_DEFAULT_DIMENSION >	multiplyObjectScalar (ColumnVector< double, CAPD_DEFAULT_DIMENSION > const &, double const &)

template Vector< double, CAPD_DEFAULT_DIMENSION >	multiplyObjectScalar (Vector< double, CAPD_DEFAULT_DIMENSION > const &, double const &)

template Vector< double, CAPD_DEFAULT_DIMENSION >	multiplyObjectScalar (Vector< double, CAPD_DEFAULT_DIMENSION > const &, long const &)

template Vector< long double, CAPD_DEFAULT_DIMENSION >	multiplyObjectScalar (Vector< long double, CAPD_DEFAULT_DIMENSION > const &, long double const &)

template Vector< long double, CAPD_DEFAULT_DIMENSION >	multiplyObjectScalar (Vector< long double, CAPD_DEFAULT_DIMENSION > const &, long const &)

template Vector< long double, CAPD_DEFAULT_DIMENSION >	multiplyObjectScalar (ColumnVector< long double, CAPD_DEFAULT_DIMENSION > const &, long double const &)

template ColumnVector< double, CAPD_DEFAULT_DIMENSION > &	divideAssignObjectScalar (ColumnVector< double, CAPD_DEFAULT_DIMENSION > &, double const &)

template ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &	divideAssignObjectScalar (ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &, long double const &)

template void	clear (ColumnVector< double, CAPD_DEFAULT_DIMENSION > &)

template void	clear (ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &)

template Vector< double, CAPD_DEFAULT_DIMENSION > &	multiplyAssignObjectScalarAddObject (Vector< double, CAPD_DEFAULT_DIMENSION > &, double const &, Vector< double, CAPD_DEFAULT_DIMENSION > const &)

template Vector< long double, CAPD_DEFAULT_DIMENSION > &	multiplyAssignObjectScalarAddObject (Vector< long double, CAPD_DEFAULT_DIMENSION > &, long double const &, Vector< long double, CAPD_DEFAULT_DIMENSION > const &)

template RowVector< double, CAPD_DEFAULT_DIMENSION > &	subtractAssignObjectObject (RowVector< double, CAPD_DEFAULT_DIMENSION > &, Vector< double, CAPD_DEFAULT_DIMENSION > const &)

template Vector< double, CAPD_DEFAULT_DIMENSION > &	addAssignObjectObject (Vector< double, CAPD_DEFAULT_DIMENSION > &, Vector< double, CAPD_DEFAULT_DIMENSION > const &)

template DVector	divideObjectScalar (const DVector &v1, const double &s)

template Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	abs< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	operator-<capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	operator+<capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	operator-<capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	operator*<capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION >	operator*<capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)

template Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	operator*<capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const capd::DInterval &)

template Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	operator*<capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const capd::DInterval &, const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	operator/<capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const capd::DInterval &)

template Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	operator+<capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const capd::DInterval &)

template Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	operator-<capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const capd::DInterval &)

template bool	operator<<capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template bool	operator<=< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	Transpose< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template std::ostream &	operator<<< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (std::ostream &, const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template void	matrixByVector (const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)

template void	matrixByMatrix (const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template void	subtractObjects (const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &v1, const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &v2, Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &result)

template void	addObjects (const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &v1, const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &v2, Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &result)

template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	addAssignMatrixByVector (Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &u, const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &A, const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &v)

template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	subtractAssignMatrixByVector (Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &u, const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &A, const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &v)

template void	split< IMatrix, IMatrix > (IMatrix &, IMatrix &)

template void	split< IMatrix, DMatrix > (const IMatrix &, DMatrix &, IMatrix &)

template IMatrix	midMatrix< IMatrix > (const IMatrix &)

template bool	intersection< IMatrix, IMatrix, IMatrix > (const IMatrix &, const IMatrix &, IMatrix &)

template IMatrix	intervalHull< IMatrix > (const IMatrix &A, const IMatrix &B)

template capd::DInterval	maxDiam< IMatrix > (const IMatrix &v)

template double	maxWidth< IMatrix > (const IMatrix &v)

template IMatrix	diam< IMatrix > (const IMatrix &v)

template DMatrix	widths< IMatrix > (const IMatrix &v)

template bool	subset< IMatrix > (const IMatrix &v1, const IMatrix &v2)

template bool	subsetInterior< IMatrix > (const IMatrix &v1, const IMatrix &v2)

template IMatrix	intersection< IMatrix > (const IMatrix &v1, const IMatrix &v2)

template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION >	operator+<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, const RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)

template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION >	operator+<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)

template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION >	operator+<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, const RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)

template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION >	operator-<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, const RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)

template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION >	operator-<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)

template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION >	operator-<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, const RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)

template capd::DInterval	operator*<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, const RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)

template capd::DInterval	operator*<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)

template capd::DInterval	operator*<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, const RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)

template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION >	operator-<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)

template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION >	operator*<capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)

template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION >	operator*<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const capd::DInterval &, const RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)

template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION >	operator*<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, const capd::DInterval &)

template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION >	operator/<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, const capd::DInterval &)

template std::ostream &	operator<<< capd::DInterval, CAPD_DEFAULT_DIMENSION > (std::ostream &, const RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)

template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION >	operator+<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)

template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION >	operator+<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)

template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION >	operator+<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)

template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION >	operator-<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)

template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION >	operator-<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)

template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION >	operator-<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)

template capd::DInterval	operator*<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)

template capd::DInterval	operator*<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)

template capd::DInterval	operator*<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)

template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION >	operator-<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)

template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION >	operator*<capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)

template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION >	operator*<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const capd::DInterval &, const ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)

template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION >	operator*<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, const capd::DInterval &)

template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION >	operator/<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, const capd::DInterval &)

template std::ostream &	operator<<< capd::DInterval, CAPD_DEFAULT_DIMENSION > (std::ostream &, const ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)

template IMatrix &	assignFromScalar (IMatrix &, capd::DInterval const &)

template IMatrix	multiplyObjectScalar (IMatrix const &, capd::DInterval const &)

template Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	multiplyAssignObjectScalarAddObject (Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, capd::DInterval const &, Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > const &)

template bool	equal (capd::vectalg::Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > const &, capd::vectalg::Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > const &)

template Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	divideObjectScalar (Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > const &, capd::DInterval const &)

template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION >	abs< capd::DInterval, CAPD_DEFAULT_DIMENSION > (const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &v)

template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION >	operator-<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &v)

template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION >	operator+<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &v1, const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &v2)

template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION >	operator-<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &v1, const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &v2)

template capd::DInterval	operator*<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &v1, const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &v2)

template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION >	operator*<capd::DInterval, capd::DInterval, CAPD_DEFAULT_DIMENSION > (const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &v, const capd::DInterval &s)

template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION >	operator*<capd::DInterval, capd::DInterval, CAPD_DEFAULT_DIMENSION > (const capd::DInterval &s, const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &v)

template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION >	operator/<capd::DInterval, capd::DInterval, CAPD_DEFAULT_DIMENSION > (const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &v, const capd::DInterval &s)

template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION >	operator*<capd::DInterval, double, CAPD_DEFAULT_DIMENSION > (const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &v, const double &s)

template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION >	operator*<capd::DInterval, double, CAPD_DEFAULT_DIMENSION > (const double &s, const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &v)

template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION >	operator/<capd::DInterval, double, CAPD_DEFAULT_DIMENSION > (const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &v, const double &s)

template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION >	operator*<capd::DInterval, long, CAPD_DEFAULT_DIMENSION > (const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &v, const long &s)

template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION >	operator*<capd::DInterval, long, CAPD_DEFAULT_DIMENSION > (const long &s, const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &v)

template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION >	operator/<capd::DInterval, long, CAPD_DEFAULT_DIMENSION > (const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &v, const long &s)

template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION >	operator*<capd::DInterval, int, CAPD_DEFAULT_DIMENSION > (const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &v, const int &s)

template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION >	operator*<capd::DInterval, int, CAPD_DEFAULT_DIMENSION > (const int &s, const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &v)

template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION >	operator/<capd::DInterval, int, CAPD_DEFAULT_DIMENSION > (const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &v, const int &s)

template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION >	operator+<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &v, const capd::DInterval &s)

template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION >	operator-<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &v, const capd::DInterval &s)

template bool	operator<<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &v1, const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &v2)

template bool	operator<=< capd::DInterval, CAPD_DEFAULT_DIMENSION > (const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &v1, const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &v2)

template std::ostream &	operator<<< capd::DInterval, CAPD_DEFAULT_DIMENSION > (std::ostream &out, const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &v)

template void	subtractObjects (const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)

template void	addObjects (const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)

template void	addObjects (const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)

template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION >	unaryMinus (ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > const &)

template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	addAssignObjectScalar (Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &v1, const capd::DInterval &)

template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION >	addObjectScalar (Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > const &, capd::DInterval const &)

template void	subtractObjects (Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > const &, ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > const &, Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)

template ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	assignObjectObject (ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > const &)

template ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	assignObjectObject (ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > const &)

template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	assignObjectObject (Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, Vector< double, CAPD_DEFAULT_DIMENSION > const &)

template bool	normalize (ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)

template RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	assignObjectObject (RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > const &)

template RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	assignObjectObject (RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > const &)

template IVector	intervalHull< IVector > (const IVector &A, const IVector &B)

template void	split< IVector, IVector > (IVector &v, IVector &rv)

template void	split< IVector, DVector > (const IVector &v, DVector &, IVector &rv)

template IVector	midVector< IVector > (const IVector &v)

template IVector	leftVector< IVector > (const IVector &v)

template IVector	rightVector< IVector > (const IVector &v)

template capd::DInterval	maxDiam< IVector > (const IVector &v)

template double	maxWidth< IVector > (const IVector &v)

template IVector	diam< IVector > (const IVector &v)

template DVector	widths< IVector > (const IVector &v)

template IVector	intervalBall< IVector > (const IVector &iv, const capd::DInterval &r)

template capd::DInterval	solveAffineInclusion< IVector > (const IVector &a, const IVector &p, const IVector &c)

template capd::DInterval	solveAffineInclusion< IVector > (const IVector &a, const IVector &p, const IVector &c, int &)

template bool	subset< IVector > (const IVector &v1, const IVector &v2)

template bool	subsetInterior< IVector > (const IVector &v1, const IVector &v2)

template IVector	intersection< IVector > (const IVector &v1, const IVector &v2)

template std::string	vectorToString< IVector > (const IVector &v, int firstIndex, int lastIndex, int precision)

template std::ostream &	printVector< IVector > (std::ostream &str, const IVector &v, int firstIndex, int lastIndex)

template std::ostream &	printVector (std::ostream &str, const ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, int, int)

template IVector	multiplyObjectScalar (ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > const &, capd::DInterval const &)

template IVector	multiplyObjectScalar (RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > const &, capd::DInterval const &)

template IVector	multiplyObjectScalar (IVector const &, capd::DInterval const &)

template IVector	multiplyObjectScalar (IVector const &, long const &)

template IVector	divideObjectScalar (IVector const &, long const &)

template IVector	divideObjectScalar (IVector const &, capd::DInterval const &)

template ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	divideAssignObjectScalar (ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, capd::DInterval const &)

template RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	divideAssignObjectScalar (RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, capd::DInterval const &)

template IVector &	multiplyAssignObjectScalarAddObject (IVector &, capd::DInterval const &, IVector const &)

template void	clear (ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)

template bool	equal (Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > const &, Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > const &)

template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION >::ScalarType	scalarProduct (Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > const &, Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > const &)

template Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	abs< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	operator-<long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	operator+<long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	operator-<long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	operator*<long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template Vector< long double, CAPD_DEFAULT_DIMENSION >	operator*<long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Vector< long double, CAPD_DEFAULT_DIMENSION > &)

template Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	operator*<long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const long double &)

template Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	operator*<long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const long double &, const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	operator/<long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const long double &)

template Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	operator+<long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const long double &)

template Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	operator-<long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const long double &)

template bool	operator<<long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template bool	operator><long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template bool	operator<=< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template bool	operator>=< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	Transpose< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template std::ostream &	operator<<< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (std::ostream &, const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template std::istream &	operator>>< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (std::istream &, Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template void	matrixByVector (const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Vector< long double, CAPD_DEFAULT_DIMENSION > &, Vector< long double, CAPD_DEFAULT_DIMENSION > &)

template void	matrixByMatrix (const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template void	subtractObjects (const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &v1, const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &v2, Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &result)

template void	addObjects (const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &v1, const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &v2, Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &result)

template Vector< long double, CAPD_DEFAULT_DIMENSION > &	addAssignMatrixByVector (Vector< long double, CAPD_DEFAULT_DIMENSION > &u, const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &A, const Vector< long double, CAPD_DEFAULT_DIMENSION > &v)

template Vector< long double, CAPD_DEFAULT_DIMENSION > &	subtractAssignMatrixByVector (Vector< long double, CAPD_DEFAULT_DIMENSION > &u, const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &A, const Vector< long double, CAPD_DEFAULT_DIMENSION > &v)

template Vector< long double, CAPD_DEFAULT_DIMENSION >	operator+<long double, CAPD_DEFAULT_DIMENSION > (const Vector< long double, CAPD_DEFAULT_DIMENSION > &, const RowVector< long double, CAPD_DEFAULT_DIMENSION > &)

template Vector< long double, CAPD_DEFAULT_DIMENSION >	operator+<long double, CAPD_DEFAULT_DIMENSION > (const RowVector< long double, CAPD_DEFAULT_DIMENSION > &, const Vector< long double, CAPD_DEFAULT_DIMENSION > &)

template Vector< long double, CAPD_DEFAULT_DIMENSION >	operator+<long double, CAPD_DEFAULT_DIMENSION > (const RowVector< long double, CAPD_DEFAULT_DIMENSION > &, const RowVector< long double, CAPD_DEFAULT_DIMENSION > &)

template Vector< long double, CAPD_DEFAULT_DIMENSION >	operator-<long double, CAPD_DEFAULT_DIMENSION > (const Vector< long double, CAPD_DEFAULT_DIMENSION > &, const RowVector< long double, CAPD_DEFAULT_DIMENSION > &)

template Vector< long double, CAPD_DEFAULT_DIMENSION >	operator-<long double, CAPD_DEFAULT_DIMENSION > (const RowVector< long double, CAPD_DEFAULT_DIMENSION > &, const Vector< long double, CAPD_DEFAULT_DIMENSION > &)

template Vector< long double, CAPD_DEFAULT_DIMENSION >	operator-<long double, CAPD_DEFAULT_DIMENSION > (const RowVector< long double, CAPD_DEFAULT_DIMENSION > &, const RowVector< long double, CAPD_DEFAULT_DIMENSION > &)

template long double	operator*<long double, CAPD_DEFAULT_DIMENSION > (const Vector< long double, CAPD_DEFAULT_DIMENSION > &, const RowVector< long double, CAPD_DEFAULT_DIMENSION > &)

template long double	operator*<long double, CAPD_DEFAULT_DIMENSION > (const RowVector< long double, CAPD_DEFAULT_DIMENSION > &, const Vector< long double, CAPD_DEFAULT_DIMENSION > &)

template long double	operator*<long double, CAPD_DEFAULT_DIMENSION > (const RowVector< long double, CAPD_DEFAULT_DIMENSION > &, const RowVector< long double, CAPD_DEFAULT_DIMENSION > &)

template Vector< long double, CAPD_DEFAULT_DIMENSION >	operator-<long double, CAPD_DEFAULT_DIMENSION > (const RowVector< long double, CAPD_DEFAULT_DIMENSION > &)

template Vector< long double, CAPD_DEFAULT_DIMENSION >	operator*<long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const RowVector< long double, CAPD_DEFAULT_DIMENSION > &)

template Vector< long double, CAPD_DEFAULT_DIMENSION >	operator*<long double, CAPD_DEFAULT_DIMENSION > (const long double &, const RowVector< long double, CAPD_DEFAULT_DIMENSION > &)

template Vector< long double, CAPD_DEFAULT_DIMENSION >	operator*<long double, CAPD_DEFAULT_DIMENSION > (const RowVector< long double, CAPD_DEFAULT_DIMENSION > &, const long double &)

template Vector< long double, CAPD_DEFAULT_DIMENSION >	operator/<long double, CAPD_DEFAULT_DIMENSION > (const RowVector< long double, CAPD_DEFAULT_DIMENSION > &, const long double &)

template std::ostream &	operator<<< long double, CAPD_DEFAULT_DIMENSION > (std::ostream &, const RowVector< long double, CAPD_DEFAULT_DIMENSION > &)

template Vector< long double, CAPD_DEFAULT_DIMENSION >	operator+<long double, CAPD_DEFAULT_DIMENSION > (const Vector< long double, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &)

template Vector< long double, CAPD_DEFAULT_DIMENSION >	operator+<long double, CAPD_DEFAULT_DIMENSION > (const ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &, const Vector< long double, CAPD_DEFAULT_DIMENSION > &)

template Vector< long double, CAPD_DEFAULT_DIMENSION >	operator+<long double, CAPD_DEFAULT_DIMENSION > (const ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &)

template Vector< long double, CAPD_DEFAULT_DIMENSION >	operator-<long double, CAPD_DEFAULT_DIMENSION > (const Vector< long double, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &)

template Vector< long double, CAPD_DEFAULT_DIMENSION >	operator-<long double, CAPD_DEFAULT_DIMENSION > (const ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &, const Vector< long double, CAPD_DEFAULT_DIMENSION > &)

template Vector< long double, CAPD_DEFAULT_DIMENSION >	operator-<long double, CAPD_DEFAULT_DIMENSION > (const ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &)

template long double	operator*<long double, CAPD_DEFAULT_DIMENSION > (const Vector< long double, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &)

template long double	operator*<long double, CAPD_DEFAULT_DIMENSION > (const ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &, const Vector< long double, CAPD_DEFAULT_DIMENSION > &)

template long double	operator*<long double, CAPD_DEFAULT_DIMENSION > (const ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &)

template Vector< long double, CAPD_DEFAULT_DIMENSION >	operator-<long double, CAPD_DEFAULT_DIMENSION > (const ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &)

template Vector< long double, CAPD_DEFAULT_DIMENSION >	operator*<long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &)

template Vector< long double, CAPD_DEFAULT_DIMENSION >	operator*<long double, CAPD_DEFAULT_DIMENSION > (const long double &, const ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &)

template Vector< long double, CAPD_DEFAULT_DIMENSION >	operator*<long double, CAPD_DEFAULT_DIMENSION > (const ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &, const long double &)

template Vector< long double, CAPD_DEFAULT_DIMENSION >	operator/<long double, CAPD_DEFAULT_DIMENSION > (const ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &, const long double &)

template std::ostream &	operator<<< long double, CAPD_DEFAULT_DIMENSION > (std::ostream &, const ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &)

template Vector< long double, CAPD_DEFAULT_DIMENSION >	abs< long double, CAPD_DEFAULT_DIMENSION > (const Vector< long double, CAPD_DEFAULT_DIMENSION > &v)

template Vector< long double, CAPD_DEFAULT_DIMENSION >	operator-<long double, CAPD_DEFAULT_DIMENSION > (const Vector< long double, CAPD_DEFAULT_DIMENSION > &v)

template Vector< long double, CAPD_DEFAULT_DIMENSION >	operator+<long double, CAPD_DEFAULT_DIMENSION > (const Vector< long double, CAPD_DEFAULT_DIMENSION > &v1, const Vector< long double, CAPD_DEFAULT_DIMENSION > &v2)

template Vector< long double, CAPD_DEFAULT_DIMENSION >	operator-<long double, CAPD_DEFAULT_DIMENSION > (const Vector< long double, CAPD_DEFAULT_DIMENSION > &v1, const Vector< long double, CAPD_DEFAULT_DIMENSION > &v2)

template long double	operator*<long double, CAPD_DEFAULT_DIMENSION > (const Vector< long double, CAPD_DEFAULT_DIMENSION > &v1, const Vector< long double, CAPD_DEFAULT_DIMENSION > &v2)

template Vector< long double, CAPD_DEFAULT_DIMENSION >	operator*<long double, long double, CAPD_DEFAULT_DIMENSION > (const Vector< long double, CAPD_DEFAULT_DIMENSION > &v, const long double &s)

template Vector< long double, CAPD_DEFAULT_DIMENSION >	operator*<long double, long double, CAPD_DEFAULT_DIMENSION > (const long double &s, const Vector< long double, CAPD_DEFAULT_DIMENSION > &v)

template Vector< long double, CAPD_DEFAULT_DIMENSION >	operator/<long double, long double, CAPD_DEFAULT_DIMENSION > (const Vector< long double, CAPD_DEFAULT_DIMENSION > &v, const long double &s)

template Vector< long double, CAPD_DEFAULT_DIMENSION >	operator*<long double, long, CAPD_DEFAULT_DIMENSION > (const Vector< long double, CAPD_DEFAULT_DIMENSION > &v, const long &s)

template Vector< long double, CAPD_DEFAULT_DIMENSION >	operator*<long double, long, CAPD_DEFAULT_DIMENSION > (const long &s, const Vector< long double, CAPD_DEFAULT_DIMENSION > &v)

template Vector< long double, CAPD_DEFAULT_DIMENSION >	operator/<long double, long, CAPD_DEFAULT_DIMENSION > (const Vector< long double, CAPD_DEFAULT_DIMENSION > &v, const long &s)

template Vector< long double, CAPD_DEFAULT_DIMENSION >	operator*<long double, int, CAPD_DEFAULT_DIMENSION > (const Vector< long double, CAPD_DEFAULT_DIMENSION > &v, const int &s)

template Vector< long double, CAPD_DEFAULT_DIMENSION >	operator*<long double, int, CAPD_DEFAULT_DIMENSION > (const int &s, const Vector< long double, CAPD_DEFAULT_DIMENSION > &v)

template Vector< long double, CAPD_DEFAULT_DIMENSION >	operator/<long double, int, CAPD_DEFAULT_DIMENSION > (const Vector< long double, CAPD_DEFAULT_DIMENSION > &v, const int &s)

template Vector< long double, CAPD_DEFAULT_DIMENSION >	operator+<long double, CAPD_DEFAULT_DIMENSION > (const Vector< long double, CAPD_DEFAULT_DIMENSION > &v, const long double &s)

template Vector< long double, CAPD_DEFAULT_DIMENSION >	operator-<long double, CAPD_DEFAULT_DIMENSION > (const Vector< long double, CAPD_DEFAULT_DIMENSION > &v, const long double &s)

template bool	operator<<long double, CAPD_DEFAULT_DIMENSION > (const Vector< long double, CAPD_DEFAULT_DIMENSION > &v1, const Vector< long double, CAPD_DEFAULT_DIMENSION > &v2)

template bool	operator><long double, CAPD_DEFAULT_DIMENSION > (const Vector< long double, CAPD_DEFAULT_DIMENSION > &v1, const Vector< long double, CAPD_DEFAULT_DIMENSION > &v2)

template bool	operator<=< long double, CAPD_DEFAULT_DIMENSION > (const Vector< long double, CAPD_DEFAULT_DIMENSION > &v1, const Vector< long double, CAPD_DEFAULT_DIMENSION > &v2)

template bool	operator>=< long double, CAPD_DEFAULT_DIMENSION > (const Vector< long double, CAPD_DEFAULT_DIMENSION > &v1, const Vector< long double, CAPD_DEFAULT_DIMENSION > &v2)

template std::ostream &	operator<<< long double, CAPD_DEFAULT_DIMENSION > (std::ostream &out, const Vector< long double, CAPD_DEFAULT_DIMENSION > &v)

template std::istream &	operator>>< long double, CAPD_DEFAULT_DIMENSION > (std::istream &inp, Vector< long double, CAPD_DEFAULT_DIMENSION > &v)

template void	subtractObjects (const Vector< long double, CAPD_DEFAULT_DIMENSION > &v1, const Vector< long double, CAPD_DEFAULT_DIMENSION > &v2, Vector< long double, CAPD_DEFAULT_DIMENSION > &result)

template void	addObjects (const Vector< long double, CAPD_DEFAULT_DIMENSION > &v1, const Vector< long double, CAPD_DEFAULT_DIMENSION > &v2, Vector< long double, CAPD_DEFAULT_DIMENSION > &result)

template LDVector	divideObjectScalar (const LDVector &v1, const long double &s)

int	computeNewton (int d, int l)

template Vector< int, CAPD_DEFAULT_DIMENSION >	abs< int, CAPD_DEFAULT_DIMENSION > (const Vector< int, CAPD_DEFAULT_DIMENSION > &v)

template Vector< int, CAPD_DEFAULT_DIMENSION >	operator-<int, CAPD_DEFAULT_DIMENSION > (const Vector< int, CAPD_DEFAULT_DIMENSION > &v)

template Vector< int, CAPD_DEFAULT_DIMENSION >	operator+<int, CAPD_DEFAULT_DIMENSION > (const Vector< int, CAPD_DEFAULT_DIMENSION > &v1, const Vector< int, CAPD_DEFAULT_DIMENSION > &v2)

template Vector< int, CAPD_DEFAULT_DIMENSION >	operator-<int, CAPD_DEFAULT_DIMENSION > (const Vector< int, CAPD_DEFAULT_DIMENSION > &v1, const Vector< int, CAPD_DEFAULT_DIMENSION > &v2)

template int	operator*<int, CAPD_DEFAULT_DIMENSION > (const Vector< int, CAPD_DEFAULT_DIMENSION > &v1, const Vector< int, CAPD_DEFAULT_DIMENSION > &v2)

template Vector< int, CAPD_DEFAULT_DIMENSION >	operator*<int, int, CAPD_DEFAULT_DIMENSION > (const Vector< int, CAPD_DEFAULT_DIMENSION > &v, const int &s)

template Vector< int, CAPD_DEFAULT_DIMENSION >	operator*<int, int, CAPD_DEFAULT_DIMENSION > (const int &s, const Vector< int, CAPD_DEFAULT_DIMENSION > &v)

template Vector< int, CAPD_DEFAULT_DIMENSION >	operator/<int, int, CAPD_DEFAULT_DIMENSION > (const Vector< int, CAPD_DEFAULT_DIMENSION > &v, const int &s)

template Vector< int, CAPD_DEFAULT_DIMENSION >	operator*<int, long, CAPD_DEFAULT_DIMENSION > (const Vector< int, CAPD_DEFAULT_DIMENSION > &v, const long &s)

template Vector< int, CAPD_DEFAULT_DIMENSION >	operator*<int, long, CAPD_DEFAULT_DIMENSION > (const long &s, const Vector< int, CAPD_DEFAULT_DIMENSION > &v)

template Vector< int, CAPD_DEFAULT_DIMENSION >	operator/<int, long, CAPD_DEFAULT_DIMENSION > (const Vector< int, CAPD_DEFAULT_DIMENSION > &v, const long &s)

template Vector< int, CAPD_DEFAULT_DIMENSION >	operator+<int, CAPD_DEFAULT_DIMENSION > (const Vector< int, CAPD_DEFAULT_DIMENSION > &v, const int &s)

template Vector< int, CAPD_DEFAULT_DIMENSION >	operator-<int, CAPD_DEFAULT_DIMENSION > (const Vector< int, CAPD_DEFAULT_DIMENSION > &v, const int &s)

template bool	operator<<int, CAPD_DEFAULT_DIMENSION > (const Vector< int, CAPD_DEFAULT_DIMENSION > &v1, const Vector< int, CAPD_DEFAULT_DIMENSION > &v2)

template bool	operator><int, CAPD_DEFAULT_DIMENSION > (const Vector< int, CAPD_DEFAULT_DIMENSION > &v1, const Vector< int, CAPD_DEFAULT_DIMENSION > &v2)

template bool	operator<=< int, CAPD_DEFAULT_DIMENSION > (const Vector< int, CAPD_DEFAULT_DIMENSION > &v1, const Vector< int, CAPD_DEFAULT_DIMENSION > &v2)

template bool	operator>=< int, CAPD_DEFAULT_DIMENSION > (const Vector< int, CAPD_DEFAULT_DIMENSION > &v1, const Vector< int, CAPD_DEFAULT_DIMENSION > &v2)

template std::ostream &	operator<<< int, CAPD_DEFAULT_DIMENSION > (std::ostream &out, const Vector< int, CAPD_DEFAULT_DIMENSION > &v)

template std::istream &	operator>>< int, CAPD_DEFAULT_DIMENSION > (std::istream &inp, Vector< int, CAPD_DEFAULT_DIMENSION > &v)

template void	subtractObjects (const Vector< int, CAPD_DEFAULT_DIMENSION > &v1, const Vector< int, CAPD_DEFAULT_DIMENSION > &v2, Vector< int, CAPD_DEFAULT_DIMENSION > &result)

template void	addObjects (const Vector< int, CAPD_DEFAULT_DIMENSION > &v1, const Vector< int, CAPD_DEFAULT_DIMENSION > &v2, Vector< int, CAPD_DEFAULT_DIMENSION > &result)

template std::string	cppReprezentation (Vector< int, CAPD_DEFAULT_DIMENSION > const &, std::string const &, std::string const &)

template Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	abs< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	operator-<MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	operator+<MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	operator-<MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	operator*<MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template Vector< MpFloat, CAPD_DEFAULT_DIMENSION >	operator*<MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &)

template Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	operator*<MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const MpFloat &)

template Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	operator*<MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const MpFloat &, const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	operator/<MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const MpFloat &)

template Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	operator+<MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const MpFloat &)

template Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	operator-<MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const MpFloat &)

template bool	operator<<MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template bool	operator><MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template bool	operator<=< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template bool	operator>=< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	Transpose< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template std::ostream &	operator<<< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (std::ostream &, const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template std::istream &	operator>>< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (std::istream &, Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template void	matrixByVector (const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &, Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &)

template void	matrixByMatrix (const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template void	subtractObjects (const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &v1, const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &v2, Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &result)

template void	addObjects (const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &v1, const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &v2, Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &result)

template Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &	addAssignMatrixByVector (Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &u, const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &A, const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v)

template Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &	subtractAssignMatrixByVector (Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &u, const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &A, const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v)

template Vector< MpFloat, CAPD_DEFAULT_DIMENSION >	operator+<MpFloat, CAPD_DEFAULT_DIMENSION > (const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &, const RowVector< MpFloat, CAPD_DEFAULT_DIMENSION > &)

template Vector< MpFloat, CAPD_DEFAULT_DIMENSION >	operator+<MpFloat, CAPD_DEFAULT_DIMENSION > (const RowVector< MpFloat, CAPD_DEFAULT_DIMENSION > &, const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &)

template Vector< MpFloat, CAPD_DEFAULT_DIMENSION >	operator+<MpFloat, CAPD_DEFAULT_DIMENSION > (const RowVector< MpFloat, CAPD_DEFAULT_DIMENSION > &, const RowVector< MpFloat, CAPD_DEFAULT_DIMENSION > &)

template Vector< MpFloat, CAPD_DEFAULT_DIMENSION >	operator-<MpFloat, CAPD_DEFAULT_DIMENSION > (const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &, const RowVector< MpFloat, CAPD_DEFAULT_DIMENSION > &)

template Vector< MpFloat, CAPD_DEFAULT_DIMENSION >	operator-<MpFloat, CAPD_DEFAULT_DIMENSION > (const RowVector< MpFloat, CAPD_DEFAULT_DIMENSION > &, const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &)

template Vector< MpFloat, CAPD_DEFAULT_DIMENSION >	operator-<MpFloat, CAPD_DEFAULT_DIMENSION > (const RowVector< MpFloat, CAPD_DEFAULT_DIMENSION > &, const RowVector< MpFloat, CAPD_DEFAULT_DIMENSION > &)

template MpFloat	operator*<MpFloat, CAPD_DEFAULT_DIMENSION > (const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &, const RowVector< MpFloat, CAPD_DEFAULT_DIMENSION > &)

template MpFloat	operator*<MpFloat, CAPD_DEFAULT_DIMENSION > (const RowVector< MpFloat, CAPD_DEFAULT_DIMENSION > &, const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &)

template MpFloat	operator*<MpFloat, CAPD_DEFAULT_DIMENSION > (const RowVector< MpFloat, CAPD_DEFAULT_DIMENSION > &, const RowVector< MpFloat, CAPD_DEFAULT_DIMENSION > &)

template Vector< MpFloat, CAPD_DEFAULT_DIMENSION >	operator-<MpFloat, CAPD_DEFAULT_DIMENSION > (const RowVector< MpFloat, CAPD_DEFAULT_DIMENSION > &)

template Vector< MpFloat, CAPD_DEFAULT_DIMENSION >	operator*<MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const RowVector< MpFloat, CAPD_DEFAULT_DIMENSION > &)

template Vector< MpFloat, CAPD_DEFAULT_DIMENSION >	operator*<MpFloat, CAPD_DEFAULT_DIMENSION > (const MpFloat &, const RowVector< MpFloat, CAPD_DEFAULT_DIMENSION > &)

template Vector< MpFloat, CAPD_DEFAULT_DIMENSION >	operator*<MpFloat, CAPD_DEFAULT_DIMENSION > (const RowVector< MpFloat, CAPD_DEFAULT_DIMENSION > &, const MpFloat &)

template Vector< MpFloat, CAPD_DEFAULT_DIMENSION >	operator/<MpFloat, CAPD_DEFAULT_DIMENSION > (const RowVector< MpFloat, CAPD_DEFAULT_DIMENSION > &, const MpFloat &)

template std::ostream &	operator<<< MpFloat, CAPD_DEFAULT_DIMENSION > (std::ostream &, const RowVector< MpFloat, CAPD_DEFAULT_DIMENSION > &)

template Vector< MpFloat, CAPD_DEFAULT_DIMENSION >	operator+<MpFloat, CAPD_DEFAULT_DIMENSION > (const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< MpFloat, CAPD_DEFAULT_DIMENSION > &)

template Vector< MpFloat, CAPD_DEFAULT_DIMENSION >	operator+<MpFloat, CAPD_DEFAULT_DIMENSION > (const ColumnVector< MpFloat, CAPD_DEFAULT_DIMENSION > &, const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &)

template Vector< MpFloat, CAPD_DEFAULT_DIMENSION >	operator+<MpFloat, CAPD_DEFAULT_DIMENSION > (const ColumnVector< MpFloat, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< MpFloat, CAPD_DEFAULT_DIMENSION > &)

template Vector< MpFloat, CAPD_DEFAULT_DIMENSION >	operator-<MpFloat, CAPD_DEFAULT_DIMENSION > (const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< MpFloat, CAPD_DEFAULT_DIMENSION > &)

template Vector< MpFloat, CAPD_DEFAULT_DIMENSION >	operator-<MpFloat, CAPD_DEFAULT_DIMENSION > (const ColumnVector< MpFloat, CAPD_DEFAULT_DIMENSION > &, const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &)

template Vector< MpFloat, CAPD_DEFAULT_DIMENSION >	operator-<MpFloat, CAPD_DEFAULT_DIMENSION > (const ColumnVector< MpFloat, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< MpFloat, CAPD_DEFAULT_DIMENSION > &)

template MpFloat	operator*<MpFloat, CAPD_DEFAULT_DIMENSION > (const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< MpFloat, CAPD_DEFAULT_DIMENSION > &)

template MpFloat	operator*<MpFloat, CAPD_DEFAULT_DIMENSION > (const ColumnVector< MpFloat, CAPD_DEFAULT_DIMENSION > &, const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &)

template MpFloat	operator*<MpFloat, CAPD_DEFAULT_DIMENSION > (const ColumnVector< MpFloat, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< MpFloat, CAPD_DEFAULT_DIMENSION > &)

template Vector< MpFloat, CAPD_DEFAULT_DIMENSION >	operator-<MpFloat, CAPD_DEFAULT_DIMENSION > (const ColumnVector< MpFloat, CAPD_DEFAULT_DIMENSION > &)

template Vector< MpFloat, CAPD_DEFAULT_DIMENSION >	operator*<MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< MpFloat, CAPD_DEFAULT_DIMENSION > &)

template Vector< MpFloat, CAPD_DEFAULT_DIMENSION >	operator*<MpFloat, CAPD_DEFAULT_DIMENSION > (const MpFloat &, const ColumnVector< MpFloat, CAPD_DEFAULT_DIMENSION > &)

template Vector< MpFloat, CAPD_DEFAULT_DIMENSION >	operator*<MpFloat, CAPD_DEFAULT_DIMENSION > (const ColumnVector< MpFloat, CAPD_DEFAULT_DIMENSION > &, const MpFloat &)

template Vector< MpFloat, CAPD_DEFAULT_DIMENSION >	operator/<MpFloat, CAPD_DEFAULT_DIMENSION > (const ColumnVector< MpFloat, CAPD_DEFAULT_DIMENSION > &, const MpFloat &)

template std::ostream &	operator<<< MpFloat, CAPD_DEFAULT_DIMENSION > (std::ostream &, const ColumnVector< MpFloat, CAPD_DEFAULT_DIMENSION > &)

template std::string	cppReprezentation (Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > const &, std::string const &, std::string const &)

template Vector< MpFloat, CAPD_DEFAULT_DIMENSION >	abs< MpFloat, CAPD_DEFAULT_DIMENSION > (const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v)

template Vector< MpFloat, CAPD_DEFAULT_DIMENSION >	operator-<MpFloat, CAPD_DEFAULT_DIMENSION > (const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v)

template Vector< MpFloat, CAPD_DEFAULT_DIMENSION >	operator+<MpFloat, CAPD_DEFAULT_DIMENSION > (const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v1, const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v2)

template Vector< MpFloat, CAPD_DEFAULT_DIMENSION >	operator-<MpFloat, CAPD_DEFAULT_DIMENSION > (const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v1, const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v2)

template MpFloat	operator*<MpFloat, CAPD_DEFAULT_DIMENSION > (const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v1, const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v2)

template Vector< MpFloat, CAPD_DEFAULT_DIMENSION >	operator*<MpFloat, MpFloat, CAPD_DEFAULT_DIMENSION > (const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v, const MpFloat &s)

template Vector< MpFloat, CAPD_DEFAULT_DIMENSION >	operator*<MpFloat, MpFloat, CAPD_DEFAULT_DIMENSION > (const MpFloat &s, const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v)

template Vector< MpFloat, CAPD_DEFAULT_DIMENSION >	operator/<MpFloat, MpFloat, CAPD_DEFAULT_DIMENSION > (const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v, const MpFloat &s)

template Vector< MpFloat, CAPD_DEFAULT_DIMENSION >	operator*<MpFloat, long, CAPD_DEFAULT_DIMENSION > (const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v, const long &s)

template Vector< MpFloat, CAPD_DEFAULT_DIMENSION >	operator*<MpFloat, long, CAPD_DEFAULT_DIMENSION > (const long &s, const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v)

template Vector< MpFloat, CAPD_DEFAULT_DIMENSION >	operator/<MpFloat, long, CAPD_DEFAULT_DIMENSION > (const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v, const long &s)

template Vector< MpFloat, CAPD_DEFAULT_DIMENSION >	operator*<MpFloat, int, CAPD_DEFAULT_DIMENSION > (const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v, const int &s)

template Vector< MpFloat, CAPD_DEFAULT_DIMENSION >	operator*<MpFloat, int, CAPD_DEFAULT_DIMENSION > (const int &s, const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v)

template Vector< MpFloat, CAPD_DEFAULT_DIMENSION >	operator/<MpFloat, int, CAPD_DEFAULT_DIMENSION > (const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v, const int &s)

template Vector< MpFloat, CAPD_DEFAULT_DIMENSION >	operator+<MpFloat, CAPD_DEFAULT_DIMENSION > (const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v, const MpFloat &s)

template Vector< MpFloat, CAPD_DEFAULT_DIMENSION >	operator-<MpFloat, CAPD_DEFAULT_DIMENSION > (const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v, const MpFloat &s)

template bool	operator<<MpFloat, CAPD_DEFAULT_DIMENSION > (const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v1, const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v2)

template bool	operator><MpFloat, CAPD_DEFAULT_DIMENSION > (const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v1, const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v2)

template bool	operator<=< MpFloat, CAPD_DEFAULT_DIMENSION > (const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v1, const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v2)

template bool	operator>=< MpFloat, CAPD_DEFAULT_DIMENSION > (const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v1, const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v2)

template std::ostream &	operator<<< MpFloat, CAPD_DEFAULT_DIMENSION > (std::ostream &out, const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v)

template std::istream &	operator>>< MpFloat, CAPD_DEFAULT_DIMENSION > (std::istream &inp, Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v)

template void	subtractObjects (const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v1, const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v2, Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &result)

template void	addObjects (const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v1, const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v2, Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &result)

template Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	abs< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	operator-<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	operator+<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	operator-<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	operator*<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template Vector< MpInt, CAPD_DEFAULT_DIMENSION >	operator*<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &)

template Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	operator*<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const MpInt &)

template Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	operator*<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const MpInt &, const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	operator/<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const MpInt &)

template Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	operator+<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const MpInt &)

template Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	operator-<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const MpInt &)

template bool	operator<<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template bool	operator><MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template bool	operator<=< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template bool	operator>=< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	Transpose< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template std::ostream &	operator<<< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (std::ostream &, const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template std::istream &	operator>>< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (std::istream &, Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template void	matrixByVector (const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &, Vector< MpInt, CAPD_DEFAULT_DIMENSION > &)

template void	matrixByMatrix (const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)

template void	subtractObjects (const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &v1, const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &v2, Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &result)

template void	addObjects (const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &v1, const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &v2, Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &result)

template Vector< MpInt, CAPD_DEFAULT_DIMENSION >	operator+<MpInt, CAPD_DEFAULT_DIMENSION > (const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &, const RowVector< MpInt, CAPD_DEFAULT_DIMENSION > &)

template Vector< MpInt, CAPD_DEFAULT_DIMENSION >	operator+<MpInt, CAPD_DEFAULT_DIMENSION > (const RowVector< MpInt, CAPD_DEFAULT_DIMENSION > &, const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &)

template Vector< MpInt, CAPD_DEFAULT_DIMENSION >	operator+<MpInt, CAPD_DEFAULT_DIMENSION > (const RowVector< MpInt, CAPD_DEFAULT_DIMENSION > &, const RowVector< MpInt, CAPD_DEFAULT_DIMENSION > &)

template Vector< MpInt, CAPD_DEFAULT_DIMENSION >	operator-<MpInt, CAPD_DEFAULT_DIMENSION > (const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &, const RowVector< MpInt, CAPD_DEFAULT_DIMENSION > &)

template Vector< MpInt, CAPD_DEFAULT_DIMENSION >	operator-<MpInt, CAPD_DEFAULT_DIMENSION > (const RowVector< MpInt, CAPD_DEFAULT_DIMENSION > &, const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &)

template Vector< MpInt, CAPD_DEFAULT_DIMENSION >	operator-<MpInt, CAPD_DEFAULT_DIMENSION > (const RowVector< MpInt, CAPD_DEFAULT_DIMENSION > &, const RowVector< MpInt, CAPD_DEFAULT_DIMENSION > &)

template MpInt	operator*<MpInt, CAPD_DEFAULT_DIMENSION > (const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &, const RowVector< MpInt, CAPD_DEFAULT_DIMENSION > &)

template MpInt	operator*<MpInt, CAPD_DEFAULT_DIMENSION > (const RowVector< MpInt, CAPD_DEFAULT_DIMENSION > &, const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &)

template MpInt	operator*<MpInt, CAPD_DEFAULT_DIMENSION > (const RowVector< MpInt, CAPD_DEFAULT_DIMENSION > &, const RowVector< MpInt, CAPD_DEFAULT_DIMENSION > &)

template Vector< MpInt, CAPD_DEFAULT_DIMENSION >	operator-<MpInt, CAPD_DEFAULT_DIMENSION > (const RowVector< MpInt, CAPD_DEFAULT_DIMENSION > &)

template Vector< MpInt, CAPD_DEFAULT_DIMENSION >	operator*<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const RowVector< MpInt, CAPD_DEFAULT_DIMENSION > &)

template Vector< MpInt, CAPD_DEFAULT_DIMENSION >	operator*<MpInt, CAPD_DEFAULT_DIMENSION > (const MpInt &, const RowVector< MpInt, CAPD_DEFAULT_DIMENSION > &)

template Vector< MpInt, CAPD_DEFAULT_DIMENSION >	operator*<MpInt, CAPD_DEFAULT_DIMENSION > (const RowVector< MpInt, CAPD_DEFAULT_DIMENSION > &, const MpInt &)

template Vector< MpInt, CAPD_DEFAULT_DIMENSION >	operator/<MpInt, CAPD_DEFAULT_DIMENSION > (const RowVector< MpInt, CAPD_DEFAULT_DIMENSION > &, const MpInt &)

template std::ostream &	operator<<< MpInt, CAPD_DEFAULT_DIMENSION > (std::ostream &, const RowVector< MpInt, CAPD_DEFAULT_DIMENSION > &)

template Vector< MpInt, CAPD_DEFAULT_DIMENSION >	operator+<MpInt, CAPD_DEFAULT_DIMENSION > (const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< MpInt, CAPD_DEFAULT_DIMENSION > &)

template Vector< MpInt, CAPD_DEFAULT_DIMENSION >	operator+<MpInt, CAPD_DEFAULT_DIMENSION > (const ColumnVector< MpInt, CAPD_DEFAULT_DIMENSION > &, const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &)

template Vector< MpInt, CAPD_DEFAULT_DIMENSION >	operator+<MpInt, CAPD_DEFAULT_DIMENSION > (const ColumnVector< MpInt, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< MpInt, CAPD_DEFAULT_DIMENSION > &)

template Vector< MpInt, CAPD_DEFAULT_DIMENSION >	operator-<MpInt, CAPD_DEFAULT_DIMENSION > (const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< MpInt, CAPD_DEFAULT_DIMENSION > &)

template Vector< MpInt, CAPD_DEFAULT_DIMENSION >	operator-<MpInt, CAPD_DEFAULT_DIMENSION > (const ColumnVector< MpInt, CAPD_DEFAULT_DIMENSION > &, const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &)

template Vector< MpInt, CAPD_DEFAULT_DIMENSION >	operator-<MpInt, CAPD_DEFAULT_DIMENSION > (const ColumnVector< MpInt, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< MpInt, CAPD_DEFAULT_DIMENSION > &)

template MpInt	operator*<MpInt, CAPD_DEFAULT_DIMENSION > (const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< MpInt, CAPD_DEFAULT_DIMENSION > &)

template MpInt	operator*<MpInt, CAPD_DEFAULT_DIMENSION > (const ColumnVector< MpInt, CAPD_DEFAULT_DIMENSION > &, const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &)

template MpInt	operator*<MpInt, CAPD_DEFAULT_DIMENSION > (const ColumnVector< MpInt, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< MpInt, CAPD_DEFAULT_DIMENSION > &)

template Vector< MpInt, CAPD_DEFAULT_DIMENSION >	operator-<MpInt, CAPD_DEFAULT_DIMENSION > (const ColumnVector< MpInt, CAPD_DEFAULT_DIMENSION > &)

template Vector< MpInt, CAPD_DEFAULT_DIMENSION >	operator*<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< MpInt, CAPD_DEFAULT_DIMENSION > &)

template Vector< MpInt, CAPD_DEFAULT_DIMENSION >	operator*<MpInt, CAPD_DEFAULT_DIMENSION > (const MpInt &, const ColumnVector< MpInt, CAPD_DEFAULT_DIMENSION > &)

template Vector< MpInt, CAPD_DEFAULT_DIMENSION >	operator*<MpInt, CAPD_DEFAULT_DIMENSION > (const ColumnVector< MpInt, CAPD_DEFAULT_DIMENSION > &, const MpInt &)

template Vector< MpInt, CAPD_DEFAULT_DIMENSION >	operator/<MpInt, CAPD_DEFAULT_DIMENSION > (const ColumnVector< MpInt, CAPD_DEFAULT_DIMENSION > &, const MpInt &)

template std::ostream &	operator<<< MpInt, CAPD_DEFAULT_DIMENSION > (std::ostream &, const ColumnVector< MpInt, CAPD_DEFAULT_DIMENSION > &)

template Vector< MpInt, CAPD_DEFAULT_DIMENSION >	abs< MpInt, CAPD_DEFAULT_DIMENSION > (const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v)

template Vector< MpInt, CAPD_DEFAULT_DIMENSION >	operator-<MpInt, CAPD_DEFAULT_DIMENSION > (const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v)

template Vector< MpInt, CAPD_DEFAULT_DIMENSION >	operator+<MpInt, CAPD_DEFAULT_DIMENSION > (const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v1, const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v2)

template Vector< MpInt, CAPD_DEFAULT_DIMENSION >	operator-<MpInt, CAPD_DEFAULT_DIMENSION > (const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v1, const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v2)

template MpInt	operator*<MpInt, CAPD_DEFAULT_DIMENSION > (const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v1, const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v2)

template Vector< MpInt, CAPD_DEFAULT_DIMENSION >	operator*<MpInt, MpInt, CAPD_DEFAULT_DIMENSION > (const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v, const MpInt &s)

template Vector< MpInt, CAPD_DEFAULT_DIMENSION >	operator*<MpInt, MpInt, CAPD_DEFAULT_DIMENSION > (const MpInt &s, const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v)

template Vector< MpInt, CAPD_DEFAULT_DIMENSION >	operator/<MpInt, MpInt, CAPD_DEFAULT_DIMENSION > (const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v, const MpInt &s)

template Vector< MpInt, CAPD_DEFAULT_DIMENSION >	operator*<MpInt, long, CAPD_DEFAULT_DIMENSION > (const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v, const long &s)

template Vector< MpInt, CAPD_DEFAULT_DIMENSION >	operator*<MpInt, long, CAPD_DEFAULT_DIMENSION > (const long &s, const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v)

template Vector< MpInt, CAPD_DEFAULT_DIMENSION >	operator/<MpInt, long, CAPD_DEFAULT_DIMENSION > (const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v, const long &s)

template Vector< MpInt, CAPD_DEFAULT_DIMENSION >	operator*<MpInt, int, CAPD_DEFAULT_DIMENSION > (const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v, const int &s)

template Vector< MpInt, CAPD_DEFAULT_DIMENSION >	operator*<MpInt, int, CAPD_DEFAULT_DIMENSION > (const int &s, const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v)

template Vector< MpInt, CAPD_DEFAULT_DIMENSION >	operator/<MpInt, int, CAPD_DEFAULT_DIMENSION > (const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v, const int &s)

template Vector< MpInt, CAPD_DEFAULT_DIMENSION >	operator+<MpInt, CAPD_DEFAULT_DIMENSION > (const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v, const MpInt &s)

template Vector< MpInt, CAPD_DEFAULT_DIMENSION >	operator-<MpInt, CAPD_DEFAULT_DIMENSION > (const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v, const MpInt &s)

template bool	operator<<MpInt, CAPD_DEFAULT_DIMENSION > (const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v1, const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v2)

template bool	operator><MpInt, CAPD_DEFAULT_DIMENSION > (const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v1, const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v2)

template bool	operator<=< MpInt, CAPD_DEFAULT_DIMENSION > (const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v1, const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v2)

template bool	operator>=< MpInt, CAPD_DEFAULT_DIMENSION > (const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v1, const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v2)

template std::ostream &	operator<<< MpInt, CAPD_DEFAULT_DIMENSION > (std::ostream &out, const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v)

template std::istream &	operator>>< MpInt, CAPD_DEFAULT_DIMENSION > (std::istream &inp, Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v)

template void	subtractObjects (const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v1, const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v2, Vector< MpInt, CAPD_DEFAULT_DIMENSION > &result)

template void	addObjects (const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v1, const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v2, Vector< MpInt, CAPD_DEFAULT_DIMENSION > &result)

Typedef Documentation

◆ __difference_type

typedef int capd::vectalg::__difference_type

◆ __size_type

typedef unsigned capd::vectalg::__size_type

◆ DMatrix

typedef Matrix<capd::DInterval::BoundType,CAPD_DEFAULT_DIMENSION,CAPD_DEFAULT_DIMENSION> capd::vectalg::DMatrix

◆ DVector

typedef Vector< capd::DInterval::BoundType, CAPD_DEFAULT_DIMENSION > capd::vectalg::DVector

◆ IMatrix

typedef Matrix<capd::DInterval,CAPD_DEFAULT_DIMENSION,CAPD_DEFAULT_DIMENSION> capd::vectalg::IMatrix

◆ IVector

typedef Vector<capd::DInterval,CAPD_DEFAULT_DIMENSION> capd::vectalg::IVector

◆ LDVector

typedef Vector<long double,CAPD_DEFAULT_DIMENSION> capd::vectalg::LDVector

Function Documentation

◆ abs() [1/2]

template<typename Scalar , __size_type rows, __size_type cols>

Matrix<Scalar,rows,cols> capd::vectalg::abs ( const Matrix< Scalar, rows, cols > & m )

inline

◆ abs() [2/2]

template<typename Scalar , __size_type dim>

Vector<Scalar,dim> capd::vectalg::abs ( const Vector< Scalar, dim > & v )

inline

◆ abs< capd::DInterval, CAPD_DEFAULT_DIMENSION >()

template Vector<capd::DInterval,CAPD_DEFAULT_DIMENSION> capd::vectalg::abs< capd::DInterval, CAPD_DEFAULT_DIMENSION > ( const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > & v )

◆ abs< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

template Matrix<capd::DInterval,CAPD_DEFAULT_DIMENSION,CAPD_DEFAULT_DIMENSION> capd::vectalg::abs< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > ( const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > & )

◆ abs< double, CAPD_DEFAULT_DIMENSION >()

template Vector<double,CAPD_DEFAULT_DIMENSION> capd::vectalg::abs< double, CAPD_DEFAULT_DIMENSION > ( const Vector< double, CAPD_DEFAULT_DIMENSION > & v )

◆ abs< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

template Matrix<double,CAPD_DEFAULT_DIMENSION,CAPD_DEFAULT_DIMENSION> capd::vectalg::abs< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > ( const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > & )

◆ abs< int, CAPD_DEFAULT_DIMENSION >()

template Vector<int,CAPD_DEFAULT_DIMENSION> capd::vectalg::abs< int, CAPD_DEFAULT_DIMENSION > ( const Vector< int, CAPD_DEFAULT_DIMENSION > & v )

◆ abs< long double, CAPD_DEFAULT_DIMENSION >()

template Vector<long double,CAPD_DEFAULT_DIMENSION> capd::vectalg::abs< long double, CAPD_DEFAULT_DIMENSION > ( const Vector< long double, CAPD_DEFAULT_DIMENSION > & v )

◆ abs< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

template Matrix<long double,CAPD_DEFAULT_DIMENSION,CAPD_DEFAULT_DIMENSION> capd::vectalg::abs< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > ( const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > & )

◆ abs< MpFloat, CAPD_DEFAULT_DIMENSION >()

template Vector<MpFloat,CAPD_DEFAULT_DIMENSION> capd::vectalg::abs< MpFloat, CAPD_DEFAULT_DIMENSION > ( const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > & v )

◆ abs< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

template Matrix<MpFloat,CAPD_DEFAULT_DIMENSION,CAPD_DEFAULT_DIMENSION> capd::vectalg::abs< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > ( const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > & )

◆ abs< MpInt, CAPD_DEFAULT_DIMENSION >()

template Vector<MpInt,CAPD_DEFAULT_DIMENSION> capd::vectalg::abs< MpInt, CAPD_DEFAULT_DIMENSION > ( const Vector< MpInt, CAPD_DEFAULT_DIMENSION > & v )

◆ abs< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

template Matrix<MpInt,CAPD_DEFAULT_DIMENSION,CAPD_DEFAULT_DIMENSION> capd::vectalg::abs< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > ( const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > & )

◆ absoluteValue()

template<typename ResultType , typename Object >

ResultType capd::vectalg::absoluteValue ( const Object & v )

◆ addAssignMatrixByVector() [1/5]

template<typename V , typename M , typename V2 >

V & capd::vectalg::addAssignMatrixByVector	(	V &	u,
		const M &	A,
		const V2 &	v
	)

This procedure computes u += A*v where u,v are vectors and A is a matrix.

◆ addAssignMatrixByVector() [2/5]

template Vector<capd::DInterval,CAPD_DEFAULT_DIMENSION>& capd::vectalg::addAssignMatrixByVector	(	Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	u,
		const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	A,
		const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	v
	)

◆ addAssignMatrixByVector() [3/5]

template Vector<double,CAPD_DEFAULT_DIMENSION>& capd::vectalg::addAssignMatrixByVector	(	Vector< double, CAPD_DEFAULT_DIMENSION > &	u,
		const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	A,
		const Vector< double, CAPD_DEFAULT_DIMENSION > &	v
	)

◆ addAssignMatrixByVector() [4/5]

template Vector<long double,CAPD_DEFAULT_DIMENSION>& capd::vectalg::addAssignMatrixByVector	(	Vector< long double, CAPD_DEFAULT_DIMENSION > &	u,
		const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	A,
		const Vector< long double, CAPD_DEFAULT_DIMENSION > &	v
	)

◆ addAssignMatrixByVector() [5/5]

template Vector<MpFloat,CAPD_DEFAULT_DIMENSION>& capd::vectalg::addAssignMatrixByVector	(	Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &	u,
		const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	A,
		const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &	v
	)

◆ addAssignObjectObject() [1/2]

template<typename T1 , typename T2 >

T1 & capd::vectalg::addAssignObjectObject	(	T1 &	u,
		const T2 &	v
	)

this procedure can be use to add of two vector-like objects result is stored in the first argument u += v

◆ addAssignObjectObject() [2/2]

template Vector<double, CAPD_DEFAULT_DIMENSION>& capd::vectalg::addAssignObjectObject	(	Vector< double, CAPD_DEFAULT_DIMENSION > &	,
		Vector< double, CAPD_DEFAULT_DIMENSION > const &
	)

◆ addAssignObjectScalar() [1/2]

template<typename Object , typename Scalar >

Object & capd::vectalg::addAssignObjectScalar	(	Object &	u,
		const Scalar &	s
	)

this procedure can be use to add a scalar to each element of a vector-like object u[i] += s

this procedure can be use to add a scalar to any element of two vector-like objects u[i] += s

◆ addAssignObjectScalar() [2/2]

template Vector<capd::DInterval,CAPD_DEFAULT_DIMENSION>& capd::vectalg::addAssignObjectScalar	(	Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	v1,
		const capd::DInterval &
	)

◆ addIndex()

Multipointer capd::vectalg::addIndex	(	const Multipointer &	mp,
		int	index
	)

returns new multipointer which is multiindex mp with index added in correct place

◆ addObjects() [1/14]

template void capd::vectalg::addObjects	(	const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	v1,
		const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	v2,
		Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	result
	)

◆ addObjects() [2/14]

template void capd::vectalg::addObjects	(	const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	v1,
		const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	v2,
		Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	result
	)

◆ addObjects() [3/14]

template void capd::vectalg::addObjects	(	const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	v1,
		const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	v2,
		Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	result
	)

◆ addObjects() [4/14]

template void capd::vectalg::addObjects	(	const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	v1,
		const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	v2,
		Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	result
	)

◆ addObjects() [5/14]

template void capd::vectalg::addObjects	(	const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	v1,
		const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	v2,
		Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	result
	)

◆ addObjects() [6/14]

template<typename ResultType , typename T1 , typename T2 >

ResultType capd::vectalg::addObjects	(	const T1 &	v1,
		const T2 &	v2
	)

inline

◆ addObjects() [7/14]

template<typename ResultType , typename T1 , typename T2 >

void capd::vectalg::addObjects	(	const T1 &	v1,
		const T2 &	v2,
		ResultType &	result
	)

this procedure can be use to add two vector-like objects:

vectors, matrices, references to columns or rows of matrix
higher dimensional containers result = v1 + v2

◆ addObjects() [8/14]

template void capd::vectalg::addObjects	(	const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	,
		const ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	,
		Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &
	)

◆ addObjects() [9/14]

template void capd::vectalg::addObjects	(	const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	,
		const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	,
		Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &
	)

◆ addObjects() [10/14]

template void capd::vectalg::addObjects	(	const Vector< double, CAPD_DEFAULT_DIMENSION > &	v1,
		const Vector< double, CAPD_DEFAULT_DIMENSION > &	v2,
		Vector< double, CAPD_DEFAULT_DIMENSION > &	result
	)

◆ addObjects() [11/14]

template void capd::vectalg::addObjects	(	const Vector< int, CAPD_DEFAULT_DIMENSION > &	v1,
		const Vector< int, CAPD_DEFAULT_DIMENSION > &	v2,
		Vector< int, CAPD_DEFAULT_DIMENSION > &	result
	)

◆ addObjects() [12/14]

template void capd::vectalg::addObjects	(	const Vector< long double, CAPD_DEFAULT_DIMENSION > &	v1,
		const Vector< long double, CAPD_DEFAULT_DIMENSION > &	v2,
		Vector< long double, CAPD_DEFAULT_DIMENSION > &	result
	)

◆ addObjects() [13/14]

template void capd::vectalg::addObjects	(	const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &	v1,
		const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &	v2,
		Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &	result
	)

◆ addObjects() [14/14]

template void capd::vectalg::addObjects	(	const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &	v1,
		const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &	v2,
		Vector< MpInt, CAPD_DEFAULT_DIMENSION > &	result
	)

◆ addObjectScalar() [1/2]

template<typename ResultType , typename Object , typename FactorType >

ResultType capd::vectalg::addObjectScalar	(	const Object &	v,
		const FactorType &	s
	)

this procedure can be use to add a scalar to any element of vector-like objects result[i] = v[i] + s

◆ addObjectScalar() [2/2]

template Vector<capd::DInterval,CAPD_DEFAULT_DIMENSION> capd::vectalg::addObjectScalar	(	Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > const &	,
		capd::DInterval const &
	)

◆ assignFromScalar() [1/2]

template IMatrix& capd::vectalg::assignFromScalar	(	IMatrix &	,
		capd::DInterval const &
	)

◆ assignFromScalar() [2/2]

template<typename Object , typename Scalar >

Object & capd::vectalg::assignFromScalar	(	Object &	u,
		const Scalar &	s
	)

this procedure can be use to assign each element of a vector-like object to be equal to a given scalar u[i] = s

this procedure can be use to assign any element of two vector-like objects to be equal to a given scalar u[i] = s

◆ assignObjectObject() [1/13]

template ColumnVector<capd::DInterval, CAPD_DEFAULT_DIMENSION>& capd::vectalg::assignObjectObject	(	ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	,
		ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > const &
	)

◆ assignObjectObject() [2/13]

template ColumnVector<capd::DInterval, CAPD_DEFAULT_DIMENSION>& capd::vectalg::assignObjectObject	(	ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	,
		Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > const &
	)

◆ assignObjectObject() [3/13]

template ColumnVector<double, CAPD_DEFAULT_DIMENSION>& capd::vectalg::assignObjectObject	(	ColumnVector< double, CAPD_DEFAULT_DIMENSION > &	,
		ColumnVector< double, CAPD_DEFAULT_DIMENSION > const &
	)

◆ assignObjectObject() [4/13]

template ColumnVector<double, CAPD_DEFAULT_DIMENSION>& capd::vectalg::assignObjectObject	(	ColumnVector< double, CAPD_DEFAULT_DIMENSION > &	,
		Vector< double, CAPD_DEFAULT_DIMENSION > const &
	)

◆ assignObjectObject() [5/13]

template ColumnVector<long double, CAPD_DEFAULT_DIMENSION>& capd::vectalg::assignObjectObject	(	ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &	,
		ColumnVector< long double, CAPD_DEFAULT_DIMENSION > const &
	)

◆ assignObjectObject() [6/13]

template ColumnVector<long double, CAPD_DEFAULT_DIMENSION>& capd::vectalg::assignObjectObject	(	ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &	,
		Vector< long double, CAPD_DEFAULT_DIMENSION > const &
	)

◆ assignObjectObject() [7/13]

template RowVector<capd::DInterval, CAPD_DEFAULT_DIMENSION>& capd::vectalg::assignObjectObject	(	RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	,
		RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > const &
	)

◆ assignObjectObject() [8/13]

template RowVector<capd::DInterval, CAPD_DEFAULT_DIMENSION>& capd::vectalg::assignObjectObject	(	RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	,
		Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > const &
	)

◆ assignObjectObject() [9/13]

template RowVector<double, CAPD_DEFAULT_DIMENSION>& capd::vectalg::assignObjectObject	(	RowVector< double, CAPD_DEFAULT_DIMENSION > &	,
		RowVector< double, CAPD_DEFAULT_DIMENSION > const &
	)

◆ assignObjectObject() [10/13]

template RowVector<long double, CAPD_DEFAULT_DIMENSION>& capd::vectalg::assignObjectObject	(	RowVector< long double, CAPD_DEFAULT_DIMENSION > &	,
		RowVector< long double, CAPD_DEFAULT_DIMENSION > const &
	)

◆ assignObjectObject() [11/13]

template<typename T1 , typename T2 >

T1 & capd::vectalg::assignObjectObject	(	T1 &	u,
		const T2 &	v
	)

this procedure can be use to assign one vector-like objects from the other.

u = v

◆ assignObjectObject() [12/13]

template Vector<capd::DInterval, CAPD_DEFAULT_DIMENSION>& capd::vectalg::assignObjectObject	(	Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	,
		Vector< double, CAPD_DEFAULT_DIMENSION > const &
	)

◆ assignObjectObject() [13/13]

template Vector<double, CAPD_DEFAULT_DIMENSION>& capd::vectalg::assignObjectObject	(	Vector< double, CAPD_DEFAULT_DIMENSION > &	,
		Vector< double, CAPD_DEFAULT_DIMENSION > const &
	)

◆ clear() [1/4]

template void capd::vectalg::clear ( ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > & )

◆ clear() [2/4]

template void capd::vectalg::clear ( ColumnVector< double, CAPD_DEFAULT_DIMENSION > & )

◆ clear() [3/4]

template void capd::vectalg::clear ( ColumnVector< long double, CAPD_DEFAULT_DIMENSION > & )

◆ clear() [4/4]

template<typename Object >

void capd::vectalg::clear ( Object & u )

Assign zero to each coordinate.

◆ computeNewton()

int capd::vectalg::computeNewton	(	int	d,
		int	l
	)

inline

◆ copyFromSubmatrix()

template<typename MatrixType1 , typename MatrixType2 >

void capd::vectalg::copyFromSubmatrix	(	const MatrixType1 &	src,
		MatrixType2 &	target,
		int	startRow,
		int	stopRow,
		int	startCol,
		int	stopCol
	)

it copies src[startRow..stopRow)[startCol..stopCol) into target

◆ copyFromSubvector()

template<typename VectorType1 , typename VectorType2 >

void capd::vectalg::copyFromSubvector	(	const VectorType1 &	src,
		VectorType2 &	target,
		int	start,
		int	stop
	)

it copies src[start..stop] into target

◆ copyToSubmatrix()

template<typename MatrixType1 , typename MatrixType2 >

void capd::vectalg::copyToSubmatrix	(	const MatrixType1 &	src,
		MatrixType2 &	target,
		int	startRow,
		int	stopRow,
		int	startCol,
		int	stopCol
	)

it copies src into target[startRow..stopRow)[startCol..stopCol)

◆ copyToSubvector()

template<typename VectorType1 , typename VectorType2 >

void capd::vectalg::copyToSubvector	(	const VectorType1 &	src,
		VectorType2 &	target,
		int	start,
		int	stop
	)

it copies src into target[start..stop]

◆ cppReprezentation() [1/8]

template<typename Scalar , __size_type rows>

std::string capd::vectalg::cppReprezentation	(	const ColumnVector< Scalar, rows > &	A,
		const std::string &	varName,
		const std::string &	typeName
	)

It serializes a matrix - gives text reprezentation which can be compiled.

◆ cppReprezentation() [2/8]

template<typename Scalar , __size_type rows, __size_type cols>

std::string capd::vectalg::cppReprezentation	(	const Matrix< Scalar, cols, rows > &	A,
		const std::string &	varName,
		const std::string &	typeName
	)

It serializes a matrix - gives text reprezentation which can be compiled.

◆ cppReprezentation() [3/8]

template std::string capd::vectalg::cppReprezentation	(	Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > const &	,
		std::string const &	,
		std::string const &
	)

◆ cppReprezentation() [4/8]

template std::string capd::vectalg::cppReprezentation	(	Matrix< int, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > const &	,
		std::string const &	,
		std::string const &
	)

◆ cppReprezentation() [5/8]

template std::string capd::vectalg::cppReprezentation	(	Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > const &	,
		std::string const &	,
		std::string const &
	)

◆ cppReprezentation() [6/8]

template std::string capd::vectalg::cppReprezentation	(	Vector< double, CAPD_DEFAULT_DIMENSION > const &	,
		std::string const &	,
		std::string const &
	)

◆ cppReprezentation() [7/8]

template std::string capd::vectalg::cppReprezentation	(	Vector< int, CAPD_DEFAULT_DIMENSION > const &	,
		std::string const &	,
		std::string const &
	)

◆ cppReprezentation() [8/8]

template std::string capd::vectalg::cppReprezentation	(	Vector< long double, CAPD_DEFAULT_DIMENSION > const &	,
		std::string const &	,
		std::string const &
	)

◆ diam() [1/3]

template<typename IVector >

IVector capd::vectalg::diam ( const IVector & )

◆ diam() [2/3]

template<typename IVectorType >

IVectorType capd::vectalg::diam ( const IVectorType & v )

◆ diam() [3/3]

template<typename Scalar , __size_type cols>

Vector< Scalar, cols > capd::vectalg::diam ( const RowVector< Scalar, cols > & v )

◆ diam< IMatrix >()

template IMatrix capd::vectalg::diam< IMatrix > ( const IMatrix & v )

◆ diam< IVector >()

template IVector capd::vectalg::diam< IVector > ( const IVector & v )

◆ divideAssignObjectScalar() [1/7]

template ColumnVector<capd::DInterval, CAPD_DEFAULT_DIMENSION>& capd::vectalg::divideAssignObjectScalar	(	ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	,
		capd::DInterval const &
	)

◆ divideAssignObjectScalar() [2/7]

template ColumnVector<double, CAPD_DEFAULT_DIMENSION>& capd::vectalg::divideAssignObjectScalar	(	ColumnVector< double, CAPD_DEFAULT_DIMENSION > &	,
		double const &
	)

◆ divideAssignObjectScalar() [3/7]

template ColumnVector<long double, CAPD_DEFAULT_DIMENSION>& capd::vectalg::divideAssignObjectScalar	(	ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &	,
		long double const &
	)

◆ divideAssignObjectScalar() [4/7]

template<typename Object , typename Scalar >

Object & capd::vectalg::divideAssignObjectScalar	(	Object &	u,
		const Scalar &	s
	)

this procedure can be use to divide by a scalar any element of two vector-like objects u[i] /= s

◆ divideAssignObjectScalar() [5/7]

template RowVector<capd::DInterval, CAPD_DEFAULT_DIMENSION>& capd::vectalg::divideAssignObjectScalar	(	RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	,
		capd::DInterval const &
	)

◆ divideAssignObjectScalar() [6/7]

template RowVector<double, CAPD_DEFAULT_DIMENSION>& capd::vectalg::divideAssignObjectScalar	(	RowVector< double, CAPD_DEFAULT_DIMENSION > &	,
		double const &
	)

◆ divideAssignObjectScalar() [7/7]

template RowVector<long double, CAPD_DEFAULT_DIMENSION>& capd::vectalg::divideAssignObjectScalar	(	RowVector< long double, CAPD_DEFAULT_DIMENSION > &	,
		long double const &
	)

◆ divideObjectScalar() [1/6]

template DVector capd::vectalg::divideObjectScalar	(	const DVector &	v1,
		const double &	s
	)

◆ divideObjectScalar() [2/6]

template LDVector capd::vectalg::divideObjectScalar	(	const LDVector &	v1,
		const long double &	s
	)

◆ divideObjectScalar() [3/6]

template<typename ResultType , typename Object , typename FactorType >

ResultType capd::vectalg::divideObjectScalar	(	const Object &	v,
		const FactorType &	s
	)

this procedure can be use to divide by a scalar any element of vector-like objects as a result we may obtain object of different type, dividing of column of matrix by scalar gives vector result = v / s

◆ divideObjectScalar() [4/6]

template IVector capd::vectalg::divideObjectScalar	(	IVector const &	,
		capd::DInterval const &
	)

◆ divideObjectScalar() [5/6]

template IVector capd::vectalg::divideObjectScalar	(	IVector const &	,
		long const &
	)

◆ divideObjectScalar() [6/6]

template Matrix<capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION> capd::vectalg::divideObjectScalar	(	Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > const &	,
		capd::DInterval const &
	)

◆ divideObjectScalar< Vector< double, CAPD_DEFAULT_DIMENSION >, Vector< double, CAPD_DEFAULT_DIMENSION >, long >()

template Vector<double, CAPD_DEFAULT_DIMENSION> capd::vectalg::divideObjectScalar< Vector< double, CAPD_DEFAULT_DIMENSION >, Vector< double, CAPD_DEFAULT_DIMENSION >, long >	(	Vector< double, CAPD_DEFAULT_DIMENSION > const &	,
		long const &
	)

◆ divideObjectScalar< Vector< long double, CAPD_DEFAULT_DIMENSION >, Vector< long double, CAPD_DEFAULT_DIMENSION >, long >()

template Vector<long double, CAPD_DEFAULT_DIMENSION> capd::vectalg::divideObjectScalar< Vector< long double, CAPD_DEFAULT_DIMENSION >, Vector< long double, CAPD_DEFAULT_DIMENSION >, long >	(	Vector< long double, CAPD_DEFAULT_DIMENSION > const &	,
		long const &
	)

◆ equal() [1/3]

template bool capd::vectalg::equal	(	capd::vectalg::Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > const &	,
		capd::vectalg::Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > const &
	)

◆ equal() [2/3]

template<typename T1 , typename T2 >

bool capd::vectalg::equal	(	const T1 &	v1,
		const T2 &	v2
	)

◆ equal() [3/3]

template bool capd::vectalg::equal	(	Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > const &	,
		Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > const &
	)

◆ euclNorm() [1/2]

template<typename T >

T capd::vectalg::euclNorm ( ::capd::fields::Complex< T > & x )

◆ euclNorm() [2/2]

template<typename Object >

Object::ScalarType capd::vectalg::euclNorm ( const Object & u )

Computes euclidean norm of any vector.

◆ evalPolynomial()

template<class Object , class Scalar >

void capd::vectalg::evalPolynomial	(	Object *	c,
		Scalar	t,
		Object &	result,
		int	n
	)

Evaluates polynomial p:R->R^n at some argument.

Coefficients of the polynomial are assumed to be stored as an array c[r], where c\in R^n. The result is stored in the third argument.

Parameters

c	- coefficients of the polynomial
t	- argument at which polynomial is evaluated
n	- deree of the polynomial

◆ getWidths()

template<typename ResultType , typename IObject >

ResultType capd::vectalg::getWidths ( const IObject & v )

◆ greaterEqual()

template<typename T1 , typename T2 >

bool capd::vectalg::greaterEqual	(	const T1 &	v1,
		const T2 &	v2
	)

◆ greaterThan()

template<typename T1 , typename T2 >

bool capd::vectalg::greaterThan	(	const T1 &	v1,
		const T2 &	v2
	)

◆ hasIndex()

bool capd::vectalg::hasIndex	(	const Multipointer &	mp,
		int	index
	)

checks if muiltipointer contains index

Parameters

[in]	-	mp multipointer that is checked
[in]	-	index index to be found

Returns: true if mp contains index

◆ indexCount()

int capd::vectalg::indexCount	(	const Multipointer &	mp,
		int	index
	)

returns the number of occurences of index in the multipointer

Parameters

[in]	mp	- multipointer that is inspected
[in]	index	- the counted index

Returns: number of occureneces o of index in mp

◆ intersection() [1/2]

template<typename IVector >

IVector capd::vectalg::intersection	(	const IVector &	,
		const IVector &
	)

◆ intersection() [2/2]

template<typename IVectorType >

IVectorType capd::vectalg::intersection	(	const IVectorType &	v1,
		const IVectorType &	v2
	)

◆ intersection< IMatrix >()

template IMatrix capd::vectalg::intersection< IMatrix >	(	const IMatrix &	v1,
		const IMatrix &	v2
	)

◆ intersection< IMatrix, IMatrix, IMatrix >()

template bool capd::vectalg::intersection< IMatrix, IMatrix, IMatrix >	(	const IMatrix &	,
		const IMatrix &	,
		IMatrix &
	)

◆ intersection< IVector >()

template IVector capd::vectalg::intersection< IVector >	(	const IVector &	v1,
		const IVector &	v2
	)

◆ intersectionWithSubmatrix()

template<typename MatrixType1 , typename MatrixType2 >

void capd::vectalg::intersectionWithSubmatrix	(	const MatrixType1 &	src,
		MatrixType2 &	target,
		int	startRow,
		int	stopRow,
		int	startCol,
		int	stopCol
	)

intersection of src with target[startRow..stopRow][startCol..stopCol] is returned in target

◆ intersectionWithSubvector()

template<typename VectorType1 , typename VectorType2 >

void capd::vectalg::intersectionWithSubvector	(	const VectorType1 &	src,
		VectorType2 &	target,
		int	start,
		int	stop
	)

Intersection of src with target[start..stop] is returned in target.

◆ intervalBall() [1/2]

template<typename IVector >

IVector capd::vectalg::intervalBall	(	const IVector &	,
		const typename IVector::ScalarType &	r
	)

◆ intervalBall() [2/2]

template<typename IVectorType >

IVectorType capd::vectalg::intervalBall	(	const IVectorType &	iv,
		const typename IVectorType::ScalarType &	r
	)

◆ intervalBall< IVector >()

template IVector capd::vectalg::intervalBall< IVector >	(	const IVector &	iv,
		const capd::DInterval &	r
	)

◆ intervalHull() [1/2]

template<typename IVector >

IVector capd::vectalg::intervalHull	(	const IVector &	,
		const IVector &
	)

◆ intervalHull() [2/2]

template<typename IVectorType >

IVectorType capd::vectalg::intervalHull	(	const IVectorType &	v1,
		const IVectorType &	v2
	)

◆ intervalHull< IMatrix >()

template IMatrix capd::vectalg::intervalHull< IMatrix >	(	const IMatrix &	A,
		const IMatrix &	B
	)

◆ intervalHull< IVector >()

template IVector capd::vectalg::intervalHull< IVector >	(	const IVector &	A,
		const IVector &	B
	)

◆ leftVector()

template<typename IVector >

IVector capd::vectalg::leftVector ( const IVector & u )

inline

◆ leftVector< IVector >()

template IVector capd::vectalg::leftVector< IVector > ( const IVector & v )

◆ lessEqual()

template<typename T1 , typename T2 >

bool capd::vectalg::lessEqual	(	const T1 &	v1,
		const T2 &	v2
	)

◆ lessThan()

template<typename T1 , typename T2 >

bool capd::vectalg::lessThan	(	const T1 &	v1,
		const T2 &	v2
	)

◆ matrixByMatrix() [1/8]

template<typename ResultType , typename Matrix1 , typename Matrix2 >

ResultType capd::vectalg::matrixByMatrix	(	const Matrix1 &	a1,
		const Matrix2 &	a2
	)

inline

◆ matrixByMatrix() [2/8]

template<typename ResultType , typename Matrix1 , typename Matrix2 >

void capd::vectalg::matrixByMatrix	(	const Matrix1 &	a1,
		const Matrix2 &	a2,
		ResultType &	result
	)

this procedure realizes multiplication of two matrix-like objects result = m1*m2

◆ matrixByMatrix() [3/8]

template void capd::vectalg::matrixByMatrix	(	const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &
	)

◆ matrixByMatrix() [4/8]

template void capd::vectalg::matrixByMatrix	(	const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &
	)

◆ matrixByMatrix() [5/8]

template void capd::vectalg::matrixByMatrix	(	const Matrix< int, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const Matrix< int, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		Matrix< int, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &
	)

◆ matrixByMatrix() [6/8]

template void capd::vectalg::matrixByMatrix	(	const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &
	)

◆ matrixByMatrix() [7/8]

template void capd::vectalg::matrixByMatrix	(	const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &
	)

◆ matrixByMatrix() [8/8]

template void capd::vectalg::matrixByMatrix	(	const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &
	)

◆ matrixByVector() [1/11]

template void capd::vectalg::matrixByVector	(	const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	,
		Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &
	)

◆ matrixByVector() [2/11]

template void capd::vectalg::matrixByVector	(	const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const ColumnVector< double, CAPD_DEFAULT_DIMENSION > &	,
		Vector< double, CAPD_DEFAULT_DIMENSION > &
	)

◆ matrixByVector() [3/11]

template void capd::vectalg::matrixByVector	(	const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const Vector< double, CAPD_DEFAULT_DIMENSION > &	,
		Vector< double, CAPD_DEFAULT_DIMENSION > &
	)

◆ matrixByVector() [4/11]

template void capd::vectalg::matrixByVector	(	const Matrix< int, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const ColumnVector< int, CAPD_DEFAULT_DIMENSION > &	,
		Vector< int, CAPD_DEFAULT_DIMENSION > &
	)

◆ matrixByVector() [5/11]

template void capd::vectalg::matrixByVector	(	const Matrix< int, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const Vector< int, CAPD_DEFAULT_DIMENSION > &	,
		Vector< int, CAPD_DEFAULT_DIMENSION > &
	)

◆ matrixByVector() [6/11]

template void capd::vectalg::matrixByVector	(	const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &	,
		Vector< long double, CAPD_DEFAULT_DIMENSION > &
	)

◆ matrixByVector() [7/11]

template void capd::vectalg::matrixByVector	(	const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const Vector< long double, CAPD_DEFAULT_DIMENSION > &	,
		Vector< long double, CAPD_DEFAULT_DIMENSION > &
	)

◆ matrixByVector() [8/11]

template void capd::vectalg::matrixByVector	(	const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &	,
		Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &
	)

◆ matrixByVector() [9/11]

template void capd::vectalg::matrixByVector	(	const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &	,
		Vector< MpInt, CAPD_DEFAULT_DIMENSION > &
	)

◆ matrixByVector() [10/11]

template<typename ResultType , typename MatrixType , typename VectorType >

ResultType capd::vectalg::matrixByVector	(	const MatrixType &	m,
		const VectorType &	u
	)

inline

◆ matrixByVector() [11/11]

template<typename ResultType , typename MatrixType , typename VectorType >

void capd::vectalg::matrixByVector	(	const MatrixType &	m,
		const VectorType &	u,
		ResultType &	result
	)

this procedure realizes multiplication of matrix-like object by vector-like object result = m*v

◆ maxDiam()

template<typename IVector >

IVector::ScalarType capd::vectalg::maxDiam ( const IVector & )

◆ maxDiam< IMatrix >()

template capd::DInterval capd::vectalg::maxDiam< IMatrix > ( const IMatrix & v )

◆ maxDiam< IVector >()

template capd::DInterval capd::vectalg::maxDiam< IVector > ( const IVector & v )

◆ maxWidth< IMatrix >()

template double capd::vectalg::maxWidth< IMatrix > ( const IMatrix & v )

◆ maxWidth< IVector >()

template double capd::vectalg::maxWidth< IVector > ( const IVector & v )

◆ midMatrix()

template<typename IMatrixType >

IMatrixType capd::vectalg::midMatrix ( const IMatrixType & v )

◆ midMatrix< IMatrix >()

template IMatrix capd::vectalg::midMatrix< IMatrix > ( const IMatrix & )

◆ midVector() [1/2]

template<typename IVector >

IVector capd::vectalg::midVector ( const IVector & )

◆ midVector() [2/2]

template<typename IVectorType >

IVectorType capd::vectalg::midVector ( const IVectorType & v )

◆ midVector< IVector >()

template IVector capd::vectalg::midVector< IVector > ( const IVector & v )

◆ multiplyAssignObjectScalar()

template<typename Object , typename Scalar >

Object & capd::vectalg::multiplyAssignObjectScalar	(	Object &	u,
		const Scalar &	s
	)

this procedure can be use to multiply by a scalar each element of a vector-like object u[i] *= s

this procedure can be use to multiply by a scalar any element of two vector-like objects u[i] *= s

◆ multiplyAssignObjectScalarAddObject() [1/7]

template IVector& capd::vectalg::multiplyAssignObjectScalarAddObject	(	IVector &	,
		capd::DInterval const &	,
		IVector const &
	)

◆ multiplyAssignObjectScalarAddObject() [2/7]

template Matrix<capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION>& capd::vectalg::multiplyAssignObjectScalarAddObject	(	Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		capd::DInterval const &	,
		Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > const &
	)

◆ multiplyAssignObjectScalarAddObject() [3/7]

template Matrix<double,CAPD_DEFAULT_DIMENSION,CAPD_DEFAULT_DIMENSION>& capd::vectalg::multiplyAssignObjectScalarAddObject	(	Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		double const &	,
		Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > const &
	)

◆ multiplyAssignObjectScalarAddObject() [4/7]

template Matrix<long double,CAPD_DEFAULT_DIMENSION,CAPD_DEFAULT_DIMENSION>& capd::vectalg::multiplyAssignObjectScalarAddObject	(	Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		long double const &	,
		Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > const &
	)

◆ multiplyAssignObjectScalarAddObject() [5/7]

template<typename Object , typename Object2 , typename Scalar >

Object & capd::vectalg::multiplyAssignObjectScalarAddObject	(	Object &	u,
		const Scalar &	s,
		const Object2 &	v
	)

this procedure can be use to multiply by a scalar each element of a vector-like object and then add compoent-wise elements of second vector-like object u[i] = u[i]*s+v[i]

◆ multiplyAssignObjectScalarAddObject() [6/7]

template Vector<double, CAPD_DEFAULT_DIMENSION>& capd::vectalg::multiplyAssignObjectScalarAddObject	(	Vector< double, CAPD_DEFAULT_DIMENSION > &	,
		double const &	,
		Vector< double, CAPD_DEFAULT_DIMENSION > const &
	)

◆ multiplyAssignObjectScalarAddObject() [7/7]

template Vector<long double, CAPD_DEFAULT_DIMENSION>& capd::vectalg::multiplyAssignObjectScalarAddObject	(	Vector< long double, CAPD_DEFAULT_DIMENSION > &	,
		long double const &	,
		Vector< long double, CAPD_DEFAULT_DIMENSION > const &
	)

◆ multiplyObjectScalar() [1/15]

template IVector capd::vectalg::multiplyObjectScalar	(	ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > const &	,
		capd::DInterval const &
	)

◆ multiplyObjectScalar() [2/15]

template Vector<double, CAPD_DEFAULT_DIMENSION> capd::vectalg::multiplyObjectScalar	(	ColumnVector< double, CAPD_DEFAULT_DIMENSION > const &	,
		double const &
	)

◆ multiplyObjectScalar() [3/15]

template Vector<long double, CAPD_DEFAULT_DIMENSION> capd::vectalg::multiplyObjectScalar	(	ColumnVector< long double, CAPD_DEFAULT_DIMENSION > const &	,
		long double const &
	)

◆ multiplyObjectScalar() [4/15]

template<typename ResultType , typename Object , typename FactorType >

ResultType capd::vectalg::multiplyObjectScalar	(	const Object &	v,
		const FactorType &	s
	)

this procedure can be use to multiply by a scalar any element of vector-like objects as a result we may obtain object of different type, multiplication of column of matrix and scalar gives vector result = v * s

◆ multiplyObjectScalar() [5/15]

template<typename ResultType , typename Object , typename FactorType >

void capd::vectalg::multiplyObjectScalar	(	const Object &	v,
		const FactorType &	s,
		ResultType &	result
	)

this procedure can be use to multiply by a scalar any element of vector-like objects as a result we may obtain object of different type, multiplication of column of matrix and scalar gives vector result = v * s

◆ multiplyObjectScalar() [6/15]

template IMatrix capd::vectalg::multiplyObjectScalar	(	IMatrix const &	,
		capd::DInterval const &
	)

◆ multiplyObjectScalar() [7/15]

template IVector capd::vectalg::multiplyObjectScalar	(	IVector const &	,
		capd::DInterval const &
	)

◆ multiplyObjectScalar() [8/15]

template IVector capd::vectalg::multiplyObjectScalar	(	IVector const &	,
		long const &
	)

◆ multiplyObjectScalar() [9/15]

template IVector capd::vectalg::multiplyObjectScalar	(	RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > const &	,
		capd::DInterval const &
	)

◆ multiplyObjectScalar() [10/15]

template Vector<double, CAPD_DEFAULT_DIMENSION> capd::vectalg::multiplyObjectScalar	(	RowVector< double, CAPD_DEFAULT_DIMENSION > const &	,
		double const &
	)

◆ multiplyObjectScalar() [11/15]

template Vector<long double, CAPD_DEFAULT_DIMENSION> capd::vectalg::multiplyObjectScalar	(	RowVector< long double, CAPD_DEFAULT_DIMENSION > const &	,
		long double const &
	)

◆ multiplyObjectScalar() [12/15]

template Vector<double, CAPD_DEFAULT_DIMENSION> capd::vectalg::multiplyObjectScalar	(	Vector< double, CAPD_DEFAULT_DIMENSION > const &	,
		double const &
	)

◆ multiplyObjectScalar() [13/15]

template Vector<double, CAPD_DEFAULT_DIMENSION> capd::vectalg::multiplyObjectScalar	(	Vector< double, CAPD_DEFAULT_DIMENSION > const &	,
		long const &
	)

◆ multiplyObjectScalar() [14/15]

template Vector<long double, CAPD_DEFAULT_DIMENSION> capd::vectalg::multiplyObjectScalar	(	Vector< long double, CAPD_DEFAULT_DIMENSION > const &	,
		long const &
	)

◆ multiplyObjectScalar() [15/15]

template Vector<long double, CAPD_DEFAULT_DIMENSION> capd::vectalg::multiplyObjectScalar	(	Vector< long double, CAPD_DEFAULT_DIMENSION > const &	,
		long double const &
	)

◆ normalize() [1/2]

template bool capd::vectalg::normalize ( ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > & )

◆ normalize() [2/2]

template<typename Object >

bool capd::vectalg::normalize ( Object & u )

normalize a vector with respect to euclidean norm if impossible returns false

◆ notEqual()

template<typename T1 , typename T2 >

bool capd::vectalg::notEqual	(	const T1 &	v1,
		const T2 &	v2
	)

◆ operator!=() [1/2]

template<typename Scalar , __size_type rows, __size_type cols>

bool capd::vectalg::operator!=	(	const Matrix< Scalar, rows, cols > &	a1,
		const Matrix< Scalar, rows, cols > &	a2
	)

inline

◆ operator!=() [2/2]

template<typename Scalar , __size_type dim>

bool capd::vectalg::operator!=	(	const Vector< Scalar, dim > &	v1,
		const Vector< Scalar, dim > &	v2
	)

inline

◆ operator*() [1/19]

template<typename Scalar , __size_type rows>

Vector<Scalar,rows> capd::vectalg::operator*	(	const ColumnVector< Scalar, rows > &	u,
		const Scalar &	s
	)

inline

◆ operator*() [2/19]

template<typename Scalar , __size_type rows>

Scalar capd::vectalg::operator*	(	const ColumnVector< Scalar, rows > &	v,
		const ColumnVector< Scalar, rows > &	u
	)

inline

◆ operator*() [3/19]

template<typename Scalar , __size_type rows>

Scalar capd::vectalg::operator*	(	const ColumnVector< Scalar, rows > &	v,
		const Vector< Scalar, rows > &	u
	)

inline

◆ operator*() [4/19]

template<typename Scalar , typename FactorType , __size_type dim>

Vector<Scalar,dim> capd::vectalg::operator*	(	const FactorType &	s,
		const Vector< Scalar, dim > &	v
	)

inline

◆ operator*() [5/19]

template<typename Scalar , __size_type rows, __size_type cols>

Vector<Scalar,rows> capd::vectalg::operator*	(	const Matrix< Scalar, rows, cols > &	a,
		const ColumnVector< Scalar, cols > &	v
	)

inline

◆ operator*() [6/19]

template<typename Scalar , __size_type rows, __size_type cols>

Vector<Scalar,rows> capd::vectalg::operator*	(	const Matrix< Scalar, rows, cols > &	m,
		const RowVector< Scalar, cols > &	u
	)

inline

◆ operator*() [7/19]

template<typename Scalar , __size_type rows, __size_type cols>

Matrix<Scalar,rows,cols> capd::vectalg::operator*	(	const Matrix< Scalar, rows, cols > &	m,
		const Scalar &	s
	)

inline

◆ operator*() [8/19]

template<typename Scalar , __size_type rows, __size_type cols>

Vector<Scalar,rows> capd::vectalg::operator*	(	const Matrix< Scalar, rows, cols > &	m,
		const Vector< Scalar, cols > &	v
	)

inline

◆ operator*() [9/19]

template<typename Scalar , __size_type rows, __size_type cols1, __size_type cols2>

Matrix< Scalar, rows, cols2 > capd::vectalg::operator*	(	const Matrix< Scalar, rows, cols1 > &	a1,
		const Matrix< Scalar, cols1, cols2 > &	a2
	)

◆ operator*() [10/19]

template<typename Scalar , __size_type cols>

Vector<Scalar,cols> capd::vectalg::operator*	(	const RowVector< Scalar, cols > &	u,
		const Scalar &	s
	)

inline

◆ operator*() [11/19]

template<typename Scalar , __size_type cols>

Scalar capd::vectalg::operator*	(	const RowVector< Scalar, cols > &	u1,
		const RowVector< Scalar, cols > &	u2
	)

inline

◆ operator*() [12/19]

template<typename Scalar , __size_type cols>

Scalar capd::vectalg::operator*	(	const RowVector< Scalar, cols > &	u1,
		const Vector< Scalar, cols > &	u2
	)

inline

◆ operator*() [13/19]

template<typename Scalar , __size_type rows>

Vector<Scalar,rows> capd::vectalg::operator*	(	const Scalar &	s,
		const ColumnVector< Scalar, rows > &	u
	)

inline

◆ operator*() [14/19]

template<typename Scalar , __size_type rows, __size_type cols>

Matrix<Scalar,rows,cols> capd::vectalg::operator*	(	const Scalar &	s,
		const Matrix< Scalar, rows, cols > &	m
	)

inline

◆ operator*() [15/19]

template<typename Scalar , __size_type cols>

Vector<Scalar,cols> capd::vectalg::operator*	(	const Scalar &	s,
		const RowVector< Scalar, cols > &	u
	)

inline

◆ operator*() [16/19]

template<typename Scalar , __size_type cols>

Scalar capd::vectalg::operator*	(	const Vector< Scalar, cols > &	u1,
		const RowVector< Scalar, cols > &	u2
	)

inline

◆ operator*() [17/19]

template<typename Scalar , typename FactorType , __size_type dim>

Vector<Scalar,dim> capd::vectalg::operator*	(	const Vector< Scalar, dim > &	v,
		const FactorType &	s
	)

inline

◆ operator*() [18/19]

template<typename Scalar , __size_type dim>

Scalar capd::vectalg::operator*	(	const Vector< Scalar, dim > &	v1,
		const Vector< Scalar, dim > &	v2
	)

inline

◆ operator*() [19/19]

template<typename Scalar , __size_type rows>

Scalar capd::vectalg::operator*	(	const Vector< Scalar, rows > &	u,
		const ColumnVector< Scalar, rows > &	v
	)

inline

◆ operator*<capd::DInterval, capd::DInterval, CAPD_DEFAULT_DIMENSION >() [1/2]

template Vector<capd::DInterval,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<capd::DInterval, capd::DInterval, CAPD_DEFAULT_DIMENSION >	(	const capd::DInterval &	s,
		const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	v
	)

◆ operator*<capd::DInterval, capd::DInterval, CAPD_DEFAULT_DIMENSION >() [2/2]

template Vector<capd::DInterval,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<capd::DInterval, capd::DInterval, CAPD_DEFAULT_DIMENSION >	(	const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	v,
		const capd::DInterval &	s
	)

◆ operator*<capd::DInterval, CAPD_DEFAULT_DIMENSION >() [1/11]

template Vector<capd::DInterval,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<capd::DInterval, CAPD_DEFAULT_DIMENSION >	(	const capd::DInterval &	,
		const ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<capd::DInterval, CAPD_DEFAULT_DIMENSION >() [2/11]

template Vector<capd::DInterval,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<capd::DInterval, CAPD_DEFAULT_DIMENSION >	(	const capd::DInterval &	,
		const RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<capd::DInterval, CAPD_DEFAULT_DIMENSION >() [3/11]

template Vector<capd::DInterval,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<capd::DInterval, CAPD_DEFAULT_DIMENSION >	(	const ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	,
		const capd::DInterval &
	)

◆ operator*<capd::DInterval, CAPD_DEFAULT_DIMENSION >() [4/11]

template capd::DInterval capd::vectalg::operator*<capd::DInterval, CAPD_DEFAULT_DIMENSION >	(	const ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	,
		const ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<capd::DInterval, CAPD_DEFAULT_DIMENSION >() [5/11]

template capd::DInterval capd::vectalg::operator*<capd::DInterval, CAPD_DEFAULT_DIMENSION >	(	const ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	,
		const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<capd::DInterval, CAPD_DEFAULT_DIMENSION >() [6/11]

template Vector<capd::DInterval,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<capd::DInterval, CAPD_DEFAULT_DIMENSION >	(	const RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	,
		const capd::DInterval &
	)

◆ operator*<capd::DInterval, CAPD_DEFAULT_DIMENSION >() [7/11]

template capd::DInterval capd::vectalg::operator*<capd::DInterval, CAPD_DEFAULT_DIMENSION >	(	const RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	,
		const RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<capd::DInterval, CAPD_DEFAULT_DIMENSION >() [8/11]

template capd::DInterval capd::vectalg::operator*<capd::DInterval, CAPD_DEFAULT_DIMENSION >	(	const RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	,
		const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<capd::DInterval, CAPD_DEFAULT_DIMENSION >() [9/11]

template capd::DInterval capd::vectalg::operator*<capd::DInterval, CAPD_DEFAULT_DIMENSION >	(	const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	,
		const ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<capd::DInterval, CAPD_DEFAULT_DIMENSION >() [10/11]

template capd::DInterval capd::vectalg::operator*<capd::DInterval, CAPD_DEFAULT_DIMENSION >	(	const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	,
		const RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<capd::DInterval, CAPD_DEFAULT_DIMENSION >() [11/11]

template capd::DInterval capd::vectalg::operator*<capd::DInterval, CAPD_DEFAULT_DIMENSION >	(	const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	v1,
		const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	v2
	)

◆ operator*<capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [1/6]

template Matrix<capd::DInterval,CAPD_DEFAULT_DIMENSION,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const capd::DInterval &	,
		const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [2/6]

template Matrix<capd::DInterval,CAPD_DEFAULT_DIMENSION,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const capd::DInterval &
	)

◆ operator*<capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [3/6]

template Vector<capd::DInterval,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [4/6]

template Matrix<capd::DInterval,CAPD_DEFAULT_DIMENSION,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [5/6]

template Vector<capd::DInterval,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [6/6]

template Vector<capd::DInterval,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<capd::DInterval, double, CAPD_DEFAULT_DIMENSION >() [1/2]

template Vector<capd::DInterval,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<capd::DInterval, double, CAPD_DEFAULT_DIMENSION >	(	const double &	s,
		const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	v
	)

◆ operator*<capd::DInterval, double, CAPD_DEFAULT_DIMENSION >() [2/2]

template Vector<capd::DInterval,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<capd::DInterval, double, CAPD_DEFAULT_DIMENSION >	(	const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	v,
		const double &	s
	)

◆ operator*<capd::DInterval, int, CAPD_DEFAULT_DIMENSION >() [1/2]

template Vector<capd::DInterval,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<capd::DInterval, int, CAPD_DEFAULT_DIMENSION >	(	const int &	s,
		const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	v
	)

◆ operator*<capd::DInterval, int, CAPD_DEFAULT_DIMENSION >() [2/2]

template Vector<capd::DInterval,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<capd::DInterval, int, CAPD_DEFAULT_DIMENSION >	(	const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	v,
		const int &	s
	)

◆ operator*<capd::DInterval, long, CAPD_DEFAULT_DIMENSION >() [1/2]

template Vector<capd::DInterval,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<capd::DInterval, long, CAPD_DEFAULT_DIMENSION >	(	const long &	s,
		const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	v
	)

◆ operator*<capd::DInterval, long, CAPD_DEFAULT_DIMENSION >() [2/2]

template Vector<capd::DInterval,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<capd::DInterval, long, CAPD_DEFAULT_DIMENSION >	(	const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	v,
		const long &	s
	)

◆ operator*<double, CAPD_DEFAULT_DIMENSION >() [1/11]

template double capd::vectalg::operator*<double, CAPD_DEFAULT_DIMENSION >	(	const ColumnVector< double, CAPD_DEFAULT_DIMENSION > &	,
		const ColumnVector< double, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<double, CAPD_DEFAULT_DIMENSION >() [2/11]

template Vector<double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<double, CAPD_DEFAULT_DIMENSION >	(	const ColumnVector< double, CAPD_DEFAULT_DIMENSION > &	,
		const double &
	)

◆ operator*<double, CAPD_DEFAULT_DIMENSION >() [3/11]

template double capd::vectalg::operator*<double, CAPD_DEFAULT_DIMENSION >	(	const ColumnVector< double, CAPD_DEFAULT_DIMENSION > &	,
		const Vector< double, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<double, CAPD_DEFAULT_DIMENSION >() [4/11]

template Vector<double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<double, CAPD_DEFAULT_DIMENSION >	(	const double &	,
		const ColumnVector< double, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<double, CAPD_DEFAULT_DIMENSION >() [5/11]

template Vector<double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<double, CAPD_DEFAULT_DIMENSION >	(	const double &	,
		const RowVector< double, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<double, CAPD_DEFAULT_DIMENSION >() [6/11]

template Vector<double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<double, CAPD_DEFAULT_DIMENSION >	(	const RowVector< double, CAPD_DEFAULT_DIMENSION > &	,
		const double &
	)

◆ operator*<double, CAPD_DEFAULT_DIMENSION >() [7/11]

template double capd::vectalg::operator*<double, CAPD_DEFAULT_DIMENSION >	(	const RowVector< double, CAPD_DEFAULT_DIMENSION > &	,
		const RowVector< double, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<double, CAPD_DEFAULT_DIMENSION >() [8/11]

template double capd::vectalg::operator*<double, CAPD_DEFAULT_DIMENSION >	(	const RowVector< double, CAPD_DEFAULT_DIMENSION > &	,
		const Vector< double, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<double, CAPD_DEFAULT_DIMENSION >() [9/11]

template double capd::vectalg::operator*<double, CAPD_DEFAULT_DIMENSION >	(	const Vector< double, CAPD_DEFAULT_DIMENSION > &	,
		const ColumnVector< double, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<double, CAPD_DEFAULT_DIMENSION >() [10/11]

template double capd::vectalg::operator*<double, CAPD_DEFAULT_DIMENSION >	(	const Vector< double, CAPD_DEFAULT_DIMENSION > &	,
		const RowVector< double, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<double, CAPD_DEFAULT_DIMENSION >() [11/11]

template double capd::vectalg::operator*<double, CAPD_DEFAULT_DIMENSION >	(	const Vector< double, CAPD_DEFAULT_DIMENSION > &	v1,
		const Vector< double, CAPD_DEFAULT_DIMENSION > &	v2
	)

◆ operator*<double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [1/6]

template Matrix<double,CAPD_DEFAULT_DIMENSION,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const double &	,
		const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [2/6]

template Vector<double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const ColumnVector< double, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [3/6]

template Matrix<double,CAPD_DEFAULT_DIMENSION,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const double &
	)

◆ operator*<double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [4/6]

template Matrix<double,CAPD_DEFAULT_DIMENSION,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [5/6]

template Vector<double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const RowVector< double, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [6/6]

template Vector<double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const Vector< double, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<double, double, CAPD_DEFAULT_DIMENSION >() [1/2]

template Vector<double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<double, double, CAPD_DEFAULT_DIMENSION >	(	const double &	s,
		const Vector< double, CAPD_DEFAULT_DIMENSION > &	v
	)

◆ operator*<double, double, CAPD_DEFAULT_DIMENSION >() [2/2]

template Vector<double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<double, double, CAPD_DEFAULT_DIMENSION >	(	const Vector< double, CAPD_DEFAULT_DIMENSION > &	v,
		const double &	s
	)

◆ operator*<double, int, CAPD_DEFAULT_DIMENSION >() [1/2]

template Vector<double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<double, int, CAPD_DEFAULT_DIMENSION >	(	const int &	s,
		const Vector< double, CAPD_DEFAULT_DIMENSION > &	v
	)

◆ operator*<double, int, CAPD_DEFAULT_DIMENSION >() [2/2]

template Vector<double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<double, int, CAPD_DEFAULT_DIMENSION >	(	const Vector< double, CAPD_DEFAULT_DIMENSION > &	v,
		const int &	s
	)

◆ operator*<double, long, CAPD_DEFAULT_DIMENSION >() [1/2]

template Vector<double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<double, long, CAPD_DEFAULT_DIMENSION >	(	const long &	s,
		const Vector< double, CAPD_DEFAULT_DIMENSION > &	v
	)

◆ operator*<double, long, CAPD_DEFAULT_DIMENSION >() [2/2]

template Vector<double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<double, long, CAPD_DEFAULT_DIMENSION >	(	const Vector< double, CAPD_DEFAULT_DIMENSION > &	v,
		const long &	s
	)

◆ operator*<int, CAPD_DEFAULT_DIMENSION >()

template int capd::vectalg::operator*<int, CAPD_DEFAULT_DIMENSION >	(	const Vector< int, CAPD_DEFAULT_DIMENSION > &	v1,
		const Vector< int, CAPD_DEFAULT_DIMENSION > &	v2
	)

◆ operator*<int, int, CAPD_DEFAULT_DIMENSION >() [1/2]

template Vector<int,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<int, int, CAPD_DEFAULT_DIMENSION >	(	const int &	s,
		const Vector< int, CAPD_DEFAULT_DIMENSION > &	v
	)

◆ operator*<int, int, CAPD_DEFAULT_DIMENSION >() [2/2]

template Vector<int,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<int, int, CAPD_DEFAULT_DIMENSION >	(	const Vector< int, CAPD_DEFAULT_DIMENSION > &	v,
		const int &	s
	)

◆ operator*<int, long, CAPD_DEFAULT_DIMENSION >() [1/2]

template Vector<int,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<int, long, CAPD_DEFAULT_DIMENSION >	(	const long &	s,
		const Vector< int, CAPD_DEFAULT_DIMENSION > &	v
	)

◆ operator*<int, long, CAPD_DEFAULT_DIMENSION >() [2/2]

template Vector<int,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<int, long, CAPD_DEFAULT_DIMENSION >	(	const Vector< int, CAPD_DEFAULT_DIMENSION > &	v,
		const long &	s
	)

◆ operator*<long double, CAPD_DEFAULT_DIMENSION >() [1/11]

template long double capd::vectalg::operator*<long double, CAPD_DEFAULT_DIMENSION >	(	const ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &	,
		const ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<long double, CAPD_DEFAULT_DIMENSION >() [2/11]

template Vector<long double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<long double, CAPD_DEFAULT_DIMENSION >	(	const ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &	,
		const long double &
	)

◆ operator*<long double, CAPD_DEFAULT_DIMENSION >() [3/11]

template long double capd::vectalg::operator*<long double, CAPD_DEFAULT_DIMENSION >	(	const ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &	,
		const Vector< long double, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<long double, CAPD_DEFAULT_DIMENSION >() [4/11]

template Vector<long double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<long double, CAPD_DEFAULT_DIMENSION >	(	const long double &	,
		const ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<long double, CAPD_DEFAULT_DIMENSION >() [5/11]

template Vector<long double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<long double, CAPD_DEFAULT_DIMENSION >	(	const long double &	,
		const RowVector< long double, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<long double, CAPD_DEFAULT_DIMENSION >() [6/11]

template Vector<long double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<long double, CAPD_DEFAULT_DIMENSION >	(	const RowVector< long double, CAPD_DEFAULT_DIMENSION > &	,
		const long double &
	)

◆ operator*<long double, CAPD_DEFAULT_DIMENSION >() [7/11]

template long double capd::vectalg::operator*<long double, CAPD_DEFAULT_DIMENSION >	(	const RowVector< long double, CAPD_DEFAULT_DIMENSION > &	,
		const RowVector< long double, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<long double, CAPD_DEFAULT_DIMENSION >() [8/11]

template long double capd::vectalg::operator*<long double, CAPD_DEFAULT_DIMENSION >	(	const RowVector< long double, CAPD_DEFAULT_DIMENSION > &	,
		const Vector< long double, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<long double, CAPD_DEFAULT_DIMENSION >() [9/11]

template long double capd::vectalg::operator*<long double, CAPD_DEFAULT_DIMENSION >	(	const Vector< long double, CAPD_DEFAULT_DIMENSION > &	,
		const ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<long double, CAPD_DEFAULT_DIMENSION >() [10/11]

template long double capd::vectalg::operator*<long double, CAPD_DEFAULT_DIMENSION >	(	const Vector< long double, CAPD_DEFAULT_DIMENSION > &	,
		const RowVector< long double, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<long double, CAPD_DEFAULT_DIMENSION >() [11/11]

template long double capd::vectalg::operator*<long double, CAPD_DEFAULT_DIMENSION >	(	const Vector< long double, CAPD_DEFAULT_DIMENSION > &	v1,
		const Vector< long double, CAPD_DEFAULT_DIMENSION > &	v2
	)

◆ operator*<long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [1/6]

template Matrix<long double,CAPD_DEFAULT_DIMENSION,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const long double &	,
		const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [2/6]

template Vector<long double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [3/6]

template Matrix<long double,CAPD_DEFAULT_DIMENSION,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const long double &
	)

◆ operator*<long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [4/6]

template Matrix<long double,CAPD_DEFAULT_DIMENSION,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [5/6]

template Vector<long double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const RowVector< long double, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [6/6]

template Vector<long double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const Vector< long double, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<long double, int, CAPD_DEFAULT_DIMENSION >() [1/2]

template Vector<long double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<long double, int, CAPD_DEFAULT_DIMENSION >	(	const int &	s,
		const Vector< long double, CAPD_DEFAULT_DIMENSION > &	v
	)

◆ operator*<long double, int, CAPD_DEFAULT_DIMENSION >() [2/2]

template Vector<long double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<long double, int, CAPD_DEFAULT_DIMENSION >	(	const Vector< long double, CAPD_DEFAULT_DIMENSION > &	v,
		const int &	s
	)

◆ operator*<long double, long double, CAPD_DEFAULT_DIMENSION >() [1/2]

template Vector<long double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<long double, long double, CAPD_DEFAULT_DIMENSION >	(	const long double &	s,
		const Vector< long double, CAPD_DEFAULT_DIMENSION > &	v
	)

◆ operator*<long double, long double, CAPD_DEFAULT_DIMENSION >() [2/2]

template Vector<long double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<long double, long double, CAPD_DEFAULT_DIMENSION >	(	const Vector< long double, CAPD_DEFAULT_DIMENSION > &	v,
		const long double &	s
	)

◆ operator*<long double, long, CAPD_DEFAULT_DIMENSION >() [1/2]

template Vector<long double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<long double, long, CAPD_DEFAULT_DIMENSION >	(	const long &	s,
		const Vector< long double, CAPD_DEFAULT_DIMENSION > &	v
	)

◆ operator*<long double, long, CAPD_DEFAULT_DIMENSION >() [2/2]

template Vector<long double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<long double, long, CAPD_DEFAULT_DIMENSION >	(	const Vector< long double, CAPD_DEFAULT_DIMENSION > &	v,
		const long &	s
	)

◆ operator*<MpFloat, CAPD_DEFAULT_DIMENSION >() [1/11]

template MpFloat capd::vectalg::operator*<MpFloat, CAPD_DEFAULT_DIMENSION >	(	const ColumnVector< MpFloat, CAPD_DEFAULT_DIMENSION > &	,
		const ColumnVector< MpFloat, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<MpFloat, CAPD_DEFAULT_DIMENSION >() [2/11]

template Vector<MpFloat,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<MpFloat, CAPD_DEFAULT_DIMENSION >	(	const ColumnVector< MpFloat, CAPD_DEFAULT_DIMENSION > &	,
		const MpFloat &
	)

◆ operator*<MpFloat, CAPD_DEFAULT_DIMENSION >() [3/11]

template MpFloat capd::vectalg::operator*<MpFloat, CAPD_DEFAULT_DIMENSION >	(	const ColumnVector< MpFloat, CAPD_DEFAULT_DIMENSION > &	,
		const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<MpFloat, CAPD_DEFAULT_DIMENSION >() [4/11]

template Vector<MpFloat,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<MpFloat, CAPD_DEFAULT_DIMENSION >	(	const MpFloat &	,
		const ColumnVector< MpFloat, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<MpFloat, CAPD_DEFAULT_DIMENSION >() [5/11]

template Vector<MpFloat,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<MpFloat, CAPD_DEFAULT_DIMENSION >	(	const MpFloat &	,
		const RowVector< MpFloat, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<MpFloat, CAPD_DEFAULT_DIMENSION >() [6/11]

template Vector<MpFloat,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<MpFloat, CAPD_DEFAULT_DIMENSION >	(	const RowVector< MpFloat, CAPD_DEFAULT_DIMENSION > &	,
		const MpFloat &
	)

◆ operator*<MpFloat, CAPD_DEFAULT_DIMENSION >() [7/11]

template MpFloat capd::vectalg::operator*<MpFloat, CAPD_DEFAULT_DIMENSION >	(	const RowVector< MpFloat, CAPD_DEFAULT_DIMENSION > &	,
		const RowVector< MpFloat, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<MpFloat, CAPD_DEFAULT_DIMENSION >() [8/11]

template MpFloat capd::vectalg::operator*<MpFloat, CAPD_DEFAULT_DIMENSION >	(	const RowVector< MpFloat, CAPD_DEFAULT_DIMENSION > &	,
		const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<MpFloat, CAPD_DEFAULT_DIMENSION >() [9/11]

template MpFloat capd::vectalg::operator*<MpFloat, CAPD_DEFAULT_DIMENSION >	(	const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &	,
		const ColumnVector< MpFloat, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<MpFloat, CAPD_DEFAULT_DIMENSION >() [10/11]

template MpFloat capd::vectalg::operator*<MpFloat, CAPD_DEFAULT_DIMENSION >	(	const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &	,
		const RowVector< MpFloat, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<MpFloat, CAPD_DEFAULT_DIMENSION >() [11/11]

template MpFloat capd::vectalg::operator*<MpFloat, CAPD_DEFAULT_DIMENSION >	(	const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &	v1,
		const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &	v2
	)

◆ operator*<MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [1/6]

template Vector<MpFloat,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const ColumnVector< MpFloat, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [2/6]

template Matrix<MpFloat,CAPD_DEFAULT_DIMENSION,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [3/6]

template Matrix<MpFloat,CAPD_DEFAULT_DIMENSION,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const MpFloat &
	)

◆ operator*<MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [4/6]

template Vector<MpFloat,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const RowVector< MpFloat, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [5/6]

template Vector<MpFloat,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [6/6]

template Matrix<MpFloat,CAPD_DEFAULT_DIMENSION,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const MpFloat &	,
		const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<MpFloat, int, CAPD_DEFAULT_DIMENSION >() [1/2]

template Vector<MpFloat,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<MpFloat, int, CAPD_DEFAULT_DIMENSION >	(	const int &	s,
		const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &	v
	)

◆ operator*<MpFloat, int, CAPD_DEFAULT_DIMENSION >() [2/2]

template Vector<MpFloat,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<MpFloat, int, CAPD_DEFAULT_DIMENSION >	(	const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &	v,
		const int &	s
	)

◆ operator*<MpFloat, long, CAPD_DEFAULT_DIMENSION >() [1/2]

template Vector<MpFloat,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<MpFloat, long, CAPD_DEFAULT_DIMENSION >	(	const long &	s,
		const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &	v
	)

◆ operator*<MpFloat, long, CAPD_DEFAULT_DIMENSION >() [2/2]

template Vector<MpFloat,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<MpFloat, long, CAPD_DEFAULT_DIMENSION >	(	const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &	v,
		const long &	s
	)

◆ operator*<MpFloat, MpFloat, CAPD_DEFAULT_DIMENSION >() [1/2]

template Vector<MpFloat,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<MpFloat, MpFloat, CAPD_DEFAULT_DIMENSION >	(	const MpFloat &	s,
		const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &	v
	)

◆ operator*<MpFloat, MpFloat, CAPD_DEFAULT_DIMENSION >() [2/2]

template Vector<MpFloat,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<MpFloat, MpFloat, CAPD_DEFAULT_DIMENSION >	(	const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &	v,
		const MpFloat &	s
	)

◆ operator*<MpInt, CAPD_DEFAULT_DIMENSION >() [1/11]

template MpInt capd::vectalg::operator*<MpInt, CAPD_DEFAULT_DIMENSION >	(	const ColumnVector< MpInt, CAPD_DEFAULT_DIMENSION > &	,
		const ColumnVector< MpInt, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<MpInt, CAPD_DEFAULT_DIMENSION >() [2/11]

template Vector<MpInt,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<MpInt, CAPD_DEFAULT_DIMENSION >	(	const ColumnVector< MpInt, CAPD_DEFAULT_DIMENSION > &	,
		const MpInt &
	)

◆ operator*<MpInt, CAPD_DEFAULT_DIMENSION >() [3/11]

template MpInt capd::vectalg::operator*<MpInt, CAPD_DEFAULT_DIMENSION >	(	const ColumnVector< MpInt, CAPD_DEFAULT_DIMENSION > &	,
		const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<MpInt, CAPD_DEFAULT_DIMENSION >() [4/11]

template Vector<MpInt,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<MpInt, CAPD_DEFAULT_DIMENSION >	(	const MpInt &	,
		const ColumnVector< MpInt, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<MpInt, CAPD_DEFAULT_DIMENSION >() [5/11]

template Vector<MpInt,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<MpInt, CAPD_DEFAULT_DIMENSION >	(	const MpInt &	,
		const RowVector< MpInt, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<MpInt, CAPD_DEFAULT_DIMENSION >() [6/11]

template Vector<MpInt,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<MpInt, CAPD_DEFAULT_DIMENSION >	(	const RowVector< MpInt, CAPD_DEFAULT_DIMENSION > &	,
		const MpInt &
	)

◆ operator*<MpInt, CAPD_DEFAULT_DIMENSION >() [7/11]

template MpInt capd::vectalg::operator*<MpInt, CAPD_DEFAULT_DIMENSION >	(	const RowVector< MpInt, CAPD_DEFAULT_DIMENSION > &	,
		const RowVector< MpInt, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<MpInt, CAPD_DEFAULT_DIMENSION >() [8/11]

template MpInt capd::vectalg::operator*<MpInt, CAPD_DEFAULT_DIMENSION >	(	const RowVector< MpInt, CAPD_DEFAULT_DIMENSION > &	,
		const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<MpInt, CAPD_DEFAULT_DIMENSION >() [9/11]

template MpInt capd::vectalg::operator*<MpInt, CAPD_DEFAULT_DIMENSION >	(	const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &	,
		const ColumnVector< MpInt, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<MpInt, CAPD_DEFAULT_DIMENSION >() [10/11]

template MpInt capd::vectalg::operator*<MpInt, CAPD_DEFAULT_DIMENSION >	(	const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &	,
		const RowVector< MpInt, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<MpInt, CAPD_DEFAULT_DIMENSION >() [11/11]

template MpInt capd::vectalg::operator*<MpInt, CAPD_DEFAULT_DIMENSION >	(	const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &	v1,
		const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &	v2
	)

◆ operator*<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [1/6]

template Vector<MpInt,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const ColumnVector< MpInt, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [2/6]

template Matrix<MpInt,CAPD_DEFAULT_DIMENSION,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [3/6]

template Matrix<MpInt,CAPD_DEFAULT_DIMENSION,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const MpInt &
	)

◆ operator*<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [4/6]

template Vector<MpInt,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const RowVector< MpInt, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [5/6]

template Vector<MpInt,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [6/6]

template Matrix<MpInt,CAPD_DEFAULT_DIMENSION,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const MpInt &	,
		const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator*<MpInt, int, CAPD_DEFAULT_DIMENSION >() [1/2]

template Vector<MpInt,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<MpInt, int, CAPD_DEFAULT_DIMENSION >	(	const int &	s,
		const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &	v
	)

◆ operator*<MpInt, int, CAPD_DEFAULT_DIMENSION >() [2/2]

template Vector<MpInt,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<MpInt, int, CAPD_DEFAULT_DIMENSION >	(	const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &	v,
		const int &	s
	)

◆ operator*<MpInt, long, CAPD_DEFAULT_DIMENSION >() [1/2]

template Vector<MpInt,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<MpInt, long, CAPD_DEFAULT_DIMENSION >	(	const long &	s,
		const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &	v
	)

◆ operator*<MpInt, long, CAPD_DEFAULT_DIMENSION >() [2/2]

template Vector<MpInt,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<MpInt, long, CAPD_DEFAULT_DIMENSION >	(	const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &	v,
		const long &	s
	)

◆ operator*<MpInt, MpInt, CAPD_DEFAULT_DIMENSION >() [1/2]

template Vector<MpInt,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<MpInt, MpInt, CAPD_DEFAULT_DIMENSION >	(	const MpInt &	s,
		const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &	v
	)

◆ operator*<MpInt, MpInt, CAPD_DEFAULT_DIMENSION >() [2/2]

template Vector<MpInt,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator*<MpInt, MpInt, CAPD_DEFAULT_DIMENSION >	(	const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &	v,
		const MpInt &	s
	)

◆ operator+() [1/10]

template<typename Scalar , __size_type rows>

Vector<Scalar,rows> capd::vectalg::operator+	(	const ColumnVector< Scalar, rows > &	u,
		const ColumnVector< Scalar, rows > &	v
	)

inline

◆ operator+() [2/10]

template<typename Scalar , __size_type rows>

Vector<Scalar,rows> capd::vectalg::operator+	(	const ColumnVector< Scalar, rows > &	v,
		const Vector< Scalar, rows > &	u
	)

inline

◆ operator+() [3/10]

template<typename Scalar , __size_type rows, __size_type cols>

Matrix<Scalar,rows,cols> capd::vectalg::operator+	(	const Matrix< Scalar, rows, cols > &	m,
		const Scalar &	s
	)

inline

◆ operator+() [4/10]

template<typename Scalar , __size_type rows, __size_type cols>

Matrix<Scalar,rows,cols> capd::vectalg::operator+	(	const Matrix< Scalar, rows, cols > &	m1,
		const Matrix< Scalar, rows, cols > &	m2
	)

inline

◆ operator+() [5/10]

template<typename Scalar , __size_type cols>

Vector<Scalar,cols> capd::vectalg::operator+	(	const RowVector< Scalar, cols > &	u1,
		const RowVector< Scalar, cols > &	u2
	)

inline

◆ operator+() [6/10]

template<typename Scalar , __size_type cols>

Vector<Scalar,cols> capd::vectalg::operator+	(	const RowVector< Scalar, cols > &	u1,
		const Vector< Scalar, cols > &	u2
	)

inline

◆ operator+() [7/10]

template<typename Scalar , __size_type cols>

Vector<Scalar,cols> capd::vectalg::operator+	(	const Vector< Scalar, cols > &	u1,
		const RowVector< Scalar, cols > &	u2
	)

inline

◆ operator+() [8/10]

template<typename Scalar , __size_type dim>

Vector<Scalar,dim> capd::vectalg::operator+	(	const Vector< Scalar, dim > &	v,
		const Scalar &	s
	)

inline

◆ operator+() [9/10]

template<typename Scalar , __size_type dim>

Vector<Scalar,dim> capd::vectalg::operator+	(	const Vector< Scalar, dim > &	v1,
		const Vector< Scalar, dim > &	v2
	)

inline

◆ operator+() [10/10]

template<typename Scalar , __size_type rows>

Vector<Scalar,rows> capd::vectalg::operator+	(	const Vector< Scalar, rows > &	u,
		const ColumnVector< Scalar, rows > &	v
	)

inline

◆ operator+<capd::DInterval, CAPD_DEFAULT_DIMENSION >() [1/8]

template Vector<capd::DInterval,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator+<capd::DInterval, CAPD_DEFAULT_DIMENSION >	(	const ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	,
		const ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator+<capd::DInterval, CAPD_DEFAULT_DIMENSION >() [2/8]

template Vector<capd::DInterval,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator+<capd::DInterval, CAPD_DEFAULT_DIMENSION >	(	const ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	,
		const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator+<capd::DInterval, CAPD_DEFAULT_DIMENSION >() [3/8]

template Vector<capd::DInterval,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator+<capd::DInterval, CAPD_DEFAULT_DIMENSION >	(	const RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	,
		const RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator+<capd::DInterval, CAPD_DEFAULT_DIMENSION >() [4/8]

template Vector<capd::DInterval,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator+<capd::DInterval, CAPD_DEFAULT_DIMENSION >	(	const RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	,
		const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator+<capd::DInterval, CAPD_DEFAULT_DIMENSION >() [5/8]

template Vector<capd::DInterval,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator+<capd::DInterval, CAPD_DEFAULT_DIMENSION >	(	const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	,
		const ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator+<capd::DInterval, CAPD_DEFAULT_DIMENSION >() [6/8]

template Vector<capd::DInterval,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator+<capd::DInterval, CAPD_DEFAULT_DIMENSION >	(	const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	,
		const RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator+<capd::DInterval, CAPD_DEFAULT_DIMENSION >() [7/8]

template Vector<capd::DInterval,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator+<capd::DInterval, CAPD_DEFAULT_DIMENSION >	(	const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	v,
		const capd::DInterval &	s
	)

◆ operator+<capd::DInterval, CAPD_DEFAULT_DIMENSION >() [8/8]

template Vector<capd::DInterval,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator+<capd::DInterval, CAPD_DEFAULT_DIMENSION >	(	const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	v1,
		const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	v2
	)

◆ operator+<capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [1/2]

template Matrix<capd::DInterval,CAPD_DEFAULT_DIMENSION,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator+<capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const capd::DInterval &
	)

◆ operator+<capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [2/2]

template Matrix<capd::DInterval,CAPD_DEFAULT_DIMENSION,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator+<capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator+<double, CAPD_DEFAULT_DIMENSION >() [1/8]

template Vector<double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator+<double, CAPD_DEFAULT_DIMENSION >	(	const ColumnVector< double, CAPD_DEFAULT_DIMENSION > &	,
		const ColumnVector< double, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator+<double, CAPD_DEFAULT_DIMENSION >() [2/8]

template Vector<double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator+<double, CAPD_DEFAULT_DIMENSION >	(	const ColumnVector< double, CAPD_DEFAULT_DIMENSION > &	,
		const Vector< double, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator+<double, CAPD_DEFAULT_DIMENSION >() [3/8]

template Vector<double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator+<double, CAPD_DEFAULT_DIMENSION >	(	const RowVector< double, CAPD_DEFAULT_DIMENSION > &	,
		const RowVector< double, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator+<double, CAPD_DEFAULT_DIMENSION >() [4/8]

template Vector<double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator+<double, CAPD_DEFAULT_DIMENSION >	(	const RowVector< double, CAPD_DEFAULT_DIMENSION > &	,
		const Vector< double, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator+<double, CAPD_DEFAULT_DIMENSION >() [5/8]

template Vector<double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator+<double, CAPD_DEFAULT_DIMENSION >	(	const Vector< double, CAPD_DEFAULT_DIMENSION > &	,
		const ColumnVector< double, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator+<double, CAPD_DEFAULT_DIMENSION >() [6/8]

template Vector<double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator+<double, CAPD_DEFAULT_DIMENSION >	(	const Vector< double, CAPD_DEFAULT_DIMENSION > &	,
		const RowVector< double, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator+<double, CAPD_DEFAULT_DIMENSION >() [7/8]

template Vector<double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator+<double, CAPD_DEFAULT_DIMENSION >	(	const Vector< double, CAPD_DEFAULT_DIMENSION > &	v,
		const double &	s
	)

◆ operator+<double, CAPD_DEFAULT_DIMENSION >() [8/8]

template Vector<double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator+<double, CAPD_DEFAULT_DIMENSION >	(	const Vector< double, CAPD_DEFAULT_DIMENSION > &	v1,
		const Vector< double, CAPD_DEFAULT_DIMENSION > &	v2
	)

◆ operator+<double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [1/2]

template Matrix<double,CAPD_DEFAULT_DIMENSION,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator+<double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const double &
	)

◆ operator+<double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [2/2]

template Matrix<double,CAPD_DEFAULT_DIMENSION,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator+<double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator+<int, CAPD_DEFAULT_DIMENSION >() [1/2]

template Vector<int,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator+<int, CAPD_DEFAULT_DIMENSION >	(	const Vector< int, CAPD_DEFAULT_DIMENSION > &	v,
		const int &	s
	)

◆ operator+<int, CAPD_DEFAULT_DIMENSION >() [2/2]

template Vector<int,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator+<int, CAPD_DEFAULT_DIMENSION >	(	const Vector< int, CAPD_DEFAULT_DIMENSION > &	v1,
		const Vector< int, CAPD_DEFAULT_DIMENSION > &	v2
	)

◆ operator+<long double, CAPD_DEFAULT_DIMENSION >() [1/8]

template Vector<long double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator+<long double, CAPD_DEFAULT_DIMENSION >	(	const ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &	,
		const ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator+<long double, CAPD_DEFAULT_DIMENSION >() [2/8]

template Vector<long double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator+<long double, CAPD_DEFAULT_DIMENSION >	(	const ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &	,
		const Vector< long double, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator+<long double, CAPD_DEFAULT_DIMENSION >() [3/8]

template Vector<long double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator+<long double, CAPD_DEFAULT_DIMENSION >	(	const RowVector< long double, CAPD_DEFAULT_DIMENSION > &	,
		const RowVector< long double, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator+<long double, CAPD_DEFAULT_DIMENSION >() [4/8]

template Vector<long double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator+<long double, CAPD_DEFAULT_DIMENSION >	(	const RowVector< long double, CAPD_DEFAULT_DIMENSION > &	,
		const Vector< long double, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator+<long double, CAPD_DEFAULT_DIMENSION >() [5/8]

template Vector<long double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator+<long double, CAPD_DEFAULT_DIMENSION >	(	const Vector< long double, CAPD_DEFAULT_DIMENSION > &	,
		const ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator+<long double, CAPD_DEFAULT_DIMENSION >() [6/8]

template Vector<long double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator+<long double, CAPD_DEFAULT_DIMENSION >	(	const Vector< long double, CAPD_DEFAULT_DIMENSION > &	,
		const RowVector< long double, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator+<long double, CAPD_DEFAULT_DIMENSION >() [7/8]

template Vector<long double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator+<long double, CAPD_DEFAULT_DIMENSION >	(	const Vector< long double, CAPD_DEFAULT_DIMENSION > &	v,
		const long double &	s
	)

◆ operator+<long double, CAPD_DEFAULT_DIMENSION >() [8/8]

template Vector<long double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator+<long double, CAPD_DEFAULT_DIMENSION >	(	const Vector< long double, CAPD_DEFAULT_DIMENSION > &	v1,
		const Vector< long double, CAPD_DEFAULT_DIMENSION > &	v2
	)

◆ operator+<long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [1/2]

template Matrix<long double,CAPD_DEFAULT_DIMENSION,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator+<long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const long double &
	)

◆ operator+<long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [2/2]

template Matrix<long double,CAPD_DEFAULT_DIMENSION,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator+<long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator+<MpFloat, CAPD_DEFAULT_DIMENSION >() [1/8]

template Vector<MpFloat,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator+<MpFloat, CAPD_DEFAULT_DIMENSION >	(	const ColumnVector< MpFloat, CAPD_DEFAULT_DIMENSION > &	,
		const ColumnVector< MpFloat, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator+<MpFloat, CAPD_DEFAULT_DIMENSION >() [2/8]

template Vector<MpFloat,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator+<MpFloat, CAPD_DEFAULT_DIMENSION >	(	const ColumnVector< MpFloat, CAPD_DEFAULT_DIMENSION > &	,
		const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator+<MpFloat, CAPD_DEFAULT_DIMENSION >() [3/8]

template Vector<MpFloat,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator+<MpFloat, CAPD_DEFAULT_DIMENSION >	(	const RowVector< MpFloat, CAPD_DEFAULT_DIMENSION > &	,
		const RowVector< MpFloat, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator+<MpFloat, CAPD_DEFAULT_DIMENSION >() [4/8]

template Vector<MpFloat,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator+<MpFloat, CAPD_DEFAULT_DIMENSION >	(	const RowVector< MpFloat, CAPD_DEFAULT_DIMENSION > &	,
		const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator+<MpFloat, CAPD_DEFAULT_DIMENSION >() [5/8]

template Vector<MpFloat,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator+<MpFloat, CAPD_DEFAULT_DIMENSION >	(	const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &	,
		const ColumnVector< MpFloat, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator+<MpFloat, CAPD_DEFAULT_DIMENSION >() [6/8]

template Vector<MpFloat,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator+<MpFloat, CAPD_DEFAULT_DIMENSION >	(	const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &	,
		const RowVector< MpFloat, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator+<MpFloat, CAPD_DEFAULT_DIMENSION >() [7/8]

template Vector<MpFloat,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator+<MpFloat, CAPD_DEFAULT_DIMENSION >	(	const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &	v,
		const MpFloat &	s
	)

◆ operator+<MpFloat, CAPD_DEFAULT_DIMENSION >() [8/8]

template Vector<MpFloat,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator+<MpFloat, CAPD_DEFAULT_DIMENSION >	(	const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &	v1,
		const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &	v2
	)

◆ operator+<MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [1/2]

template Matrix<MpFloat,CAPD_DEFAULT_DIMENSION,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator+<MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator+<MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [2/2]

template Matrix<MpFloat,CAPD_DEFAULT_DIMENSION,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator+<MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const MpFloat &
	)

◆ operator+<MpInt, CAPD_DEFAULT_DIMENSION >() [1/8]

template Vector<MpInt,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator+<MpInt, CAPD_DEFAULT_DIMENSION >	(	const ColumnVector< MpInt, CAPD_DEFAULT_DIMENSION > &	,
		const ColumnVector< MpInt, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator+<MpInt, CAPD_DEFAULT_DIMENSION >() [2/8]

template Vector<MpInt,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator+<MpInt, CAPD_DEFAULT_DIMENSION >	(	const ColumnVector< MpInt, CAPD_DEFAULT_DIMENSION > &	,
		const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator+<MpInt, CAPD_DEFAULT_DIMENSION >() [3/8]

template Vector<MpInt,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator+<MpInt, CAPD_DEFAULT_DIMENSION >	(	const RowVector< MpInt, CAPD_DEFAULT_DIMENSION > &	,
		const RowVector< MpInt, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator+<MpInt, CAPD_DEFAULT_DIMENSION >() [4/8]

template Vector<MpInt,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator+<MpInt, CAPD_DEFAULT_DIMENSION >	(	const RowVector< MpInt, CAPD_DEFAULT_DIMENSION > &	,
		const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator+<MpInt, CAPD_DEFAULT_DIMENSION >() [5/8]

template Vector<MpInt,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator+<MpInt, CAPD_DEFAULT_DIMENSION >	(	const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &	,
		const ColumnVector< MpInt, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator+<MpInt, CAPD_DEFAULT_DIMENSION >() [6/8]

template Vector<MpInt,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator+<MpInt, CAPD_DEFAULT_DIMENSION >	(	const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &	,
		const RowVector< MpInt, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator+<MpInt, CAPD_DEFAULT_DIMENSION >() [7/8]

template Vector<MpInt,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator+<MpInt, CAPD_DEFAULT_DIMENSION >	(	const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &	v,
		const MpInt &	s
	)

◆ operator+<MpInt, CAPD_DEFAULT_DIMENSION >() [8/8]

template Vector<MpInt,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator+<MpInt, CAPD_DEFAULT_DIMENSION >	(	const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &	v1,
		const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &	v2
	)

◆ operator+<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [1/2]

template Matrix<MpInt,CAPD_DEFAULT_DIMENSION,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator+<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator+<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [2/2]

template Matrix<MpInt,CAPD_DEFAULT_DIMENSION,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator+<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const MpInt &
	)

◆ operator-() [1/14]

template<typename Scalar , __size_type rows>

Vector<Scalar,rows> capd::vectalg::operator- ( const ColumnVector< Scalar, rows > & u )

inline

◆ operator-() [2/14]

template<typename Scalar , __size_type rows>

Vector<Scalar,rows> capd::vectalg::operator-	(	const ColumnVector< Scalar, rows > &	u,
		const ColumnVector< Scalar, rows > &	v
	)

inline

◆ operator-() [3/14]

template<typename Scalar , __size_type rows>

Vector<Scalar,rows> capd::vectalg::operator-	(	const ColumnVector< Scalar, rows > &	v,
		const Vector< Scalar, rows > &	u
	)

inline

◆ operator-() [4/14]

template<typename Scalar , __size_type rows, __size_type cols>

Matrix<Scalar,rows,cols> capd::vectalg::operator- ( const Matrix< Scalar, rows, cols > & m )

inline

◆ operator-() [5/14]

template<typename Scalar , __size_type rows, __size_type cols>

Matrix<Scalar,rows,cols> capd::vectalg::operator-	(	const Matrix< Scalar, rows, cols > &	m,
		const Scalar &	s
	)

inline

◆ operator-() [6/14]

template<typename Scalar , __size_type rows, __size_type cols>

Matrix<Scalar,rows,cols> capd::vectalg::operator-	(	const Matrix< Scalar, rows, cols > &	m1,
		const Matrix< Scalar, rows, cols > &	m2
	)

inline

◆ operator-() [7/14]

template<typename Scalar , __size_type cols>

Vector<Scalar,cols> capd::vectalg::operator- ( const RowVector< Scalar, cols > & u )

inline

◆ operator-() [8/14]

template<typename Scalar , __size_type cols>

Vector<Scalar,cols> capd::vectalg::operator-	(	const RowVector< Scalar, cols > &	u1,
		const RowVector< Scalar, cols > &	u2
	)

inline

◆ operator-() [9/14]

template<typename Scalar , __size_type cols>

Vector<Scalar,cols> capd::vectalg::operator-	(	const RowVector< Scalar, cols > &	u1,
		const Vector< Scalar, cols > &	u2
	)

inline

◆ operator-() [10/14]

template<typename Scalar , __size_type cols>

Vector<Scalar,cols> capd::vectalg::operator-	(	const Vector< Scalar, cols > &	u1,
		const RowVector< Scalar, cols > &	u2
	)

inline

◆ operator-() [11/14]

template<typename Scalar , __size_type dim>

Vector<Scalar,dim> capd::vectalg::operator- ( const Vector< Scalar, dim > & v )

inline

◆ operator-() [12/14]

template<typename Scalar , __size_type dim>

Vector<Scalar,dim> capd::vectalg::operator-	(	const Vector< Scalar, dim > &	v,
		const Scalar &	s
	)

inline

◆ operator-() [13/14]

template<typename Scalar , __size_type dim>

Vector<Scalar,dim> capd::vectalg::operator-	(	const Vector< Scalar, dim > &	v1,
		const Vector< Scalar, dim > &	v2
	)

inline

◆ operator-() [14/14]

template<typename Scalar , __size_type rows>

Vector<Scalar,rows> capd::vectalg::operator-	(	const Vector< Scalar, rows > &	u,
		const ColumnVector< Scalar, rows > &	v
	)

inline

◆ operator-<capd::DInterval, CAPD_DEFAULT_DIMENSION >() [1/11]

template Vector<capd::DInterval,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<capd::DInterval, CAPD_DEFAULT_DIMENSION > ( const ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > & )

◆ operator-<capd::DInterval, CAPD_DEFAULT_DIMENSION >() [2/11]

template Vector<capd::DInterval,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<capd::DInterval, CAPD_DEFAULT_DIMENSION >	(	const ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	,
		const ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator-<capd::DInterval, CAPD_DEFAULT_DIMENSION >() [3/11]

template Vector<capd::DInterval,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<capd::DInterval, CAPD_DEFAULT_DIMENSION >	(	const ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	,
		const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator-<capd::DInterval, CAPD_DEFAULT_DIMENSION >() [4/11]

template Vector<capd::DInterval,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<capd::DInterval, CAPD_DEFAULT_DIMENSION > ( const RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > & )

◆ operator-<capd::DInterval, CAPD_DEFAULT_DIMENSION >() [5/11]

template Vector<capd::DInterval,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<capd::DInterval, CAPD_DEFAULT_DIMENSION >	(	const RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	,
		const RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator-<capd::DInterval, CAPD_DEFAULT_DIMENSION >() [6/11]

template Vector<capd::DInterval,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<capd::DInterval, CAPD_DEFAULT_DIMENSION >	(	const RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	,
		const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator-<capd::DInterval, CAPD_DEFAULT_DIMENSION >() [7/11]

template Vector<capd::DInterval,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<capd::DInterval, CAPD_DEFAULT_DIMENSION >	(	const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	,
		const ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator-<capd::DInterval, CAPD_DEFAULT_DIMENSION >() [8/11]

template Vector<capd::DInterval,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<capd::DInterval, CAPD_DEFAULT_DIMENSION >	(	const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	,
		const RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator-<capd::DInterval, CAPD_DEFAULT_DIMENSION >() [9/11]

template Vector<capd::DInterval,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<capd::DInterval, CAPD_DEFAULT_DIMENSION > ( const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > & v )

◆ operator-<capd::DInterval, CAPD_DEFAULT_DIMENSION >() [10/11]

template Vector<capd::DInterval,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<capd::DInterval, CAPD_DEFAULT_DIMENSION >	(	const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	v,
		const capd::DInterval &	s
	)

◆ operator-<capd::DInterval, CAPD_DEFAULT_DIMENSION >() [11/11]

template Vector<capd::DInterval,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<capd::DInterval, CAPD_DEFAULT_DIMENSION >	(	const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	v1,
		const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	v2
	)

◆ operator-<capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [1/3]

template Matrix<capd::DInterval,CAPD_DEFAULT_DIMENSION,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > ( const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > & )

◆ operator-<capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [2/3]

template Matrix<capd::DInterval,CAPD_DEFAULT_DIMENSION,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const capd::DInterval &
	)

◆ operator-<capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [3/3]

template Matrix<capd::DInterval,CAPD_DEFAULT_DIMENSION,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator-<double, CAPD_DEFAULT_DIMENSION >() [1/11]

template Vector<double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<double, CAPD_DEFAULT_DIMENSION > ( const ColumnVector< double, CAPD_DEFAULT_DIMENSION > & )

◆ operator-<double, CAPD_DEFAULT_DIMENSION >() [2/11]

template Vector<double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<double, CAPD_DEFAULT_DIMENSION >	(	const ColumnVector< double, CAPD_DEFAULT_DIMENSION > &	,
		const ColumnVector< double, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator-<double, CAPD_DEFAULT_DIMENSION >() [3/11]

template Vector<double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<double, CAPD_DEFAULT_DIMENSION >	(	const ColumnVector< double, CAPD_DEFAULT_DIMENSION > &	,
		const Vector< double, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator-<double, CAPD_DEFAULT_DIMENSION >() [4/11]

template Vector<double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<double, CAPD_DEFAULT_DIMENSION > ( const RowVector< double, CAPD_DEFAULT_DIMENSION > & )

◆ operator-<double, CAPD_DEFAULT_DIMENSION >() [5/11]

template Vector<double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<double, CAPD_DEFAULT_DIMENSION >	(	const RowVector< double, CAPD_DEFAULT_DIMENSION > &	,
		const RowVector< double, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator-<double, CAPD_DEFAULT_DIMENSION >() [6/11]

template Vector<double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<double, CAPD_DEFAULT_DIMENSION >	(	const RowVector< double, CAPD_DEFAULT_DIMENSION > &	,
		const Vector< double, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator-<double, CAPD_DEFAULT_DIMENSION >() [7/11]

template Vector<double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<double, CAPD_DEFAULT_DIMENSION >	(	const Vector< double, CAPD_DEFAULT_DIMENSION > &	,
		const ColumnVector< double, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator-<double, CAPD_DEFAULT_DIMENSION >() [8/11]

template Vector<double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<double, CAPD_DEFAULT_DIMENSION >	(	const Vector< double, CAPD_DEFAULT_DIMENSION > &	,
		const RowVector< double, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator-<double, CAPD_DEFAULT_DIMENSION >() [9/11]

template Vector<double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<double, CAPD_DEFAULT_DIMENSION > ( const Vector< double, CAPD_DEFAULT_DIMENSION > & v )

◆ operator-<double, CAPD_DEFAULT_DIMENSION >() [10/11]

template Vector<double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<double, CAPD_DEFAULT_DIMENSION >	(	const Vector< double, CAPD_DEFAULT_DIMENSION > &	v,
		const double &	s
	)

◆ operator-<double, CAPD_DEFAULT_DIMENSION >() [11/11]

template Vector<double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<double, CAPD_DEFAULT_DIMENSION >	(	const Vector< double, CAPD_DEFAULT_DIMENSION > &	v1,
		const Vector< double, CAPD_DEFAULT_DIMENSION > &	v2
	)

◆ operator-<double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [1/3]

template Matrix<double,CAPD_DEFAULT_DIMENSION,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > ( const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > & )

◆ operator-<double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [2/3]

template Matrix<double,CAPD_DEFAULT_DIMENSION,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const double &
	)

◆ operator-<double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [3/3]

template Matrix<double,CAPD_DEFAULT_DIMENSION,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator-<int, CAPD_DEFAULT_DIMENSION >() [1/3]

template Vector<int,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<int, CAPD_DEFAULT_DIMENSION > ( const Vector< int, CAPD_DEFAULT_DIMENSION > & v )

◆ operator-<int, CAPD_DEFAULT_DIMENSION >() [2/3]

template Vector<int,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<int, CAPD_DEFAULT_DIMENSION >	(	const Vector< int, CAPD_DEFAULT_DIMENSION > &	v,
		const int &	s
	)

◆ operator-<int, CAPD_DEFAULT_DIMENSION >() [3/3]

template Vector<int,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<int, CAPD_DEFAULT_DIMENSION >	(	const Vector< int, CAPD_DEFAULT_DIMENSION > &	v1,
		const Vector< int, CAPD_DEFAULT_DIMENSION > &	v2
	)

◆ operator-<long double, CAPD_DEFAULT_DIMENSION >() [1/11]

template Vector<long double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<long double, CAPD_DEFAULT_DIMENSION > ( const ColumnVector< long double, CAPD_DEFAULT_DIMENSION > & )

◆ operator-<long double, CAPD_DEFAULT_DIMENSION >() [2/11]

template Vector<long double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<long double, CAPD_DEFAULT_DIMENSION >	(	const ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &	,
		const ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator-<long double, CAPD_DEFAULT_DIMENSION >() [3/11]

template Vector<long double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<long double, CAPD_DEFAULT_DIMENSION >	(	const ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &	,
		const Vector< long double, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator-<long double, CAPD_DEFAULT_DIMENSION >() [4/11]

template Vector<long double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<long double, CAPD_DEFAULT_DIMENSION > ( const RowVector< long double, CAPD_DEFAULT_DIMENSION > & )

◆ operator-<long double, CAPD_DEFAULT_DIMENSION >() [5/11]

template Vector<long double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<long double, CAPD_DEFAULT_DIMENSION >	(	const RowVector< long double, CAPD_DEFAULT_DIMENSION > &	,
		const RowVector< long double, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator-<long double, CAPD_DEFAULT_DIMENSION >() [6/11]

template Vector<long double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<long double, CAPD_DEFAULT_DIMENSION >	(	const RowVector< long double, CAPD_DEFAULT_DIMENSION > &	,
		const Vector< long double, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator-<long double, CAPD_DEFAULT_DIMENSION >() [7/11]

template Vector<long double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<long double, CAPD_DEFAULT_DIMENSION >	(	const Vector< long double, CAPD_DEFAULT_DIMENSION > &	,
		const ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator-<long double, CAPD_DEFAULT_DIMENSION >() [8/11]

template Vector<long double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<long double, CAPD_DEFAULT_DIMENSION >	(	const Vector< long double, CAPD_DEFAULT_DIMENSION > &	,
		const RowVector< long double, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator-<long double, CAPD_DEFAULT_DIMENSION >() [9/11]

template Vector<long double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<long double, CAPD_DEFAULT_DIMENSION > ( const Vector< long double, CAPD_DEFAULT_DIMENSION > & v )

◆ operator-<long double, CAPD_DEFAULT_DIMENSION >() [10/11]

template Vector<long double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<long double, CAPD_DEFAULT_DIMENSION >	(	const Vector< long double, CAPD_DEFAULT_DIMENSION > &	v,
		const long double &	s
	)

◆ operator-<long double, CAPD_DEFAULT_DIMENSION >() [11/11]

template Vector<long double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<long double, CAPD_DEFAULT_DIMENSION >	(	const Vector< long double, CAPD_DEFAULT_DIMENSION > &	v1,
		const Vector< long double, CAPD_DEFAULT_DIMENSION > &	v2
	)

◆ operator-<long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [1/3]

template Matrix<long double,CAPD_DEFAULT_DIMENSION,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > ( const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > & )

◆ operator-<long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [2/3]

template Matrix<long double,CAPD_DEFAULT_DIMENSION,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const long double &
	)

◆ operator-<long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [3/3]

template Matrix<long double,CAPD_DEFAULT_DIMENSION,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator-<MpFloat, CAPD_DEFAULT_DIMENSION >() [1/11]

template Vector<MpFloat,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<MpFloat, CAPD_DEFAULT_DIMENSION > ( const ColumnVector< MpFloat, CAPD_DEFAULT_DIMENSION > & )

◆ operator-<MpFloat, CAPD_DEFAULT_DIMENSION >() [2/11]

template Vector<MpFloat,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<MpFloat, CAPD_DEFAULT_DIMENSION >	(	const ColumnVector< MpFloat, CAPD_DEFAULT_DIMENSION > &	,
		const ColumnVector< MpFloat, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator-<MpFloat, CAPD_DEFAULT_DIMENSION >() [3/11]

template Vector<MpFloat,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<MpFloat, CAPD_DEFAULT_DIMENSION >	(	const ColumnVector< MpFloat, CAPD_DEFAULT_DIMENSION > &	,
		const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator-<MpFloat, CAPD_DEFAULT_DIMENSION >() [4/11]

template Vector<MpFloat,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<MpFloat, CAPD_DEFAULT_DIMENSION > ( const RowVector< MpFloat, CAPD_DEFAULT_DIMENSION > & )

◆ operator-<MpFloat, CAPD_DEFAULT_DIMENSION >() [5/11]

template Vector<MpFloat,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<MpFloat, CAPD_DEFAULT_DIMENSION >	(	const RowVector< MpFloat, CAPD_DEFAULT_DIMENSION > &	,
		const RowVector< MpFloat, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator-<MpFloat, CAPD_DEFAULT_DIMENSION >() [6/11]

template Vector<MpFloat,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<MpFloat, CAPD_DEFAULT_DIMENSION >	(	const RowVector< MpFloat, CAPD_DEFAULT_DIMENSION > &	,
		const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator-<MpFloat, CAPD_DEFAULT_DIMENSION >() [7/11]

template Vector<MpFloat,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<MpFloat, CAPD_DEFAULT_DIMENSION >	(	const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &	,
		const ColumnVector< MpFloat, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator-<MpFloat, CAPD_DEFAULT_DIMENSION >() [8/11]

template Vector<MpFloat,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<MpFloat, CAPD_DEFAULT_DIMENSION >	(	const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &	,
		const RowVector< MpFloat, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator-<MpFloat, CAPD_DEFAULT_DIMENSION >() [9/11]

template Vector<MpFloat,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<MpFloat, CAPD_DEFAULT_DIMENSION > ( const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > & v )

◆ operator-<MpFloat, CAPD_DEFAULT_DIMENSION >() [10/11]

template Vector<MpFloat,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<MpFloat, CAPD_DEFAULT_DIMENSION >	(	const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &	v,
		const MpFloat &	s
	)

◆ operator-<MpFloat, CAPD_DEFAULT_DIMENSION >() [11/11]

template Vector<MpFloat,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<MpFloat, CAPD_DEFAULT_DIMENSION >	(	const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &	v1,
		const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &	v2
	)

◆ operator-<MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [1/3]

template Matrix<MpFloat,CAPD_DEFAULT_DIMENSION,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > ( const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > & )

◆ operator-<MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [2/3]

template Matrix<MpFloat,CAPD_DEFAULT_DIMENSION,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator-<MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [3/3]

template Matrix<MpFloat,CAPD_DEFAULT_DIMENSION,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const MpFloat &
	)

◆ operator-<MpInt, CAPD_DEFAULT_DIMENSION >() [1/11]

template Vector<MpInt,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<MpInt, CAPD_DEFAULT_DIMENSION > ( const ColumnVector< MpInt, CAPD_DEFAULT_DIMENSION > & )

◆ operator-<MpInt, CAPD_DEFAULT_DIMENSION >() [2/11]

template Vector<MpInt,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<MpInt, CAPD_DEFAULT_DIMENSION >	(	const ColumnVector< MpInt, CAPD_DEFAULT_DIMENSION > &	,
		const ColumnVector< MpInt, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator-<MpInt, CAPD_DEFAULT_DIMENSION >() [3/11]

template Vector<MpInt,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<MpInt, CAPD_DEFAULT_DIMENSION >	(	const ColumnVector< MpInt, CAPD_DEFAULT_DIMENSION > &	,
		const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator-<MpInt, CAPD_DEFAULT_DIMENSION >() [4/11]

template Vector<MpInt,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<MpInt, CAPD_DEFAULT_DIMENSION > ( const RowVector< MpInt, CAPD_DEFAULT_DIMENSION > & )

◆ operator-<MpInt, CAPD_DEFAULT_DIMENSION >() [5/11]

template Vector<MpInt,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<MpInt, CAPD_DEFAULT_DIMENSION >	(	const RowVector< MpInt, CAPD_DEFAULT_DIMENSION > &	,
		const RowVector< MpInt, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator-<MpInt, CAPD_DEFAULT_DIMENSION >() [6/11]

template Vector<MpInt,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<MpInt, CAPD_DEFAULT_DIMENSION >	(	const RowVector< MpInt, CAPD_DEFAULT_DIMENSION > &	,
		const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator-<MpInt, CAPD_DEFAULT_DIMENSION >() [7/11]

template Vector<MpInt,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<MpInt, CAPD_DEFAULT_DIMENSION >	(	const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &	,
		const ColumnVector< MpInt, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator-<MpInt, CAPD_DEFAULT_DIMENSION >() [8/11]

template Vector<MpInt,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<MpInt, CAPD_DEFAULT_DIMENSION >	(	const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &	,
		const RowVector< MpInt, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator-<MpInt, CAPD_DEFAULT_DIMENSION >() [9/11]

template Vector<MpInt,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<MpInt, CAPD_DEFAULT_DIMENSION > ( const Vector< MpInt, CAPD_DEFAULT_DIMENSION > & v )

◆ operator-<MpInt, CAPD_DEFAULT_DIMENSION >() [10/11]

template Vector<MpInt,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<MpInt, CAPD_DEFAULT_DIMENSION >	(	const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &	v,
		const MpInt &	s
	)

◆ operator-<MpInt, CAPD_DEFAULT_DIMENSION >() [11/11]

template Vector<MpInt,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<MpInt, CAPD_DEFAULT_DIMENSION >	(	const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &	v1,
		const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &	v2
	)

◆ operator-<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [1/3]

template Matrix<MpInt,CAPD_DEFAULT_DIMENSION,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > ( const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > & )

◆ operator-<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [2/3]

template Matrix<MpInt,CAPD_DEFAULT_DIMENSION,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator-<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [3/3]

template Matrix<MpInt,CAPD_DEFAULT_DIMENSION,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator-<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const MpInt &
	)

◆ operator/() [1/4]

template<typename Scalar , __size_type rows>

Vector<Scalar,rows> capd::vectalg::operator/	(	const ColumnVector< Scalar, rows > &	u,
		const Scalar &	s
	)

inline

◆ operator/() [2/4]

template<typename Scalar , __size_type rows, __size_type cols>

Matrix<Scalar,rows,cols> capd::vectalg::operator/	(	const Matrix< Scalar, rows, cols > &	m,
		const Scalar &	s
	)

inline

◆ operator/() [3/4]

template<typename Scalar , __size_type cols>

Vector<Scalar,cols> capd::vectalg::operator/	(	const RowVector< Scalar, cols > &	u,
		const Scalar &	s
	)

inline

◆ operator/() [4/4]

template<typename Scalar , typename FactorType , __size_type dim>

Vector<Scalar,dim> capd::vectalg::operator/	(	const Vector< Scalar, dim > &	v,
		const FactorType &	s
	)

◆ operator/<capd::DInterval, capd::DInterval, CAPD_DEFAULT_DIMENSION >()

template Vector<capd::DInterval,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator/<capd::DInterval, capd::DInterval, CAPD_DEFAULT_DIMENSION >	(	const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	v,
		const capd::DInterval &	s
	)

◆ operator/<capd::DInterval, CAPD_DEFAULT_DIMENSION >() [1/2]

template Vector<capd::DInterval,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator/<capd::DInterval, CAPD_DEFAULT_DIMENSION >	(	const ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	,
		const capd::DInterval &
	)

◆ operator/<capd::DInterval, CAPD_DEFAULT_DIMENSION >() [2/2]

template Vector<capd::DInterval,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator/<capd::DInterval, CAPD_DEFAULT_DIMENSION >	(	const RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	,
		const capd::DInterval &
	)

◆ operator/<capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

template Matrix<capd::DInterval,CAPD_DEFAULT_DIMENSION,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator/<capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const capd::DInterval &
	)

◆ operator/<capd::DInterval, double, CAPD_DEFAULT_DIMENSION >()

template Vector<capd::DInterval,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator/<capd::DInterval, double, CAPD_DEFAULT_DIMENSION >	(	const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	v,
		const double &	s
	)

◆ operator/<capd::DInterval, int, CAPD_DEFAULT_DIMENSION >()

template Vector<capd::DInterval,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator/<capd::DInterval, int, CAPD_DEFAULT_DIMENSION >	(	const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	v,
		const int &	s
	)

◆ operator/<capd::DInterval, long, CAPD_DEFAULT_DIMENSION >()

template Vector<capd::DInterval,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator/<capd::DInterval, long, CAPD_DEFAULT_DIMENSION >	(	const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	v,
		const long &	s
	)

◆ operator/<double, CAPD_DEFAULT_DIMENSION >() [1/2]

template Vector<double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator/<double, CAPD_DEFAULT_DIMENSION >	(	const ColumnVector< double, CAPD_DEFAULT_DIMENSION > &	,
		const double &
	)

◆ operator/<double, CAPD_DEFAULT_DIMENSION >() [2/2]

template Vector<double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator/<double, CAPD_DEFAULT_DIMENSION >	(	const RowVector< double, CAPD_DEFAULT_DIMENSION > &	,
		const double &
	)

◆ operator/<double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

template Matrix<double,CAPD_DEFAULT_DIMENSION,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator/<double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const double &
	)

◆ operator/<double, double, CAPD_DEFAULT_DIMENSION >()

template Vector<double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator/<double, double, CAPD_DEFAULT_DIMENSION >	(	const Vector< double, CAPD_DEFAULT_DIMENSION > &	v,
		const double &	s
	)

◆ operator/<double, int, CAPD_DEFAULT_DIMENSION >()

template Vector<double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator/<double, int, CAPD_DEFAULT_DIMENSION >	(	const Vector< double, CAPD_DEFAULT_DIMENSION > &	v,
		const int &	s
	)

◆ operator/<double, long, CAPD_DEFAULT_DIMENSION >()

template Vector<double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator/<double, long, CAPD_DEFAULT_DIMENSION >	(	const Vector< double, CAPD_DEFAULT_DIMENSION > &	v,
		const long &	s
	)

◆ operator/<int, int, CAPD_DEFAULT_DIMENSION >()

template Vector<int,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator/<int, int, CAPD_DEFAULT_DIMENSION >	(	const Vector< int, CAPD_DEFAULT_DIMENSION > &	v,
		const int &	s
	)

◆ operator/<int, long, CAPD_DEFAULT_DIMENSION >()

template Vector<int,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator/<int, long, CAPD_DEFAULT_DIMENSION >	(	const Vector< int, CAPD_DEFAULT_DIMENSION > &	v,
		const long &	s
	)

◆ operator/<long double, CAPD_DEFAULT_DIMENSION >() [1/2]

template Vector<long double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator/<long double, CAPD_DEFAULT_DIMENSION >	(	const ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &	,
		const long double &
	)

◆ operator/<long double, CAPD_DEFAULT_DIMENSION >() [2/2]

template Vector<long double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator/<long double, CAPD_DEFAULT_DIMENSION >	(	const RowVector< long double, CAPD_DEFAULT_DIMENSION > &	,
		const long double &
	)

◆ operator/<long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

template Matrix<long double,CAPD_DEFAULT_DIMENSION,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator/<long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const long double &
	)

◆ operator/<long double, int, CAPD_DEFAULT_DIMENSION >()

template Vector<long double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator/<long double, int, CAPD_DEFAULT_DIMENSION >	(	const Vector< long double, CAPD_DEFAULT_DIMENSION > &	v,
		const int &	s
	)

◆ operator/<long double, long double, CAPD_DEFAULT_DIMENSION >()

template Vector<long double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator/<long double, long double, CAPD_DEFAULT_DIMENSION >	(	const Vector< long double, CAPD_DEFAULT_DIMENSION > &	v,
		const long double &	s
	)

◆ operator/<long double, long, CAPD_DEFAULT_DIMENSION >()

template Vector<long double,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator/<long double, long, CAPD_DEFAULT_DIMENSION >	(	const Vector< long double, CAPD_DEFAULT_DIMENSION > &	v,
		const long &	s
	)

◆ operator/<MpFloat, CAPD_DEFAULT_DIMENSION >() [1/2]

template Vector<MpFloat,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator/<MpFloat, CAPD_DEFAULT_DIMENSION >	(	const ColumnVector< MpFloat, CAPD_DEFAULT_DIMENSION > &	,
		const MpFloat &
	)

◆ operator/<MpFloat, CAPD_DEFAULT_DIMENSION >() [2/2]

template Vector<MpFloat,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator/<MpFloat, CAPD_DEFAULT_DIMENSION >	(	const RowVector< MpFloat, CAPD_DEFAULT_DIMENSION > &	,
		const MpFloat &
	)

◆ operator/<MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

template Matrix<MpFloat,CAPD_DEFAULT_DIMENSION,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator/<MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const MpFloat &
	)

◆ operator/<MpFloat, int, CAPD_DEFAULT_DIMENSION >()

template Vector<MpFloat,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator/<MpFloat, int, CAPD_DEFAULT_DIMENSION >	(	const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &	v,
		const int &	s
	)

◆ operator/<MpFloat, long, CAPD_DEFAULT_DIMENSION >()

template Vector<MpFloat,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator/<MpFloat, long, CAPD_DEFAULT_DIMENSION >	(	const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &	v,
		const long &	s
	)

◆ operator/<MpFloat, MpFloat, CAPD_DEFAULT_DIMENSION >()

template Vector<MpFloat,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator/<MpFloat, MpFloat, CAPD_DEFAULT_DIMENSION >	(	const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &	v,
		const MpFloat &	s
	)

◆ operator/<MpInt, CAPD_DEFAULT_DIMENSION >() [1/2]

template Vector<MpInt,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator/<MpInt, CAPD_DEFAULT_DIMENSION >	(	const ColumnVector< MpInt, CAPD_DEFAULT_DIMENSION > &	,
		const MpInt &
	)

◆ operator/<MpInt, CAPD_DEFAULT_DIMENSION >() [2/2]

template Vector<MpInt,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator/<MpInt, CAPD_DEFAULT_DIMENSION >	(	const RowVector< MpInt, CAPD_DEFAULT_DIMENSION > &	,
		const MpInt &
	)

◆ operator/<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

template Matrix<MpInt,CAPD_DEFAULT_DIMENSION,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator/<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const MpInt &
	)

◆ operator/<MpInt, int, CAPD_DEFAULT_DIMENSION >()

template Vector<MpInt,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator/<MpInt, int, CAPD_DEFAULT_DIMENSION >	(	const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &	v,
		const int &	s
	)

◆ operator/<MpInt, long, CAPD_DEFAULT_DIMENSION >()

template Vector<MpInt,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator/<MpInt, long, CAPD_DEFAULT_DIMENSION >	(	const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &	v,
		const long &	s
	)

◆ operator/<MpInt, MpInt, CAPD_DEFAULT_DIMENSION >()

template Vector<MpInt,CAPD_DEFAULT_DIMENSION> capd::vectalg::operator/<MpInt, MpInt, CAPD_DEFAULT_DIMENSION >	(	const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &	v,
		const MpInt &	s
	)

◆ operator<() [1/2]

template<typename Scalar , __size_type rows, __size_type cols>

bool capd::vectalg::operator<	(	const Matrix< Scalar, rows, cols > &	m1,
		const Matrix< Scalar, rows, cols > &	m2
	)

inline

◆ operator<() [2/2]

template<typename Scalar , __size_type dim>

bool capd::vectalg::operator<	(	const Vector< Scalar, dim > &	v1,
		const Vector< Scalar, dim > &	v2
	)

inline

◆ operator<<() [1/3]

template<typename Scalar , __size_type rows, __size_type cols>

std::ostream & capd::vectalg::operator<<	(	std::ostream &	out,
		const Matrix< Scalar, rows, cols > &	a
	)

◆ operator<<() [2/3]

template<typename Scalar , __size_type rows>

std::ostream& capd::vectalg::operator<<	(	std::ostream &	out,
		const ColumnVector< Scalar, rows > &	s
	)

inline

◆ operator<<() [3/3]

template<typename Scalar , __size_type cols>

std::ostream& capd::vectalg::operator<<	(	std::ostream &	out,
		const RowVector< Scalar, cols > &	u
	)

inline

◆ operator<<< capd::DInterval, CAPD_DEFAULT_DIMENSION >() [1/3]

template std::ostream& capd::vectalg::operator<<< capd::DInterval, CAPD_DEFAULT_DIMENSION >	(	std::ostream &	,
		const ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator<<< capd::DInterval, CAPD_DEFAULT_DIMENSION >() [2/3]

template std::ostream& capd::vectalg::operator<<< capd::DInterval, CAPD_DEFAULT_DIMENSION >	(	std::ostream &	,
		const RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator<<< capd::DInterval, CAPD_DEFAULT_DIMENSION >() [3/3]

template std::ostream& capd::vectalg::operator<<< capd::DInterval, CAPD_DEFAULT_DIMENSION >	(	std::ostream &	out,
		const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	v
	)

◆ operator<<< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

template std::ostream& capd::vectalg::operator<<< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	std::ostream &	,
		const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator<<< double, CAPD_DEFAULT_DIMENSION >() [1/3]

template std::ostream& capd::vectalg::operator<<< double, CAPD_DEFAULT_DIMENSION >	(	std::ostream &	,
		const ColumnVector< double, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator<<< double, CAPD_DEFAULT_DIMENSION >() [2/3]

template std::ostream& capd::vectalg::operator<<< double, CAPD_DEFAULT_DIMENSION >	(	std::ostream &	,
		const RowVector< double, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator<<< double, CAPD_DEFAULT_DIMENSION >() [3/3]

template std::ostream& capd::vectalg::operator<<< double, CAPD_DEFAULT_DIMENSION >	(	std::ostream &	out,
		const Vector< double, CAPD_DEFAULT_DIMENSION > &	v
	)

◆ operator<<< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

template std::ostream& capd::vectalg::operator<<< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	std::ostream &	,
		const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator<<< int, CAPD_DEFAULT_DIMENSION >()

template std::ostream& capd::vectalg::operator<<< int, CAPD_DEFAULT_DIMENSION >	(	std::ostream &	out,
		const Vector< int, CAPD_DEFAULT_DIMENSION > &	v
	)

◆ operator<<< long double, CAPD_DEFAULT_DIMENSION >() [1/3]

template std::ostream& capd::vectalg::operator<<< long double, CAPD_DEFAULT_DIMENSION >	(	std::ostream &	,
		const ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator<<< long double, CAPD_DEFAULT_DIMENSION >() [2/3]

template std::ostream& capd::vectalg::operator<<< long double, CAPD_DEFAULT_DIMENSION >	(	std::ostream &	,
		const RowVector< long double, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator<<< long double, CAPD_DEFAULT_DIMENSION >() [3/3]

template std::ostream& capd::vectalg::operator<<< long double, CAPD_DEFAULT_DIMENSION >	(	std::ostream &	out,
		const Vector< long double, CAPD_DEFAULT_DIMENSION > &	v
	)

◆ operator<<< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

template std::ostream& capd::vectalg::operator<<< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	std::ostream &	,
		const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator<<< MpFloat, CAPD_DEFAULT_DIMENSION >() [1/3]

template std::ostream& capd::vectalg::operator<<< MpFloat, CAPD_DEFAULT_DIMENSION >	(	std::ostream &	,
		const ColumnVector< MpFloat, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator<<< MpFloat, CAPD_DEFAULT_DIMENSION >() [2/3]

template std::ostream& capd::vectalg::operator<<< MpFloat, CAPD_DEFAULT_DIMENSION >	(	std::ostream &	,
		const RowVector< MpFloat, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator<<< MpFloat, CAPD_DEFAULT_DIMENSION >() [3/3]

template std::ostream& capd::vectalg::operator<<< MpFloat, CAPD_DEFAULT_DIMENSION >	(	std::ostream &	out,
		const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &	v
	)

◆ operator<<< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

template std::ostream& capd::vectalg::operator<<< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	std::ostream &	,
		const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator<<< MpInt, CAPD_DEFAULT_DIMENSION >() [1/3]

template std::ostream& capd::vectalg::operator<<< MpInt, CAPD_DEFAULT_DIMENSION >	(	std::ostream &	,
		const ColumnVector< MpInt, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator<<< MpInt, CAPD_DEFAULT_DIMENSION >() [2/3]

template std::ostream& capd::vectalg::operator<<< MpInt, CAPD_DEFAULT_DIMENSION >	(	std::ostream &	,
		const RowVector< MpInt, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator<<< MpInt, CAPD_DEFAULT_DIMENSION >() [3/3]

template std::ostream& capd::vectalg::operator<<< MpInt, CAPD_DEFAULT_DIMENSION >	(	std::ostream &	out,
		const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &	v
	)

◆ operator<<< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

template std::ostream& capd::vectalg::operator<<< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	std::ostream &	,
		const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator<<capd::DInterval, CAPD_DEFAULT_DIMENSION >()

template bool capd::vectalg::operator<<capd::DInterval, CAPD_DEFAULT_DIMENSION >	(	const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	v1,
		const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	v2
	)

◆ operator<<capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

template bool capd::vectalg::operator<<capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator<<double, CAPD_DEFAULT_DIMENSION >()

template bool capd::vectalg::operator<<double, CAPD_DEFAULT_DIMENSION >	(	const Vector< double, CAPD_DEFAULT_DIMENSION > &	v1,
		const Vector< double, CAPD_DEFAULT_DIMENSION > &	v2
	)

◆ operator<<double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

template bool capd::vectalg::operator<<double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator<<int, CAPD_DEFAULT_DIMENSION >()

template bool capd::vectalg::operator<<int, CAPD_DEFAULT_DIMENSION >	(	const Vector< int, CAPD_DEFAULT_DIMENSION > &	v1,
		const Vector< int, CAPD_DEFAULT_DIMENSION > &	v2
	)

◆ operator<<long double, CAPD_DEFAULT_DIMENSION >()

template bool capd::vectalg::operator<<long double, CAPD_DEFAULT_DIMENSION >	(	const Vector< long double, CAPD_DEFAULT_DIMENSION > &	v1,
		const Vector< long double, CAPD_DEFAULT_DIMENSION > &	v2
	)

◆ operator<<long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

template bool capd::vectalg::operator<<long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator<<MpFloat, CAPD_DEFAULT_DIMENSION >()

template bool capd::vectalg::operator<<MpFloat, CAPD_DEFAULT_DIMENSION >	(	const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &	v1,
		const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &	v2
	)

◆ operator<<MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

template bool capd::vectalg::operator<<MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator<<MpInt, CAPD_DEFAULT_DIMENSION >()

template bool capd::vectalg::operator<<MpInt, CAPD_DEFAULT_DIMENSION >	(	const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &	v1,
		const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &	v2
	)

◆ operator<<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

template bool capd::vectalg::operator<<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator<=() [1/2]

template<typename Scalar , __size_type rows, __size_type cols>

bool capd::vectalg::operator<=	(	const Matrix< Scalar, rows, cols > &	m1,
		const Matrix< Scalar, rows, cols > &	m2
	)

inline

◆ operator<=() [2/2]

template<typename Scalar , __size_type dim>

bool capd::vectalg::operator<=	(	const Vector< Scalar, dim > &	v1,
		const Vector< Scalar, dim > &	v2
	)

inline

◆ operator<=< capd::DInterval, CAPD_DEFAULT_DIMENSION >()

template bool capd::vectalg::operator<=< capd::DInterval, CAPD_DEFAULT_DIMENSION >	(	const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	v1,
		const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	v2
	)

◆ operator<=< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

template bool capd::vectalg::operator<=< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator<=< double, CAPD_DEFAULT_DIMENSION >()

template bool capd::vectalg::operator<=< double, CAPD_DEFAULT_DIMENSION >	(	const Vector< double, CAPD_DEFAULT_DIMENSION > &	v1,
		const Vector< double, CAPD_DEFAULT_DIMENSION > &	v2
	)

◆ operator<=< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

template bool capd::vectalg::operator<=< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator<=< int, CAPD_DEFAULT_DIMENSION >()

template bool capd::vectalg::operator<=< int, CAPD_DEFAULT_DIMENSION >	(	const Vector< int, CAPD_DEFAULT_DIMENSION > &	v1,
		const Vector< int, CAPD_DEFAULT_DIMENSION > &	v2
	)

◆ operator<=< long double, CAPD_DEFAULT_DIMENSION >()

template bool capd::vectalg::operator<=< long double, CAPD_DEFAULT_DIMENSION >	(	const Vector< long double, CAPD_DEFAULT_DIMENSION > &	v1,
		const Vector< long double, CAPD_DEFAULT_DIMENSION > &	v2
	)

◆ operator<=< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

template bool capd::vectalg::operator<=< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator<=< MpFloat, CAPD_DEFAULT_DIMENSION >()

template bool capd::vectalg::operator<=< MpFloat, CAPD_DEFAULT_DIMENSION >	(	const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &	v1,
		const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &	v2
	)

◆ operator<=< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

template bool capd::vectalg::operator<=< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator<=< MpInt, CAPD_DEFAULT_DIMENSION >()

template bool capd::vectalg::operator<=< MpInt, CAPD_DEFAULT_DIMENSION >	(	const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &	v1,
		const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &	v2
	)

◆ operator<=< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

template bool capd::vectalg::operator<=< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator==() [1/2]

template<typename Scalar , __size_type rows, __size_type cols>

bool capd::vectalg::operator==	(	const Matrix< Scalar, rows, cols > &	a1,
		const Matrix< Scalar, rows, cols > &	a2
	)

inline

◆ operator==() [2/2]

template<typename Scalar , __size_type dim>

bool capd::vectalg::operator==	(	const Vector< Scalar, dim > &	v1,
		const Vector< Scalar, dim > &	v2
	)

inline

◆ operator>() [1/2]

template<typename Scalar , __size_type rows, __size_type cols>

bool capd::vectalg::operator>	(	const Matrix< Scalar, rows, cols > &	m1,
		const Matrix< Scalar, rows, cols > &	m2
	)

inline

◆ operator>() [2/2]

template<typename Scalar , __size_type dim>

bool capd::vectalg::operator>	(	const Vector< Scalar, dim > &	v1,
		const Vector< Scalar, dim > &	v2
	)

inline

◆ operator><double, CAPD_DEFAULT_DIMENSION >()

template bool capd::vectalg::operator><double, CAPD_DEFAULT_DIMENSION >	(	const Vector< double, CAPD_DEFAULT_DIMENSION > &	v1,
		const Vector< double, CAPD_DEFAULT_DIMENSION > &	v2
	)

◆ operator><double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

template bool capd::vectalg::operator><double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator><int, CAPD_DEFAULT_DIMENSION >()

template bool capd::vectalg::operator><int, CAPD_DEFAULT_DIMENSION >	(	const Vector< int, CAPD_DEFAULT_DIMENSION > &	v1,
		const Vector< int, CAPD_DEFAULT_DIMENSION > &	v2
	)

◆ operator><long double, CAPD_DEFAULT_DIMENSION >()

template bool capd::vectalg::operator><long double, CAPD_DEFAULT_DIMENSION >	(	const Vector< long double, CAPD_DEFAULT_DIMENSION > &	v1,
		const Vector< long double, CAPD_DEFAULT_DIMENSION > &	v2
	)

◆ operator><long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

template bool capd::vectalg::operator><long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator><MpFloat, CAPD_DEFAULT_DIMENSION >()

template bool capd::vectalg::operator><MpFloat, CAPD_DEFAULT_DIMENSION >	(	const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &	v1,
		const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &	v2
	)

◆ operator><MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

template bool capd::vectalg::operator><MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator><MpInt, CAPD_DEFAULT_DIMENSION >()

template bool capd::vectalg::operator><MpInt, CAPD_DEFAULT_DIMENSION >	(	const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &	v1,
		const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &	v2
	)

◆ operator><MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

template bool capd::vectalg::operator><MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator>=() [1/2]

template<typename Scalar , __size_type rows, __size_type cols>

bool capd::vectalg::operator>=	(	const Matrix< Scalar, rows, cols > &	m1,
		const Matrix< Scalar, rows, cols > &	m2
	)

inline

◆ operator>=() [2/2]

template<typename Scalar , __size_type dim>

bool capd::vectalg::operator>=	(	const Vector< Scalar, dim > &	v1,
		const Vector< Scalar, dim > &	v2
	)

inline

◆ operator>=< double, CAPD_DEFAULT_DIMENSION >()

template bool capd::vectalg::operator>=< double, CAPD_DEFAULT_DIMENSION >	(	const Vector< double, CAPD_DEFAULT_DIMENSION > &	v1,
		const Vector< double, CAPD_DEFAULT_DIMENSION > &	v2
	)

◆ operator>=< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

template bool capd::vectalg::operator>=< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator>=< int, CAPD_DEFAULT_DIMENSION >()

template bool capd::vectalg::operator>=< int, CAPD_DEFAULT_DIMENSION >	(	const Vector< int, CAPD_DEFAULT_DIMENSION > &	v1,
		const Vector< int, CAPD_DEFAULT_DIMENSION > &	v2
	)

◆ operator>=< long double, CAPD_DEFAULT_DIMENSION >()

template bool capd::vectalg::operator>=< long double, CAPD_DEFAULT_DIMENSION >	(	const Vector< long double, CAPD_DEFAULT_DIMENSION > &	v1,
		const Vector< long double, CAPD_DEFAULT_DIMENSION > &	v2
	)

◆ operator>=< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

template bool capd::vectalg::operator>=< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator>=< MpFloat, CAPD_DEFAULT_DIMENSION >()

template bool capd::vectalg::operator>=< MpFloat, CAPD_DEFAULT_DIMENSION >	(	const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &	v1,
		const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &	v2
	)

◆ operator>=< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

template bool capd::vectalg::operator>=< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator>=< MpInt, CAPD_DEFAULT_DIMENSION >()

template bool capd::vectalg::operator>=< MpInt, CAPD_DEFAULT_DIMENSION >	(	const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &	v1,
		const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &	v2
	)

◆ operator>=< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

template bool capd::vectalg::operator>=< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	,
		const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator>>()

template<typename Scalar , __size_type rows, __size_type cols>

std::istream & capd::vectalg::operator>>	(	std::istream &	inp,
		Matrix< Scalar, rows, cols > &	a
	)

◆ operator>>< double, CAPD_DEFAULT_DIMENSION >()

template std::istream& capd::vectalg::operator>>< double, CAPD_DEFAULT_DIMENSION >	(	std::istream &	inp,
		Vector< double, CAPD_DEFAULT_DIMENSION > &	v
	)

◆ operator>>< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

template std::istream& capd::vectalg::operator>>< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	std::istream &	,
		Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator>>< int, CAPD_DEFAULT_DIMENSION >()

template std::istream& capd::vectalg::operator>>< int, CAPD_DEFAULT_DIMENSION >	(	std::istream &	inp,
		Vector< int, CAPD_DEFAULT_DIMENSION > &	v
	)

◆ operator>>< long double, CAPD_DEFAULT_DIMENSION >()

template std::istream& capd::vectalg::operator>>< long double, CAPD_DEFAULT_DIMENSION >	(	std::istream &	inp,
		Vector< long double, CAPD_DEFAULT_DIMENSION > &	v
	)

◆ operator>>< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

template std::istream& capd::vectalg::operator>>< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	std::istream &	,
		Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator>>< MpFloat, CAPD_DEFAULT_DIMENSION >()

template std::istream& capd::vectalg::operator>>< MpFloat, CAPD_DEFAULT_DIMENSION >	(	std::istream &	inp,
		Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &	v
	)

◆ operator>>< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

template std::istream& capd::vectalg::operator>>< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	std::istream &	,
		Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &
	)

◆ operator>>< MpInt, CAPD_DEFAULT_DIMENSION >()

template std::istream& capd::vectalg::operator>>< MpInt, CAPD_DEFAULT_DIMENSION >	(	std::istream &	inp,
		Vector< MpInt, CAPD_DEFAULT_DIMENSION > &	v
	)

◆ operator>>< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

template std::istream& capd::vectalg::operator>>< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >	(	std::istream &	,
		Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &
	)

◆ printVector() [1/3]

template std::ostream& capd::vectalg::printVector	(	std::ostream &	str,
		const ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	,
		int	,
		int
	)

◆ printVector() [2/3]

template std::ostream& capd::vectalg::printVector	(	std::ostream &	str,
		const ColumnVector< double, CAPD_DEFAULT_DIMENSION > &	,
		int	,
		int
	)

◆ printVector() [3/3]

template std::ostream& capd::vectalg::printVector	(	std::ostream &	str,
		const ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &	,
		int	,
		int
	)

◆ printVector< IVector >()

template std::ostream& capd::vectalg::printVector< IVector >	(	std::ostream &	str,
		const IVector &	v,
		int	firstIndex,
		int	lastIndex
	)

◆ push_back()

Multipointer capd::vectalg::push_back	(	const Multipointer &	mp,
		int	index
	)

appends index to the end of multipointer mp

◆ removeIndex()

Multipointer capd::vectalg::removeIndex	(	const Multipointer &	mp,
		int	index
	)

returns a multipointer with removed index

Parameters

[in]	mp	- multipointer from which an index is removed
[in]	index	-index to be removed

Returns: a multipointer with removed index

◆ rightVector()

template<typename IVector >

IVector capd::vectalg::rightVector ( const IVector & u )

inline

◆ rightVector< IVector >()

template IVector capd::vectalg::rightVector< IVector > ( const IVector & v )

◆ scalarProduct() [1/2]

template<typename T1 , typename T2 >

T1::ScalarType capd::vectalg::scalarProduct	(	const T1 &	v1,
		const T2 &	v2
	)

this procedure can be use to compute scalar product of two vector-like objects:

vectors, matrices, references to columns or rows of matrix
vectors of partial derivatives from higher order containers result = v1 * v2

◆ scalarProduct() [2/2]

template Vector<capd::DInterval, CAPD_DEFAULT_DIMENSION>::ScalarType capd::vectalg::scalarProduct	(	Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > const &	,
		Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > const &
	)

◆ secondTrace()

template<typename Scalar , __size_type rows, __size_type cols>

Matrix< Scalar, cols, rows >::ScalarType capd::vectalg::secondTrace ( const Matrix< Scalar, cols, rows > & A )

It returns a sum of determinants of all 2x2 matrix.

It returns a sum of determinants of all 2x2 matrices from main diagonal.

◆ setDimensionInArray() [1/4]

template<typename Scalar >

void capd::vectalg::setDimensionInArray	(	Matrix< Scalar, 0, 0 > *	t,
		__size_type	N,
		__size_type	r,
		__size_type	c
	)

inline

◆ setDimensionInArray() [2/4]

template<typename Scalar , __size_type rows, __size_type cols>

void capd::vectalg::setDimensionInArray	(	Matrix< Scalar, rows, cols > *	,
		__size_type	,
		__size_type	,
		__size_type
	)

inline

◆ setDimensionInArray() [3/4]

template<typename Scalar >

void capd::vectalg::setDimensionInArray	(	Vector< Scalar, 0 > *	t,
		__size_type	N,
		__size_type	_dim
	)

inline

◆ setDimensionInArray() [4/4]

template<typename Scalar , __size_type dim>

void capd::vectalg::setDimensionInArray	(	Vector< Scalar, dim > *	,
		__size_type	,
		__size_type
	)

inline

◆ solveAffineInclusion() [1/4]

template<typename IVector >

IVector::ScalarType capd::vectalg::solveAffineInclusion	(	const IVector &	,
		const IVector &	,
		const IVector &
	)

◆ solveAffineInclusion() [2/4]

template<typename IVector >

IVector::ScalarType capd::vectalg::solveAffineInclusion	(	const IVector &	,
		const IVector &	,
		const IVector &	,
		int &
	)

◆ solveAffineInclusion() [3/4]

template<typename IVectorType >

IVectorType::ScalarType capd::vectalg::solveAffineInclusion	(	const IVectorType &	a,
		const IVectorType &	p,
		const IVectorType &	c
	)

◆ solveAffineInclusion() [4/4]

template<typename IVectorType >

IVectorType::ScalarType capd::vectalg::solveAffineInclusion	(	const IVectorType &	a,
		const IVectorType &	p,
		const IVectorType &	c,
		int &	dir
	)

◆ solveAffineInclusion< IVector >() [1/2]

template capd::DInterval capd::vectalg::solveAffineInclusion< IVector >	(	const IVector &	a,
		const IVector &	p,
		const IVector &	c
	)

◆ solveAffineInclusion< IVector >() [2/2]

template capd::DInterval capd::vectalg::solveAffineInclusion< IVector >	(	const IVector &	a,
		const IVector &	p,
		const IVector &	c,
		int &
	)

◆ split< IMatrix, DMatrix >()

template void capd::vectalg::split< IMatrix, DMatrix >	(	const IMatrix &	,
		DMatrix &	,
		IMatrix &
	)

◆ split< IMatrix, IMatrix >()

template void capd::vectalg::split< IMatrix, IMatrix >	(	IMatrix &	,
		IMatrix &
	)

◆ split< IVector, DVector >()

template void capd::vectalg::split< IVector, DVector >	(	const IVector &	v,
		DVector &	,
		IVector &	rv
	)

◆ split< IVector, IVector >()

template void capd::vectalg::split< IVector, IVector >	(	IVector &	v,
		IVector &	rv
	)

◆ subset< IMatrix >()

template bool capd::vectalg::subset< IMatrix >	(	const IMatrix &	v1,
		const IMatrix &	v2
	)

◆ subset< IVector >()

template bool capd::vectalg::subset< IVector >	(	const IVector &	v1,
		const IVector &	v2
	)

◆ subsetInterior< IMatrix >()

template bool capd::vectalg::subsetInterior< IMatrix >	(	const IMatrix &	v1,
		const IMatrix &	v2
	)

◆ subsetInterior< IVector >()

template bool capd::vectalg::subsetInterior< IVector >	(	const IVector &	v1,
		const IVector &	v2
	)

◆ subtractAssignMatrixByVector() [1/5]

template<typename V , typename M , typename V2 >

V & capd::vectalg::subtractAssignMatrixByVector	(	V &	u,
		const M &	A,
		const V2 &	v
	)

This procedure computes u -= A*v where u,v are vectors and A is a matrix.

◆ subtractAssignMatrixByVector() [2/5]

template Vector<capd::DInterval,CAPD_DEFAULT_DIMENSION>& capd::vectalg::subtractAssignMatrixByVector	(	Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	u,
		const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	A,
		const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	v
	)

◆ subtractAssignMatrixByVector() [3/5]

template Vector<double,CAPD_DEFAULT_DIMENSION>& capd::vectalg::subtractAssignMatrixByVector	(	Vector< double, CAPD_DEFAULT_DIMENSION > &	u,
		const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	A,
		const Vector< double, CAPD_DEFAULT_DIMENSION > &	v
	)

◆ subtractAssignMatrixByVector() [4/5]

template Vector<long double,CAPD_DEFAULT_DIMENSION>& capd::vectalg::subtractAssignMatrixByVector	(	Vector< long double, CAPD_DEFAULT_DIMENSION > &	u,
		const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	A,
		const Vector< long double, CAPD_DEFAULT_DIMENSION > &	v
	)

◆ subtractAssignMatrixByVector() [5/5]

template Vector<MpFloat,CAPD_DEFAULT_DIMENSION>& capd::vectalg::subtractAssignMatrixByVector	(	Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &	u,
		const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	A,
		const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &	v
	)

◆ subtractAssignObjectObject() [1/2]

template RowVector<double, CAPD_DEFAULT_DIMENSION>& capd::vectalg::subtractAssignObjectObject	(	RowVector< double, CAPD_DEFAULT_DIMENSION > &	,
		Vector< double, CAPD_DEFAULT_DIMENSION > const &
	)

◆ subtractAssignObjectObject() [2/2]

template<typename T1 , typename T2 >

T1 & capd::vectalg::subtractAssignObjectObject	(	T1 &	u,
		const T2 &	v
	)

this procedure can be use to subtract of two vector-like objects result is stored in the first argument u -= v

this procedure can be use to subtract of two vector-like objects result is stored in the first argument u += v

◆ subtractAssignObjectScalar()

template<typename Object , typename Scalar >

Object & capd::vectalg::subtractAssignObjectScalar	(	Object &	u,
		const Scalar &	s
	)

this procedure can be use to subtract a scalar from each element of a vector-like object u[i] -= s

this procedure can be use to subtract a scalar from any element of two vector-like objects u[i] -= s

◆ subtractObjects() [1/14]

template void capd::vectalg::subtractObjects	(	const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	v1,
		const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	v2,
		Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	result
	)

◆ subtractObjects() [2/14]

template void capd::vectalg::subtractObjects	(	const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	v1,
		const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	v2,
		Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	result
	)

◆ subtractObjects() [3/14]

template void capd::vectalg::subtractObjects	(	const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	v1,
		const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	v2,
		Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	result
	)

◆ subtractObjects() [4/14]

template void capd::vectalg::subtractObjects	(	const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	v1,
		const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	v2,
		Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	result
	)

◆ subtractObjects() [5/14]

template void capd::vectalg::subtractObjects	(	const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	v1,
		const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	v2,
		Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &	result
	)

◆ subtractObjects() [6/14]

template<typename ResultType , typename T1 , typename T2 >

ResultType capd::vectalg::subtractObjects	(	const T1 &	v1,
		const T2 &	v2
	)

inline

◆ subtractObjects() [7/14]

template<typename ResultType , typename T1 , typename T2 >

void capd::vectalg::subtractObjects	(	const T1 &	v1,
		const T2 &	v2,
		ResultType &	result
	)

this procedure can be use to subtract two vector-like objects:

vectors, matrices, references to columns or rows of matrix
higher dimensional containers result = v1 - v2

◆ subtractObjects() [8/14]

template void capd::vectalg::subtractObjects	(	const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	,
		const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &	,
		Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &
	)

◆ subtractObjects() [9/14]

template void capd::vectalg::subtractObjects	(	const Vector< double, CAPD_DEFAULT_DIMENSION > &	v1,
		const Vector< double, CAPD_DEFAULT_DIMENSION > &	v2,
		Vector< double, CAPD_DEFAULT_DIMENSION > &	result
	)

◆ subtractObjects() [10/14]

template void capd::vectalg::subtractObjects	(	const Vector< int, CAPD_DEFAULT_DIMENSION > &	v1,
		const Vector< int, CAPD_DEFAULT_DIMENSION > &	v2,
		Vector< int, CAPD_DEFAULT_DIMENSION > &	result
	)

◆ subtractObjects() [11/14]

template void capd::vectalg::subtractObjects	(	const Vector< long double, CAPD_DEFAULT_DIMENSION > &	v1,
		const Vector< long double, CAPD_DEFAULT_DIMENSION > &	v2,
		Vector< long double, CAPD_DEFAULT_DIMENSION > &	result
	)

◆ subtractObjects() [12/14]

template void capd::vectalg::subtractObjects	(	const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &	v1,
		const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &	v2,
		Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &	result
	)

◆ subtractObjects() [13/14]

template void capd::vectalg::subtractObjects	(	const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &	v1,
		const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &	v2,
		Vector< MpInt, CAPD_DEFAULT_DIMENSION > &	result
	)

◆ subtractObjects() [14/14]

template void capd::vectalg::subtractObjects	(	Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > const &	,
		ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > const &	,
		Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &
	)

◆ subtractObjectScalar()

template<typename ResultType , typename Object , typename FactorType >

ResultType capd::vectalg::subtractObjectScalar	(	const Object &	v,
		const FactorType &	s
	)

this procedure can be used to substract a scalar from any element of vector-like objects result[i] = v[i] - s

this procedure can be use to subtract a scalar from any element of vector-like objects result[i] = v[i] - s

◆ sumMultipointers()

Multipointer capd::vectalg::sumMultipointers	(	const Multipointer &	x,
		const Multipointer &	y
	)

◆ trace()

template<typename Scalar , __size_type rows, __size_type cols>

Matrix< Scalar, cols, rows >::ScalarType capd::vectalg::trace ( const Matrix< Scalar, cols, rows > & A )

Computes Trace of a given matrix.

Trace is a sum of all elements on the main diagonal

◆ transpose()

template<typename Scalar , __size_type rows, __size_type cols>

Matrix< Scalar, cols, rows > capd::vectalg::transpose ( const Matrix< Scalar, rows, cols > & a )

◆ Transpose()

template<typename Scalar , __size_type rows, __size_type cols>

Matrix< Scalar, cols, rows > capd::vectalg::Transpose ( const Matrix< Scalar, rows, cols > & a )

inline

◆ Transpose< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

template Matrix<capd::DInterval,CAPD_DEFAULT_DIMENSION,CAPD_DEFAULT_DIMENSION> capd::vectalg::Transpose< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > ( const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > & )

◆ Transpose< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

template Matrix<double,CAPD_DEFAULT_DIMENSION,CAPD_DEFAULT_DIMENSION> capd::vectalg::Transpose< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > ( const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > & )

◆ Transpose< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

template Matrix<long double,CAPD_DEFAULT_DIMENSION,CAPD_DEFAULT_DIMENSION> capd::vectalg::Transpose< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > ( const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > & )

◆ Transpose< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

template Matrix<MpFloat,CAPD_DEFAULT_DIMENSION,CAPD_DEFAULT_DIMENSION> capd::vectalg::Transpose< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > ( const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > & )

◆ Transpose< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

template Matrix<MpInt,CAPD_DEFAULT_DIMENSION,CAPD_DEFAULT_DIMENSION> capd::vectalg::Transpose< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > ( const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > & )

◆ unaryMinus() [1/4]

template Vector<capd::DInterval,CAPD_DEFAULT_DIMENSION> capd::vectalg::unaryMinus ( ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > const & )

◆ unaryMinus() [2/4]

template Vector<double, CAPD_DEFAULT_DIMENSION> capd::vectalg::unaryMinus ( ColumnVector< double, CAPD_DEFAULT_DIMENSION > const & )

◆ unaryMinus() [3/4]

template Vector<long double, CAPD_DEFAULT_DIMENSION> capd::vectalg::unaryMinus ( ColumnVector< long double, CAPD_DEFAULT_DIMENSION > const & )

◆ unaryMinus() [4/4]

template<typename ResultType , typename Object >

ResultType capd::vectalg::unaryMinus ( const Object & v )

◆ vectorToString< IVector >()

template std::string capd::vectalg::vectorToString< IVector >	(	const IVector &	v,
		int	firstIndex,
		int	lastIndex,
		int	precision
	)

◆ widths()

template<typename IObject >

IObject::template rebind<typename capd::TypeTraits<typename IObject::ScalarType>::Real>::other capd::vectalg::widths ( const IObject & v )

◆ widths< IMatrix >()

template DMatrix capd::vectalg::widths< IMatrix > ( const IMatrix & v )

◆ widths< IVector >()

template DVector capd::vectalg::widths< IVector > ( const IVector & v )

Classes

Typedefs

Functions

Typedef Documentation

◆ __difference_type

◆ __size_type

◆ DMatrix

◆ DVector

◆ IMatrix

◆ IVector

◆ LDVector

Function Documentation

◆ abs() [1/2]

◆ abs() [2/2]

◆ abs< capd::DInterval, CAPD_DEFAULT_DIMENSION >()

◆ abs< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

◆ abs< double, CAPD_DEFAULT_DIMENSION >()

◆ abs< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

◆ abs< int, CAPD_DEFAULT_DIMENSION >()

◆ abs< long double, CAPD_DEFAULT_DIMENSION >()

◆ abs< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

◆ abs< MpFloat, CAPD_DEFAULT_DIMENSION >()

◆ abs< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

◆ abs< MpInt, CAPD_DEFAULT_DIMENSION >()

◆ abs< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

◆ absoluteValue()

◆ addAssignMatrixByVector() [1/5]

◆ addAssignMatrixByVector() [2/5]

◆ addAssignMatrixByVector() [3/5]

◆ addAssignMatrixByVector() [4/5]

◆ addAssignMatrixByVector() [5/5]

◆ addAssignObjectObject() [1/2]

◆ addAssignObjectObject() [2/2]

◆ addAssignObjectScalar() [1/2]

◆ addAssignObjectScalar() [2/2]

◆ addIndex()

◆ addObjects() [1/14]

◆ addObjects() [2/14]

◆ addObjects() [3/14]

◆ addObjects() [4/14]

◆ addObjects() [5/14]

◆ addObjects() [6/14]

◆ addObjects() [7/14]

◆ addObjects() [8/14]

◆ addObjects() [9/14]

◆ addObjects() [10/14]

◆ addObjects() [11/14]

◆ addObjects() [12/14]

◆ addObjects() [13/14]

◆ addObjects() [14/14]

◆ addObjectScalar() [1/2]

◆ addObjectScalar() [2/2]

◆ assignFromScalar() [1/2]

◆ assignFromScalar() [2/2]

◆ assignObjectObject() [1/13]

◆ assignObjectObject() [2/13]

◆ assignObjectObject() [3/13]

◆ assignObjectObject() [4/13]

◆ assignObjectObject() [5/13]

◆ assignObjectObject() [6/13]

◆ assignObjectObject() [7/13]

◆ assignObjectObject() [8/13]

◆ assignObjectObject() [9/13]

◆ assignObjectObject() [10/13]

◆ assignObjectObject() [11/13]

◆ assignObjectObject() [12/13]

◆ assignObjectObject() [13/13]

◆ clear() [1/4]

◆ clear() [2/4]

◆ clear() [3/4]

◆ clear() [4/4]

◆ computeNewton()

◆ copyFromSubmatrix()

◆ copyFromSubvector()

◆ copyToSubmatrix()

◆ copyToSubvector()

◆ cppReprezentation() [1/8]

◆ cppReprezentation() [2/8]

◆ cppReprezentation() [3/8]

◆ cppReprezentation() [4/8]