Macros | Typedefs | Variables
Configuration

Macros

#define BLAZE_INTERNAL_ASSERTION   0
 Compilation switch for internal assertions.This compilation switch triggers internal assertions, which are used to verify the program itself. The internal assertions can also be deactivated by defining NDEBUG during the compilation. More...
 
#define BLAZE_USER_ASSERTION   0
 Compilation switch for user assertions.This compilation switch triggers user assertions, which are used to check user specified function parameters and values. The user assertions can also be deactivated by defining NDEBUG during the compilation. More...
 
#define BLAZE_BLAS_MODE   0
 Compilation switch for the BLAS mode.This compilation switch enables/disables the BLAS mode. In case the BLAS mode is enabled, several basic linear algebra functions (such as for instance matrix-matrix multiplications between two dense matrices) are handled by performance optimized BLAS functions. Note that in this case it is mandatory to provide the according BLAS header file for the compilation of the Blaze library. In case the BLAS mode is disabled, all linear algebra functions use the default implementations of the Blaze library and therefore BLAS is not a requirement for the compilation process. More...
 
#define BLAZE_USE_BLAS_MATRIX_VECTOR_MULTIPLICATION   0
 Compilation switch for the BLAS matrix/vector multiplication kernels (gemv).This compilation switch enables/disables the BLAS matrix/vector multiplication kernels. If the switch is enabled, multiplications between dense matrices and dense vectors are computed by BLAS kernels, if it is disabled the multiplications are handled by the default Blaze kernels. More...
 
#define BLAZE_USE_BLAS_MATRIX_MATRIX_MULTIPLICATION   1
 Compilation switch for the BLAS matrix/matrix multiplication kernels (gemv).This compilation switch enables/disables the BLAS matrix/matrix multiplication kernels. If the switch is enabled, multiplications between dense matrices are computed by BLAS kernels, if it is disabled the multiplications are handled by the default Blaze kernels. More...
 
#define BLAZE_BLAS_IS_PARALLEL   0
 Compilation switch for the parallel BLAS mode.This compilation switch specifies whether the used BLAS library is itself parallelized or not. In case the given BLAS library is itself parallelized, the Blaze library does not perform any attempt to parallelize the execution of BLAS kernels. If, however, the given BLAS library is not parallelized Blaze will attempt to parallelize the execution of BLAS kernels. More...
 
#define BLAZE_BLAS_INCLUDE_FILE   <cblas.h>
 Compilation switch for the of the BLAS include file.This compilation switch specifies the name of the BLAS include file. By default, the header <cblas.h> is included when the BLAS mode is activated. In case the name of the include file differs (as for instance in case of the MKL the file is called <mkl_cblas.h>) this switch needs to be adapted accordingly. More...
 
#define BLAZE_USE_DEBUG_MODE   0
 Compilation switch for the (de-)activation of the debug mode.This compilation switch enables/disables the debug mode of the Blaze library. In case the switch is set to 1 (i.e. in case the debug mode is enabled), the Blaze library is allowed to perform additional runtime checks and to modify user-defined settings to guarantee a full and thorough debugging process. In case the switch is set to 0 (i.e. the debug mode is disabled), no additional checks are added and no settings are modified. More...
 
#define BLAZE_USE_STRONG_INLINE   1
 Compilation switch for a strengthened inline keyword.The regular C++ inline keyword merely represents a hint to the compiler to inline a function. Due to that, when using the inline keyword for performance critical functions, one is at the mercy of the compiler to properly inline the functions. In order to improve the likelihood of a function being properly inlined the BLAZE_STRONG_INLINE keyword can be used. In contrast to the regular inline keyword, BLAZE_STRONG_INLINE uses platform-specific keywords and modifiers to improve the likelihood of a function being properly inlined. Please note, however, that even in case the platform-specific inline is used, there is no guarantee that a function is inlined (see for instance the http://msdn.microsoft.com/en-us/library/z8y1yy88.aspx). More...
 
#define BLAZE_USE_ALWAYS_INLINE   1
 Compilation switch for an enforced inline keyword.Although the BLAZE_STRONG_INLINE keyword improves the likelihood of a function being inlined it does not provide a 100% guarantee. Depending on the availability of an according keyword and/or modifier on a specific platform, this guarantee is provided by the BLAZE_ALWAYS_INLINE keyword, which uses platform-specific functionality to enforce the inlining of a function. More...
 
#define BLAZE_USE_FUNCTION_TRACES   0
 Compilation switch for function traces.This compilation switch triggers the use of function traces. In case the switch is set to 1, function traces via the BLAZE_FUNCTION_TRACE are enabled. Note however, that enabling function traces creates a dependency to the compiled Blaze library, i.e. it will be necessary to link the Blaze library to the executable. This is also true in case only template functionality is used! More...
 
#define BLAZE_USE_RESTRICT   1
 Compilation switch for C99 restrict keyword.This compilation switch enables/disables the C99 restrict keyword. More...
 
#define BLAZE_USE_SHARED_MEMORY_PARALLELIZATION   1
 Compilation switch for the (de-)activation of the shared-memory parallelizationThis compilation switch enables/disables the shared-memory parallelization. In case the switch is set to 1 (i.e. in case the shared-memory parallelization is enabled), the Blaze library is allowed to execute operations in parallel. In case the switch is set to 0 (i.e. parallelization is disabled), the Blaze library is restricted from executing operations in parallel. More...
 
#define BLAZE_USE_VECTORIZATION   1
 Compilation switch for (de-)activation of the Blaze vectorization.This compilation switch enables/disables vectorization of mathematical expressions via the SSE, AVX, and/or MIC instruction sets. In case the switch is set to 1 (i.e. in case vectorization is enabled), the Blaze library attempts to vectorize the linear algebra operations by SSE, AVX, and/or MIC intrinsics (depending on which instruction set is available on the target platform). In case the switch is set to 0 (i.e. vectorization is disabled), the Blaze library chooses default, non-vectorized functionality for the operations. Note that deactivating the vectorization may pose a severe performance limitation for a large number of operations! More...
 

Typedefs

typedef double blaze::real_t
 Floating point data type of the Blaze library.This type definition offers the possibility to switch the floating point precision of the Blaze library between float, double and long double. More...
 
typedef std::mt19937 blaze::RNG
 Type of the random number generator of the Blaze library.This type definition represents the type of the random number generated used in the Blaze library. The default random number generator is the std::mt19937 mersenne-twister pseudo random number generator. For more information see the following reference documentation: More...
 

Variables

constexpr size_t blaze::cacheSize = 3145728UL
 Cache size of the target architecture.This setting specifies the available cache size in Byte of the used target architecture. Several algorithms use this setting for an optimized evaluation. More...
 
constexpr LogLevel blaze::logging::loglevel = info
 Setting of the logging level.This value specifies the logging level of the Blaze logging functionality. Depending on this setting, more or less informations will be written to the log file(s). The following logging levels can be selected: More...
 
constexpr bool blaze::logging::spacing = false
 Adding an additional spacing line between two log messages.This setting gives the opportunity to add an additional spacing line between two log messages to improve readability of log files. If set to true, each log message will be appended with an additional empty line. If set to false, no line will be appended.
 
constexpr bool blaze::usePadding = true
 Configuration of the padding of dense vectors and matrices.This configuration switch enables/disables the padding of dense vectors and matrices. Padding is used by the Blaze library in order to achieve maximum performance for both dense vector and matrix operations. Due to padding, the proper alignment of data elements can be guaranteed and the need for remainder loops is minimized. In case the switch is set to true, padding is enabled for all native dense vectors and matrices. If the switch is set to false, padding is generally disabled. More...
 
constexpr bool blaze::useStreaming = true
 Configuration of the streaming behavior.For large vectors and matrices non-temporal stores can provide a significant performance advantage of about 20%. However, this advantage is only in effect in case the memory bandwidth of the target architecture is maxed out. If the target architecture's memory bandwidth cannot be exhausted the use of non-temporal stores can decrease performance instead of increasing it. More...
 
constexpr bool blaze::useOptimizedKernels = true
 Configuration switch for optimized kernels.This configuration switch enables/disables all optimized compute kernels of the Blaze library, including all vectorized and data type depending kernels. In case the switch is set to true the optimized kernels are used whenever possible. In case the switch is set to false all optimized kernels are not used, even if it would be possible. More...
 
constexpr bool blaze::defaultStorageOrder = rowMajor
 The default storage order for all matrices of the Blaze library.This value specifies the default storage order for all matrices of the Blaze library. In case no explicit storage order is specified with the according matrix type, this setting is used. More...
 
constexpr size_t blaze::DMATDVECMULT_USER_THRESHOLD = 4000000UL
 Row-major dense matrix/dense vector multiplication threshold.This setting specifies the threshold between the application of the custom Blaze kernels and the BLAS kernels for the row-major dense matrix/dense vector multiplication. In case the number of elements in the dense matrix is equal or higher than this value, the BLAS kernels are preferred over the custom Blaze kernels. In case the number of elements in the dense matrix is smaller, the Blaze kernels are used. More...
 
constexpr size_t blaze::TDMATDVECMULT_USER_THRESHOLD = 62500UL
 Column-major dense matrix/dense vector multiplication threshold.This setting specifies the threshold between the application of the custom Blaze kernels and the BLAS kernels for the column-major dense matrix/dense vector multiplication. In case the number of elements in the dense matrix is equal or higher than this value, the BLAS kernels are preferred over the custom Blaze kernels. In case the number of elements in the dense matrix is smaller, the Blaze kernels are used. More...
 
constexpr size_t blaze::TDVECDMATMULT_USER_THRESHOLD = 62500UL
 Dense Vector/row-major dense matrix multiplication threshold.This setting specifies the threshold between the application of the custom Blaze kernels and the BLAS kernels for the dense vector/row-major dense matrix multiplication. In case the number of elements in the dense matrix is equal or higher than this value, the BLAS kernels are preferred over the custom Blaze kernels. In case the number of elements in the dense matrix is smaller, the Blaze kernels are used. More...
 
constexpr size_t blaze::TDVECTDMATMULT_USER_THRESHOLD = 4000000UL
 Dense Vector/column-major dense matrix multiplication threshold.This setting specifies the threshold between the application of the custom Blaze kernels and the BLAS kernels for the dense vector/column-major dense matrix multiplication. In case the number of elements in the dense matrix is equal or higher than this value, the BLAS kernels are preferred over the custom Blaze kernels. In case the number of elements in the dense matrix is smaller, the Blaze kernels are used. More...
 
constexpr size_t blaze::DMATDMATMULT_USER_THRESHOLD = 10000UL
 Row-major dense matrix/row-major dense matrix multiplication threshold.This setting specifies the threshold between the application of the custom Blaze kernels and the BLAS kernels for the row-major dense matrix/row-major dense matrix multiplication. In case the number of elements of the target matrix is equal or higher than this value, the BLAS kernels are preferred over the custom Blaze kernels. In case the number of elements in the target matrix is smaller, the Blaze kernels are used. More...
 
constexpr size_t blaze::DMATTDMATMULT_USER_THRESHOLD = 10000UL
 Row-major dense matrix/column-major dense matrix multiplication threshold.This setting specifies the threshold between the application of the custom Blaze kernels and the BLAS kernels for the row-major dense matrix/column-major dense matrix multiplication. In case the number of elements of the target matrix is equal or higher than this value, the BLAS kernels are preferred over the custom Blaze kernels. In case the number of elements in the target matrix is smaller, the Blaze kernels are used. More...
 
constexpr size_t blaze::TDMATDMATMULT_USER_THRESHOLD = 10000UL
 Column-major dense matrix/row-major dense matrix multiplication threshold.This setting specifies the threshold between the application of the custom Blaze kernels and the BLAS kernels for the column-major dense matrix/row-major dense matrix multiplication. In case the number of elements of the target matrix is equal or higher than this value, the BLAS kernels are preferred over the custom Blaze kernels. In case the number of elements in the target matrix is smaller, the Blaze kernels are used. More...
 
constexpr size_t blaze::TDMATTDMATMULT_USER_THRESHOLD = 10000UL
 Column-major dense matrix/column-major dense matrix multiplication threshold.This setting specifies the threshold between the application of the custom Blaze kernels and the BLAS kernels for the column-major dense matrix/column-major dense matrix multiplication. In case the number of elements of the target matrix is equal or higher than this value, the BLAS kernels are preferred over the custom Blaze kernels. In case the number of elements in the target matrix is smaller, the Blaze kernels are used. More...
 
constexpr size_t blaze::DMATSMATMULT_USER_THRESHOLD = 2500UL
 Row-major dense matrix/row-major sparse matrix multiplication threshold.This setting specifies the threshold between the application of the Blaze kernels for small and for large row-major dense matrix/row-major sparse matrix multiplications. In case the number of elements of the target matrix is equal or higher than this value, the kernel for large matrices is preferred over the kernel for small matrices. In case the number of elements in the target matrix is smaller, the kernel for small matrices is used. More...
 
constexpr size_t blaze::TDMATSMATMULT_USER_THRESHOLD = 2500UL
 Column-major dense matrix/row-major sparse matrix multiplication threshold.This setting specifies the threshold between the application of the Blaze kernels for small and for large column-major dense matrix/row-major sparse matrix multiplications. In case the number of elements of the target matrix is equal or higher than this value, the kernel for large matrices is preferred over the kernel for small matrices. In case the number of elements in the target matrix is smaller, the kernel for small matrices is used. More...
 
constexpr size_t blaze::TSMATDMATMULT_USER_THRESHOLD = 10000UL
 Column-major sparse matrix/row-major dense matrix multiplication threshold.This setting specifies the threshold between the application of the Blaze kernels for small and for large column-major sparse matrix/row-major dense matrix multiplications. In case the number of elements of the target matrix is equal or higher than this value, the kernel for large matrices is preferred over the kernel for small matrices. In case the number of elements in the target matrix is smaller, the kernel for small matrices is used. More...
 
constexpr size_t blaze::TSMATTDMATMULT_USER_THRESHOLD = 22500UL
 Column-major sparse matrix/column-major dense matrix multiplication threshold.This setting specifies the threshold between the application of the Blaze kernels for small and for large column-major sparse matrix/column-major dense matrix multiplications. In case the number of elements of the target matrix is equal or higher than this value, the kernel for large matrices is preferred over the kernel for small matrices. In case the number of elements in the target matrix is smaller, the kernel for small matrices is used. More...
 
constexpr size_t blaze::SMP_DVECASSIGN_USER_THRESHOLD = 38000UL
 SMP dense vector assignment threshold.This threshold specifies when an assignment of a simple dense vector can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. More...
 
constexpr size_t blaze::SMP_DVECDVECADD_USER_THRESHOLD = 38000UL
 SMP dense vector/dense vector addition threshold.This threshold specifies when a dense vector/dense vector addition can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. More...
 
constexpr size_t blaze::SMP_DVECDVECSUB_USER_THRESHOLD = 38000UL
 SMP dense vector/dense vector subtraction threshold.This threshold specifies when a dense vector/dense vector subtraction can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. More...
 
constexpr size_t blaze::SMP_DVECDVECMULT_USER_THRESHOLD = 38000UL
 SMP dense vector/dense vector multiplication threshold.This threshold specifies when a dense vector/dense vector multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. More...
 
constexpr size_t blaze::SMP_DVECDVECDIV_USER_THRESHOLD = 38000UL
 SMP dense vector/dense vector division threshold.This threshold specifies when a dense vector/dense vector division can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. More...
 
constexpr size_t blaze::SMP_DVECSCALARMULT_USER_THRESHOLD = 51000UL
 SMP dense vector/scalar multiplication/division threshold.This threshold specifies when a dense vector/scalar multiplication/division can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. More...
 
constexpr size_t blaze::SMP_DMATDVECMULT_USER_THRESHOLD = 330UL
 SMP row-major dense matrix/dense vector multiplication threshold.This threshold specifies when a row-major dense matrix/dense vector multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. More...
 
constexpr size_t blaze::SMP_TDMATDVECMULT_USER_THRESHOLD = 360UL
 SMP column-major dense matrix/dense vector multiplication threshold.This threshold specifies when a column-major dense matrix/dense vector multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. More...
 
constexpr size_t blaze::SMP_TDVECDMATMULT_USER_THRESHOLD = 370UL
 SMP dense vector/row-major dense matrix multiplication threshold.This threshold specifies when a dense vector/row-major dense matrix multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. More...
 
constexpr size_t blaze::SMP_TDVECTDMATMULT_USER_THRESHOLD = 340UL
 SMP dense vector/column-major dense matrix multiplication threshold.This threshold specifies when a dense vector/column-major dense matrix multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. More...
 
constexpr size_t blaze::SMP_DMATSVECMULT_USER_THRESHOLD = 480UL
 SMP row-major dense matrix/sparse vector multiplication threshold.This threshold specifies when a row-major dense matrix/sparse vector multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. More...
 
constexpr size_t blaze::SMP_TDMATSVECMULT_USER_THRESHOLD = 910UL
 SMP column-major dense matrix/sparse vector multiplication threshold.This threshold specifies when a column-major dense matrix/sparse vector multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. More...
 
constexpr size_t blaze::SMP_TSVECDMATMULT_USER_THRESHOLD = 910UL
 SMP sparse vector/row-major dense matrix multiplication threshold.This threshold specifies when a sparse vector/row-major dense matrix multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. More...
 
constexpr size_t blaze::SMP_TSVECTDMATMULT_USER_THRESHOLD = 480UL
 SMP sparse vector/column-major dense matrix multiplication threshold.This threshold specifies when a sparse vector/column-major dense matrix multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. More...
 
constexpr size_t blaze::SMP_SMATDVECMULT_USER_THRESHOLD = 600UL
 SMP row-major sparse matrix/dense vector multiplication threshold.This threshold specifies when a row-major sparse matrix/dense vector multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. More...
 
constexpr size_t blaze::SMP_TSMATDVECMULT_USER_THRESHOLD = 1250UL
 SMP column-major sparse matrix/dense vector multiplication threshold.This threshold specifies when a column-major sparse matrix/dense vector multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. More...
 
constexpr size_t blaze::SMP_TDVECSMATMULT_USER_THRESHOLD = 1190UL
 SMP dense vector/row-major sparse matrix multiplication threshold.This threshold specifies when a dense vector/row-major sparse matrix multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. More...
 
constexpr size_t blaze::SMP_TDVECTSMATMULT_USER_THRESHOLD = 530UL
 SMP dense vector/column-major sparse matrix multiplication threshold.This threshold specifies when a dense vector/column-major sparse matrix multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. More...
 
constexpr size_t blaze::SMP_SMATSVECMULT_USER_THRESHOLD = 260UL
 SMP row-major sparse matrix/sparse vector multiplication threshold.This threshold specifies when a row-major sparse matrix/sparse vector multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. More...
 
constexpr size_t blaze::SMP_TSMATSVECMULT_USER_THRESHOLD = 2160UL
 SMP column-major sparse matrix/sparse vector multiplication threshold.This threshold specifies when a column-major sparse matrix/sparse vector multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. More...
 
constexpr size_t blaze::SMP_TSVECSMATMULT_USER_THRESHOLD = 2160UL
 SMP sparse vector/row-major sparse matrix multiplication threshold.This threshold specifies when a sparse vector/row-major sparse matrix multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. More...
 
constexpr size_t blaze::SMP_TSVECTSMATMULT_USER_THRESHOLD = 260UL
 SMP sparse vector/column-major sparse matrix multiplication threshold.This threshold specifies when a sparse vector/column-major sparse matrix multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. More...
 
constexpr size_t blaze::SMP_DMATASSIGN_USER_THRESHOLD = 48400UL
 SMP dense matrix assignment threshold.This threshold specifies when an assignment with a simple dense matrix can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. More...
 
constexpr size_t blaze::SMP_DMATDMATADD_USER_THRESHOLD = 36100UL
 SMP row-major dense matrix/row-major dense matrix addition threshold.This threshold specifies when a row-major dense matrix/row-major dense matrix addition can be executed in parallel. This threshold affects both additions between two row-major matrices or two column-major dense matrices. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. More...
 
constexpr size_t blaze::SMP_DMATTDMATADD_USER_THRESHOLD = 30625UL
 SMP row-major dense matrix/column-major dense matrix addition threshold.This threshold specifies when a row-major dense matrix/column-major dense matrix addition can be executed in parallel. This threshold affects both additions between a row-major matrix and a column-major matrix and a column-major matrix and a row-major matrix. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. More...
 
constexpr size_t blaze::SMP_DMATDMATSUB_USER_THRESHOLD = 36100UL
 SMP row-major dense matrix/row-major dense matrix subtraction threshold.This threshold specifies when a row-major dense matrix/row-major dense matrix subtraction can be executed in parallel. This threshold affects both subtractions between two row-major matrices or two column-major dense matrices. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. More...
 
constexpr size_t blaze::SMP_DMATTDMATSUB_USER_THRESHOLD = 30625UL
 SMP row-major dense matrix/column-major dense matrix subtraction threshold.This threshold specifies when a row-major dense matrix/column-major dense matrix subtraction can be executed in parallel. This threshold affects both subtractions between a row-major matrix and a column-major matrix and a column-major matrix and a row-major matrix. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. More...
 
constexpr size_t blaze::SMP_DMATSCALARMULT_USER_THRESHOLD = 48400UL
 SMP dense matrix/scalar multiplication/division threshold.This threshold specifies when a dense matrix/scalar multiplication or division can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. More...
 
constexpr size_t blaze::SMP_DMATDMATMULT_USER_THRESHOLD = 3025UL
 SMP row-major dense matrix/row-major dense matrix multiplication threshold.This threshold specifies when a row-major dense matrix/row-major dense matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. More...
 
constexpr size_t blaze::SMP_DMATTDMATMULT_USER_THRESHOLD = 3025UL
 SMP row-major dense matrix/column-major dense matrix multiplication threshold.This threshold specifies when a row-major dense matrix/column-major dense matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. More...
 
constexpr size_t blaze::SMP_TDMATDMATMULT_USER_THRESHOLD = 3025UL
 SMP column-major dense matrix/row-major dense matrix multiplication threshold.This threshold specifies when a column-major dense matrix/row-major dense matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. More...
 
constexpr size_t blaze::SMP_TDMATTDMATMULT_USER_THRESHOLD = 3025UL
 SMP column-major dense matrix/column-major dense matrix multiplication threshold.This threshold specifies when a column-major dense matrix/column-major dense matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. More...
 
constexpr size_t blaze::SMP_DMATSMATMULT_USER_THRESHOLD = 4096UL
 SMP row-major dense matrix/row-major sparse matrix multiplication threshold.This threshold specifies when a row-major dense matrix/row-major sparse matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. More...
 
constexpr size_t blaze::SMP_DMATTSMATMULT_USER_THRESHOLD = 4624UL
 SMP row-major dense matrix/column-major sparse matrix multiplication threshold.This threshold specifies when a row-major dense matrix/column-major sparse matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. More...
 
constexpr size_t blaze::SMP_TDMATSMATMULT_USER_THRESHOLD = 8100UL
 SMP column-major dense matrix/row-major sparse matrix multiplication threshold.This threshold specifies when a column-major dense matrix/row-major sparse matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. More...
 
constexpr size_t blaze::SMP_TDMATTSMATMULT_USER_THRESHOLD = 8100UL
 SMP column-major dense matrix/column-major sparse matrix multiplication threshold.This threshold specifies when a column-major dense matrix/column-major sparse matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. More...
 
constexpr size_t blaze::SMP_SMATDMATMULT_USER_THRESHOLD = 7744UL
 SMP row-major sparse matrix/row-major dense matrix multiplication threshold.This threshold specifies when a row-major sparse matrix/row-major dense matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. More...
 
constexpr size_t blaze::SMP_SMATTDMATMULT_USER_THRESHOLD = 5184UL
 SMP row-major sparse matrix/column-major dense matrix multiplication threshold.This threshold specifies when a row-major sparse matrix/column-major dense matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. More...
 
constexpr size_t blaze::SMP_TSMATDMATMULT_USER_THRESHOLD = 4356UL
 SMP column-major sparse matrix/row-major dense matrix multiplication threshold.This threshold specifies when a column-major sparse matrix/row-major dense matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. More...
 
constexpr size_t blaze::SMP_TSMATTDMATMULT_USER_THRESHOLD = 4356UL
 SMP column-major sparse matrix/column-major dense matrix multiplication threshold.This threshold specifies when a column-major sparse matrix/column-major dense matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. More...
 
constexpr size_t blaze::SMP_SMATSMATMULT_USER_THRESHOLD = 22500UL
 SMP row-major sparse matrix/row-major sparse matrix multiplication threshold.This threshold specifies when a row-major sparse matrix/row-major sparse matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. More...
 
constexpr size_t blaze::SMP_SMATTSMATMULT_USER_THRESHOLD = 19600UL
 SMP row-major sparse matrix/column-major sparse matrix multiplication threshold.This threshold specifies when a row-major sparse matrix/column-major sparse matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. More...
 
constexpr size_t blaze::SMP_TSMATSMATMULT_USER_THRESHOLD = 19600UL
 SMP column-major sparse matrix/row-major sparse matrix multiplication threshold.This threshold specifies when a column-major sparse matrix/row-major sparse matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. More...
 
constexpr size_t blaze::SMP_TSMATTSMATMULT_USER_THRESHOLD = 22500UL
 SMP column-major sparse matrix/column-major sparse matrix multiplication threshold.This threshold specifies when a column-major sparse matrix/column-major sparse matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. More...
 
constexpr size_t blaze::SMP_DVECTDVECMULT_USER_THRESHOLD = 84100UL
 SMP dense vector/dense vector outer product threshold.This threshold specifies when a dense vector/dense vector outer product can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. More...
 
constexpr bool blaze::defaultTransposeFlag = columnVector
 The default transpose flag for all vectors of the Blaze library.This value specifies the default transpose flag for all vector of the Blaze library. In case no explicit transpose flag is specified with the according vector type, this setting is used. More...
 
constexpr size_t blaze::DMATDVECMULT_DEBUG_THRESHOLD = 256UL
 Row-major dense matrix/dense vector multiplication threshold.This debug value is used instead of the blaze::DMATDVECMULT_USER_THRESHOLD while the Blaze debug mode is active. It specifies the threshold between the application of the custom Blaze kernels and the BLAS kernels for the row-major dense matrix/dense vector multiplication. In case the number of elements in the dense matrix is equal or higher than this value, the BLAS kernels are preferred over the custom Blaze kernels. In case the number of elements in the dense matrix is smaller, the Blaze kernels are used.
 
constexpr size_t blaze::TDMATDVECMULT_DEBUG_THRESHOLD = 256UL
 Column-major dense matrix/dense vector multiplication threshold.This debug value is used instead of the blaze::TDMATDVECMULT_USER_THRESHOLD while the Blaze debug mode is active. It specifies the threshold between the application of the custom Blaze kernels and the BLAS kernels for the column-major dense matrix/dense vector multiplication. In case the number of elements in the dense matrix is equal or higher than this value, the BLAS kernels are preferred over the custom Blaze kernels. In case the number of elements in the dense matrix is smaller, the Blaze kernels are used.
 
constexpr size_t blaze::TDVECDMATMULT_DEBUG_THRESHOLD = 256UL
 Dense Vector/row-major dense matrix multiplication threshold.This debug value is used instead of the blaze::TDVECDMATMULT_USER_THRESHOLD while the Blaze debug mode is active. It specifies the threshold between the application of the custom Blaze kernels and the BLAS kernels for the dense vector/row-major dense matrix multiplication. In case the number of elements in the dense matrix is equal or higher than this value, the BLAS kernels are preferred over the custom Blaze kernels. In case the number of elements in the dense matrix is smaller, the Blaze kernels are used.
 
constexpr size_t blaze::TDVECTDMATMULT_DEBUG_THRESHOLD = 256UL
 Dense Vector/column-major dense matrix multiplication threshold.This debug value is used instead of the blaze::TDVECTDMATMULT_USER_THRESHOLD while the Blaze debug mode is active. It specifies the threshold between the application of the custom Blaze kernels and the BLAS kernels for the dense vector/column-major dense matrix multiplication. In case the number of elements in the dense matrix is equal or higher than this value, the BLAS kernels are preferred over the custom Blaze kernels. In case the number of elements in the dense matrix is smaller, the Blaze kernels are used.
 
constexpr size_t blaze::DMATDMATMULT_DEBUG_THRESHOLD = 256UL
 Row-major dense matrix/row-major dense matrix multiplication threshold.This debug value is used instead of the blaze::DMATDMATMULT_USER_THRESHOLD while the Blaze debug mode is active. It specifies the threshold between the application of the custom Blaze kernels and the BLAS kernels for the row-major dense matrix/row-major dense matrix multiplication. In case the number of elements in the dense matrix is equal or higher than this value, the BLAS kernels are preferred over the custom Blaze kernels. In case the number of elements in the dense matrix is smaller, the Blaze kernels are used.
 
constexpr size_t blaze::DMATTDMATMULT_DEBUG_THRESHOLD = 256UL
 Row-major dense matrix/column-major dense matrix multiplication threshold.This debug value is used instead of the blaze::DMATTDMATMULT_USER_THRESHOLD while the Blaze debug mode is active. It specifies the threshold between the application of the custom Blaze kernels and the BLAS kernels for the row-major dense matrix/column-major dense matrix multiplication. In case the number of elements in the dense matrix is equal or higher than this value, the BLAS kernels are preferred over the custom Blaze kernels. In case the number of elements in the dense matrix is smaller, the Blaze kernels are used.
 
constexpr size_t blaze::TDMATDMATMULT_DEBUG_THRESHOLD = 256UL
 Column-major dense matrix/row-major dense matrix multiplication threshold.This debug value is used instead of the blaze::TDMATDMATMULT_USER_THRESHOLD while the Blaze debug mode is active. It specifies the threshold between the application of the custom Blaze kernels and the BLAS kernels for the column-major dense matrix/row-major dense matrix multiplication. In case the number of elements in the dense matrix is equal or higher than this value, the BLAS kernels are preferred over the custom Blaze kernels. In case the number of elements in the dense matrix is smaller, the Blaze kernels are used.
 
constexpr size_t blaze::TDMATTDMATMULT_DEBUG_THRESHOLD = 256UL
 Column-major dense matrix/column-major dense matrix multiplication threshold.This debug value is used instead of the blaze::TDMATTDMATMULT_USER_THRESHOLD while the Blaze debug mode is active. It specifies the threshold between the application of the custom Blaze kernels and the BLAS kernels for the column-major dense matrix/column-major dense matrix multiplication. In case the number of elements in the dense matrix is equal or higher than this value, the BLAS kernels are preferred over the custom Blaze kernels. In case the number of elements in the dense matrix is smaller, the Blaze kernels are used.
 
constexpr size_t blaze::DMATSMATMULT_DEBUG_THRESHOLD = 256UL
 Row-major dense matrix/row-major sparse matrix multiplication threshold.This debug value is used instead of the blaze::DMATSMATMULT_USER_THRESHOLD while the Blaze debug mode is active. It specifies the threshold between the application of the Blaze kernels for small and for large row-major dense matrix/row-major sparse matrix multiplications. In case the number of elements of the target matrix is equal or higher than this value, the kernel for large matrices is preferred over the kernel for small matrices. In case the number of elements in the target matrix is smaller, the kernel for small matrices is used.
 
constexpr size_t blaze::TDMATSMATMULT_DEBUG_THRESHOLD = 256UL
 Column-major dense matrix/row-major sparse matrix multiplication threshold.This debug value is used instead of the blaze::DMATSMATMULT_USER_THRESHOLD while the Blaze debug mode is active. It specifies the threshold between the application of the Blaze kernels for small and for large column-major dense matrix/row-major sparse matrix multiplications. In case the number of elements of the target matrix is equal or higher than this value, the kernel for large matrices is preferred over the kernel for small matrices. In case the number of elements in the target matrix is smaller, the kernel for small matrices is used.
 
constexpr size_t blaze::TSMATDMATMULT_DEBUG_THRESHOLD = 256UL
 Column-major sparse matrix/row-major dense matrix multiplication threshold.This debug value is used instead of the blaze::TSMATDMATMULT_USER_THRESHOLD while the Blaze debug mode is active. It specifies the threshold between the application of the Blaze kernels for small and for large column-major sparse matrix/row-major dense matrix multiplications. In case the number of elements of the target matrix is equal or higher than this value, the kernel for large matrices is preferred over the kernel for small matrices. In case the number of elements in the target matrix is smaller, the kernel for small matrices is used.
 
constexpr size_t blaze::TSMATTDMATMULT_DEBUG_THRESHOLD = 256UL
 Column-major sparse matrix/column-major dense matrix multiplication threshold.This debug value is used instead of the blaze::TSMATTDMATMULT_USER_THRESHOLD while the Blaze debug mode is active. It specifies the threshold between the application of the Blaze kernels for small and for large column-major sparse matrix/column-major dense matrix multiplications. In case the number of elements of the target matrix is equal or higher than this value, the kernel for large matrices is preferred over the kernel for small matrices. In case the number of elements in the target matrix is smaller, the kernel for small matrices is used.
 
constexpr size_t blaze::SMP_DVECASSIGN_DEBUG_THRESHOLD = 32UL
 SMP dense vector assignment threshold.This debug value is used instead of the blaze::SMP_DVECASSIGN_USER_THRESHOLD while the Blaze debug mode is active. It specifies when an assignment of a simple dense vector can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.
 
constexpr size_t blaze::SMP_DVECDVECADD_DEBUG_THRESHOLD = 32UL
 SMP dense vector/dense vector addition threshold.This debug value is used instead of the blaze::SMP_DVECDVECADD_USER_THRESHOLD while the Blaze debug mode is active. It specifies when a dense vector/dense vector addition can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.
 
constexpr size_t blaze::SMP_DVECDVECSUB_DEBUG_THRESHOLD = 32UL
 SMP dense vector/dense vector subtraction threshold.This debug value is used instead of the blaze::SMP_DVECDVECSUB_USER_THRESHOLD while the Blaze debug mode is active. It specifies when a dense vector/dense vector subtraction can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.
 
constexpr size_t blaze::SMP_DVECDVECMULT_DEBUG_THRESHOLD = 32UL
 SMP dense vector/dense vector multiplication threshold.This debug value is used instead of the blaze::SMP_DVECDVECMULT_USER_THRESHOLD while the Blaze debug mode is active. It specifies when a dense vector/dense vector multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.
 
constexpr size_t blaze::SMP_DVECDVECDIV_DEBUG_THRESHOLD = 32UL
 SMP dense vector/dense vector division threshold.This debug value is used instead of the blaze::SMP_DVECDVECDIV_USER_THRESHOLD while the Blaze debug mode is active. It specifies when a dense vector/dense vector division can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.
 
constexpr size_t blaze::SMP_DVECSCALARMULT_DEBUG_THRESHOLD = 32UL
 SMP dense vector/scalar multiplication/division threshold.This debug value is used instead of the blaze::SMP_DVECSCALARMULT_USER_THRESHOLD while the Blaze debug mode is active. It specifies when a dense vector/scalar multiplication/division can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.
 
constexpr size_t blaze::SMP_DMATDVECMULT_DEBUG_THRESHOLD = 16UL
 SMP row-major dense matrix/dense vector multiplication threshold.This debug value is used instead of the blaze::SMP_DMATDVECMULT_USER_THRESHOLD while the Blaze debug mode is active. It specifies when a row-major dense matrix/dense vector multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.
 
constexpr size_t blaze::SMP_TDMATDVECMULT_DEBUG_THRESHOLD = 16UL
 SMP column-major dense matrix/dense vector multiplication threshold.This debug value is used instead of the blaze::SMP_TDMATDVECMULT_USER_THRESHOLD while the Blaze debug mode is active. It specifies when a column-major dense matrix/dense vector multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.
 
constexpr size_t blaze::SMP_TDVECDMATMULT_DEBUG_THRESHOLD = 16UL
 SMP dense vector/row-major dense matrix multiplication threshold.This debug value is used instead of the blaze::SMP_TDVECDMATMULT_USER_THRESHOLD while the Blaze debug mode is active. It specifies when a dense vector/row-major dense matrix multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.
 
constexpr size_t blaze::SMP_TDVECTDMATMULT_DEBUG_THRESHOLD = 16UL
 SMP dense vector/column-major dense matrix multiplication threshold.This debug value is used instead of the blaze::SMP_TDVECTDMATMULT_USER_THRESHOLD while the Blaze debug mode is active. It specifies when a dense vector/column-major dense matrix multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.
 
constexpr size_t blaze::SMP_DMATSVECMULT_DEBUG_THRESHOLD = 16UL
 SMP row-major dense matrix/sparse vector multiplication threshold.This debug value is used instead of the blaze::SMP_DMATSVECMULT_USER_THRESHOLD while the Blaze debug mode is active. It specifies when a row-major dense matrix/sparse vector multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.
 
constexpr size_t blaze::SMP_TDMATSVECMULT_DEBUG_THRESHOLD = 16UL
 SMP column-major dense matrix/sparse vector multiplication threshold.This debug value is used instead of the blaze::SMP_TDMATSVECMULT_USER_THRESHOLD while the Blaze debug mode is active. It specifies when a column-major dense matrix/sparse vector multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.
 
constexpr size_t blaze::SMP_TSVECDMATMULT_DEBUG_THRESHOLD = 16UL
 SMP sparse vector/row-major dense matrix multiplication threshold.This debug value is used instead of the blaze::SMP_TSVECDMATMULT_USER_THRESHOLD while the Blaze debug mode is active. It specifies when a sparse vector/row-major dense matrix multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.
 
constexpr size_t blaze::SMP_TSVECTDMATMULT_DEBUG_THRESHOLD = 16UL
 SMP sparse vector/column-major dense matrix multiplication threshold.This debug value is used instead of the blaze::SMP_TSVECTDMATMULT_USER_THRESHOLD while the Blaze debug mode is active. It specifies when a sparse vector/column-major dense matrix multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.
 
constexpr size_t blaze::SMP_SMATDVECMULT_DEBUG_THRESHOLD = 16UL
 SMP row-major sparse matrix/dense vector multiplication threshold.This debug value is used instead of the blaze::SMP_SMATDVECMULT_USER_THRESHOLD while the Blaze debug mode is active. It specifies when a row-major sparse matrix/dense vector multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.
 
constexpr size_t blaze::SMP_TSMATDVECMULT_DEBUG_THRESHOLD = 16UL
 SMP column-major sparse matrix/dense vector multiplication threshold.This debug value is used instead of the blaze::SMP_TSMATDVECMULT_USER_THRESHOLD while the Blaze debug mode is active. It specifies when a column-major sparse matrix/dense vector multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.
 
constexpr size_t blaze::SMP_TDVECSMATMULT_DEBUG_THRESHOLD = 16UL
 SMP dense vector/row-major sparse matrix multiplication threshold.This debug value is used instead of the blaze::SMP_TDVECSMATMULT_USER_THRESHOLD while the Blaze debug mode is active. It specifies when a dense vector/row-major sparse matrix multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.
 
constexpr size_t blaze::SMP_TDVECTSMATMULT_DEBUG_THRESHOLD = 16UL
 SMP dense vector/column-major sparse matrix multiplication threshold.This debug value is used instead of the blaze::SMP_TDVECTSMATMULT_USER_THRESHOLD while the Blaze debug mode is active. It specifies when a dense vector/column-major sparse matrix multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.
 
constexpr size_t blaze::SMP_SMATSVECMULT_DEBUG_THRESHOLD = 16UL
 SMP row-major sparse matrix/sparse vector multiplication threshold.This debug value is used instead of the blaze::SMP_SMATSVECMULT_USER_THRESHOLD while the Blaze debug mode is active. It specifies when a row-major sparse matrix/sparse vector multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.
 
constexpr size_t blaze::SMP_TSMATSVECMULT_DEBUG_THRESHOLD = 16UL
 SMP column-major sparse matrix/sparse vector multiplication threshold.This debug value is used instead of the blaze::SMP_TSMATSVECMULT_USER_THRESHOLD while the Blaze debug mode is active. It specifies when a column-major sparse matrix/sparse vector multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.
 
constexpr size_t blaze::SMP_TSVECSMATMULT_DEBUG_THRESHOLD = 16UL
 SMP sparse vector/row-major sparse matrix multiplication threshold.This debug value is used instead of the blaze::SMP_TSVECSMATMULT_USER_THRESHOLD while the Blaze debug mode is active. It specifies when a sparse vector/row-major sparse matrix multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.
 
constexpr size_t blaze::SMP_TSVECTSMATMULT_DEBUG_THRESHOLD = 16UL
 SMP sparse vector/column-major sparse matrix multiplication threshold.This debug value is used instead of the blaze::SMP_TSVECTSMATMULT_USER_THRESHOLD while the Blaze debug mode is active. It specifies when a sparse vector/column-major sparse matrix multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.
 
constexpr size_t blaze::SMP_DMATASSIGN_DEBUG_THRESHOLD = 256UL
 SMP dense matrix assignment threshold.This debug value is used instead of the blaze::SMP_DMATASSIGN_USER_THRESHOLD while the Blaze debug mode is active. It specifies when an assignment with a simple dense matrix can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.
 
constexpr size_t blaze::SMP_DMATDMATADD_DEBUG_THRESHOLD = 256UL
 SMP row-major dense matrix/row-major dense matrix addition threshold.This debug value is used instead of the blaze::SMP_DMATDMATADD_USER_THRESHOLD while the Blaze debug mode is active. It specifies when a row-major dense matrix/row-major dense matrix addition can be executed in parallel. This threshold affects both additions between two row-major matrices or two column-major dense matrices. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.
 
constexpr size_t blaze::SMP_DMATTDMATADD_DEBUG_THRESHOLD = 256UL
 SMP row-major dense matrix/column-major dense matrix addition threshold.This debug value is used instead of the blaze::SMP_DMATTDMATADD_USER_THRESHOLD while the Blaze debug mode is active. It specifies when a row-major dense matrix/column-major dense matrix addition can be executed in parallel. This threshold affects both additions between a row-major matrix and a column-major matrix and a column-major matrix and a row-major matrix. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.
 
constexpr size_t blaze::SMP_DMATDMATSUB_DEBUG_THRESHOLD = 256UL
 SMP row-major dense matrix/row-major dense matrix subtraction threshold.This debug value is used instead of the blaze::SMP_DMATDMATSUB_USER_THRESHOLD while the Blaze debug mode is active. It specifies when a row-major dense matrix/row-major dense matrix subtraction can be executed in parallel. This threshold affects both subtractions between two row-major matrices or two column-major dense matrices. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.
 
constexpr size_t blaze::SMP_DMATTDMATSUB_DEBUG_THRESHOLD = 256UL
 SMP row-major dense matrix/column-major dense matrix subtraction threshold.This debug value is used instead of the blaze::SMP_DMATTDMATSUB_USER_THRESHOLD while the Blaze debug mode is active. It specifies when a row-major dense matrix/column-major dense matrix subtraction can be executed in parallel. This threshold affects both subtractions between a row-major matrix and a column-major matrix and a column-major matrix and a row-major matrix. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.
 
constexpr size_t blaze::SMP_DMATSCALARMULT_DEBUG_THRESHOLD = 256UL
 SMP dense matrix/scalar multiplication/division threshold.This debug value is used instead of the blaze::SMP_DMATSCALARMULT_USER_THRESHOLD while the Blaze debug mode is active. It specifies when a dense matrix/scalar multiplication or division can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.
 
constexpr size_t blaze::SMP_DMATDMATMULT_DEBUG_THRESHOLD = 256UL
 SMP row-major dense matrix/row-major dense matrix multiplication threshold.This debug value is used instead of the blaze::SMP_DMATDMATMULT_USER_THRESHOLD while the Blaze debug mode is active. It specifies when a row-major dense matrix/row-major dense matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.
 
constexpr size_t blaze::SMP_DMATTDMATMULT_DEBUG_THRESHOLD = 256UL
 SMP row-major dense matrix/column-major dense matrix multiplication threshold.This debug value is used instead of the blaze::SMP_DMATTDMATMULT_USER_THRESHOLD while the Blaze debug mode is active. It specifies when a row-major dense matrix/column-major dense matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.
 
constexpr size_t blaze::SMP_TDMATDMATMULT_DEBUG_THRESHOLD = 256UL
 SMP column-major dense matrix/row-major dense matrix multiplication threshold.This debug value is used instead of the blaze::SMP_TDMATDMATMULT_USER_THRESHOLD while the Blaze debug mode is active. It specifies when a column-major dense matrix/row-major dense matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.
 
constexpr size_t blaze::SMP_TDMATTDMATMULT_DEBUG_THRESHOLD = 256UL
 SMP column-major dense matrix/column-major dense matrix multiplication threshold.This debug value is used instead of the blaze::SMP_TDMATTDMATMULT_USER_THRESHOLD while the Blaze debug mode is active. It specifies when a column-major dense matrix/column-major dense matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.
 
constexpr size_t blaze::SMP_DMATSMATMULT_DEBUG_THRESHOLD = 256UL
 SMP row-major dense matrix/row-major sparse matrix multiplication threshold.This debug value is used instead of the blaze::SMP_DMATSMATMULT_USER_THRESHOLD while the Blaze debug mode is active. It specifies when a row-major dense matrix/row-major sparse matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.
 
constexpr size_t blaze::SMP_DMATTSMATMULT_DEBUG_THRESHOLD = 256UL
 SMP row-major dense matrix/column-major sparse matrix multiplication threshold.This debug value is used instead of the blaze::SMP_DMATTSMATMULT_USER_THRESHOLD while the Blaze debug mode is active. It specifies when a row-major dense matrix/column-major sparse matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.
 
constexpr size_t blaze::SMP_TDMATSMATMULT_DEBUG_THRESHOLD = 256UL
 SMP column-major dense matrix/row-major sparse matrix multiplication threshold.This debug value is used instead of the blaze::SMP_TDMATSMATMULT_USER_THRESHOLD while the Blaze debug mode is active. It specifies when a column-major dense matrix/row-major sparse matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.
 
constexpr size_t blaze::SMP_TDMATTSMATMULT_DEBUG_THRESHOLD = 256UL
 SMP column-major dense matrix/column-major sparse matrix multiplication threshold.This debug value is used instead of the blaze::SMP_TDMATTSMATMULT_USER_THRESHOLD while the Blaze debug mode is active. It specifies when a column-major dense matrix/column-major sparse matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.
 
constexpr size_t blaze::SMP_SMATDMATMULT_DEBUG_THRESHOLD = 256UL
 SMP row-major sparse matrix/row-major dense matrix multiplication threshold.This debug value is used instead of the blaze::SMP_SMATDMATMULT_USER_THRESHOLD while the Blaze debug mode is active. It specifies when a row-major sparse matrix/row-major dense matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.
 
constexpr size_t blaze::SMP_SMATTDMATMULT_DEBUG_THRESHOLD = 256UL
 SMP row-major sparse matrix/column-major dense matrix multiplication threshold.This debug value is used instead of the blaze::SMP_SMATTDMATMULT_USER_THRESHOLD while the Blaze debug mode is active. It specifies when a row-major sparse matrix/column-major dense matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.
 
constexpr size_t blaze::SMP_TSMATDMATMULT_DEBUG_THRESHOLD = 256UL
 SMP column-major sparse matrix/row-major dense matrix multiplication threshold.This debug value is used instead of the blaze::SMP_TSMATDMATMULT_USER_THRESHOLD while the Blaze debug mode is active. It specifies when a column-major sparse matrix/row-major dense matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.
 
constexpr size_t blaze::SMP_TSMATTDMATMULT_DEBUG_THRESHOLD = 256UL
 SMP column-major sparse matrix/column-major dense matrix multiplication threshold.This debug value is used instead of the blaze::SMP_TSMATTDMATMULT_USER_THRESHOLD while the Blaze debug mode is active. It specifies when a column-major sparse matrix/column-major dense matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.
 
constexpr size_t blaze::SMP_SMATSMATMULT_DEBUG_THRESHOLD = 256UL
 SMP row-major sparse matrix/row-major sparse matrix multiplication threshold.This debug value is used instead of the blaze::SMP_SMATSMATMULT_USER_THRESHOLD while the Blaze debug mode is active. It specifies when a row-major sparse matrix/row-major sparse matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.
 
constexpr size_t blaze::SMP_SMATTSMATMULT_DEBUG_THRESHOLD = 256UL
 SMP row-major sparse matrix/column-major sparse matrix multiplication threshold.This debug value is used instead of the blaze::SMP_SMATTSMATMULT_USER_THRESHOLD while the Blaze debug mode is active. It specifies when a row-major sparse matrix/column-major sparse matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.
 
constexpr size_t blaze::SMP_TSMATSMATMULT_DEBUG_THRESHOLD = 256UL
 SMP column-major sparse matrix/row-major sparse matrix multiplication threshold.This debug value is used instead of the blaze::SMP_TSMATSMATMULT_USER_THRESHOLD while the Blaze debug mode is active. It specifies when a column-major sparse matrix/row-major sparse matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.
 
constexpr size_t blaze::SMP_TSMATTSMATMULT_DEBUG_THRESHOLD = 256UL
 SMP column-major sparse matrix/column-major sparse matrix multiplication threshold.This debug value is used instead of the blaze::SMP_TSMATTSMATMULT_USER_THRESHOLD while the Blaze debug mode is active. It specifies when a column-major sparse matrix/column-major sparse matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.
 
constexpr size_t blaze::SMP_DVECTDVECMULT_DEBUG_THRESHOLD = 256UL
 SMP dense vector/dense vector outer product threshold.This debug value is used instead of the blaze::SMP_DVECTDVECMULT_USER_THRESHOLD while the Blaze debug mode is active. It specifies when a dense vector/dense vector outer product can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.
 

Detailed Description

The configuration module offers the possibility to tune the Blaze library to the individual needs and requirements.

Macro Definition Documentation

#define BLAZE_BLAS_INCLUDE_FILE   <cblas.h>

Compilation switch for the of the BLAS include file.This compilation switch specifies the name of the BLAS include file. By default, the header <cblas.h> is included when the BLAS mode is activated. In case the name of the include file differs (as for instance in case of the MKL the file is called <mkl_cblas.h>) this switch needs to be adapted accordingly.

Note that changing the name of the BLAS include file requires a recompilation of all code using the Blaze library.

#define BLAZE_BLAS_IS_PARALLEL   0

Compilation switch for the parallel BLAS mode.This compilation switch specifies whether the used BLAS library is itself parallelized or not. In case the given BLAS library is itself parallelized, the Blaze library does not perform any attempt to parallelize the execution of BLAS kernels. If, however, the given BLAS library is not parallelized Blaze will attempt to parallelize the execution of BLAS kernels.

Possible settings for the switch:

  • BLAS library is not parallelized: 0 (default)
  • BLAS library is parallelized : 1

Note that changing the setting of the BLAS mode requires a recompilation of all code using the Blaze library.

#define BLAZE_BLAS_MODE   0

Compilation switch for the BLAS mode.This compilation switch enables/disables the BLAS mode. In case the BLAS mode is enabled, several basic linear algebra functions (such as for instance matrix-matrix multiplications between two dense matrices) are handled by performance optimized BLAS functions. Note that in this case it is mandatory to provide the according BLAS header file for the compilation of the Blaze library. In case the BLAS mode is disabled, all linear algebra functions use the default implementations of the Blaze library and therefore BLAS is not a requirement for the compilation process.

Possible settings for the BLAS switch:

  • Disabled: 0
  • Enabled : 1

Note that changing the setting of the BLAS mode requires a recompilation of all code using the Blaze library.

#define BLAZE_INTERNAL_ASSERTION   0

Compilation switch for internal assertions.This compilation switch triggers internal assertions, which are used to verify the program itself. The internal assertions can also be deactivated by defining NDEBUG during the compilation.

Possible settings for the internal assertion switch:

  • Deactivated: 0
  • Activated : 1
#define BLAZE_USE_ALWAYS_INLINE   1

Compilation switch for an enforced inline keyword.Although the BLAZE_STRONG_INLINE keyword improves the likelihood of a function being inlined it does not provide a 100% guarantee. Depending on the availability of an according keyword and/or modifier on a specific platform, this guarantee is provided by the BLAZE_ALWAYS_INLINE keyword, which uses platform-specific functionality to enforce the inlining of a function.

This compilation switch enables/disables the BLAZE_ALWAYS_INLINE keyword. When disabled or in case the platform does not provide a keyword and/or modifier for a 100% inline guarantee, the BLAZE_ALWAYS_INLINE keyword uses the BLAZE_STRONG_INLINE keyword as fallback. Possible settings for the switch are:

  • Deactivated: 0
  • Activated : 1
#define BLAZE_USE_BLAS_MATRIX_MATRIX_MULTIPLICATION   1

Compilation switch for the BLAS matrix/matrix multiplication kernels (gemv).This compilation switch enables/disables the BLAS matrix/matrix multiplication kernels. If the switch is enabled, multiplications between dense matrices are computed by BLAS kernels, if it is disabled the multiplications are handled by the default Blaze kernels.

Possible settings for the switch:

  • Disabled: 0
  • Enabled : 1 (default)

Note that changing the setting of this compilation switch requires a recompilation of all code using the Blaze library.

#define BLAZE_USE_BLAS_MATRIX_VECTOR_MULTIPLICATION   0

Compilation switch for the BLAS matrix/vector multiplication kernels (gemv).This compilation switch enables/disables the BLAS matrix/vector multiplication kernels. If the switch is enabled, multiplications between dense matrices and dense vectors are computed by BLAS kernels, if it is disabled the multiplications are handled by the default Blaze kernels.

Possible settings for the switch:

  • Disabled: 0 (default)
  • Enabled : 1

Note that changing the setting of this compilation switch requires a recompilation of all code using the Blaze library.

#define BLAZE_USE_DEBUG_MODE   0

Compilation switch for the (de-)activation of the debug mode.This compilation switch enables/disables the debug mode of the Blaze library. In case the switch is set to 1 (i.e. in case the debug mode is enabled), the Blaze library is allowed to perform additional runtime checks and to modify user-defined settings to guarantee a full and thorough debugging process. In case the switch is set to 0 (i.e. the debug mode is disabled), no additional checks are added and no settings are modified.

Possible settings for the debug mode switch:

  • Deactivated: 0 (default)
  • Activated : 1
#define BLAZE_USE_FUNCTION_TRACES   0

Compilation switch for function traces.This compilation switch triggers the use of function traces. In case the switch is set to 1, function traces via the BLAZE_FUNCTION_TRACE are enabled. Note however, that enabling function traces creates a dependency to the compiled Blaze library, i.e. it will be necessary to link the Blaze library to the executable. This is also true in case only template functionality is used!

Possible settings for the function trace switch:

  • Deactivated: 0 (default)
  • Activated : 1
#define BLAZE_USE_RESTRICT   1

Compilation switch for C99 restrict keyword.This compilation switch enables/disables the C99 restrict keyword.

Possible settings for the C99 restrict switch:

  • Deactivated: 0
  • Activated : 1
#define BLAZE_USE_SHARED_MEMORY_PARALLELIZATION   1

Compilation switch for the (de-)activation of the shared-memory parallelizationThis compilation switch enables/disables the shared-memory parallelization. In case the switch is set to 1 (i.e. in case the shared-memory parallelization is enabled), the Blaze library is allowed to execute operations in parallel. In case the switch is set to 0 (i.e. parallelization is disabled), the Blaze library is restricted from executing operations in parallel.

Possible settings for the shared-memory parallelization switch:

  • Deactivated: 0
  • Activated : 1 (default)
#define BLAZE_USE_STRONG_INLINE   1

Compilation switch for a strengthened inline keyword.The regular C++ inline keyword merely represents a hint to the compiler to inline a function. Due to that, when using the inline keyword for performance critical functions, one is at the mercy of the compiler to properly inline the functions. In order to improve the likelihood of a function being properly inlined the BLAZE_STRONG_INLINE keyword can be used. In contrast to the regular inline keyword, BLAZE_STRONG_INLINE uses platform-specific keywords and modifiers to improve the likelihood of a function being properly inlined. Please note, however, that even in case the platform-specific inline is used, there is no guarantee that a function is inlined (see for instance the http://msdn.microsoft.com/en-us/library/z8y1yy88.aspx).

This compilation switch enables/disables the BLAZE_STRONG_INLINE keyword. When disabled, the keyword uses the regular inline keyword as fallback. Possible setting for the switch are:

  • Deactivated: 0
  • Activated : 1
#define BLAZE_USE_VECTORIZATION   1

Compilation switch for (de-)activation of the Blaze vectorization.This compilation switch enables/disables vectorization of mathematical expressions via the SSE, AVX, and/or MIC instruction sets. In case the switch is set to 1 (i.e. in case vectorization is enabled), the Blaze library attempts to vectorize the linear algebra operations by SSE, AVX, and/or MIC intrinsics (depending on which instruction set is available on the target platform). In case the switch is set to 0 (i.e. vectorization is disabled), the Blaze library chooses default, non-vectorized functionality for the operations. Note that deactivating the vectorization may pose a severe performance limitation for a large number of operations!

Possible settings for the vectorization switch:

  • Deactivated: 0
  • Activated : 1 (default)
#define BLAZE_USER_ASSERTION   0

Compilation switch for user assertions.This compilation switch triggers user assertions, which are used to check user specified function parameters and values. The user assertions can also be deactivated by defining NDEBUG during the compilation.

Possible settings for the user assertion switch:

  • Deactivated: 0
  • Activated : 1

Typedef Documentation

typedef double blaze::real_t

Floating point data type of the Blaze library.This type definition offers the possibility to switch the floating point precision of the Blaze library between float, double and long double.

Valid types for the real_t floating point type: float, double, long double

typedef std::mt19937 blaze::RNG

Type of the random number generator of the Blaze library.This type definition represents the type of the random number generated used in the Blaze library. The default random number generator is the std::mt19937 mersenne-twister pseudo random number generator. For more information see the following reference documentation:

http://en.cppreference.com/w/cpp/numeric/random/mersenne_twister_engine

Variable Documentation

constexpr size_t blaze::cacheSize = 3145728UL

Cache size of the target architecture.This setting specifies the available cache size in Byte of the used target architecture. Several algorithms use this setting for an optimized evaluation.

The size of the cache is specified in Byte. For instance, a cache of 3 MiByte must therefore be specified as 3145728.

constexpr bool blaze::defaultStorageOrder = rowMajor

The default storage order for all matrices of the Blaze library.This value specifies the default storage order for all matrices of the Blaze library. In case no explicit storage order is specified with the according matrix type, this setting is used.

// Explicit specification of the storage order => row-major matrix
StaticMatrix<double,3UL,3UL,rowMajor> A;
// No explicit specification of the storage order => use of the defaultStorageOrder
StaticMatrix<double,3UL,3UL> B;

Valid settings for the defaultStorageOrder are blaze::rowMajor and blaze::columnMajor.

constexpr bool blaze::defaultTransposeFlag = columnVector

The default transpose flag for all vectors of the Blaze library.This value specifies the default transpose flag for all vector of the Blaze library. In case no explicit transpose flag is specified with the according vector type, this setting is used.

// Explicit specification of the transpose flag => column vector
StaticVector<double,3UL,columnMajor> a;
// No explicit specification of the transpose flag => use of the defaultTransposeFlag
StaticVector<double,3UL> b;

Valid settings for the defaultTransposeFlag are blaze::rowVector and blaze::columnVector.

constexpr size_t blaze::DMATDMATMULT_USER_THRESHOLD = 10000UL

Row-major dense matrix/row-major dense matrix multiplication threshold.This setting specifies the threshold between the application of the custom Blaze kernels and the BLAS kernels for the row-major dense matrix/row-major dense matrix multiplication. In case the number of elements of the target matrix is equal or higher than this value, the BLAS kernels are preferred over the custom Blaze kernels. In case the number of elements in the target matrix is smaller, the Blaze kernels are used.

The default setting for this threshold is 10000 (which for instance corresponds to a matrix size of $ 100 \times 100 $). Note that in case the Blaze debug mode is active, this threshold will be replaced by the blaze::DMATDMATMULT_DEBUG_THRESHOLD value.

constexpr size_t blaze::DMATDVECMULT_USER_THRESHOLD = 4000000UL

Row-major dense matrix/dense vector multiplication threshold.This setting specifies the threshold between the application of the custom Blaze kernels and the BLAS kernels for the row-major dense matrix/dense vector multiplication. In case the number of elements in the dense matrix is equal or higher than this value, the BLAS kernels are preferred over the custom Blaze kernels. In case the number of elements in the dense matrix is smaller, the Blaze kernels are used.

The default setting for this threshold is 4000000 (which for instance corresponds to a matrix size of $ 2000 \times 2000 $). Note that in case the Blaze debug mode is active, this threshold will be replaced by the blaze::DMATDVECMULT_DEBUG_THRESHOLD value.

constexpr size_t blaze::DMATSMATMULT_USER_THRESHOLD = 2500UL

Row-major dense matrix/row-major sparse matrix multiplication threshold.This setting specifies the threshold between the application of the Blaze kernels for small and for large row-major dense matrix/row-major sparse matrix multiplications. In case the number of elements of the target matrix is equal or higher than this value, the kernel for large matrices is preferred over the kernel for small matrices. In case the number of elements in the target matrix is smaller, the kernel for small matrices is used.

The default setting for this threshold is 2500 (which for instance corresponds to a matrix size of $ 50 \times 50 $). Note that in case the Blaze debug mode is active, this threshold will be replaced by the blaze::DMATSMATMULT_DEBUG_THRESHOLD value.

constexpr size_t blaze::DMATTDMATMULT_USER_THRESHOLD = 10000UL

Row-major dense matrix/column-major dense matrix multiplication threshold.This setting specifies the threshold between the application of the custom Blaze kernels and the BLAS kernels for the row-major dense matrix/column-major dense matrix multiplication. In case the number of elements of the target matrix is equal or higher than this value, the BLAS kernels are preferred over the custom Blaze kernels. In case the number of elements in the target matrix is smaller, the Blaze kernels are used.

The default setting for this threshold is 10000 (which for instance corresponds to a matrix size of $ 100 \times 100 $). Note that in case the Blaze debug mode is active, this threshold will be replaced by the blaze::DMATTDMATMULT_DEBUG_THRESHOLD value.

constexpr LogLevel blaze::logging::loglevel = info

Setting of the logging level.This value specifies the logging level of the Blaze logging functionality. Depending on this setting, more or less informations will be written to the log file(s). The following logging levels can be selected:

  • inactive: Completely deactives the logging functionality, i.e., no log file(s) will be written. Since this setting can immensely complicate error correction, it is not recommended to use this setting!
  • error : Only (severe) errors are written to the log file(s).
  • warning : Extends the error setting by warning messages.
  • info : Extends the warning setting by additional informative messages (default).
  • progress: Extends the info setting by progress informations.
  • debug : Extends the progress setting by debug information.
  • detail : Extends the debug setting by very fine grained detail information.
constexpr size_t blaze::SMP_DMATASSIGN_USER_THRESHOLD = 48400UL

SMP dense matrix assignment threshold.This threshold specifies when an assignment with a simple dense matrix can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.

Please note that this threshold is highly sensitiv to the used system architecture and the shared memory parallelization technique. Therefore the default value cannot guarantee maximum performance for all possible situations and configurations. It merely provides a reasonable standard for the current generation of CPUs. Also note that the provided default has been determined using the OpenMP parallelization and requires individual adaption for the C++11 and Boost thread parallelization.

The default setting for this threshold is 48400 (which corresponds to a matrix size of $ 220 \times 220 $). In case the threshold is set to 0, the operation is unconditionally executed in parallel.

constexpr size_t blaze::SMP_DMATDMATADD_USER_THRESHOLD = 36100UL

SMP row-major dense matrix/row-major dense matrix addition threshold.This threshold specifies when a row-major dense matrix/row-major dense matrix addition can be executed in parallel. This threshold affects both additions between two row-major matrices or two column-major dense matrices. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.

Please note that this threshold is highly sensitiv to the used system architecture and the shared memory parallelization technique. Therefore the default value cannot guarantee maximum performance for all possible situations and configurations. It merely provides a reasonable standard for the current generation of CPUs. Also note that the provided default has been determined using the OpenMP parallelization and requires individual adaption for the C++11 and Boost thread parallelization.

The default setting for this threshold is 36100 (which corresponds to a matrix size of $ 190 \times 190 $). In case the threshold is set to 0, the operation is unconditionally executed in parallel.

constexpr size_t blaze::SMP_DMATDMATMULT_USER_THRESHOLD = 3025UL

SMP row-major dense matrix/row-major dense matrix multiplication threshold.This threshold specifies when a row-major dense matrix/row-major dense matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.

Please note that this threshold is highly sensitiv to the used system architecture and the shared memory parallelization technique. Therefore the default value cannot guarantee maximum performance for all possible situations and configurations. It merely provides a reasonable standard for the current generation of CPUs. Also note that the provided default has been determined using the OpenMP parallelization and requires individual adaption for the C++11 and Boost thread parallelization.

The default setting for this threshold is 3025 (which corresponds to a matrix size of $ 55 \times 55 $). In case the threshold is set to 0, the operation is unconditionally executed in parallel.

constexpr size_t blaze::SMP_DMATDMATSUB_USER_THRESHOLD = 36100UL

SMP row-major dense matrix/row-major dense matrix subtraction threshold.This threshold specifies when a row-major dense matrix/row-major dense matrix subtraction can be executed in parallel. This threshold affects both subtractions between two row-major matrices or two column-major dense matrices. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.

Please note that this threshold is highly sensitiv to the used system architecture and the shared memory parallelization technique. Therefore the default value cannot guarantee maximum performance for all possible situations and configurations. It merely provides a reasonable standard for the current generation of CPUs. Also note that the provided default has been determined using the OpenMP parallelization and requires individual adaption for the C++11 and Boost thread parallelization.

The default setting for this threshold is 36100 (which corresponds to a matrix size of $ 190 \times 190 $). In case the threshold is set to 0, the operation is unconditionally executed in parallel.

constexpr size_t blaze::SMP_DMATDVECMULT_USER_THRESHOLD = 330UL

SMP row-major dense matrix/dense vector multiplication threshold.This threshold specifies when a row-major dense matrix/dense vector multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.

Please note that this threshold is highly sensitiv to the used system architecture and the shared memory parallelization technique. Therefore the default value cannot guarantee maximum performance for all possible situations and configurations. It merely provides a reasonable standard for the current generation of CPUs. Also note that the provided default has been determined using the OpenMP parallelization and requires individual adaption for the C++11 and Boost thread parallelization.

The default setting for this threshold is 330. In case the threshold is set to 0, the operation is unconditionally executed in parallel.

constexpr size_t blaze::SMP_DMATSCALARMULT_USER_THRESHOLD = 48400UL

SMP dense matrix/scalar multiplication/division threshold.This threshold specifies when a dense matrix/scalar multiplication or division can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.

Please note that this threshold is highly sensitiv to the used system architecture and the shared memory parallelization technique. Therefore the default value cannot guarantee maximum performance for all possible situations and configurations. It merely provides a reasonable standard for the current generation of CPUs. Also note that the provided default has been determined using the OpenMP parallelization and requires individual adaption for the C++11 and Boost thread parallelization.

The default setting for this threshold is 48400 (which corresponds to a matrix size of $ 220 \times 220 $). In case the threshold is set to 0, the operation is unconditionally executed in parallel.

constexpr size_t blaze::SMP_DMATSMATMULT_USER_THRESHOLD = 4096UL

SMP row-major dense matrix/row-major sparse matrix multiplication threshold.This threshold specifies when a row-major dense matrix/row-major sparse matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.

Please note that this threshold is highly sensitiv to the used system architecture and the shared memory parallelization technique. Therefore the default value cannot guarantee maximum performance for all possible situations and configurations. It merely provides a reasonable standard for the current generation of CPUs. Also note that the provided default has been determined using the OpenMP parallelization and requires individual adaption for the C++11 and Boost thread parallelization.

The default setting for this threshold is 4096 (which corresponds to a matrix size of $ 64 \times 64 $). In case the threshold is set to 0, the operation is unconditionally executed in parallel.

constexpr size_t blaze::SMP_DMATSVECMULT_USER_THRESHOLD = 480UL

SMP row-major dense matrix/sparse vector multiplication threshold.This threshold specifies when a row-major dense matrix/sparse vector multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.

Please note that this threshold is highly sensitiv to the used system architecture and the shared memory parallelization technique. Therefore the default value cannot guarantee maximum performance for all possible situations and configurations. It merely provides a reasonable standard for the current generation of CPUs. Also note that the provided default has been determined using the OpenMP parallelization and requires individual adaption for the C++11 and Boost thread parallelization.

The default setting for this threshold is 480. In case the threshold is set to 0, the operation is unconditionally executed in parallel.

constexpr size_t blaze::SMP_DMATTDMATADD_USER_THRESHOLD = 30625UL

SMP row-major dense matrix/column-major dense matrix addition threshold.This threshold specifies when a row-major dense matrix/column-major dense matrix addition can be executed in parallel. This threshold affects both additions between a row-major matrix and a column-major matrix and a column-major matrix and a row-major matrix. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.

Please note that this threshold is highly sensitiv to the used system architecture and the shared memory parallelization technique. Therefore the default value cannot guarantee maximum performance for all possible situations and configurations. It merely provides a reasonable standard for the current generation of CPUs. Also note that the provided default has been determined using the OpenMP parallelization and requires individual adaption for the C++11 and Boost thread parallelization.

The default setting for this threshold is 30625 (which corresponds to a matrix size of $ 175 \times 175 $). In case the threshold is set to 0, the operation is unconditionally executed in parallel.

constexpr size_t blaze::SMP_DMATTDMATMULT_USER_THRESHOLD = 3025UL

SMP row-major dense matrix/column-major dense matrix multiplication threshold.This threshold specifies when a row-major dense matrix/column-major dense matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.

Please note that this threshold is highly sensitiv to the used system architecture and the shared memory parallelization technique. Therefore the default value cannot guarantee maximum performance for all possible situations and configurations. It merely provides a reasonable standard for the current generation of CPUs. Also note that the provided default has been determined using the OpenMP parallelization and requires individual adaption for the C++11 and Boost thread parallelization.

The default setting for this threshold is 3025 (which corresponds to a matrix size of $ 55 \times 55 $). In case the threshold is set to 0, the operation is unconditionally executed in parallel.

constexpr size_t blaze::SMP_DMATTDMATSUB_USER_THRESHOLD = 30625UL

SMP row-major dense matrix/column-major dense matrix subtraction threshold.This threshold specifies when a row-major dense matrix/column-major dense matrix subtraction can be executed in parallel. This threshold affects both subtractions between a row-major matrix and a column-major matrix and a column-major matrix and a row-major matrix. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.

Please note that this threshold is highly sensitiv to the used system architecture and the shared memory parallelization technique. Therefore the default value cannot guarantee maximum performance for all possible situations and configurations. It merely provides a reasonable standard for the current generation of CPUs. Also note that the provided default has been determined using the OpenMP parallelization and requires individual adaption for the C++11 and Boost thread parallelization.

The default setting for this threshold is 30625 (which corresponds to a matrix size of $ 175 \times 175 $). In case the threshold is set to 0, the operation is unconditionally executed in parallel.

constexpr size_t blaze::SMP_DMATTSMATMULT_USER_THRESHOLD = 4624UL

SMP row-major dense matrix/column-major sparse matrix multiplication threshold.This threshold specifies when a row-major dense matrix/column-major sparse matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.

Please note that this threshold is highly sensitiv to the used system architecture and the shared memory parallelization technique. Therefore the default value cannot guarantee maximum performance for all possible situations and configurations. It merely provides a reasonable standard for the current generation of CPUs. Also note that the provided default has been determined using the OpenMP parallelization and requires individual adaption for the C++11 and Boost thread parallelization.

The default setting for this threshold is 4624 (which corresponds to a matrix size of $ 68 \times 68 $). In case the threshold is set to 0, the operation is unconditionally executed in parallel.

constexpr size_t blaze::SMP_DVECASSIGN_USER_THRESHOLD = 38000UL

SMP dense vector assignment threshold.This threshold specifies when an assignment of a simple dense vector can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.

Please note that this threshold is highly sensitiv to the used system architecture and the shared memory parallelization technique. Therefore the default value cannot guarantee maximum performance for all possible situations and configurations. It merely provides a reasonable standard for the current generation of CPUs. Also note that the provided default has been determined using the OpenMP parallelization and requires individual adaption for the C++11 and Boost thread parallelization.

The default setting for this threshold is 38000. In case the threshold is set to 0, the operation is unconditionally executed in parallel.

constexpr size_t blaze::SMP_DVECDVECADD_USER_THRESHOLD = 38000UL

SMP dense vector/dense vector addition threshold.This threshold specifies when a dense vector/dense vector addition can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.

Please note that this threshold is highly sensitiv to the used system architecture and the shared memory parallelization technique. Therefore the default value cannot guarantee maximum performance for all possible situations and configurations. It merely provides a reasonable standard for the current generation of CPUs. Also note that the provided default has been determined using the OpenMP parallelization and requires individual adaption for the C++11 and Boost thread parallelization.

The default setting for this threshold is 38000. In case the threshold is set to 0, the operation is unconditionally executed in parallel.

constexpr size_t blaze::SMP_DVECDVECDIV_USER_THRESHOLD = 38000UL

SMP dense vector/dense vector division threshold.This threshold specifies when a dense vector/dense vector division can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.

Please note that this threshold is highly sensitiv to the used system architecture and the shared memory parallelization technique. Therefore the default value cannot guarantee maximum performance for all possible situations and configurations. It merely provides a reasonable standard for the current generation of CPUs. Also note that the provided default has been determined using the OpenMP parallelization and requires individual adaption for the C++11 and Boost thread parallelization.

The default setting for this threshold is 38000. In case the threshold is set to 0, the operation is unconditionally executed in parallel.

constexpr size_t blaze::SMP_DVECDVECMULT_USER_THRESHOLD = 38000UL

SMP dense vector/dense vector multiplication threshold.This threshold specifies when a dense vector/dense vector multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.

Please note that this threshold is highly sensitiv to the used system architecture and the shared memory parallelization technique. Therefore the default value cannot guarantee maximum performance for all possible situations and configurations. It merely provides a reasonable standard for the current generation of CPUs. Also note that the provided default has been determined using the OpenMP parallelization and requires individual adaption for the C++11 and Boost thread parallelization.

The default setting for this threshold is 38000. In case the threshold is set to 0, the operation is unconditionally executed in parallel.

constexpr size_t blaze::SMP_DVECDVECSUB_USER_THRESHOLD = 38000UL

SMP dense vector/dense vector subtraction threshold.This threshold specifies when a dense vector/dense vector subtraction can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.

Please note that this threshold is highly sensitiv to the used system architecture and the shared memory parallelization technique. Therefore the default value cannot guarantee maximum performance for all possible situations and configurations. It merely provides a reasonable standard for the current generation of CPUs. Also note that the provided default has been determined using the OpenMP parallelization and requires individual adaption for the C++11 and Boost thread parallelization.

The default setting for this threshold is 38000. In case the threshold is set to 0, the operation is unconditionally executed in parallel.

constexpr size_t blaze::SMP_DVECSCALARMULT_USER_THRESHOLD = 51000UL

SMP dense vector/scalar multiplication/division threshold.This threshold specifies when a dense vector/scalar multiplication/division can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.

Please note that this threshold is highly sensitiv to the used system architecture and the shared memory parallelization technique. Therefore the default value cannot guarantee maximum performance for all possible situations and configurations. It merely provides a reasonable standard for the current generation of CPUs. Also note that the provided default has been determined using the OpenMP parallelization and requires individual adaption for the C++11 and Boost thread parallelization.

The default setting for this threshold is 51000. In case the threshold is set to 0, the operation is unconditionally executed in parallel.

constexpr size_t blaze::SMP_DVECTDVECMULT_USER_THRESHOLD = 84100UL

SMP dense vector/dense vector outer product threshold.This threshold specifies when a dense vector/dense vector outer product can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.

Please note that this threshold is highly sensitiv to the used system architecture and the shared memory parallelization technique. Therefore the default value cannot guarantee maximum performance for all possible situations and configurations. It merely provides a reasonable standard for the current generation of CPUs. Also note that the provided default has been determined using the OpenMP parallelization and requires individual adaption for the C++11 and Boost thread parallelization.

The default setting for this threshold is 84100 (which corresponds to a matrix size of $ 290 \times 290 $). In case the threshold is set to 0, the operation is unconditionally executed in parallel.

constexpr size_t blaze::SMP_SMATDMATMULT_USER_THRESHOLD = 7744UL

SMP row-major sparse matrix/row-major dense matrix multiplication threshold.This threshold specifies when a row-major sparse matrix/row-major dense matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.

Please note that this threshold is highly sensitiv to the used system architecture and the shared memory parallelization technique. Therefore the default value cannot guarantee maximum performance for all possible situations and configurations. It merely provides a reasonable standard for the current generation of CPUs. Also note that the provided default has been determined using the OpenMP parallelization and requires individual adaption for the C++11 and Boost thread parallelization.

The default setting for this threshold is 7744 (which corresponds to a matrix size of $ 88 \times 88 $). In case the threshold is set to 0, the operation is unconditionally executed in parallel.

constexpr size_t blaze::SMP_SMATDVECMULT_USER_THRESHOLD = 600UL

SMP row-major sparse matrix/dense vector multiplication threshold.This threshold specifies when a row-major sparse matrix/dense vector multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.

Please note that this threshold is highly sensitiv to the used system architecture and the shared memory parallelization technique. Therefore the default value cannot guarantee maximum performance for all possible situations and configurations. It merely provides a reasonable standard for the current generation of CPUs. Also note that the provided default has been determined using the OpenMP parallelization and requires individual adaption for the C++11 and Boost thread parallelization.

The default setting for this threshold is 600. In case the threshold is set to 0, the operation is unconditionally executed in parallel.

constexpr size_t blaze::SMP_SMATSMATMULT_USER_THRESHOLD = 22500UL

SMP row-major sparse matrix/row-major sparse matrix multiplication threshold.This threshold specifies when a row-major sparse matrix/row-major sparse matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.

Please note that this threshold is highly sensitiv to the used system architecture and the shared memory parallelization technique. Therefore the default value cannot guarantee maximum performance for all possible situations and configurations. It merely provides a reasonable standard for the current generation of CPUs. Also note that the provided default has been determined using the OpenMP parallelization and requires individual adaption for the C++11 and Boost thread parallelization.

The default setting for this threshold is 22500 (which corresponds to a matrix size of $ 150 \times 150 $). In case the threshold is set to 0, the operation is unconditionally executed in parallel.

constexpr size_t blaze::SMP_SMATSVECMULT_USER_THRESHOLD = 260UL

SMP row-major sparse matrix/sparse vector multiplication threshold.This threshold specifies when a row-major sparse matrix/sparse vector multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.

Please note that this threshold is highly sensitiv to the used system architecture and the shared memory parallelization technique. Therefore the default value cannot guarantee maximum performance for all possible situations and configurations. It merely provides a reasonable standard for the current generation of CPUs. Also note that the provided default has been determined using the OpenMP parallelization and requires individual adaption for the C++11 and Boost thread parallelization.

The default setting for this threshold is 260. In case the threshold is set to 0, the operation is unconditionally executed in parallel.

constexpr size_t blaze::SMP_SMATTDMATMULT_USER_THRESHOLD = 5184UL

SMP row-major sparse matrix/column-major dense matrix multiplication threshold.This threshold specifies when a row-major sparse matrix/column-major dense matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.

Please note that this threshold is highly sensitiv to the used system architecture and the shared memory parallelization technique. Therefore the default value cannot guarantee maximum performance for all possible situations and configurations. It merely provides a reasonable standard for the current generation of CPUs. Also note that the provided default has been determined using the OpenMP parallelization and requires individual adaption for the C++11 and Boost thread parallelization.

The default setting for this threshold is 5184 (which corresponds to a matrix size of $ 72 \times 72 $). In case the threshold is set to 0, the operation is unconditionally executed in parallel.

constexpr size_t blaze::SMP_SMATTSMATMULT_USER_THRESHOLD = 19600UL

SMP row-major sparse matrix/column-major sparse matrix multiplication threshold.This threshold specifies when a row-major sparse matrix/column-major sparse matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.

Please note that this threshold is highly sensitiv to the used system architecture and the shared memory parallelization technique. Therefore the default value cannot guarantee maximum performance for all possible situations and configurations. It merely provides a reasonable standard for the current generation of CPUs. Also note that the provided default has been determined using the OpenMP parallelization and requires individual adaption for the C++11 and Boost thread parallelization.

The default setting for this threshold is 19600 (which corresponds to a matrix size of $ 140 \times 140 $). In case the threshold is set to 0, the operation is unconditionally executed in parallel.

constexpr size_t blaze::SMP_TDMATDMATMULT_USER_THRESHOLD = 3025UL

SMP column-major dense matrix/row-major dense matrix multiplication threshold.This threshold specifies when a column-major dense matrix/row-major dense matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.

Please note that this threshold is highly sensitiv to the used system architecture and the shared memory parallelization technique. Therefore the default value cannot guarantee maximum performance for all possible situations and configurations. It merely provides a reasonable standard for the current generation of CPUs. Also note that the provided default has been determined using the OpenMP parallelization and requires individual adaption for the C++11 and Boost thread parallelization.

The default setting for this threshold is 3025 (which corresponds to a matrix size of $ 55 \times 55 $). In case the threshold is set to 0, the operation is unconditionally executed in parallel.

constexpr size_t blaze::SMP_TDMATDVECMULT_USER_THRESHOLD = 360UL

SMP column-major dense matrix/dense vector multiplication threshold.This threshold specifies when a column-major dense matrix/dense vector multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.

Please note that this threshold is highly sensitiv to the used system architecture and the shared memory parallelization technique. Therefore the default value cannot guarantee maximum performance for all possible situations and configurations. It merely provides a reasonable standard for the current generation of CPUs. Also note that the provided default has been determined using the OpenMP parallelization and requires individual adaption for the C++11 and Boost thread parallelization.

The default setting for this threshold is 360. In case the threshold is set to 0, the operation is unconditionally executed in parallel.

constexpr size_t blaze::SMP_TDMATSMATMULT_USER_THRESHOLD = 8100UL

SMP column-major dense matrix/row-major sparse matrix multiplication threshold.This threshold specifies when a column-major dense matrix/row-major sparse matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.

Please note that this threshold is highly sensitiv to the used system architecture and the shared memory parallelization technique. Therefore the default value cannot guarantee maximum performance for all possible situations and configurations. It merely provides a reasonable standard for the current generation of CPUs. Also note that the provided default has been determined using the OpenMP parallelization and requires individual adaption for the C++11 and Boost thread parallelization.

The default setting for this threshold is 8100 (which corresponds to a matrix size of $ 90 \times 90 $). In case the threshold is set to 0, the operation is unconditionally executed in parallel.

constexpr size_t blaze::SMP_TDMATSVECMULT_USER_THRESHOLD = 910UL

SMP column-major dense matrix/sparse vector multiplication threshold.This threshold specifies when a column-major dense matrix/sparse vector multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.

Please note that this threshold is highly sensitiv to the used system architecture and the shared memory parallelization technique. Therefore the default value cannot guarantee maximum performance for all possible situations and configurations. It merely provides a reasonable standard for the current generation of CPUs. Also note that the provided default has been determined using the OpenMP parallelization and requires individual adaption for the C++11 and Boost thread parallelization.

The default setting for this threshold is 910. In case the threshold is set to 0, the operation is unconditionally executed in parallel.

constexpr size_t blaze::SMP_TDMATTDMATMULT_USER_THRESHOLD = 3025UL

SMP column-major dense matrix/column-major dense matrix multiplication threshold.This threshold specifies when a column-major dense matrix/column-major dense matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.

Please note that this threshold is highly sensitiv to the used system architecture and the shared memory parallelization technique. Therefore the default value cannot guarantee maximum performance for all possible situations and configurations. It merely provides a reasonable standard for the current generation of CPUs. Also note that the provided default has been determined using the OpenMP parallelization and requires individual adaption for the C++11 and Boost thread parallelization.

The default setting for this threshold is 3025 (which corresponds to a matrix size of $ 55 \times 55 $). In case the threshold is set to 0, the operation is unconditionally executed in parallel.

constexpr size_t blaze::SMP_TDMATTSMATMULT_USER_THRESHOLD = 8100UL

SMP column-major dense matrix/column-major sparse matrix multiplication threshold.This threshold specifies when a column-major dense matrix/column-major sparse matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.

Please note that this threshold is highly sensitiv to the used system architecture and the shared memory parallelization technique. Therefore the default value cannot guarantee maximum performance for all possible situations and configurations. It merely provides a reasonable standard for the current generation of CPUs. Also note that the provided default has been determined using the OpenMP parallelization and requires individual adaption for the C++11 and Boost thread parallelization.

The default setting for this threshold is 8100 (which corresponds to a matrix size of $ 90 \times 90 $). In case the threshold is set to 0, the operation is unconditionally executed in parallel.

constexpr size_t blaze::SMP_TDVECDMATMULT_USER_THRESHOLD = 370UL

SMP dense vector/row-major dense matrix multiplication threshold.This threshold specifies when a dense vector/row-major dense matrix multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.

Please note that this threshold is highly sensitiv to the used system architecture and the shared memory parallelization technique. Therefore the default value cannot guarantee maximum performance for all possible situations and configurations. It merely provides a reasonable standard for the current generation of CPUs. Also note that the provided default has been determined using the OpenMP parallelization and requires individual adaption for the C++11 and Boost thread parallelization.

The default setting for this threshold is 370. In case the threshold is set to 0, the operation is unconditionally executed in parallel.

constexpr size_t blaze::SMP_TDVECSMATMULT_USER_THRESHOLD = 1190UL

SMP dense vector/row-major sparse matrix multiplication threshold.This threshold specifies when a dense vector/row-major sparse matrix multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.

Please note that this threshold is highly sensitiv to the used system architecture and the shared memory parallelization technique. Therefore the default value cannot guarantee maximum performance for all possible situations and configurations. It merely provides a reasonable standard for the current generation of CPUs. Also note that the provided default has been determined using the OpenMP parallelization and requires individual adaption for the C++11 and Boost thread parallelization.

The default setting for this threshold is 1190. In case the threshold is set to 0, the operation is unconditionally executed in parallel.

constexpr size_t blaze::SMP_TDVECTDMATMULT_USER_THRESHOLD = 340UL

SMP dense vector/column-major dense matrix multiplication threshold.This threshold specifies when a dense vector/column-major dense matrix multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.

Please note that this threshold is highly sensitiv to the used system architecture and the shared memory parallelization technique. Therefore the default value cannot guarantee maximum performance for all possible situations and configurations. It merely provides a reasonable standard for the current generation of CPUs. Also note that the provided default has been determined using the OpenMP parallelization and requires individual adaption for the C++11 and Boost thread parallelization.

The default setting for this threshold is 340. In case the threshold is set to 0, the operation is unconditionally executed in parallel.

constexpr size_t blaze::SMP_TDVECTSMATMULT_USER_THRESHOLD = 530UL

SMP dense vector/column-major sparse matrix multiplication threshold.This threshold specifies when a dense vector/column-major sparse matrix multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.

Please note that this threshold is highly sensitiv to the used system architecture and the shared memory parallelization technique. Therefore the default value cannot guarantee maximum performance for all possible situations and configurations. It merely provides a reasonable standard for the current generation of CPUs. Also note that the provided default has been determined using the OpenMP parallelization and requires individual adaption for the C++11 and Boost thread parallelization.

The default setting for this threshold is 530. In case the threshold is set to 0, the operation is unconditionally executed in parallel.

constexpr size_t blaze::SMP_TSMATDMATMULT_USER_THRESHOLD = 4356UL

SMP column-major sparse matrix/row-major dense matrix multiplication threshold.This threshold specifies when a column-major sparse matrix/row-major dense matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.

Please note that this threshold is highly sensitiv to the used system architecture and the shared memory parallelization technique. Therefore the default value cannot guarantee maximum performance for all possible situations and configurations. It merely provides a reasonable standard for the current generation of CPUs. Also note that the provided default has been determined using the OpenMP parallelization and requires individual adaption for the C++11 and Boost thread parallelization.

The default setting for this threshold is 4356 (which corresponds to a matrix size of $ 66 \times 66 $). In case the threshold is set to 0, the operation is unconditionally executed in parallel.

constexpr size_t blaze::SMP_TSMATDVECMULT_USER_THRESHOLD = 1250UL

SMP column-major sparse matrix/dense vector multiplication threshold.This threshold specifies when a column-major sparse matrix/dense vector multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.

Please note that this threshold is highly sensitiv to the used system architecture and the shared memory parallelization technique. Therefore the default value cannot guarantee maximum performance for all possible situations and configurations. It merely provides a reasonable standard for the current generation of CPUs. Also note that the provided default has been determined using the OpenMP parallelization and requires individual adaption for the C++11 and Boost thread parallelization.

The default setting for this threshold is 1250. In case the threshold is set to 0, the operation is unconditionally executed in parallel.

constexpr size_t blaze::SMP_TSMATSMATMULT_USER_THRESHOLD = 19600UL

SMP column-major sparse matrix/row-major sparse matrix multiplication threshold.This threshold specifies when a column-major sparse matrix/row-major sparse matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.

Please note that this threshold is highly sensitiv to the used system architecture and the shared memory parallelization technique. Therefore the default value cannot guarantee maximum performance for all possible situations and configurations. It merely provides a reasonable standard for the current generation of CPUs. Also note that the provided default has been determined using the OpenMP parallelization and requires individual adaption for the C++11 and Boost thread parallelization.

The default setting for this threshold is 19600 (which corresponds to a matrix size of $ 140 \times 140 $). In case the threshold is set to 0, the operation is unconditionally executed in parallel.

constexpr size_t blaze::SMP_TSMATSVECMULT_USER_THRESHOLD = 2160UL

SMP column-major sparse matrix/sparse vector multiplication threshold.This threshold specifies when a column-major sparse matrix/sparse vector multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.

Please note that this threshold is highly sensitiv to the used system architecture and the shared memory parallelization technique. Therefore the default value cannot guarantee maximum performance for all possible situations and configurations. It merely provides a reasonable standard for the current generation of CPUs. Also note that the provided default has been determined using the OpenMP parallelization and requires individual adaption for the C++11 and Boost thread parallelization.

The default setting for this threshold is 2160. In case the threshold is set to 0, the operation is unconditionally executed in parallel.

constexpr size_t blaze::SMP_TSMATTDMATMULT_USER_THRESHOLD = 4356UL

SMP column-major sparse matrix/column-major dense matrix multiplication threshold.This threshold specifies when a column-major sparse matrix/column-major dense matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.

Please note that this threshold is highly sensitiv to the used system architecture and the shared memory parallelization technique. Therefore the default value cannot guarantee maximum performance for all possible situations and configurations. It merely provides a reasonable standard for the current generation of CPUs. Also note that the provided default has been determined using the OpenMP parallelization and requires individual adaption for the C++11 and Boost thread parallelization.

The default setting for this threshold is 4356 (which corresponds to a matrix size of $ 66 \times 66 $). In case the threshold is set to 0, the operation is unconditionally executed in parallel.

constexpr size_t blaze::SMP_TSMATTSMATMULT_USER_THRESHOLD = 22500UL

SMP column-major sparse matrix/column-major sparse matrix multiplication threshold.This threshold specifies when a column-major sparse matrix/column-major sparse matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.

Please note that this threshold is highly sensitiv to the used system architecture and the shared memory parallelization technique. Therefore the default value cannot guarantee maximum performance for all possible situations and configurations. It merely provides a reasonable standard for the current generation of CPUs. Also note that the provided default has been determined using the OpenMP parallelization and requires individual adaption for the C++11 and Boost thread parallelization.

The default setting for this threshold is 22500 (which corresponds to a matrix size of $ 150 \times 150 $). In case the threshold is set to 0, the operation is unconditionally executed in parallel.

constexpr size_t blaze::SMP_TSVECDMATMULT_USER_THRESHOLD = 910UL

SMP sparse vector/row-major dense matrix multiplication threshold.This threshold specifies when a sparse vector/row-major dense matrix multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.

Please note that this threshold is highly sensitiv to the used system architecture and the shared memory parallelization technique. Therefore the default value cannot guarantee maximum performance for all possible situations and configurations. It merely provides a reasonable standard for the current generation of CPUs. Also note that the provided default has been determined using the OpenMP parallelization and requires individual adaption for the C++11 and Boost thread parallelization.

The default setting for this threshold is 910. In case the threshold is set to 0, the operation is unconditionally executed in parallel.

constexpr size_t blaze::SMP_TSVECSMATMULT_USER_THRESHOLD = 2160UL

SMP sparse vector/row-major sparse matrix multiplication threshold.This threshold specifies when a sparse vector/row-major sparse matrix multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.

Please note that this threshold is highly sensitiv to the used system architecture and the shared memory parallelization technique. Therefore the default value cannot guarantee maximum performance for all possible situations and configurations. It merely provides a reasonable standard for the current generation of CPUs. Also note that the provided default has been determined using the OpenMP parallelization and requires individual adaption for the C++11 and Boost thread parallelization.

The default setting for this threshold is 2160. In case the threshold is set to 0, the operation is unconditionally executed in parallel.

constexpr size_t blaze::SMP_TSVECTDMATMULT_USER_THRESHOLD = 480UL

SMP sparse vector/column-major dense matrix multiplication threshold.This threshold specifies when a sparse vector/column-major dense matrix multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.

Please note that this threshold is highly sensitiv to the used system architecture and the shared memory parallelization technique. Therefore the default value cannot guarantee maximum performance for all possible situations and configurations. It merely provides a reasonable standard for the current generation of CPUs. Also note that the provided default has been determined using the OpenMP parallelization and requires individual adaption for the C++11 and Boost thread parallelization.

The default setting for this threshold is 480. In case the threshold is set to 0, the operation is unconditionally executed in parallel.

constexpr size_t blaze::SMP_TSVECTSMATMULT_USER_THRESHOLD = 260UL

SMP sparse vector/column-major sparse matrix multiplication threshold.This threshold specifies when a sparse vector/column-major sparse matrix multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded.

Please note that this threshold is highly sensitiv to the used system architecture and the shared memory parallelization technique. Therefore the default value cannot guarantee maximum performance for all possible situations and configurations. It merely provides a reasonable standard for the current generation of CPUs. Also note that the provided default has been determined using the OpenMP parallelization and requires individual adaption for the C++11 and Boost thread parallelization.

The default setting for this threshold is 260. In case the threshold is set to 0, the operation is unconditionally executed in parallel.

constexpr size_t blaze::TDMATDMATMULT_USER_THRESHOLD = 10000UL

Column-major dense matrix/row-major dense matrix multiplication threshold.This setting specifies the threshold between the application of the custom Blaze kernels and the BLAS kernels for the column-major dense matrix/row-major dense matrix multiplication. In case the number of elements of the target matrix is equal or higher than this value, the BLAS kernels are preferred over the custom Blaze kernels. In case the number of elements in the target matrix is smaller, the Blaze kernels are used.

The default setting for this threshold is 10000 (which for instance corresponds to a matrix size of $ 100 \times 100 $). Note that in case the Blaze debug mode is active, this threshold will be replaced by the blaze::TDMATDMATMULT_DEBUG_THRESHOLD value.

constexpr size_t blaze::TDMATDVECMULT_USER_THRESHOLD = 62500UL

Column-major dense matrix/dense vector multiplication threshold.This setting specifies the threshold between the application of the custom Blaze kernels and the BLAS kernels for the column-major dense matrix/dense vector multiplication. In case the number of elements in the dense matrix is equal or higher than this value, the BLAS kernels are preferred over the custom Blaze kernels. In case the number of elements in the dense matrix is smaller, the Blaze kernels are used.

The default setting for this threshold is 62500 (which for instance corresponds to a matrix size of $ 250 \times 250 $). Note that in case the Blaze debug mode is active, this threshold will be replaced by the blaze::TDMATDVECMULT_DEBUG_THRESHOLD value.

constexpr size_t blaze::TDMATSMATMULT_USER_THRESHOLD = 2500UL

Column-major dense matrix/row-major sparse matrix multiplication threshold.This setting specifies the threshold between the application of the Blaze kernels for small and for large column-major dense matrix/row-major sparse matrix multiplications. In case the number of elements of the target matrix is equal or higher than this value, the kernel for large matrices is preferred over the kernel for small matrices. In case the number of elements in the target matrix is smaller, the kernel for small matrices is used.

The default setting for this threshold is 2500 (which for instance corresponds to a matrix size of $ 50 \times 50 $). Note that in case the Blaze debug mode is active, this threshold will be replaced by the blaze::TDMATSMATMULT_DEBUG_THRESHOLD value.

constexpr size_t blaze::TDMATTDMATMULT_USER_THRESHOLD = 10000UL

Column-major dense matrix/column-major dense matrix multiplication threshold.This setting specifies the threshold between the application of the custom Blaze kernels and the BLAS kernels for the column-major dense matrix/column-major dense matrix multiplication. In case the number of elements of the target matrix is equal or higher than this value, the BLAS kernels are preferred over the custom Blaze kernels. In case the number of elements in the target matrix is smaller, the Blaze kernels are used.

The default setting for this threshold is 10000 (which for instance corresponds to a matrix size of $ 100 \times 100 $). Note that in case the Blaze debug mode is active, this threshold will be replaced by the blaze::TDMATTDMATMULT_DEBUG_THRESHOLD value.

constexpr size_t blaze::TDVECDMATMULT_USER_THRESHOLD = 62500UL

Dense Vector/row-major dense matrix multiplication threshold.This setting specifies the threshold between the application of the custom Blaze kernels and the BLAS kernels for the dense vector/row-major dense matrix multiplication. In case the number of elements in the dense matrix is equal or higher than this value, the BLAS kernels are preferred over the custom Blaze kernels. In case the number of elements in the dense matrix is smaller, the Blaze kernels are used.

The default setting for this threshold is 62500 (which for instance corresponds to a matrix size of $ 250 \times 250 $). Note that in case the Blaze debug mode is active, this threshold will be replaced by the blaze::TDVECDMATMULT_DEBUG_THRESHOLD value.

constexpr size_t blaze::TDVECTDMATMULT_USER_THRESHOLD = 4000000UL

Dense Vector/column-major dense matrix multiplication threshold.This setting specifies the threshold between the application of the custom Blaze kernels and the BLAS kernels for the dense vector/column-major dense matrix multiplication. In case the number of elements in the dense matrix is equal or higher than this value, the BLAS kernels are preferred over the custom Blaze kernels. In case the number of elements in the dense matrix is smaller, the Blaze kernels are used.

The default setting for this threshold is 4000000 (which for instance corresponds to a matrix size of $ 2000 \times 2000 $). Note that in case the Blaze debug mode is active, this threshold will be replaced by the blaze::TDVECTDMATMULT_DEBUG_THRESHOLD value.

constexpr size_t blaze::TSMATDMATMULT_USER_THRESHOLD = 10000UL

Column-major sparse matrix/row-major dense matrix multiplication threshold.This setting specifies the threshold between the application of the Blaze kernels for small and for large column-major sparse matrix/row-major dense matrix multiplications. In case the number of elements of the target matrix is equal or higher than this value, the kernel for large matrices is preferred over the kernel for small matrices. In case the number of elements in the target matrix is smaller, the kernel for small matrices is used.

The default setting for this threshold is 10000 (which for instance corresponds to a matrix size of $ 100 \times 100 $). Note that in case the Blaze debug mode is active, this threshold will be replaced by the blaze::TSMATDMATMULT_DEBUG_THRESHOLD value.

constexpr size_t blaze::TSMATTDMATMULT_USER_THRESHOLD = 22500UL

Column-major sparse matrix/column-major dense matrix multiplication threshold.This setting specifies the threshold between the application of the Blaze kernels for small and for large column-major sparse matrix/column-major dense matrix multiplications. In case the number of elements of the target matrix is equal or higher than this value, the kernel for large matrices is preferred over the kernel for small matrices. In case the number of elements in the target matrix is smaller, the kernel for small matrices is used.

The default setting for this threshold is 22500 (which for instance corresponds to a matrix size of $ 150 \times 150 $). Note that in case the Blaze debug mode is active, this threshold will be replaced by the blaze::TSMATTDMATMULT_DEBUG_THRESHOLD value.

constexpr bool blaze::useOptimizedKernels = true

Configuration switch for optimized kernels.This configuration switch enables/disables all optimized compute kernels of the Blaze library, including all vectorized and data type depending kernels. In case the switch is set to true the optimized kernels are used whenever possible. In case the switch is set to false all optimized kernels are not used, even if it would be possible.

Warning
Note that disabling the optimized kernels causes a severe performance limitiation to nearly all operations!
constexpr bool blaze::usePadding = true

Configuration of the padding of dense vectors and matrices.This configuration switch enables/disables the padding of dense vectors and matrices. Padding is used by the Blaze library in order to achieve maximum performance for both dense vector and matrix operations. Due to padding, the proper alignment of data elements can be guaranteed and the need for remainder loops is minimized. In case the switch is set to true, padding is enabled for all native dense vectors and matrices. If the switch is set to false, padding is generally disabled.

Warning
Note that disabling padding can considerably reduce the performance of all dense vector and matrix operations!
constexpr bool blaze::useStreaming = true

Configuration of the streaming behavior.For large vectors and matrices non-temporal stores can provide a significant performance advantage of about 20%. However, this advantage is only in effect in case the memory bandwidth of the target architecture is maxed out. If the target architecture's memory bandwidth cannot be exhausted the use of non-temporal stores can decrease performance instead of increasing it.

Via this compilation switch streaming (i.e. non-temporal stores) can be (de-)activated. If set to true streaming is enabled, if set to false streaming is disabled.