Blaze 3.9
Macros
Configuration

Macros

#define BLAZE_DEFAULT_ALIGNMENT_FLAG   blaze::aligned
 The default alignment for all vectors and matrices of the Blaze library. More...
 
#define BLAZE_INTERNAL_ASSERTION   0
 Compilation switch for internal assertions. More...
 
#define BLAZE_USER_ASSERTION   0
 Compilation switch for user assertions. More...
 
#define BLAZE_BLAS_MODE   0
 Compilation switch for the BLAS mode. More...
 
#define BLAZE_BLAS_IS_64BIT   0
 Compilation switch for the BLAS 64-bit support. More...
 
#define BLAZE_BLAS_IS_PARALLEL   0
 Compilation switch for the parallel BLAS mode. More...
 
#define BLAZE_USE_BLAS_MATRIX_VECTOR_MULTIPLICATION   0
 Compilation switch for the BLAS matrix/vector multiplication kernels (gemv). More...
 
#define BLAZE_BLAS_INCLUDE_FILE   <cblas.h>
 Compilation switch for the BLAS matrix/matrix multiplication kernels (gemv). More...
 
#define BLAZE_CACHE_SIZE   3145728UL
 Cache size of the target architecture. More...
 
#define BLAZE_USE_DEBUG_MODE   0
 Compilation switch for the (de-)activation of the debug mode. More...
 
#define BLAZE_USE_FUNCTION_TRACES   0
 Compilation switch for function traces. More...
 
#define BLAZE_USE_ALWAYS_INLINE   1
 Compilation switch for a strengthened inline keyword. More...
 
#define BLAZE_USE_STREAMING   1
 Configuration of the padding of dynamic vectors and matrices. More...
 
#define BLAZE_USE_OPTIMIZED_KERNELS   1
 Configuration switch for optimized kernels. More...
 
#define BLAZE_USE_DEFAULT_INITIALIZATION   1
 Configuration switch for the initialization in default constructors. More...
 
#define BLAZE_DEFAULT_PADDING_FLAG   blaze::padded
 The default padding flag for all vectors and matrices of the Blaze library. More...
 
#define BLAZE_RANDOM_NUMBER_GENERATOR   std::mt19937
 Type of the random number generator of the Blaze library. More...
 
#define BLAZE_DEFAULT_STORAGE_ORDER   blaze::rowMajor
 The default storage order for all matrices of the Blaze library. More...
 
#define BLAZE_DMATDVECMULT_THRESHOLD   4000000UL
 Row-major dense matrix/dense vector multiplication threshold. More...
 
#define BLAZE_TDMATDVECMULT_THRESHOLD   62500UL
 Column-major dense matrix/dense vector multiplication threshold. More...
 
#define BLAZE_TDVECDMATMULT_THRESHOLD   62500UL
 Dense Vector/row-major dense matrix multiplication threshold. More...
 
#define BLAZE_TDVECTDMATMULT_THRESHOLD   4000000UL
 Dense Vector/column-major dense matrix multiplication threshold. More...
 
#define BLAZE_DMATDMATMULT_THRESHOLD   4900UL
 Row-major dense matrix/row-major dense matrix multiplication threshold. More...
 
#define BLAZE_DMATTDMATMULT_THRESHOLD   4900UL
 Row-major dense matrix/column-major dense matrix multiplication threshold. More...
 
#define BLAZE_TDMATDMATMULT_THRESHOLD   4900UL
 Column-major dense matrix/row-major dense matrix multiplication threshold. More...
 
#define BLAZE_TDMATTDMATMULT_THRESHOLD   4900UL
 Column-major dense matrix/column-major dense matrix multiplication threshold. More...
 
#define BLAZE_DMATSMATMULT_THRESHOLD   2500UL
 Row-major dense matrix/row-major sparse matrix multiplication threshold. More...
 
#define BLAZE_TDMATSMATMULT_THRESHOLD   2500UL
 Column-major dense matrix/row-major sparse matrix multiplication threshold. More...
 
#define BLAZE_TSMATDMATMULT_THRESHOLD   10000UL
 Column-major sparse matrix/row-major dense matrix multiplication threshold. More...
 
#define BLAZE_TSMATTDMATMULT_THRESHOLD   22500UL
 Column-major sparse matrix/column-major dense matrix multiplication threshold. More...
 
#define BLAZE_SMP_DVECASSIGN_THRESHOLD   38000UL
 SMP dense vector assignment threshold. More...
 
#define BLAZE_SMP_DVECSCALARMULT_THRESHOLD   51000UL
 SMP dense vector/scalar multiplication/division threshold. More...
 
#define BLAZE_SMP_DVECDVECADD_THRESHOLD   38000UL
 SMP dense vector/dense vector addition threshold. More...
 
#define BLAZE_SMP_DVECDVECSUB_THRESHOLD   38000UL
 SMP dense vector/dense vector subtraction threshold. More...
 
#define BLAZE_SMP_DVECDVECMULT_THRESHOLD   38000UL
 SMP dense vector/dense vector multiplication threshold. More...
 
#define BLAZE_SMP_DVECDVECDIV_THRESHOLD   38000UL
 SMP dense vector/dense vector division threshold. More...
 
#define BLAZE_SMP_DVECDVECOUTER_THRESHOLD   84100UL
 SMP dense vector/dense vector outer product threshold. More...
 
#define BLAZE_SMP_DMATDVECMULT_THRESHOLD   330UL
 SMP row-major dense matrix/dense vector multiplication threshold. More...
 
#define BLAZE_SMP_TDMATDVECMULT_THRESHOLD   360UL
 SMP column-major dense matrix/dense vector multiplication threshold. More...
 
#define BLAZE_SMP_TDVECDMATMULT_THRESHOLD   370UL
 SMP dense vector/row-major dense matrix multiplication threshold. More...
 
#define BLAZE_SMP_TDVECTDMATMULT_THRESHOLD   340UL
 SMP dense vector/column-major dense matrix multiplication threshold. More...
 
#define BLAZE_SMP_DMATSVECMULT_THRESHOLD   480UL
 SMP row-major dense matrix/sparse vector multiplication threshold. More...
 
#define BLAZE_SMP_TDMATSVECMULT_THRESHOLD   910UL
 SMP column-major dense matrix/sparse vector multiplication threshold. More...
 
#define BLAZE_SMP_TSVECDMATMULT_THRESHOLD   910UL
 SMP sparse vector/row-major dense matrix multiplication threshold. More...
 
#define BLAZE_SMP_TSVECTDMATMULT_THRESHOLD   480UL
 SMP sparse vector/column-major dense matrix multiplication threshold. More...
 
#define BLAZE_SMP_SMATDVECMULT_THRESHOLD   600UL
 SMP row-major sparse matrix/dense vector multiplication threshold. More...
 
#define BLAZE_SMP_TSMATDVECMULT_THRESHOLD   1250UL
 SMP column-major sparse matrix/dense vector multiplication threshold. More...
 
#define BLAZE_SMP_TDVECSMATMULT_THRESHOLD   1190UL
 SMP dense vector/row-major sparse matrix multiplication threshold. More...
 
#define BLAZE_SMP_TDVECTSMATMULT_THRESHOLD   530UL
 SMP dense vector/column-major sparse matrix multiplication threshold. More...
 
#define BLAZE_SMP_SMATSVECMULT_THRESHOLD   260UL
 SMP row-major sparse matrix/sparse vector multiplication threshold. More...
 
#define BLAZE_SMP_TSMATSVECMULT_THRESHOLD   2160UL
 SMP column-major sparse matrix/sparse vector multiplication threshold. More...
 
#define BLAZE_SMP_TSVECSMATMULT_THRESHOLD   2160UL
 SMP sparse vector/row-major sparse matrix multiplication threshold. More...
 
#define BLAZE_SMP_TSVECTSMATMULT_THRESHOLD   260UL
 SMP sparse vector/column-major sparse matrix multiplication threshold. More...
 
#define BLAZE_SMP_DMATASSIGN_THRESHOLD   48400UL
 SMP dense matrix assignment threshold. More...
 
#define BLAZE_SMP_DMATSCALARMULT_THRESHOLD   48400UL
 SMP dense matrix/scalar multiplication/division threshold. More...
 
#define BLAZE_SMP_DMATDMATADD_THRESHOLD   36100UL
 SMP row-major dense matrix/row-major dense matrix addition threshold. More...
 
#define BLAZE_SMP_DMATTDMATADD_THRESHOLD   30625UL
 SMP row-major dense matrix/column-major dense matrix addition threshold. More...
 
#define BLAZE_SMP_DMATDMATSUB_THRESHOLD   36100UL
 SMP row-major dense matrix/row-major dense matrix subtraction threshold. More...
 
#define BLAZE_SMP_DMATTDMATSUB_THRESHOLD   30625UL
 SMP row-major dense matrix/column-major dense matrix subtraction threshold. More...
 
#define BLAZE_SMP_DMATDMATSCHUR_THRESHOLD   36100UL
 SMP row-major dense matrix/row-major dense matrix Schur product threshold. More...
 
#define BLAZE_SMP_DMATTDMATSCHUR_THRESHOLD   30625UL
 SMP row-major dense matrix/column-major dense matrix Schur product threshold. More...
 
#define BLAZE_SMP_DMATDMATMULT_THRESHOLD   3025UL
 SMP row-major dense matrix/row-major dense matrix multiplication threshold. More...
 
#define BLAZE_SMP_DMATTDMATMULT_THRESHOLD   3025UL
 SMP row-major dense matrix/column-major dense matrix multiplication threshold. More...
 
#define BLAZE_SMP_TDMATDMATMULT_THRESHOLD   3025UL
 SMP column-major dense matrix/row-major dense matrix multiplication threshold. More...
 
#define BLAZE_SMP_TDMATTDMATMULT_THRESHOLD   3025UL
 SMP column-major dense matrix/column-major dense matrix multiplication threshold. More...
 
#define BLAZE_SMP_DMATSMATMULT_THRESHOLD   4096UL
 SMP row-major dense matrix/row-major sparse matrix multiplication threshold. More...
 
#define BLAZE_SMP_DMATTSMATMULT_THRESHOLD   4624UL
 SMP row-major dense matrix/column-major sparse matrix multiplication threshold. More...
 
#define BLAZE_SMP_TDMATSMATMULT_THRESHOLD   8100UL
 SMP column-major dense matrix/row-major sparse matrix multiplication threshold. More...
 
#define BLAZE_SMP_TDMATTSMATMULT_THRESHOLD   8100UL
 SMP column-major dense matrix/column-major sparse matrix multiplication threshold. More...
 
#define BLAZE_SMP_SMATDMATMULT_THRESHOLD   7744UL
 SMP row-major sparse matrix/row-major dense matrix multiplication threshold. More...
 
#define BLAZE_SMP_SMATTDMATMULT_THRESHOLD   5184UL
 SMP row-major sparse matrix/column-major dense matrix multiplication threshold. More...
 
#define BLAZE_SMP_TSMATDMATMULT_THRESHOLD   4356UL
 SMP column-major sparse matrix/row-major dense matrix multiplication threshold. More...
 
#define BLAZE_SMP_TSMATTDMATMULT_THRESHOLD   4356UL
 SMP column-major sparse matrix/column-major dense matrix multiplication threshold. More...
 
#define BLAZE_SMP_SMATSMATMULT_THRESHOLD   22500UL
 SMP row-major sparse matrix/row-major sparse matrix multiplication threshold. More...
 
#define BLAZE_SMP_SMATTSMATMULT_THRESHOLD   19600UL
 SMP row-major sparse matrix/column-major sparse matrix multiplication threshold. More...
 
#define BLAZE_SMP_TSMATSMATMULT_THRESHOLD   19600UL
 SMP column-major sparse matrix/row-major sparse matrix multiplication threshold. More...
 
#define BLAZE_SMP_TSMATTSMATMULT_THRESHOLD   22500UL
 SMP column-major sparse matrix/column-major sparse matrix multiplication threshold. More...
 
#define BLAZE_SMP_DMATREDUCE_THRESHOLD   180UL
 SMP dense matrix reduction threshold. More...
 
#define BLAZE_SMP_SMATREDUCE_THRESHOLD   180UL
 SMP sparse matrix reduction threshold. More...
 
#define BLAZE_DEFAULT_TRANSPOSE_FLAG   blaze::columnVector
 The default transpose flag for all vectors of the Blaze library. More...
 
#define BLAZE_USE_SLEEF   0
 Compilation switch for (de-)activation of the Blaze vectorization. More...
 

Detailed Description

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

Macro Definition Documentation

◆ BLAZE_BLAS_INCLUDE_FILE

#define BLAZE_BLAS_INCLUDE_FILE   <cblas.h>

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)
Warning
Changing the setting of this compilation switch requires a recompilation of all code code using the Blaze library!
Note
It is possible to (de-)activate the use of the BLAS matrix/matrix multiplication kernels via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_USE_BLAS_MATRIX_MATRIX_MULTIPLICATION=1 ...
#define BLAZE_USE_BLAS_MATRIX_MATRIX_MULTIPLICATION 1
#include <blaze/Blaze.h>
Primary include file of the Blaze library.

Compilation switch for 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.

Warning
Changing the name of the BLAS include file requires a recompilation of all code using the Blaze library!
Note
It is possible to specify the BLAS include file via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_BLAS_INCLUDE_FILE="<cblas.h>" ...
#define BLAZE_BLAS_INCLUDE_FILE <cblas.h>
#include <blaze/Blaze.h>

◆ BLAZE_BLAS_IS_64BIT

#define BLAZE_BLAS_IS_64BIT   0

Compilation switch for the BLAS 64-bit support.

This compilation switch enables/disables 64-bit BLAS and LAPACK support. In case the 64-bit BLAS mode is enabled, blaze::blas_int_t, which is used in the BLAS and LAPACK wrapper functions, is a 64-bit signed integral type. In case the 64-bit BLAS mode is disabled, blaze::blas_int_t is a 32-bit signed integral type.

Possible settings for the switch:

  • 32-bit BLAS/LAPACK: 0 (default)
  • 64-bit BLAS/LAPACK: 1
Warning
Changing the setting of the BLAS mode requires a recompilation of all code using the Blaze library!
Note
It is possible to (de-)activate the 64-bit BLAS mode via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_BLAS_IS_64BIT=1 ...
#define BLAZE_BLAS_IS_64BIT 1
#include <blaze/Blaze.h>

◆ BLAZE_BLAS_IS_PARALLEL

#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
Warning
Changing the setting of the BLAS mode requires a recompilation of all code using the Blaze library!
Note
It is possible to (de-)activate the parallel BLAS mode via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_BLAS_IS_PARALLEL=1 ...
#define BLAZE_BLAS_IS_PARALLEL 1
#include <blaze/Blaze.h>

◆ BLAZE_BLAS_MODE

#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
Warning
Changing the setting of the BLAS mode requires a recompilation of all code using the Blaze library!
Note
It is possible to (de-)activate the BLAS mode via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_BLAS_MODE=1 ...
#define BLAZE_BLAS_MODE 1
#include <blaze/Blaze.h>

◆ BLAZE_CACHE_SIZE

#define BLAZE_CACHE_SIZE   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.

Note
It is possible to specify the cache size via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_CACHE_SIZE=3145728 ...
#define BLAZE_CACHE_SIZE 3145728UL
#include <blaze/Blaze.h>

◆ BLAZE_DEFAULT_ALIGNMENT_FLAG

#define BLAZE_DEFAULT_ALIGNMENT_FLAG   blaze::aligned

The default alignment for all vectors and matrices of the Blaze library.

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

// Explicit specification of the alignment => the vector element are aligned
StaticVector<double,3UL,columnVector,aligned> a;
// No explicit specification of the alignment => use of the default alignment
StaticVector<double,3UL> b;

Valid settings for the BLAZE_DEFAULT_ALIGNMENT_FLAG are blaze::aligned and blaze::unaligned.

Note
It is possible to specify the default alignment flag via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_DEFAULT_ALIGNMENT_FLAG=blaze::aligned ...
@ aligned
Flag for aligned vectors and matrices.
Definition: AlignmentFlag.h:65
#define BLAZE_DEFAULT_ALIGNMENT_FLAG blaze::aligned
#include <blaze/Blaze.h>

◆ BLAZE_DEFAULT_PADDING_FLAG

#define BLAZE_DEFAULT_PADDING_FLAG   blaze::padded

The default padding flag for all vectors and matrices of the Blaze library.

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

// Explicit specification of the padding flag => the vector is padded
StaticVector<double,3UL,columnVector,aligned,padded> a;
// No explicit specification of the padding flag => use of the default padding flag
StaticVector<double,3UL,columnVector,aligned> b;

Valid settings for the BLAZE_DEFAULT_PADDING_FLAG are blaze::padded and blaze::unpadded.

Note
It is possible to specify the default padding flag via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_DEFAULT_PADDING_FLAG=blaze::padded ...
@ padded
Flag for padded vectors and matrices.
Definition: PaddingFlag.h:79
#define BLAZE_DEFAULT_PADDING_FLAG blaze::padded
#include <blaze/Blaze.h>

◆ BLAZE_DEFAULT_STORAGE_ORDER

#define BLAZE_DEFAULT_STORAGE_ORDER   blaze::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 default storage order
StaticMatrix<double,3UL,3UL> B;

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

Note
It is possible to specify the default storage order via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_DEFAULT_STORAGE_ORDER=blaze::rowMajor ...
constexpr bool rowMajor
Storage order flag for row-major matrices.
Definition: StorageOrder.h:71
#define BLAZE_DEFAULT_STORAGE_ORDER blaze::rowMajor
#include <blaze/Blaze.h>

◆ BLAZE_DEFAULT_TRANSPOSE_FLAG

#define BLAZE_DEFAULT_TRANSPOSE_FLAG   blaze::columnVector

The default transpose flag for all vectors of the Blaze library.

This value specifies the default transpose flag for all vectors 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,columnVector> a;
// No explicit specification of the transpose flag => use of the default transpose flag
StaticVector<double,3UL> b;

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

Note
It is possible to specify the default transpose flag via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_DEFAULT_TRANSPOSE_FLAG=blaze::columnVector ...
constexpr bool columnVector
Transpose flag for column vectors.
Definition: TransposeFlag.h:58
#define BLAZE_DEFAULT_TRANSPOSE_FLAG blaze::columnVector
#include <blaze/Blaze.h>

◆ BLAZE_DMATDMATMULT_THRESHOLD

#define BLAZE_DMATDMATMULT_THRESHOLD   4900UL

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 4900 (which for instance corresponds to a matrix size of $ 70 \times 70 $). Note that in case the Blaze debug mode is active, this threshold will be replaced by the blaze::DMATDMATMULT_DEBUG_THRESHOLD value.

Note
It is possible to specify this threshold via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_DMATDMATMULT_THRESHOLD=4900 ...
#define BLAZE_DMATDMATMULT_THRESHOLD 4900UL
#include <blaze/Blaze.h>

◆ BLAZE_DMATDVECMULT_THRESHOLD

#define BLAZE_DMATDVECMULT_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.

Note
It is possible to specify this threshold via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_DMATDVECMULT_THRESHOLD=4000000 ...
#define BLAZE_DMATDVECMULT_THRESHOLD 4000000UL
#include <blaze/Blaze.h>

◆ BLAZE_DMATSMATMULT_THRESHOLD

#define BLAZE_DMATSMATMULT_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.

Note
It is possible to specify this threshold via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_DMATSMATMULT_THRESHOLD=2500 ...
#define BLAZE_DMATSMATMULT_THRESHOLD 2500UL
#include <blaze/Blaze.h>

◆ BLAZE_DMATTDMATMULT_THRESHOLD

#define BLAZE_DMATTDMATMULT_THRESHOLD   4900UL

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 4900 (which for instance corresponds to a matrix size of $ 70 \times 70 $). Note that in case the Blaze debug mode is active, this threshold will be replaced by the blaze::DMATTDMATMULT_DEBUG_THRESHOLD value.

Note
It is possible to specify this threshold via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_DMATTDMATMULT_THRESHOLD=4900 ...
#define BLAZE_DMATTDMATMULT_THRESHOLD 4900UL
#include <blaze/Blaze.h>

◆ BLAZE_INTERNAL_ASSERTION

#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
Note
It is possible to (de-)activate internal assertions via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_INTERNAL_ASSERTION=1 ...
#define BLAZE_INTERNAL_ASSERTION 1
#include <blaze/Blaze.h>

◆ BLAZE_RANDOM_NUMBER_GENERATOR

#define BLAZE_RANDOM_NUMBER_GENERATOR   std::mt19937

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

Note
It is possible to specify the random number generator via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_RANDOM_NUMBER_GENERATOR=std::mt19937 ...
#define BLAZE_RANDOM_NUMBER_GENERATOR std::mt19937
#include <blaze/Blaze.h>

◆ BLAZE_SMP_DMATASSIGN_THRESHOLD

#define BLAZE_SMP_DMATASSIGN_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 or the HPX-based 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.

Note
It is possible to specify this threshold via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_SMP_DMATASSIGN_THRESHOLD=48400 ...
#define BLAZE_SMP_DMATASSIGN_THRESHOLD 48400UL
#include <blaze/Blaze.h>

◆ BLAZE_SMP_DMATDMATADD_THRESHOLD

#define BLAZE_SMP_DMATDMATADD_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 or the HPX-based 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.

Note
It is possible to specify this threshold via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_SMP_DMATDMATADD_THRESHOLD=36100 ...
#define BLAZE_SMP_DMATDMATADD_THRESHOLD 36100UL
#include <blaze/Blaze.h>

◆ BLAZE_SMP_DMATDMATMULT_THRESHOLD

#define BLAZE_SMP_DMATDMATMULT_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 or the HPX-based 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.

Note
It is possible to specify this threshold via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_SMP_DMATDMATMULT_THRESHOLD=3025 ...
#define BLAZE_SMP_DMATDMATMULT_THRESHOLD 3025UL
#include <blaze/Blaze.h>

◆ BLAZE_SMP_DMATDMATSCHUR_THRESHOLD

#define BLAZE_SMP_DMATDMATSCHUR_THRESHOLD   36100UL

SMP row-major dense matrix/row-major dense matrix Schur product threshold.

This threshold specifies when a row-major dense matrix/row-major dense matrix Schur product can be executed in parallel. This threshold affects both Schur products 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 or the HPX-based 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.

Note
It is possible to specify this threshold via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_SMP_DMATDMATSCHUR_THRESHOLD=36100 ...
#define BLAZE_SMP_DMATDMATSCHUR_THRESHOLD 36100UL
#include <blaze/Blaze.h>

◆ BLAZE_SMP_DMATDMATSUB_THRESHOLD

#define BLAZE_SMP_DMATDMATSUB_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 or the HPX-based 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.

Note
It is possible to specify this threshold via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_SMP_DMATDMATSUB_THRESHOLD=36100 ...
#define BLAZE_SMP_DMATDMATSUB_THRESHOLD 36100UL
#include <blaze/Blaze.h>

◆ BLAZE_SMP_DMATDVECMULT_THRESHOLD

#define BLAZE_SMP_DMATDVECMULT_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 or the HPX-based parallelization.

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

Note
It is possible to specify this threshold via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_SMP_DMATDVECMULT_THRESHOLD=330 ...
#define BLAZE_SMP_DMATDVECMULT_THRESHOLD 330UL
#include <blaze/Blaze.h>

◆ BLAZE_SMP_DMATREDUCE_THRESHOLD

#define BLAZE_SMP_DMATREDUCE_THRESHOLD   180UL

SMP dense matrix reduction threshold.

This threshold specifies when a dense matrix reduction 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 or the HPX-based parallelization.

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

Note
It is possible to specify this threshold via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_SMP_DMATREDUCE_THRESHOLD=180 ...
#define BLAZE_SMP_DMATREDUCE_THRESHOLD 180UL
#include <blaze/Blaze.h>

◆ BLAZE_SMP_DMATSCALARMULT_THRESHOLD

#define BLAZE_SMP_DMATSCALARMULT_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 or the HPX-based 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.

Note
It is possible to specify this threshold via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_SMP_DMATSCALARMULT_THRESHOLD=48400 ...
#define BLAZE_SMP_DMATSCALARMULT_THRESHOLD 48400UL
#include <blaze/Blaze.h>

◆ BLAZE_SMP_DMATSMATMULT_THRESHOLD

#define BLAZE_SMP_DMATSMATMULT_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 or the HPX-based 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.

Note
It is possible to specify this threshold via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_SMP_DMATSMATMULT_THRESHOLD=4096 ...
#define BLAZE_SMP_DMATSMATMULT_THRESHOLD 4096UL
#include <blaze/Blaze.h>

◆ BLAZE_SMP_DMATSVECMULT_THRESHOLD

#define BLAZE_SMP_DMATSVECMULT_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 or the HPX-based parallelization.

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

Note
It is possible to specify this threshold via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_SMP_DMATSVECMULT_THRESHOLD=480 ...
#define BLAZE_SMP_DMATSVECMULT_THRESHOLD 480UL
#include <blaze/Blaze.h>

◆ BLAZE_SMP_DMATTDMATADD_THRESHOLD

#define BLAZE_SMP_DMATTDMATADD_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 or the HPX-based 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.

Note
It is possible to specify this threshold via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_SMP_DMATTDMATADD_THRESHOLD=30625 ...
#define BLAZE_SMP_DMATTDMATADD_THRESHOLD 30625UL
#include <blaze/Blaze.h>

◆ BLAZE_SMP_DMATTDMATMULT_THRESHOLD

#define BLAZE_SMP_DMATTDMATMULT_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 or the HPX-based 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.

Note
It is possible to specify this threshold via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_SMP_DMATTDMATMULT_THRESHOLD=3025 ...
#define BLAZE_SMP_DMATTDMATMULT_THRESHOLD 3025UL
#include <blaze/Blaze.h>

◆ BLAZE_SMP_DMATTDMATSCHUR_THRESHOLD

#define BLAZE_SMP_DMATTDMATSCHUR_THRESHOLD   30625UL

SMP row-major dense matrix/column-major dense matrix Schur product threshold.

This threshold specifies when a row-major dense matrix/column-major dense matrix Schur product can be executed in parallel. This threshold affects both Schur products 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 or the HPX-based 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.

Note
It is possible to specify this threshold via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_SMP_DMATTDMATSCHUR_THRESHOLD=30625 ...
#define BLAZE_SMP_DMATTDMATSCHUR_THRESHOLD 30625UL
#include <blaze/Blaze.h>

◆ BLAZE_SMP_DMATTDMATSUB_THRESHOLD

#define BLAZE_SMP_DMATTDMATSUB_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 or the HPX-based 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.

Note
It is possible to specify this threshold via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_SMP_DMATTDMATSUB_THRESHOLD=30625 ...
#define BLAZE_SMP_DMATTDMATSUB_THRESHOLD 30625UL
#include <blaze/Blaze.h>

◆ BLAZE_SMP_DMATTSMATMULT_THRESHOLD

#define BLAZE_SMP_DMATTSMATMULT_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 or the HPX-based 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.

Note
It is possible to specify this threshold via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_SMP_DMATTSMATMULT_THRESHOLD=4624 ...
#define BLAZE_SMP_DMATTSMATMULT_THRESHOLD 4624UL
#include <blaze/Blaze.h>

◆ BLAZE_SMP_DVECASSIGN_THRESHOLD

#define BLAZE_SMP_DVECASSIGN_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 or the HPX-based parallelization.

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

Note
It is possible to specify this threshold via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_SMP_DVECASSIGN_THRESHOLD=38000 ...
#define BLAZE_SMP_DVECASSIGN_THRESHOLD 38000UL
#include <blaze/Blaze.h>

◆ BLAZE_SMP_DVECDVECADD_THRESHOLD

#define BLAZE_SMP_DVECDVECADD_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 or the HPX-based parallelization.

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

Note
It is possible to specify this threshold via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_SMP_DVECDVECADD_THRESHOLD=38000 ...
#define BLAZE_SMP_DVECDVECADD_THRESHOLD 38000UL
#include <blaze/Blaze.h>

◆ BLAZE_SMP_DVECDVECDIV_THRESHOLD

#define BLAZE_SMP_DVECDVECDIV_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 or the HPX-based parallelization.

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

Note
It is possible to specify this threshold via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_SMP_DVECDVECDIV_THRESHOLD=38000 ...
#define BLAZE_SMP_DVECDVECDIV_THRESHOLD 38000UL
#include <blaze/Blaze.h>

◆ BLAZE_SMP_DVECDVECMULT_THRESHOLD

#define BLAZE_SMP_DVECDVECMULT_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 or the HPX-based parallelization.

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

Note
It is possible to specify this threshold via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_SMP_DVECDVECMULT_THRESHOLD=38000 ...
#define BLAZE_SMP_DVECDVECMULT_THRESHOLD 38000UL
#include <blaze/Blaze.h>

◆ BLAZE_SMP_DVECDVECOUTER_THRESHOLD

#define BLAZE_SMP_DVECDVECOUTER_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 or the HPX-based 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.

Note
It is possible to specify this threshold via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_SMP_DVECDVECOUTER_THRESHOLD=84100 ...
#define BLAZE_SMP_DVECDVECOUTER_THRESHOLD 84100UL
#include <blaze/Blaze.h>

◆ BLAZE_SMP_DVECDVECSUB_THRESHOLD

#define BLAZE_SMP_DVECDVECSUB_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 or the HPX-based parallelization.

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

Note
It is possible to specify this threshold via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_SMP_DVECDVECSUB_THRESHOLD=38000 ...
#define BLAZE_SMP_DVECDVECSUB_THRESHOLD 38000UL
#include <blaze/Blaze.h>

◆ BLAZE_SMP_DVECSCALARMULT_THRESHOLD

#define BLAZE_SMP_DVECSCALARMULT_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 or the HPX-based parallelization.

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

Note
It is possible to specify this threshold via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_SMP_DVECSCALARMULT_THRESHOLD=51000 ...
#define BLAZE_SMP_DVECSCALARMULT_THRESHOLD 51000UL
#include <blaze/Blaze.h>

◆ BLAZE_SMP_SMATDMATMULT_THRESHOLD

#define BLAZE_SMP_SMATDMATMULT_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 or the HPX-based 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.

Note
It is possible to specify this threshold via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_SMP_SMATDMATMULT_THRESHOLD=7744 ...
#define BLAZE_SMP_SMATDMATMULT_THRESHOLD 7744UL
#include <blaze/Blaze.h>

◆ BLAZE_SMP_SMATDVECMULT_THRESHOLD

#define BLAZE_SMP_SMATDVECMULT_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 or the HPX-based parallelization.

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

Note
It is possible to specify this threshold via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_SMP_SMATDVECMULT_THRESHOLD=600 ...
#define BLAZE_SMP_SMATDVECMULT_THRESHOLD 600UL
#include <blaze/Blaze.h>

◆ BLAZE_SMP_SMATREDUCE_THRESHOLD

#define BLAZE_SMP_SMATREDUCE_THRESHOLD   180UL

SMP sparse matrix reduction threshold.

This threshold specifies when a sparse matrix reduction 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 or the HPX-based parallelization.

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

Note
It is possible to specify this threshold via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_SMP_SMATREDUCE_THRESHOLD=180 ...
#define BLAZE_SMP_SMATREDUCE_THRESHOLD 180UL
#include <blaze/Blaze.h>

◆ BLAZE_SMP_SMATSMATMULT_THRESHOLD

#define BLAZE_SMP_SMATSMATMULT_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 or the HPX-based 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.

Note
It is possible to specify this threshold via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_SMP_SMATSMATMULT_THRESHOLD=22500 ...
#define BLAZE_SMP_SMATSMATMULT_THRESHOLD 22500UL
#include <blaze/Blaze.h>

◆ BLAZE_SMP_SMATSVECMULT_THRESHOLD

#define BLAZE_SMP_SMATSVECMULT_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 or the HPX-based parallelization.

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

Note
It is possible to specify this threshold via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_SMP_SMATSVECMULT_THRESHOLD=260 ...
#define BLAZE_SMP_SMATSVECMULT_THRESHOLD 260UL
#include <blaze/Blaze.h>

◆ BLAZE_SMP_SMATTDMATMULT_THRESHOLD

#define BLAZE_SMP_SMATTDMATMULT_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 or the HPX-based 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.

Note
It is possible to specify this threshold via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_SMP_SMATTDMATMULT_THRESHOLD=5184 ...
#define BLAZE_SMP_SMATTDMATMULT_THRESHOLD 5184UL
#include <blaze/Blaze.h>

◆ BLAZE_SMP_SMATTSMATMULT_THRESHOLD

#define BLAZE_SMP_SMATTSMATMULT_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 or the HPX-based 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.

Note
It is possible to specify this threshold via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_SMP_SMATTSMATMULT_THRESHOLD=19600 ...
#define BLAZE_SMP_SMATTSMATMULT_THRESHOLD 19600UL
#include <blaze/Blaze.h>

◆ BLAZE_SMP_TDMATDMATMULT_THRESHOLD

#define BLAZE_SMP_TDMATDMATMULT_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 or the HPX-based 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.

Note
It is possible to specify this threshold via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_SMP_TDMATDMATMULT_THRESHOLD=3025 ...
#define BLAZE_SMP_TDMATDMATMULT_THRESHOLD 3025UL
#include <blaze/Blaze.h>

◆ BLAZE_SMP_TDMATDVECMULT_THRESHOLD

#define BLAZE_SMP_TDMATDVECMULT_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 or the HPX-based parallelization.

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

Note
It is possible to specify this threshold via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_SMP_TDMATDVECMULT_THRESHOLD=360 ...
#define BLAZE_SMP_TDMATDVECMULT_THRESHOLD 360UL
#include <blaze/Blaze.h>

◆ BLAZE_SMP_TDMATSMATMULT_THRESHOLD

#define BLAZE_SMP_TDMATSMATMULT_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 or the HPX-based 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.

Note
It is possible to specify this threshold via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_SMP_TDMATSMATMULT_THRESHOLD=8100 ...
#define BLAZE_SMP_TDMATSMATMULT_THRESHOLD 8100UL
#include <blaze/Blaze.h>

◆ BLAZE_SMP_TDMATSVECMULT_THRESHOLD

#define BLAZE_SMP_TDMATSVECMULT_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 or the HPX-based parallelization.

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

Note
It is possible to specify this threshold via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_SMP_TDMATSVECMULT_THRESHOLD=910 ...
#define BLAZE_SMP_TDMATSVECMULT_THRESHOLD 910UL
#include <blaze/Blaze.h>

◆ BLAZE_SMP_TDMATTDMATMULT_THRESHOLD

#define BLAZE_SMP_TDMATTDMATMULT_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 or the HPX-based 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.

Note
It is possible to specify this threshold via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_SMP_TDMATTDMATMULT_THRESHOLD=3025 ...
#define BLAZE_SMP_TDMATTDMATMULT_THRESHOLD 3025UL
#include <blaze/Blaze.h>

◆ BLAZE_SMP_TDMATTSMATMULT_THRESHOLD

#define BLAZE_SMP_TDMATTSMATMULT_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 or the HPX-based 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.

Note
It is possible to specify this threshold via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_SMP_TDMATTSMATMULT_THRESHOLD=8100 ...
#define BLAZE_SMP_TDMATTSMATMULT_THRESHOLD 8100UL
#include <blaze/Blaze.h>

◆ BLAZE_SMP_TDVECDMATMULT_THRESHOLD

#define BLAZE_SMP_TDVECDMATMULT_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 or the HPX-based parallelization.

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

Note
It is possible to specify this threshold via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_SMP_TDVECDMATMULT_THRESHOLD=370 ...
#define BLAZE_SMP_TDVECDMATMULT_THRESHOLD 370UL
#include <blaze/Blaze.h>

◆ BLAZE_SMP_TDVECSMATMULT_THRESHOLD

#define BLAZE_SMP_TDVECSMATMULT_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 or the HPX-based parallelization.

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

Note
It is possible to specify this threshold via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_SMP_TDVECSMATMULT_THRESHOLD=1190 ...
#define BLAZE_SMP_TDVECSMATMULT_THRESHOLD 1190UL
#include <blaze/Blaze.h>

◆ BLAZE_SMP_TDVECTDMATMULT_THRESHOLD

#define BLAZE_SMP_TDVECTDMATMULT_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 or the HPX-based parallelization.

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

Note
It is possible to specify this threshold via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_SMP_TDVECTDMATMULT_THRESHOLD=340 ...
#define BLAZE_SMP_TDVECTDMATMULT_THRESHOLD 340UL
#include <blaze/Blaze.h>

◆ BLAZE_SMP_TDVECTSMATMULT_THRESHOLD

#define BLAZE_SMP_TDVECTSMATMULT_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 or the HPX-based parallelization.

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

Note
It is possible to specify this threshold via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_SMP_TDVECTSMATMULT_THRESHOLD=530 ...
#define BLAZE_SMP_TDVECTSMATMULT_THRESHOLD 530UL
#include <blaze/Blaze.h>

◆ BLAZE_SMP_TSMATDMATMULT_THRESHOLD

#define BLAZE_SMP_TSMATDMATMULT_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 or the HPX-based 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.

Note
It is possible to specify this threshold via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_SMP_TSMATDMATMULT_THRESHOLD=4356 ...
#define BLAZE_SMP_TSMATDMATMULT_THRESHOLD 4356UL
#include <blaze/Blaze.h>

◆ BLAZE_SMP_TSMATDVECMULT_THRESHOLD

#define BLAZE_SMP_TSMATDVECMULT_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 or the HPX-based parallelization.

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

Note
It is possible to specify this threshold via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_SMP_TSMATDVECMULT_THRESHOLD=1250 ...
#define BLAZE_SMP_TSMATDVECMULT_THRESHOLD 1250UL
#include <blaze/Blaze.h>

◆ BLAZE_SMP_TSMATSMATMULT_THRESHOLD

#define BLAZE_SMP_TSMATSMATMULT_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 or the HPX-based 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.

Note
It is possible to specify this threshold via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_SMP_TSMATSMATMULT_THRESHOLD=19600 ...
#define BLAZE_SMP_TSMATSMATMULT_THRESHOLD 19600UL
#include <blaze/Blaze.h>

◆ BLAZE_SMP_TSMATSVECMULT_THRESHOLD

#define BLAZE_SMP_TSMATSVECMULT_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 or the HPX-based parallelization.

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

Note
It is possible to specify this threshold via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_SMP_TSMATSVECMULT_THRESHOLD=2160 ...
#define BLAZE_SMP_TSMATSVECMULT_THRESHOLD 2160UL
#include <blaze/Blaze.h>

◆ BLAZE_SMP_TSMATTDMATMULT_THRESHOLD

#define BLAZE_SMP_TSMATTDMATMULT_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 or the HPX-based 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.

Note
It is possible to specify this threshold via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_SMP_TSMATTDMATMULT_THRESHOLD=4356 ...
#define BLAZE_SMP_TSMATTDMATMULT_THRESHOLD 4356UL
#include <blaze/Blaze.h>

◆ BLAZE_SMP_TSMATTSMATMULT_THRESHOLD

#define BLAZE_SMP_TSMATTSMATMULT_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 or the HPX-based 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.

Note
It is possible to specify this threshold via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_SMP_TSMATTSMATMULT_THRESHOLD=22500 ...
#define BLAZE_SMP_TSMATTSMATMULT_THRESHOLD 22500UL
#include <blaze/Blaze.h>

◆ BLAZE_SMP_TSVECDMATMULT_THRESHOLD

#define BLAZE_SMP_TSVECDMATMULT_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 or the HPX-based parallelization.

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

Note
It is possible to specify this threshold via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_SMP_TSVECDMATMULT_THRESHOLD=910 ...
#define BLAZE_SMP_TSVECDMATMULT_THRESHOLD 910UL
#include <blaze/Blaze.h>

◆ BLAZE_SMP_TSVECSMATMULT_THRESHOLD

#define BLAZE_SMP_TSVECSMATMULT_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 or the HPX-based parallelization.

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

Note
It is possible to specify this threshold via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_SMP_TSVECSMATMULT_THRESHOLD=2160 ...
#define BLAZE_SMP_TSVECSMATMULT_THRESHOLD 2160UL
#include <blaze/Blaze.h>

◆ BLAZE_SMP_TSVECTDMATMULT_THRESHOLD

#define BLAZE_SMP_TSVECTDMATMULT_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 or the HPX-based parallelization.

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

Note
It is possible to specify this threshold via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_SMP_TSVECTDMATMULT_THRESHOLD=480 ...
#define BLAZE_SMP_TSVECTDMATMULT_THRESHOLD 480UL
#include <blaze/Blaze.h>

◆ BLAZE_SMP_TSVECTSMATMULT_THRESHOLD

#define BLAZE_SMP_TSVECTSMATMULT_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 or the HPX-based parallelization.

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

Note
It is possible to specify this threshold via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_SMP_TSVECTSMATMULT_THRESHOLD=260 ...
#define BLAZE_SMP_TSVECTSMATMULT_THRESHOLD 260UL
#include <blaze/Blaze.h>

◆ BLAZE_TDMATDMATMULT_THRESHOLD

#define BLAZE_TDMATDMATMULT_THRESHOLD   4900UL

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 4900 (which for instance corresponds to a matrix size of $ 70 \times 70 $). Note that in case the Blaze debug mode is active, this threshold will be replaced by the blaze::TDMATDMATMULT_DEBUG_THRESHOLD value.

Note
It is possible to specify this threshold via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_TDMATDMATMULT_THRESHOLD=4900 ...
#define BLAZE_TDMATDMATMULT_THRESHOLD 4900UL
#include <blaze/Blaze.h>

◆ BLAZE_TDMATDVECMULT_THRESHOLD

#define BLAZE_TDMATDVECMULT_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.

Note
It is possible to specify this threshold via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_TDMATDVECMULT_THRESHOLD=62500 ...
#define BLAZE_TDMATDVECMULT_THRESHOLD 62500UL
#include <blaze/Blaze.h>

◆ BLAZE_TDMATSMATMULT_THRESHOLD

#define BLAZE_TDMATSMATMULT_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.

Note
It is possible to specify this threshold via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_TDMATSMATMULT_THRESHOLD=2500 ...
#define BLAZE_TDMATSMATMULT_THRESHOLD 2500UL
#include <blaze/Blaze.h>

◆ BLAZE_TDMATTDMATMULT_THRESHOLD

#define BLAZE_TDMATTDMATMULT_THRESHOLD   4900UL

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 4900 (which for instance corresponds to a matrix size of $ 70 \times 70 $). Note that in case the Blaze debug mode is active, this threshold will be replaced by the blaze::TDMATTDMATMULT_DEBUG_THRESHOLD value.

Note
It is possible to specify this threshold via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_TDMATTDMATMULT_THRESHOLD=4900 ...
#define BLAZE_TDMATTDMATMULT_THRESHOLD 4900UL
#include <blaze/Blaze.h>

◆ BLAZE_TDVECDMATMULT_THRESHOLD

#define BLAZE_TDVECDMATMULT_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.

Note
It is possible to specify this threshold via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_TDVECDMATMULT_THRESHOLD=62500 ...
#define BLAZE_TDVECDMATMULT_THRESHOLD 62500UL
#include <blaze/Blaze.h>

◆ BLAZE_TDVECTDMATMULT_THRESHOLD

#define BLAZE_TDVECTDMATMULT_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.

Note
It is possible to specify this threshold via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_TDVECTDMATMULT_THRESHOLD=4000000 ...
#define BLAZE_TDVECTDMATMULT_THRESHOLD 4000000UL
#include <blaze/Blaze.h>

◆ BLAZE_TSMATDMATMULT_THRESHOLD

#define BLAZE_TSMATDMATMULT_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.

Note
It is possible to specify this threshold via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_TSMATDMATMULT_THRESHOLD=10000 ...
#define BLAZE_TSMATDMATMULT_THRESHOLD 10000UL
#include <blaze/Blaze.h>

◆ BLAZE_TSMATTDMATMULT_THRESHOLD

#define BLAZE_TSMATTDMATMULT_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.

Note
It is possible to specify this threshold via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_TSMATTDMATMULT_THRESHOLD=22500 ...
#define BLAZE_TSMATTDMATMULT_THRESHOLD 22500UL
#include <blaze/Blaze.h>

◆ BLAZE_USE_ALWAYS_INLINE

#define BLAZE_USE_ALWAYS_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

Note that it is possible to (de-)activate the strengthened inline keyword via command line or by defining this symbol manually before including any Blaze header file:

g++ ... -DBLAZE_USE_STRONG_INLINE=1 ...
#define BLAZE_USE_STRONG_INLINE 1
#include <blaze/Blaze.h>

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

Note that it is possible to (de-)activate the enforced inline keyword via command line or by defining this symbol manually before including any Blaze header file:

g++ ... -DBLAZE_USE_ALWAYS_INLINE=1 ...
#define BLAZE_USE_ALWAYS_INLINE 1
#include <blaze/Blaze.h>

◆ BLAZE_USE_BLAS_MATRIX_VECTOR_MULTIPLICATION

#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
Warning
Changing the setting of this compilation switch requires a recompilation of all code using the Blaze library!
Note
It is possible to (de-)activate the use of the BLAS matrix/vector multiplication kernels via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_USE_BLAS_MATRIX_VECTOR_MULTIPLICATION=1 ...
#define BLAZE_USE_BLAS_MATRIX_VECTOR_MULTIPLICATION 1
#include <blaze/Blaze.h>

◆ BLAZE_USE_DEBUG_MODE

#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
Note
It is possible to (de-)activate the debug mode via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_USE_DEBUG_MODE=1 ...
#define BLAZE_USE_DEBUG_MODE 1
#include <blaze/Blaze.h>

◆ BLAZE_USE_DEFAULT_INITIALIZATION

#define BLAZE_USE_DEFAULT_INITIALIZATION   1

Configuration switch for the initialization in default constructors.

This configuration switch enables/disables the element initialization in the default constructors of the StaticVector and StaticMatrix class templates. In case the switch is set to 1 all elements are initialized to their respective default. In case the switch is set to 0 the default initialization is skipped and the elements are not initialized. Please note that this switch is only effective in case the elements are of fundamental type (i.e. integral or floating point). In case the elements are of class type, this switch has no effect.

Possible settings for the default initialization:

  • Disabled: 0
  • Enabled : 1
Note
It is possible to (de-)activate the default initialization via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_USE_DEFAULT_INITIALIZATION=1 ...
#define BLAZE_USE_DEFAULT_INITIALIZATION 1
#include <blaze/Blaze.h>

◆ BLAZE_USE_FUNCTION_TRACES

#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 and trace information is written to the console via std::cerr.

Possible settings for the function trace switch:

  • Deactivated: 0 (default)
  • Activated : 1
Note
It is possible to (de-)activate function traces via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_USE_FUNCTION_TRACES=1 ...
#define BLAZE_USE_FUNCTION_TRACES 1
#include <blaze/Blaze.h>

◆ BLAZE_USE_OPTIMIZED_KERNELS

#define BLAZE_USE_OPTIMIZED_KERNELS   1

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 1 the optimized kernels are used whenever possible. In case the switch is set to 0 all optimized kernels are not used, even if it would be possible.

Possible settings for the optimized kernels:

  • Disabled: 0
  • Enabled : 1
Warning
Note that disabling the optimized kernels causes a severe performance limitiation to nearly all operations!
Note
It is possible to (de-)activate the optimized kernels via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_USE_OPTIMIZED_KERNELS=1 ...
#define BLAZE_USE_OPTIMIZED_KERNELS 1
#include <blaze/Blaze.h>

◆ BLAZE_USE_SLEEF

#define BLAZE_USE_SLEEF   0

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)
Note
It is possible to (de-)activate vectorization via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_USE_VECTORIZATION=1 ...
#define BLAZE_USE_VECTORIZATION 1
#include <blaze/Blaze.h>

Compilation switch for enabling/disabling vectorization by means of the Sleef library.

For several complex operations Blaze can make use of the Sleef library for vectorization (https://github.com/shibatch/sleef). This compilation switch enables/disables the vectorization by means of Sleef. In case the switch is set to 1, Blaze uses Sleef for instance for the vectorized computation of trigonometric functions (i.e. sin(), cos(), tan(), etc.) and exponential functions (i.e. exp(), log(), ...).

Possible settings for the Sleef switch:

  • Deactivated: 0 (default)
  • Activated : 1
Note
It is possible to enable/disable Sleef vectorization via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_USE_SLEEF=1 ...
#define BLAZE_USE_SLEEF 1
#include <blaze/Blaze.h>

◆ BLAZE_USE_STREAMING

#define BLAZE_USE_STREAMING   1

Configuration of the padding of dynamic vectors and matrices.

This configuration switch enables/disables the padding of DynamicVector and DynamicMatrix. 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 padding is enabled, it is enabled only for the DynamicVector and DynamicMatrix class templates. Other dense vector and matrix classes are not affected. If padding is disabled, both DynamicVector and DynamicMatrix don't apply padding.

Possible settings for padding:

  • Disabled: 0
  • Enabled : 1
Warning
Note that disabling padding can considerably reduce the performance of operations with DynamicVector and DynamicMatrix.
Note
It is possible to (de-)activate padding via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_USE_PADDING=1 ...
#define BLAZE_USE_PADDING 1
#include <blaze/Blaze.h>

Configuration of the streaming behavior.

Via this compilation switch streaming (i.e. non-temporal stores) can be (de-)activated. 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.

Possible settings for streaming:

  • Disabled: 0
  • Enabled : 1
Note
It is possible to (de-)activate streaming via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_USE_STREAMING=1 ...
#define BLAZE_USE_STREAMING 1
#include <blaze/Blaze.h>

◆ BLAZE_USER_ASSERTION

#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
Note
It is possible to (de-)activate user assertions via command line or by defining this symbol manually before including any Blaze header file:
g++ ... -DBLAZE_USER_ASSERTION=1 ...
#define BLAZE_USER_ASSERTION 1
#include <blaze/Blaze.h>