Level3.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_BLAS_LEVEL3_H_
36 #define _BLAZE_MATH_BLAS_LEVEL3_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <boost/cast.hpp>
50 #include <blaze/system/BLAS.h>
51 #include <blaze/system/Inline.h>
52 #include <blaze/util/Assert.h>
53 #include <blaze/util/Complex.h>
57 
58 
59 namespace blaze {
60 
61 //=================================================================================================
62 //
63 // BLAS LEVEL 3 FUNCTIONS
64 //
65 //=================================================================================================
66 
67 //*************************************************************************************************
70 #if BLAZE_BLAS_MODE
71 
72 template< typename MT1, bool SO1, typename MT2, bool SO2, typename MT3, bool SO3 >
73 BLAZE_ALWAYS_INLINE void sgemm( DenseMatrix<MT1,SO1>& C, const DenseMatrix<MT2,SO2>& A,
74  const DenseMatrix<MT3,SO3>& B, float alpha, float beta );
75 
76 template< typename MT1, bool SO1, typename MT2, bool SO2, typename MT3, bool SO3 >
77 BLAZE_ALWAYS_INLINE void dgemm( DenseMatrix<MT1,SO1>& C, const DenseMatrix<MT2,SO2>& A,
78  const DenseMatrix<MT3,SO3>& B, double alpha, double beta );
79 
80 template< typename MT1, bool SO1, typename MT2, bool SO2, typename MT3, bool SO3 >
81 BLAZE_ALWAYS_INLINE void cgemm( DenseMatrix<MT1,SO1>& C, const DenseMatrix<MT2,SO2>& A,
82  const DenseMatrix<MT3,SO3>& B, complex<float> alpha, complex<float> beta );
83 
84 template< typename MT1, bool SO1, typename MT2, bool SO2, typename MT3, bool SO3 >
85 BLAZE_ALWAYS_INLINE void zgemm( DenseMatrix<MT1,SO1>& C, const DenseMatrix<MT2,SO2>& A,
86  const DenseMatrix<MT3,SO3>& B, complex<double> alpha, complex<double> beta );
87 
88 template< typename MT1, bool SO1, typename MT2, bool SO2 >
89 BLAZE_ALWAYS_INLINE void strmm( DenseMatrix<MT1,SO1>& B, const DenseMatrix<MT2,SO2>& A,
90  CBLAS_SIDE side, CBLAS_UPLO uplo, float alpha );
91 
92 template< typename MT1, bool SO1, typename MT2, bool SO2 >
93 BLAZE_ALWAYS_INLINE void dtrmm( DenseMatrix<MT1,SO1>& B, const DenseMatrix<MT2,SO2>& A,
94  CBLAS_SIDE side, CBLAS_UPLO uplo, double alpha );
95 
96 template< typename MT1, bool SO1, typename MT2, bool SO2 >
97 BLAZE_ALWAYS_INLINE void ctrmm( DenseMatrix<MT1,SO1>& B, const DenseMatrix<MT2,SO2>& A,
98  CBLAS_SIDE side, CBLAS_UPLO uplo, complex<float> alpha );
99 
100 template< typename MT1, bool SO1, typename MT2, bool SO2 >
101 BLAZE_ALWAYS_INLINE void ztrmm( DenseMatrix<MT1,SO1>& B, const DenseMatrix<MT2,SO2>& A,
102  CBLAS_SIDE side, CBLAS_UPLO uplo, complex<double> alpha );
103 
104 #endif
105 
106 //*************************************************************************************************
107 
108 
109 //*************************************************************************************************
110 #if BLAZE_BLAS_MODE
111 
127 template< typename MT1 // Type of the left-hand side target matrix
128  , bool SO1 // Storage order of the left-hand side target matrix
129  , typename MT2 // Type of the left-hand side matrix operand
130  , bool SO2 // Storage order of the left-hand side matrix operand
131  , typename MT3 // Type of the right-hand side matrix operand
132  , bool SO3 > // Storage order of the right-hand side matrix operand
133 BLAZE_ALWAYS_INLINE void sgemm( DenseMatrix<MT1,SO1>& C, const DenseMatrix<MT2,SO2>& A,
134  const DenseMatrix<MT3,SO3>& B, float alpha, float beta )
135 {
136  using boost::numeric_cast;
137 
141 
145 
149 
150  const int M ( numeric_cast<int>( (~A).rows() ) );
151  const int N ( numeric_cast<int>( (~B).columns() ) );
152  const int K ( numeric_cast<int>( (~A).columns() ) );
153  const int lda( numeric_cast<int>( (~A).spacing() ) );
154  const int ldb( numeric_cast<int>( (~B).spacing() ) );
155  const int ldc( numeric_cast<int>( (~C).spacing() ) );
156 
157  if( IsSymmetric<MT2>::value && ( SO1 == SO3 ) ) {
158  cblas_ssymm( ( IsRowMajorMatrix<MT1>::value )?( CblasRowMajor ):( CblasColMajor ),
159  CblasLeft,
160  ( IsRowMajorMatrix<MT2>::value )?( CblasLower ):( CblasUpper ),
161  M, N, alpha, (~A).data(), lda, (~B).data(), ldb, beta, (~C).data(), ldc );
162  }
163  else if( IsSymmetric<MT3>::value && ( SO1 == SO2 ) ) {
164  cblas_ssymm( ( IsRowMajorMatrix<MT1>::value )?( CblasRowMajor ):( CblasColMajor ),
165  CblasRight,
166  ( IsRowMajorMatrix<MT3>::value )?( CblasLower ):( CblasUpper ),
167  M, N, alpha, (~B).data(), ldb, (~A).data(), lda, beta, (~C).data(), ldc );
168  }
169  else {
170  cblas_sgemm( ( IsRowMajorMatrix<MT1>::value )?( CblasRowMajor ):( CblasColMajor ),
171  ( SO1 == SO2 )?( CblasNoTrans ):( CblasTrans ),
172  ( SO1 == SO3 )?( CblasNoTrans ):( CblasTrans ),
173  M, N, K, alpha, (~A).data(), lda, (~B).data(), ldb, beta, (~C).data(), ldc );
174  }
175 }
176 #endif
177 //*************************************************************************************************
178 
179 
180 //*************************************************************************************************
181 #if BLAZE_BLAS_MODE
182 
198 template< typename MT1 // Type of the left-hand side target matrix
199  , bool SO1 // Storage order of the left-hand side target matrix
200  , typename MT2 // Type of the left-hand side matrix operand
201  , bool SO2 // Storage order of the left-hand side matrix operand
202  , typename MT3 // Type of the right-hand side matrix operand
203  , bool SO3 > // Storage order of the right-hand side matrix operand
204 BLAZE_ALWAYS_INLINE void dgemm( DenseMatrix<MT1,SO1>& C, const DenseMatrix<MT2,SO2>& A,
205  const DenseMatrix<MT3,SO3>& B, double alpha, double beta )
206 {
207  using boost::numeric_cast;
208 
212 
216 
220 
221  const int M ( numeric_cast<int>( (~A).rows() ) );
222  const int N ( numeric_cast<int>( (~B).columns() ) );
223  const int K ( numeric_cast<int>( (~A).columns() ) );
224  const int lda( numeric_cast<int>( (~A).spacing() ) );
225  const int ldb( numeric_cast<int>( (~B).spacing() ) );
226  const int ldc( numeric_cast<int>( (~C).spacing() ) );
227 
228  if( IsSymmetric<MT2>::value && ( SO1 == SO3 ) ) {
229  cblas_dsymm( ( IsRowMajorMatrix<MT1>::value )?( CblasRowMajor ):( CblasColMajor ),
230  CblasLeft,
231  ( IsRowMajorMatrix<MT2>::value )?( CblasLower ):( CblasUpper ),
232  M, N, alpha, (~A).data(), lda, (~B).data(), ldb, beta, (~C).data(), ldc );
233  }
234  else if( IsSymmetric<MT3>::value && ( SO1 == SO2 ) ) {
235  cblas_dsymm( ( IsRowMajorMatrix<MT1>::value )?( CblasRowMajor ):( CblasColMajor ),
236  CblasRight,
237  ( IsRowMajorMatrix<MT3>::value )?( CblasLower ):( CblasUpper ),
238  M, N, alpha, (~B).data(), ldb, (~A).data(), lda, beta, (~C).data(), ldc );
239  }
240  else {
241  cblas_dgemm( ( IsRowMajorMatrix<MT1>::value )?( CblasRowMajor ):( CblasColMajor ),
242  ( SO1 == SO2 )?( CblasNoTrans ):( CblasTrans ),
243  ( SO1 == SO3 )?( CblasNoTrans ):( CblasTrans ),
244  M, N, K, alpha, (~A).data(), lda, (~B).data(), ldb, beta, (~C).data(), ldc );
245  }
246 }
247 #endif
248 //*************************************************************************************************
249 
250 
251 //*************************************************************************************************
252 #if BLAZE_BLAS_MODE
253 
269 template< typename MT1 // Type of the left-hand side target matrix
270  , bool SO1 // Storage order of the left-hand side target matrix
271  , typename MT2 // Type of the left-hand side matrix operand
272  , bool SO2 // Storage order of the left-hand side matrix operand
273  , typename MT3 // Type of the right-hand side matrix operand
274  , bool SO3 > // Storage order of the right-hand side matrix operand
275 BLAZE_ALWAYS_INLINE void cgemm( DenseMatrix<MT1,SO1>& C, const DenseMatrix<MT2,SO2>& A,
276  const DenseMatrix<MT3,SO3>& B, complex<float> alpha, complex<float> beta )
277 {
278  using boost::numeric_cast;
279 
283 
287 
291  BLAZE_CONSTRAINT_MUST_BE_FLOAT_TYPE ( typename MT1::ElementType::value_type );
292  BLAZE_CONSTRAINT_MUST_BE_FLOAT_TYPE ( typename MT2::ElementType::value_type );
293  BLAZE_CONSTRAINT_MUST_BE_FLOAT_TYPE ( typename MT3::ElementType::value_type );
294 
295  const int M ( numeric_cast<int>( (~A).rows() ) );
296  const int N ( numeric_cast<int>( (~B).columns() ) );
297  const int K ( numeric_cast<int>( (~A).columns() ) );
298  const int lda( numeric_cast<int>( (~A).spacing() ) );
299  const int ldb( numeric_cast<int>( (~B).spacing() ) );
300  const int ldc( numeric_cast<int>( (~C).spacing() ) );
301 
302  if( IsSymmetric<MT2>::value && ( SO1 == SO3 ) ) {
303  cblas_csymm( ( IsRowMajorMatrix<MT1>::value )?( CblasRowMajor ):( CblasColMajor ),
304  CblasLeft,
305  ( IsRowMajorMatrix<MT2>::value )?( CblasLower ):( CblasUpper ),
306  M, N, &alpha, (~A).data(), lda, (~B).data(), ldb, &beta, (~C).data(), ldc );
307  }
308  else if( IsSymmetric<MT3>::value && ( SO1 == SO2 ) ) {
309  cblas_csymm( ( IsRowMajorMatrix<MT1>::value )?( CblasRowMajor ):( CblasColMajor ),
310  CblasRight,
311  ( IsRowMajorMatrix<MT3>::value )?( CblasLower ):( CblasUpper ),
312  M, N, &alpha, (~B).data(), ldb, (~A).data(), lda, &beta, (~C).data(), ldc );
313  }
314  else {
315  cblas_cgemm( ( IsRowMajorMatrix<MT1>::value )?( CblasRowMajor ):( CblasColMajor ),
316  ( SO1 == SO2 )?( CblasNoTrans ):( CblasTrans ),
317  ( SO1 == SO3 )?( CblasNoTrans ):( CblasTrans ),
318  M, N, K, &alpha, (~A).data(), lda, (~B).data(), ldb, &beta, (~C).data(), ldc );
319  }
320 }
321 #endif
322 //*************************************************************************************************
323 
324 
325 //*************************************************************************************************
326 #if BLAZE_BLAS_MODE
327 
343 template< typename MT1 // Type of the left-hand side target matrix
344  , bool SO1 // Storage order of the left-hand side target matrix
345  , typename MT2 // Type of the left-hand side matrix operand
346  , bool SO2 // Storage order of the left-hand side matrix operand
347  , typename MT3 // Type of the right-hand side matrix operand
348  , bool SO3 > // Storage order of the right-hand side matrix operand
349 BLAZE_ALWAYS_INLINE void zgemm( DenseMatrix<MT1,SO1>& C, const DenseMatrix<MT2,SO2>& A,
350  const DenseMatrix<MT3,SO3>& B, complex<double> alpha, complex<double> beta )
351 {
352  using boost::numeric_cast;
353 
357 
361 
365  BLAZE_CONSTRAINT_MUST_BE_DOUBLE_TYPE ( typename MT1::ElementType::value_type );
366  BLAZE_CONSTRAINT_MUST_BE_DOUBLE_TYPE ( typename MT2::ElementType::value_type );
367  BLAZE_CONSTRAINT_MUST_BE_DOUBLE_TYPE ( typename MT3::ElementType::value_type );
368 
369  const int M ( numeric_cast<int>( (~A).rows() ) );
370  const int N ( numeric_cast<int>( (~B).columns() ) );
371  const int K ( numeric_cast<int>( (~A).columns() ) );
372  const int lda( numeric_cast<int>( (~A).spacing() ) );
373  const int ldb( numeric_cast<int>( (~B).spacing() ) );
374  const int ldc( numeric_cast<int>( (~C).spacing() ) );
375 
376  if( IsSymmetric<MT2>::value && ( SO1 == SO3 ) ) {
377  cblas_zsymm( ( IsRowMajorMatrix<MT1>::value )?( CblasRowMajor ):( CblasColMajor ),
378  CblasLeft,
379  ( IsRowMajorMatrix<MT2>::value )?( CblasLower ):( CblasUpper ),
380  M, N, &alpha, (~A).data(), lda, (~B).data(), ldb, &beta, (~C).data(), ldc );
381  }
382  else if( IsSymmetric<MT3>::value && ( SO1 == SO2 ) ) {
383  cblas_zsymm( ( IsRowMajorMatrix<MT1>::value )?( CblasRowMajor ):( CblasColMajor ),
384  CblasRight,
385  ( IsRowMajorMatrix<MT3>::value )?( CblasLower ):( CblasUpper ),
386  M, N, &alpha, (~B).data(), ldb, (~A).data(), lda, &beta, (~C).data(), ldc );
387  }
388  else {
389  cblas_zgemm( ( IsRowMajorMatrix<MT1>::value )?( CblasRowMajor ):( CblasColMajor ),
390  ( SO1 == SO2 )?( CblasNoTrans ):( CblasTrans ),
391  ( SO1 == SO3 )?( CblasNoTrans ):( CblasTrans ),
392  M, N, K, &alpha, (~A).data(), lda, (~B).data(), ldb, &beta, (~C).data(), ldc );
393  }
394 }
395 #endif
396 //*************************************************************************************************
397 
398 
399 //*************************************************************************************************
400 #if BLAZE_BLAS_MODE
401 
417 template< typename MT1 // Type of the left-hand side target matrix
418  , bool SO1 // Storage order of the left-hand side target matrix
419  , typename MT2 // Type of the left-hand side matrix operand
420  , bool SO2 > // Storage order of the left-hand side matrix operand
421 BLAZE_ALWAYS_INLINE void strmm( DenseMatrix<MT1,SO1>& B, const DenseMatrix<MT2,SO2>& A,
422  CBLAS_SIDE side, CBLAS_UPLO uplo, float alpha )
423 {
424  using boost::numeric_cast;
425 
428 
431 
434 
435  BLAZE_INTERNAL_ASSERT( (~A).rows() == (~A).columns(), "Non-square triangular matrix detected" );
436  BLAZE_INTERNAL_ASSERT( side == CblasLeft || side == CblasRight, "Invalid side argument detected" );
437  BLAZE_INTERNAL_ASSERT( uplo == CblasLower || uplo == CblasUpper, "Invalid uplo argument detected" );
438 
439  const int M ( numeric_cast<int>( (~B).rows() ) );
440  const int N ( numeric_cast<int>( (~B).columns() ) );
441  const int lda( numeric_cast<int>( (~A).spacing() ) );
442  const int ldb( numeric_cast<int>( (~B).spacing() ) );
443 
444  cblas_strmm( ( IsRowMajorMatrix<MT1>::value )?( CblasRowMajor ):( CblasColMajor ),
445  side,
446  ( SO1 == SO2 )?( uplo )
447  :( ( uplo == CblasLower )?( CblasUpper ):( CblasLower ) ),
448  ( SO1 == SO2 )?( CblasNoTrans ):( CblasTrans ),
449  CblasNonUnit,
450  M, N, alpha, (~A).data(), lda, (~B).data(), ldb );
451 }
452 #endif
453 //*************************************************************************************************
454 
455 
456 //*************************************************************************************************
457 #if BLAZE_BLAS_MODE
458 
474 template< typename MT1 // Type of the left-hand side target matrix
475  , bool SO1 // Storage order of the left-hand side target matrix
476  , typename MT2 // Type of the left-hand side matrix operand
477  , bool SO2 > // Storage order of the left-hand side matrix operand
478 BLAZE_ALWAYS_INLINE void dtrmm( DenseMatrix<MT1,SO1>& B, const DenseMatrix<MT2,SO2>& A,
479  CBLAS_SIDE side, CBLAS_UPLO uplo, double alpha )
480 {
481  using boost::numeric_cast;
482 
485 
488 
491 
492  BLAZE_INTERNAL_ASSERT( (~A).rows() == (~A).columns(), "Non-square triangular matrix detected" );
493  BLAZE_INTERNAL_ASSERT( side == CblasLeft || side == CblasRight, "Invalid side argument detected" );
494  BLAZE_INTERNAL_ASSERT( uplo == CblasLower || uplo == CblasUpper, "Invalid uplo argument detected" );
495 
496  const int M ( numeric_cast<int>( (~B).rows() ) );
497  const int N ( numeric_cast<int>( (~B).columns() ) );
498  const int lda( numeric_cast<int>( (~A).spacing() ) );
499  const int ldb( numeric_cast<int>( (~B).spacing() ) );
500 
501  cblas_dtrmm( ( IsRowMajorMatrix<MT1>::value )?( CblasRowMajor ):( CblasColMajor ),
502  side,
503  ( SO1 == SO2 )?( uplo )
504  :( ( uplo == CblasLower )?( CblasUpper ):( CblasLower ) ),
505  ( SO1 == SO2 )?( CblasNoTrans ):( CblasTrans ),
506  CblasNonUnit,
507  M, N, alpha, (~A).data(), lda, (~B).data(), ldb );
508 }
509 #endif
510 //*************************************************************************************************
511 
512 
513 //*************************************************************************************************
514 #if BLAZE_BLAS_MODE
515 
532 template< typename MT1 // Type of the left-hand side target matrix
533  , bool SO1 // Storage order of the left-hand side target matrix
534  , typename MT2 // Type of the left-hand side matrix operand
535  , bool SO2 > // Storage order of the left-hand side matrix operand
536 BLAZE_ALWAYS_INLINE void ctrmm( DenseMatrix<MT1,SO1>& B, const DenseMatrix<MT2,SO2>& A,
537  CBLAS_SIDE side, CBLAS_UPLO uplo, complex<float> alpha )
538 {
539  using boost::numeric_cast;
540 
543 
546 
549  BLAZE_CONSTRAINT_MUST_BE_FLOAT_TYPE ( typename MT1::ElementType::value_type );
550  BLAZE_CONSTRAINT_MUST_BE_FLOAT_TYPE ( typename MT2::ElementType::value_type );
551 
552  BLAZE_INTERNAL_ASSERT( (~A).rows() == (~A).columns(), "Non-square triangular matrix detected" );
553  BLAZE_INTERNAL_ASSERT( side == CblasLeft || side == CblasRight, "Invalid side argument detected" );
554  BLAZE_INTERNAL_ASSERT( uplo == CblasLower || uplo == CblasUpper, "Invalid uplo argument detected" );
555 
556  const int M ( numeric_cast<int>( (~B).rows() ) );
557  const int N ( numeric_cast<int>( (~B).columns() ) );
558  const int lda( numeric_cast<int>( (~A).spacing() ) );
559  const int ldb( numeric_cast<int>( (~B).spacing() ) );
560 
561  cblas_ctrmm( ( IsRowMajorMatrix<MT1>::value )?( CblasRowMajor ):( CblasColMajor ),
562  side,
563  ( SO1 == SO2 )?( uplo )
564  :( ( uplo == CblasLower )?( CblasUpper ):( CblasLower ) ),
565  ( SO1 == SO2 )?( CblasNoTrans ):( CblasTrans ),
566  CblasNonUnit,
567  M, N, &alpha, (~A).data(), lda, (~B).data(), ldb );
568 }
569 #endif
570 //*************************************************************************************************
571 
572 
573 //*************************************************************************************************
574 #if BLAZE_BLAS_MODE
575 
592 template< typename MT1 // Type of the left-hand side target matrix
593  , bool SO1 // Storage order of the left-hand side target matrix
594  , typename MT2 // Type of the left-hand side matrix operand
595  , bool SO2 > // Storage order of the left-hand side matrix operand
596 BLAZE_ALWAYS_INLINE void ztrmm( DenseMatrix<MT1,SO1>& B, const DenseMatrix<MT2,SO2>& A,
597  CBLAS_SIDE side, CBLAS_UPLO uplo, complex<double> alpha )
598 {
599  using boost::numeric_cast;
600 
603 
606 
609  BLAZE_CONSTRAINT_MUST_BE_DOUBLE_TYPE ( typename MT1::ElementType::value_type );
610  BLAZE_CONSTRAINT_MUST_BE_DOUBLE_TYPE ( typename MT2::ElementType::value_type );
611 
612  BLAZE_INTERNAL_ASSERT( (~A).rows() == (~A).columns(), "Non-square triangular matrix detected" );
613  BLAZE_INTERNAL_ASSERT( side == CblasLeft || side == CblasRight, "Invalid side argument detected" );
614  BLAZE_INTERNAL_ASSERT( uplo == CblasLower || uplo == CblasUpper, "Invalid uplo argument detected" );
615 
616  const int M ( numeric_cast<int>( (~B).rows() ) );
617  const int N ( numeric_cast<int>( (~B).columns() ) );
618  const int lda( numeric_cast<int>( (~A).spacing() ) );
619  const int ldb( numeric_cast<int>( (~B).spacing() ) );
620 
621  cblas_ztrmm( ( IsRowMajorMatrix<MT1>::value )?( CblasRowMajor ):( CblasColMajor ),
622  side,
623  ( SO1 == SO2 )?( uplo )
624  :( ( uplo == CblasLower )?( CblasUpper ):( CblasLower ) ),
625  ( SO1 == SO2 )?( CblasNoTrans ):( CblasTrans ),
626  CblasNonUnit,
627  M, N, &alpha, (~A).data(), lda, (~B).data(), ldb );
628 }
629 #endif
630 //*************************************************************************************************
631 
632 } // namespace blaze
633 
634 #endif
Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_HAVE_MUTABLE_DATA_ACCESS(T)
Constraint on the data type.In case the given data type T does not provide low-level data access to m...
Definition: MutableDataAccess.h:79
#define BLAZE_CONSTRAINT_MUST_HAVE_CONST_DATA_ACCESS(T)
Constraint on the data type.In case the given data type T does not provide low-level data access to c...
Definition: ConstDataAccess.h:79
#define BLAZE_CONSTRAINT_MUST_NOT_BE_COMPUTATION_TYPE(T)
Constraint on the data type.In case the given data type T is a computational expression (i...
Definition: Computation.h:118
Constraint on the data type.
BLAZE_ALWAYS_INLINE size_t rows(const Matrix< MT, SO > &matrix)
Returns the current number of rows of the matrix.
Definition: Matrix.h:316
#define BLAZE_CONSTRAINT_MUST_BE_FLOAT_TYPE(T)
Constraint on the data type.This compile time constraint checks that the given data type T is of type...
Definition: Float.h:80
Constraint on the data type.
Header file for the IsSymmetric type trait.
Namespace of the Blaze C++ math library.
Definition: Blaze.h:57
#define BLAZE_ALWAYS_INLINE
Platform dependent setup of an enforced inline keyword.
Definition: Inline.h:85
#define BLAZE_CONSTRAINT_MUST_BE_DOUBLE_TYPE(T)
Constraint on the data type.This compile time constraint checks that the given data type T is of type...
Definition: Double.h:80
Header file for the DenseMatrix base class.
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:2505
Constraint on the data type.
const bool spacing
Adding an additional spacing line between two log messages.This setting gives the opportunity to add ...
Definition: Logging.h:70
System settings for the BLAS mode.
Header file for run time assertion macros.
Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_COMPLEX_TYPE(T)
Constraint on the data type.This compile time constraint checks that the given data type T is a compl...
Definition: Complex.h:80
Header file for the IsRowMajorMatrix type trait.
BLAZE_ALWAYS_INLINE size_t columns(const Matrix< MT, SO > &matrix)
Returns the current number of columns of the matrix.
Definition: Matrix.h:332
Header file for the complex data type.
Constraint on the data type.
System settings for the inline keywords.
#define BLAZE_INTERNAL_ASSERT(expr, msg)
Run time assertion macro for internal checks.In case of an invalid run time expression, the program execution is terminated. The BLAZE_INTERNAL_ASSERT macro can be disabled by setting the BLAZE_USER_ASSERTION flag to zero or by defining NDEBUG during the compilation.
Definition: Assert.h:101