Blaze 3.9
gges.h
Go to the documentation of this file.
1//=================================================================================================
33//=================================================================================================
34
35#ifndef _BLAZE_MATH_LAPACK_GGES_H_
36#define _BLAZE_MATH_LAPACK_GGES_H_
37
38
39//*************************************************************************************************
40// Includes
41//*************************************************************************************************
42
43#include <memory>
44#include <blaze/math/Aliases.h>
57#include <blaze/util/Assert.h>
58#include <blaze/util/Complex.h>
61#include <blaze/util/EnableIf.h>
64
65
66namespace blaze {
67
68//=================================================================================================
69//
70// LAPACK GENERALIZED MATRIX EIGENVALUE FUNCTIONS (GGES)
71//
72//=================================================================================================
73
74//*************************************************************************************************
77template< typename MT1, bool SO1, typename MT2, bool SO2
78 , typename VT1, bool TF1, typename VT2, bool TF2 >
79void gges( DenseMatrix<MT1,SO1>& A, DenseMatrix<MT2,SO2>& B,
80 DenseVector<VT1,TF1>& alpha, DenseVector<VT2,TF2>& beta );
81
82template< typename MT1, bool SO1, typename MT2, bool SO2
83 , typename VT1, bool TF1, typename VT2, bool TF2
84 , typename Select >
85void gges( DenseMatrix<MT1,SO1>& A, DenseMatrix<MT2,SO2>& B,
86 DenseVector<VT1,TF1>& alpha, DenseVector<VT2,TF2>& beta,
87 Select select );
88
89template< typename MT1, bool SO1, typename MT2, bool SO2, typename MT3, bool SO3
90 , typename VT1, bool TF1, typename VT2, bool TF2, typename MT4, bool SO4 >
91void gges( DenseMatrix<MT1,SO1>& A, DenseMatrix<MT2,SO2>& B, DenseMatrix<MT3,SO3>& VSL,
92 DenseVector<VT1,TF1>& alpha, DenseVector<VT2,TF2>& beta, DenseMatrix<MT4,SO4>& VSR );
93
94template< typename MT1, bool SO1, typename MT2, bool SO2, typename MT3, bool SO3
95 , typename VT1, bool TF1, typename VT2, bool TF2, typename MT4, bool SO4
96 , typename Select >
97void gges( DenseMatrix<MT1,SO1>& A, DenseMatrix<MT2,SO2>& B, DenseMatrix<MT3,SO3>& VSL,
98 DenseVector<VT1,TF1>& alpha, DenseVector<VT2,TF2>& beta, DenseMatrix<MT4,SO4>& VSR,
99 Select select );
101//*************************************************************************************************
102
103
104//*************************************************************************************************
124template< typename MT1 // Type of the matrix A
125 , bool SO1 // Storage order of the matrix A
126 , typename MT2 // Type of the matrix B
127 , bool SO2 // Storage order of the matrix B
128 , typename VT1 // Type of the vector alpha
129 , bool TF1 // Transpose flag of the vector alpha
130 , typename VT2 // Type of the vector beta
131 , bool TF2 // Transpose flag of the vector beta
132 , typename Select > // Type of the eigenvalue selector
133inline auto gges_backend( DenseMatrix<MT1,SO1>& A, DenseMatrix<MT2,SO2>& B,
134 DenseVector<VT1,TF1>& alpha, DenseVector<VT2,TF2>& beta,
135 Select select )
136 -> DisableIf_t< IsComplex_v< ElementType_t<MT1> > >
137{
138 BLAZE_INTERNAL_ASSERT( isSquare( *A ), "Invalid non-square matrix detected" );
139 BLAZE_INTERNAL_ASSERT( isSquare( *B ), "Invalid non-square matrix detected" );
140 BLAZE_INTERNAL_ASSERT( (*B).rows() == (*A).rows(), "Invalid matrix dimension detected" );
141 BLAZE_INTERNAL_ASSERT( (*alpha).size() == (*A).rows(), "Invalid vector dimension detected" );
142 BLAZE_INTERNAL_ASSERT( (*beta).size() == (*A).rows(), "Invalid vector dimension detected" );
143
144 using CT = ElementType_t<VT1>;
145 using BT = ElementType_t<MT1>;
146
149
150 const blas_int_t n ( numeric_cast<blas_int_t>( (*A).rows() ) );
151 const blas_int_t lda( numeric_cast<blas_int_t>( (*A).spacing() ) );
152 const blas_int_t ldb( numeric_cast<blas_int_t>( (*B).spacing() ) );
153 blas_int_t info( 0 );
154 blas_int_t sdim( 0 );
155
156 blas_int_t lwork = max( 8*n, 6*n + 16 );
157 const std::unique_ptr<BT[]> alphar( new BT[n] );
158 const std::unique_ptr<BT[]> alphai( new BT[n] );
159 const std::unique_ptr<BT[]> work( new BT[max(1,lwork)] );
160 const std::unique_ptr<blas_int_t[]> bwork( select ? new blas_int_t[n] : nullptr );
161
162 gges( 'N', 'N', ( select ? 'S' : 'N' ), select, n, (*A).data(), lda, (*B).data(), ldb, &sdim,
163 alphar.get(), alphai.get(), (*beta).data(), nullptr, 1, nullptr, 1,
164 work.get(), lwork, bwork.get(), &info );
165
166 BLAZE_INTERNAL_ASSERT( info >= 0, "Invalid argument for generalized eigenvalue decomposition" );
167
168 if( info > 0 ) {
169 BLAZE_THROW_LAPACK_ERROR( "Generalized eigenvalue decomposition failed" );
170 }
171
172 for( size_t i=0UL; i<(*A).rows(); ++i ) {
173 (*alpha)[i] = CT( alphar[i], alphai[i] );
174 }
175}
177//*************************************************************************************************
178
179
180//*************************************************************************************************
200template< typename MT1 // Type of the matrix A
201 , bool SO1 // Storage order of the matrix A
202 , typename MT2 // Type of the matrix B
203 , bool SO2 // Storage order of the matrix B
204 , typename VT1 // Type of the vector alpha
205 , bool TF1 // Transpose flag of the vector alpha
206 , typename VT2 // Type of the vector beta
207 , bool TF2 // Transpose flag of the vector beta
208 , typename Select > // Type of the eigenvalue selector
209inline auto gges_backend( DenseMatrix<MT1,SO1>& A, DenseMatrix<MT2,SO2>& B,
210 DenseVector<VT1,TF1>& alpha, DenseVector<VT2,TF2>& beta,
211 Select select )
212 -> EnableIf_t< IsComplex_v< ElementType_t<MT1> > >
213{
214 BLAZE_INTERNAL_ASSERT( isSquare( *A ), "Invalid non-square matrix detected" );
215 BLAZE_INTERNAL_ASSERT( isSquare( *B ), "Invalid non-square matrix detected" );
216 BLAZE_INTERNAL_ASSERT( (*B).rows() == (*A).rows(), "Invalid matrix dimension detected" );
217 BLAZE_INTERNAL_ASSERT( (*alpha).size() == (*A).rows(), "Invalid vector dimension detected" );
218 BLAZE_INTERNAL_ASSERT( (*beta).size() == (*A).rows(), "Invalid vector dimension detected" );
219
220 using CT = ElementType_t<VT1>;
221 using BT = typename CT::value_type;
222
225
226 const blas_int_t n ( numeric_cast<blas_int_t>( (*A).rows() ) );
227 const blas_int_t lda( numeric_cast<blas_int_t>( (*A).spacing() ) );
228 const blas_int_t ldb( numeric_cast<blas_int_t>( (*B).spacing() ) );
229 blas_int_t info( 0 );
230 blas_int_t sdim( 0 );
231
232 blas_int_t lwork = max( 1, 2*n );
233 const std::unique_ptr<CT[]> work( new CT[max(1,lwork)] );
234 const std::unique_ptr<BT[]> rwork( new BT[8*n] );
235 const std::unique_ptr<blas_int_t[]> bwork( select ? new blas_int_t[n] : nullptr );
236
237 gges( 'N', 'N', ( select ? 'S' : 'N' ), select, n, (*A).data(), lda, (*B).data(), ldb, &sdim,
238 (*alpha).data(), (*beta).data(), nullptr, 1, nullptr, 1,
239 work.get(), lwork, rwork.get(), bwork.get(), &info );
240
241 BLAZE_INTERNAL_ASSERT( info >= 0, "Invalid argument for generalized eigenvalue decomposition" );
242
243 if( info > 0 ) {
244 BLAZE_THROW_LAPACK_ERROR( "Generalized eigenvalue decomposition failed" );
245 }
246}
248//*************************************************************************************************
249
250
251//*************************************************************************************************
318template< typename MT1 // Type of the matrix A
319 , bool SO1 // Storage order of the matrix A
320 , typename MT2 // Type of the matrix B
321 , bool SO2 // Storage order of the matrix B
322 , typename VT1 // Type of the vector alpha
323 , bool TF1 // Transpose flag of the vector alpha
324 , typename VT2 // Type of the vector beta
325 , bool TF2 > // Transpose flag of the vector beta
328{
334
340
346
351
352 const size_t N( (*A).rows() );
353
354 if( !isSquare( *A ) ) {
355 BLAZE_THROW_INVALID_ARGUMENT( "Invalid non-square matrix provided" );
356 }
357
358 resize( *B, N, N, false );
359 resize( *alpha, N, false );
360 resize( *beta, N, false );
361
362 if( N == 0UL ) {
363 return;
364 }
365
366 gges_backend( *A, *B, *alpha, *beta, nullptr );
367}
368//*************************************************************************************************
369
370
371//*************************************************************************************************
451template< typename MT1 // Type of the matrix A
452 , bool SO1 // Storage order of the matrix A
453 , typename MT2 // Type of the matrix B
454 , bool SO2 // Storage order of the matrix B
455 , typename VT1 // Type of the vector alpha
456 , bool TF1 // Transpose flag of the vector alpha
457 , typename VT2 // Type of the vector beta
458 , bool TF2 // Transpose flag of the vector beta
459 , typename Select > // Type of the eigenvalue selector
462 Select select )
463{
469
475
481
486
487 const size_t N( (*A).rows() );
488
489 if( !isSquare( *A ) ) {
490 BLAZE_THROW_INVALID_ARGUMENT( "Invalid non-square matrix provided" );
491 }
492
493 resize( *B, N, N, false );
494 resize( *alpha, N, false );
495 resize( *beta, N, false );
496
497 if( N == 0UL ) {
498 return;
499 }
500
501 gges_backend( *A, *B, *alpha, *beta, select );
502}
503//*************************************************************************************************
504
505
506//*************************************************************************************************
528template< typename MT1 // Type of the matrix A
529 , bool SO1 // Storage order of the matrix A
530 , typename MT2 // Type of the matrix B
531 , bool SO2 // Storage order of the matrix B
532 , typename MT3 // Type of the matrix VSL
533 , bool SO3 // Storage order of the matrix VSL
534 , typename VT1 // Type of the vector alpha
535 , bool TF1 // Transpose flag of the vector alpha
536 , typename VT2 // Type of the vector beta
537 , bool TF2 // Transpose flag of the vector beta
538 , typename MT4 // Type of the matrix VSR
539 , bool SO4 // Storage order of the matrix VSR
540 , typename Select > // Type of the eigenvalue selector
541inline auto gges_backend( DenseMatrix<MT1,SO1>& A, DenseMatrix<MT2,SO2>& B,
542 DenseMatrix<MT3,SO3>& VSL, DenseVector<VT1,TF1>& alpha,
543 DenseVector<VT2,TF2>& beta, DenseMatrix<MT4,SO4>& VSR,
544 Select select )
545 -> DisableIf_t< IsComplex_v< ElementType_t<MT1> > >
546{
547 BLAZE_INTERNAL_ASSERT( isSquare( *A ), "Invalid non-square matrix detected" );
548 BLAZE_INTERNAL_ASSERT( isSquare( *B ), "Invalid non-square matrix detected" );
549 BLAZE_INTERNAL_ASSERT( isSquare( *VSL ), "Invalid non-square matrix detected" );
550 BLAZE_INTERNAL_ASSERT( isSquare( *VSR ), "Invalid non-square matrix detected" );
551 BLAZE_INTERNAL_ASSERT( (*B).rows() == (*A).rows(), "Invalid matrix dimension detected" );
552 BLAZE_INTERNAL_ASSERT( (*VSL).rows() == (*A).rows(), "Invalid matrix dimension detected" );
553 BLAZE_INTERNAL_ASSERT( (*VSR).rows() == (*A).rows(), "Invalid matrix dimension detected" );
554 BLAZE_INTERNAL_ASSERT( (*alpha).size() == (*A).rows(), "Invalid vector dimension detected" );
555 BLAZE_INTERNAL_ASSERT( (*beta).size() == (*A).rows(), "Invalid vector dimension detected" );
556
557 using CT = ElementType_t<VT1>;
558 using BT = ElementType_t<MT1>;
559
562
563 const blas_int_t n ( numeric_cast<blas_int_t>( (*A).rows() ) );
564 const blas_int_t lda ( numeric_cast<blas_int_t>( (*A).spacing() ) );
565 const blas_int_t ldb ( numeric_cast<blas_int_t>( (*B).spacing() ) );
566 const blas_int_t ldvsl( numeric_cast<blas_int_t>( (*VSL).spacing() ) );
567 const blas_int_t ldvsr( numeric_cast<blas_int_t>( (*VSR).spacing() ) );
568 blas_int_t info( 0 );
569 blas_int_t sdim( 0 );
570
571 blas_int_t lwork = max( 8*n, 6*n + 16 );
572 const std::unique_ptr<BT[]> alphar( new BT[n] );
573 const std::unique_ptr<BT[]> alphai( new BT[n] );
574 const std::unique_ptr<BT[]> work( new BT[max(1, lwork)] );
575 const std::unique_ptr<blas_int_t[]> bwork( select ? new blas_int_t[n] : nullptr );
576
577 gges( 'V', 'V', ( select ? 'S' : 'N' ), select, n, (*A).data(), lda, (*B).data(), ldb, &sdim,
578 alphar.get(), alphai.get(), (*beta).data(), (*VSL).data(), ldvsl, (*VSR).data(), ldvsr,
579 work.get(), lwork, bwork.get(), &info );
580
581 BLAZE_INTERNAL_ASSERT( info >= 0, "Invalid argument for generalized eigenvalue decomposition" );
582
583 if( info > 0 ) {
584 BLAZE_THROW_LAPACK_ERROR( "Generalized eigenvalue decomposition failed" );
585 }
586
587 for( size_t i=0UL; i<(*A).rows(); ++i ) {
588 (*alpha)[i] = CT( alphar[i], alphai[i] );
589 }
590}
592//*************************************************************************************************
593
594
595//*************************************************************************************************
617template< typename MT1 // Type of the matrix A
618 , bool SO1 // Storage order of the matrix A
619 , typename MT2 // Type of the matrix B
620 , bool SO2 // Storage order of the matrix B
621 , typename MT3 // Type of the matrix VSL
622 , bool SO3 // Storage order of the matrix VSL
623 , typename VT1 // Type of the vector alpha
624 , bool TF1 // Transpose flag of the vector alpha
625 , typename VT2 // Type of the vector beta
626 , bool TF2 // Transpose flag of the vector beta
627 , typename MT4 // Type of the matrix VSR
628 , bool SO4 // Storage order of the matrix VSR
629 , typename Select > // Type of the eigenvalue selector
630inline auto gges_backend( DenseMatrix<MT1,SO1>& A, DenseMatrix<MT2,SO2>& B,
631 DenseMatrix<MT3,SO3>& VSL, DenseVector<VT1,TF1>& alpha,
632 DenseVector<VT2,TF2>& beta, DenseMatrix<MT4,SO4>& VSR,
633 Select select )
634 -> EnableIf_t< IsComplex_v< ElementType_t<MT1> > >
635{
636 BLAZE_INTERNAL_ASSERT( isSquare( *A ), "Invalid non-square matrix detected" );
637 BLAZE_INTERNAL_ASSERT( isSquare( *B ), "Invalid non-square matrix detected" );
638 BLAZE_INTERNAL_ASSERT( isSquare( *VSL ), "Invalid non-square matrix detected" );
639 BLAZE_INTERNAL_ASSERT( isSquare( *VSR ), "Invalid non-square matrix detected" );
640 BLAZE_INTERNAL_ASSERT( (*B).rows() == (*A).rows(), "Invalid matrix dimension detected" );
641 BLAZE_INTERNAL_ASSERT( (*VSL).rows() == (*A).rows(), "Invalid matrix dimension detected" );
642 BLAZE_INTERNAL_ASSERT( (*VSR).rows() == (*A).rows(), "Invalid matrix dimension detected" );
643 BLAZE_INTERNAL_ASSERT( (*alpha).size() == (*A).rows(), "Invalid vector dimension detected" );
644 BLAZE_INTERNAL_ASSERT( (*beta).size() == (*A).rows(), "Invalid vector dimension detected" );
645
646 using CT = ElementType_t<VT1>;
647 using BT = typename CT::value_type;
648
651
652 const blas_int_t n ( numeric_cast<blas_int_t>( (*A).rows() ) );
653 const blas_int_t lda ( numeric_cast<blas_int_t>( (*A).spacing() ) );
654 const blas_int_t ldb ( numeric_cast<blas_int_t>( (*B).spacing() ) );
655 const blas_int_t ldvsl( numeric_cast<blas_int_t>( (*VSL).spacing() ) );
656 const blas_int_t ldvsr( numeric_cast<blas_int_t>( (*VSR).spacing() ) );
657 blas_int_t info( 0 );
658 blas_int_t sdim( 0 );
659
660 blas_int_t lwork = max( 1, 2*n );
661 const std::unique_ptr<CT[]> work( new CT[max(1,lwork)] );
662 const std::unique_ptr<BT[]> rwork( new BT[8*n] );
663 const std::unique_ptr<blas_int_t[]> bwork( select ? new blas_int_t[n] : nullptr );
664
665 gges( 'V', 'V', ( select ? 'S' : 'N' ), select, n, (*A).data(), lda, (*B).data(), ldb, &sdim,
666 (*alpha).data(), (*beta).data(), (*VSL).data(), ldvsl, (*VSR).data(), ldvsr,
667 work.get(), lwork, rwork.get(), bwork.get(), &info );
668
669 BLAZE_INTERNAL_ASSERT( info >= 0, "Invalid argument for generalized eigenvalue decomposition" );
670
671 if( info > 0 ) {
672 BLAZE_THROW_LAPACK_ERROR( "Generalized eigenvalue decomposition failed" );
673 }
674}
676//*************************************************************************************************
677
678
679//*************************************************************************************************
761template< typename MT1 // Type of the matrix A
762 , bool SO1 // Storage order of the matrix A
763 , typename MT2 // Type of the matrix B
764 , bool SO2 // Storage order of the matrix B
765 , typename MT3 // Type of the matrix VSL
766 , bool SO3 // Storage order of the matrix VSL
767 , typename VT1 // Type of the vector alpha
768 , bool TF1 // Transpose flag of the vector alpha
769 , typename VT2 // Type of the vector beta
770 , bool TF2 // Transpose flag of the vector beta
771 , typename MT4 // Type of the matrix VSR
772 , bool SO4 > // Storage order of the matrix VSR
776{
782
788
794
800
805
811
812 const size_t N( (*A).rows() );
813
814 if( !isSquare( *A ) ) {
815 BLAZE_THROW_INVALID_ARGUMENT( "Invalid non-square matrix provided" );
816 }
817
818 if( (*A).rows() != (*B).rows() || (*A).columns() != (*B).columns() ) {
819 BLAZE_THROW_INVALID_ARGUMENT( "Matrix sizes do not match" );
820 }
821
822 resize( *VSL, N, N, false );
823 resize( *alpha, N, false );
824 resize( *beta, N, false );
825 resize( *VSR, N, N, false );
826
827 if( N == 0UL ) {
828 return;
829 }
830
831 gges_backend( *A, *B, *VSL, *alpha, *beta, *VSR, nullptr );
832}
833//*************************************************************************************************
834
835
836//*************************************************************************************************
932template< typename MT1 // Type of the matrix A
933 , bool SO1 // Storage order of the matrix A
934 , typename MT2 // Type of the matrix B
935 , bool SO2 // Storage order of the matrix B
936 , typename MT3 // Type of the matrix VSL
937 , bool SO3 // Storage order of the matrix VSL
938 , typename VT1 // Type of the vector alpha
939 , bool TF1 // Transpose flag of the vector alpha
940 , typename VT2 // Type of the vector beta
941 , bool TF2 // Transpose flag of the vector beta
942 , typename MT4 // Type of the matrix VSR
943 , bool SO4 // Storage order of the matrix VSR
944 , typename Select > // Type of the eigenvalue selector
948 Select select )
949{
955
961
967
973
978
984
985 const size_t N( (*A).rows() );
986
987 if( !isSquare( *A ) ) {
988 BLAZE_THROW_INVALID_ARGUMENT( "Invalid non-square matrix provided" );
989 }
990
991 resize( *B, N, N, false );
992 resize( *VSL, N, N, false );
993 resize( *alpha, N, false );
994 resize( *beta, N, false );
995 resize( *VSR, N, N, false );
996
997 if( N == 0UL ) {
998 return;
999 }
1000
1001 gges_backend( *A, *B, *VSL, *alpha, *beta, *VSR, select );
1002}
1003//*************************************************************************************************
1004
1005} // namespace blaze
1006
1007#endif
Constraint on the data type.
Header file for auxiliary alias declarations.
typename T::ElementType ElementType_t
Alias declaration for nested ElementType type definitions.
Definition: Aliases.h:190
Header file for run time assertion macros.
Constraint on the data type.
Constraint on the data type.
Header file for the complex data type.
Constraint on the data type.
Header file for the EnableIf class template.
Header file for the IsComplex type trait.
Deactivation of problematic macros.
Constraint on the data type.
Cast operators for numeric types.
Header file for the CLAPACK gges wrapper functions.
Base class for dense matrices.
Definition: DenseMatrix.h:82
Base class for N-dimensional dense vectors.
Definition: DenseVector.h:77
Constraint on the data type.
Constraint on the data type.
Header file for the DenseMatrix base class.
Header file for the DenseVector base class.
#define BLAZE_CONSTRAINT_MUST_BE_BUILTIN_TYPE(T)
Constraint on the data type.
Definition: Builtin.h:60
#define BLAZE_CONSTRAINT_MUST_BE_COMPLEX_TYPE(T)
Constraint on the data type.
Definition: Complex.h:62
decltype(auto) max(const DenseMatrix< MT1, SO1 > &lhs, const DenseMatrix< MT2, SO2 > &rhs)
Computes the componentwise maximum of the dense matrices lhs and rhs.
Definition: DMatDMatMapExpr.h:1375
decltype(auto) select(const DenseMatrix< MT1, SO > &cond, const DenseMatrix< MT2, SO > &lhs, const DenseMatrix< MT3, SO > &rhs)
Elementwise conditional selection of values from the dense matrices lhs and rhs.
Definition: DMatDMatMapExpr.h:1528
void gges(DenseMatrix< MT1, SO1 > &A, DenseMatrix< MT2, SO2 > &B, DenseMatrix< MT3, SO3 > &VSL, DenseVector< VT1, TF1 > &alpha, DenseVector< VT2, TF2 > &beta, DenseMatrix< MT4, SO4 > &VSR, Select select)
LAPACK kernel for computing the generalized Schur factorization of the given pair of dense general ma...
Definition: gges.h:945
#define BLAZE_CONSTRAINT_MUST_BE_BLAS_COMPATIBLE_TYPE(T)
Constraint on the data type.
Definition: BLASCompatible.h:61
#define BLAZE_CONSTRAINT_MUST_BE_CONTIGUOUS_TYPE(T)
Constraint on the data type.
Definition: Contiguous.h:61
#define BLAZE_CONSTRAINT_MUST_NOT_BE_COMPUTATION_TYPE(T)
Constraint on the data type.
Definition: Computation.h:81
#define BLAZE_CONSTRAINT_MUST_NOT_BE_ADAPTOR_TYPE(T)
Constraint on the data type.
Definition: Adaptor.h:81
#define BLAZE_CONSTRAINT_MUST_HAVE_MUTABLE_DATA_ACCESS(T)
Constraint on the data type.
Definition: MutableDataAccess.h:61
int32_t blas_int_t
Signed integer type used in the BLAS/LAPACK wrapper functions.
Definition: Types.h:64
#define BLAZE_THROW_LAPACK_ERROR(MESSAGE)
Macro for the emission of an exception on detection of a LAPACK error.
Definition: Exception.h:146
void resize(Matrix< MT, SO > &matrix, size_t rows, size_t columns, bool preserve=true)
Changing the size of the matrix.
Definition: Matrix.h:1108
bool isSquare(const Matrix< MT, SO > &matrix) noexcept
Checks if the given matrix is a square matrix.
Definition: Matrix.h:1383
#define BLAZE_INTERNAL_ASSERT(expr, msg)
Run time assertion macro for internal checks.
Definition: Assert.h:101
#define BLAZE_THROW_INVALID_ARGUMENT(MESSAGE)
Macro for the emission of a std::invalid_argument exception.
Definition: Exception.h:235
Header file for the exception macros of the math module.
Header file for the equal shim.
Header file for the generic max algorithm.