Classes
class	ColumnIterator

class	const_ColumnIterator

class	Matrix

class	Vector

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	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, true >

struct	Convert< ResultType, ScalarType, false >

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	Multipointer
	Multipointer always contains nondecreasing list of indexes of variables. 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	Norm
	A general abstract norm. More...

class	EuclNorm
	Euclidean norm. More...

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

class	SumNorm
	norm More...

class	EuclLNorm
	Euclidean Logarithmic Norm. More...

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

class	SumLNorm
	Logarytmic 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...

Typedefs
typedef unsigned	__size_type

typedef int	__difference_type

typedef Vector< double, 0 >	DVector

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

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

typedef Vector< capd::DInterval, 0 >	IVector

typedef Vector< long double, 0 >	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, 0, 0 >	abs< double, 0, 0 > (const Matrix< double, 0, 0 > &)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template Matrix< double, 0, 0 > &	addAssignObjectObject (Matrix< double, 0, 0 > &, const Matrix< double, 0, 0 > &)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template Matrix< capd::DInterval, 0, 0 > &	addAssignObjectObject (Matrix< capd::DInterval, 0, 0 > &, const Matrix< capd::DInterval, 0, 0 > &)

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, 0 >	operator+<capd::DInterval, 0 > (const Vector< capd::DInterval, 0 > &, const RowVector< capd::DInterval, 0 > &)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template RowVector< capd::DInterval, 0 > &	assignObjectObject (RowVector< capd::DInterval, 0 > &, RowVector< capd::DInterval, 0 > 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, 0 > &, int, int)

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

template IVector	multiplyObjectScalar (RowVector< capd::DInterval, 0 > 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, 0 > &	divideAssignObjectScalar (ColumnVector< capd::DInterval, 0 > &, capd::DInterval const &)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template Matrix< long double, 0, 0 > &	addAssignObjectObject (Matrix< long double, 0, 0 > &, const Matrix< long double, 0, 0 > &)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

int	computeNewton (int d, int l)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template Matrix< MpFloat, 0, 0 > &	addAssignObjectObject (Matrix< MpFloat, 0, 0 > &, const Matrix< MpFloat, 0, 0 > &)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template void	addObjects (const Vector< MpInt, 0 > &v1, const Vector< MpInt, 0 > &v2, Vector< MpInt, 0 > &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, 0 , 0 > capd::vectalg::DMatrix

◆ DVector

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

◆ IMatrix

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

◆ IVector

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

◆ LDVector

typedef Vector<long double, 0 > 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, 0 >()

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

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

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

◆ abs< double, 0 >()

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

◆ abs< double, 0, 0 >()

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

◆ abs< int, 0 >()

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

◆ abs< long double, 0 >()

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

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

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

◆ abs< MpFloat, 0 >()

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

◆ abs< MpFloat, 0, 0 >()

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

◆ abs< MpInt, 0 >()

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

◆ abs< MpInt, 0, 0 >()

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

◆ 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, 0 >& capd::vectalg::addAssignMatrixByVector	(	Vector< capd::DInterval, 0 > &	u,
		const Matrix< capd::DInterval, 0, 0 > &	A,
		const Vector< capd::DInterval, 0 > &	v
	)

◆ addAssignMatrixByVector() [3/5]

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

◆ addAssignMatrixByVector() [4/5]

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

◆ addAssignMatrixByVector() [5/5]

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

◆ addAssignObjectObject() [1/6]

template Matrix<capd::DInterval, 0 , 0 >& capd::vectalg::addAssignObjectObject	(	Matrix< capd::DInterval, 0, 0 > &	,
		const Matrix< capd::DInterval, 0, 0 > &
	)

◆ addAssignObjectObject() [2/6]

template Matrix<double, 0 , 0 >& capd::vectalg::addAssignObjectObject	(	Matrix< double, 0, 0 > &	,
		const Matrix< double, 0, 0 > &
	)

◆ addAssignObjectObject() [3/6]

template Matrix<long double, 0 , 0 >& capd::vectalg::addAssignObjectObject	(	Matrix< long double, 0, 0 > &	,
		const Matrix< long double, 0, 0 > &
	)

◆ addAssignObjectObject() [4/6]

template Matrix<MpFloat, 0 , 0 >& capd::vectalg::addAssignObjectObject	(	Matrix< MpFloat, 0, 0 > &	,
		const Matrix< MpFloat, 0, 0 > &
	)

◆ addAssignObjectObject() [5/6]

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() [6/6]

template Vector<double, 0 >& capd::vectalg::addAssignObjectObject	(	Vector< double, 0 > &	,
		Vector< double, 0 > 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, 0 >& capd::vectalg::addAssignObjectScalar	(	Vector< capd::DInterval, 0 > &	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, 0, 0 > &	v1,
		const Matrix< capd::DInterval, 0, 0 > &	v2,
		Matrix< capd::DInterval, 0, 0 > &	result
	)

◆ addObjects() [2/14]

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

◆ addObjects() [3/14]

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

◆ addObjects() [4/14]

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

◆ addObjects() [5/14]

template void capd::vectalg::addObjects	(	const Matrix< MpInt, 0, 0 > &	v1,
		const Matrix< MpInt, 0, 0 > &	v2,
		Matrix< MpInt, 0, 0 > &	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, 0 > &	,
		const ColumnVector< capd::DInterval, 0 > &	,
		Vector< capd::DInterval, 0 > &
	)

◆ addObjects() [9/14]

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

◆ addObjects() [10/14]

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

◆ addObjects() [11/14]

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

◆ addObjects() [12/14]

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

◆ addObjects() [13/14]

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

◆ addObjects() [14/14]

template void capd::vectalg::addObjects	(	const Vector< MpInt, 0 > &	v1,
		const Vector< MpInt, 0 > &	v2,
		Vector< MpInt, 0 > &	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, 0 > capd::vectalg::addObjectScalar	(	Vector< capd::DInterval, 0 > 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, 0 >& capd::vectalg::assignObjectObject	(	ColumnVector< capd::DInterval, 0 > &	,
		ColumnVector< capd::DInterval, 0 > const &
	)

◆ assignObjectObject() [2/13]

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

◆ assignObjectObject() [3/13]

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

◆ assignObjectObject() [4/13]

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

◆ assignObjectObject() [5/13]

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

◆ assignObjectObject() [6/13]

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

◆ assignObjectObject() [7/13]

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

◆ assignObjectObject() [8/13]

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

◆ assignObjectObject() [9/13]

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

◆ assignObjectObject() [10/13]

template RowVector<long double, 0 >& capd::vectalg::assignObjectObject	(	RowVector< long double, 0 > &	,
		RowVector< long double, 0 > 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, 0 >& capd::vectalg::assignObjectObject	(	Vector< capd::DInterval, 0 > &	,
		Vector< double, 0 > const &
	)

◆ assignObjectObject() [13/13]

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

◆ clear() [1/4]

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

◆ clear() [2/4]

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

◆ clear() [3/4]

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

◆ 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, 0, 0 > const &	,
		std::string const &	,
		std::string const &
	)

◆ cppReprezentation() [4/8]

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

◆ cppReprezentation() [5/8]

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

◆ cppReprezentation() [6/8]

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

◆ cppReprezentation() [7/8]

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

◆ cppReprezentation() [8/8]

template std::string capd::vectalg::cppReprezentation	(	Vector< long double, 0 > 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, 0 >& capd::vectalg::divideAssignObjectScalar	(	ColumnVector< capd::DInterval, 0 > &	,
		capd::DInterval const &
	)

◆ divideAssignObjectScalar() [2/7]

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

◆ divideAssignObjectScalar() [3/7]

template ColumnVector<long double, 0 >& capd::vectalg::divideAssignObjectScalar	(	ColumnVector< long double, 0 > &	,
		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, 0 >& capd::vectalg::divideAssignObjectScalar	(	RowVector< capd::DInterval, 0 > &	,
		capd::DInterval const &
	)

◆ divideAssignObjectScalar() [6/7]

template RowVector<double, 0 >& capd::vectalg::divideAssignObjectScalar	(	RowVector< double, 0 > &	,
		double const &
	)

◆ divideAssignObjectScalar() [7/7]

template RowVector<long double, 0 >& capd::vectalg::divideAssignObjectScalar	(	RowVector< long double, 0 > &	,
		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, 0 , 0 > capd::vectalg::divideObjectScalar	(	Matrix< capd::DInterval, 0, 0 > const &	,
		capd::DInterval const &
	)

◆ divideObjectScalar< Vector< double, 0 >, Vector< double, 0 >, long >()

template Vector<double, 0 > capd::vectalg::divideObjectScalar< Vector< double, 0 >, Vector< double, 0 >, long >	(	Vector< double, 0 > const &	,
		long const &
	)

◆ divideObjectScalar< Vector< long double, 0 >, Vector< long double, 0 >, long >()

template Vector<long double, 0 > capd::vectalg::divideObjectScalar< Vector< long double, 0 >, Vector< long double, 0 >, long >	(	Vector< long double, 0 > const &	,
		long const &
	)

◆ equal() [1/3]

template bool capd::vectalg::equal	(	capd::vectalg::Matrix< capd::DInterval, 0, 0 > const &	,
		capd::vectalg::Matrix< capd::DInterval, 0, 0 > 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, 0 > const &	,
		Vector< capd::DInterval, 0 > 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, 0, 0 > &	,
		const Matrix< capd::DInterval, 0, 0 > &	,
		Matrix< capd::DInterval, 0, 0 > &
	)

◆ matrixByMatrix() [4/8]

template void capd::vectalg::matrixByMatrix	(	const Matrix< double, 0, 0 > &	,
		const Matrix< double, 0, 0 > &	,
		Matrix< double, 0, 0 > &
	)

◆ matrixByMatrix() [5/8]

template void capd::vectalg::matrixByMatrix	(	const Matrix< int, 0, 0 > &	,
		const Matrix< int, 0, 0 > &	,
		Matrix< int, 0, 0 > &
	)

◆ matrixByMatrix() [6/8]

template void capd::vectalg::matrixByMatrix	(	const Matrix< long double, 0, 0 > &	,
		const Matrix< long double, 0, 0 > &	,
		Matrix< long double, 0, 0 > &
	)

◆ matrixByMatrix() [7/8]

template void capd::vectalg::matrixByMatrix	(	const Matrix< MpFloat, 0, 0 > &	,
		const Matrix< MpFloat, 0, 0 > &	,
		Matrix< MpFloat, 0, 0 > &
	)

◆ matrixByMatrix() [8/8]

template void capd::vectalg::matrixByMatrix	(	const Matrix< MpInt, 0, 0 > &	,
		const Matrix< MpInt, 0, 0 > &	,
		Matrix< MpInt, 0, 0 > &
	)

◆ matrixByVector() [1/11]

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

◆ matrixByVector() [2/11]

template void capd::vectalg::matrixByVector	(	const Matrix< double, 0, 0 > &	,
		const ColumnVector< double, 0 > &	,
		Vector< double, 0 > &
	)

◆ matrixByVector() [3/11]

template void capd::vectalg::matrixByVector	(	const Matrix< double, 0, 0 > &	,
		const Vector< double, 0 > &	,
		Vector< double, 0 > &
	)

◆ matrixByVector() [4/11]

template void capd::vectalg::matrixByVector	(	const Matrix< int, 0, 0 > &	,
		const ColumnVector< int, 0 > &	,
		Vector< int, 0 > &
	)

◆ matrixByVector() [5/11]

template void capd::vectalg::matrixByVector	(	const Matrix< int, 0, 0 > &	,
		const Vector< int, 0 > &	,
		Vector< int, 0 > &
	)

◆ matrixByVector() [6/11]

template void capd::vectalg::matrixByVector	(	const Matrix< long double, 0, 0 > &	,
		const ColumnVector< long double, 0 > &	,
		Vector< long double, 0 > &
	)

◆ matrixByVector() [7/11]

template void capd::vectalg::matrixByVector	(	const Matrix< long double, 0, 0 > &	,
		const Vector< long double, 0 > &	,
		Vector< long double, 0 > &
	)

◆ matrixByVector() [8/11]

template void capd::vectalg::matrixByVector	(	const Matrix< MpFloat, 0, 0 > &	,
		const Vector< MpFloat, 0 > &	,
		Vector< MpFloat, 0 > &
	)

◆ matrixByVector() [9/11]

template void capd::vectalg::matrixByVector	(	const Matrix< MpInt, 0, 0 > &	,
		const Vector< MpInt, 0 > &	,
		Vector< MpInt, 0 > &
	)

◆ 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, 0 , 0 >& capd::vectalg::multiplyAssignObjectScalarAddObject	(	Matrix< capd::DInterval, 0, 0 > &	,
		capd::DInterval const &	,
		Matrix< capd::DInterval, 0, 0 > const &
	)

◆ multiplyAssignObjectScalarAddObject() [3/7]

template Matrix<double, 0 , 0 >& capd::vectalg::multiplyAssignObjectScalarAddObject	(	Matrix< double, 0, 0 > &	,
		double const &	,
		Matrix< double, 0, 0 > const &
	)

◆ multiplyAssignObjectScalarAddObject() [4/7]

template Matrix<long double, 0 , 0 >& capd::vectalg::multiplyAssignObjectScalarAddObject	(	Matrix< long double, 0, 0 > &	,
		long double const &	,
		Matrix< long double, 0, 0 > 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, 0 >& capd::vectalg::multiplyAssignObjectScalarAddObject	(	Vector< double, 0 > &	,
		double const &	,
		Vector< double, 0 > const &
	)

◆ multiplyAssignObjectScalarAddObject() [7/7]

template Vector<long double, 0 >& capd::vectalg::multiplyAssignObjectScalarAddObject	(	Vector< long double, 0 > &	,
		long double const &	,
		Vector< long double, 0 > const &
	)

◆ multiplyObjectScalar() [1/15]

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

◆ multiplyObjectScalar() [2/15]

template Vector<double, 0 > capd::vectalg::multiplyObjectScalar	(	ColumnVector< double, 0 > const &	,
		double const &
	)

◆ multiplyObjectScalar() [3/15]

template Vector<long double, 0 > capd::vectalg::multiplyObjectScalar	(	ColumnVector< long double, 0 > 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, 0 > const &	,
		capd::DInterval const &
	)

◆ multiplyObjectScalar() [10/15]

template Vector<double, 0 > capd::vectalg::multiplyObjectScalar	(	RowVector< double, 0 > const &	,
		double const &
	)

◆ multiplyObjectScalar() [11/15]

template Vector<long double, 0 > capd::vectalg::multiplyObjectScalar	(	RowVector< long double, 0 > const &	,
		long double const &
	)

◆ multiplyObjectScalar() [12/15]

template Vector<double, 0 > capd::vectalg::multiplyObjectScalar	(	Vector< double, 0 > const &	,
		double const &
	)

◆ multiplyObjectScalar() [13/15]

template Vector<double, 0 > capd::vectalg::multiplyObjectScalar	(	Vector< double, 0 > const &	,
		long const &
	)

◆ multiplyObjectScalar() [14/15]

template Vector<long double, 0 > capd::vectalg::multiplyObjectScalar	(	Vector< long double, 0 > const &	,
		long const &
	)

◆ multiplyObjectScalar() [15/15]

template Vector<long double, 0 > capd::vectalg::multiplyObjectScalar	(	Vector< long double, 0 > const &	,
		long double const &
	)

◆ normalize() [1/2]

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

◆ 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, 0 >() [1/11]

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

◆ operator*<capd::DInterval, 0 >() [2/11]

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

◆ operator*<capd::DInterval, 0 >() [3/11]

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

◆ operator*<capd::DInterval, 0 >() [4/11]

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

◆ operator*<capd::DInterval, 0 >() [5/11]

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

◆ operator*<capd::DInterval, 0 >() [6/11]

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

◆ operator*<capd::DInterval, 0 >() [7/11]

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

◆ operator*<capd::DInterval, 0 >() [8/11]

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

◆ operator*<capd::DInterval, 0 >() [9/11]

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

◆ operator*<capd::DInterval, 0 >() [10/11]

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

◆ operator*<capd::DInterval, 0 >() [11/11]

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

◆ operator*<capd::DInterval, 0, 0 >() [1/6]

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

◆ operator*<capd::DInterval, 0, 0 >() [2/6]

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

◆ operator*<capd::DInterval, 0, 0 >() [3/6]

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

◆ operator*<capd::DInterval, 0, 0 >() [4/6]

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

◆ operator*<capd::DInterval, 0, 0 >() [5/6]

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

◆ operator*<capd::DInterval, 0, 0 >() [6/6]

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

◆ operator*<capd::DInterval, capd::DInterval, 0 >() [1/2]

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

◆ operator*<capd::DInterval, capd::DInterval, 0 >() [2/2]

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

◆ operator*<capd::DInterval, double, 0 >() [1/2]

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

◆ operator*<capd::DInterval, double, 0 >() [2/2]

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

◆ operator*<capd::DInterval, int, 0 >() [1/2]

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

◆ operator*<capd::DInterval, int, 0 >() [2/2]

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

◆ operator*<capd::DInterval, long, 0 >() [1/2]

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

◆ operator*<capd::DInterval, long, 0 >() [2/2]

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

◆ operator*<double, 0 >() [1/11]

template double capd::vectalg::operator*<double, 0 >	(	const ColumnVector< double, 0 > &	,
		const ColumnVector< double, 0 > &
	)

◆ operator*<double, 0 >() [2/11]

template Vector<double, 0 > capd::vectalg::operator*<double, 0 >	(	const ColumnVector< double, 0 > &	,
		const double &
	)

◆ operator*<double, 0 >() [3/11]

template double capd::vectalg::operator*<double, 0 >	(	const ColumnVector< double, 0 > &	,
		const Vector< double, 0 > &
	)

◆ operator*<double, 0 >() [4/11]

template Vector<double, 0 > capd::vectalg::operator*<double, 0 >	(	const double &	,
		const ColumnVector< double, 0 > &
	)

◆ operator*<double, 0 >() [5/11]

template Vector<double, 0 > capd::vectalg::operator*<double, 0 >	(	const double &	,
		const RowVector< double, 0 > &
	)

◆ operator*<double, 0 >() [6/11]

template Vector<double, 0 > capd::vectalg::operator*<double, 0 >	(	const RowVector< double, 0 > &	,
		const double &
	)

◆ operator*<double, 0 >() [7/11]

template double capd::vectalg::operator*<double, 0 >	(	const RowVector< double, 0 > &	,
		const RowVector< double, 0 > &
	)

◆ operator*<double, 0 >() [8/11]

template double capd::vectalg::operator*<double, 0 >	(	const RowVector< double, 0 > &	,
		const Vector< double, 0 > &
	)

◆ operator*<double, 0 >() [9/11]

template double capd::vectalg::operator*<double, 0 >	(	const Vector< double, 0 > &	,
		const ColumnVector< double, 0 > &
	)

◆ operator*<double, 0 >() [10/11]

template double capd::vectalg::operator*<double, 0 >	(	const Vector< double, 0 > &	,
		const RowVector< double, 0 > &
	)

◆ operator*<double, 0 >() [11/11]

template double capd::vectalg::operator*<double, 0 >	(	const Vector< double, 0 > &	v1,
		const Vector< double, 0 > &	v2
	)

◆ operator*<double, 0, 0 >() [1/6]

template Matrix<double, 0 , 0 > capd::vectalg::operator*<double, 0, 0 >	(	const double &	,
		const Matrix< double, 0, 0 > &
	)

◆ operator*<double, 0, 0 >() [2/6]

template Vector<double, 0 > capd::vectalg::operator*<double, 0, 0 >	(	const Matrix< double, 0, 0 > &	,
		const ColumnVector< double, 0 > &
	)

◆ operator*<double, 0, 0 >() [3/6]

template Matrix<double, 0 , 0 > capd::vectalg::operator*<double, 0, 0 >	(	const Matrix< double, 0, 0 > &	,
		const double &
	)

◆ operator*<double, 0, 0 >() [4/6]

template Matrix<double, 0 , 0 > capd::vectalg::operator*<double, 0, 0 >	(	const Matrix< double, 0, 0 > &	,
		const Matrix< double, 0, 0 > &
	)

◆ operator*<double, 0, 0 >() [5/6]

template Vector<double, 0 > capd::vectalg::operator*<double, 0, 0 >	(	const Matrix< double, 0, 0 > &	,
		const RowVector< double, 0 > &
	)

◆ operator*<double, 0, 0 >() [6/6]

template Vector<double, 0 > capd::vectalg::operator*<double, 0, 0 >	(	const Matrix< double, 0, 0 > &	,
		const Vector< double, 0 > &
	)

◆ operator*<double, double, 0 >() [1/2]

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

◆ operator*<double, double, 0 >() [2/2]

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

◆ operator*<double, int, 0 >() [1/2]

template Vector<double, 0 > capd::vectalg::operator*<double, int, 0 >	(	const int &	s,
		const Vector< double, 0 > &	v
	)

◆ operator*<double, int, 0 >() [2/2]

template Vector<double, 0 > capd::vectalg::operator*<double, int, 0 >	(	const Vector< double, 0 > &	v,
		const int &	s
	)

◆ operator*<double, long, 0 >() [1/2]

template Vector<double, 0 > capd::vectalg::operator*<double, long, 0 >	(	const long &	s,
		const Vector< double, 0 > &	v
	)

◆ operator*<double, long, 0 >() [2/2]

template Vector<double, 0 > capd::vectalg::operator*<double, long, 0 >	(	const Vector< double, 0 > &	v,
		const long &	s
	)

◆ operator*<int, 0 >()

template int capd::vectalg::operator*<int, 0 >	(	const Vector< int, 0 > &	v1,
		const Vector< int, 0 > &	v2
	)

◆ operator*<int, int, 0 >() [1/2]

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

◆ operator*<int, int, 0 >() [2/2]

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

◆ operator*<int, long, 0 >() [1/2]

template Vector<int, 0 > capd::vectalg::operator*<int, long, 0 >	(	const long &	s,
		const Vector< int, 0 > &	v
	)

◆ operator*<int, long, 0 >() [2/2]

template Vector<int, 0 > capd::vectalg::operator*<int, long, 0 >	(	const Vector< int, 0 > &	v,
		const long &	s
	)

◆ operator*<long double, 0 >() [1/11]

template long double capd::vectalg::operator*<long double, 0 >	(	const ColumnVector< long double, 0 > &	,
		const ColumnVector< long double, 0 > &
	)

◆ operator*<long double, 0 >() [2/11]

template Vector<long double, 0 > capd::vectalg::operator*<long double, 0 >	(	const ColumnVector< long double, 0 > &	,
		const long double &
	)

◆ operator*<long double, 0 >() [3/11]

template long double capd::vectalg::operator*<long double, 0 >	(	const ColumnVector< long double, 0 > &	,
		const Vector< long double, 0 > &
	)

◆ operator*<long double, 0 >() [4/11]

template Vector<long double, 0 > capd::vectalg::operator*<long double, 0 >	(	const long double &	,
		const ColumnVector< long double, 0 > &
	)

◆ operator*<long double, 0 >() [5/11]

template Vector<long double, 0 > capd::vectalg::operator*<long double, 0 >	(	const long double &	,
		const RowVector< long double, 0 > &
	)

◆ operator*<long double, 0 >() [6/11]

template Vector<long double, 0 > capd::vectalg::operator*<long double, 0 >	(	const RowVector< long double, 0 > &	,
		const long double &
	)

◆ operator*<long double, 0 >() [7/11]

template long double capd::vectalg::operator*<long double, 0 >	(	const RowVector< long double, 0 > &	,
		const RowVector< long double, 0 > &
	)

◆ operator*<long double, 0 >() [8/11]

template long double capd::vectalg::operator*<long double, 0 >	(	const RowVector< long double, 0 > &	,
		const Vector< long double, 0 > &
	)

◆ operator*<long double, 0 >() [9/11]

template long double capd::vectalg::operator*<long double, 0 >	(	const Vector< long double, 0 > &	,
		const ColumnVector< long double, 0 > &
	)

◆ operator*<long double, 0 >() [10/11]

template long double capd::vectalg::operator*<long double, 0 >	(	const Vector< long double, 0 > &	,
		const RowVector< long double, 0 > &
	)

◆ operator*<long double, 0 >() [11/11]

template long double capd::vectalg::operator*<long double, 0 >	(	const Vector< long double, 0 > &	v1,
		const Vector< long double, 0 > &	v2
	)

◆ operator*<long double, 0, 0 >() [1/6]

template Matrix<long double, 0 , 0 > capd::vectalg::operator*<long double, 0, 0 >	(	const long double &	,
		const Matrix< long double, 0, 0 > &
	)

◆ operator*<long double, 0, 0 >() [2/6]

template Vector<long double, 0 > capd::vectalg::operator*<long double, 0, 0 >	(	const Matrix< long double, 0, 0 > &	,
		const ColumnVector< long double, 0 > &
	)

◆ operator*<long double, 0, 0 >() [3/6]

template Matrix<long double, 0 , 0 > capd::vectalg::operator*<long double, 0, 0 >	(	const Matrix< long double, 0, 0 > &	,
		const long double &
	)

◆ operator*<long double, 0, 0 >() [4/6]

template Matrix<long double, 0 , 0 > capd::vectalg::operator*<long double, 0, 0 >	(	const Matrix< long double, 0, 0 > &	,
		const Matrix< long double, 0, 0 > &
	)

◆ operator*<long double, 0, 0 >() [5/6]

template Vector<long double, 0 > capd::vectalg::operator*<long double, 0, 0 >	(	const Matrix< long double, 0, 0 > &	,
		const RowVector< long double, 0 > &
	)

◆ operator*<long double, 0, 0 >() [6/6]

template Vector<long double, 0 > capd::vectalg::operator*<long double, 0, 0 >	(	const Matrix< long double, 0, 0 > &	,
		const Vector< long double, 0 > &
	)

◆ operator*<long double, int, 0 >() [1/2]

template Vector<long double, 0 > capd::vectalg::operator*<long double, int, 0 >	(	const int &	s,
		const Vector< long double, 0 > &	v
	)

◆ operator*<long double, int, 0 >() [2/2]

template Vector<long double, 0 > capd::vectalg::operator*<long double, int, 0 >	(	const Vector< long double, 0 > &	v,
		const int &	s
	)

◆ operator*<long double, long double, 0 >() [1/2]

template Vector<long double, 0 > capd::vectalg::operator*<long double, long double, 0 >	(	const long double &	s,
		const Vector< long double, 0 > &	v
	)

◆ operator*<long double, long double, 0 >() [2/2]

template Vector<long double, 0 > capd::vectalg::operator*<long double, long double, 0 >	(	const Vector< long double, 0 > &	v,
		const long double &	s
	)

◆ operator*<long double, long, 0 >() [1/2]

template Vector<long double, 0 > capd::vectalg::operator*<long double, long, 0 >	(	const long &	s,
		const Vector< long double, 0 > &	v
	)

◆ operator*<long double, long, 0 >() [2/2]

template Vector<long double, 0 > capd::vectalg::operator*<long double, long, 0 >	(	const Vector< long double, 0 > &	v,
		const long &	s
	)

◆ operator*<MpFloat, 0 >() [1/11]

template MpFloat capd::vectalg::operator*<MpFloat, 0 >	(	const ColumnVector< MpFloat, 0 > &	,
		const ColumnVector< MpFloat, 0 > &
	)

◆ operator*<MpFloat, 0 >() [2/11]

template Vector<MpFloat, 0 > capd::vectalg::operator*<MpFloat, 0 >	(	const ColumnVector< MpFloat, 0 > &	,
		const MpFloat &
	)

◆ operator*<MpFloat, 0 >() [3/11]

template MpFloat capd::vectalg::operator*<MpFloat, 0 >	(	const ColumnVector< MpFloat, 0 > &	,
		const Vector< MpFloat, 0 > &
	)

◆ operator*<MpFloat, 0 >() [4/11]

template Vector<MpFloat, 0 > capd::vectalg::operator*<MpFloat, 0 >	(	const MpFloat &	,
		const ColumnVector< MpFloat, 0 > &
	)

◆ operator*<MpFloat, 0 >() [5/11]

template Vector<MpFloat, 0 > capd::vectalg::operator*<MpFloat, 0 >	(	const MpFloat &	,
		const RowVector< MpFloat, 0 > &
	)

◆ operator*<MpFloat, 0 >() [6/11]

template Vector<MpFloat, 0 > capd::vectalg::operator*<MpFloat, 0 >	(	const RowVector< MpFloat, 0 > &	,
		const MpFloat &
	)

◆ operator*<MpFloat, 0 >() [7/11]

template MpFloat capd::vectalg::operator*<MpFloat, 0 >	(	const RowVector< MpFloat, 0 > &	,
		const RowVector< MpFloat, 0 > &
	)

◆ operator*<MpFloat, 0 >() [8/11]

template MpFloat capd::vectalg::operator*<MpFloat, 0 >	(	const RowVector< MpFloat, 0 > &	,
		const Vector< MpFloat, 0 > &
	)

◆ operator*<MpFloat, 0 >() [9/11]

template MpFloat capd::vectalg::operator*<MpFloat, 0 >	(	const Vector< MpFloat, 0 > &	,
		const ColumnVector< MpFloat, 0 > &
	)

◆ operator*<MpFloat, 0 >() [10/11]

template MpFloat capd::vectalg::operator*<MpFloat, 0 >	(	const Vector< MpFloat, 0 > &	,
		const RowVector< MpFloat, 0 > &
	)

◆ operator*<MpFloat, 0 >() [11/11]

template MpFloat capd::vectalg::operator*<MpFloat, 0 >	(	const Vector< MpFloat, 0 > &	v1,
		const Vector< MpFloat, 0 > &	v2
	)

◆ operator*<MpFloat, 0, 0 >() [1/6]

template Vector<MpFloat, 0 > capd::vectalg::operator*<MpFloat, 0, 0 >	(	const Matrix< MpFloat, 0, 0 > &	,
		const ColumnVector< MpFloat, 0 > &
	)

◆ operator*<MpFloat, 0, 0 >() [2/6]

template Matrix<MpFloat, 0 , 0 > capd::vectalg::operator*<MpFloat, 0, 0 >	(	const Matrix< MpFloat, 0, 0 > &	,
		const Matrix< MpFloat, 0, 0 > &
	)

◆ operator*<MpFloat, 0, 0 >() [3/6]

template Matrix<MpFloat, 0 , 0 > capd::vectalg::operator*<MpFloat, 0, 0 >	(	const Matrix< MpFloat, 0, 0 > &	,
		const MpFloat &
	)

◆ operator*<MpFloat, 0, 0 >() [4/6]

template Vector<MpFloat, 0 > capd::vectalg::operator*<MpFloat, 0, 0 >	(	const Matrix< MpFloat, 0, 0 > &	,
		const RowVector< MpFloat, 0 > &
	)

◆ operator*<MpFloat, 0, 0 >() [5/6]

template Vector<MpFloat, 0 > capd::vectalg::operator*<MpFloat, 0, 0 >	(	const Matrix< MpFloat, 0, 0 > &	,
		const Vector< MpFloat, 0 > &
	)

◆ operator*<MpFloat, 0, 0 >() [6/6]

template Matrix<MpFloat, 0 , 0 > capd::vectalg::operator*<MpFloat, 0, 0 >	(	const MpFloat &	,
		const Matrix< MpFloat, 0, 0 > &
	)

◆ operator*<MpFloat, int, 0 >() [1/2]

template Vector<MpFloat, 0 > capd::vectalg::operator*<MpFloat, int, 0 >	(	const int &	s,
		const Vector< MpFloat, 0 > &	v
	)

◆ operator*<MpFloat, int, 0 >() [2/2]

template Vector<MpFloat, 0 > capd::vectalg::operator*<MpFloat, int, 0 >	(	const Vector< MpFloat, 0 > &	v,
		const int &	s
	)

◆ operator*<MpFloat, long, 0 >() [1/2]

template Vector<MpFloat, 0 > capd::vectalg::operator*<MpFloat, long, 0 >	(	const long &	s,
		const Vector< MpFloat, 0 > &	v
	)

◆ operator*<MpFloat, long, 0 >() [2/2]

template Vector<MpFloat, 0 > capd::vectalg::operator*<MpFloat, long, 0 >	(	const Vector< MpFloat, 0 > &	v,
		const long &	s
	)

◆ operator*<MpFloat, MpFloat, 0 >() [1/2]

template Vector<MpFloat, 0 > capd::vectalg::operator*<MpFloat, MpFloat, 0 >	(	const MpFloat &	s,
		const Vector< MpFloat, 0 > &	v
	)

◆ operator*<MpFloat, MpFloat, 0 >() [2/2]

template Vector<MpFloat, 0 > capd::vectalg::operator*<MpFloat, MpFloat, 0 >	(	const Vector< MpFloat, 0 > &	v,
		const MpFloat &	s
	)

◆ operator*<MpInt, 0 >() [1/11]

template MpInt capd::vectalg::operator*<MpInt, 0 >	(	const ColumnVector< MpInt, 0 > &	,
		const ColumnVector< MpInt, 0 > &
	)

◆ operator*<MpInt, 0 >() [2/11]

template Vector<MpInt, 0 > capd::vectalg::operator*<MpInt, 0 >	(	const ColumnVector< MpInt, 0 > &	,
		const MpInt &
	)

◆ operator*<MpInt, 0 >() [3/11]

template MpInt capd::vectalg::operator*<MpInt, 0 >	(	const ColumnVector< MpInt, 0 > &	,
		const Vector< MpInt, 0 > &
	)

◆ operator*<MpInt, 0 >() [4/11]

template Vector<MpInt, 0 > capd::vectalg::operator*<MpInt, 0 >	(	const MpInt &	,
		const ColumnVector< MpInt, 0 > &
	)

◆ operator*<MpInt, 0 >() [5/11]

template Vector<MpInt, 0 > capd::vectalg::operator*<MpInt, 0 >	(	const MpInt &	,
		const RowVector< MpInt, 0 > &
	)

◆ operator*<MpInt, 0 >() [6/11]

template Vector<MpInt, 0 > capd::vectalg::operator*<MpInt, 0 >	(	const RowVector< MpInt, 0 > &	,
		const MpInt &
	)

◆ operator*<MpInt, 0 >() [7/11]

template MpInt capd::vectalg::operator*<MpInt, 0 >	(	const RowVector< MpInt, 0 > &	,
		const RowVector< MpInt, 0 > &
	)

◆ operator*<MpInt, 0 >() [8/11]

template MpInt capd::vectalg::operator*<MpInt, 0 >	(	const RowVector< MpInt, 0 > &	,
		const Vector< MpInt, 0 > &
	)

◆ operator*<MpInt, 0 >() [9/11]

template MpInt capd::vectalg::operator*<MpInt, 0 >	(	const Vector< MpInt, 0 > &	,
		const ColumnVector< MpInt, 0 > &
	)

◆ operator*<MpInt, 0 >() [10/11]

template MpInt capd::vectalg::operator*<MpInt, 0 >	(	const Vector< MpInt, 0 > &	,
		const RowVector< MpInt, 0 > &
	)

◆ operator*<MpInt, 0 >() [11/11]

template MpInt capd::vectalg::operator*<MpInt, 0 >	(	const Vector< MpInt, 0 > &	v1,
		const Vector< MpInt, 0 > &	v2
	)

◆ operator*<MpInt, 0, 0 >() [1/6]

template Vector<MpInt, 0 > capd::vectalg::operator*<MpInt, 0, 0 >	(	const Matrix< MpInt, 0, 0 > &	,
		const ColumnVector< MpInt, 0 > &
	)

◆ operator*<MpInt, 0, 0 >() [2/6]

template Matrix<MpInt, 0 , 0 > capd::vectalg::operator*<MpInt, 0, 0 >	(	const Matrix< MpInt, 0, 0 > &	,
		const Matrix< MpInt, 0, 0 > &
	)

◆ operator*<MpInt, 0, 0 >() [3/6]

template Matrix<MpInt, 0 , 0 > capd::vectalg::operator*<MpInt, 0, 0 >	(	const Matrix< MpInt, 0, 0 > &	,
		const MpInt &
	)

◆ operator*<MpInt, 0, 0 >() [4/6]

template Vector<MpInt, 0 > capd::vectalg::operator*<MpInt, 0, 0 >	(	const Matrix< MpInt, 0, 0 > &	,
		const RowVector< MpInt, 0 > &
	)

◆ operator*<MpInt, 0, 0 >() [5/6]

template Vector<MpInt, 0 > capd::vectalg::operator*<MpInt, 0, 0 >	(	const Matrix< MpInt, 0, 0 > &	,
		const Vector< MpInt, 0 > &
	)

◆ operator*<MpInt, 0, 0 >() [6/6]

template Matrix<MpInt, 0 , 0 > capd::vectalg::operator*<MpInt, 0, 0 >	(	const MpInt &	,
		const Matrix< MpInt, 0, 0 > &
	)

◆ operator*<MpInt, int, 0 >() [1/2]

template Vector<MpInt, 0 > capd::vectalg::operator*<MpInt, int, 0 >	(	const int &	s,
		const Vector< MpInt, 0 > &	v
	)

◆ operator*<MpInt, int, 0 >() [2/2]

template Vector<MpInt, 0 > capd::vectalg::operator*<MpInt, int, 0 >	(	const Vector< MpInt, 0 > &	v,
		const int &	s
	)

◆ operator*<MpInt, long, 0 >() [1/2]

template Vector<MpInt, 0 > capd::vectalg::operator*<MpInt, long, 0 >	(	const long &	s,
		const Vector< MpInt, 0 > &	v
	)

◆ operator*<MpInt, long, 0 >() [2/2]

template Vector<MpInt, 0 > capd::vectalg::operator*<MpInt, long, 0 >	(	const Vector< MpInt, 0 > &	v,
		const long &	s
	)

◆ operator*<MpInt, MpInt, 0 >() [1/2]

template Vector<MpInt, 0 > capd::vectalg::operator*<MpInt, MpInt, 0 >	(	const MpInt &	s,
		const Vector< MpInt, 0 > &	v
	)

◆ operator*<MpInt, MpInt, 0 >() [2/2]

template Vector<MpInt, 0 > capd::vectalg::operator*<MpInt, MpInt, 0 >	(	const Vector< MpInt, 0 > &	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, 0 >() [1/8]

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

◆ operator+<capd::DInterval, 0 >() [2/8]

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

◆ operator+<capd::DInterval, 0 >() [3/8]

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

◆ operator+<capd::DInterval, 0 >() [4/8]

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

◆ operator+<capd::DInterval, 0 >() [5/8]

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

◆ operator+<capd::DInterval, 0 >() [6/8]

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

◆ operator+<capd::DInterval, 0 >() [7/8]

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

◆ operator+<capd::DInterval, 0 >() [8/8]

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

◆ operator+<capd::DInterval, 0, 0 >() [1/2]

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

◆ operator+<capd::DInterval, 0, 0 >() [2/2]

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

◆ operator+<double, 0 >() [1/8]

template Vector<double, 0 > capd::vectalg::operator+<double, 0 >	(	const ColumnVector< double, 0 > &	,
		const ColumnVector< double, 0 > &
	)

◆ operator+<double, 0 >() [2/8]

template Vector<double, 0 > capd::vectalg::operator+<double, 0 >	(	const ColumnVector< double, 0 > &	,
		const Vector< double, 0 > &
	)

◆ operator+<double, 0 >() [3/8]

template Vector<double, 0 > capd::vectalg::operator+<double, 0 >	(	const RowVector< double, 0 > &	,
		const RowVector< double, 0 > &
	)

◆ operator+<double, 0 >() [4/8]

template Vector<double, 0 > capd::vectalg::operator+<double, 0 >	(	const RowVector< double, 0 > &	,
		const Vector< double, 0 > &
	)

◆ operator+<double, 0 >() [5/8]

template Vector<double, 0 > capd::vectalg::operator+<double, 0 >	(	const Vector< double, 0 > &	,
		const ColumnVector< double, 0 > &
	)

◆ operator+<double, 0 >() [6/8]

template Vector<double, 0 > capd::vectalg::operator+<double, 0 >	(	const Vector< double, 0 > &	,
		const RowVector< double, 0 > &
	)

◆ operator+<double, 0 >() [7/8]

template Vector<double, 0 > capd::vectalg::operator+<double, 0 >	(	const Vector< double, 0 > &	v,
		const double &	s
	)

◆ operator+<double, 0 >() [8/8]

template Vector<double, 0 > capd::vectalg::operator+<double, 0 >	(	const Vector< double, 0 > &	v1,
		const Vector< double, 0 > &	v2
	)

◆ operator+<double, 0, 0 >() [1/2]

template Matrix<double, 0 , 0 > capd::vectalg::operator+<double, 0, 0 >	(	const Matrix< double, 0, 0 > &	,
		const double &
	)

◆ operator+<double, 0, 0 >() [2/2]

template Matrix<double, 0 , 0 > capd::vectalg::operator+<double, 0, 0 >	(	const Matrix< double, 0, 0 > &	,
		const Matrix< double, 0, 0 > &
	)

◆ operator+<int, 0 >() [1/2]

template Vector<int, 0 > capd::vectalg::operator+<int, 0 >	(	const Vector< int, 0 > &	v,
		const int &	s
	)

◆ operator+<int, 0 >() [2/2]

template Vector<int, 0 > capd::vectalg::operator+<int, 0 >	(	const Vector< int, 0 > &	v1,
		const Vector< int, 0 > &	v2
	)

◆ operator+<long double, 0 >() [1/8]

template Vector<long double, 0 > capd::vectalg::operator+<long double, 0 >	(	const ColumnVector< long double, 0 > &	,
		const ColumnVector< long double, 0 > &
	)

◆ operator+<long double, 0 >() [2/8]

template Vector<long double, 0 > capd::vectalg::operator+<long double, 0 >	(	const ColumnVector< long double, 0 > &	,
		const Vector< long double, 0 > &
	)

◆ operator+<long double, 0 >() [3/8]

template Vector<long double, 0 > capd::vectalg::operator+<long double, 0 >	(	const RowVector< long double, 0 > &	,
		const RowVector< long double, 0 > &
	)

◆ operator+<long double, 0 >() [4/8]

template Vector<long double, 0 > capd::vectalg::operator+<long double, 0 >	(	const RowVector< long double, 0 > &	,
		const Vector< long double, 0 > &
	)

◆ operator+<long double, 0 >() [5/8]

template Vector<long double, 0 > capd::vectalg::operator+<long double, 0 >	(	const Vector< long double, 0 > &	,
		const ColumnVector< long double, 0 > &
	)

◆ operator+<long double, 0 >() [6/8]

template Vector<long double, 0 > capd::vectalg::operator+<long double, 0 >	(	const Vector< long double, 0 > &	,
		const RowVector< long double, 0 > &
	)

◆ operator+<long double, 0 >() [7/8]

template Vector<long double, 0 > capd::vectalg::operator+<long double, 0 >	(	const Vector< long double, 0 > &	v,
		const long double &	s
	)

◆ operator+<long double, 0 >() [8/8]

template Vector<long double, 0 > capd::vectalg::operator+<long double, 0 >	(	const Vector< long double, 0 > &	v1,
		const Vector< long double, 0 > &	v2
	)

◆ operator+<long double, 0, 0 >() [1/2]

template Matrix<long double, 0 , 0 > capd::vectalg::operator+<long double, 0, 0 >	(	const Matrix< long double, 0, 0 > &	,
		const long double &
	)

◆ operator+<long double, 0, 0 >() [2/2]

template Matrix<long double, 0 , 0 > capd::vectalg::operator+<long double, 0, 0 >	(	const Matrix< long double, 0, 0 > &	,
		const Matrix< long double, 0, 0 > &
	)

◆ operator+<MpFloat, 0 >() [1/8]

template Vector<MpFloat, 0 > capd::vectalg::operator+<MpFloat, 0 >	(	const ColumnVector< MpFloat, 0 > &	,
		const ColumnVector< MpFloat, 0 > &
	)

◆ operator+<MpFloat, 0 >() [2/8]

template Vector<MpFloat, 0 > capd::vectalg::operator+<MpFloat, 0 >	(	const ColumnVector< MpFloat, 0 > &	,
		const Vector< MpFloat, 0 > &
	)

◆ operator+<MpFloat, 0 >() [3/8]

template Vector<MpFloat, 0 > capd::vectalg::operator+<MpFloat, 0 >	(	const RowVector< MpFloat, 0 > &	,
		const RowVector< MpFloat, 0 > &
	)

◆ operator+<MpFloat, 0 >() [4/8]

template Vector<MpFloat, 0 > capd::vectalg::operator+<MpFloat, 0 >	(	const RowVector< MpFloat, 0 > &	,
		const Vector< MpFloat, 0 > &
	)

◆ operator+<MpFloat, 0 >() [5/8]

template Vector<MpFloat, 0 > capd::vectalg::operator+<MpFloat, 0 >	(	const Vector< MpFloat, 0 > &	,
		const ColumnVector< MpFloat, 0 > &
	)

◆ operator+<MpFloat, 0 >() [6/8]

template Vector<MpFloat, 0 > capd::vectalg::operator+<MpFloat, 0 >	(	const Vector< MpFloat, 0 > &	,
		const RowVector< MpFloat, 0 > &
	)

◆ operator+<MpFloat, 0 >() [7/8]

template Vector<MpFloat, 0 > capd::vectalg::operator+<MpFloat, 0 >	(	const Vector< MpFloat, 0 > &	v,
		const MpFloat &	s
	)

◆ operator+<MpFloat, 0 >() [8/8]

template Vector<MpFloat, 0 > capd::vectalg::operator+<MpFloat, 0 >	(	const Vector< MpFloat, 0 > &	v1,
		const Vector< MpFloat, 0 > &	v2
	)

◆ operator+<MpFloat, 0, 0 >() [1/2]

template Matrix<MpFloat, 0 , 0 > capd::vectalg::operator+<MpFloat, 0, 0 >	(	const Matrix< MpFloat, 0, 0 > &	,
		const Matrix< MpFloat, 0, 0 > &
	)

◆ operator+<MpFloat, 0, 0 >() [2/2]

template Matrix<MpFloat, 0 , 0 > capd::vectalg::operator+<MpFloat, 0, 0 >	(	const Matrix< MpFloat, 0, 0 > &	,
		const MpFloat &
	)

◆ operator+<MpInt, 0 >() [1/8]

template Vector<MpInt, 0 > capd::vectalg::operator+<MpInt, 0 >	(	const ColumnVector< MpInt, 0 > &	,
		const ColumnVector< MpInt, 0 > &
	)

◆ operator+<MpInt, 0 >() [2/8]

template Vector<MpInt, 0 > capd::vectalg::operator+<MpInt, 0 >	(	const ColumnVector< MpInt, 0 > &	,
		const Vector< MpInt, 0 > &
	)

◆ operator+<MpInt, 0 >() [3/8]

template Vector<MpInt, 0 > capd::vectalg::operator+<MpInt, 0 >	(	const RowVector< MpInt, 0 > &	,
		const RowVector< MpInt, 0 > &
	)

◆ operator+<MpInt, 0 >() [4/8]

template Vector<MpInt, 0 > capd::vectalg::operator+<MpInt, 0 >	(	const RowVector< MpInt, 0 > &	,
		const Vector< MpInt, 0 > &
	)

◆ operator+<MpInt, 0 >() [5/8]

template Vector<MpInt, 0 > capd::vectalg::operator+<MpInt, 0 >	(	const Vector< MpInt, 0 > &	,
		const ColumnVector< MpInt, 0 > &
	)

◆ operator+<MpInt, 0 >() [6/8]

template Vector<MpInt, 0 > capd::vectalg::operator+<MpInt, 0 >	(	const Vector< MpInt, 0 > &	,
		const RowVector< MpInt, 0 > &
	)

◆ operator+<MpInt, 0 >() [7/8]

template Vector<MpInt, 0 > capd::vectalg::operator+<MpInt, 0 >	(	const Vector< MpInt, 0 > &	v,
		const MpInt &	s
	)

◆ operator+<MpInt, 0 >() [8/8]

template Vector<MpInt, 0 > capd::vectalg::operator+<MpInt, 0 >	(	const Vector< MpInt, 0 > &	v1,
		const Vector< MpInt, 0 > &	v2
	)

◆ operator+<MpInt, 0, 0 >() [1/2]

template Matrix<MpInt, 0 , 0 > capd::vectalg::operator+<MpInt, 0, 0 >	(	const Matrix< MpInt, 0, 0 > &	,
		const Matrix< MpInt, 0, 0 > &
	)

◆ operator+<MpInt, 0, 0 >() [2/2]

template Matrix<MpInt, 0 , 0 > capd::vectalg::operator+<MpInt, 0, 0 >	(	const Matrix< MpInt, 0, 0 > &	,
		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, 0 >() [1/11]

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

◆ operator-<capd::DInterval, 0 >() [2/11]

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

◆ operator-<capd::DInterval, 0 >() [3/11]

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

◆ operator-<capd::DInterval, 0 >() [4/11]

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

◆ operator-<capd::DInterval, 0 >() [5/11]

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

◆ operator-<capd::DInterval, 0 >() [6/11]

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

◆ operator-<capd::DInterval, 0 >() [7/11]

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

◆ operator-<capd::DInterval, 0 >() [8/11]

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

◆ operator-<capd::DInterval, 0 >() [9/11]

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

◆ operator-<capd::DInterval, 0 >() [10/11]

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

◆ operator-<capd::DInterval, 0 >() [11/11]

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

◆ operator-<capd::DInterval, 0, 0 >() [1/3]

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

◆ operator-<capd::DInterval, 0, 0 >() [2/3]

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

◆ operator-<capd::DInterval, 0, 0 >() [3/3]

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

◆ operator-<double, 0 >() [1/11]

template Vector<double, 0 > capd::vectalg::operator-<double, 0 > ( const ColumnVector< double, 0 > & )

◆ operator-<double, 0 >() [2/11]

template Vector<double, 0 > capd::vectalg::operator-<double, 0 >	(	const ColumnVector< double, 0 > &	,
		const ColumnVector< double, 0 > &
	)

◆ operator-<double, 0 >() [3/11]

template Vector<double, 0 > capd::vectalg::operator-<double, 0 >	(	const ColumnVector< double, 0 > &	,
		const Vector< double, 0 > &
	)

◆ operator-<double, 0 >() [4/11]

template Vector<double, 0 > capd::vectalg::operator-<double, 0 > ( const RowVector< double, 0 > & )

◆ operator-<double, 0 >() [5/11]

template Vector<double, 0 > capd::vectalg::operator-<double, 0 >	(	const RowVector< double, 0 > &	,
		const RowVector< double, 0 > &
	)

◆ operator-<double, 0 >() [6/11]

template Vector<double, 0 > capd::vectalg::operator-<double, 0 >	(	const RowVector< double, 0 > &	,
		const Vector< double, 0 > &
	)

◆ operator-<double, 0 >() [7/11]

template Vector<double, 0 > capd::vectalg::operator-<double, 0 >	(	const Vector< double, 0 > &	,
		const ColumnVector< double, 0 > &
	)

◆ operator-<double, 0 >() [8/11]

template Vector<double, 0 > capd::vectalg::operator-<double, 0 >	(	const Vector< double, 0 > &	,
		const RowVector< double, 0 > &
	)

◆ operator-<double, 0 >() [9/11]

template Vector<double, 0 > capd::vectalg::operator-<double, 0 > ( const Vector< double, 0 > & v )

◆ operator-<double, 0 >() [10/11]

template Vector<double, 0 > capd::vectalg::operator-<double, 0 >	(	const Vector< double, 0 > &	v,
		const double &	s
	)

◆ operator-<double, 0 >() [11/11]

template Vector<double, 0 > capd::vectalg::operator-<double, 0 >	(	const Vector< double, 0 > &	v1,
		const Vector< double, 0 > &	v2
	)

◆ operator-<double, 0, 0 >() [1/3]

template Matrix<double, 0 , 0 > capd::vectalg::operator-<double, 0, 0 > ( const Matrix< double, 0, 0 > & )

◆ operator-<double, 0, 0 >() [2/3]

template Matrix<double, 0 , 0 > capd::vectalg::operator-<double, 0, 0 >	(	const Matrix< double, 0, 0 > &	,
		const double &
	)

◆ operator-<double, 0, 0 >() [3/3]

template Matrix<double, 0 , 0 > capd::vectalg::operator-<double, 0, 0 >	(	const Matrix< double, 0, 0 > &	,
		const Matrix< double, 0, 0 > &
	)

◆ operator-<int, 0 >() [1/3]

template Vector<int, 0 > capd::vectalg::operator-<int, 0 > ( const Vector< int, 0 > & v )

◆ operator-<int, 0 >() [2/3]

template Vector<int, 0 > capd::vectalg::operator-<int, 0 >	(	const Vector< int, 0 > &	v,
		const int &	s
	)

◆ operator-<int, 0 >() [3/3]

template Vector<int, 0 > capd::vectalg::operator-<int, 0 >	(	const Vector< int, 0 > &	v1,
		const Vector< int, 0 > &	v2
	)

◆ operator-<long double, 0 >() [1/11]

template Vector<long double, 0 > capd::vectalg::operator-<long double, 0 > ( const ColumnVector< long double, 0 > & )

◆ operator-<long double, 0 >() [2/11]

template Vector<long double, 0 > capd::vectalg::operator-<long double, 0 >	(	const ColumnVector< long double, 0 > &	,
		const ColumnVector< long double, 0 > &
	)

◆ operator-<long double, 0 >() [3/11]

template Vector<long double, 0 > capd::vectalg::operator-<long double, 0 >	(	const ColumnVector< long double, 0 > &	,
		const Vector< long double, 0 > &
	)

◆ operator-<long double, 0 >() [4/11]

template Vector<long double, 0 > capd::vectalg::operator-<long double, 0 > ( const RowVector< long double, 0 > & )

◆ operator-<long double, 0 >() [5/11]

template Vector<long double, 0 > capd::vectalg::operator-<long double, 0 >	(	const RowVector< long double, 0 > &	,
		const RowVector< long double, 0 > &
	)

◆ operator-<long double, 0 >() [6/11]

template Vector<long double, 0 > capd::vectalg::operator-<long double, 0 >	(	const RowVector< long double, 0 > &	,
		const Vector< long double, 0 > &
	)

◆ operator-<long double, 0 >() [7/11]

template Vector<long double, 0 > capd::vectalg::operator-<long double, 0 >	(	const Vector< long double, 0 > &	,
		const ColumnVector< long double, 0 > &
	)

◆ operator-<long double, 0 >() [8/11]

template Vector<long double, 0 > capd::vectalg::operator-<long double, 0 >	(	const Vector< long double, 0 > &	,
		const RowVector< long double, 0 > &
	)

◆ operator-<long double, 0 >() [9/11]

template Vector<long double, 0 > capd::vectalg::operator-<long double, 0 > ( const Vector< long double, 0 > & v )

◆ operator-<long double, 0 >() [10/11]

template Vector<long double, 0 > capd::vectalg::operator-<long double, 0 >	(	const Vector< long double, 0 > &	v,
		const long double &	s
	)

◆ operator-<long double, 0 >() [11/11]

template Vector<long double, 0 > capd::vectalg::operator-<long double, 0 >	(	const Vector< long double, 0 > &	v1,
		const Vector< long double, 0 > &	v2
	)

◆ operator-<long double, 0, 0 >() [1/3]

template Matrix<long double, 0 , 0 > capd::vectalg::operator-<long double, 0, 0 > ( const Matrix< long double, 0, 0 > & )

◆ operator-<long double, 0, 0 >() [2/3]

template Matrix<long double, 0 , 0 > capd::vectalg::operator-<long double, 0, 0 >	(	const Matrix< long double, 0, 0 > &	,
		const long double &
	)

◆ operator-<long double, 0, 0 >() [3/3]

template Matrix<long double, 0 , 0 > capd::vectalg::operator-<long double, 0, 0 >	(	const Matrix< long double, 0, 0 > &	,
		const Matrix< long double, 0, 0 > &
	)

◆ operator-<MpFloat, 0 >() [1/11]

template Vector<MpFloat, 0 > capd::vectalg::operator-<MpFloat, 0 > ( const ColumnVector< MpFloat, 0 > & )

◆ operator-<MpFloat, 0 >() [2/11]

template Vector<MpFloat, 0 > capd::vectalg::operator-<MpFloat, 0 >	(	const ColumnVector< MpFloat, 0 > &	,
		const ColumnVector< MpFloat, 0 > &
	)

◆ operator-<MpFloat, 0 >() [3/11]

template Vector<MpFloat, 0 > capd::vectalg::operator-<MpFloat, 0 >	(	const ColumnVector< MpFloat, 0 > &	,
		const Vector< MpFloat, 0 > &
	)

◆ operator-<MpFloat, 0 >() [4/11]

template Vector<MpFloat, 0 > capd::vectalg::operator-<MpFloat, 0 > ( const RowVector< MpFloat, 0 > & )

◆ operator-<MpFloat, 0 >() [5/11]

template Vector<MpFloat, 0 > capd::vectalg::operator-<MpFloat, 0 >	(	const RowVector< MpFloat, 0 > &	,
		const RowVector< MpFloat, 0 > &
	)

◆ operator-<MpFloat, 0 >() [6/11]

template Vector<MpFloat, 0 > capd::vectalg::operator-<MpFloat, 0 >	(	const RowVector< MpFloat, 0 > &	,
		const Vector< MpFloat, 0 > &
	)

◆ operator-<MpFloat, 0 >() [7/11]

template Vector<MpFloat, 0 > capd::vectalg::operator-<MpFloat, 0 >	(	const Vector< MpFloat, 0 > &	,
		const ColumnVector< MpFloat, 0 > &
	)

◆ operator-<MpFloat, 0 >() [8/11]

template Vector<MpFloat, 0 > capd::vectalg::operator-<MpFloat, 0 >	(	const Vector< MpFloat, 0 > &	,
		const RowVector< MpFloat, 0 > &
	)

◆ operator-<MpFloat, 0 >() [9/11]

template Vector<MpFloat, 0 > capd::vectalg::operator-<MpFloat, 0 > ( const Vector< MpFloat, 0 > & v )

◆ operator-<MpFloat, 0 >() [10/11]

template Vector<MpFloat, 0 > capd::vectalg::operator-<MpFloat, 0 >	(	const Vector< MpFloat, 0 > &	v,
		const MpFloat &	s
	)

◆ operator-<MpFloat, 0 >() [11/11]

template Vector<MpFloat, 0 > capd::vectalg::operator-<MpFloat, 0 >	(	const Vector< MpFloat, 0 > &	v1,
		const Vector< MpFloat, 0 > &	v2
	)

◆ operator-<MpFloat, 0, 0 >() [1/3]

template Matrix<MpFloat, 0 , 0 > capd::vectalg::operator-<MpFloat, 0, 0 > ( const Matrix< MpFloat, 0, 0 > & )

◆ operator-<MpFloat, 0, 0 >() [2/3]

template Matrix<MpFloat, 0 , 0 > capd::vectalg::operator-<MpFloat, 0, 0 >	(	const Matrix< MpFloat, 0, 0 > &	,
		const Matrix< MpFloat, 0, 0 > &
	)

◆ operator-<MpFloat, 0, 0 >() [3/3]

template Matrix<MpFloat, 0 , 0 > capd::vectalg::operator-<MpFloat, 0, 0 >	(	const Matrix< MpFloat, 0, 0 > &	,
		const MpFloat &
	)

◆ operator-<MpInt, 0 >() [1/11]

template Vector<MpInt, 0 > capd::vectalg::operator-<MpInt, 0 > ( const ColumnVector< MpInt, 0 > & )

◆ operator-<MpInt, 0 >() [2/11]

template Vector<MpInt, 0 > capd::vectalg::operator-<MpInt, 0 >	(	const ColumnVector< MpInt, 0 > &	,
		const ColumnVector< MpInt, 0 > &
	)

◆ operator-<MpInt, 0 >() [3/11]

template Vector<MpInt, 0 > capd::vectalg::operator-<MpInt, 0 >	(	const ColumnVector< MpInt, 0 > &	,
		const Vector< MpInt, 0 > &
	)

◆ operator-<MpInt, 0 >() [4/11]

template Vector<MpInt, 0 > capd::vectalg::operator-<MpInt, 0 > ( const RowVector< MpInt, 0 > & )

◆ operator-<MpInt, 0 >() [5/11]

template Vector<MpInt, 0 > capd::vectalg::operator-<MpInt, 0 >	(	const RowVector< MpInt, 0 > &	,
		const RowVector< MpInt, 0 > &
	)

◆ operator-<MpInt, 0 >() [6/11]

template Vector<MpInt, 0 > capd::vectalg::operator-<MpInt, 0 >	(	const RowVector< MpInt, 0 > &	,
		const Vector< MpInt, 0 > &
	)

◆ operator-<MpInt, 0 >() [7/11]

template Vector<MpInt, 0 > capd::vectalg::operator-<MpInt, 0 >	(	const Vector< MpInt, 0 > &	,
		const ColumnVector< MpInt, 0 > &
	)

◆ operator-<MpInt, 0 >() [8/11]

template Vector<MpInt, 0 > capd::vectalg::operator-<MpInt, 0 >	(	const Vector< MpInt, 0 > &	,
		const RowVector< MpInt, 0 > &
	)

◆ operator-<MpInt, 0 >() [9/11]

template Vector<MpInt, 0 > capd::vectalg::operator-<MpInt, 0 > ( const Vector< MpInt, 0 > & v )

◆ operator-<MpInt, 0 >() [10/11]

template Vector<MpInt, 0 > capd::vectalg::operator-<MpInt, 0 >	(	const Vector< MpInt, 0 > &	v,
		const MpInt &	s
	)

◆ operator-<MpInt, 0 >() [11/11]

template Vector<MpInt, 0 > capd::vectalg::operator-<MpInt, 0 >	(	const Vector< MpInt, 0 > &	v1,
		const Vector< MpInt, 0 > &	v2
	)

◆ operator-<MpInt, 0, 0 >() [1/3]

template Matrix<MpInt, 0 , 0 > capd::vectalg::operator-<MpInt, 0, 0 > ( const Matrix< MpInt, 0, 0 > & )

◆ operator-<MpInt, 0, 0 >() [2/3]

template Matrix<MpInt, 0 , 0 > capd::vectalg::operator-<MpInt, 0, 0 >	(	const Matrix< MpInt, 0, 0 > &	,
		const Matrix< MpInt, 0, 0 > &
	)

◆ operator-<MpInt, 0, 0 >() [3/3]

template Matrix<MpInt, 0 , 0 > capd::vectalg::operator-<MpInt, 0, 0 >	(	const Matrix< MpInt, 0, 0 > &	,
		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, 0 >() [1/2]

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

◆ operator/<capd::DInterval, 0 >() [2/2]

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

◆ operator/<capd::DInterval, 0, 0 >()

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

◆ operator/<capd::DInterval, capd::DInterval, 0 >()

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

◆ operator/<capd::DInterval, double, 0 >()

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

◆ operator/<capd::DInterval, int, 0 >()

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

◆ operator/<capd::DInterval, long, 0 >()

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

◆ operator/<double, 0 >() [1/2]

template Vector<double, 0 > capd::vectalg::operator/<double, 0 >	(	const ColumnVector< double, 0 > &	,
		const double &
	)

◆ operator/<double, 0 >() [2/2]

template Vector<double, 0 > capd::vectalg::operator/<double, 0 >	(	const RowVector< double, 0 > &	,
		const double &
	)

◆ operator/<double, 0, 0 >()

template Matrix<double, 0 , 0 > capd::vectalg::operator/<double, 0, 0 >	(	const Matrix< double, 0, 0 > &	,
		const double &
	)

◆ operator/<double, double, 0 >()

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

◆ operator/<double, int, 0 >()

template Vector<double, 0 > capd::vectalg::operator/<double, int, 0 >	(	const Vector< double, 0 > &	v,
		const int &	s
	)

◆ operator/<double, long, 0 >()

template Vector<double, 0 > capd::vectalg::operator/<double, long, 0 >	(	const Vector< double, 0 > &	v,
		const long &	s
	)

◆ operator/<int, int, 0 >()

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

◆ operator/<int, long, 0 >()

template Vector<int, 0 > capd::vectalg::operator/<int, long, 0 >	(	const Vector< int, 0 > &	v,
		const long &	s
	)

◆ operator/<long double, 0 >() [1/2]

template Vector<long double, 0 > capd::vectalg::operator/<long double, 0 >	(	const ColumnVector< long double, 0 > &	,
		const long double &
	)

◆ operator/<long double, 0 >() [2/2]

template Vector<long double, 0 > capd::vectalg::operator/<long double, 0 >	(	const RowVector< long double, 0 > &	,
		const long double &
	)

◆ operator/<long double, 0, 0 >()

template Matrix<long double, 0 , 0 > capd::vectalg::operator/<long double, 0, 0 >	(	const Matrix< long double, 0, 0 > &	,
		const long double &
	)

◆ operator/<long double, int, 0 >()

template Vector<long double, 0 > capd::vectalg::operator/<long double, int, 0 >	(	const Vector< long double, 0 > &	v,
		const int &	s
	)

◆ operator/<long double, long double, 0 >()

template Vector<long double, 0 > capd::vectalg::operator/<long double, long double, 0 >	(	const Vector< long double, 0 > &	v,
		const long double &	s
	)

◆ operator/<long double, long, 0 >()

template Vector<long double, 0 > capd::vectalg::operator/<long double, long, 0 >	(	const Vector< long double, 0 > &	v,
		const long &	s
	)

◆ operator/<MpFloat, 0 >() [1/2]

template Vector<MpFloat, 0 > capd::vectalg::operator/<MpFloat, 0 >	(	const ColumnVector< MpFloat, 0 > &	,
		const MpFloat &
	)

◆ operator/<MpFloat, 0 >() [2/2]

template Vector<MpFloat, 0 > capd::vectalg::operator/<MpFloat, 0 >	(	const RowVector< MpFloat, 0 > &	,
		const MpFloat &
	)

◆ operator/<MpFloat, 0, 0 >()

template Matrix<MpFloat, 0 , 0 > capd::vectalg::operator/<MpFloat, 0, 0 >	(	const Matrix< MpFloat, 0, 0 > &	,
		const MpFloat &
	)

◆ operator/<MpFloat, int, 0 >()

template Vector<MpFloat, 0 > capd::vectalg::operator/<MpFloat, int, 0 >	(	const Vector< MpFloat, 0 > &	v,
		const int &	s
	)

◆ operator/<MpFloat, long, 0 >()

template Vector<MpFloat, 0 > capd::vectalg::operator/<MpFloat, long, 0 >	(	const Vector< MpFloat, 0 > &	v,
		const long &	s
	)

◆ operator/<MpFloat, MpFloat, 0 >()

template Vector<MpFloat, 0 > capd::vectalg::operator/<MpFloat, MpFloat, 0 >	(	const Vector< MpFloat, 0 > &	v,
		const MpFloat &	s
	)

◆ operator/<MpInt, 0 >() [1/2]

template Vector<MpInt, 0 > capd::vectalg::operator/<MpInt, 0 >	(	const ColumnVector< MpInt, 0 > &	,
		const MpInt &
	)

◆ operator/<MpInt, 0 >() [2/2]

template Vector<MpInt, 0 > capd::vectalg::operator/<MpInt, 0 >	(	const RowVector< MpInt, 0 > &	,
		const MpInt &
	)

◆ operator/<MpInt, 0, 0 >()

template Matrix<MpInt, 0 , 0 > capd::vectalg::operator/<MpInt, 0, 0 >	(	const Matrix< MpInt, 0, 0 > &	,
		const MpInt &
	)

◆ operator/<MpInt, int, 0 >()

template Vector<MpInt, 0 > capd::vectalg::operator/<MpInt, int, 0 >	(	const Vector< MpInt, 0 > &	v,
		const int &	s
	)

◆ operator/<MpInt, long, 0 >()

template Vector<MpInt, 0 > capd::vectalg::operator/<MpInt, long, 0 >	(	const Vector< MpInt, 0 > &	v,
		const long &	s
	)

◆ operator/<MpInt, MpInt, 0 >()

template Vector<MpInt, 0 > capd::vectalg::operator/<MpInt, MpInt, 0 >	(	const Vector< MpInt, 0 > &	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, 0 >() [1/3]

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

◆ operator<<< capd::DInterval, 0 >() [2/3]

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

◆ operator<<< capd::DInterval, 0 >() [3/3]

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

◆ operator<<< capd::DInterval, 0, 0 >()

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

◆ operator<<< double, 0 >() [1/3]

template std::ostream& capd::vectalg::operator<<< double, 0 >	(	std::ostream &	,
		const ColumnVector< double, 0 > &
	)

◆ operator<<< double, 0 >() [2/3]

template std::ostream& capd::vectalg::operator<<< double, 0 >	(	std::ostream &	,
		const RowVector< double, 0 > &
	)

◆ operator<<< double, 0 >() [3/3]

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

◆ operator<<< double, 0, 0 >()

template std::ostream& capd::vectalg::operator<<< double, 0, 0 >	(	std::ostream &	,
		const Matrix< double, 0, 0 > &
	)

◆ operator<<< int, 0 >()

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

◆ operator<<< long double, 0 >() [1/3]

template std::ostream& capd::vectalg::operator<<< long double, 0 >	(	std::ostream &	,
		const ColumnVector< long double, 0 > &
	)

◆ operator<<< long double, 0 >() [2/3]

template std::ostream& capd::vectalg::operator<<< long double, 0 >	(	std::ostream &	,
		const RowVector< long double, 0 > &
	)

◆ operator<<< long double, 0 >() [3/3]

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

◆ operator<<< long double, 0, 0 >()

template std::ostream& capd::vectalg::operator<<< long double, 0, 0 >	(	std::ostream &	,
		const Matrix< long double, 0, 0 > &
	)

◆ operator<<< MpFloat, 0 >() [1/3]

template std::ostream& capd::vectalg::operator<<< MpFloat, 0 >	(	std::ostream &	,
		const ColumnVector< MpFloat, 0 > &
	)

◆ operator<<< MpFloat, 0 >() [2/3]

template std::ostream& capd::vectalg::operator<<< MpFloat, 0 >	(	std::ostream &	,
		const RowVector< MpFloat, 0 > &
	)

◆ operator<<< MpFloat, 0 >() [3/3]

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

◆ operator<<< MpFloat, 0, 0 >()

template std::ostream& capd::vectalg::operator<<< MpFloat, 0, 0 >	(	std::ostream &	,
		const Matrix< MpFloat, 0, 0 > &
	)

◆ operator<<< MpInt, 0 >() [1/3]

template std::ostream& capd::vectalg::operator<<< MpInt, 0 >	(	std::ostream &	,
		const ColumnVector< MpInt, 0 > &
	)

◆ operator<<< MpInt, 0 >() [2/3]

template std::ostream& capd::vectalg::operator<<< MpInt, 0 >	(	std::ostream &	,
		const RowVector< MpInt, 0 > &
	)

◆ operator<<< MpInt, 0 >() [3/3]

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

◆ operator<<< MpInt, 0, 0 >()

template std::ostream& capd::vectalg::operator<<< MpInt, 0, 0 >	(	std::ostream &	,
		const Matrix< MpInt, 0, 0 > &
	)

◆ operator<<capd::DInterval, 0 >()

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

◆ operator<<capd::DInterval, 0, 0 >()

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

◆ operator<<double, 0 >()

template bool capd::vectalg::operator<<double, 0 >	(	const Vector< double, 0 > &	v1,
		const Vector< double, 0 > &	v2
	)

◆ operator<<double, 0, 0 >()

template bool capd::vectalg::operator<<double, 0, 0 >	(	const Matrix< double, 0, 0 > &	,
		const Matrix< double, 0, 0 > &
	)

◆ operator<<int, 0 >()

template bool capd::vectalg::operator<<int, 0 >	(	const Vector< int, 0 > &	v1,
		const Vector< int, 0 > &	v2
	)

◆ operator<<long double, 0 >()

template bool capd::vectalg::operator<<long double, 0 >	(	const Vector< long double, 0 > &	v1,
		const Vector< long double, 0 > &	v2
	)

◆ operator<<long double, 0, 0 >()

template bool capd::vectalg::operator<<long double, 0, 0 >	(	const Matrix< long double, 0, 0 > &	,
		const Matrix< long double, 0, 0 > &
	)

◆ operator<<MpFloat, 0 >()

template bool capd::vectalg::operator<<MpFloat, 0 >	(	const Vector< MpFloat, 0 > &	v1,
		const Vector< MpFloat, 0 > &	v2
	)

◆ operator<<MpFloat, 0, 0 >()

template bool capd::vectalg::operator<<MpFloat, 0, 0 >	(	const Matrix< MpFloat, 0, 0 > &	,
		const Matrix< MpFloat, 0, 0 > &
	)

◆ operator<<MpInt, 0 >()

template bool capd::vectalg::operator<<MpInt, 0 >	(	const Vector< MpInt, 0 > &	v1,
		const Vector< MpInt, 0 > &	v2
	)

◆ operator<<MpInt, 0, 0 >()

template bool capd::vectalg::operator<<MpInt, 0, 0 >	(	const Matrix< MpInt, 0, 0 > &	,
		const Matrix< MpInt, 0, 0 > &
	)

◆ 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, 0 >()

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

◆ operator<=< capd::DInterval, 0, 0 >()

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

◆ operator<=< double, 0 >()

template bool capd::vectalg::operator<=< double, 0 >	(	const Vector< double, 0 > &	v1,
		const Vector< double, 0 > &	v2
	)

◆ operator<=< double, 0, 0 >()

template bool capd::vectalg::operator<=< double, 0, 0 >	(	const Matrix< double, 0, 0 > &	,
		const Matrix< double, 0, 0 > &
	)

◆ operator<=< int, 0 >()

template bool capd::vectalg::operator<=< int, 0 >	(	const Vector< int, 0 > &	v1,
		const Vector< int, 0 > &	v2
	)

◆ operator<=< long double, 0 >()

template bool capd::vectalg::operator<=< long double, 0 >	(	const Vector< long double, 0 > &	v1,
		const Vector< long double, 0 > &	v2
	)

◆ operator<=< long double, 0, 0 >()

template bool capd::vectalg::operator<=< long double, 0, 0 >	(	const Matrix< long double, 0, 0 > &	,
		const Matrix< long double, 0, 0 > &
	)

◆ operator<=< MpFloat, 0 >()

template bool capd::vectalg::operator<=< MpFloat, 0 >	(	const Vector< MpFloat, 0 > &	v1,
		const Vector< MpFloat, 0 > &	v2
	)

◆ operator<=< MpFloat, 0, 0 >()

template bool capd::vectalg::operator<=< MpFloat, 0, 0 >	(	const Matrix< MpFloat, 0, 0 > &	,
		const Matrix< MpFloat, 0, 0 > &
	)

◆ operator<=< MpInt, 0 >()

template bool capd::vectalg::operator<=< MpInt, 0 >	(	const Vector< MpInt, 0 > &	v1,
		const Vector< MpInt, 0 > &	v2
	)

◆ operator<=< MpInt, 0, 0 >()

template bool capd::vectalg::operator<=< MpInt, 0, 0 >	(	const Matrix< MpInt, 0, 0 > &	,
		const Matrix< MpInt, 0, 0 > &
	)

◆ 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, 0 >()

template bool capd::vectalg::operator><double, 0 >	(	const Vector< double, 0 > &	v1,
		const Vector< double, 0 > &	v2
	)

◆ operator><double, 0, 0 >()

template bool capd::vectalg::operator><double, 0, 0 >	(	const Matrix< double, 0, 0 > &	,
		const Matrix< double, 0, 0 > &
	)

◆ operator><int, 0 >()

template bool capd::vectalg::operator><int, 0 >	(	const Vector< int, 0 > &	v1,
		const Vector< int, 0 > &	v2
	)

◆ operator><long double, 0 >()

template bool capd::vectalg::operator><long double, 0 >	(	const Vector< long double, 0 > &	v1,
		const Vector< long double, 0 > &	v2
	)

◆ operator><long double, 0, 0 >()

template bool capd::vectalg::operator><long double, 0, 0 >	(	const Matrix< long double, 0, 0 > &	,
		const Matrix< long double, 0, 0 > &
	)

◆ operator><MpFloat, 0 >()

template bool capd::vectalg::operator><MpFloat, 0 >	(	const Vector< MpFloat, 0 > &	v1,
		const Vector< MpFloat, 0 > &	v2
	)

◆ operator><MpFloat, 0, 0 >()

template bool capd::vectalg::operator><MpFloat, 0, 0 >	(	const Matrix< MpFloat, 0, 0 > &	,
		const Matrix< MpFloat, 0, 0 > &
	)

◆ operator><MpInt, 0 >()

template bool capd::vectalg::operator><MpInt, 0 >	(	const Vector< MpInt, 0 > &	v1,
		const Vector< MpInt, 0 > &	v2
	)

◆ operator><MpInt, 0, 0 >()

template bool capd::vectalg::operator><MpInt, 0, 0 >	(	const Matrix< MpInt, 0, 0 > &	,
		const Matrix< MpInt, 0, 0 > &
	)

◆ 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, 0 >()

template bool capd::vectalg::operator>=< double, 0 >	(	const Vector< double, 0 > &	v1,
		const Vector< double, 0 > &	v2
	)

◆ operator>=< double, 0, 0 >()

template bool capd::vectalg::operator>=< double, 0, 0 >	(	const Matrix< double, 0, 0 > &	,
		const Matrix< double, 0, 0 > &
	)

◆ operator>=< int, 0 >()

template bool capd::vectalg::operator>=< int, 0 >	(	const Vector< int, 0 > &	v1,
		const Vector< int, 0 > &	v2
	)

◆ operator>=< long double, 0 >()

template bool capd::vectalg::operator>=< long double, 0 >	(	const Vector< long double, 0 > &	v1,
		const Vector< long double, 0 > &	v2
	)

◆ operator>=< long double, 0, 0 >()

template bool capd::vectalg::operator>=< long double, 0, 0 >	(	const Matrix< long double, 0, 0 > &	,
		const Matrix< long double, 0, 0 > &
	)

◆ operator>=< MpFloat, 0 >()

template bool capd::vectalg::operator>=< MpFloat, 0 >	(	const Vector< MpFloat, 0 > &	v1,
		const Vector< MpFloat, 0 > &	v2
	)

◆ operator>=< MpFloat, 0, 0 >()

template bool capd::vectalg::operator>=< MpFloat, 0, 0 >	(	const Matrix< MpFloat, 0, 0 > &	,
		const Matrix< MpFloat, 0, 0 > &
	)

◆ operator>=< MpInt, 0 >()

template bool capd::vectalg::operator>=< MpInt, 0 >	(	const Vector< MpInt, 0 > &	v1,
		const Vector< MpInt, 0 > &	v2
	)

◆ operator>=< MpInt, 0, 0 >()

template bool capd::vectalg::operator>=< MpInt, 0, 0 >	(	const Matrix< MpInt, 0, 0 > &	,
		const Matrix< MpInt, 0, 0 > &
	)

◆ 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, 0 >()

template std::istream& capd::vectalg::operator>>< double, 0 >	(	std::istream &	inp,
		Vector< double, 0 > &	v
	)

◆ operator>>< double, 0, 0 >()

template std::istream& capd::vectalg::operator>>< double, 0, 0 >	(	std::istream &	,
		Matrix< double, 0, 0 > &
	)

◆ operator>>< int, 0 >()

template std::istream& capd::vectalg::operator>>< int, 0 >	(	std::istream &	inp,
		Vector< int, 0 > &	v
	)

◆ operator>>< long double, 0 >()

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

◆ operator>>< long double, 0, 0 >()

template std::istream& capd::vectalg::operator>>< long double, 0, 0 >	(	std::istream &	,
		Matrix< long double, 0, 0 > &
	)

◆ operator>>< MpFloat, 0 >()

template std::istream& capd::vectalg::operator>>< MpFloat, 0 >	(	std::istream &	inp,
		Vector< MpFloat, 0 > &	v
	)

◆ operator>>< MpFloat, 0, 0 >()

template std::istream& capd::vectalg::operator>>< MpFloat, 0, 0 >	(	std::istream &	,
		Matrix< MpFloat, 0, 0 > &
	)

◆ operator>>< MpInt, 0 >()

template std::istream& capd::vectalg::operator>>< MpInt, 0 >	(	std::istream &	inp,
		Vector< MpInt, 0 > &	v
	)

◆ operator>>< MpInt, 0, 0 >()

template std::istream& capd::vectalg::operator>>< MpInt, 0, 0 >	(	std::istream &	,
		Matrix< MpInt, 0, 0 > &
	)

◆ printVector() [1/3]

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

◆ printVector() [2/3]

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

◆ printVector() [3/3]

template std::ostream& capd::vectalg::printVector	(	std::ostream &	str,
		const ColumnVector< long double, 0 > &	,
		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, 0 >::ScalarType capd::vectalg::scalarProduct	(	Vector< capd::DInterval, 0 > const &	,
		Vector< capd::DInterval, 0 > 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, 0 >& capd::vectalg::subtractAssignMatrixByVector	(	Vector< capd::DInterval, 0 > &	u,
		const Matrix< capd::DInterval, 0, 0 > &	A,
		const Vector< capd::DInterval, 0 > &	v
	)

◆ subtractAssignMatrixByVector() [3/5]

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

◆ subtractAssignMatrixByVector() [4/5]

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

◆ subtractAssignMatrixByVector() [5/5]

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

◆ subtractAssignObjectObject() [1/2]

template RowVector<double, 0 >& capd::vectalg::subtractAssignObjectObject	(	RowVector< double, 0 > &	,
		Vector< double, 0 > 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, 0, 0 > &	v1,
		const Matrix< capd::DInterval, 0, 0 > &	v2,
		Matrix< capd::DInterval, 0, 0 > &	result
	)

◆ subtractObjects() [2/14]

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

◆ subtractObjects() [3/14]

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

◆ subtractObjects() [4/14]

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

◆ subtractObjects() [5/14]

template void capd::vectalg::subtractObjects	(	const Matrix< MpInt, 0, 0 > &	v1,
		const Matrix< MpInt, 0, 0 > &	v2,
		Matrix< MpInt, 0, 0 > &	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, 0 > &	,
		const Vector< capd::DInterval, 0 > &	,
		Vector< capd::DInterval, 0 > &
	)

◆ subtractObjects() [9/14]

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

◆ subtractObjects() [10/14]

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

◆ subtractObjects() [11/14]

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

◆ subtractObjects() [12/14]

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

◆ subtractObjects() [13/14]

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

◆ subtractObjects() [14/14]

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

◆ 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, 0, 0 >()

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

◆ Transpose< double, 0, 0 >()

template Matrix<double, 0 , 0 > capd::vectalg::Transpose< double, 0, 0 > ( const Matrix< double, 0, 0 > & )

◆ Transpose< long double, 0, 0 >()

template Matrix<long double, 0 , 0 > capd::vectalg::Transpose< long double, 0, 0 > ( const Matrix< long double, 0, 0 > & )

◆ Transpose< MpFloat, 0, 0 >()

template Matrix<MpFloat, 0 , 0 > capd::vectalg::Transpose< MpFloat, 0, 0 > ( const Matrix< MpFloat, 0, 0 > & )

◆ Transpose< MpInt, 0, 0 >()

template Matrix<MpInt, 0 , 0 > capd::vectalg::Transpose< MpInt, 0, 0 > ( const Matrix< MpInt, 0, 0 > & )

◆ unaryMinus() [1/4]

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

◆ unaryMinus() [2/4]

template Vector<double, 0 > capd::vectalg::unaryMinus ( ColumnVector< double, 0 > const & )

◆ unaryMinus() [3/4]

template Vector<long double, 0 > capd::vectalg::unaryMinus ( ColumnVector< long double, 0 > 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, 0 >()

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

◆ abs< double, 0 >()

◆ abs< double, 0, 0 >()

◆ abs< int, 0 >()

◆ abs< long double, 0 >()

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

◆ abs< MpFloat, 0 >()

◆ abs< MpFloat, 0, 0 >()

◆ abs< MpInt, 0 >()

◆ abs< MpInt, 0, 0 >()

◆ absoluteValue()

◆ addAssignMatrixByVector() [1/5]

◆ addAssignMatrixByVector() [2/5]

◆ addAssignMatrixByVector() [3/5]

◆ addAssignMatrixByVector() [4/5]

◆ addAssignMatrixByVector() [5/5]

◆ addAssignObjectObject() [1/6]

◆ addAssignObjectObject() [2/6]

◆ addAssignObjectObject() [3/6]

◆ addAssignObjectObject() [4/6]

◆ addAssignObjectObject() [5/6]

◆ addAssignObjectObject() [6/6]

◆ 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()