![]() |
Modules | |
Adaptors | |
Compile time constraints | |
Matrices | |
Vectors | |
Intrinsics | |
Quaternion | |
Serialization | |
Shims | |
Shared memory parallelization module | |
Solvers | |
Expression traits | |
Type traits | |
Views | |
Classes | |
class | blaze::NegativeAccuracy< A > |
Negative computation accuracy for floating point data types.The NegativeAccuracy class is a wrapper class around the functionality of the blaze::Limits class. It represents the negative computation accuracy of the Blaze library for any floating point data type. In order to assign a negative accuracy value, the NegativeAccuracy class can be implicitly converted to the three built-in floating point data types float, double and long double. More... | |
class | blaze::Accuracy |
Computation accuracy for floating point data types.The Accuracy class is a wrapper class around the functionality of the blaze::Limits class. It represents the computation accuracy of the Blaze library for any floating point data type. In order to assign an accuracy value, the Accuracy class can be implicitly converted to the three built-in floating point data types float, double and long double. In order to handle accuracy values conveniently, the global Accuracy instance blaze::accuracy is provided, which can be used wherever a floating point data value is required. More... | |
class | blaze::DenseIterator< Type > |
Implementation of a generic iterator for dense vectors and matrices.The DenseIterator represents a generic random-access iterator that can be used for dense vectors and specific rows/columns of dense matrices. More... | |
class | blaze::NegativeEpsilon< E > |
Negative epsilon value for floating point data types.The NegativeEpsilon class is a wrapper class around the functionality of the blaze::Limits class. It represents the negative smallest difference between two values of any floating point data type. In order to assign a negative epsilon value, the Epsilon class can be implicitly converted to the three built-in floating point data types float, double and long double. More... | |
class | blaze::Epsilon |
Numerical epsilon value for floating point data types.The Epsilon class is a wrapper class around the functionality of the blaze::Limits class. It represents the smallest difference between two values of any floating point data type. In order to assign an epsilon value, the Epsilon class can be implicitly converted to the three built-in floating point data types float, double and long double. In order to handle epsilon values conveniently, the global Epsilon instance blaze::epsilon is provided, which can be used wherever a floating point data type is required. More... | |
struct | blaze::AbsExpr |
Base class for all absolute value expression templates.The AbsExpr class serves as a tag for all expression templates that implement an absolute value operation. All classes, that represent an absolute value operation and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as absolute value expression template. Only in case a class is derived from the AbsExpr base class, the IsAbsExpr type trait recognizes the class as valid absolute value expression template. More... | |
struct | blaze::AddExpr |
Base class for all addition expression templates.The AddExpr class serves as a tag for all expression templates that implement mathematical additions. All classes, that represent a mathematical addition (vector additions and matrix additions) and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as addition expression template. Only in case a class is derived from the AddExpr base class, the IsAddExpr type trait recognizes the class as valid addition expression template. More... | |
struct | blaze::Column |
Base class for all columns.The Column class serves as a tag for all columns (i.e. dense and sparse columns). All classes that represent a column and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as a column. Only in case a class is derived from the Column base class, the IsColumn type trait recognizes the class as valid column. More... | |
struct | blaze::Computation |
Base class for all compute expression templates.The Computation class serves as a tag for all computational expression templates. All classes, that represent a mathematical computation (addition, subtraction, multiplication, division, absolute value calculation, ...) and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as computational expression template. Only in case a class is derived from the Computation base class, the IsComputation type trait recognizes the class as valid computational expression template. More... | |
struct | blaze::CrossExpr |
Base class for all cross product expression templates.The CrossExpr class serves as a tag for all expression templates that implement mathematical cross products. All classes, that represent a mathematical cross product and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as cross product expression template. Only in case a class is derived from the CrossExpr base class, the IsCrossExpr type trait recognizes the class as valid cross product expression template. More... | |
struct | blaze::DivExpr |
Base class for all division expression templates.The DivExpr class serves as a tag for all expression templates that implement mathematical divisions. All classes, that represent a mathematical division (vector/scalar divisions and matrix/scalar division) and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as division expression template. Only in case a class is derived from the DivExpr base class, the IsDivExpr type trait recognizes the class as valid division expression template. More... | |
struct | blaze::EvalExpr |
Base class for all evaluation expression templates.The EvalExpr class serves as a tag for all expression templates that implement an evaluation operation. All classes, that represent an evaluation operation and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as evaluation expression template. Only in case a class is derived from the EvalExpr base class, the IsEvalExpr type trait recognizes the class as valid evaluation expression template. More... | |
struct | blaze::Expression |
Base class for all expression templates.The Expression class is the base class for all expression templates. All classes, that represent a mathematical operation and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as expression template. Only in case a class is derived from the Expression base class, the IsExpression type trait recognizes the class as valid expression template. More... | |
struct | blaze::MatAbsExpr |
Base class for all matrix absolute value expression templates.The MatAbsExpr class serves as a tag for all expression templates that implement a matrix absolute value operation. All classes, that represent a matrix absolute value operation and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as matrix absolute value expression template. Only in case a class is derived from the MatAbsExpr base class, the IsMatAbsExpr type trait recognizes the class as valid matrix absolute value expression template. More... | |
struct | blaze::MatEvalExpr |
Base class for all matrix evaluation expression templates.The MatEvalExpr class serves as a tag for all expression templates that implement a matrix evaluation operation. All classes, that represent a matrix evaluation operation and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as matrix evaluation expression template. Only in case a class is derived from the MatEvalExpr base class, the IsMatEvalExpr type trait recognizes the class as valid matrix evaluation expression template. More... | |
struct | blaze::MatMatAddExpr |
Base class for all matrix/matrix addition expression templates.The MatMatAddExpr class serves as a tag for all expression templates that implement a matrix/matrix addition. All classes, that represent a matrix addition and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as matrix addition expression template. Only in case a class is derived from the MatMatAddExpr base class, the IsMatMatAddExpr type trait recognizes the class as valid matrix addition expression template. More... | |
struct | blaze::MatMatMultExpr |
Base class for all matrix/matrix multiplication expression templates.The MatMatMultExpr class serves as a tag for all expression templates that implement a matrix/matrix multiplication. All classes, that represent a matrix multiplication and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as matrix multiplication expression template. Only in case a class is derived from the MatMatMultExpr base class, the IsMatMatMultExpr type trait recognizes the class as valid matrix multiplication expression template. More... | |
struct | blaze::MatMatSubExpr |
Base class for all matrix/matrix subtraction expression templates.The MatMatSubExpr class serves as a tag for all expression templates that implement a matrix/matrix subtraction. All classes, that represent a matrix subtraction and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as matrix subtraction expression template. Only in case a class is derived from the MatMatSubExpr base class, the IsMatMatSubExpr type trait recognizes the class as valid matrix subtraction expression template. More... | |
struct | blaze::MatScalarDivExpr |
Base class for all matrix/scalar divsion expression templates.The MatScalarDivExpr class serves as a tag for all expression templates that implement a matrix/scalar divsion. All classes, that represent a matrix/scalar divsion and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as matrix/scalar divsion expression template. Only in case a class is derived from the MatScalarDivExpr base class, the IsMatScalarDivExpr type trait recognizes the class as valid matrix/scalar divsion expression template. More... | |
struct | blaze::MatScalarMultExpr |
Base class for all matrix/scalar multiplication expression templates.The MatScalarMultExpr class serves as a tag for all expression templates that implement a matrix/scalar multiplication. All classes, that represent a matrix/scalar multiplication and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as matrix/scalar multiplication expression template. Only in case a class is derived from the MatScalarMultExpr base class, the IsMatScalarMultExpr type trait recognizes the class as valid matrix/scalar multiplication expression template. More... | |
struct | blaze::MatSerialExpr |
Base class for all matrix serial evaluation expression templates.The MatSerialExpr class serves as a tag for all expression templates that enforce a serial evaluation of a matrix. All classes, that represent a matrix serialization operation and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as matrix serial evaluation expression template. Only in case a class is derived from the MatSerialExpr base class, the IsMatSerialExpr type trait recognizes the class as valid matrix serial evaluation expression template. More... | |
struct | blaze::MatTransExpr |
Base class for all matrix transposition expression templates.The MatTransExpr class serves as a tag for all expression templates that implement a matrix transposition operation. All classes, that represent a matrix transposition operation and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as matrix transposition expression template. Only in case a class is derived from the MatTransExpr base class, the IsMatTransExpr type trait recognizes the class as valid matrix transposition expression template. More... | |
struct | blaze::MatVecMultExpr |
Base class for all matrix/vector multiplication expression templates.The MatVecMultExpr class serves as a tag for all expression templates that implement a matrix/vector multiplication. All classes, that represent a matrix/vector multiplication and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as matrix/vector multiplication expression template. Only in case a class is derived from the MatVecMultExpr base class, the IsMatVecMultExpr type trait recognizes the class as valid matrix/vector multiplication expression template. More... | |
struct | blaze::MultExpr |
Base class for all multiplication expression templates.The MultExpr class serves as a tag for all expression templates that implement mathematical multiplications. All classes, that represent a mathematical multiplication (element-wise vector multiplications, matrix/vector multiplications, vector/matrix multiplications and matrix/matrix multiplications) and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as multiplication expression template. Only in case a class is derived from the MultExpr base class, the IsMultExpr type trait recognizes the class as valid multiplication expression template. More... | |
struct | blaze::Row |
Base class for all rows.The Row class serves as a tag for all rows (i.e. dense and sparse rows). All classes that represent a row and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as a row. Only in case a class is derived from the Row base class, the IsRow type trait recognizes the class as valid row. More... | |
struct | blaze::SerialExpr |
Base class for all serial evaluation expression templates.The SerialExpr class serves as a tag for all expression templates that enforce a serial evaluation. All classes, that represent a serialization operation and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as serial evaluation expression template. Only in case a class is derived from the SerialExpr base class, the IsSerialExpr type trait recognizes the class as valid serial evaluation expression template. More... | |
struct | blaze::SubExpr |
Base class for all subtraction expression templates.The SubExpr class serves as a tag for all expression templates that implement mathematical subtractions. All classes, that represent a mathematical subtraction (vector subtractions and matrix subtractions) and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as subtraction expression template. Only in case a class is derived from the SubExpr base class, the IsSubExpr type trait recognizes the class as valid subtraction expression template. More... | |
struct | blaze::Submatrix |
Base class for all submatrices.The Submatrix class serves as a tag for all submatrices (i.e. dense and sparse submatrices). All classes that represent a submatrix and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as a submatrix. Only in case a class is derived from the Submatrix base class, the IsSubmatrix type trait recognizes the class as valid submatrix. More... | |
struct | blaze::Subvector |
Base class for all subvectors.The Subvector class serves as a tag for all subvectors (i.e. dense and sparse subvectors). All classes that represent a subvector and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as a subvector. Only in case a class is derived from the Subvector base class, the IsSubvector type trait recognizes the class as valid subvector. More... | |
struct | blaze::TransExpr |
Base class for all transposition expression templates.The TransExpr class serves as a tag for all expression templates that implement mathematical transpositions. All classes, that represent a mathematical transposition (vector transpositions and matrix transpositions) and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as transposition expression template. Only in case a class is derived from the TransExpr base class, the IsTransExpr type trait recognizes the class as valid transposition expression template. More... | |
struct | blaze::TVecMatMultExpr |
Base class for all vector/matrix multiplication expression templates.The TVecMatMultExpr class serves as a tag for all expression templates that implement a vector/matrix multiplication. All classes, that represent a vector/matrix multiplication and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as vector/matrix multiplication expression template. Only in case a class is derived from the TVecMatMultExpr base class, the IsTVecMatMultExpr type trait recognizes the class as valid vector/matrix multiplication expression template. More... | |
struct | blaze::VecAbsExpr |
Base class for all vector absolute value expression templates.The VecAbsExpr class serves as a tag for all expression templates that implement a vector absolute value operation. All classes, that represent a vector absolute value operation and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as vector absolute value expression template. Only in case a class is derived from the VecAbsExpr base class, the IsVecAbsExpr type trait recognizes the class as valid vector absolute value expression template. More... | |
struct | blaze::VecEvalExpr |
Base class for all vector evaluation expression templates.The VecEvalExpr class serves as a tag for all expression templates that implement a vector evaluation operation. All classes, that represent a vector evaluation operation and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as vector evaluation expression template. Only in case a class is derived from the VecEvalExpr base class, the IsVecEvalExpr type trait recognizes the class as valid vector evaluation expression template. More... | |
struct | blaze::VecScalarDivExpr |
Base class for all vector/scalar division expression templates.The VecScalarDivExpr class serves as a tag for all expression templates that implement a vector/scalar division. All classes, that represent a vector/scalar division and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as vector/scalar division expression template. Only in case a class is derived from the VecScalarDivExpr base class, the IsVecScalarDivExpr type trait recognizes the class as valid vector/scalar division expression template. More... | |
struct | blaze::VecScalarMultExpr |
Base class for all vector/scalar multiplication expression templates.The VecScalarMultExpr class serves as a tag for all expression templates that implement a vector/scalar multiplication. All classes, that represent a vector/scalar multiplication and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as vector/scalar multiplication expression template. Only in case a class is derived from the VecScalarMultExpr base class, the IsVecScalarMultExpr type trait recognizes the class as valid vector/scalar multiplication expression template. More... | |
struct | blaze::VecSerialExpr |
Base class for all vector serial evaluation expression templates.The VecSerialExpr class serves as a tag for all expression templates that enforce a serial evaluation of a vector. All classes, that represent a vector serialization operation and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as vector serial evaluation expression template. Only in case a class is derived from the VecSerialExpr base class, the IsVecSerialExpr type trait recognizes the class as valid vector serial evaluation expression template. More... | |
struct | blaze::VecTransExpr |
Base class for all vector transposition expression templates.The VecTransExpr class serves as a tag for all expression templates that implement a vector transposition operation. All classes, that represent a vector transposition operation and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as vector transposition expression template. Only in case a class is derived from the VecTransExpr base class, the IsVecTransExpr type trait recognizes the class as valid vector transposition expression template. More... | |
struct | blaze::VecTVecMultExpr |
Base class for all outer product expression templates.The VecTVecMultExpr class serves as a tag for all expression templates that implement mathematical outer products (i.e. multiplications between a column vector and a row vector). All classes, that represent a mathematical outer product and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as outer product expression template. Only in case a class is derived from the VecTVecMultExpr base class, the IsVecTVecMultExpr type trait recognizes the class as valid outer product expression template. More... | |
struct | blaze::VecVecAddExpr |
Base class for all vector/vector addition expression templates.The VecVecAddExpr class serves as a tag for all expression templates that implement a vector/vector addition. All classes, that represent a vector addition and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as vector addition expression template. Only in case a class is derived from the VecVecAddExpr base class, the IsVecVecAddExpr type trait recognizes the class as valid vector addition expression template. More... | |
struct | blaze::VecVecMultExpr |
Base class for all vector/vector multiplication expression templates.The VecVecMultExpr class serves as a tag for all expression templates that implement a vector/vector multiplication. All classes, that represent a vector multiplication and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as vector multiplication expression template. Only in case a class is derived from the VecVecMultExpr base class, the IsVecVecMultExpr type trait recognizes the class as valid vector multiplication expression template. More... | |
struct | blaze::VecVecSubExpr |
Base class for all vector/vector subtraction expression templates.The VecVecSubExpr class serves as a tag for all expression templates that implement a vector/vector subtraction. All classes, that represent a vector subtraction and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as vector subtraction expression template. Only in case a class is derived from the VecVecSubExpr base class, the IsVecVecSubExpr type trait recognizes the class as valid vector subtraction expression template. More... | |
struct | blaze::View |
Base class for all views.The View class serves as a tag for all views (subvectors, submatrices, rows, columns, ...). All classes that represent a view and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as a view. Only in case a class is derived from the View base class, the IsView type trait recognizes the class as valid view. More... | |
class | blaze::NegativeInfinity< I > |
Negative infinity for built-in data types.The NegativeInfinity class is a wrapper class around the functionality of the blaze::Limits class to provide the possibility to assign negative infinity values to built-in data types. As negative infinity value, the largest possible negative value of the corresponding data type is used. In order to assign the negative infinity value, the NegativeInfinity class can be implicitly converted to all signed integral and floating point data types: More... | |
class | blaze::Infinity |
Positive infinity for built-in data types.The Infinity class is a wrapper class around the functionality of the blaze::Limits class to provide the possiblity to assign a positive infinity value to built-in data types. As positive infinity value, the largest possible positive value of the corresponding data type is used. In order to assign the positive infinity value, the Infinity class can be implicitly converted to the following 13 built-in integral and floating point data types: More... | |
struct | blaze::BoxLCP |
A box linear complementarity problem (BLCP) data structure.The BoxLCP class represent a box linear complementarity problem (BLCP) of the form ![]() | |
struct | blaze::ContactLCP |
A data structure for linear complementarity problems (LCPs) for contact mechanics.TODO. More... | |
struct | blaze::LCP |
A linear complementarity problem (LCP) data structure.The LCP class represent a linear complementarity problem of the form ![]() | |
struct | blaze::LSE |
A linear system of equations (LSE) data structure.The LSE class represent a linear system of equations of the form ![]() | |
struct | blaze::MixedLCP |
A mixed linear complementarity problem (MLCP) data structure.The LCP class represent a mixed linear complementarity problem of the form. More... | |
struct | blaze::ModifiedBoxLCP |
A modified box linear complementarity problem (MBLCP) data structure.The ModifiedBoxLCP class represent a modified box linear complementarity problem (MBLCP) of the form. More... | |
class | blaze::ComplexProxy< PT, CT > |
Proxy backend for complex types.The ComplexProxy class serves as a backend for the Proxy class. It is used in case the data type represented by the proxy is a complex number and augments the Proxy interface by the complete interface required of complex numbers. More... | |
class | blaze::DefaultProxy< PT, RT > |
Default proxy backend for built-in and alternate user-specific class types.The DefaultProxy class serves as a backend for the Proxy class. It is used in case the data type represented by the proxy is a built-in or alternate user-specific class type. This proxy does not augment the Proxy interface by any additional interface. More... | |
class | blaze::DenseMatrixProxy< PT, MT > |
Proxy backend for dense matrix types.The DenseMatrixProxy class serves as a backend for the Proxy class. It is used in case the data type represented by the proxy is a dense matrix and augments the Proxy interface by the complete interface required of dense matrices. More... | |
class | blaze::DenseVectorProxy< PT, VT > |
Proxy backend for dense vector types.The DenseVectorProxy class serves as a backend for the Proxy class. It is used in case the data type represented by the proxy is a dense vector and augments the Proxy interface by the complete interface required of dense vectors. More... | |
class | blaze::Proxy< PT, RT > |
Proxy base class.The Proxy class is a base class for all proxy classes within the Blaze library that may represent non-numeric data types (vectors, matrices, ...). It augments the interface of the deriving proxy class depending on the data type represented by the proxy. In addition, it provides an abstraction from the actual type of the proxy, but enables a type-safe conversion back to this type via the 'Curiously Recurring Template Pattern' (CRTP). More... | |
class | blaze::SparseMatrixProxy< PT, MT > |
Proxy backend for sparse matrix types.The SparseMatrixProxy class serves as a backend for the Proxy class. It is used in case the data type represented by the proxy is a sparse matrix and augments the Proxy interface by the complete interface required of sparse matrices. More... | |
class | blaze::SparseVectorProxy< PT, VT > |
Proxy backend for sparse vector types.The SparseVectorProxy class serves as a backend for the Proxy class. It is used in case the data type represented by the proxy is a sparse vector and augments the Proxy interface by the complete interface required of sparse vectors. More... | |
class | blaze::MatrixAccessProxy< MT > |
Access proxy for sparse, ![]() The proxied access to the elements of a sparse matrix is necessary since it may be possible that several insertion operations happen in the same statement. The following code illustrates this with two examples by means of the CompressedMatrix class: More... | |
struct | blaze::SparseElement |
Base class for all sparse element types.The SparseElement class is the base class for all sparse element types. All types that conceptually represent a sparse vector or matrix element and that provide a value() and an index() member function have to derive from this class in order to qualify as sparse element. Only in case a class is derived from the SparseElement base class, the IsSparseElement type trait recognizes the class as valid sparse element. More... | |
class | blaze::ValueIndexPair< Type > |
Index-value-pair for sparse vectors and matrices.The ValueIndexPair class represents a single index-value-pair of a sparse vector or sparse matrix. More... | |
class | blaze::VectorAccessProxy< VT > |
Access proxy for sparse, N-dimensional vectors.The VectorAccessProxy provides safe access to the elements of a non-const sparse vector. The proxied access to the elements of a sparse vector is necessary since it may be possible that several insertion operations happen in the same statement. The following code illustrates this with two examples by means of the CompressedVector class: More... | |
struct | blaze::AddTrait< T1, T2 > |
Base template for the AddTrait class. More... | |
struct | blaze::CMathTrait< T > |
Base template for the CMathTrait class.The CMathTrait template evaluates the return type of the mathematical functions defined in the C++ header <cmath> depending on the type of the template argument. In case of an integral data type or double precision argument, the return value of the functions is double, whereas the return type is float for single precision arguments and long double for long double precision arguments. More... | |
struct | blaze::ColumnTrait< MT > |
Base template for the ColumnTrait class. More... | |
struct | blaze::CrossTrait< T1, T2 > |
Base template for the CrossTrait class. More... | |
struct | blaze::DivTrait< T1, T2 > |
Base template for the DivTrait class. More... | |
struct | blaze::MathTrait< T1, T2 > |
Base template for the MathTrait class. More... | |
struct | blaze::MultTrait< T1, T2 > |
Base template for the MultTrait class. More... | |
struct | blaze::RowTrait< MT > |
Base template for the RowTrait class. More... | |
struct | blaze::SubmatrixTrait< MT > |
Base template for the SubmatrixTrait class. More... | |
struct | blaze::SubTrait< T1, T2 > |
Base template for the SubTrait class. More... | |
struct | blaze::SubvectorTrait< VT > |
Base template for the SubvectorTrait class. More... | |
Enumerations | |
enum | blaze::EulerRotation { blaze::XYZs = 0, blaze::ZYXr = 1, blaze::XYXs = 2, blaze::XYXr = 3, blaze::XZYs = 4, blaze::YZXr = 5, blaze::XZXs = 6, blaze::XZXr = 7, blaze::YZXs = 8, blaze::XZYr = 9, blaze::YZYs = 10, blaze::YZYr = 11, blaze::YXZs = 12, blaze::ZXYr = 13, blaze::YXYs = 14, blaze::YXYr = 15, blaze::ZXYs = 16, blaze::YXZr = 17, blaze::ZXZs = 18, blaze::ZXZr = 19, blaze::ZYXs = 20, blaze::XYZr = 21, blaze::ZYZs = 22, blaze::ZYZr = 23 } |
Order of the Euler rotationThis codes are needed for the EulerAngles function in order to calculate the Euler angles for a specific combination of rotations. More... | |
Variables | |
const Accuracy | blaze::accuracy |
Global Accuracy instance.The blaze::accuracy instance can be used wherever a floating point data type is expected. It is implicitly converted to the corresponding floating point data type and represents the computation accuracy of the Blaze library for the according data type. | |
const real | blaze::M_E = 2.7182818284590452353602874713526625 |
Definition of the mathematical constant ![]() | |
const real | blaze::M_LOG2E = 1.4426950408889634073599246810018921 |
Definition of the mathematical constant ![]() | |
const real | blaze::M_LOG10E = 0.4342944819032518276511289189166051 |
Definition of the mathematical constant ![]() | |
const real | blaze::M_LN2 = 0.6931471805599453094172321214581766 |
Definition of the mathematical constant ![]() | |
const real | blaze::M_LN10 = 2.3025850929940456840179914546843642 |
Definition of the mathematical constant ![]() | |
const real | blaze::M_PI = 3.1415926535897932384626433832795029 |
Definition of the mathematical constant ![]() | |
const real | blaze::M_SQRT2 = 1.4142135623730950488016887242096981 |
Definition of the mathematical constant ![]() | |
const real | blaze::M_SQRT3 = 1.7320508075688772935274463415058724 |
Definition of the mathematical constant ![]() | |
const Epsilon | blaze::epsilon |
Global Epsilon instance.The blaze::epsilon instance can be used wherever a floating point data type is expected. It is implicitly converted to the corresponding floating point data type and represents the smallest possible difference between two values of the according data type. | |
const Infinity | blaze::inf |
Global Infinity instance.The blaze::inf instance can be used wherever a built-in data type is expected. It is implicitly converted to the corresponding built-in data type and represents its largest possible data value. | |
Accuracy operators | |
template<typename A , typename T > | |
bool | blaze::operator== (const NegativeAccuracy< A > &, const T &rhs) |
Equality comparison between a NegativeAccuracy object and a floating point value. More... | |
template<typename A , typename T > | |
bool | blaze::operator== (const T &lhs, const NegativeAccuracy< A > &) |
Equality comparison between a floating point value and a NegativeAccuracy object. More... | |
template<typename A , typename T > | |
bool | blaze::operator!= (const NegativeAccuracy< A > &, const T &rhs) |
Inequality comparison between a NegativeAccuracy object and a floating point value. More... | |
template<typename A , typename T > | |
bool | blaze::operator!= (const T &lhs, const NegativeAccuracy< A > &) |
Inequality comparison between a floating point value and a NegativeAccuracy object. More... | |
template<typename T > | |
bool | blaze::operator== (const Accuracy &, const T &rhs) |
Equality comparison between an Accuracy object and a floating point value. More... | |
template<typename T > | |
bool | blaze::operator== (const T &lhs, const Accuracy &) |
Equality comparison between a floating point value and an Accuracy object. More... | |
template<typename T > | |
bool | blaze::operator!= (const Accuracy &, const T &rhs) |
Inequality comparison between an Accuracy object and a floating point value. More... | |
template<typename T > | |
bool | blaze::operator!= (const T &lhs, const Accuracy &) |
Inequality comparison between a floating point value and an Accuracy object. More... | |
template<typename A , typename T > | |
bool | blaze::operator< (const NegativeAccuracy< A > &, const T &rhs) |
Less-than comparison between a NegativeAccuracy object and a floating point value. More... | |
template<typename A , typename T > | |
bool | blaze::operator< (const T &lhs, const NegativeAccuracy< A > &) |
Less-than comparison between a floating point value and a NegativeAccuracy object. More... | |
template<typename A , typename T > | |
bool | blaze::operator> (const NegativeAccuracy< A > &, const T &rhs) |
Greater-than comparison between a NegativeAccuracy object and a floating point value. More... | |
template<typename A , typename T > | |
bool | blaze::operator> (const T &lhs, const NegativeAccuracy< A > &) |
Greater-than comparison between a floating point value and a NegativeAccuracy object. More... | |
template<typename T > | |
bool | blaze::operator< (const Accuracy &, const T &rhs) |
Less-than comparison between an Accuracy object and a floating point value. More... | |
template<typename T > | |
bool | blaze::operator< (const T &lhs, const Accuracy &) |
Less-than comparison between a floating point value and an Accuracy object. More... | |
template<typename T > | |
bool | blaze::operator> (const Accuracy &, const T &rhs) |
Greater-than comparison between an Accuracy object and a floating point value. More... | |
template<typename T > | |
bool | blaze::operator> (const T &lhs, const Accuracy &) |
Greater-than comparison between a floating point value and an Accuracy object. More... | |
template<typename T > | |
bool | blaze::operator<= (const Accuracy &, const T &rhs) |
Less-or-equal-than comparison between an Accuracy object and a floating point value. More... | |
template<typename T > | |
bool | blaze::operator<= (const T &lhs, const Accuracy &) |
Less-or-equal-than comparison between a floating point value and an Accuracy object. More... | |
template<typename T > | |
bool | blaze::operator>= (const Accuracy &, const T &rhs) |
Greater-or-equal-than comparison between an Accuracy object and a floating point value. More... | |
template<typename T > | |
bool | blaze::operator>= (const T &lhs, const Accuracy &) |
Less-or-equal-than comparison between a floating point value and an Accuracy object. More... | |
NonNumericProxy operators | |
template<typename MT1 , typename MT2 > | |
bool | blaze::operator== (const NonNumericProxy< MT1 > &lhs, const NonNumericProxy< MT2 > &rhs) |
Equality comparison between two NonNumericProxy objects. More... | |
template<typename MT , typename T > | |
bool | blaze::operator== (const NonNumericProxy< MT > &lhs, const T &rhs) |
Equality comparison between a NonNumericProxy object and an object of different type. More... | |
template<typename T , typename MT > | |
bool | blaze::operator== (const T &lhs, const NonNumericProxy< MT > &rhs) |
Equality comparison between an object of different type and a NonNumericProxy object. More... | |
template<typename MT1 , typename MT2 > | |
bool | blaze::operator!= (const NonNumericProxy< MT1 > &lhs, const NonNumericProxy< MT2 > &rhs) |
Inequality comparison between two NonNumericProxy objects. More... | |
template<typename MT , typename T > | |
bool | blaze::operator!= (const NonNumericProxy< MT > &lhs, const T &rhs) |
Inequality comparison between a NonNumericProxy object and an object of different type. More... | |
template<typename T , typename MT > | |
bool | blaze::operator!= (const T &lhs, const NonNumericProxy< MT > &rhs) |
Inquality comparison between an object of different type and a NonNumericProxy object. More... | |
template<typename MT1 , typename MT2 > | |
bool | blaze::operator< (const NonNumericProxy< MT1 > &lhs, const NonNumericProxy< MT2 > &rhs) |
Less-than comparison between two NonNumericProxy objects. More... | |
template<typename MT , typename T > | |
bool | blaze::operator< (const NonNumericProxy< MT > &lhs, const T &rhs) |
Less-than comparison between a NonNumericProxy object and an object of different type. More... | |
template<typename T , typename MT > | |
bool | blaze::operator< (const T &lhs, const NonNumericProxy< MT > &rhs) |
Less-than comparison between an object of different type and a NonNumericProxy object. More... | |
template<typename MT1 , typename MT2 > | |
bool | blaze::operator> (const NonNumericProxy< MT1 > &lhs, const NonNumericProxy< MT2 > &rhs) |
Greater-than comparison between two NonNumericProxy objects. More... | |
template<typename MT , typename T > | |
bool | blaze::operator> (const NonNumericProxy< MT > &lhs, const T &rhs) |
Greater-than comparison between a NonNumericProxy object and an object of different type. More... | |
template<typename T , typename MT > | |
bool | blaze::operator> (const T &lhs, const NonNumericProxy< MT > &rhs) |
Greater-than comparison between an object of different type and a NonNumericProxy object. More... | |
template<typename MT1 , typename MT2 > | |
bool | blaze::operator<= (const NonNumericProxy< MT1 > &lhs, const NonNumericProxy< MT2 > &rhs) |
Less-or-equal-than comparison between two NonNumericProxy objects. More... | |
template<typename MT , typename T > | |
bool | blaze::operator<= (const NonNumericProxy< MT > &lhs, const T &rhs) |
Less-or-equal-than comparison between a NonNumericProxy object and an object of different type. More... | |
template<typename T , typename MT > | |
bool | blaze::operator<= (const T &lhs, const NonNumericProxy< MT > &rhs) |
Less-or-equal-than comparison between an object of different type and a NonNumericProxy object. More... | |
template<typename MT1 , typename MT2 > | |
bool | blaze::operator>= (const NonNumericProxy< MT1 > &lhs, const NonNumericProxy< MT2 > &rhs) |
Greater-or-equal-than comparison between two NonNumericProxy objects. More... | |
template<typename MT , typename T > | |
bool | blaze::operator>= (const NonNumericProxy< MT > &lhs, const T &rhs) |
Greater-or-equal-than comparison between a NonNumericProxy object and an object of different type. More... | |
template<typename T , typename MT > | |
bool | blaze::operator>= (const T &lhs, const NonNumericProxy< MT > &rhs) |
Greater-or-equal-than comparison between an object of different type and a NonNumericProxy object. More... | |
template<typename MT > | |
std::ostream & | blaze::operator<< (std::ostream &os, const NonNumericProxy< MT > &proxy) |
Global output operator for the NonNumericProxy class template. More... | |
NonNumericProxy global functions | |
template<typename MT > | |
BLAZE_ALWAYS_INLINE void | blaze::reset (const NonNumericProxy< MT > &proxy) |
Resetting the represented element to the default initial values. More... | |
template<typename MT > | |
BLAZE_ALWAYS_INLINE void | blaze::clear (const NonNumericProxy< MT > &proxy) |
Clearing the represented element. More... | |
template<typename MT > | |
BLAZE_ALWAYS_INLINE bool | blaze::isDefault (const NonNumericProxy< MT > &proxy) |
Returns whether the represented element is in default state. More... | |
NegativeEpsilon operators | |
template<typename E , typename T > | |
bool | blaze::operator== (const NegativeEpsilon< E > &, const T &rhs) |
Equality comparison between a NegativeEpsilon object and a floating point value. More... | |
template<typename E , typename T > | |
bool | blaze::operator== (const T &lhs, const NegativeEpsilon< E > &) |
Equality comparison between a floating point value and a NegativeEpsilon object. More... | |
template<typename E , typename T > | |
bool | blaze::operator!= (const NegativeEpsilon< E > &, const T &rhs) |
Inequality comparison between a NegativeEpsilon object and a floating point value. More... | |
template<typename E , typename T > | |
bool | blaze::operator!= (const T &lhs, const NegativeEpsilon< E > &) |
Inequality comparison between a floating point value and a NegativeEpsilon object. More... | |
template<typename E , typename T > | |
bool | blaze::operator< (const NegativeEpsilon< E > &, const T &rhs) |
Less-than comparison between a NegativeEpsilon object and a floating point value. More... | |
template<typename E , typename T > | |
bool | blaze::operator< (const T &lhs, const NegativeEpsilon< E > &) |
Less-than comparison between a floating point value and a NegativeEpsilon object. More... | |
template<typename E , typename T > | |
bool | blaze::operator> (const NegativeEpsilon< E > &, const T &rhs) |
Greater-than comparison between a NegativeEpsilon object and a floating point value. More... | |
template<typename E , typename T > | |
bool | blaze::operator> (const T &lhs, const NegativeEpsilon< E > &) |
Greater-than comparison between a floating point value and a NegativeEpsilon object. More... | |
Epsilon operators | |
template<typename T > | |
bool | blaze::operator== (const Epsilon &, const T &rhs) |
Equality comparison between an Epsilon object and a floating point value. More... | |
template<typename T > | |
bool | blaze::operator== (const T &lhs, const Epsilon &) |
Equality comparison between a floating point value and an Epsilon object. More... | |
template<typename T > | |
bool | blaze::operator!= (const Epsilon &, const T &rhs) |
Inequality comparison between an Epsilon object and a floating point value. More... | |
template<typename T > | |
bool | blaze::operator!= (const T &lhs, const Epsilon &) |
Inequality comparison between a floating point value and an Epsilon object. More... | |
template<typename T > | |
bool | blaze::operator< (const Epsilon &, const T &rhs) |
Less-than comparison between an Epsilon object and a floating point value. More... | |
template<typename T > | |
bool | blaze::operator< (const T &lhs, const Epsilon &) |
Less-than comparison between a floating point value and an Epsilon object. More... | |
template<typename T > | |
bool | blaze::operator> (const Epsilon &, const T &rhs) |
Greater-than comparison between an Epsilon object and a floating point value. More... | |
template<typename T > | |
bool | blaze::operator> (const T &lhs, const Epsilon &) |
Greater-than comparison between a floating point value and an Epsilon object. More... | |
template<typename T > | |
bool | blaze::operator<= (const Epsilon &, const T &rhs) |
Less-or-equal-than comparison between an Epsilon object and a floating point value. More... | |
template<typename T > | |
bool | blaze::operator<= (const T &lhs, const Epsilon &) |
Less-or-equal-than comparison between a floating point value and an Epsilon object. More... | |
template<typename T > | |
bool | blaze::operator>= (const Epsilon &, const T &rhs) |
Greater-or-equal-than comparison between an Epsilon object and a floating point value. More... | |
template<typename T > | |
bool | blaze::operator>= (const T &lhs, const Epsilon &) |
Less-or-equal-than comparison between a floating point value and an Epsilon object. More... | |
Mathematical utility functions | |
template<typename T > | |
int | blaze::sign (T a) |
Sign function. More... | |
template<typename T > | |
size_t | blaze::digits (T a) |
Returns the number of valid digits of an integral value. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE const MathTrait< T1, T2 >::HighType | blaze::min (const T1 &a, const T2 &b) |
Minimum function for two arguments. More... | |
template<typename T1 , typename T2 , typename T3 > | |
BLAZE_ALWAYS_INLINE const MathTrait< typename MathTrait < T1, T2 >::HighType, T3 > ::HighType | blaze::min (const T1 &a, const T2 &b, const T3 &c) |
Minimum function for three arguments. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE const MathTrait< T1, T2 >::HighType | blaze::max (const T1 &a, const T2 &b) |
Maximum function for two arguments. More... | |
template<typename T1 , typename T2 , typename T3 > | |
BLAZE_ALWAYS_INLINE const MathTrait< typename MathTrait < T1, T2 >::HighType, T3 > ::HighType | blaze::max (const T1 &a, const T2 &b, const T3 &c) |
Maximum function for three arguments. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE T | blaze::round (T a) |
Rounds the given input value. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE bool | blaze::lessThan (T1 a, T2 b) |
Generic less-than comparison. More... | |
NegativeInfinity operators | |
template<typename I1 , typename I2 > | |
bool | blaze::operator== (const NegativeInfinity< I1 > &lhs, const NegativeInfinity< I2 > &rhs) |
Equality comparison between two NegativeInfinity objects. More... | |
template<typename I , typename T > | |
bool | blaze::operator== (const NegativeInfinity< I > &lhs, const T &rhs) |
Equality comparison between an NegativeInfinity object and a built-in data type. More... | |
template<typename I , typename T > | |
bool | blaze::operator== (const T &lhs, const NegativeInfinity< I > &rhs) |
Equality comparison between a built-in data type and an NegativeInfinity object. More... | |
template<typename I1 , typename I2 > | |
bool | blaze::operator!= (const NegativeInfinity< I1 > &lhs, const NegativeInfinity< I2 > &rhs) |
Inequality comparison between two NegativeInfinity objects. More... | |
template<typename I , typename T > | |
bool | blaze::operator!= (const NegativeInfinity< I > &lhs, const T &rhs) |
Inequality comparison between an NegativeInfinity object and a built-in data type. More... | |
template<typename I , typename T > | |
bool | blaze::operator!= (const T &lhs, const NegativeInfinity< I > &rhs) |
Inequality comparison between a built-in data type and an NegativeInfinity object. More... | |
Infinity operators | |
bool | blaze::operator== (const Infinity &lhs, const Infinity &rhs) |
Equality comparison between two Infinity objects. More... | |
template<typename I > | |
bool | blaze::operator== (const Infinity &lhs, const NegativeInfinity< I > &rhs) |
Equality comparison between an Infinity object and a NegativeInfinity object. More... | |
template<typename I > | |
bool | blaze::operator== (const NegativeInfinity< I > &lhs, const Infinity &rhs) |
Equality comparison between a NegativeInfinity object and an Infinity object. More... | |
template<typename T > | |
bool | blaze::operator== (const Infinity &lhs, const T &rhs) |
Equality comparison between an Infinity object and a built-in data type. More... | |
template<typename T > | |
bool | blaze::operator== (const T &lhs, const Infinity &rhs) |
Equality comparison between a built-in data type and an Infinity object. More... | |
bool | blaze::operator!= (const Infinity &lhs, const Infinity &rhs) |
Inequality comparison between two Infinity objects. More... | |
template<typename I > | |
bool | blaze::operator!= (const Infinity &lhs, const NegativeInfinity< I > &rhs) |
Inequality comparison between an Infinity object and a NegativeInfinity object. More... | |
template<typename I > | |
bool | blaze::operator!= (const NegativeInfinity< I > &lhs, const Infinity &rhs) |
Inequality comparison between a NegativeInfinity object and an Infinity object. More... | |
template<typename T > | |
bool | blaze::operator!= (const Infinity &lhs, const T &rhs) |
Inequality comparison between an Infinity object and a built-in data type. More... | |
template<typename T > | |
bool | blaze::operator!= (const T &lhs, const Infinity &rhs) |
Inequality comparison between a built-in data type and an Infinity object. More... | |
DenseMatrixProxy global functions | |
template<typename PT , typename MT > | |
BLAZE_ALWAYS_INLINE DenseMatrixProxy< PT, MT > ::Iterator | blaze::begin (const DenseMatrixProxy< PT, MT > &proxy, size_t i) |
Returns an iterator to the first element of row/column i of the represented matrix. More... | |
template<typename PT , typename MT > | |
BLAZE_ALWAYS_INLINE DenseMatrixProxy< PT, MT > ::ConstIterator | blaze::cbegin (const DenseMatrixProxy< PT, MT > &proxy, size_t i) |
Returns an iterator to the first element of row/column i of the represented matrix. More... | |
template<typename PT , typename MT > | |
BLAZE_ALWAYS_INLINE DenseMatrixProxy< PT, MT > ::Iterator | blaze::end (const DenseMatrixProxy< PT, MT > &proxy, size_t i) |
Returns an iterator just past the last element of row/column i of the represented matrix. More... | |
template<typename PT , typename MT > | |
BLAZE_ALWAYS_INLINE DenseMatrixProxy< PT, MT > ::ConstIterator | blaze::cend (const DenseMatrixProxy< PT, MT > &proxy, size_t i) |
Returns an iterator just past the last element of row/column i of the represented matrix. More... | |
template<typename PT , typename MT > | |
BLAZE_ALWAYS_INLINE size_t | blaze::rows (const DenseMatrixProxy< PT, MT > &proxy) |
Returns the current number of rows of the represented matrix. More... | |
template<typename PT , typename MT > | |
BLAZE_ALWAYS_INLINE size_t | blaze::columns (const DenseMatrixProxy< PT, MT > &proxy) |
Returns the current number of columns of the represented matrix. More... | |
template<typename PT , typename MT > | |
BLAZE_ALWAYS_INLINE size_t | blaze::capacity (const DenseMatrixProxy< PT, MT > &proxy) |
Returns the maximum capacity of the represented matrix. More... | |
template<typename PT , typename MT > | |
BLAZE_ALWAYS_INLINE size_t | blaze::capacity (const DenseMatrixProxy< PT, MT > &proxy, size_t i) |
Returns the current capacity of the specified row/column of the represented matrix. More... | |
template<typename PT , typename MT > | |
BLAZE_ALWAYS_INLINE size_t | blaze::nonZeros (const DenseMatrixProxy< PT, MT > &proxy) |
Returns the number of non-zero elements in the represented matrix. More... | |
template<typename PT , typename MT > | |
BLAZE_ALWAYS_INLINE size_t | blaze::nonZeros (const DenseMatrixProxy< PT, MT > &proxy, size_t i) |
Returns the number of non-zero elements in the specified row/column of the represented matrix. More... | |
template<typename PT , typename MT > | |
BLAZE_ALWAYS_INLINE void | blaze::reset (const DenseMatrixProxy< PT, MT > &proxy) |
Resetting the represented element to the default initial values. More... | |
template<typename PT , typename MT > | |
BLAZE_ALWAYS_INLINE void | blaze::reset (const DenseMatrixProxy< PT, MT > &proxy, size_t i) |
Reset the specified row/column of the represented matrix. More... | |
template<typename PT , typename MT > | |
BLAZE_ALWAYS_INLINE void | blaze::clear (const DenseMatrixProxy< PT, MT > &proxy) |
Clearing the represented matrix. More... | |
DenseVectorProxy global functions | |
template<typename PT , typename VT > | |
BLAZE_ALWAYS_INLINE DenseVectorProxy< PT, VT > ::Iterator | blaze::begin (const DenseVectorProxy< PT, VT > &proxy) |
Returns an iterator to the first element of the represented vector. More... | |
template<typename PT , typename VT > | |
BLAZE_ALWAYS_INLINE DenseVectorProxy< PT, VT > ::ConstIterator | blaze::cbegin (const DenseVectorProxy< PT, VT > &proxy) |
Returns an iterator to the first element of the represented vector. More... | |
template<typename PT , typename VT > | |
BLAZE_ALWAYS_INLINE DenseVectorProxy< PT, VT > ::Iterator | blaze::end (const DenseVectorProxy< PT, VT > &proxy) |
Returns an iterator just past the last element of the represented vector. More... | |
template<typename PT , typename VT > | |
BLAZE_ALWAYS_INLINE DenseVectorProxy< PT, VT > ::ConstIterator | blaze::cend (const DenseVectorProxy< PT, VT > &proxy) |
Returns an iterator just past the last element of the represented vector. More... | |
template<typename PT , typename VT > | |
BLAZE_ALWAYS_INLINE size_t | blaze::size (const DenseVectorProxy< PT, VT > &proxy) |
Returns the current size/dimension of the represented vector. More... | |
template<typename PT , typename VT > | |
BLAZE_ALWAYS_INLINE size_t | blaze::capacity (const DenseVectorProxy< PT, VT > &proxy) |
Returns the maximum capacity of the represented vector. More... | |
template<typename PT , typename VT > | |
BLAZE_ALWAYS_INLINE size_t | blaze::nonZeros (const DenseVectorProxy< PT, VT > &proxy) |
Returns the number of non-zero elements in the represented vector. More... | |
template<typename PT , typename VT > | |
BLAZE_ALWAYS_INLINE void | blaze::reset (const DenseVectorProxy< PT, VT > &proxy) |
Resetting the represented vector to the default initial values. More... | |
template<typename PT , typename VT > | |
BLAZE_ALWAYS_INLINE void | blaze::clear (const DenseVectorProxy< PT, VT > &proxy) |
Clearing the represented vector. More... | |
SparseMatrixProxy global functions | |
template<typename PT , typename MT > | |
BLAZE_ALWAYS_INLINE SparseMatrixProxy< PT, MT > ::Iterator | blaze::begin (const SparseMatrixProxy< PT, MT > &proxy, size_t i) |
Returns an iterator to the first element of row/column i of the represented matrix. More... | |
template<typename PT , typename MT > | |
BLAZE_ALWAYS_INLINE SparseMatrixProxy< PT, MT > ::ConstIterator | blaze::cbegin (const SparseMatrixProxy< PT, MT > &proxy, size_t i) |
Returns an iterator to the first element of row/column i of the represented matrix. More... | |
template<typename PT , typename MT > | |
BLAZE_ALWAYS_INLINE SparseMatrixProxy< PT, MT > ::Iterator | blaze::end (const SparseMatrixProxy< PT, MT > &proxy, size_t i) |
Returns an iterator just past the last element of row/column i of the represented matrix. More... | |
template<typename PT , typename MT > | |
BLAZE_ALWAYS_INLINE SparseMatrixProxy< PT, MT > ::ConstIterator | blaze::cend (const SparseMatrixProxy< PT, MT > &proxy, size_t i) |
Returns an iterator just past the last element of row/column i of the represented matrix. More... | |
template<typename PT , typename MT > | |
BLAZE_ALWAYS_INLINE size_t | blaze::rows (const SparseMatrixProxy< PT, MT > &proxy) |
Returns the current number of rows of the represented matrix. More... | |
template<typename PT , typename MT > | |
BLAZE_ALWAYS_INLINE size_t | blaze::columns (const SparseMatrixProxy< PT, MT > &proxy) |
Returns the current number of columns of the represented matrix. More... | |
template<typename PT , typename MT > | |
BLAZE_ALWAYS_INLINE size_t | blaze::capacity (const SparseMatrixProxy< PT, MT > &proxy) |
Returns the maximum capacity of the represented matrix. More... | |
template<typename PT , typename MT > | |
BLAZE_ALWAYS_INLINE size_t | blaze::capacity (const SparseMatrixProxy< PT, MT > &proxy, size_t i) |
Returns the current capacity of the specified row/column of the represented matrix. More... | |
template<typename PT , typename MT > | |
BLAZE_ALWAYS_INLINE size_t | blaze::nonZeros (const SparseMatrixProxy< PT, MT > &proxy) |
Returns the number of non-zero elements in the represented matrix. More... | |
template<typename PT , typename MT > | |
BLAZE_ALWAYS_INLINE size_t | blaze::nonZeros (const SparseMatrixProxy< PT, MT > &proxy, size_t i) |
Returns the number of non-zero elements in the specified row/column of the represented matrix. More... | |
template<typename PT , typename MT > | |
BLAZE_ALWAYS_INLINE void | blaze::reset (const SparseMatrixProxy< PT, MT > &proxy) |
Resetting the represented element to the default initial values. More... | |
template<typename PT , typename MT > | |
BLAZE_ALWAYS_INLINE void | blaze::reset (const SparseMatrixProxy< PT, MT > &proxy, size_t i) |
Reset the specified row/column of the represented matrix. More... | |
template<typename PT , typename MT > | |
BLAZE_ALWAYS_INLINE void | blaze::clear (const SparseMatrixProxy< PT, MT > &proxy) |
Clearing the represented matrix. More... | |
SparseVectorProxy global functions | |
template<typename PT , typename VT > | |
BLAZE_ALWAYS_INLINE SparseVectorProxy< PT, VT > ::Iterator | blaze::begin (const SparseVectorProxy< PT, VT > &proxy) |
Returns an iterator to the first element of the represented vector. More... | |
template<typename PT , typename VT > | |
BLAZE_ALWAYS_INLINE SparseVectorProxy< PT, VT > ::ConstIterator | blaze::cbegin (const SparseVectorProxy< PT, VT > &proxy) |
Returns an iterator to the first element of the represented vector. More... | |
template<typename PT , typename VT > | |
BLAZE_ALWAYS_INLINE SparseVectorProxy< PT, VT > ::Iterator | blaze::end (const SparseVectorProxy< PT, VT > &proxy) |
Returns an iterator just past the last element of the represented vector. More... | |
template<typename PT , typename VT > | |
BLAZE_ALWAYS_INLINE SparseVectorProxy< PT, VT > ::ConstIterator | blaze::cend (const SparseVectorProxy< PT, VT > &proxy) |
Returns an iterator just past the last element of the represented vector. More... | |
template<typename PT , typename VT > | |
BLAZE_ALWAYS_INLINE size_t | blaze::size (const SparseVectorProxy< PT, VT > &proxy) |
Returns the current size/dimension of the represented vector. More... | |
template<typename PT , typename VT > | |
BLAZE_ALWAYS_INLINE size_t | blaze::capacity (const SparseVectorProxy< PT, VT > &proxy) |
Returns the maximum capacity of the represented vector. More... | |
template<typename PT , typename VT > | |
BLAZE_ALWAYS_INLINE size_t | blaze::nonZeros (const SparseVectorProxy< PT, VT > &proxy) |
Returns the number of non-zero elements in the represented vector. More... | |
template<typename PT , typename VT > | |
BLAZE_ALWAYS_INLINE void | blaze::reset (const SparseVectorProxy< PT, VT > &proxy) |
Resetting the represented element to the default initial values. More... | |
template<typename PT , typename VT > | |
BLAZE_ALWAYS_INLINE void | blaze::clear (const SparseVectorProxy< PT, VT > &proxy) |
Clearing the represented element. More... | |
MatrixAccessProxy operators | |
template<typename MT1 , typename MT2 > | |
bool | blaze::operator== (const MatrixAccessProxy< MT1 > &lhs, const MatrixAccessProxy< MT2 > &rhs) |
Equality comparison between two MatrixAccessProxy objects. More... | |
template<typename MT , typename T > | |
bool | blaze::operator== (const MatrixAccessProxy< MT > &lhs, const T &rhs) |
Equality comparison between a MatrixAccessProxy object and an object of different type. More... | |
template<typename T , typename MT > | |
bool | blaze::operator== (const T &lhs, const MatrixAccessProxy< MT > &rhs) |
Equality comparison between an object of different type and a MatrixAccessProxy object. More... | |
template<typename MT1 , typename MT2 > | |
bool | blaze::operator!= (const MatrixAccessProxy< MT1 > &lhs, const MatrixAccessProxy< MT2 > &rhs) |
Inequality comparison between two MatrixAccessProxy objects. More... | |
template<typename MT , typename T > | |
bool | blaze::operator!= (const MatrixAccessProxy< MT > &lhs, const T &rhs) |
Inequality comparison between a MatrixAccessProxy object and an object of different type. More... | |
template<typename T , typename MT > | |
bool | blaze::operator!= (const T &lhs, const MatrixAccessProxy< MT > &rhs) |
Inquality comparison between an object of different type and a MatrixAccessProxy object. More... | |
template<typename MT1 , typename MT2 > | |
bool | blaze::operator< (const MatrixAccessProxy< MT1 > &lhs, const MatrixAccessProxy< MT2 > &rhs) |
Less-than comparison between two MatrixAccessProxy objects. More... | |
template<typename MT , typename T > | |
bool | blaze::operator< (const MatrixAccessProxy< MT > &lhs, const T &rhs) |
Less-than comparison between a MatrixAccessProxy object and an object of different type. More... | |
template<typename T , typename MT > | |
bool | blaze::operator< (const T &lhs, const MatrixAccessProxy< MT > &rhs) |
Less-than comparison between an object of different type and a MatrixAccessProxy object. More... | |
template<typename MT1 , typename MT2 > | |
bool | blaze::operator> (const MatrixAccessProxy< MT1 > &lhs, const MatrixAccessProxy< MT2 > &rhs) |
Greater-than comparison between two MatrixAccessProxy objects. More... | |
template<typename MT , typename T > | |
bool | blaze::operator> (const MatrixAccessProxy< MT > &lhs, const T &rhs) |
Greater-than comparison between a MatrixAccessProxy object and an object of different type. More... | |
template<typename T , typename MT > | |
bool | blaze::operator> (const T &lhs, const MatrixAccessProxy< MT > &rhs) |
Greater-than comparison between an object of different type and a MatrixAccessProxy object. More... | |
template<typename MT1 , typename MT2 > | |
bool | blaze::operator<= (const MatrixAccessProxy< MT1 > &lhs, const MatrixAccessProxy< MT2 > &rhs) |
Less-or-equal-than comparison between two MatrixAccessProxy objects. More... | |
template<typename MT , typename T > | |
bool | blaze::operator<= (const MatrixAccessProxy< MT > &lhs, const T &rhs) |
Less-or-equal-than comparison between a MatrixAccessProxy object and an object of different type. More... | |
template<typename T , typename MT > | |
bool | blaze::operator<= (const T &lhs, const MatrixAccessProxy< MT > &rhs) |
Less-or-equal-than comparison between an object of different type and a MatrixAccessProxy object. More... | |
template<typename MT1 , typename MT2 > | |
bool | blaze::operator>= (const MatrixAccessProxy< MT1 > &lhs, const MatrixAccessProxy< MT2 > &rhs) |
Greater-or-equal-than comparison between two MatrixAccessProxy objects. More... | |
template<typename MT , typename T > | |
bool | blaze::operator>= (const MatrixAccessProxy< MT > &lhs, const T &rhs) |
Greater-or-equal-than comparison between a MatrixAccessProxy object and an object of different type. More... | |
template<typename T , typename MT > | |
bool | blaze::operator>= (const T &lhs, const MatrixAccessProxy< MT > &rhs) |
Greater-or-equal-than comparison between an object of different type and a MatrixAccessProxy object. More... | |
template<typename MT > | |
std::ostream & | blaze::operator<< (std::ostream &os, const MatrixAccessProxy< MT > &proxy) |
Global output operator for the MatrixAccessProxy class template. More... | |
MatrixAccessProxy global functions | |
template<typename MT > | |
void | blaze::reset (const MatrixAccessProxy< MT > &proxy) |
Resetting the represented element to the default initial values. More... | |
template<typename MT > | |
void | blaze::clear (const MatrixAccessProxy< MT > &proxy) |
Clearing the represented element. More... | |
template<typename MT > | |
bool | blaze::isDefault (const MatrixAccessProxy< MT > &proxy) |
Returns whether the represented element is in default state. More... | |
template<typename MT > | |
void | blaze::swap (const MatrixAccessProxy< MT > &a, const MatrixAccessProxy< MT > &b) |
Swapping the contents of two access proxies. More... | |
template<typename MT , typename T > | |
void | blaze::swap (const MatrixAccessProxy< MT > &a, T &b) |
Swapping the contents of an access proxy with another element. More... | |
template<typename T , typename MT > | |
void | blaze::swap (T &a, const MatrixAccessProxy< MT > &b) |
Swapping the contents of an access proxy with another element. More... | |
VectorAccessProxy operators | |
template<typename VT1 , typename VT2 > | |
bool | blaze::operator== (const VectorAccessProxy< VT1 > &lhs, const VectorAccessProxy< VT2 > &rhs) |
Equality comparison between two VectorAccessProxy objects. More... | |
template<typename VT , typename T > | |
bool | blaze::operator== (const VectorAccessProxy< VT > &lhs, const T &rhs) |
Equality comparison between a VectorAccessProxy object and an object of different type. More... | |
template<typename T , typename VT > | |
bool | blaze::operator== (const T &lhs, const VectorAccessProxy< VT > &rhs) |
Equality comparison between an object of different type and a VectorAccessProxy object. More... | |
template<typename VT1 , typename VT2 > | |
bool | blaze::operator!= (const VectorAccessProxy< VT1 > &lhs, const VectorAccessProxy< VT2 > &rhs) |
Inequality comparison between two VectorAccessProxy objects. More... | |
template<typename VT , typename T > | |
bool | blaze::operator!= (const VectorAccessProxy< VT > &lhs, const T &rhs) |
Inequality comparison between a VectorAccessProxy object and an object of different type. More... | |
template<typename T , typename VT > | |
bool | blaze::operator!= (const T &lhs, const VectorAccessProxy< VT > &rhs) |
Inquality comparison between an object of different type and a VectorAccessProxy object. More... | |
template<typename VT1 , typename VT2 > | |
bool | blaze::operator< (const VectorAccessProxy< VT1 > &lhs, const VectorAccessProxy< VT2 > &rhs) |
Less-than comparison between two VectorAccessProxy objects. More... | |
template<typename VT , typename T > | |
bool | blaze::operator< (const VectorAccessProxy< VT > &lhs, const T &rhs) |
Less-than comparison between a VectorAccessProxy object and an object of different type. More... | |
template<typename T , typename VT > | |
bool | blaze::operator< (const T &lhs, const VectorAccessProxy< VT > &rhs) |
Less-than comparison between an object of different type and a VectorAccessProxy object. More... | |
template<typename VT1 , typename VT2 > | |
bool | blaze::operator> (const VectorAccessProxy< VT1 > &lhs, const VectorAccessProxy< VT2 > &rhs) |
Greater-than comparison between two VectorAccessProxy objects. More... | |
template<typename VT , typename T > | |
bool | blaze::operator> (const VectorAccessProxy< VT > &lhs, const T &rhs) |
Greater-than comparison between a VectorAccessProxy object and an object of different type. More... | |
template<typename T , typename VT > | |
bool | blaze::operator> (const T &lhs, const VectorAccessProxy< VT > &rhs) |
Greater-than comparison between an object of different type and a VectorAccessProxy object. More... | |
template<typename VT1 , typename VT2 > | |
bool | blaze::operator<= (const VectorAccessProxy< VT1 > &lhs, const VectorAccessProxy< VT2 > &rhs) |
Less-or-equal-than comparison between two VectorAccessProxy objects. More... | |
template<typename VT , typename T > | |
bool | blaze::operator<= (const VectorAccessProxy< VT > &lhs, const T &rhs) |
Less-or-equal-than comparison between a VectorAccessProxy object and an object of different type. More... | |
template<typename T , typename VT > | |
bool | blaze::operator<= (const T &lhs, const VectorAccessProxy< VT > &rhs) |
Less-or-equal-than comparison between an object of different type and a VectorAccessProxy object. More... | |
template<typename VT1 , typename VT2 > | |
bool | blaze::operator>= (const VectorAccessProxy< VT1 > &lhs, const VectorAccessProxy< VT2 > &rhs) |
Greater-or-equal-than comparison between two VectorAccessProxy objects. More... | |
template<typename VT , typename T > | |
bool | blaze::operator>= (const VectorAccessProxy< VT > &lhs, const T &rhs) |
Greater-or-equal-than comparison between a VectorAccessProxy object and an object of different type. More... | |
template<typename T , typename VT > | |
bool | blaze::operator>= (const T &lhs, const VectorAccessProxy< VT > &rhs) |
Greater-or-equal-than comparison between an object of different type and a VectorAccessProxy object. More... | |
template<typename VT > | |
std::ostream & | blaze::operator<< (std::ostream &os, const VectorAccessProxy< VT > &proxy) |
Global output operator for the VectorAccessProxy class template. More... | |
VectorAccessProxy global functions | |
template<typename VT > | |
void | blaze::reset (const VectorAccessProxy< VT > &proxy) |
Resetting the represented element to the default initial values. More... | |
template<typename VT > | |
void | blaze::clear (const VectorAccessProxy< VT > &proxy) |
Clearing the represented element. More... | |
template<typename VT > | |
bool | blaze::isDefault (const VectorAccessProxy< VT > &proxy) |
Returns whether the represented element is in default state. More... | |
template<typename VT > | |
void | blaze::swap (const VectorAccessProxy< VT > &a, const VectorAccessProxy< VT > &b) |
Swapping the contents of two access proxies. More... | |
template<typename VT , typename T > | |
void | blaze::swap (const VectorAccessProxy< VT > &a, T &b) |
Swapping the contents of an access proxy with another element. More... | |
template<typename T , typename VT > | |
void | blaze::swap (T &a, const VectorAccessProxy< VT > &b) |
Swapping the contents of an access proxy with another element. More... | |
enum blaze::EulerRotation |
Order of the Euler rotationThis codes are needed for the EulerAngles function in order to calculate the Euler angles for a specific combination of rotations.
BLAZE_ALWAYS_INLINE DenseVectorProxy< PT, VT >::Iterator blaze::begin | ( | const DenseVectorProxy< PT, VT > & | proxy | ) |
Returns an iterator to the first element of the represented vector.
proxy | The given access proxy. |
BLAZE_ALWAYS_INLINE DenseMatrixProxy< PT, MT >::Iterator blaze::begin | ( | const DenseMatrixProxy< PT, MT > & | proxy, |
size_t | i | ||
) |
Returns an iterator to the first element of row/column i of the represented matrix.
proxy | The given access proxy. |
i | The row/column index. |
This function returns a row/column iterator to the first element of row/column i. In case the given matrix is a row-major matrix the function returns an iterator to the first element of row i, in case it is a column-major matrix the function returns an iterator to the first element of column i.
BLAZE_ALWAYS_INLINE SparseVectorProxy< PT, VT >::Iterator blaze::begin | ( | const SparseVectorProxy< PT, VT > & | proxy | ) |
Returns an iterator to the first element of the represented vector.
proxy | The given access proxy. |
BLAZE_ALWAYS_INLINE SparseMatrixProxy< PT, MT >::Iterator blaze::begin | ( | const SparseMatrixProxy< PT, MT > & | proxy, |
size_t | i | ||
) |
Returns an iterator to the first element of row/column i of the represented matrix.
proxy | The given access proxy. |
i | The row/column index. |
This function returns a row/column iterator to the first element of row/column i. In case the given matrix is a row-major matrix the function returns an iterator to the first element of row i, in case it is a column-major matrix the function returns an iterator to the first element of column i.
BLAZE_ALWAYS_INLINE size_t blaze::capacity | ( | const DenseVectorProxy< PT, VT > & | proxy | ) |
Returns the maximum capacity of the represented vector.
proxy | The given access proxy. |
BLAZE_ALWAYS_INLINE size_t blaze::capacity | ( | const DenseMatrixProxy< PT, MT > & | proxy | ) |
Returns the maximum capacity of the represented matrix.
proxy | The given access proxy. |
BLAZE_ALWAYS_INLINE size_t blaze::capacity | ( | const DenseMatrixProxy< PT, MT > & | proxy, |
size_t | i | ||
) |
Returns the current capacity of the specified row/column of the represented matrix.
proxy | The given access proxy. |
i | The index of the row/column. |
This function returns the current capacity of the specified row/column. In case the storage order is set to rowMajor the function returns the capacity of row i, in case the storage flag is set to columnMajor the function returns the capacity of column i.
BLAZE_ALWAYS_INLINE size_t blaze::capacity | ( | const SparseVectorProxy< PT, VT > & | proxy | ) |
Returns the maximum capacity of the represented vector.
proxy | The given access proxy. |
BLAZE_ALWAYS_INLINE size_t blaze::capacity | ( | const SparseMatrixProxy< PT, MT > & | proxy | ) |
Returns the maximum capacity of the represented matrix.
proxy | The given access proxy. |
BLAZE_ALWAYS_INLINE size_t blaze::capacity | ( | const SparseMatrixProxy< PT, MT > & | proxy, |
size_t | i | ||
) |
Returns the current capacity of the specified row/column of the represented matrix.
proxy | The given access proxy. |
i | The index of the row/column. |
This function returns the current capacity of the specified row/column. In case the storage order is set to rowMajor the function returns the capacity of row i, in case the storage flag is set to columnMajor the function returns the capacity of column i.
BLAZE_ALWAYS_INLINE DenseVectorProxy< PT, VT >::ConstIterator blaze::cbegin | ( | const DenseVectorProxy< PT, VT > & | proxy | ) |
Returns an iterator to the first element of the represented vector.
proxy | The given access proxy. |
BLAZE_ALWAYS_INLINE DenseMatrixProxy< PT, MT >::ConstIterator blaze::cbegin | ( | const DenseMatrixProxy< PT, MT > & | proxy, |
size_t | i | ||
) |
Returns an iterator to the first element of row/column i of the represented matrix.
proxy | The given access proxy. |
i | The row/column index. |
This function returns a row/column iterator to the first element of row/column i. In case the given matrix is a row-major matrix the function returns an iterator to the first element of row i, in case it is a column-major matrix the function returns an iterator to the first element of column i.
BLAZE_ALWAYS_INLINE SparseVectorProxy< PT, VT >::ConstIterator blaze::cbegin | ( | const SparseVectorProxy< PT, VT > & | proxy | ) |
Returns an iterator to the first element of the represented vector.
proxy | The given access proxy. |
BLAZE_ALWAYS_INLINE SparseMatrixProxy< PT, MT >::ConstIterator blaze::cbegin | ( | const SparseMatrixProxy< PT, MT > & | proxy, |
size_t | i | ||
) |
Returns an iterator to the first element of row/column i of the represented matrix.
proxy | The given access proxy. |
i | The row/column index. |
This function returns a row/column iterator to the first element of row/column i. In case the given matrix is a row-major matrix the function returns an iterator to the first element of row i, in case it is a column-major matrix the function returns an iterator to the first element of column i.
BLAZE_ALWAYS_INLINE DenseVectorProxy< PT, VT >::ConstIterator blaze::cend | ( | const DenseVectorProxy< PT, VT > & | proxy | ) |
Returns an iterator just past the last element of the represented vector.
proxy | The given access proxy. |
BLAZE_ALWAYS_INLINE DenseMatrixProxy< PT, MT >::ConstIterator blaze::cend | ( | const DenseMatrixProxy< PT, MT > & | proxy, |
size_t | i | ||
) |
Returns an iterator just past the last element of row/column i of the represented matrix.
proxy | The given access proxy. |
i | The row/column index. |
In case the access proxy represents a matrix-like data structure that provides a cend() function, this function returns an iterator just past the last element of row/column i of the matrix. In case the given matrix is a row-major matrix the function returns an iterator just past the last element of row i, in case it is a column-major matrix the function returns an iterator just past the last element of column i.
BLAZE_ALWAYS_INLINE SparseVectorProxy< PT, VT >::ConstIterator blaze::cend | ( | const SparseVectorProxy< PT, VT > & | proxy | ) |
Returns an iterator just past the last element of the represented vector.
proxy | The given access proxy. |
BLAZE_ALWAYS_INLINE SparseMatrixProxy< PT, MT >::ConstIterator blaze::cend | ( | const SparseMatrixProxy< PT, MT > & | proxy, |
size_t | i | ||
) |
Returns an iterator just past the last element of row/column i of the represented matrix.
proxy | The given access proxy. |
i | The row/column index. |
In case the access proxy represents a matrix-like data structure that provides a cend() function, this function returns an iterator just past the last element of row/column i of the matrix. In case the given matrix is a row-major matrix the function returns an iterator just past the last element of row i, in case it is a column-major matrix the function returns an iterator just past the last element of column i.
BLAZE_ALWAYS_INLINE void blaze::clear | ( | const DenseVectorProxy< PT, VT > & | proxy | ) |
Clearing the represented vector.
proxy | The given access proxy. |
This function clears the vector to its default initial state.
BLAZE_ALWAYS_INLINE void blaze::clear | ( | const DenseMatrixProxy< PT, MT > & | proxy | ) |
Clearing the represented matrix.
proxy | The given access proxy. |
This function clears the matrix to its default initial state.
BLAZE_ALWAYS_INLINE void blaze::clear | ( | const SparseVectorProxy< PT, VT > & | proxy | ) |
Clearing the represented element.
proxy | The given access proxy. |
This function clears the vector to its default initial state.
|
inline |
Clearing the represented element.
proxy | The given access proxy. |
|
inline |
Clearing the represented element.
proxy | The given access proxy. |
This function clears the element represented by the access proxy to its default initial state. In case the access proxy represents a vector- or matrix-like data structure that provides a clear() function, this function clears the vector/matrix to its default initial state.
BLAZE_ALWAYS_INLINE void blaze::clear | ( | const NonNumericProxy< MT > & | proxy | ) |
Clearing the represented element.
proxy | The given access proxy. |
This function clears the element represented by the access proxy to its default initial state. In case the access proxy represents a vector- or matrix-like data structure that provides a clear() function, this function clears the vector/matrix to its default initial state.
BLAZE_ALWAYS_INLINE void blaze::clear | ( | const SparseMatrixProxy< PT, MT > & | proxy | ) |
Clearing the represented matrix.
proxy | The given access proxy. |
This function clears the matrix to its default initial state.
BLAZE_ALWAYS_INLINE size_t blaze::columns | ( | const DenseMatrixProxy< PT, MT > & | proxy | ) |
Returns the current number of columns of the represented matrix.
proxy | The given access proxy. |
BLAZE_ALWAYS_INLINE size_t blaze::columns | ( | const SparseMatrixProxy< PT, MT > & | proxy | ) |
Returns the current number of columns of the represented matrix.
proxy | The given access proxy. |
|
inline |
Returns the number of valid digits of an integral value.
a | The integral value. |
This function counts the number of valid digits in the given integral value.
The digits function only works for integral built-in data types. The attempt to use any other type will result in a compile time error.
BLAZE_ALWAYS_INLINE DenseVectorProxy< PT, VT >::Iterator blaze::end | ( | const DenseVectorProxy< PT, VT > & | proxy | ) |
Returns an iterator just past the last element of the represented vector.
proxy | The given access proxy. |
BLAZE_ALWAYS_INLINE DenseMatrixProxy< PT, MT >::Iterator blaze::end | ( | const DenseMatrixProxy< PT, MT > & | proxy, |
size_t | i | ||
) |
Returns an iterator just past the last element of row/column i of the represented matrix.
proxy | The given access proxy. |
i | The row/column index. |
In case the access proxy represents a matrix-like data structure that provides an end() function, this function returns an iterator just past the last element of row/column i of the matrix. In case the given matrix is a row-major matrix the function returns an iterator just past the last element of row i, in case it is a column-major matrix the function returns an iterator just past the last element of column i.
BLAZE_ALWAYS_INLINE SparseVectorProxy< PT, VT >::Iterator blaze::end | ( | const SparseVectorProxy< PT, VT > & | proxy | ) |
Returns an iterator just past the last element of the represented vector.
proxy | The given access proxy. |
BLAZE_ALWAYS_INLINE SparseMatrixProxy< PT, MT >::Iterator blaze::end | ( | const SparseMatrixProxy< PT, MT > & | proxy, |
size_t | i | ||
) |
Returns an iterator just past the last element of row/column i of the represented matrix.
proxy | The given access proxy. |
i | The row/column index. |
In case the access proxy represents a matrix-like data structure that provides an end() function, this function returns an iterator just past the last element of row/column i of the matrix. In case the given matrix is a row-major matrix the function returns an iterator just past the last element of row i, in case it is a column-major matrix the function returns an iterator just past the last element of column i.
|
inline |
Returns whether the represented element is in default state.
proxy | The given access proxy. |
This function checks whether the element represented by the access proxy is in default state. In case it is in default state, the function returns true, otherwise it returns false.
|
inline |
Returns whether the represented element is in default state.
proxy | The given access proxy. |
This function checks whether the element represented by the access proxy is in default state. In case it is in default state, the function returns true, otherwise it returns false.
BLAZE_ALWAYS_INLINE bool blaze::isDefault | ( | const NonNumericProxy< MT > & | proxy | ) |
Returns whether the represented element is in default state.
proxy | The given access proxy. |
This function checks whether the element represented by the access proxy is in default state. In case it is in default state, the function returns true, otherwise it returns false.
BLAZE_ALWAYS_INLINE bool blaze::lessThan | ( | T1 | a, |
T2 | b | ||
) |
Generic less-than comparison.
a | First value. |
b | Second value. |
Generic less-than comparison between to numeric values. Depending on the types of the two arguments, a special comparison for floating point values is selected that takes the limited machine accuracy into account.
BLAZE_ALWAYS_INLINE const MathTrait< T1, T2 >::HighType blaze::max | ( | const T1 & | a, |
const T2 & | b | ||
) |
Maximum function for two arguments.
a | First value. |
b | Second value. |
This function returns the maximum of the two given data values. The return type of the function is determined by the data types of the given arguments (for further detail see the MathTrait class description).
BLAZE_ALWAYS_INLINE const MathTrait< typename MathTrait< T1, T2 >::HighType, T3 >::HighType blaze::max | ( | const T1 & | a, |
const T2 & | b, | ||
const T3 & | c | ||
) |
Maximum function for three arguments.
a | First value. |
b | Second value. |
c | Third value. |
This function returns the maximum of the three given data values. The return type of the function is determined by the data types of the given arguments (for further detail see the MathTrait class description).
BLAZE_ALWAYS_INLINE const MathTrait< T1, T2 >::HighType blaze::min | ( | const T1 & | a, |
const T2 & | b | ||
) |
Minimum function for two arguments.
a | First value. |
b | Second value. |
This function returns the minimum of the two given data values. The return type of the function is determined by the data types of the given arguments (for further detail see the MathTrait class description).
BLAZE_ALWAYS_INLINE const MathTrait< typename MathTrait< T1, T2 >::HighType, T3 >::HighType blaze::min | ( | const T1 & | a, |
const T2 & | b, | ||
const T3 & | c | ||
) |
Minimum function for three arguments.
a | First value. |
b | Second value. |
c | Third value |
This function returns the minimum of the three given data values. The return type of the function is determined by the data types of the given arguments (for further detail see the MathTrait class description).
BLAZE_ALWAYS_INLINE size_t blaze::nonZeros | ( | const DenseVectorProxy< PT, VT > & | proxy | ) |
Returns the number of non-zero elements in the represented vector.
proxy | The given access proxy. |
Note that the number of non-zero elements is always less than or equal to the current size of the vector.
BLAZE_ALWAYS_INLINE size_t blaze::nonZeros | ( | const DenseMatrixProxy< PT, MT > & | proxy | ) |
Returns the number of non-zero elements in the represented matrix.
proxy | The given access proxy. |
BLAZE_ALWAYS_INLINE size_t blaze::nonZeros | ( | const DenseMatrixProxy< PT, MT > & | proxy, |
size_t | i | ||
) |
Returns the number of non-zero elements in the specified row/column of the represented matrix.
proxy | The given access proxy. |
i | The index of the row/column. |
This function returns the current number of non-zero elements in the specified row/column. In case the storage order is set to rowMajor the function returns the number of non-zero elements in row i, in case the storage flag is set to columnMajor the function returns the number of non-zero elements in column i.
BLAZE_ALWAYS_INLINE size_t blaze::nonZeros | ( | const SparseVectorProxy< PT, VT > & | proxy | ) |
Returns the number of non-zero elements in the represented vector.
proxy | The given access proxy. |
Note that the number of non-zero elements is always less than or equal to the current size of the vector.
BLAZE_ALWAYS_INLINE size_t blaze::nonZeros | ( | const SparseMatrixProxy< PT, MT > & | proxy | ) |
Returns the number of non-zero elements in the represented matrix.
proxy | The given access proxy. |
BLAZE_ALWAYS_INLINE size_t blaze::nonZeros | ( | const SparseMatrixProxy< PT, MT > & | proxy, |
size_t | i | ||
) |
Returns the number of non-zero elements in the specified row/column of the represented matrix.
proxy | The given access proxy. |
i | The index of the row/column. |
This function returns the current number of non-zero elements in the specified row/column. In case the storage order is set to rowMajor the function returns the number of non-zero elements in row i, in case the storage flag is set to columnMajor the function returns the number of non-zero elements in column i.
|
inline |
Inequality comparison between a NegativeEpsilon object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Inequality comparison between a NegativeAccuracy object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Inequality comparison between a floating point value and a NegativeEpsilon object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Inequality comparison between a floating point value and a NegativeAccuracy object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Inequality comparison between two NegativeInfinity objects.
lhs | The left-hand side NegativeInfinity object. |
rhs | The right-hand side NegativeInfinity object. |
|
inline |
Inequality comparison between an NegativeInfinity object and a built-in data type.
lhs | The left-hand side NegativeInfinity object. |
rhs | The right-hand side built-in data value. |
This operator works only for built-in data types. The attempt to compare user-defined class types will result in a compile time error.
|
inline |
Inequality comparison between a built-in data type and an NegativeInfinity object.
lhs | The left-hand side built-in data value. |
rhs | The right-hand side NegativeInfinity object. |
This operator works only for built-in data types. The attempt to compare user-defined class types will result in a compile time error.
|
inline |
Inequality comparison between two VectorAccessProxy objects.
lhs | The left-hand side VectorAccessProxy object. |
rhs | The right-hand side VectorAccessProxy object. |
|
inline |
Inequality comparison between a VectorAccessProxy object and an object of different type.
lhs | The left-hand side VectorAccessProxy object. |
rhs | The right-hand side object of other type. |
|
inline |
Inquality comparison between an object of different type and a VectorAccessProxy object.
lhs | The left-hand side object of other type. |
rhs | The right-hand side VectorAccessProxy object. |
|
inline |
Inequality comparison between two MatrixAccessProxy objects.
lhs | The left-hand side MatrixAccessProxy object. |
rhs | The right-hand side MatrixAccessProxy object. |
|
inline |
Inequality comparison between a MatrixAccessProxy object and an object of different type.
lhs | The left-hand side MatrixAccessProxy object. |
rhs | The right-hand side object of other type. |
|
inline |
Inquality comparison between an object of different type and a MatrixAccessProxy object.
lhs | The left-hand side object of other type. |
rhs | The right-hand side MatrixAccessProxy object. |
|
inline |
Inequality comparison between two NonNumericProxy objects.
lhs | The left-hand side NonNumericProxy object. |
rhs | The right-hand side NonNumericProxy object. |
|
inline |
Inequality comparison between a NonNumericProxy object and an object of different type.
lhs | The left-hand side NonNumericProxy object. |
rhs | The right-hand side object of other type. |
|
inline |
Inquality comparison between an object of different type and a NonNumericProxy object.
lhs | The left-hand side object of other type. |
rhs | The right-hand side NonNumericProxy object. |
|
inline |
Inequality comparison between an Epsilon object and a floating point value.
rhs | The right-hand side floating point value. |
This operator works only for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Inequality comparison between an Accuracy object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Inequality comparison between a floating point value and an Accuracy object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Inequality comparison between a floating point value and an Epsilon object.
lhs | The left-hand side floating point value. |
This operator works only for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
|
inline |
Inequality comparison between an Infinity object and a NegativeInfinity object.
lhs | The left-hand side Infinity object. |
rhs | The right-hand side NegativeInfinity object. |
|
inline |
Inequality comparison between a NegativeInfinity object and an Infinity object.
rhs | The left-hand side NegativeInfinity object. |
lhs | The right-hand side Infinity object. |
|
inline |
Inequality comparison between an Infinity object and a built-in data type.
lhs | The left-hand side Infinity object. |
rhs | The right-hand side built-in data value. |
This operator works only for built-in data types. The attempt to compare user-defined class types will result in a compile time error.
|
inline |
Inequality comparison between a built-in data type and an Infinity object.
lhs | The left-hand side built-in data value. |
rhs | The right-hand side Infinity object. |
This operator works only for built-in data types. The attempt to compare user-defined class types will result in a compile time error.
|
inline |
Less-than comparison between a NegativeAccuracy object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Less-than comparison between a NegativeEpsilon object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Less-than comparison between a floating point value and a NegativeAccuracy object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Less-than comparison between a floating point value and a NegativeEpsilon object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Less-than comparison between two VectorAccessProxy objects.
lhs | The left-hand side VectorAccessProxy object. |
rhs | The right-hand side VectorAccessProxy object. |
|
inline |
Less-than comparison between a VectorAccessProxy object and an object of different type.
lhs | The left-hand side VectorAccessProxy object. |
rhs | The right-hand side object of other type. |
|
inline |
Less-than comparison between an object of different type and a VectorAccessProxy object.
lhs | The left-hand side object of other type. |
rhs | The right-hand side VectorAccessProxy object. |
|
inline |
Less-than comparison between two MatrixAccessProxy objects.
lhs | The left-hand side MatrixAccessProxy object. |
rhs | The right-hand side MatrixAccessProxy object. |
|
inline |
Less-than comparison between a MatrixAccessProxy object and an object of different type.
lhs | The left-hand side MatrixAccessProxy object. |
rhs | The right-hand side object of other type. |
|
inline |
Less-than comparison between an object of different type and a MatrixAccessProxy object.
lhs | The left-hand side object of other type. |
rhs | The right-hand side MatrixAccessProxy object. |
|
inline |
Less-than comparison between two NonNumericProxy objects.
lhs | The left-hand side NonNumericProxy object. |
rhs | The right-hand side NonNumericProxy object. |
|
inline |
Less-than comparison between a NonNumericProxy object and an object of different type.
lhs | The left-hand side NonNumericProxy object. |
rhs | The right-hand side object of other type. |
|
inline |
Less-than comparison between an object of different type and a NonNumericProxy object.
lhs | The left-hand side object of other type. |
rhs | The right-hand side NonNumericProxy object. |
|
inline |
Less-than comparison between an Accuracy object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Less-than comparison between an Epsilon object and a floating point value.
rhs | The right-hand side floating point value. |
This operator works only for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Less-than comparison between a floating point value and an Accuracy object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Less-than comparison between a floating point value and an Epsilon object.
lhs | The left-hand side floating point value. |
This operator works only for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Global output operator for the VectorAccessProxy class template.
os | Reference to the output stream. |
proxy | Reference to a constant proxy object. |
|
inline |
Global output operator for the MatrixAccessProxy class template.
os | Reference to the output stream. |
proxy | Reference to a constant proxy object. |
|
inline |
Global output operator for the NonNumericProxy class template.
os | Reference to the output stream. |
proxy | Reference to a constant proxy object. |
|
inline |
Less-or-equal-than comparison between two VectorAccessProxy objects.
lhs | The left-hand side VectorAccessProxy object. |
rhs | The right-hand side VectorAccessProxy object. |
|
inline |
Less-or-equal-than comparison between a VectorAccessProxy object and an object of different type.
lhs | The left-hand side VectorAccessProxy object. |
rhs | The right-hand side object of other type. |
|
inline |
Less-or-equal-than comparison between an object of different type and a VectorAccessProxy object.
lhs | The left-hand side object of other type. |
rhs | The right-hand side VectorAccessProxy object. |
|
inline |
Less-or-equal-than comparison between two MatrixAccessProxy objects.
lhs | The left-hand side MatrixAccessProxy object. |
rhs | The right-hand side MatrixAccessProxy object. |
|
inline |
Less-or-equal-than comparison between a MatrixAccessProxy object and an object of different type.
lhs | The left-hand side MatrixAccessProxy object. |
rhs | The right-hand side object of other type. |
|
inline |
Less-or-equal-than comparison between an object of different type and a MatrixAccessProxy object.
lhs | The left-hand side object of other type. |
rhs | The right-hand side MatrixAccessProxy object. |
|
inline |
Less-or-equal-than comparison between two NonNumericProxy objects.
lhs | The left-hand side NonNumericProxy object. |
rhs | The right-hand side NonNumericProxy object. |
|
inline |
Less-or-equal-than comparison between a NonNumericProxy object and an object of different type.
lhs | The left-hand side NonNumericProxy object. |
rhs | The right-hand side object of other type. |
|
inline |
Less-or-equal-than comparison between an object of different type and a NonNumericProxy object.
lhs | The left-hand side object of other type. |
rhs | The right-hand side NonNumericProxy object. |
|
inline |
Less-or-equal-than comparison between an Accuracy object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Less-or-equal-than comparison between an Epsilon object and a floating point value.
rhs | The right-hand side floating point value. |
This operator works only for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Less-or-equal-than comparison between a floating point value and an Accuracy object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Less-or-equal-than comparison between a floating point value and an Epsilon object.
lhs | The left-hand side floating point value. |
This operator works only for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Equality comparison between a NegativeEpsilon object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Equality comparison between a NegativeAccuracy object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Equality comparison between a floating point value and a NegativeEpsilon object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Equality comparison between a floating point value and a NegativeAccuracy object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Equality comparison between two NegativeInfinity objects.
lhs | The left-hand side NegativeInfinity object. |
rhs | The right-hand side NegativeInfinity object. |
|
inline |
Equality comparison between an NegativeInfinity object and a built-in data type.
lhs | The left-hand side NegativeInfinity object. |
rhs | The right-hand side built-in data value. |
This operator works only for built-in data types. The attempt to compare user-defined class types will result in a compile time error.
|
inline |
Equality comparison between a built-in data type and an NegativeInfinity object.
lhs | The left-hand side built-in data value. |
rhs | The right-hand side NegativeInfinity object. |
This operator works only for built-in data types. The attempt to compare user-defined class types will result in a compile time error.
|
inline |
Equality comparison between two VectorAccessProxy objects.
lhs | The left-hand side VectorAccessProxy object. |
rhs | The right-hand side VectorAccessProxy object. |
|
inline |
Equality comparison between a VectorAccessProxy object and an object of different type.
lhs | The left-hand side VectorAccessProxy object. |
rhs | The right-hand side object of other type. |
|
inline |
Equality comparison between an object of different type and a VectorAccessProxy object.
lhs | The left-hand side object of other type. |
rhs | The right-hand side VectorAccessProxy object. |
|
inline |
Equality comparison between two MatrixAccessProxy objects.
lhs | The left-hand side MatrixAccessProxy object. |
rhs | The right-hand side MatrixAccessProxy object. |
|
inline |
Equality comparison between a MatrixAccessProxy object and an object of different type.
lhs | The left-hand side MatrixAccessProxy object. |
rhs | The right-hand side object of other type. |
|
inline |
Equality comparison between an object of different type and a MatrixAccessProxy object.
lhs | The left-hand side object of other type. |
rhs | The right-hand side MatrixAccessProxy object. |
|
inline |
Equality comparison between two NonNumericProxy objects.
lhs | The left-hand side NonNumericProxy object. |
rhs | The right-hand side NonNumericProxy object. |
|
inline |
Equality comparison between a NonNumericProxy object and an object of different type.
lhs | The left-hand side NonNumericProxy object. |
rhs | The right-hand side object of other type. |
|
inline |
Equality comparison between an object of different type and a NonNumericProxy object.
lhs | The left-hand side object of other type. |
rhs | The right-hand side NonNumericProxy object. |
|
inline |
Equality comparison between an Epsilon object and a floating point value.
rhs | The right-hand side floating point value. |
This operator works only for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Equality comparison between an Accuracy object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Equality comparison between a floating point value and an Epsilon object.
lhs | The left-hand side floating point value. |
This operator works only for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Equality comparison between a floating point value and an Accuracy object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
|
inline |
Equality comparison between an Infinity object and a NegativeInfinity object.
lhs | The left-hand side Infinity object. |
rhs | The right-hand side NegativeInfinity object. |
|
inline |
Equality comparison between a NegativeInfinity object and an Infinity object.
rhs | The left-hand side NegativeInfinity object. |
lhs | The right-hand side Infinity object. |
|
inline |
Equality comparison between an Infinity object and a built-in data type.
lhs | The left-hand side Infinity object. |
rhs | The right-hand side built-in data value. |
This operator works only for built-in data types. The attempt to compare user-defined class types will result in a compile time error.
|
inline |
Equality comparison between a built-in data type and an Infinity object.
lhs | The left-hand side built-in data value. |
rhs | The right-hand side Infinity object. |
This operator works only for built-in data types. The attempt to compare user-defined class types will result in a compile time error.
|
inline |
Greater-than comparison between a NegativeEpsilon object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Greater-than comparison between a NegativeAccuracy object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Greater-than comparison between a floating point value and a NegativeEpsilon object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Greater-than comparison between a floating point value and a NegativeAccuracy object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Greater-than comparison between two VectorAccessProxy objects.
lhs | The left-hand side VectorAccessProxy object. |
rhs | The right-hand side VectorAccessProxy object. |
|
inline |
Greater-than comparison between a VectorAccessProxy object and an object of different type.
lhs | The left-hand side VectorAccessProxy object. |
rhs | The right-hand side object of other type. |
|
inline |
Greater-than comparison between an object of different type and a VectorAccessProxy object.
lhs | The left-hand side object of other type. |
rhs | The right-hand side VectorAccessProxy object. |
|
inline |
Greater-than comparison between two MatrixAccessProxy objects.
lhs | The left-hand side MatrixAccessProxy object. |
rhs | The right-hand side MatrixAccessProxy object. |
|
inline |
Greater-than comparison between a MatrixAccessProxy object and an object of different type.
lhs | The left-hand side MatrixAccessProxy object. |
rhs | The right-hand side object of other type. |
|
inline |
Greater-than comparison between an object of different type and a MatrixAccessProxy object.
lhs | The left-hand side object of other type. |
rhs | The right-hand side MatrixAccessProxy object. |
|
inline |
Greater-than comparison between two NonNumericProxy objects.
lhs | The left-hand side NonNumericProxy object. |
rhs | The right-hand side NonNumericProxy object. |
|
inline |
Greater-than comparison between a NonNumericProxy object and an object of different type.
lhs | The left-hand side NonNumericProxy object. |
rhs | The right-hand side object of other type. |
|
inline |
Greater-than comparison between an object of different type and a NonNumericProxy object.
lhs | The left-hand side object of other type. |
rhs | The right-hand side NonNumericProxy object. |
|
inline |
Greater-than comparison between an Epsilon object and a floating point value.
rhs | The right-hand side floating point value. |
This operator works only for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Greater-than comparison between an Accuracy object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Greater-than comparison between a floating point value and an Epsilon object.
lhs | The left-hand side floating point value. |
This operator works only for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Greater-than comparison between a floating point value and an Accuracy object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Greater-or-equal-than comparison between two VectorAccessProxy objects.
lhs | The left-hand side VectorAccessProxy object. |
rhs | The right-hand side VectorAccessProxy object. |
|
inline |
Greater-or-equal-than comparison between a VectorAccessProxy object and an object of different type.
lhs | The left-hand side VectorAccessProxy object. |
rhs | The right-hand side object of other type. |
|
inline |
Greater-or-equal-than comparison between an object of different type and a VectorAccessProxy object.
lhs | The left-hand side object of other type. |
rhs | The right-hand side VectorAccessProxy object. |
|
inline |
Greater-or-equal-than comparison between two MatrixAccessProxy objects.
lhs | The left-hand side MatrixAccessProxy object. |
rhs | The right-hand side MatrixAccessProxy object. |
|
inline |
Greater-or-equal-than comparison between a MatrixAccessProxy object and an object of different type.
lhs | The left-hand side MatrixAccessProxy object. |
rhs | The right-hand side object of other type. |
|
inline |
Greater-or-equal-than comparison between an object of different type and a MatrixAccessProxy object.
lhs | The left-hand side object of other type. |
rhs | The right-hand side MatrixAccessProxy object. |
|
inline |
Greater-or-equal-than comparison between two NonNumericProxy objects.
lhs | The left-hand side NonNumericProxy object. |
rhs | The right-hand side NonNumericProxy object. |
|
inline |
Greater-or-equal-than comparison between a NonNumericProxy object and an object of different type.
lhs | The left-hand side NonNumericProxy object. |
rhs | The right-hand side object of other type. |
|
inline |
Greater-or-equal-than comparison between an object of different type and a NonNumericProxy object.
lhs | The left-hand side object of other type. |
rhs | The right-hand side NonNumericProxy object. |
|
inline |
Greater-or-equal-than comparison between an Accuracy object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Greater-or-equal-than comparison between an Epsilon object and a floating point value.
rhs | The right-hand side floating point value. |
This operator works only for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Less-or-equal-than comparison between a floating point value and an Accuracy object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Less-or-equal-than comparison between a floating point value and an Epsilon object.
lhs | The left-hand side floating point value. |
This operator works only for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
BLAZE_ALWAYS_INLINE void blaze::reset | ( | const DenseVectorProxy< PT, VT > & | proxy | ) |
Resetting the represented vector to the default initial values.
proxy | The given access proxy. |
This function resets all elements of the vector to the default initial values.
BLAZE_ALWAYS_INLINE void blaze::reset | ( | const DenseMatrixProxy< PT, MT > & | proxy | ) |
Resetting the represented element to the default initial values.
proxy | The given access proxy. |
This function resets all elements of the matrix to the default initial values.
BLAZE_ALWAYS_INLINE void blaze::reset | ( | const DenseMatrixProxy< PT, MT > & | proxy, |
size_t | i | ||
) |
Reset the specified row/column of the represented matrix.
proxy | The given access proxy. |
i | The index of the row/column to be resetted. |
This function resets all elements in the specified row/column of the given matrix to their default value. In case the given matrix is a rowMajor matrix the function resets the values in row i, if it is a columnMajor matrix the function resets the values in column i. Note that the capacity of the row/column remains unchanged.
BLAZE_ALWAYS_INLINE void blaze::reset | ( | const SparseVectorProxy< PT, VT > & | proxy | ) |
Resetting the represented element to the default initial values.
proxy | The given access proxy. |
This function resets all elements of the vector to the default initial values.
|
inline |
Resetting the represented element to the default initial values.
proxy | The given access proxy. |
|
inline |
Resetting the represented element to the default initial values.
proxy | The given access proxy. |
This function resets the element represented by the access proxy to its default initial value. In case the access proxy represents a vector- or matrix-like data structure that provides a reset() function, this function resets all elements of the vector/matrix to the default initial values.
BLAZE_ALWAYS_INLINE void blaze::reset | ( | const NonNumericProxy< MT > & | proxy | ) |
Resetting the represented element to the default initial values.
proxy | The given access proxy. |
This function resets the element represented by the access proxy to its default initial value. In case the access proxy represents a vector- or matrix-like data structure that provides a reset() function, this function resets all elements of the vector/matrix to the default initial values.
BLAZE_ALWAYS_INLINE void blaze::reset | ( | const SparseMatrixProxy< PT, MT > & | proxy | ) |
Resetting the represented element to the default initial values.
proxy | The given access proxy. |
This function resets all elements of the matrix to the default initial values.
BLAZE_ALWAYS_INLINE void blaze::reset | ( | const SparseMatrixProxy< PT, MT > & | proxy, |
size_t | i | ||
) |
Reset the specified row/column of the represented matrix.
proxy | The given access proxy. |
i | The index of the row/column to be resetted. |
This function resets all elements in the specified row/column of the given matrix to their default value. In case the given matrix is a rowMajor matrix the function resets the values in row i, if it is a columnMajor matrix the function resets the values in column i. Note that the capacity of the row/column remains unchanged.
BLAZE_ALWAYS_INLINE T blaze::round | ( | T | a | ) |
Rounds the given input value.
a | Value to be rounded. |
This function rounds the given input value. In case the first digit after the comma is smaller than five the value is rounded down. Otherwise it is rounded up. Note that this function only works for integral and floating point types. The attempt to use the function for any other type will result in a compile time error.
BLAZE_ALWAYS_INLINE size_t blaze::rows | ( | const DenseMatrixProxy< PT, MT > & | proxy | ) |
Returns the current number of rows of the represented matrix.
proxy | The given access proxy. |
BLAZE_ALWAYS_INLINE size_t blaze::rows | ( | const SparseMatrixProxy< PT, MT > & | proxy | ) |
Returns the current number of rows of the represented matrix.
proxy | The given access proxy. |
|
inline |
Sign function.
a | The given value. |
The sign function only works for built-in data types. The attempt to use any user-defined class type will result in a compile time error.
BLAZE_ALWAYS_INLINE size_t blaze::size | ( | const DenseVectorProxy< PT, VT > & | proxy | ) |
Returns the current size/dimension of the represented vector.
proxy | The given access proxy. |
BLAZE_ALWAYS_INLINE size_t blaze::size | ( | const SparseVectorProxy< PT, VT > & | proxy | ) |
Returns the current size/dimension of the represented vector.
proxy | The given access proxy. |
|
inline |
Swapping the contents of two access proxies.
a | The first access proxy to be swapped. |
b | The second access proxy to be swapped. |
no-throw | guarantee. |
|
inline |
Swapping the contents of an access proxy with another element.
a | The access proxy to be swapped. |
b | The other element to be swapped. |
no-throw | guarantee. |
|
inline |
Swapping the contents of an access proxy with another element.
a | The other element to be swapped. |
b | The access proxy to be swapped. |
no-throw | guarantee. |
|
inline |
Swapping the contents of two access proxies.
a | The first access proxy to be swapped. |
b | The second access proxy to be swapped. |
no-throw | guarantee. |
|
inline |
Swapping the contents of an access proxy with another element.
a | The access proxy to be swapped. |
b | The other element to be swapped. |
no-throw | guarantee. |
|
inline |
Swapping the contents of an access proxy with another element.
a | The other element to be swapped. |
b | The access proxy to be swapped. |
no-throw | guarantee. |