CAPD DynSys Library 5.2.0
capd::vectalg Namespace Reference

Classes

class  ColumnIterator
 
class  ColumnVector
 This class realizes a vector without its own container, which is a reference to a subset of other object with his own container. A typical situation is a column of matrix which can be considered as a vector. More...
 
class  const_ColumnIterator
 
class  Container
 class Container together with suitable iterators The container has fixed size specified by a template argument 'capacity' More...
 
class  Container< Scalar, 0 >
 Specialization for capacity=0 This container allocates objects on a storage. More...
 
struct  Convert
 
struct  Convert< ResultType, ScalarType, false >
 
struct  Convert< ResultType, ScalarType, true >
 
class  EuclLNorm
 Euclidean Logarithmic Norm. More...
 
class  EuclNorm
 Euclidean norm. More...
 
class  Matrix
 
class  MatrixContainer
 This class inherits form general Container class and provides constructors and methods specific for two dimensional data. More...
 
class  MatrixContainer< Scalar, 0, 0 >
 
class  MaxLNorm
 $ L_\infty $ Logarithmic Norm More...
 
class  MaxNorm
 $ L_\infty $ norm (max norm) More...
 
class  Multiindex
 For a Multiindex mi, mi[p] is a number of differentiation with respect to i-th variable. For example, a Multipointer mp=(0,0,2,3) in 5-dimensional space corresponds to the Multiindex mi=(2,0,1,1,0). Hence, Multiindex agrees with standard notation and it contains an additional information about the dimension of the domain of the function. More...
 
class  Multipointer
 Multipointer always contains nondecreasing list of indexes of variables. More...
 
class  Norm
 A general abstract norm. More...
 
class  RowVector
 RowVector class realizes a vector without its own container. He is just a reference to a part of other object (i.e. Matrix of Vector) with his own container. More...
 
class  SumLNorm
 $ L_1 $ Logarytmic norm More...
 
class  SumNorm
 $ L_1 $ norm More...
 
class  Vector
 

Typedefs

typedef unsigned __size_type
 
typedef int __difference_type
 
typedef Vector< double, CAPD_DEFAULT_DIMENSIONDVector
 
typedef Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSIONIMatrix
 
typedef Matrix< capd::DInterval::BoundType, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSIONDMatrix
 
typedef Vector< capd::DInterval, CAPD_DEFAULT_DIMENSIONIVector
 
typedef Vector< long double, CAPD_DEFAULT_DIMENSIONLDVector
 

Functions

template<typename 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 >
ObjectassignFromScalar (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 >
ObjectaddAssignObjectScalar (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 >
ObjectsubtractAssignObjectScalar (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 >
ObjectmultiplyAssignObjectScalar (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 >
ObjectmultiplyAssignObjectScalarAddObject (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 >
ObjectdivideAssignObjectScalar (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< typenameIObject::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< typenamecapd::TypeTraits< typenameIObject::ScalarType >::Real >::other widths (const IObject &v)
 
template<typename Scalar , __size_type rows, __size_type cols1, __size_type cols2>
Matrix< Scalar, rows, cols2 > operator* (const Matrix< Scalar, rows, cols1 > &, const Matrix< Scalar, cols1, cols2 > &)
 
template<typename Scalar , __size_type rows, __size_type cols>
Matrix< Scalar, cols, rows > transpose (const Matrix< Scalar, rows, cols > &)
 
template<typename Scalar , __size_type rows, __size_type cols>
Matrix< Scalar, cols, rows > Transpose (const Matrix< Scalar, rows, cols > &)
 
template<typename Scalar , __size_type rows, __size_type cols>
std::ostream & operator<< (std::ostream &, const Matrix< Scalar, rows, cols > &)
 
template<typename Scalar , __size_type rows, __size_type cols>
std::istream & operator>> (std::istream &, Matrix< Scalar, rows, cols > &)
 
template<typename Scalar , __size_type rows, __size_type cols>
Matrix< Scalar, cols, rows >::ScalarType trace (const Matrix< Scalar, cols, rows > &A)
 Computes Trace of a given matrix. More...
 
template<typename Scalar , __size_type rows, __size_type cols>
Matrix< Scalar, cols, rows >::ScalarType secondTrace (const Matrix< Scalar, cols, rows > &A)
 It returns a sum of determinants of all 2x2 matrix. More...
 
template<typename Scalar , __size_type rows, __size_type cols>
std::string cppReprezentation (const Matrix< Scalar, cols, rows > &A, const std::string &varName, const std::string &typeName)
 It serializes a matrix - gives text reprezentation which can be compiled. More...
 
template<typename Scalar , __size_type rows, __size_type cols>
void setDimensionInArray (Matrix< Scalar, rows, cols > *, __size_type, __size_type, __size_type)
 
template<typename Scalar >
void setDimensionInArray (Matrix< Scalar, 0, 0 > *t, __size_type N, __size_type r, __size_type c)
 
template<typename Scalar , __size_type rows, __size_type cols>
Vector< Scalar, rows > operator* (const Matrix< Scalar, rows, cols > &m, const Vector< Scalar, cols > &v)
 
template<typename Scalar , __size_type rows, __size_type cols>
Vector< Scalar, rows > operator* (const Matrix< Scalar, rows, cols > &a, const ColumnVector< Scalar, cols > &v)
 
template<typename Scalar , __size_type rows, __size_type cols>
Vector< Scalar, rows > operator* (const Matrix< Scalar, rows, cols > &m, const RowVector< Scalar, cols > &u)
 
template<typename Scalar , __size_type rows, __size_type cols>
Matrix< Scalar, rows, cols > abs (const Matrix< Scalar, rows, cols > &m)
 
template<typename Scalar , __size_type rows, __size_type cols>
Matrix< Scalar, rows, cols > operator- (const Matrix< Scalar, rows, cols > &m)
 
template<typename Scalar , __size_type rows, __size_type cols>
Matrix< Scalar, rows, cols > operator+ (const Matrix< Scalar, rows, cols > &m1, const Matrix< Scalar, rows, cols > &m2)
 
template<typename Scalar , __size_type rows, __size_type cols>
Matrix< Scalar, rows, cols > operator- (const Matrix< Scalar, rows, cols > &m1, const Matrix< Scalar, rows, cols > &m2)
 
template<typename Scalar , __size_type rows, __size_type cols>
Matrix< Scalar, rows, cols > operator* (const Matrix< Scalar, rows, cols > &m, const Scalar &s)
 
template<typename Scalar , __size_type rows, __size_type cols>
Matrix< Scalar, rows, cols > operator* (const Scalar &s, const Matrix< Scalar, rows, cols > &m)
 
template<typename Scalar , __size_type rows, __size_type cols>
Matrix< Scalar, rows, cols > operator/ (const Matrix< Scalar, rows, cols > &m, const Scalar &s)
 
template<typename Scalar , __size_type rows, __size_type cols>
Matrix< Scalar, rows, cols > operator+ (const Matrix< Scalar, rows, cols > &m, const Scalar &s)
 
template<typename Scalar , __size_type rows, __size_type cols>
Matrix< Scalar, rows, cols > operator- (const Matrix< Scalar, rows, cols > &m, const Scalar &s)
 
template<typename Scalar , __size_type rows, __size_type cols>
bool operator< (const Matrix< Scalar, rows, cols > &m1, const Matrix< Scalar, rows, cols > &m2)
 
template<typename Scalar , __size_type rows, __size_type cols>
bool operator> (const Matrix< Scalar, rows, cols > &m1, const Matrix< Scalar, rows, cols > &m2)
 
template<typename Scalar , __size_type rows, __size_type cols>
bool operator<= (const Matrix< Scalar, rows, cols > &m1, const Matrix< Scalar, rows, cols > &m2)
 
template<typename Scalar , __size_type rows, __size_type cols>
bool operator>= (const Matrix< Scalar, rows, cols > &m1, const Matrix< Scalar, rows, cols > &m2)
 
template<typename Scalar , __size_type rows, __size_type cols>
bool operator== (const Matrix< Scalar, rows, cols > &a1, const Matrix< Scalar, rows, cols > &a2)
 
template<typename Scalar , __size_type rows, __size_type cols>
bool operator!= (const Matrix< Scalar, rows, cols > &a1, const Matrix< Scalar, rows, cols > &a2)
 
template<typename IMatrixType >
IMatrixType midMatrix (const IMatrixType &v)
 
Multipointer sumMultipointers (const Multipointer &, const Multipointer &)
 
Multipointer addIndex (const Multipointer &mp, int index)
 returns new multipointer which is multiindex mp with index added in correct place More...
 
Multipointer push_back (const Multipointer &mp, int index)
 appends index to the end of multipointer mp More...
 
bool hasIndex (const Multipointer &mp, int index)
 checks if muiltipointer contains index More...
 
int indexCount (const Multipointer &mp, int index)
 returns the number of occurences of index in the multipointer More...
 
Multipointer removeIndex (const Multipointer &mp, int index)
 returns a multipointer with removed index More...
 
template<typename Scalar , __size_type cols>
Vector< Scalar, cols > diam (const RowVector< Scalar, cols > &v)
 
template<typename Scalar , __size_type cols>
Vector< Scalar, cols > operator+ (const Vector< Scalar, cols > &u1, const RowVector< Scalar, cols > &u2)
 
template<typename Scalar , __size_type cols>
Vector< Scalar, cols > operator+ (const RowVector< Scalar, cols > &u1, const Vector< Scalar, cols > &u2)
 
template<typename Scalar , __size_type cols>
Vector< Scalar, cols > operator+ (const RowVector< Scalar, cols > &u1, const RowVector< Scalar, cols > &u2)
 
template<typename Scalar , __size_type cols>
Vector< Scalar, cols > operator- (const Vector< Scalar, cols > &u1, const RowVector< Scalar, cols > &u2)
 
template<typename Scalar , __size_type cols>
Vector< Scalar, cols > operator- (const RowVector< Scalar, cols > &u1, const Vector< Scalar, cols > &u2)
 
template<typename Scalar , __size_type cols>
Vector< Scalar, cols > operator- (const RowVector< Scalar, cols > &u1, const RowVector< Scalar, cols > &u2)
 
template<typename Scalar , __size_type cols>
Scalar operator* (const Vector< Scalar, cols > &u1, const RowVector< Scalar, cols > &u2)
 
template<typename Scalar , __size_type cols>
Scalar operator* (const RowVector< Scalar, cols > &u1, const Vector< Scalar, cols > &u2)
 
template<typename Scalar , __size_type cols>
Scalar operator* (const RowVector< Scalar, cols > &u1, const RowVector< Scalar, cols > &u2)
 
template<typename Scalar , __size_type cols>
Vector< Scalar, cols > operator- (const RowVector< Scalar, cols > &u)
 
template<typename Scalar , __size_type cols>
Vector< Scalar, cols > operator* (const Scalar &s, const RowVector< Scalar, cols > &u)
 
template<typename Scalar , __size_type cols>
Vector< Scalar, cols > operator* (const RowVector< Scalar, cols > &u, const Scalar &s)
 
template<typename Scalar , __size_type cols>
Vector< Scalar, cols > operator/ (const RowVector< Scalar, cols > &u, const Scalar &s)
 
template<typename Scalar , __size_type cols>
std::ostream & operator<< (std::ostream &out, const RowVector< Scalar, cols > &u)
 
template<typename VectorType1 , typename VectorType2 >
void intersectionWithSubvector (const VectorType1 &src, VectorType2 &target, int start, int stop)
 Intersection of src with target[start..stop] is returned in target. More...
 
template<typename VectorType1 , typename VectorType2 >
void copyToSubvector (const VectorType1 &src, VectorType2 &target, int start, int stop)
 it copies src into target[start..stop] More...
 
template<typename VectorType1 , typename VectorType2 >
void copyFromSubvector (const VectorType1 &src, VectorType2 &target, int start, int stop)
 it copies src[start..stop] into target More...
 
template<typename MatrixType1 , typename MatrixType2 >
void intersectionWithSubmatrix (const MatrixType1 &src, MatrixType2 &target, int startRow, int stopRow, int startCol, int stopCol)
 intersection of src with target[startRow..stopRow][startCol..stopCol] is returned in target More...
 
template<typename MatrixType1 , typename MatrixType2 >
void copyToSubmatrix (const MatrixType1 &src, MatrixType2 &target, int startRow, int stopRow, int startCol, int stopCol)
 it copies src into target[startRow..stopRow)[startCol..stopCol) More...
 
template<typename MatrixType1 , typename MatrixType2 >
void copyFromSubmatrix (const MatrixType1 &src, MatrixType2 &target, int startRow, int stopRow, int startCol, int stopCol)
 it copies src[startRow..stopRow)[startCol..stopCol) into target More...
 
template<typename Scalar , __size_type dim>
std::ostream & operator<< (std::ostream &out, const Vector< Scalar, dim > &v)
 
template<typename Scalar , __size_type dim>
std::istream & operator>> (std::istream &inp, Vector< Scalar, dim > &v)
 
template<typename Vector >
std::string vectorToString (const Vector &v, int firstIndex=0, int lastIndex=-1, int precision=-1)
 
template<typename Vector >
std::ostream & printVector (std::ostream &str, const Vector &v, int firstIndex=0, int lastIndex=-1)
 
template<typename Scalar , __size_type dim>
std::ostream & print (std::ostream &str, const Vector< Scalar, dim > &v, int firstIndex=0, int lastIndex=-1)
 
template<typename Scalar , __size_type dim>
std::string cppReprezentation (const Vector< Scalar, dim > &A, const std::string &varName, const std::string &typeName)
 It serializes a matrix - gives text reprezentation which can be compiled. More...
 
template<typename Scalar , __size_type dim>
void setDimensionInArray (Vector< Scalar, dim > *, __size_type, __size_type)
 
template<typename Scalar >
void setDimensionInArray (Vector< Scalar, 0 > *t, __size_type N, __size_type _dim)
 
template<typename Scalar , __size_type dim>
Vector< Scalar, dim > abs (const Vector< Scalar, dim > &v)
 
template<typename Scalar , __size_type dim>
Vector< Scalar, dim > operator- (const Vector< Scalar, dim > &v)
 
template<typename Scalar , __size_type dim>
Vector< Scalar, dim > operator+ (const Vector< Scalar, dim > &v1, const Vector< Scalar, dim > &v2)
 
template<typename Scalar , __size_type dim>
Vector< Scalar, dim > operator- (const Vector< Scalar, dim > &v1, const Vector< Scalar, dim > &v2)
 
template<typename Scalar , __size_type dim>
Scalar operator* (const Vector< Scalar, dim > &v1, const Vector< Scalar, dim > &v2)
 
template<typename Scalar , __size_type dim>
Vector< Scalar, dim > operator+ (const Vector< Scalar, dim > &v, const Scalar &s)
 
template<typename Scalar , __size_type dim>
Vector< Scalar, dim > operator- (const Vector< Scalar, dim > &v, const Scalar &s)
 
template<typename Scalar , typename FactorType , __size_type dim>
Vector< Scalar, dim > operator* (const Vector< Scalar, dim > &v, const FactorType &s)
 
template<typename Scalar , typename FactorType , __size_type dim>
Vector< Scalar, dim > operator* (const FactorType &s, const Vector< Scalar, dim > &v)
 
template<typename Scalar , typename FactorType , __size_type dim>
Vector< Scalar, dim > operator/ (const Vector< Scalar, dim > &v, const FactorType &s)
 
template<typename Scalar , __size_type dim>
bool operator< (const Vector< Scalar, dim > &v1, const Vector< Scalar, dim > &v2)
 
template<typename Scalar , __size_type dim>
bool operator> (const Vector< Scalar, dim > &v1, const Vector< Scalar, dim > &v2)
 
template<typename Scalar , __size_type dim>
bool operator<= (const Vector< Scalar, dim > &v1, const Vector< Scalar, dim > &v2)
 
template<typename Scalar , __size_type dim>
bool operator>= (const Vector< Scalar, dim > &v1, const Vector< Scalar, dim > &v2)
 
template<typename Scalar , __size_type dim>
bool operator== (const Vector< Scalar, dim > &v1, const Vector< Scalar, dim > &v2)
 
template<typename Scalar , __size_type dim>
bool operator!= (const Vector< Scalar, dim > &v1, const Vector< Scalar, dim > &v2)
 
template<typename IVector >
IVector leftVector (const IVector &u)
 
template<typename IVector >
IVector rightVector (const IVector &u)
 
template<typename IVector >
IVector::ScalarType maxDiam (const IVector &)
 
template<typename IVector >
IVector intervalBall (const IVector &, const typename IVector::ScalarType &r)
 
template<typename IVector >
IVector::ScalarType solveAffineInclusion (const IVector &, const IVector &, const IVector &)
 
template<typename IVector >
IVector::ScalarType solveAffineInclusion (const IVector &, const IVector &, const IVector &, int &)
 
template<typename IVector >
IVector intervalHull (const IVector &, const IVector &)
 
template<typename IVector >
IVector midVector (const IVector &)
 
template<typename IVector >
IVector diam (const IVector &)
 
template<typename IVector >
IVector intersection (const IVector &, const IVector &)
 
template<typename IVectorType >
IVectorType diam (const IVectorType &v)
 
template<typename IVectorType >
IVectorType intersection (const IVectorType &v1, const IVectorType &v2)
 
template<typename IVectorType >
IVectorType midVector (const IVectorType &v)
 
template<typename IVectorType >
IVectorType intervalHull (const IVectorType &v1, const IVectorType &v2)
 
template<typename IVectorType >
IVectorType intervalBall (const IVectorType &iv, const typename IVectorType::ScalarType &r)
 
template<typename IVectorType >
IVectorType::ScalarType solveAffineInclusion (const IVectorType &a, const IVectorType &p, const IVectorType &c)
 
template<typename IVectorType >
IVectorType::ScalarType solveAffineInclusion (const IVectorType &a, const IVectorType &p, const IVectorType &c, int &dir)
 
template Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSIONabs< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSIONoperator-<double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSIONoperator+<double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSIONoperator-<double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSIONoperator*<double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< double, CAPD_DEFAULT_DIMENSIONoperator*<double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Vector< double, CAPD_DEFAULT_DIMENSION > &)
 
template Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSIONoperator*<double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const double &)
 
template Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSIONoperator*<double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const double &, const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSIONoperator/<double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const double &)
 
template Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSIONoperator+<double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const double &)
 
template Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSIONoperator-<double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const double &)
 
template bool operator<<double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template bool operator><double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template bool operator<=< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template bool operator>=< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSIONTranspose< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template std::ostream & operator<<< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (std::ostream &, const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template std::istream & operator>>< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (std::istream &, Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template void matrixByVector (const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Vector< double, CAPD_DEFAULT_DIMENSION > &, Vector< double, CAPD_DEFAULT_DIMENSION > &)
 
template void matrixByVector (const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< double, CAPD_DEFAULT_DIMENSION > &, Vector< double, CAPD_DEFAULT_DIMENSION > &)
 
template void matrixByVector (const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &, Vector< long double, CAPD_DEFAULT_DIMENSION > &)
 
template void matrixByMatrix (const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template void matrixByMatrix (const Matrix< int, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< int, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, Matrix< int, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template void matrixByVector (const Matrix< int, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Vector< int, CAPD_DEFAULT_DIMENSION > &, Vector< int, CAPD_DEFAULT_DIMENSION > &)
 
template void matrixByVector (const Matrix< int, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< int, CAPD_DEFAULT_DIMENSION > &, Vector< int, CAPD_DEFAULT_DIMENSION > &)
 
template void subtractObjects (const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &v1, const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &v2, Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &result)
 
template void addObjects (const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &v1, const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &v2, Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &result)
 
template Vector< double, CAPD_DEFAULT_DIMENSION > & addAssignMatrixByVector (Vector< double, CAPD_DEFAULT_DIMENSION > &u, const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &A, const Vector< double, CAPD_DEFAULT_DIMENSION > &v)
 
template Vector< double, CAPD_DEFAULT_DIMENSION > & subtractAssignMatrixByVector (Vector< double, CAPD_DEFAULT_DIMENSION > &u, const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &A, const Vector< double, CAPD_DEFAULT_DIMENSION > &v)
 
template Vector< double, CAPD_DEFAULT_DIMENSIONoperator+<double, CAPD_DEFAULT_DIMENSION > (const Vector< double, CAPD_DEFAULT_DIMENSION > &, const RowVector< double, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< double, CAPD_DEFAULT_DIMENSIONoperator+<double, CAPD_DEFAULT_DIMENSION > (const RowVector< double, CAPD_DEFAULT_DIMENSION > &, const Vector< double, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< double, CAPD_DEFAULT_DIMENSIONoperator+<double, CAPD_DEFAULT_DIMENSION > (const RowVector< double, CAPD_DEFAULT_DIMENSION > &, const RowVector< double, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< double, CAPD_DEFAULT_DIMENSIONoperator-<double, CAPD_DEFAULT_DIMENSION > (const Vector< double, CAPD_DEFAULT_DIMENSION > &, const RowVector< double, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< double, CAPD_DEFAULT_DIMENSIONoperator-<double, CAPD_DEFAULT_DIMENSION > (const RowVector< double, CAPD_DEFAULT_DIMENSION > &, const Vector< double, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< double, CAPD_DEFAULT_DIMENSIONoperator-<double, CAPD_DEFAULT_DIMENSION > (const RowVector< double, CAPD_DEFAULT_DIMENSION > &, const RowVector< double, CAPD_DEFAULT_DIMENSION > &)
 
template double operator*<double, CAPD_DEFAULT_DIMENSION > (const Vector< double, CAPD_DEFAULT_DIMENSION > &, const RowVector< double, CAPD_DEFAULT_DIMENSION > &)
 
template double operator*<double, CAPD_DEFAULT_DIMENSION > (const RowVector< double, CAPD_DEFAULT_DIMENSION > &, const Vector< double, CAPD_DEFAULT_DIMENSION > &)
 
template double operator*<double, CAPD_DEFAULT_DIMENSION > (const RowVector< double, CAPD_DEFAULT_DIMENSION > &, const RowVector< double, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< double, CAPD_DEFAULT_DIMENSIONoperator-<double, CAPD_DEFAULT_DIMENSION > (const RowVector< double, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< double, CAPD_DEFAULT_DIMENSIONoperator*<double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const RowVector< double, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< double, CAPD_DEFAULT_DIMENSIONoperator*<double, CAPD_DEFAULT_DIMENSION > (const double &, const RowVector< double, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< double, CAPD_DEFAULT_DIMENSIONoperator*<double, CAPD_DEFAULT_DIMENSION > (const RowVector< double, CAPD_DEFAULT_DIMENSION > &, const double &)
 
template Vector< double, CAPD_DEFAULT_DIMENSIONoperator/<double, CAPD_DEFAULT_DIMENSION > (const RowVector< double, CAPD_DEFAULT_DIMENSION > &, const double &)
 
template std::ostream & operator<<< double, CAPD_DEFAULT_DIMENSION > (std::ostream &, const RowVector< double, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< double, CAPD_DEFAULT_DIMENSIONoperator+<double, CAPD_DEFAULT_DIMENSION > (const Vector< double, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< double, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< double, CAPD_DEFAULT_DIMENSIONoperator+<double, CAPD_DEFAULT_DIMENSION > (const ColumnVector< double, CAPD_DEFAULT_DIMENSION > &, const Vector< double, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< double, CAPD_DEFAULT_DIMENSIONoperator+<double, CAPD_DEFAULT_DIMENSION > (const ColumnVector< double, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< double, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< double, CAPD_DEFAULT_DIMENSIONoperator-<double, CAPD_DEFAULT_DIMENSION > (const Vector< double, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< double, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< double, CAPD_DEFAULT_DIMENSIONoperator-<double, CAPD_DEFAULT_DIMENSION > (const ColumnVector< double, CAPD_DEFAULT_DIMENSION > &, const Vector< double, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< double, CAPD_DEFAULT_DIMENSIONoperator-<double, CAPD_DEFAULT_DIMENSION > (const ColumnVector< double, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< double, CAPD_DEFAULT_DIMENSION > &)
 
template double operator*<double, CAPD_DEFAULT_DIMENSION > (const Vector< double, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< double, CAPD_DEFAULT_DIMENSION > &)
 
template double operator*<double, CAPD_DEFAULT_DIMENSION > (const ColumnVector< double, CAPD_DEFAULT_DIMENSION > &, const Vector< double, CAPD_DEFAULT_DIMENSION > &)
 
template double operator*<double, CAPD_DEFAULT_DIMENSION > (const ColumnVector< double, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< double, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< double, CAPD_DEFAULT_DIMENSIONoperator-<double, CAPD_DEFAULT_DIMENSION > (const ColumnVector< double, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< double, CAPD_DEFAULT_DIMENSIONoperator*<double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< double, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< double, CAPD_DEFAULT_DIMENSIONoperator*<double, CAPD_DEFAULT_DIMENSION > (const double &, const ColumnVector< double, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< double, CAPD_DEFAULT_DIMENSIONoperator*<double, CAPD_DEFAULT_DIMENSION > (const ColumnVector< double, CAPD_DEFAULT_DIMENSION > &, const double &)
 
template Vector< double, CAPD_DEFAULT_DIMENSIONoperator/<double, CAPD_DEFAULT_DIMENSION > (const ColumnVector< double, CAPD_DEFAULT_DIMENSION > &, const double &)
 
template std::ostream & operator<<< double, CAPD_DEFAULT_DIMENSION > (std::ostream &, const ColumnVector< double, CAPD_DEFAULT_DIMENSION > &)
 
template Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > & multiplyAssignObjectScalarAddObject (Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, double const &, Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > const &)
 
template Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > & multiplyAssignObjectScalarAddObject (Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, long double const &, Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > const &)
 
template std::string cppReprezentation (Matrix< int, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > const &, std::string const &, std::string const &)
 
template std::string cppReprezentation (Matrix< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > const &, std::string const &, std::string const &)
 
template Vector< double, CAPD_DEFAULT_DIMENSIONabs< double, CAPD_DEFAULT_DIMENSION > (const Vector< double, CAPD_DEFAULT_DIMENSION > &v)
 
template Vector< double, CAPD_DEFAULT_DIMENSIONoperator-<double, CAPD_DEFAULT_DIMENSION > (const Vector< double, CAPD_DEFAULT_DIMENSION > &v)
 
template Vector< double, CAPD_DEFAULT_DIMENSIONoperator+<double, CAPD_DEFAULT_DIMENSION > (const Vector< double, CAPD_DEFAULT_DIMENSION > &v1, const Vector< double, CAPD_DEFAULT_DIMENSION > &v2)
 
template Vector< double, CAPD_DEFAULT_DIMENSIONoperator-<double, CAPD_DEFAULT_DIMENSION > (const Vector< double, CAPD_DEFAULT_DIMENSION > &v1, const Vector< double, CAPD_DEFAULT_DIMENSION > &v2)
 
template double operator*<double, CAPD_DEFAULT_DIMENSION > (const Vector< double, CAPD_DEFAULT_DIMENSION > &v1, const Vector< double, CAPD_DEFAULT_DIMENSION > &v2)
 
template Vector< double, CAPD_DEFAULT_DIMENSIONoperator*<double, double, CAPD_DEFAULT_DIMENSION > (const Vector< double, CAPD_DEFAULT_DIMENSION > &v, const double &s)
 
template Vector< double, CAPD_DEFAULT_DIMENSIONoperator*<double, double, CAPD_DEFAULT_DIMENSION > (const double &s, const Vector< double, CAPD_DEFAULT_DIMENSION > &v)
 
template Vector< double, CAPD_DEFAULT_DIMENSIONoperator/<double, double, CAPD_DEFAULT_DIMENSION > (const Vector< double, CAPD_DEFAULT_DIMENSION > &v, const double &s)
 
template Vector< double, CAPD_DEFAULT_DIMENSIONoperator*<double, long, CAPD_DEFAULT_DIMENSION > (const Vector< double, CAPD_DEFAULT_DIMENSION > &v, const long &s)
 
template Vector< double, CAPD_DEFAULT_DIMENSIONoperator*<double, long, CAPD_DEFAULT_DIMENSION > (const long &s, const Vector< double, CAPD_DEFAULT_DIMENSION > &v)
 
template Vector< double, CAPD_DEFAULT_DIMENSIONoperator/<double, long, CAPD_DEFAULT_DIMENSION > (const Vector< double, CAPD_DEFAULT_DIMENSION > &v, const long &s)
 
template Vector< double, CAPD_DEFAULT_DIMENSIONoperator*<double, int, CAPD_DEFAULT_DIMENSION > (const Vector< double, CAPD_DEFAULT_DIMENSION > &v, const int &s)
 
template Vector< double, CAPD_DEFAULT_DIMENSIONoperator*<double, int, CAPD_DEFAULT_DIMENSION > (const int &s, const Vector< double, CAPD_DEFAULT_DIMENSION > &v)
 
template Vector< double, CAPD_DEFAULT_DIMENSIONoperator/<double, int, CAPD_DEFAULT_DIMENSION > (const Vector< double, CAPD_DEFAULT_DIMENSION > &v, const int &s)
 
template Vector< double, CAPD_DEFAULT_DIMENSIONoperator+<double, CAPD_DEFAULT_DIMENSION > (const Vector< double, CAPD_DEFAULT_DIMENSION > &v, const double &s)
 
template Vector< double, CAPD_DEFAULT_DIMENSIONoperator-<double, CAPD_DEFAULT_DIMENSION > (const Vector< double, CAPD_DEFAULT_DIMENSION > &v, const double &s)
 
template bool operator<<double, CAPD_DEFAULT_DIMENSION > (const Vector< double, CAPD_DEFAULT_DIMENSION > &v1, const Vector< double, CAPD_DEFAULT_DIMENSION > &v2)
 
template bool operator><double, CAPD_DEFAULT_DIMENSION > (const Vector< double, CAPD_DEFAULT_DIMENSION > &v1, const Vector< double, CAPD_DEFAULT_DIMENSION > &v2)
 
template bool operator<=< double, CAPD_DEFAULT_DIMENSION > (const Vector< double, CAPD_DEFAULT_DIMENSION > &v1, const Vector< double, CAPD_DEFAULT_DIMENSION > &v2)
 
template bool operator>=< double, CAPD_DEFAULT_DIMENSION > (const Vector< double, CAPD_DEFAULT_DIMENSION > &v1, const Vector< double, CAPD_DEFAULT_DIMENSION > &v2)
 
template std::ostream & operator<<< double, CAPD_DEFAULT_DIMENSION > (std::ostream &out, const Vector< double, CAPD_DEFAULT_DIMENSION > &v)
 
template std::istream & operator>>< double, CAPD_DEFAULT_DIMENSION > (std::istream &inp, Vector< double, CAPD_DEFAULT_DIMENSION > &v)
 
template void subtractObjects (const Vector< double, CAPD_DEFAULT_DIMENSION > &v1, const Vector< double, CAPD_DEFAULT_DIMENSION > &v2, Vector< double, CAPD_DEFAULT_DIMENSION > &result)
 
template void addObjects (const Vector< double, CAPD_DEFAULT_DIMENSION > &v1, const Vector< double, CAPD_DEFAULT_DIMENSION > &v2, Vector< double, CAPD_DEFAULT_DIMENSION > &result)
 
template RowVector< double, CAPD_DEFAULT_DIMENSION > & assignObjectObject (RowVector< double, CAPD_DEFAULT_DIMENSION > &, RowVector< double, CAPD_DEFAULT_DIMENSION > const &)
 
template RowVector< long double, CAPD_DEFAULT_DIMENSION > & assignObjectObject (RowVector< long double, CAPD_DEFAULT_DIMENSION > &, RowVector< long double, CAPD_DEFAULT_DIMENSION > const &)
 
template ColumnVector< double, CAPD_DEFAULT_DIMENSION > & assignObjectObject (ColumnVector< double, CAPD_DEFAULT_DIMENSION > &, ColumnVector< double, CAPD_DEFAULT_DIMENSION > const &)
 
template ColumnVector< double, CAPD_DEFAULT_DIMENSION > & assignObjectObject (ColumnVector< double, CAPD_DEFAULT_DIMENSION > &, Vector< double, CAPD_DEFAULT_DIMENSION > const &)
 
template ColumnVector< long double, CAPD_DEFAULT_DIMENSION > & assignObjectObject (ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &, ColumnVector< long double, CAPD_DEFAULT_DIMENSION > const &)
 
template ColumnVector< long double, CAPD_DEFAULT_DIMENSION > & assignObjectObject (ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &, Vector< long double, CAPD_DEFAULT_DIMENSION > const &)
 
template Vector< double, CAPD_DEFAULT_DIMENSION > & assignObjectObject (Vector< double, CAPD_DEFAULT_DIMENSION > &, Vector< double, CAPD_DEFAULT_DIMENSION > const &)
 
template Vector< double, CAPD_DEFAULT_DIMENSIONmultiplyObjectScalar (RowVector< double, CAPD_DEFAULT_DIMENSION > const &, double const &)
 
template Vector< long double, CAPD_DEFAULT_DIMENSIONmultiplyObjectScalar (RowVector< long double, CAPD_DEFAULT_DIMENSION > const &, long double const &)
 
template RowVector< double, CAPD_DEFAULT_DIMENSION > & divideAssignObjectScalar (RowVector< double, CAPD_DEFAULT_DIMENSION > &, double const &)
 
template RowVector< long double, CAPD_DEFAULT_DIMENSION > & divideAssignObjectScalar (RowVector< long double, CAPD_DEFAULT_DIMENSION > &, long double const &)
 
template Vector< double, CAPD_DEFAULT_DIMENSIONdivideObjectScalar< Vector< double, CAPD_DEFAULT_DIMENSION >, Vector< double, CAPD_DEFAULT_DIMENSION >, long > (Vector< double, CAPD_DEFAULT_DIMENSION > const &, long const &)
 
template Vector< long double, CAPD_DEFAULT_DIMENSIONdivideObjectScalar< Vector< long double, CAPD_DEFAULT_DIMENSION >, Vector< long double, CAPD_DEFAULT_DIMENSION >, long > (Vector< long double, CAPD_DEFAULT_DIMENSION > const &, long const &)
 
template Vector< double, CAPD_DEFAULT_DIMENSIONunaryMinus (ColumnVector< double, CAPD_DEFAULT_DIMENSION > const &)
 
template Vector< long double, CAPD_DEFAULT_DIMENSIONunaryMinus (ColumnVector< long double, CAPD_DEFAULT_DIMENSION > const &)
 
template std::ostream & printVector (std::ostream &str, const ColumnVector< double, CAPD_DEFAULT_DIMENSION > &, int, int)
 
template std::ostream & printVector (std::ostream &str, const ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &, int, int)
 
template std::string cppReprezentation (Vector< double, CAPD_DEFAULT_DIMENSION > const &, std::string const &, std::string const &)
 
template std::string cppReprezentation (Vector< long double, CAPD_DEFAULT_DIMENSION > const &, std::string const &, std::string const &)
 
template Vector< double, CAPD_DEFAULT_DIMENSIONmultiplyObjectScalar (ColumnVector< double, CAPD_DEFAULT_DIMENSION > const &, double const &)
 
template Vector< double, CAPD_DEFAULT_DIMENSIONmultiplyObjectScalar (Vector< double, CAPD_DEFAULT_DIMENSION > const &, double const &)
 
template Vector< double, CAPD_DEFAULT_DIMENSIONmultiplyObjectScalar (Vector< double, CAPD_DEFAULT_DIMENSION > const &, long const &)
 
template Vector< long double, CAPD_DEFAULT_DIMENSIONmultiplyObjectScalar (Vector< long double, CAPD_DEFAULT_DIMENSION > const &, long double const &)
 
template Vector< long double, CAPD_DEFAULT_DIMENSIONmultiplyObjectScalar (Vector< long double, CAPD_DEFAULT_DIMENSION > const &, long const &)
 
template Vector< long double, CAPD_DEFAULT_DIMENSIONmultiplyObjectScalar (ColumnVector< long double, CAPD_DEFAULT_DIMENSION > const &, long double const &)
 
template ColumnVector< double, CAPD_DEFAULT_DIMENSION > & divideAssignObjectScalar (ColumnVector< double, CAPD_DEFAULT_DIMENSION > &, double const &)
 
template ColumnVector< long double, CAPD_DEFAULT_DIMENSION > & divideAssignObjectScalar (ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &, long double const &)
 
template void clear (ColumnVector< double, CAPD_DEFAULT_DIMENSION > &)
 
template void clear (ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< double, CAPD_DEFAULT_DIMENSION > & multiplyAssignObjectScalarAddObject (Vector< double, CAPD_DEFAULT_DIMENSION > &, double const &, Vector< double, CAPD_DEFAULT_DIMENSION > const &)
 
template Vector< long double, CAPD_DEFAULT_DIMENSION > & multiplyAssignObjectScalarAddObject (Vector< long double, CAPD_DEFAULT_DIMENSION > &, long double const &, Vector< long double, CAPD_DEFAULT_DIMENSION > const &)
 
template RowVector< double, CAPD_DEFAULT_DIMENSION > & subtractAssignObjectObject (RowVector< double, CAPD_DEFAULT_DIMENSION > &, Vector< double, CAPD_DEFAULT_DIMENSION > const &)
 
template Vector< double, CAPD_DEFAULT_DIMENSION > & addAssignObjectObject (Vector< double, CAPD_DEFAULT_DIMENSION > &, Vector< double, CAPD_DEFAULT_DIMENSION > const &)
 
template DVector divideObjectScalar (const DVector &v1, const double &s)
 
template Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSIONabs< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSIONoperator-<capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSIONoperator+<capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSIONoperator-<capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSIONoperator*<capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSIONoperator*<capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)
 
template Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSIONoperator*<capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const capd::DInterval &)
 
template Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSIONoperator*<capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const capd::DInterval &, const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSIONoperator/<capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const capd::DInterval &)
 
template Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSIONoperator+<capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const capd::DInterval &)
 
template Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSIONoperator-<capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const capd::DInterval &)
 
template bool operator<<capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template bool operator<=< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSIONTranspose< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template std::ostream & operator<<< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (std::ostream &, const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template void matrixByVector (const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)
 
template void matrixByMatrix (const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template void subtractObjects (const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &v1, const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &v2, Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &result)
 
template void addObjects (const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &v1, const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &v2, Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &result)
 
template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > & addAssignMatrixByVector (Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &u, const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &A, const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &v)
 
template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > & subtractAssignMatrixByVector (Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &u, const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &A, const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &v)
 
template void split< IMatrix, IMatrix > (IMatrix &, IMatrix &)
 
template void split< IMatrix, DMatrix > (const IMatrix &, DMatrix &, IMatrix &)
 
template IMatrix midMatrix< IMatrix > (const IMatrix &)
 
template bool intersection< IMatrix, IMatrix, IMatrix > (const IMatrix &, const IMatrix &, IMatrix &)
 
template IMatrix intervalHull< IMatrix > (const IMatrix &A, const IMatrix &B)
 
template capd::DInterval maxDiam< IMatrix > (const IMatrix &v)
 
template double maxWidth< IMatrix > (const IMatrix &v)
 
template IMatrix diam< IMatrix > (const IMatrix &v)
 
template DMatrix widths< IMatrix > (const IMatrix &v)
 
template bool subset< IMatrix > (const IMatrix &v1, const IMatrix &v2)
 
template bool subsetInterior< IMatrix > (const IMatrix &v1, const IMatrix &v2)
 
template IMatrix intersection< IMatrix > (const IMatrix &v1, const IMatrix &v2)
 
template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSIONoperator+<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, const RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSIONoperator+<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSIONoperator+<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, const RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSIONoperator-<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, const RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSIONoperator-<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSIONoperator-<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, const RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)
 
template capd::DInterval operator*<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, const RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)
 
template capd::DInterval operator*<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)
 
template capd::DInterval operator*<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, const RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSIONoperator-<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSIONoperator*<capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSIONoperator*<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const capd::DInterval &, const RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSIONoperator*<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, const capd::DInterval &)
 
template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSIONoperator/<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, const capd::DInterval &)
 
template std::ostream & operator<<< capd::DInterval, CAPD_DEFAULT_DIMENSION > (std::ostream &, const RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSIONoperator+<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSIONoperator+<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSIONoperator+<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSIONoperator-<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSIONoperator-<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSIONoperator-<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)
 
template capd::DInterval operator*<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)
 
template capd::DInterval operator*<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)
 
template capd::DInterval operator*<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSIONoperator-<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSIONoperator*<capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSIONoperator*<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const capd::DInterval &, const ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSIONoperator*<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, const capd::DInterval &)
 
template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSIONoperator/<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, const capd::DInterval &)
 
template std::ostream & operator<<< capd::DInterval, CAPD_DEFAULT_DIMENSION > (std::ostream &, const ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)
 
template IMatrixassignFromScalar (IMatrix &, capd::DInterval const &)
 
template IMatrix multiplyObjectScalar (IMatrix const &, capd::DInterval const &)
 
template Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > & multiplyAssignObjectScalarAddObject (Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, capd::DInterval const &, Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > const &)
 
template bool equal (capd::vectalg::Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > const &, capd::vectalg::Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > const &)
 
template Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSIONdivideObjectScalar (Matrix< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > const &, capd::DInterval const &)
 
template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSIONabs< capd::DInterval, CAPD_DEFAULT_DIMENSION > (const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &v)
 
template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSIONoperator-<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &v)
 
template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSIONoperator+<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &v1, const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &v2)
 
template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSIONoperator-<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &v1, const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &v2)
 
template capd::DInterval operator*<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &v1, const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &v2)
 
template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSIONoperator*<capd::DInterval, capd::DInterval, CAPD_DEFAULT_DIMENSION > (const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &v, const capd::DInterval &s)
 
template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSIONoperator*<capd::DInterval, capd::DInterval, CAPD_DEFAULT_DIMENSION > (const capd::DInterval &s, const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &v)
 
template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSIONoperator/<capd::DInterval, capd::DInterval, CAPD_DEFAULT_DIMENSION > (const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &v, const capd::DInterval &s)
 
template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSIONoperator*<capd::DInterval, double, CAPD_DEFAULT_DIMENSION > (const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &v, const double &s)
 
template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSIONoperator*<capd::DInterval, double, CAPD_DEFAULT_DIMENSION > (const double &s, const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &v)
 
template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSIONoperator/<capd::DInterval, double, CAPD_DEFAULT_DIMENSION > (const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &v, const double &s)
 
template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSIONoperator*<capd::DInterval, long, CAPD_DEFAULT_DIMENSION > (const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &v, const long &s)
 
template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSIONoperator*<capd::DInterval, long, CAPD_DEFAULT_DIMENSION > (const long &s, const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &v)
 
template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSIONoperator/<capd::DInterval, long, CAPD_DEFAULT_DIMENSION > (const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &v, const long &s)
 
template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSIONoperator*<capd::DInterval, int, CAPD_DEFAULT_DIMENSION > (const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &v, const int &s)
 
template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSIONoperator*<capd::DInterval, int, CAPD_DEFAULT_DIMENSION > (const int &s, const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &v)
 
template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSIONoperator/<capd::DInterval, int, CAPD_DEFAULT_DIMENSION > (const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &v, const int &s)
 
template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSIONoperator+<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &v, const capd::DInterval &s)
 
template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSIONoperator-<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &v, const capd::DInterval &s)
 
template bool operator<<capd::DInterval, CAPD_DEFAULT_DIMENSION > (const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &v1, const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &v2)
 
template bool operator<=< capd::DInterval, CAPD_DEFAULT_DIMENSION > (const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &v1, const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &v2)
 
template std::ostream & operator<<< capd::DInterval, CAPD_DEFAULT_DIMENSION > (std::ostream &out, const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &v)
 
template void subtractObjects (const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)
 
template void addObjects (const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)
 
template void addObjects (const Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSIONunaryMinus (ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > const &)
 
template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > & addAssignObjectScalar (Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &v1, const capd::DInterval &)
 
template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSIONaddObjectScalar (Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > const &, capd::DInterval const &)
 
template void subtractObjects (Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > const &, ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > const &, Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)
 
template ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > & assignObjectObject (ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > const &)
 
template ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > & assignObjectObject (ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > const &)
 
template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > & assignObjectObject (Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, Vector< double, CAPD_DEFAULT_DIMENSION > const &)
 
template bool normalize (ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)
 
template RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > & assignObjectObject (RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > const &)
 
template RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > & assignObjectObject (RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > const &)
 
template IVector intervalHull< IVector > (const IVector &A, const IVector &B)
 
template void split< IVector, IVector > (IVector &v, IVector &rv)
 
template void split< IVector, DVector > (const IVector &v, DVector &, IVector &rv)
 
template IVector midVector< IVector > (const IVector &v)
 
template IVector leftVector< IVector > (const IVector &v)
 
template IVector rightVector< IVector > (const IVector &v)
 
template capd::DInterval maxDiam< IVector > (const IVector &v)
 
template double maxWidth< IVector > (const IVector &v)
 
template IVector diam< IVector > (const IVector &v)
 
template DVector widths< IVector > (const IVector &v)
 
template IVector intervalBall< IVector > (const IVector &iv, const capd::DInterval &r)
 
template capd::DInterval solveAffineInclusion< IVector > (const IVector &a, const IVector &p, const IVector &c)
 
template capd::DInterval solveAffineInclusion< IVector > (const IVector &a, const IVector &p, const IVector &c, int &)
 
template bool subset< IVector > (const IVector &v1, const IVector &v2)
 
template bool subsetInterior< IVector > (const IVector &v1, const IVector &v2)
 
template IVector intersection< IVector > (const IVector &v1, const IVector &v2)
 
template std::string vectorToString< IVector > (const IVector &v, int firstIndex, int lastIndex, int precision)
 
template std::ostream & printVector< IVector > (std::ostream &str, const IVector &v, int firstIndex, int lastIndex)
 
template std::ostream & printVector (std::ostream &str, const ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, int, int)
 
template IVector multiplyObjectScalar (ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > const &, capd::DInterval const &)
 
template IVector multiplyObjectScalar (RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > const &, capd::DInterval const &)
 
template IVector multiplyObjectScalar (IVector const &, capd::DInterval const &)
 
template IVector multiplyObjectScalar (IVector const &, long const &)
 
template IVector divideObjectScalar (IVector const &, long const &)
 
template IVector divideObjectScalar (IVector const &, capd::DInterval const &)
 
template ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > & divideAssignObjectScalar (ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, capd::DInterval const &)
 
template RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > & divideAssignObjectScalar (RowVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &, capd::DInterval const &)
 
template IVectormultiplyAssignObjectScalarAddObject (IVector &, capd::DInterval const &, IVector const &)
 
template void clear (ColumnVector< capd::DInterval, CAPD_DEFAULT_DIMENSION > &)
 
template bool equal (Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > const &, Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > const &)
 
template Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION >::ScalarType scalarProduct (Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > const &, Vector< capd::DInterval, CAPD_DEFAULT_DIMENSION > const &)
 
template Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSIONabs< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSIONoperator-<long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSIONoperator+<long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSIONoperator-<long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSIONoperator*<long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< long double, CAPD_DEFAULT_DIMENSIONoperator*<long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Vector< long double, CAPD_DEFAULT_DIMENSION > &)
 
template Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSIONoperator*<long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const long double &)
 
template Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSIONoperator*<long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const long double &, const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSIONoperator/<long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const long double &)
 
template Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSIONoperator+<long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const long double &)
 
template Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSIONoperator-<long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const long double &)
 
template bool operator<<long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template bool operator><long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template bool operator<=< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template bool operator>=< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSIONTranspose< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template std::ostream & operator<<< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (std::ostream &, const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template std::istream & operator>>< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (std::istream &, Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template void matrixByVector (const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Vector< long double, CAPD_DEFAULT_DIMENSION > &, Vector< long double, CAPD_DEFAULT_DIMENSION > &)
 
template void matrixByMatrix (const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template void subtractObjects (const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &v1, const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &v2, Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &result)
 
template void addObjects (const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &v1, const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &v2, Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &result)
 
template Vector< long double, CAPD_DEFAULT_DIMENSION > & addAssignMatrixByVector (Vector< long double, CAPD_DEFAULT_DIMENSION > &u, const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &A, const Vector< long double, CAPD_DEFAULT_DIMENSION > &v)
 
template Vector< long double, CAPD_DEFAULT_DIMENSION > & subtractAssignMatrixByVector (Vector< long double, CAPD_DEFAULT_DIMENSION > &u, const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &A, const Vector< long double, CAPD_DEFAULT_DIMENSION > &v)
 
template Vector< long double, CAPD_DEFAULT_DIMENSIONoperator+<long double, CAPD_DEFAULT_DIMENSION > (const Vector< long double, CAPD_DEFAULT_DIMENSION > &, const RowVector< long double, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< long double, CAPD_DEFAULT_DIMENSIONoperator+<long double, CAPD_DEFAULT_DIMENSION > (const RowVector< long double, CAPD_DEFAULT_DIMENSION > &, const Vector< long double, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< long double, CAPD_DEFAULT_DIMENSIONoperator+<long double, CAPD_DEFAULT_DIMENSION > (const RowVector< long double, CAPD_DEFAULT_DIMENSION > &, const RowVector< long double, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< long double, CAPD_DEFAULT_DIMENSIONoperator-<long double, CAPD_DEFAULT_DIMENSION > (const Vector< long double, CAPD_DEFAULT_DIMENSION > &, const RowVector< long double, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< long double, CAPD_DEFAULT_DIMENSIONoperator-<long double, CAPD_DEFAULT_DIMENSION > (const RowVector< long double, CAPD_DEFAULT_DIMENSION > &, const Vector< long double, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< long double, CAPD_DEFAULT_DIMENSIONoperator-<long double, CAPD_DEFAULT_DIMENSION > (const RowVector< long double, CAPD_DEFAULT_DIMENSION > &, const RowVector< long double, CAPD_DEFAULT_DIMENSION > &)
 
template long double operator*<long double, CAPD_DEFAULT_DIMENSION > (const Vector< long double, CAPD_DEFAULT_DIMENSION > &, const RowVector< long double, CAPD_DEFAULT_DIMENSION > &)
 
template long double operator*<long double, CAPD_DEFAULT_DIMENSION > (const RowVector< long double, CAPD_DEFAULT_DIMENSION > &, const Vector< long double, CAPD_DEFAULT_DIMENSION > &)
 
template long double operator*<long double, CAPD_DEFAULT_DIMENSION > (const RowVector< long double, CAPD_DEFAULT_DIMENSION > &, const RowVector< long double, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< long double, CAPD_DEFAULT_DIMENSIONoperator-<long double, CAPD_DEFAULT_DIMENSION > (const RowVector< long double, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< long double, CAPD_DEFAULT_DIMENSIONoperator*<long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const RowVector< long double, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< long double, CAPD_DEFAULT_DIMENSIONoperator*<long double, CAPD_DEFAULT_DIMENSION > (const long double &, const RowVector< long double, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< long double, CAPD_DEFAULT_DIMENSIONoperator*<long double, CAPD_DEFAULT_DIMENSION > (const RowVector< long double, CAPD_DEFAULT_DIMENSION > &, const long double &)
 
template Vector< long double, CAPD_DEFAULT_DIMENSIONoperator/<long double, CAPD_DEFAULT_DIMENSION > (const RowVector< long double, CAPD_DEFAULT_DIMENSION > &, const long double &)
 
template std::ostream & operator<<< long double, CAPD_DEFAULT_DIMENSION > (std::ostream &, const RowVector< long double, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< long double, CAPD_DEFAULT_DIMENSIONoperator+<long double, CAPD_DEFAULT_DIMENSION > (const Vector< long double, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< long double, CAPD_DEFAULT_DIMENSIONoperator+<long double, CAPD_DEFAULT_DIMENSION > (const ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &, const Vector< long double, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< long double, CAPD_DEFAULT_DIMENSIONoperator+<long double, CAPD_DEFAULT_DIMENSION > (const ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< long double, CAPD_DEFAULT_DIMENSIONoperator-<long double, CAPD_DEFAULT_DIMENSION > (const Vector< long double, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< long double, CAPD_DEFAULT_DIMENSIONoperator-<long double, CAPD_DEFAULT_DIMENSION > (const ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &, const Vector< long double, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< long double, CAPD_DEFAULT_DIMENSIONoperator-<long double, CAPD_DEFAULT_DIMENSION > (const ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &)
 
template long double operator*<long double, CAPD_DEFAULT_DIMENSION > (const Vector< long double, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &)
 
template long double operator*<long double, CAPD_DEFAULT_DIMENSION > (const ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &, const Vector< long double, CAPD_DEFAULT_DIMENSION > &)
 
template long double operator*<long double, CAPD_DEFAULT_DIMENSION > (const ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< long double, CAPD_DEFAULT_DIMENSIONoperator-<long double, CAPD_DEFAULT_DIMENSION > (const ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< long double, CAPD_DEFAULT_DIMENSIONoperator*<long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< long double, CAPD_DEFAULT_DIMENSIONoperator*<long double, CAPD_DEFAULT_DIMENSION > (const long double &, const ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< long double, CAPD_DEFAULT_DIMENSIONoperator*<long double, CAPD_DEFAULT_DIMENSION > (const ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &, const long double &)
 
template Vector< long double, CAPD_DEFAULT_DIMENSIONoperator/<long double, CAPD_DEFAULT_DIMENSION > (const ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &, const long double &)
 
template std::ostream & operator<<< long double, CAPD_DEFAULT_DIMENSION > (std::ostream &, const ColumnVector< long double, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< long double, CAPD_DEFAULT_DIMENSIONabs< long double, CAPD_DEFAULT_DIMENSION > (const Vector< long double, CAPD_DEFAULT_DIMENSION > &v)
 
template Vector< long double, CAPD_DEFAULT_DIMENSIONoperator-<long double, CAPD_DEFAULT_DIMENSION > (const Vector< long double, CAPD_DEFAULT_DIMENSION > &v)
 
template Vector< long double, CAPD_DEFAULT_DIMENSIONoperator+<long double, CAPD_DEFAULT_DIMENSION > (const Vector< long double, CAPD_DEFAULT_DIMENSION > &v1, const Vector< long double, CAPD_DEFAULT_DIMENSION > &v2)
 
template Vector< long double, CAPD_DEFAULT_DIMENSIONoperator-<long double, CAPD_DEFAULT_DIMENSION > (const Vector< long double, CAPD_DEFAULT_DIMENSION > &v1, const Vector< long double, CAPD_DEFAULT_DIMENSION > &v2)
 
template long double operator*<long double, CAPD_DEFAULT_DIMENSION > (const Vector< long double, CAPD_DEFAULT_DIMENSION > &v1, const Vector< long double, CAPD_DEFAULT_DIMENSION > &v2)
 
template Vector< long double, CAPD_DEFAULT_DIMENSIONoperator*<long double, long double, CAPD_DEFAULT_DIMENSION > (const Vector< long double, CAPD_DEFAULT_DIMENSION > &v, const long double &s)
 
template Vector< long double, CAPD_DEFAULT_DIMENSIONoperator*<long double, long double, CAPD_DEFAULT_DIMENSION > (const long double &s, const Vector< long double, CAPD_DEFAULT_DIMENSION > &v)
 
template Vector< long double, CAPD_DEFAULT_DIMENSIONoperator/<long double, long double, CAPD_DEFAULT_DIMENSION > (const Vector< long double, CAPD_DEFAULT_DIMENSION > &v, const long double &s)
 
template Vector< long double, CAPD_DEFAULT_DIMENSIONoperator*<long double, long, CAPD_DEFAULT_DIMENSION > (const Vector< long double, CAPD_DEFAULT_DIMENSION > &v, const long &s)
 
template Vector< long double, CAPD_DEFAULT_DIMENSIONoperator*<long double, long, CAPD_DEFAULT_DIMENSION > (const long &s, const Vector< long double, CAPD_DEFAULT_DIMENSION > &v)
 
template Vector< long double, CAPD_DEFAULT_DIMENSIONoperator/<long double, long, CAPD_DEFAULT_DIMENSION > (const Vector< long double, CAPD_DEFAULT_DIMENSION > &v, const long &s)
 
template Vector< long double, CAPD_DEFAULT_DIMENSIONoperator*<long double, int, CAPD_DEFAULT_DIMENSION > (const Vector< long double, CAPD_DEFAULT_DIMENSION > &v, const int &s)
 
template Vector< long double, CAPD_DEFAULT_DIMENSIONoperator*<long double, int, CAPD_DEFAULT_DIMENSION > (const int &s, const Vector< long double, CAPD_DEFAULT_DIMENSION > &v)
 
template Vector< long double, CAPD_DEFAULT_DIMENSIONoperator/<long double, int, CAPD_DEFAULT_DIMENSION > (const Vector< long double, CAPD_DEFAULT_DIMENSION > &v, const int &s)
 
template Vector< long double, CAPD_DEFAULT_DIMENSIONoperator+<long double, CAPD_DEFAULT_DIMENSION > (const Vector< long double, CAPD_DEFAULT_DIMENSION > &v, const long double &s)
 
template Vector< long double, CAPD_DEFAULT_DIMENSIONoperator-<long double, CAPD_DEFAULT_DIMENSION > (const Vector< long double, CAPD_DEFAULT_DIMENSION > &v, const long double &s)
 
template bool operator<<long double, CAPD_DEFAULT_DIMENSION > (const Vector< long double, CAPD_DEFAULT_DIMENSION > &v1, const Vector< long double, CAPD_DEFAULT_DIMENSION > &v2)
 
template bool operator><long double, CAPD_DEFAULT_DIMENSION > (const Vector< long double, CAPD_DEFAULT_DIMENSION > &v1, const Vector< long double, CAPD_DEFAULT_DIMENSION > &v2)
 
template bool operator<=< long double, CAPD_DEFAULT_DIMENSION > (const Vector< long double, CAPD_DEFAULT_DIMENSION > &v1, const Vector< long double, CAPD_DEFAULT_DIMENSION > &v2)
 
template bool operator>=< long double, CAPD_DEFAULT_DIMENSION > (const Vector< long double, CAPD_DEFAULT_DIMENSION > &v1, const Vector< long double, CAPD_DEFAULT_DIMENSION > &v2)
 
template std::ostream & operator<<< long double, CAPD_DEFAULT_DIMENSION > (std::ostream &out, const Vector< long double, CAPD_DEFAULT_DIMENSION > &v)
 
template std::istream & operator>>< long double, CAPD_DEFAULT_DIMENSION > (std::istream &inp, Vector< long double, CAPD_DEFAULT_DIMENSION > &v)
 
template void subtractObjects (const Vector< long double, CAPD_DEFAULT_DIMENSION > &v1, const Vector< long double, CAPD_DEFAULT_DIMENSION > &v2, Vector< long double, CAPD_DEFAULT_DIMENSION > &result)
 
template void addObjects (const Vector< long double, CAPD_DEFAULT_DIMENSION > &v1, const Vector< long double, CAPD_DEFAULT_DIMENSION > &v2, Vector< long double, CAPD_DEFAULT_DIMENSION > &result)
 
template LDVector divideObjectScalar (const LDVector &v1, const long double &s)
 
int computeNewton (int d, int l)
 
template Vector< int, CAPD_DEFAULT_DIMENSIONabs< int, CAPD_DEFAULT_DIMENSION > (const Vector< int, CAPD_DEFAULT_DIMENSION > &v)
 
template Vector< int, CAPD_DEFAULT_DIMENSIONoperator-<int, CAPD_DEFAULT_DIMENSION > (const Vector< int, CAPD_DEFAULT_DIMENSION > &v)
 
template Vector< int, CAPD_DEFAULT_DIMENSIONoperator+<int, CAPD_DEFAULT_DIMENSION > (const Vector< int, CAPD_DEFAULT_DIMENSION > &v1, const Vector< int, CAPD_DEFAULT_DIMENSION > &v2)
 
template Vector< int, CAPD_DEFAULT_DIMENSIONoperator-<int, CAPD_DEFAULT_DIMENSION > (const Vector< int, CAPD_DEFAULT_DIMENSION > &v1, const Vector< int, CAPD_DEFAULT_DIMENSION > &v2)
 
template int operator*<int, CAPD_DEFAULT_DIMENSION > (const Vector< int, CAPD_DEFAULT_DIMENSION > &v1, const Vector< int, CAPD_DEFAULT_DIMENSION > &v2)
 
template Vector< int, CAPD_DEFAULT_DIMENSIONoperator*<int, int, CAPD_DEFAULT_DIMENSION > (const Vector< int, CAPD_DEFAULT_DIMENSION > &v, const int &s)
 
template Vector< int, CAPD_DEFAULT_DIMENSIONoperator*<int, int, CAPD_DEFAULT_DIMENSION > (const int &s, const Vector< int, CAPD_DEFAULT_DIMENSION > &v)
 
template Vector< int, CAPD_DEFAULT_DIMENSIONoperator/<int, int, CAPD_DEFAULT_DIMENSION > (const Vector< int, CAPD_DEFAULT_DIMENSION > &v, const int &s)
 
template Vector< int, CAPD_DEFAULT_DIMENSIONoperator*<int, long, CAPD_DEFAULT_DIMENSION > (const Vector< int, CAPD_DEFAULT_DIMENSION > &v, const long &s)
 
template Vector< int, CAPD_DEFAULT_DIMENSIONoperator*<int, long, CAPD_DEFAULT_DIMENSION > (const long &s, const Vector< int, CAPD_DEFAULT_DIMENSION > &v)
 
template Vector< int, CAPD_DEFAULT_DIMENSIONoperator/<int, long, CAPD_DEFAULT_DIMENSION > (const Vector< int, CAPD_DEFAULT_DIMENSION > &v, const long &s)
 
template Vector< int, CAPD_DEFAULT_DIMENSIONoperator+<int, CAPD_DEFAULT_DIMENSION > (const Vector< int, CAPD_DEFAULT_DIMENSION > &v, const int &s)
 
template Vector< int, CAPD_DEFAULT_DIMENSIONoperator-<int, CAPD_DEFAULT_DIMENSION > (const Vector< int, CAPD_DEFAULT_DIMENSION > &v, const int &s)
 
template bool operator<<int, CAPD_DEFAULT_DIMENSION > (const Vector< int, CAPD_DEFAULT_DIMENSION > &v1, const Vector< int, CAPD_DEFAULT_DIMENSION > &v2)
 
template bool operator><int, CAPD_DEFAULT_DIMENSION > (const Vector< int, CAPD_DEFAULT_DIMENSION > &v1, const Vector< int, CAPD_DEFAULT_DIMENSION > &v2)
 
template bool operator<=< int, CAPD_DEFAULT_DIMENSION > (const Vector< int, CAPD_DEFAULT_DIMENSION > &v1, const Vector< int, CAPD_DEFAULT_DIMENSION > &v2)
 
template bool operator>=< int, CAPD_DEFAULT_DIMENSION > (const Vector< int, CAPD_DEFAULT_DIMENSION > &v1, const Vector< int, CAPD_DEFAULT_DIMENSION > &v2)
 
template std::ostream & operator<<< int, CAPD_DEFAULT_DIMENSION > (std::ostream &out, const Vector< int, CAPD_DEFAULT_DIMENSION > &v)
 
template std::istream & operator>>< int, CAPD_DEFAULT_DIMENSION > (std::istream &inp, Vector< int, CAPD_DEFAULT_DIMENSION > &v)
 
template void subtractObjects (const Vector< int, CAPD_DEFAULT_DIMENSION > &v1, const Vector< int, CAPD_DEFAULT_DIMENSION > &v2, Vector< int, CAPD_DEFAULT_DIMENSION > &result)
 
template void addObjects (const Vector< int, CAPD_DEFAULT_DIMENSION > &v1, const Vector< int, CAPD_DEFAULT_DIMENSION > &v2, Vector< int, CAPD_DEFAULT_DIMENSION > &result)
 
template std::string cppReprezentation (Vector< int, CAPD_DEFAULT_DIMENSION > const &, std::string const &, std::string const &)
 
template Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSIONabs< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSIONoperator-<MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSIONoperator+<MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSIONoperator-<MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSIONoperator*<MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< MpFloat, CAPD_DEFAULT_DIMENSIONoperator*<MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &)
 
template Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSIONoperator*<MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const MpFloat &)
 
template Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSIONoperator*<MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const MpFloat &, const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSIONoperator/<MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const MpFloat &)
 
template Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSIONoperator+<MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const MpFloat &)
 
template Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSIONoperator-<MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const MpFloat &)
 
template bool operator<<MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template bool operator><MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template bool operator<=< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template bool operator>=< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSIONTranspose< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template std::ostream & operator<<< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (std::ostream &, const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template std::istream & operator>>< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (std::istream &, Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template void matrixByVector (const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &, Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &)
 
template void matrixByMatrix (const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template void subtractObjects (const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &v1, const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &v2, Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &result)
 
template void addObjects (const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &v1, const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &v2, Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &result)
 
template Vector< MpFloat, CAPD_DEFAULT_DIMENSION > & addAssignMatrixByVector (Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &u, const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &A, const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v)
 
template Vector< MpFloat, CAPD_DEFAULT_DIMENSION > & subtractAssignMatrixByVector (Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &u, const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &A, const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v)
 
template Vector< MpFloat, CAPD_DEFAULT_DIMENSIONoperator+<MpFloat, CAPD_DEFAULT_DIMENSION > (const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &, const RowVector< MpFloat, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< MpFloat, CAPD_DEFAULT_DIMENSIONoperator+<MpFloat, CAPD_DEFAULT_DIMENSION > (const RowVector< MpFloat, CAPD_DEFAULT_DIMENSION > &, const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< MpFloat, CAPD_DEFAULT_DIMENSIONoperator+<MpFloat, CAPD_DEFAULT_DIMENSION > (const RowVector< MpFloat, CAPD_DEFAULT_DIMENSION > &, const RowVector< MpFloat, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< MpFloat, CAPD_DEFAULT_DIMENSIONoperator-<MpFloat, CAPD_DEFAULT_DIMENSION > (const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &, const RowVector< MpFloat, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< MpFloat, CAPD_DEFAULT_DIMENSIONoperator-<MpFloat, CAPD_DEFAULT_DIMENSION > (const RowVector< MpFloat, CAPD_DEFAULT_DIMENSION > &, const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< MpFloat, CAPD_DEFAULT_DIMENSIONoperator-<MpFloat, CAPD_DEFAULT_DIMENSION > (const RowVector< MpFloat, CAPD_DEFAULT_DIMENSION > &, const RowVector< MpFloat, CAPD_DEFAULT_DIMENSION > &)
 
template MpFloat operator*<MpFloat, CAPD_DEFAULT_DIMENSION > (const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &, const RowVector< MpFloat, CAPD_DEFAULT_DIMENSION > &)
 
template MpFloat operator*<MpFloat, CAPD_DEFAULT_DIMENSION > (const RowVector< MpFloat, CAPD_DEFAULT_DIMENSION > &, const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &)
 
template MpFloat operator*<MpFloat, CAPD_DEFAULT_DIMENSION > (const RowVector< MpFloat, CAPD_DEFAULT_DIMENSION > &, const RowVector< MpFloat, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< MpFloat, CAPD_DEFAULT_DIMENSIONoperator-<MpFloat, CAPD_DEFAULT_DIMENSION > (const RowVector< MpFloat, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< MpFloat, CAPD_DEFAULT_DIMENSIONoperator*<MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const RowVector< MpFloat, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< MpFloat, CAPD_DEFAULT_DIMENSIONoperator*<MpFloat, CAPD_DEFAULT_DIMENSION > (const MpFloat &, const RowVector< MpFloat, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< MpFloat, CAPD_DEFAULT_DIMENSIONoperator*<MpFloat, CAPD_DEFAULT_DIMENSION > (const RowVector< MpFloat, CAPD_DEFAULT_DIMENSION > &, const MpFloat &)
 
template Vector< MpFloat, CAPD_DEFAULT_DIMENSIONoperator/<MpFloat, CAPD_DEFAULT_DIMENSION > (const RowVector< MpFloat, CAPD_DEFAULT_DIMENSION > &, const MpFloat &)
 
template std::ostream & operator<<< MpFloat, CAPD_DEFAULT_DIMENSION > (std::ostream &, const RowVector< MpFloat, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< MpFloat, CAPD_DEFAULT_DIMENSIONoperator+<MpFloat, CAPD_DEFAULT_DIMENSION > (const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< MpFloat, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< MpFloat, CAPD_DEFAULT_DIMENSIONoperator+<MpFloat, CAPD_DEFAULT_DIMENSION > (const ColumnVector< MpFloat, CAPD_DEFAULT_DIMENSION > &, const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< MpFloat, CAPD_DEFAULT_DIMENSIONoperator+<MpFloat, CAPD_DEFAULT_DIMENSION > (const ColumnVector< MpFloat, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< MpFloat, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< MpFloat, CAPD_DEFAULT_DIMENSIONoperator-<MpFloat, CAPD_DEFAULT_DIMENSION > (const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< MpFloat, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< MpFloat, CAPD_DEFAULT_DIMENSIONoperator-<MpFloat, CAPD_DEFAULT_DIMENSION > (const ColumnVector< MpFloat, CAPD_DEFAULT_DIMENSION > &, const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< MpFloat, CAPD_DEFAULT_DIMENSIONoperator-<MpFloat, CAPD_DEFAULT_DIMENSION > (const ColumnVector< MpFloat, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< MpFloat, CAPD_DEFAULT_DIMENSION > &)
 
template MpFloat operator*<MpFloat, CAPD_DEFAULT_DIMENSION > (const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< MpFloat, CAPD_DEFAULT_DIMENSION > &)
 
template MpFloat operator*<MpFloat, CAPD_DEFAULT_DIMENSION > (const ColumnVector< MpFloat, CAPD_DEFAULT_DIMENSION > &, const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &)
 
template MpFloat operator*<MpFloat, CAPD_DEFAULT_DIMENSION > (const ColumnVector< MpFloat, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< MpFloat, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< MpFloat, CAPD_DEFAULT_DIMENSIONoperator-<MpFloat, CAPD_DEFAULT_DIMENSION > (const ColumnVector< MpFloat, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< MpFloat, CAPD_DEFAULT_DIMENSIONoperator*<MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< MpFloat, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< MpFloat, CAPD_DEFAULT_DIMENSIONoperator*<MpFloat, CAPD_DEFAULT_DIMENSION > (const MpFloat &, const ColumnVector< MpFloat, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< MpFloat, CAPD_DEFAULT_DIMENSIONoperator*<MpFloat, CAPD_DEFAULT_DIMENSION > (const ColumnVector< MpFloat, CAPD_DEFAULT_DIMENSION > &, const MpFloat &)
 
template Vector< MpFloat, CAPD_DEFAULT_DIMENSIONoperator/<MpFloat, CAPD_DEFAULT_DIMENSION > (const ColumnVector< MpFloat, CAPD_DEFAULT_DIMENSION > &, const MpFloat &)
 
template std::ostream & operator<<< MpFloat, CAPD_DEFAULT_DIMENSION > (std::ostream &, const ColumnVector< MpFloat, CAPD_DEFAULT_DIMENSION > &)
 
template std::string cppReprezentation (Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > const &, std::string const &, std::string const &)
 
template Vector< MpFloat, CAPD_DEFAULT_DIMENSIONabs< MpFloat, CAPD_DEFAULT_DIMENSION > (const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v)
 
template Vector< MpFloat, CAPD_DEFAULT_DIMENSIONoperator-<MpFloat, CAPD_DEFAULT_DIMENSION > (const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v)
 
template Vector< MpFloat, CAPD_DEFAULT_DIMENSIONoperator+<MpFloat, CAPD_DEFAULT_DIMENSION > (const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v1, const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v2)
 
template Vector< MpFloat, CAPD_DEFAULT_DIMENSIONoperator-<MpFloat, CAPD_DEFAULT_DIMENSION > (const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v1, const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v2)
 
template MpFloat operator*<MpFloat, CAPD_DEFAULT_DIMENSION > (const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v1, const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v2)
 
template Vector< MpFloat, CAPD_DEFAULT_DIMENSIONoperator*<MpFloat, MpFloat, CAPD_DEFAULT_DIMENSION > (const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v, const MpFloat &s)
 
template Vector< MpFloat, CAPD_DEFAULT_DIMENSIONoperator*<MpFloat, MpFloat, CAPD_DEFAULT_DIMENSION > (const MpFloat &s, const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v)
 
template Vector< MpFloat, CAPD_DEFAULT_DIMENSIONoperator/<MpFloat, MpFloat, CAPD_DEFAULT_DIMENSION > (const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v, const MpFloat &s)
 
template Vector< MpFloat, CAPD_DEFAULT_DIMENSIONoperator*<MpFloat, long, CAPD_DEFAULT_DIMENSION > (const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v, const long &s)
 
template Vector< MpFloat, CAPD_DEFAULT_DIMENSIONoperator*<MpFloat, long, CAPD_DEFAULT_DIMENSION > (const long &s, const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v)
 
template Vector< MpFloat, CAPD_DEFAULT_DIMENSIONoperator/<MpFloat, long, CAPD_DEFAULT_DIMENSION > (const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v, const long &s)
 
template Vector< MpFloat, CAPD_DEFAULT_DIMENSIONoperator*<MpFloat, int, CAPD_DEFAULT_DIMENSION > (const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v, const int &s)
 
template Vector< MpFloat, CAPD_DEFAULT_DIMENSIONoperator*<MpFloat, int, CAPD_DEFAULT_DIMENSION > (const int &s, const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v)
 
template Vector< MpFloat, CAPD_DEFAULT_DIMENSIONoperator/<MpFloat, int, CAPD_DEFAULT_DIMENSION > (const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v, const int &s)
 
template Vector< MpFloat, CAPD_DEFAULT_DIMENSIONoperator+<MpFloat, CAPD_DEFAULT_DIMENSION > (const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v, const MpFloat &s)
 
template Vector< MpFloat, CAPD_DEFAULT_DIMENSIONoperator-<MpFloat, CAPD_DEFAULT_DIMENSION > (const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v, const MpFloat &s)
 
template bool operator<<MpFloat, CAPD_DEFAULT_DIMENSION > (const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v1, const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v2)
 
template bool operator><MpFloat, CAPD_DEFAULT_DIMENSION > (const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v1, const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v2)
 
template bool operator<=< MpFloat, CAPD_DEFAULT_DIMENSION > (const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v1, const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v2)
 
template bool operator>=< MpFloat, CAPD_DEFAULT_DIMENSION > (const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v1, const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v2)
 
template std::ostream & operator<<< MpFloat, CAPD_DEFAULT_DIMENSION > (std::ostream &out, const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v)
 
template std::istream & operator>>< MpFloat, CAPD_DEFAULT_DIMENSION > (std::istream &inp, Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v)
 
template void subtractObjects (const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v1, const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v2, Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &result)
 
template void addObjects (const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v1, const Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &v2, Vector< MpFloat, CAPD_DEFAULT_DIMENSION > &result)
 
template Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSIONabs< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSIONoperator-<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSIONoperator+<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSIONoperator-<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSIONoperator*<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< MpInt, CAPD_DEFAULT_DIMENSIONoperator*<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &)
 
template Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSIONoperator*<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const MpInt &)
 
template Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSIONoperator*<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const MpInt &, const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSIONoperator/<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const MpInt &)
 
template Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSIONoperator+<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const MpInt &)
 
template Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSIONoperator-<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const MpInt &)
 
template bool operator<<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template bool operator><MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template bool operator<=< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template bool operator>=< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSIONTranspose< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template std::ostream & operator<<< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (std::ostream &, const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template std::istream & operator>>< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (std::istream &, Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template void matrixByVector (const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &, Vector< MpInt, CAPD_DEFAULT_DIMENSION > &)
 
template void matrixByMatrix (const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &)
 
template void subtractObjects (const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &v1, const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &v2, Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &result)
 
template void addObjects (const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &v1, const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &v2, Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &result)
 
template Vector< MpInt, CAPD_DEFAULT_DIMENSIONoperator+<MpInt, CAPD_DEFAULT_DIMENSION > (const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &, const RowVector< MpInt, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< MpInt, CAPD_DEFAULT_DIMENSIONoperator+<MpInt, CAPD_DEFAULT_DIMENSION > (const RowVector< MpInt, CAPD_DEFAULT_DIMENSION > &, const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< MpInt, CAPD_DEFAULT_DIMENSIONoperator+<MpInt, CAPD_DEFAULT_DIMENSION > (const RowVector< MpInt, CAPD_DEFAULT_DIMENSION > &, const RowVector< MpInt, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< MpInt, CAPD_DEFAULT_DIMENSIONoperator-<MpInt, CAPD_DEFAULT_DIMENSION > (const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &, const RowVector< MpInt, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< MpInt, CAPD_DEFAULT_DIMENSIONoperator-<MpInt, CAPD_DEFAULT_DIMENSION > (const RowVector< MpInt, CAPD_DEFAULT_DIMENSION > &, const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< MpInt, CAPD_DEFAULT_DIMENSIONoperator-<MpInt, CAPD_DEFAULT_DIMENSION > (const RowVector< MpInt, CAPD_DEFAULT_DIMENSION > &, const RowVector< MpInt, CAPD_DEFAULT_DIMENSION > &)
 
template MpInt operator*<MpInt, CAPD_DEFAULT_DIMENSION > (const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &, const RowVector< MpInt, CAPD_DEFAULT_DIMENSION > &)
 
template MpInt operator*<MpInt, CAPD_DEFAULT_DIMENSION > (const RowVector< MpInt, CAPD_DEFAULT_DIMENSION > &, const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &)
 
template MpInt operator*<MpInt, CAPD_DEFAULT_DIMENSION > (const RowVector< MpInt, CAPD_DEFAULT_DIMENSION > &, const RowVector< MpInt, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< MpInt, CAPD_DEFAULT_DIMENSIONoperator-<MpInt, CAPD_DEFAULT_DIMENSION > (const RowVector< MpInt, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< MpInt, CAPD_DEFAULT_DIMENSIONoperator*<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const RowVector< MpInt, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< MpInt, CAPD_DEFAULT_DIMENSIONoperator*<MpInt, CAPD_DEFAULT_DIMENSION > (const MpInt &, const RowVector< MpInt, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< MpInt, CAPD_DEFAULT_DIMENSIONoperator*<MpInt, CAPD_DEFAULT_DIMENSION > (const RowVector< MpInt, CAPD_DEFAULT_DIMENSION > &, const MpInt &)
 
template Vector< MpInt, CAPD_DEFAULT_DIMENSIONoperator/<MpInt, CAPD_DEFAULT_DIMENSION > (const RowVector< MpInt, CAPD_DEFAULT_DIMENSION > &, const MpInt &)
 
template std::ostream & operator<<< MpInt, CAPD_DEFAULT_DIMENSION > (std::ostream &, const RowVector< MpInt, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< MpInt, CAPD_DEFAULT_DIMENSIONoperator+<MpInt, CAPD_DEFAULT_DIMENSION > (const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< MpInt, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< MpInt, CAPD_DEFAULT_DIMENSIONoperator+<MpInt, CAPD_DEFAULT_DIMENSION > (const ColumnVector< MpInt, CAPD_DEFAULT_DIMENSION > &, const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< MpInt, CAPD_DEFAULT_DIMENSIONoperator+<MpInt, CAPD_DEFAULT_DIMENSION > (const ColumnVector< MpInt, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< MpInt, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< MpInt, CAPD_DEFAULT_DIMENSIONoperator-<MpInt, CAPD_DEFAULT_DIMENSION > (const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< MpInt, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< MpInt, CAPD_DEFAULT_DIMENSIONoperator-<MpInt, CAPD_DEFAULT_DIMENSION > (const ColumnVector< MpInt, CAPD_DEFAULT_DIMENSION > &, const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< MpInt, CAPD_DEFAULT_DIMENSIONoperator-<MpInt, CAPD_DEFAULT_DIMENSION > (const ColumnVector< MpInt, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< MpInt, CAPD_DEFAULT_DIMENSION > &)
 
template MpInt operator*<MpInt, CAPD_DEFAULT_DIMENSION > (const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< MpInt, CAPD_DEFAULT_DIMENSION > &)
 
template MpInt operator*<MpInt, CAPD_DEFAULT_DIMENSION > (const ColumnVector< MpInt, CAPD_DEFAULT_DIMENSION > &, const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &)
 
template MpInt operator*<MpInt, CAPD_DEFAULT_DIMENSION > (const ColumnVector< MpInt, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< MpInt, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< MpInt, CAPD_DEFAULT_DIMENSIONoperator-<MpInt, CAPD_DEFAULT_DIMENSION > (const ColumnVector< MpInt, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< MpInt, CAPD_DEFAULT_DIMENSIONoperator*<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > (const Matrix< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION > &, const ColumnVector< MpInt, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< MpInt, CAPD_DEFAULT_DIMENSIONoperator*<MpInt, CAPD_DEFAULT_DIMENSION > (const MpInt &, const ColumnVector< MpInt, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< MpInt, CAPD_DEFAULT_DIMENSIONoperator*<MpInt, CAPD_DEFAULT_DIMENSION > (const ColumnVector< MpInt, CAPD_DEFAULT_DIMENSION > &, const MpInt &)
 
template Vector< MpInt, CAPD_DEFAULT_DIMENSIONoperator/<MpInt, CAPD_DEFAULT_DIMENSION > (const ColumnVector< MpInt, CAPD_DEFAULT_DIMENSION > &, const MpInt &)
 
template std::ostream & operator<<< MpInt, CAPD_DEFAULT_DIMENSION > (std::ostream &, const ColumnVector< MpInt, CAPD_DEFAULT_DIMENSION > &)
 
template Vector< MpInt, CAPD_DEFAULT_DIMENSIONabs< MpInt, CAPD_DEFAULT_DIMENSION > (const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v)
 
template Vector< MpInt, CAPD_DEFAULT_DIMENSIONoperator-<MpInt, CAPD_DEFAULT_DIMENSION > (const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v)
 
template Vector< MpInt, CAPD_DEFAULT_DIMENSIONoperator+<MpInt, CAPD_DEFAULT_DIMENSION > (const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v1, const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v2)
 
template Vector< MpInt, CAPD_DEFAULT_DIMENSIONoperator-<MpInt, CAPD_DEFAULT_DIMENSION > (const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v1, const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v2)
 
template MpInt operator*<MpInt, CAPD_DEFAULT_DIMENSION > (const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v1, const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v2)
 
template Vector< MpInt, CAPD_DEFAULT_DIMENSIONoperator*<MpInt, MpInt, CAPD_DEFAULT_DIMENSION > (const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v, const MpInt &s)
 
template Vector< MpInt, CAPD_DEFAULT_DIMENSIONoperator*<MpInt, MpInt, CAPD_DEFAULT_DIMENSION > (const MpInt &s, const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v)
 
template Vector< MpInt, CAPD_DEFAULT_DIMENSIONoperator/<MpInt, MpInt, CAPD_DEFAULT_DIMENSION > (const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v, const MpInt &s)
 
template Vector< MpInt, CAPD_DEFAULT_DIMENSIONoperator*<MpInt, long, CAPD_DEFAULT_DIMENSION > (const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v, const long &s)
 
template Vector< MpInt, CAPD_DEFAULT_DIMENSIONoperator*<MpInt, long, CAPD_DEFAULT_DIMENSION > (const long &s, const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v)
 
template Vector< MpInt, CAPD_DEFAULT_DIMENSIONoperator/<MpInt, long, CAPD_DEFAULT_DIMENSION > (const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v, const long &s)
 
template Vector< MpInt, CAPD_DEFAULT_DIMENSIONoperator*<MpInt, int, CAPD_DEFAULT_DIMENSION > (const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v, const int &s)
 
template Vector< MpInt, CAPD_DEFAULT_DIMENSIONoperator*<MpInt, int, CAPD_DEFAULT_DIMENSION > (const int &s, const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v)
 
template Vector< MpInt, CAPD_DEFAULT_DIMENSIONoperator/<MpInt, int, CAPD_DEFAULT_DIMENSION > (const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v, const int &s)
 
template Vector< MpInt, CAPD_DEFAULT_DIMENSIONoperator+<MpInt, CAPD_DEFAULT_DIMENSION > (const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v, const MpInt &s)
 
template Vector< MpInt, CAPD_DEFAULT_DIMENSIONoperator-<MpInt, CAPD_DEFAULT_DIMENSION > (const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v, const MpInt &s)
 
template bool operator<<MpInt, CAPD_DEFAULT_DIMENSION > (const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v1, const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v2)
 
template bool operator><MpInt, CAPD_DEFAULT_DIMENSION > (const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v1, const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v2)
 
template bool operator<=< MpInt, CAPD_DEFAULT_DIMENSION > (const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v1, const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v2)
 
template bool operator>=< MpInt, CAPD_DEFAULT_DIMENSION > (const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v1, const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v2)
 
template std::ostream & operator<<< MpInt, CAPD_DEFAULT_DIMENSION > (std::ostream &out, const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v)
 
template std::istream & operator>>< MpInt, CAPD_DEFAULT_DIMENSION > (std::istream &inp, Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v)
 
template void subtractObjects (const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v1, const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v2, Vector< MpInt, CAPD_DEFAULT_DIMENSION > &result)
 
template void addObjects (const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v1, const Vector< MpInt, CAPD_DEFAULT_DIMENSION > &v2, Vector< MpInt, CAPD_DEFAULT_DIMENSION > &result)
 

Typedef Documentation

◆ __difference_type

◆ __size_type

typedef unsigned capd::vectalg::__size_type

◆ DMatrix

◆ DVector

◆ IMatrix

◆ IVector

◆ LDVector

Function Documentation

◆ abs() [1/2]

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

◆ abs() [2/2]

template<typename Scalar , __size_type dim>
Vector< Scalar, dim > capd::vectalg::abs ( const Vector< Scalar, dim > &  v)
inline

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

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

◆ abs< double, CAPD_DEFAULT_DIMENSION >()

◆ abs< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

◆ abs< int, CAPD_DEFAULT_DIMENSION >()

◆ abs< long double, CAPD_DEFAULT_DIMENSION >()

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

◆ abs< MpFloat, CAPD_DEFAULT_DIMENSION >()

◆ abs< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

◆ abs< MpInt, CAPD_DEFAULT_DIMENSION >()

◆ abs< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

◆ absoluteValue()

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]

◆ addAssignMatrixByVector() [3/5]

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

◆ addAssignMatrixByVector() [4/5]

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

◆ addAssignMatrixByVector() [5/5]

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

◆ addAssignObjectObject() [1/2]

template<typename T1 , typename T2 >
T1 & capd::vectalg::addAssignObjectObject ( T1 &  u,
const T2 &  v 
)

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

◆ addAssignObjectObject() [2/2]

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

◆ addAssignObjectScalar() [1/2]

template<typename Object , typename Scalar >
Object & capd::vectalg::addAssignObjectScalar ( Object u,
const Scalar &  s 
)

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

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

◆ addAssignObjectScalar() [2/2]

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

◆ addIndex()

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

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

◆ addObjects() [1/14]

◆ addObjects() [2/14]

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

◆ addObjects() [3/14]

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

◆ addObjects() [4/14]

◆ addObjects() [5/14]

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

◆ addObjects() [6/14]

template<typename ResultType , typename T1 , typename T2 >
ResultType capd::vectalg::addObjects ( const T1 &  v1,
const T2 &  v2 
)
inline

◆ addObjects() [7/14]

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

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

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

◆ addObjects() [8/14]

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

◆ addObjects() [9/14]

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

◆ addObjects() [10/14]

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

◆ addObjects() [11/14]

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

◆ addObjects() [12/14]

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

◆ addObjects() [13/14]

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

◆ addObjects() [14/14]

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

◆ addObjectScalar() [1/2]

template<typename ResultType , typename Object , typename FactorType >
ResultType capd::vectalg::addObjectScalar ( const Object v,
const FactorType &  s 
)

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

◆ addObjectScalar() [2/2]

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

◆ assignFromScalar() [1/2]

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

◆ assignFromScalar() [2/2]

template<typename Object , typename Scalar >
Object & capd::vectalg::assignFromScalar ( Object u,
const Scalar &  s 
)

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

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

◆ assignObjectObject() [1/13]

◆ assignObjectObject() [2/13]

◆ assignObjectObject() [3/13]

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

◆ assignObjectObject() [4/13]

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

◆ assignObjectObject() [5/13]

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

◆ assignObjectObject() [6/13]

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

◆ assignObjectObject() [7/13]

◆ assignObjectObject() [8/13]

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

◆ assignObjectObject() [9/13]

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

◆ assignObjectObject() [10/13]

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

◆ assignObjectObject() [11/13]

template<typename T1 , typename T2 >
T1 & capd::vectalg::assignObjectObject ( T1 &  u,
const T2 &  v 
)

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

u = v

◆ assignObjectObject() [12/13]

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

◆ assignObjectObject() [13/13]

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

◆ clear() [1/4]

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

◆ clear() [2/4]

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

◆ clear() [3/4]

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

◆ clear() [4/4]

template<typename Object >
void capd::vectalg::clear ( Object u)

Assign zero to each coordinate.

◆ computeNewton()

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

◆ copyFromSubmatrix()

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

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

◆ copyFromSubvector()

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

it copies src[start..stop] into target

◆ copyToSubmatrix()

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

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

◆ copyToSubvector()

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

it copies src into target[start..stop]

◆ cppReprezentation() [1/8]

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

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

◆ cppReprezentation() [2/8]

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

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

◆ cppReprezentation() [3/8]

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

◆ cppReprezentation() [4/8]

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

◆ cppReprezentation() [5/8]

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

◆ cppReprezentation() [6/8]

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

◆ cppReprezentation() [7/8]

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

◆ cppReprezentation() [8/8]

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

◆ diam() [1/3]

template<typename IVector >
IVector capd::vectalg::diam ( const IVector )

◆ diam() [2/3]

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

◆ diam() [3/3]

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

◆ diam< IMatrix >()

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

◆ diam< IVector >()

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

◆ divideAssignObjectScalar() [1/7]

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

◆ divideAssignObjectScalar() [2/7]

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

◆ divideAssignObjectScalar() [3/7]

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

◆ divideAssignObjectScalar() [4/7]

template<typename Object , typename Scalar >
Object & capd::vectalg::divideAssignObjectScalar ( Object u,
const Scalar &  s 
)

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

◆ divideAssignObjectScalar() [5/7]

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

◆ divideAssignObjectScalar() [6/7]

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

◆ divideAssignObjectScalar() [7/7]

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

◆ divideObjectScalar() [1/6]

template DVector capd::vectalg::divideObjectScalar ( const DVector v1,
const double s 
)

◆ divideObjectScalar() [2/6]

template LDVector capd::vectalg::divideObjectScalar ( const LDVector v1,
const long double s 
)

◆ divideObjectScalar() [3/6]

template<typename ResultType , typename Object , typename FactorType >
ResultType capd::vectalg::divideObjectScalar ( const Object v,
const FactorType &  s 
)

this procedure can be use to divide by a scalar any element of vector-like objects as a result we may obtain object of different type, dividing of column of matrix by scalar gives vector result = v / s

◆ divideObjectScalar() [4/6]

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

◆ divideObjectScalar() [5/6]

template IVector capd::vectalg::divideObjectScalar ( IVector const &  ,
long const &   
)

◆ divideObjectScalar() [6/6]

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

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

◆ equal() [1/3]

◆ equal() [2/3]

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

◆ equal() [3/3]

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

◆ euclNorm() [1/2]

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

◆ euclNorm() [2/2]

template<typename Object >
Object::ScalarType capd::vectalg::euclNorm ( const Object u)

Computes euclidean norm of any vector.

◆ evalPolynomial()

template<class Object , class Scalar >
void capd::vectalg::evalPolynomial ( Object c,
Scalar  t,
Object result,
int  n 
)

Evaluates polynomial p:R->R^n at some argument.

Coefficients of the polynomial are assumed to be stored as an array c[r], where c\in R^n. The result is stored in the third argument.

Parameters
c- coefficients of the polynomial
t- argument at which polynomial is evaluated
n- deree of the polynomial

◆ getWidths()

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

◆ greaterEqual()

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

◆ greaterThan()

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

◆ hasIndex()

bool capd::vectalg::hasIndex ( const Multipointer mp,
int  index 
)

checks if muiltipointer contains index

Parameters
[in]-mp multipointer that is checked
[in]-index index to be found
Returns
true if mp contains index

◆ indexCount()

int capd::vectalg::indexCount ( const Multipointer mp,
int  index 
)

returns the number of occurences of index in the multipointer

Parameters
[in]mp- multipointer that is inspected
[in]index- the counted index
Returns
number of occureneces o of index in mp

◆ intersection() [1/2]

template<typename IVector >
IVector capd::vectalg::intersection ( const IVector ,
const IVector  
)

◆ intersection() [2/2]

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

◆ intersection< IMatrix >()

template IMatrix capd::vectalg::intersection< IMatrix > ( const IMatrix v1,
const IMatrix v2 
)

◆ intersection< IMatrix, IMatrix, IMatrix >()

template bool capd::vectalg::intersection< IMatrix, IMatrix, IMatrix > ( const IMatrix ,
const IMatrix ,
IMatrix  
)

◆ intersection< IVector >()

template IVector capd::vectalg::intersection< IVector > ( const IVector v1,
const IVector v2 
)

◆ intersectionWithSubmatrix()

template<typename MatrixType1 , typename MatrixType2 >
void capd::vectalg::intersectionWithSubmatrix ( const MatrixType1 &  src,
MatrixType2 &  target,
int  startRow,
int  stopRow,
int  startCol,
int  stopCol 
)

intersection of src with target[startRow..stopRow][startCol..stopCol] is returned in target

◆ intersectionWithSubvector()

template<typename VectorType1 , typename VectorType2 >
void capd::vectalg::intersectionWithSubvector ( const VectorType1 &  src,
VectorType2 &  target,
int  start,
int  stop 
)

Intersection of src with target[start..stop] is returned in target.

◆ intervalBall() [1/2]

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

◆ intervalBall() [2/2]

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

◆ intervalBall< IVector >()

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

◆ intervalHull() [1/2]

template<typename IVector >
IVector capd::vectalg::intervalHull ( const IVector ,
const IVector  
)

◆ intervalHull() [2/2]

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

◆ intervalHull< IMatrix >()

template IMatrix capd::vectalg::intervalHull< IMatrix > ( const IMatrix A,
const IMatrix B 
)

◆ intervalHull< IVector >()

template IVector capd::vectalg::intervalHull< IVector > ( const IVector A,
const IVector B 
)

◆ leftVector()

template<typename IVector >
IVector capd::vectalg::leftVector ( const IVector u)
inline

◆ leftVector< IVector >()

template IVector capd::vectalg::leftVector< IVector > ( const IVector v)

◆ lessEqual()

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

◆ lessThan()

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

◆ matrixByMatrix() [1/8]

template<typename ResultType , typename Matrix1 , typename Matrix2 >
ResultType capd::vectalg::matrixByMatrix ( const Matrix1 &  a1,
const Matrix2 &  a2 
)
inline

◆ matrixByMatrix() [2/8]

template<typename ResultType , typename Matrix1 , typename Matrix2 >
void capd::vectalg::matrixByMatrix ( const Matrix1 &  a1,
const Matrix2 &  a2,
ResultType &  result 
)

this procedure realizes multiplication of two matrix-like objects result = m1*m2

◆ matrixByMatrix() [3/8]

◆ matrixByMatrix() [4/8]

◆ matrixByMatrix() [5/8]

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

◆ matrixByMatrix() [6/8]

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

◆ matrixByMatrix() [7/8]

◆ matrixByMatrix() [8/8]

◆ matrixByVector() [1/11]

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

◆ matrixByVector() [2/11]

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

◆ matrixByVector() [3/11]

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

◆ matrixByVector() [4/11]

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

◆ matrixByVector() [5/11]

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

◆ matrixByVector() [6/11]

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

◆ matrixByVector() [7/11]

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

◆ matrixByVector() [8/11]

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

◆ matrixByVector() [9/11]

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

◆ matrixByVector() [10/11]

template<typename ResultType , typename MatrixType , typename VectorType >
ResultType capd::vectalg::matrixByVector ( const MatrixType &  m,
const VectorType &  u 
)
inline

◆ matrixByVector() [11/11]

template<typename ResultType , typename MatrixType , typename VectorType >
void capd::vectalg::matrixByVector ( const MatrixType &  m,
const VectorType &  u,
ResultType &  result 
)

this procedure realizes multiplication of matrix-like object by vector-like object result = m*v

◆ maxDiam()

template<typename IVector >
IVector::ScalarType capd::vectalg::maxDiam ( const IVector )

◆ maxDiam< IMatrix >()

◆ maxDiam< IVector >()

◆ 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]

◆ multiplyAssignObjectScalarAddObject() [3/7]

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

◆ multiplyAssignObjectScalarAddObject() [4/7]

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

◆ multiplyAssignObjectScalarAddObject() [5/7]

template<typename Object , typename Object2 , typename Scalar >
Object & capd::vectalg::multiplyAssignObjectScalarAddObject ( Object u,
const Scalar &  s,
const Object2 &  v 
)

this procedure can be use to multiply by a scalar each element of a vector-like object and then add compoent-wise elements of second vector-like object u[i] = u[i]*s+v[i]

◆ multiplyAssignObjectScalarAddObject() [6/7]

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

◆ multiplyAssignObjectScalarAddObject() [7/7]

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

◆ multiplyObjectScalar() [1/15]

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

◆ multiplyObjectScalar() [2/15]

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

◆ multiplyObjectScalar() [3/15]

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

◆ multiplyObjectScalar() [4/15]

template<typename ResultType , typename Object , typename FactorType >
ResultType capd::vectalg::multiplyObjectScalar ( const Object v,
const FactorType &  s 
)

this procedure can be use to multiply by a scalar any element of vector-like objects as a result we may obtain object of different type, multiplication of column of matrix and scalar gives vector result = v * s

◆ multiplyObjectScalar() [5/15]

template<typename ResultType , typename Object , typename FactorType >
void capd::vectalg::multiplyObjectScalar ( const Object v,
const FactorType &  s,
ResultType &  result 
)

this procedure can be use to multiply by a scalar any element of vector-like objects as a result we may obtain object of different type, multiplication of column of matrix and scalar gives vector result = v * s

◆ multiplyObjectScalar() [6/15]

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

◆ multiplyObjectScalar() [7/15]

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

◆ multiplyObjectScalar() [8/15]

template IVector capd::vectalg::multiplyObjectScalar ( IVector const &  ,
long const &   
)

◆ multiplyObjectScalar() [9/15]

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

◆ multiplyObjectScalar() [10/15]

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

◆ multiplyObjectScalar() [11/15]

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

◆ multiplyObjectScalar() [12/15]

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

◆ multiplyObjectScalar() [13/15]

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

◆ multiplyObjectScalar() [14/15]

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

◆ multiplyObjectScalar() [15/15]

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

◆ normalize() [1/2]

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

◆ normalize() [2/2]

template<typename Object >
bool capd::vectalg::normalize ( Object u)

normalize a vector with respect to euclidean norm if impossible returns false

◆ notEqual()

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

◆ operator!=() [1/2]

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

◆ operator!=() [2/2]

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

◆ operator*() [1/19]

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

◆ operator*() [2/19]

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

◆ operator*() [3/19]

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

◆ operator*() [4/19]

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

◆ operator*() [5/19]

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

◆ operator*() [6/19]

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

◆ operator*() [7/19]

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

◆ operator*() [8/19]

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

◆ operator*() [9/19]

template<typename Scalar , __size_type rows, __size_type cols1, __size_type cols2>
Matrix< Scalar, rows, cols2 > capd::vectalg::operator* ( const Matrix< Scalar, rows, cols1 > &  a1,
const Matrix< Scalar, cols1, cols2 > &  a2 
)

◆ operator*() [10/19]

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

◆ operator*() [11/19]

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

◆ operator*() [12/19]

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

◆ operator*() [13/19]

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

◆ operator*() [14/19]

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

◆ operator*() [15/19]

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

◆ operator*() [16/19]

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

◆ operator*() [17/19]

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

◆ operator*() [18/19]

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

◆ operator*() [19/19]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

◆ operator*<int, CAPD_DEFAULT_DIMENSION >()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

◆ operator*<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [2/6]

◆ operator*<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [3/6]

◆ operator*<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [4/6]

◆ operator*<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [5/6]

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

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

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

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

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

◆ operator*<MpInt, long, CAPD_DEFAULT_DIMENSION >() [1/2]

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

◆ operator*<MpInt, long, CAPD_DEFAULT_DIMENSION >() [2/2]

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

◆ operator*<MpInt, MpInt, CAPD_DEFAULT_DIMENSION >() [1/2]

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

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

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

◆ operator+() [1/10]

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

◆ operator+() [2/10]

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

◆ operator+() [3/10]

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

◆ operator+() [4/10]

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

◆ operator+() [5/10]

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

◆ operator+() [6/10]

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

◆ operator+() [7/10]

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

◆ operator+() [8/10]

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

◆ operator+() [9/10]

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

◆ operator+() [10/10]

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

◆ operator+<capd::DInterval, CAPD_DEFAULT_DIMENSION >() [1/8]

◆ operator+<capd::DInterval, CAPD_DEFAULT_DIMENSION >() [2/8]

◆ operator+<capd::DInterval, CAPD_DEFAULT_DIMENSION >() [3/8]

◆ operator+<capd::DInterval, CAPD_DEFAULT_DIMENSION >() [4/8]

◆ operator+<capd::DInterval, CAPD_DEFAULT_DIMENSION >() [5/8]

◆ operator+<capd::DInterval, CAPD_DEFAULT_DIMENSION >() [6/8]

◆ operator+<capd::DInterval, CAPD_DEFAULT_DIMENSION >() [7/8]

◆ operator+<capd::DInterval, CAPD_DEFAULT_DIMENSION >() [8/8]

◆ operator+<capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [1/2]

◆ operator+<capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [2/2]

◆ operator+<double, CAPD_DEFAULT_DIMENSION >() [1/8]

◆ operator+<double, CAPD_DEFAULT_DIMENSION >() [2/8]

◆ operator+<double, CAPD_DEFAULT_DIMENSION >() [3/8]

◆ operator+<double, CAPD_DEFAULT_DIMENSION >() [4/8]

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

◆ operator+<double, CAPD_DEFAULT_DIMENSION >() [5/8]

◆ operator+<double, CAPD_DEFAULT_DIMENSION >() [6/8]

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

◆ operator+<double, CAPD_DEFAULT_DIMENSION >() [7/8]

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

◆ operator+<double, CAPD_DEFAULT_DIMENSION >() [8/8]

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

◆ operator+<double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [1/2]

◆ operator+<double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [2/2]

◆ operator+<int, CAPD_DEFAULT_DIMENSION >() [1/2]

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

◆ operator+<int, CAPD_DEFAULT_DIMENSION >() [2/2]

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

◆ operator+<long double, CAPD_DEFAULT_DIMENSION >() [1/8]

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

◆ operator+<long double, CAPD_DEFAULT_DIMENSION >() [2/8]

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

◆ operator+<long double, CAPD_DEFAULT_DIMENSION >() [3/8]

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

◆ operator+<long double, CAPD_DEFAULT_DIMENSION >() [4/8]

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

◆ operator+<long double, CAPD_DEFAULT_DIMENSION >() [5/8]

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

◆ operator+<long double, CAPD_DEFAULT_DIMENSION >() [6/8]

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

◆ operator+<long double, CAPD_DEFAULT_DIMENSION >() [7/8]

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

◆ operator+<long double, CAPD_DEFAULT_DIMENSION >() [8/8]

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

◆ operator+<long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [1/2]

◆ operator+<long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [2/2]

◆ operator+<MpFloat, CAPD_DEFAULT_DIMENSION >() [1/8]

◆ operator+<MpFloat, CAPD_DEFAULT_DIMENSION >() [2/8]

◆ operator+<MpFloat, CAPD_DEFAULT_DIMENSION >() [3/8]

◆ operator+<MpFloat, CAPD_DEFAULT_DIMENSION >() [4/8]

◆ operator+<MpFloat, CAPD_DEFAULT_DIMENSION >() [5/8]

◆ operator+<MpFloat, CAPD_DEFAULT_DIMENSION >() [6/8]

◆ operator+<MpFloat, CAPD_DEFAULT_DIMENSION >() [7/8]

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

◆ operator+<MpFloat, CAPD_DEFAULT_DIMENSION >() [8/8]

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

◆ operator+<MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [1/2]

◆ operator+<MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [2/2]

◆ operator+<MpInt, CAPD_DEFAULT_DIMENSION >() [1/8]

◆ operator+<MpInt, CAPD_DEFAULT_DIMENSION >() [2/8]

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

◆ operator+<MpInt, CAPD_DEFAULT_DIMENSION >() [3/8]

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

◆ operator+<MpInt, CAPD_DEFAULT_DIMENSION >() [4/8]

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

◆ operator+<MpInt, CAPD_DEFAULT_DIMENSION >() [5/8]

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

◆ operator+<MpInt, CAPD_DEFAULT_DIMENSION >() [6/8]

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

◆ operator+<MpInt, CAPD_DEFAULT_DIMENSION >() [7/8]

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

◆ operator+<MpInt, CAPD_DEFAULT_DIMENSION >() [8/8]

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

◆ operator+<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [1/2]

◆ operator+<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [2/2]

◆ operator-() [1/14]

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

◆ operator-() [2/14]

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

◆ operator-() [3/14]

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

◆ operator-() [4/14]

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

◆ operator-() [5/14]

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

◆ operator-() [6/14]

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

◆ operator-() [7/14]

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

◆ operator-() [8/14]

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

◆ operator-() [9/14]

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

◆ operator-() [10/14]

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

◆ operator-() [11/14]

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

◆ operator-() [12/14]

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

◆ operator-() [13/14]

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

◆ operator-() [14/14]

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

◆ operator-<capd::DInterval, CAPD_DEFAULT_DIMENSION >() [1/11]

◆ operator-<capd::DInterval, CAPD_DEFAULT_DIMENSION >() [2/11]

◆ operator-<capd::DInterval, CAPD_DEFAULT_DIMENSION >() [3/11]

◆ operator-<capd::DInterval, CAPD_DEFAULT_DIMENSION >() [4/11]

◆ operator-<capd::DInterval, CAPD_DEFAULT_DIMENSION >() [5/11]

◆ operator-<capd::DInterval, CAPD_DEFAULT_DIMENSION >() [6/11]

◆ operator-<capd::DInterval, CAPD_DEFAULT_DIMENSION >() [7/11]

◆ operator-<capd::DInterval, CAPD_DEFAULT_DIMENSION >() [8/11]

◆ operator-<capd::DInterval, CAPD_DEFAULT_DIMENSION >() [9/11]

◆ operator-<capd::DInterval, CAPD_DEFAULT_DIMENSION >() [10/11]

◆ operator-<capd::DInterval, CAPD_DEFAULT_DIMENSION >() [11/11]

◆ operator-<capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [1/3]

◆ operator-<capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [2/3]

◆ operator-<capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [3/3]

◆ operator-<double, CAPD_DEFAULT_DIMENSION >() [1/11]

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

◆ operator-<double, CAPD_DEFAULT_DIMENSION >() [2/11]

◆ operator-<double, CAPD_DEFAULT_DIMENSION >() [3/11]

◆ operator-<double, CAPD_DEFAULT_DIMENSION >() [4/11]

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

◆ operator-<double, CAPD_DEFAULT_DIMENSION >() [5/11]

◆ operator-<double, CAPD_DEFAULT_DIMENSION >() [6/11]

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

◆ operator-<double, CAPD_DEFAULT_DIMENSION >() [7/11]

◆ operator-<double, CAPD_DEFAULT_DIMENSION >() [8/11]

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

◆ operator-<double, CAPD_DEFAULT_DIMENSION >() [9/11]

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

◆ operator-<double, CAPD_DEFAULT_DIMENSION >() [10/11]

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

◆ operator-<double, CAPD_DEFAULT_DIMENSION >() [11/11]

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

◆ operator-<double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [1/3]

◆ operator-<double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [2/3]

◆ operator-<double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [3/3]

◆ operator-<int, CAPD_DEFAULT_DIMENSION >() [1/3]

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

◆ operator-<int, CAPD_DEFAULT_DIMENSION >() [2/3]

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

◆ operator-<int, CAPD_DEFAULT_DIMENSION >() [3/3]

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

◆ operator-<long double, CAPD_DEFAULT_DIMENSION >() [1/11]

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

◆ operator-<long double, CAPD_DEFAULT_DIMENSION >() [2/11]

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

◆ operator-<long double, CAPD_DEFAULT_DIMENSION >() [3/11]

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

◆ operator-<long double, CAPD_DEFAULT_DIMENSION >() [4/11]

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

◆ operator-<long double, CAPD_DEFAULT_DIMENSION >() [5/11]

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

◆ operator-<long double, CAPD_DEFAULT_DIMENSION >() [6/11]

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

◆ operator-<long double, CAPD_DEFAULT_DIMENSION >() [7/11]

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

◆ operator-<long double, CAPD_DEFAULT_DIMENSION >() [8/11]

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

◆ operator-<long double, CAPD_DEFAULT_DIMENSION >() [9/11]

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

◆ operator-<long double, CAPD_DEFAULT_DIMENSION >() [10/11]

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

◆ operator-<long double, CAPD_DEFAULT_DIMENSION >() [11/11]

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

◆ operator-<long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [1/3]

◆ operator-<long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [2/3]

◆ operator-<long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [3/3]

◆ operator-<MpFloat, CAPD_DEFAULT_DIMENSION >() [1/11]

◆ operator-<MpFloat, CAPD_DEFAULT_DIMENSION >() [2/11]

◆ operator-<MpFloat, CAPD_DEFAULT_DIMENSION >() [3/11]

◆ operator-<MpFloat, CAPD_DEFAULT_DIMENSION >() [4/11]

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

◆ operator-<MpFloat, CAPD_DEFAULT_DIMENSION >() [5/11]

◆ operator-<MpFloat, CAPD_DEFAULT_DIMENSION >() [6/11]

◆ operator-<MpFloat, CAPD_DEFAULT_DIMENSION >() [7/11]

◆ operator-<MpFloat, CAPD_DEFAULT_DIMENSION >() [8/11]

◆ operator-<MpFloat, CAPD_DEFAULT_DIMENSION >() [9/11]

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

◆ operator-<MpFloat, CAPD_DEFAULT_DIMENSION >() [10/11]

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

◆ operator-<MpFloat, CAPD_DEFAULT_DIMENSION >() [11/11]

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

◆ operator-<MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [1/3]

◆ operator-<MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [2/3]

◆ operator-<MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [3/3]

◆ operator-<MpInt, CAPD_DEFAULT_DIMENSION >() [1/11]

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

◆ operator-<MpInt, CAPD_DEFAULT_DIMENSION >() [2/11]

◆ operator-<MpInt, CAPD_DEFAULT_DIMENSION >() [3/11]

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

◆ operator-<MpInt, CAPD_DEFAULT_DIMENSION >() [4/11]

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

◆ operator-<MpInt, CAPD_DEFAULT_DIMENSION >() [5/11]

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

◆ operator-<MpInt, CAPD_DEFAULT_DIMENSION >() [6/11]

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

◆ operator-<MpInt, CAPD_DEFAULT_DIMENSION >() [7/11]

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

◆ operator-<MpInt, CAPD_DEFAULT_DIMENSION >() [8/11]

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

◆ operator-<MpInt, CAPD_DEFAULT_DIMENSION >() [9/11]

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

◆ operator-<MpInt, CAPD_DEFAULT_DIMENSION >() [10/11]

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

◆ operator-<MpInt, CAPD_DEFAULT_DIMENSION >() [11/11]

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

◆ operator-<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [1/3]

◆ operator-<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [2/3]

◆ operator-<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >() [3/3]

◆ operator/() [1/4]

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

◆ operator/() [2/4]

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

◆ operator/() [3/4]

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

◆ operator/() [4/4]

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

◆ operator/<capd::DInterval, capd::DInterval, CAPD_DEFAULT_DIMENSION >()

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

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

◆ operator/<capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

◆ operator/<capd::DInterval, double, CAPD_DEFAULT_DIMENSION >()

◆ operator/<capd::DInterval, int, CAPD_DEFAULT_DIMENSION >()

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

◆ operator/<capd::DInterval, long, CAPD_DEFAULT_DIMENSION >()

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

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

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

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

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

◆ operator/<double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

◆ operator/<double, double, CAPD_DEFAULT_DIMENSION >()

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

◆ operator/<double, int, CAPD_DEFAULT_DIMENSION >()

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

◆ operator/<double, long, CAPD_DEFAULT_DIMENSION >()

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

◆ operator/<int, int, CAPD_DEFAULT_DIMENSION >()

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

◆ operator/<int, long, CAPD_DEFAULT_DIMENSION >()

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

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

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

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

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

◆ operator/<long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

◆ operator/<long double, int, CAPD_DEFAULT_DIMENSION >()

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

◆ operator/<long double, long double, CAPD_DEFAULT_DIMENSION >()

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

◆ operator/<long double, long, CAPD_DEFAULT_DIMENSION >()

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

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

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

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

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

◆ operator/<MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

◆ operator/<MpFloat, int, CAPD_DEFAULT_DIMENSION >()

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

◆ operator/<MpFloat, long, CAPD_DEFAULT_DIMENSION >()

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

◆ operator/<MpFloat, MpFloat, CAPD_DEFAULT_DIMENSION >()

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

◆ operator/<MpInt, CAPD_DEFAULT_DIMENSION >() [1/2]

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

◆ operator/<MpInt, CAPD_DEFAULT_DIMENSION >() [2/2]

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

◆ operator/<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

◆ operator/<MpInt, int, CAPD_DEFAULT_DIMENSION >()

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

◆ operator/<MpInt, long, CAPD_DEFAULT_DIMENSION >()

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

◆ operator/<MpInt, MpInt, CAPD_DEFAULT_DIMENSION >()

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

◆ operator<() [1/2]

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

◆ operator<() [2/2]

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

◆ operator<<() [1/3]

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

◆ operator<<() [2/3]

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

◆ operator<<() [3/3]

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

◆ operator<<< capd::DInterval, CAPD_DEFAULT_DIMENSION >() [1/3]

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

◆ operator<<< capd::DInterval, CAPD_DEFAULT_DIMENSION >() [2/3]

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

◆ operator<<< capd::DInterval, CAPD_DEFAULT_DIMENSION >() [3/3]

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

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

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

◆ operator<<< double, CAPD_DEFAULT_DIMENSION >() [1/3]

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

◆ operator<<< double, CAPD_DEFAULT_DIMENSION >() [2/3]

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

◆ operator<<< double, CAPD_DEFAULT_DIMENSION >() [3/3]

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

◆ operator<<< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

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

◆ operator<<< int, CAPD_DEFAULT_DIMENSION >()

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

◆ operator<<< long double, CAPD_DEFAULT_DIMENSION >() [1/3]

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

◆ operator<<< long double, CAPD_DEFAULT_DIMENSION >() [2/3]

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

◆ operator<<< long double, CAPD_DEFAULT_DIMENSION >() [3/3]

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

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

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

◆ operator<<< MpFloat, CAPD_DEFAULT_DIMENSION >() [1/3]

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

◆ operator<<< MpFloat, CAPD_DEFAULT_DIMENSION >() [2/3]

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

◆ operator<<< MpFloat, CAPD_DEFAULT_DIMENSION >() [3/3]

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

◆ operator<<< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

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

◆ operator<<< MpInt, CAPD_DEFAULT_DIMENSION >() [1/3]

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

◆ operator<<< MpInt, CAPD_DEFAULT_DIMENSION >() [2/3]

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

◆ operator<<< MpInt, CAPD_DEFAULT_DIMENSION >() [3/3]

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

◆ operator<<< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

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

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

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

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

◆ operator<<double, CAPD_DEFAULT_DIMENSION >()

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

◆ operator<<double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

◆ operator<<int, CAPD_DEFAULT_DIMENSION >()

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

◆ operator<<long double, CAPD_DEFAULT_DIMENSION >()

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

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

◆ operator<<MpFloat, CAPD_DEFAULT_DIMENSION >()

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

◆ operator<<MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

◆ operator<<MpInt, CAPD_DEFAULT_DIMENSION >()

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

◆ operator<<MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

◆ operator<=() [1/2]

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

◆ operator<=() [2/2]

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

◆ operator<=< capd::DInterval, CAPD_DEFAULT_DIMENSION >()

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

◆ operator<=< capd::DInterval, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

◆ operator<=< double, CAPD_DEFAULT_DIMENSION >()

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

◆ operator<=< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

◆ operator<=< int, CAPD_DEFAULT_DIMENSION >()

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

◆ operator<=< long double, CAPD_DEFAULT_DIMENSION >()

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

◆ operator<=< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

◆ operator<=< MpFloat, CAPD_DEFAULT_DIMENSION >()

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

◆ operator<=< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

◆ operator<=< MpInt, CAPD_DEFAULT_DIMENSION >()

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

◆ operator<=< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

◆ operator==() [1/2]

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

◆ operator==() [2/2]

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

◆ operator>() [1/2]

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

◆ operator>() [2/2]

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

◆ operator><double, CAPD_DEFAULT_DIMENSION >()

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

◆ operator><double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

◆ operator><int, CAPD_DEFAULT_DIMENSION >()

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

◆ operator><long double, CAPD_DEFAULT_DIMENSION >()

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

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

◆ operator><MpFloat, CAPD_DEFAULT_DIMENSION >()

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

◆ operator><MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

◆ operator><MpInt, CAPD_DEFAULT_DIMENSION >()

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

◆ operator><MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

◆ operator>=() [1/2]

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

◆ operator>=() [2/2]

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

◆ operator>=< double, CAPD_DEFAULT_DIMENSION >()

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

◆ operator>=< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

◆ operator>=< int, CAPD_DEFAULT_DIMENSION >()

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

◆ operator>=< long double, CAPD_DEFAULT_DIMENSION >()

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

◆ operator>=< long double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

◆ operator>=< MpFloat, CAPD_DEFAULT_DIMENSION >()

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

◆ operator>=< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

◆ operator>=< MpInt, CAPD_DEFAULT_DIMENSION >()

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

◆ operator>=< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

◆ operator>>()

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

◆ operator>>< double, CAPD_DEFAULT_DIMENSION >()

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

◆ operator>>< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

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

◆ operator>>< int, CAPD_DEFAULT_DIMENSION >()

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

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

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

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

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

◆ operator>>< MpFloat, CAPD_DEFAULT_DIMENSION >()

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

◆ operator>>< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

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

◆ operator>>< MpInt, CAPD_DEFAULT_DIMENSION >()

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

◆ operator>>< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

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

◆ printVector() [1/3]

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

◆ printVector() [2/3]

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

◆ printVector() [3/3]

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

◆ printVector< IVector >()

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

◆ push_back()

Multipointer capd::vectalg::push_back ( const Multipointer mp,
int  index 
)

appends index to the end of multipointer mp

◆ removeIndex()

Multipointer capd::vectalg::removeIndex ( const Multipointer mp,
int  index 
)

returns a multipointer with removed index

Parameters
[in]mp- multipointer from which an index is removed
[in]index-index to be removed
Returns
a multipointer with removed index

◆ rightVector()

template<typename IVector >
IVector capd::vectalg::rightVector ( const IVector u)
inline

◆ rightVector< IVector >()

template IVector capd::vectalg::rightVector< IVector > ( const IVector v)

◆ scalarProduct() [1/2]

template<typename T1 , typename T2 >
T1::ScalarType capd::vectalg::scalarProduct ( const T1 &  v1,
const T2 &  v2 
)

this procedure can be use to compute scalar product of two vector-like objects:

  • vectors, matrices, references to columns or rows of matrix
  • vectors of partial derivatives from higher order containers result = v1 * v2

◆ scalarProduct() [2/2]

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

◆ secondTrace()

template<typename Scalar , __size_type rows, __size_type cols>
Matrix< Scalar, cols, rows >::ScalarType capd::vectalg::secondTrace ( const Matrix< Scalar, cols, rows > &  A)

It returns a sum of determinants of all 2x2 matrix.

It returns a sum of determinants of all 2x2 matrices from main diagonal.

◆ setDimensionInArray() [1/4]

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

◆ setDimensionInArray() [2/4]

template<typename Scalar , __size_type rows, __size_type cols>
void capd::vectalg::setDimensionInArray ( Matrix< Scalar, rows, cols > *  ,
__size_type  ,
__size_type  ,
__size_type   
)
inline

◆ setDimensionInArray() [3/4]

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

◆ setDimensionInArray() [4/4]

template<typename Scalar , __size_type dim>
void capd::vectalg::setDimensionInArray ( Vector< Scalar, dim > *  ,
__size_type  ,
__size_type   
)
inline

◆ solveAffineInclusion() [1/4]

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

◆ solveAffineInclusion() [2/4]

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

◆ solveAffineInclusion() [3/4]

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

◆ solveAffineInclusion() [4/4]

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

◆ solveAffineInclusion< IVector >() [1/2]

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

◆ solveAffineInclusion< IVector >() [2/2]

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

◆ split< IMatrix, DMatrix >()

template void capd::vectalg::split< IMatrix, DMatrix > ( const IMatrix ,
DMatrix ,
IMatrix  
)

◆ split< IMatrix, IMatrix >()

template void capd::vectalg::split< IMatrix, IMatrix > ( IMatrix ,
IMatrix  
)

◆ split< IVector, DVector >()

template void capd::vectalg::split< IVector, DVector > ( const IVector v,
DVector ,
IVector rv 
)

◆ split< IVector, IVector >()

template void capd::vectalg::split< IVector, IVector > ( IVector v,
IVector rv 
)

◆ subset< IMatrix >()

template bool capd::vectalg::subset< IMatrix > ( const IMatrix v1,
const IMatrix v2 
)

◆ subset< IVector >()

template bool capd::vectalg::subset< IVector > ( const IVector v1,
const IVector v2 
)

◆ subsetInterior< IMatrix >()

template bool capd::vectalg::subsetInterior< IMatrix > ( const IMatrix v1,
const IMatrix v2 
)

◆ subsetInterior< IVector >()

template bool capd::vectalg::subsetInterior< IVector > ( const IVector v1,
const IVector v2 
)

◆ subtractAssignMatrixByVector() [1/5]

template<typename V , typename M , typename V2 >
V & capd::vectalg::subtractAssignMatrixByVector ( V &  u,
const M &  A,
const V2 &  v 
)

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

◆ subtractAssignMatrixByVector() [2/5]

◆ subtractAssignMatrixByVector() [3/5]

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

◆ subtractAssignMatrixByVector() [4/5]

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

◆ subtractAssignMatrixByVector() [5/5]

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

◆ subtractAssignObjectObject() [1/2]

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

◆ subtractAssignObjectObject() [2/2]

template<typename T1 , typename T2 >
T1 & capd::vectalg::subtractAssignObjectObject ( T1 &  u,
const T2 &  v 
)

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

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

◆ subtractAssignObjectScalar()

template<typename Object , typename Scalar >
Object & capd::vectalg::subtractAssignObjectScalar ( Object u,
const Scalar &  s 
)

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

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

◆ subtractObjects() [1/14]

◆ subtractObjects() [2/14]

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

◆ subtractObjects() [3/14]

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

◆ subtractObjects() [4/14]

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

◆ subtractObjects() [5/14]

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

◆ subtractObjects() [6/14]

template<typename ResultType , typename T1 , typename T2 >
ResultType capd::vectalg::subtractObjects ( const T1 &  v1,
const T2 &  v2 
)
inline

◆ subtractObjects() [7/14]

template<typename ResultType , typename T1 , typename T2 >
void capd::vectalg::subtractObjects ( const T1 &  v1,
const T2 &  v2,
ResultType &  result 
)

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

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

◆ subtractObjects() [8/14]

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

◆ subtractObjects() [9/14]

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

◆ subtractObjects() [10/14]

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

◆ subtractObjects() [11/14]

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

◆ subtractObjects() [12/14]

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

◆ subtractObjects() [13/14]

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

◆ subtractObjects() [14/14]

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

◆ subtractObjectScalar()

template<typename ResultType , typename Object , typename FactorType >
ResultType capd::vectalg::subtractObjectScalar ( const Object v,
const FactorType &  s 
)

this procedure can be used to substract a scalar from any element of vector-like objects result[i] = v[i] - s

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

◆ sumMultipointers()

Multipointer capd::vectalg::sumMultipointers ( const Multipointer x,
const Multipointer y 
)

◆ trace()

template<typename Scalar , __size_type rows, __size_type cols>
Matrix< Scalar, cols, rows >::ScalarType capd::vectalg::trace ( const Matrix< Scalar, cols, rows > &  A)

Computes Trace of a given matrix.

Trace is a sum of all elements on the main diagonal

◆ transpose()

template<typename Scalar , __size_type rows, __size_type cols>
Matrix< Scalar, cols, rows > capd::vectalg::transpose ( const Matrix< Scalar, rows, cols > &  a)

◆ Transpose()

template<typename Scalar , __size_type rows, __size_type cols>
Matrix< Scalar, cols, rows > capd::vectalg::Transpose ( const Matrix< Scalar, rows, cols > &  a)
inline

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

◆ Transpose< double, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

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

◆ Transpose< MpFloat, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

◆ Transpose< MpInt, CAPD_DEFAULT_DIMENSION, CAPD_DEFAULT_DIMENSION >()

◆ unaryMinus() [1/4]

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

◆ unaryMinus() [2/4]

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

◆ unaryMinus() [3/4]

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

◆ unaryMinus() [4/4]

template<typename ResultType , typename Object >
ResultType capd::vectalg::unaryMinus ( const Object v)

◆ vectorToString< IVector >()

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

◆ widths()

template<typename IObject >
IObject::template rebind< typenamecapd::TypeTraits< typenameIObject::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)