Blaze 3.9
Loading...
Searching...
No Matches
DenseMatrixProxy.h
Go to the documentation of this file.
1//=================================================================================================
33//=================================================================================================
34
35#ifndef _BLAZE_MATH_PROXY_DENSEMATRIXPROXY_H_
36#define _BLAZE_MATH_PROXY_DENSEMATRIXPROXY_H_
37
38
39//*************************************************************************************************
40// Includes
41//*************************************************************************************************
42
43#include <blaze/math/Aliases.h>
52#include <blaze/system/Inline.h>
53#include <blaze/util/EnableIf.h>
55#include <blaze/util/Types.h>
56
57
58namespace blaze {
59
60//=================================================================================================
61//
62// CLASS DEFINITION
63//
64//=================================================================================================
65
66//*************************************************************************************************
74template< typename PT // Type of the proxy
75 , typename MT > // Type of the dense matrix
76class DenseMatrixProxy
77 : public DenseMatrix< PT, IsColumnMajorMatrix_v<MT> >
78{
79 public:
80 //**Type definitions****************************************************************************
93 //**********************************************************************************************
94
95 //**Compilation flags***************************************************************************
97 static constexpr bool simdEnabled = MT::simdEnabled;
98
100 static constexpr bool smpAssignable = MT::smpAssignable;
101 //**********************************************************************************************
102
103 //**Data access functions***********************************************************************
106 inline Reference operator()( size_t i, size_t j ) const;
107 inline Reference at( size_t i, size_t j ) const;
108
109 inline Pointer data () const;
110 inline Pointer data ( size_t i ) const;
111 inline Iterator begin ( size_t i ) const;
112 inline ConstIterator cbegin( size_t i ) const;
113 inline Iterator end ( size_t i ) const;
114 inline ConstIterator cend ( size_t i ) const;
116 //**********************************************************************************************
117
118 //**Utility functions***************************************************************************
121 inline size_t rows() const;
122 inline size_t columns() const;
123 inline size_t spacing() const;
124 inline size_t capacity() const;
125 inline size_t capacity( size_t i ) const;
126 inline size_t nonZeros() const;
127 inline size_t nonZeros( size_t i ) const;
128 inline void reset() const;
129 inline void reset( size_t i ) const;
130 inline void clear() const;
131 inline void resize( size_t m, size_t n, bool preserve=true ) const;
132 inline void extend( size_t m, size_t n, bool preserve=true ) const;
133 inline void reserve( size_t n ) const;
135 //**********************************************************************************************
136
137 //**Numeric functions***************************************************************************
140 inline void transpose() const;
141 inline void ctranspose() const;
142
143 template< typename Other > inline void scale( const Other& scalar ) const;
145 //**********************************************************************************************
146
147 protected:
148 //**Special member functions********************************************************************
151 DenseMatrixProxy() = default;
152 DenseMatrixProxy( const DenseMatrixProxy& ) = default;
153 DenseMatrixProxy( DenseMatrixProxy&& ) = default;
154 ~DenseMatrixProxy() = default;
155 DenseMatrixProxy& operator=( const DenseMatrixProxy& ) = default;
156 DenseMatrixProxy& operator=( DenseMatrixProxy&& ) = default;
158 //**********************************************************************************************
159
160 private:
161 //**Compile time checks*************************************************************************
165 //**********************************************************************************************
166};
167//*************************************************************************************************
168
169
170
171
172//=================================================================================================
173//
174// DATA ACCESS FUNCTIONS
175//
176//=================================================================================================
177
178//*************************************************************************************************
186template< typename PT // Type of the proxy
187 , typename MT > // Type of the dense matrix
189 DenseMatrixProxy<PT,MT>::operator()( size_t i, size_t j ) const
190{
191 if( (**this).isRestricted() ) {
192 BLAZE_THROW_INVALID_ARGUMENT( "Invalid access to restricted element" );
193 }
194
195 return (**this).get()(i,j);
196}
197//*************************************************************************************************
198
199
200//*************************************************************************************************
212template< typename PT // Type of the proxy
213 , typename MT > // Type of the dense matrix
215 DenseMatrixProxy<PT,MT>::at( size_t i, size_t j ) const
216{
217 if( (**this).isRestricted() ) {
218 BLAZE_THROW_INVALID_ARGUMENT( "Invalid access to restricted element" );
219 }
220
221 return (**this).get().at(i,j);
222}
223//*************************************************************************************************
224
225
226//*************************************************************************************************
238template< typename PT // Type of the proxy
239 , typename MT > // Type of the dense matrix
241{
242 if( (**this).isRestricted() ) {
243 BLAZE_THROW_INVALID_ARGUMENT( "Invalid access to restricted element" );
244 }
245
246 return (**this).get().data();
247}
248//*************************************************************************************************
249
250
251//*************************************************************************************************
259template< typename PT // Type of the proxy
260 , typename MT > // Type of the dense matrix
262{
263 if( (**this).isRestricted() ) {
264 BLAZE_THROW_INVALID_ARGUMENT( "Invalid access to restricted element" );
265 }
266
267 return (**this).get().data(i);
268}
269//*************************************************************************************************
270
271
272//*************************************************************************************************
284template< typename PT // Type of the proxy
285 , typename MT > // Type of the dense matrix
288{
289 if( (**this).isRestricted() ) {
290 BLAZE_THROW_INVALID_ARGUMENT( "Invalid access to restricted element" );
291 }
292
293 return (**this).get().begin(i);
294}
295//*************************************************************************************************
296
297
298//*************************************************************************************************
309template< typename PT // Type of the proxy
310 , typename MT > // Type of the dense matrix
313{
314 return (**this).get().cbegin(i);
315}
316//*************************************************************************************************
317
318
319//*************************************************************************************************
331template< typename PT // Type of the proxy
332 , typename MT > // Type of the dense matrix
335{
336 if( (**this).isRestricted() ) {
337 BLAZE_THROW_INVALID_ARGUMENT( "Invalid access to restricted element" );
338 }
339
340 return (**this).get().end(i);
341}
342//*************************************************************************************************
343
344
345//*************************************************************************************************
356template< typename PT // Type of the proxy
357 , typename MT > // Type of the dense matrix
360{
361 return (**this).get().cend(i);
362}
363//*************************************************************************************************
364
365
366
367
368//=================================================================================================
369//
370// UTILITY FUNCTIONS
371//
372//=================================================================================================
373
374//*************************************************************************************************
379template< typename PT // Type of the proxy
380 , typename MT > // Type of the dense matrix
381inline size_t DenseMatrixProxy<PT,MT>::rows() const
382{
383 return (**this).get().rows();
384}
385//*************************************************************************************************
386
387
388//*************************************************************************************************
393template< typename PT // Type of the proxy
394 , typename MT > // Type of the dense matrix
396{
397 return (**this).get().columns();
398}
399//*************************************************************************************************
400
401
402//*************************************************************************************************
412template< typename PT // Type of the proxy
413 , typename MT > // Type of the dense matrix
415{
416 return (**this).get().spacing();
417}
418//*************************************************************************************************
419
420
421//*************************************************************************************************
426template< typename PT // Type of the proxy
427 , typename MT > // Type of the dense matrix
429{
430 return (**this).get().capacity();
431}
432//*************************************************************************************************
433
434
435//*************************************************************************************************
446template< typename PT // Type of the proxy
447 , typename MT > // Type of the dense matrix
448inline size_t DenseMatrixProxy<PT,MT>::capacity( size_t i ) const
449{
450 return (**this).get().capacity(i);
451}
452//*************************************************************************************************
453
454
455//*************************************************************************************************
460template< typename PT // Type of the proxy
461 , typename MT > // Type of the dense matrix
463{
464 return (**this).get().nonZeros();
465}
466//*************************************************************************************************
467
468
469//*************************************************************************************************
480template< typename PT // Type of the proxy
481 , typename MT > // Type of the dense matrix
482inline size_t DenseMatrixProxy<PT,MT>::nonZeros( size_t i ) const
483{
484 return (**this).get().nonZeros(i);
485}
486//*************************************************************************************************
487
488
489//*************************************************************************************************
496template< typename PT // Type of the proxy
497 , typename MT > // Type of the dense matrix
499{
500 using blaze::reset;
501
502 reset( (**this).get() );
503}
504//*************************************************************************************************
505
506
507//*************************************************************************************************
518template< typename PT // Type of the proxy
519 , typename MT > // Type of the dense matrix
520inline void DenseMatrixProxy<PT,MT>::reset( size_t i ) const
521{
522 using blaze::reset;
523
524 reset( (**this).get(), i );
525}
526//*************************************************************************************************
527
528
529//*************************************************************************************************
536template< typename PT // Type of the proxy
537 , typename MT > // Type of the dense matrix
539{
540 using blaze::clear;
541
542 clear( (**this).get() );
543}
544//*************************************************************************************************
545
546
547//*************************************************************************************************
564template< typename PT // Type of the proxy
565 , typename MT > // Type of the dense matrix
566inline void DenseMatrixProxy<PT,MT>::resize( size_t m, size_t n, bool preserve ) const
567{
568 if( (**this).isRestricted() ) {
569 BLAZE_THROW_INVALID_ARGUMENT( "Invalid access to restricted element" );
570 }
571
572 (**this).get().resize( m, n, preserve );
573}
574//*************************************************************************************************
575
576
577//*************************************************************************************************
593template< typename PT // Type of the proxy
594 , typename MT > // Type of the dense matrix
595inline void DenseMatrixProxy<PT,MT>::extend( size_t m, size_t n, bool preserve ) const
596{
597 if( (**this).isRestricted() ) {
598 BLAZE_THROW_INVALID_ARGUMENT( "Invalid access to restricted element" );
599 }
600
601 (**this).get().extend( m, n, preserve );
602}
603//*************************************************************************************************
604
605
606//*************************************************************************************************
616template< typename PT // Type of the proxy
617 , typename MT > // Type of the dense matrix
618inline void DenseMatrixProxy<PT,MT>::reserve( size_t n ) const
619{
620 if( (**this).isRestricted() ) {
621 BLAZE_THROW_INVALID_ARGUMENT( "Invalid access to restricted element" );
622 }
623
624 (**this).get().reserve( n );
625}
626//*************************************************************************************************
627
628
629//*************************************************************************************************
635template< typename PT // Type of the proxy
636 , typename MT > // Type of the dense matrix
638{
639 if( (**this).isRestricted() ) {
640 BLAZE_THROW_INVALID_ARGUMENT( "Invalid access to restricted element" );
641 }
642
643 (**this).get().transpose();
644}
645//*************************************************************************************************
646
647
648//*************************************************************************************************
654template< typename PT // Type of the proxy
655 , typename MT > // Type of the dense matrix
657{
658 if( (**this).isRestricted() ) {
659 BLAZE_THROW_INVALID_ARGUMENT( "Invalid access to restricted element" );
660 }
661
662 (**this).get().ctranspose();
663}
664//*************************************************************************************************
665
666
667//*************************************************************************************************
678template< typename PT // Type of the proxy
679 , typename MT > // Type of the dense matrix
680template< typename Other > // Data type of the scalar value
681inline void DenseMatrixProxy<PT,MT>::scale( const Other& scalar ) const
682{
683 if( (**this).isRestricted() ) {
684 BLAZE_THROW_INVALID_ARGUMENT( "Invalid access to restricted element" );
685 }
686
687 (**this).get().scale( scalar );
688}
689//*************************************************************************************************
690
691
692
693
694//=================================================================================================
695//
696// GLOBAL FUNCTIONS
697//
698//=================================================================================================
699
700//*************************************************************************************************
703template< typename PT, typename MT >
705 begin( const DenseMatrixProxy<PT,MT>& proxy, size_t i );
706
707template< typename PT, typename MT >
709 cbegin( const DenseMatrixProxy<PT,MT>& proxy, size_t i );
710
711template< typename PT, typename MT >
713 end( const DenseMatrixProxy<PT,MT>& proxy, size_t i );
714
715template< typename PT, typename MT >
717 cend( const DenseMatrixProxy<PT,MT>& proxy, size_t i );
718
719template< typename PT, typename MT >
720size_t rows( const DenseMatrixProxy<PT,MT>& proxy );
721
722template< typename PT, typename MT >
723size_t columns( const DenseMatrixProxy<PT,MT>& proxy );
724
725template< typename PT, typename MT >
726size_t capacity( const DenseMatrixProxy<PT,MT>& proxy );
727
728template< typename PT, typename MT >
729size_t capacity( const DenseMatrixProxy<PT,MT>& proxy, size_t i );
730
731template< typename PT, typename MT >
732size_t nonZeros( const DenseMatrixProxy<PT,MT>& proxy );
733
734template< typename PT, typename MT >
735size_t nonZeros( const DenseMatrixProxy<PT,MT>& proxy, size_t i );
736
737template< typename PT, typename MT >
738void resize( const DenseMatrixProxy<PT,MT>& proxy, size_t m, size_t n, bool preserve=true );
740//*************************************************************************************************
741
742
743//*************************************************************************************************
756template< typename PT // Type of the proxy
757 , typename MT > // Type of the dense matrix
759 begin( const DenseMatrixProxy<PT,MT>& proxy, size_t i )
760{
761 return proxy.begin(i);
762}
763//*************************************************************************************************
764
765
766//*************************************************************************************************
779template< typename PT // Type of the proxy
780 , typename MT > // Type of the dense matrix
782 cbegin( const DenseMatrixProxy<PT,MT>& proxy, size_t i )
783{
784 return proxy.cbegin(i);
785}
786//*************************************************************************************************
787
788
789//*************************************************************************************************
803template< typename PT // Type of the proxy
804 , typename MT > // Type of the dense matrix
806 end( const DenseMatrixProxy<PT,MT>& proxy, size_t i )
807{
808 return proxy.end(i);
809}
810//*************************************************************************************************
811
812
813//*************************************************************************************************
827template< typename PT // Type of the proxy
828 , typename MT > // Type of the dense matrix
830 cend( const DenseMatrixProxy<PT,MT>& proxy, size_t i )
831{
832 return proxy.cend(i);
833}
834//*************************************************************************************************
835
836
837//*************************************************************************************************
844template< typename PT // Type of the proxy
845 , typename MT > // Type of the dense matrix
847{
848 return proxy.rows();
849}
850//*************************************************************************************************
851
852
853//*************************************************************************************************
860template< typename PT // Type of the proxy
861 , typename MT > // Type of the dense matrix
863{
864 return proxy.columns();
865}
866//*************************************************************************************************
867
868
869//*************************************************************************************************
876template< typename PT // Type of the proxy
877 , typename MT > // Type of the dense matrix
879{
880 return proxy.capacity();
881}
882//*************************************************************************************************
883
884
885//*************************************************************************************************
898template< typename PT // Type of the proxy
899 , typename MT > // Type of the dense matrix
901{
902 return proxy.capacity(i);
903}
904//*************************************************************************************************
905
906
907//*************************************************************************************************
914template< typename PT // Type of the proxy
915 , typename MT > // Type of the dense matrix
917{
918 return proxy.nonZeros();
919}
920//*************************************************************************************************
921
922
923//*************************************************************************************************
936template< typename PT // Type of the proxy
937 , typename MT > // Type of the dense matrix
939{
940 return proxy.nonZeros(i);
941}
942//*************************************************************************************************
943
944
945//*************************************************************************************************
962template< typename PT // Type of the proxy
963 , typename MT > // Type of the dense matrix
965 resize_backend( const DenseMatrixProxy<PT,MT>& proxy, size_t m, size_t n, bool preserve )
966{
967 MAYBE_UNUSED( preserve );
968
969 if( proxy.rows() != m || proxy.columns() != n ) {
970 BLAZE_THROW_INVALID_ARGUMENT( "Matrix cannot be resized" );
971 }
972}
974//*************************************************************************************************
975
976
977//*************************************************************************************************
990template< typename PT // Type of the proxy
991 , typename MT > // Type of the dense matrix
993 resize_backend( const DenseMatrixProxy<PT,MT>& proxy, size_t m, size_t n, bool preserve )
994{
995 proxy.resize( m, n, preserve );
996}
998//*************************************************************************************************
999
1000
1001//*************************************************************************************************
1015template< typename PT // Type of the proxy
1016 , typename MT > // Type of the dense matrix
1018 resize_backend( const DenseMatrixProxy<PT,MT>& proxy, size_t m, size_t n, bool preserve )
1019{
1020 if( m != n ) {
1021 BLAZE_THROW_INVALID_ARGUMENT( "Invalid resize arguments for square matrix" );
1022 }
1023
1024 proxy.resize( m, preserve );
1025}
1027//*************************************************************************************************
1028
1029
1030//*************************************************************************************************
1055template< typename PT // Type of the proxy
1056 , typename MT > // Type of the dense matrix
1057BLAZE_ALWAYS_INLINE void resize( const DenseMatrixProxy<PT,MT>& proxy, size_t m, size_t n, bool preserve )
1058{
1059 resize_backend( proxy, m, n, preserve );
1060}
1061//*************************************************************************************************
1062
1063} // namespace blaze
1064
1065#endif
Header file for auxiliary alias declarations.
typename T::ReturnType ReturnType_t
Alias declaration for nested ReturnType type definitions.
Definition Aliases.h:470
typename T::ConstPointer ConstPointer_t
Alias declaration for nested ConstPointer type definitions.
Definition Aliases.h:150
typename T::ConstReference ConstReference_t
Alias declaration for nested ConstReference type definitions.
Definition Aliases.h:170
typename T::OppositeType OppositeType_t
Alias declaration for nested OppositeType type definitions.
Definition Aliases.h:310
typename T::ConstIterator ConstIterator_t
Alias declaration for nested ConstIterator type definitions.
Definition Aliases.h:130
typename T::Reference Reference_t
Alias declaration for nested Reference type definitions.
Definition Aliases.h:390
typename T::Iterator Iterator_t
Alias declaration for nested Iterator type definitions.
Definition Aliases.h:210
typename T::CompositeType CompositeType_t
Alias declaration for nested CompositeType type definitions.
Definition Aliases.h:110
typename T::TransposeType TransposeType_t
Alias declaration for nested TransposeType type definitions.
Definition Aliases.h:550
typename T::ElementType ElementType_t
Alias declaration for nested ElementType type definitions.
Definition Aliases.h:190
typename T::ResultType ResultType_t
Alias declaration for nested ResultType type definitions.
Definition Aliases.h:450
typename T::Pointer Pointer_t
Alias declaration for nested Pointer type definitions.
Definition Aliases.h:330
Header file for the EnableIf class template.
Header file for the IsColumnMajorMatrix type trait.
Header file for the IsResizable type trait.
Header file for the IsSquare type trait.
Header file for the MAYBE_UNUSED function template.
Proxy backend for dense matrix types.
Definition DenseMatrixProxy.h:78
ElementType_t< MT > ElementType
Type of the matrix elements.
Definition DenseMatrixProxy.h:84
void clear() const
Clearing the represented matrix.
Definition DenseMatrixProxy.h:538
size_t columns() const
Returns the current number of columns of the represented matrix.
Definition DenseMatrixProxy.h:395
Iterator end(size_t i) const
Returns an iterator just past the last element of row/column i of the represented matrix.
Definition DenseMatrixProxy.h:334
TransposeType_t< MT > TransposeType
Transpose type for expression template evaluations.
Definition DenseMatrixProxy.h:83
ResultType_t< MT > ResultType
Result type for expression template evaluations.
Definition DenseMatrixProxy.h:81
void reset() const
Reset to the default initial value.
Definition DenseMatrixProxy.h:498
void extend(size_t m, size_t n, bool preserve=true) const
Extending the size of the represented matrix.
Definition DenseMatrixProxy.h:595
Pointer data() const
Low-level data access to matrix elements.
Definition DenseMatrixProxy.h:240
size_t rows() const
Returns the current number of rows of the represented matrix.
Definition DenseMatrixProxy.h:381
Pointer_t< MT > Pointer
Pointer to a non-constant matrix value.
Definition DenseMatrixProxy.h:89
void reserve(size_t n) const
Setting the minimum capacity of the represented matrix.
Definition DenseMatrixProxy.h:618
Reference_t< MT > Reference
Reference to a non-constant matrix value.
Definition DenseMatrixProxy.h:87
static constexpr bool simdEnabled
Compilation flag for SIMD optimization.
Definition DenseMatrixProxy.h:97
Reference at(size_t i, size_t j) const
Checked access to the matrix elements.
Definition DenseMatrixProxy.h:215
void transpose() const
In-place transpose of the represented matrix.
Definition DenseMatrixProxy.h:637
ConstIterator cend(size_t i) const
Returns an iterator just past the last element of row/column i of the represented matrix.
Definition DenseMatrixProxy.h:359
static constexpr bool smpAssignable
Compilation flag for SMP assignments.
Definition DenseMatrixProxy.h:100
size_t spacing() const
Returns the spacing between the beginning of two rows/columns of the represented matrix.
Definition DenseMatrixProxy.h:414
Iterator begin(size_t i) const
Returns an iterator to the first element of row/column i of the represented matrix.
Definition DenseMatrixProxy.h:287
ConstIterator_t< MT > ConstIterator
Iterator over constant elements.
Definition DenseMatrixProxy.h:92
CompositeType_t< MT > CompositeType
Data type for composite expression templates.
Definition DenseMatrixProxy.h:86
Reference operator()(size_t i, size_t j) const
Function call operator for the direct access to matrix elements.
Definition DenseMatrixProxy.h:189
Iterator_t< MT > Iterator
Iterator over non-constant elements.
Definition DenseMatrixProxy.h:91
ConstPointer_t< MT > ConstPointer
Pointer to a constant matrix value.
Definition DenseMatrixProxy.h:90
void scale(const Other &scalar) const
Scaling of the matrix by the scalar value scalar ( ).
Definition DenseMatrixProxy.h:681
void resize(size_t m, size_t n, bool preserve=true) const
Changing the size of the represented matrix.
Definition DenseMatrixProxy.h:566
size_t nonZeros() const
Returns the number of non-zero elements in the represented matrix.
Definition DenseMatrixProxy.h:462
size_t capacity() const
Returns the maximum capacity of the represented matrix.
Definition DenseMatrixProxy.h:428
ReturnType_t< MT > ReturnType
Return type for expression template evaluations.
Definition DenseMatrixProxy.h:85
ConstReference_t< MT > ConstReference
Reference to a constant matrix value.
Definition DenseMatrixProxy.h:88
void ctranspose() const
In-place conjugate transpose of the represented matrix.
Definition DenseMatrixProxy.h:656
OppositeType_t< MT > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition DenseMatrixProxy.h:82
ConstIterator cbegin(size_t i) const
Returns an iterator to the first element of row/column i of the represented matrix.
Definition DenseMatrixProxy.h:312
Constraint on the data type.
Header file for the DenseMatrix base class.
#define BLAZE_CONSTRAINT_MUST_BE_DENSE_MATRIX_TYPE(T)
Constraint on the data type.
Definition DenseMatrix.h:61
constexpr bool IsSquare_v
Auxiliary variable template for the IsSquare type trait.
Definition IsSquare.h:146
constexpr void clear(Matrix< MT, SO > &matrix)
Clearing the given matrix.
Definition Matrix.h:960
MT::ConstIterator cend(const Matrix< MT, SO > &matrix, size_t i)
Returns an iterator just past the last element of row/column i.
Definition Matrix.h:628
constexpr size_t rows(const Matrix< MT, SO > &matrix) noexcept
Returns the current number of rows of the matrix.
Definition Matrix.h:644
size_t nonZeros(const Matrix< MT, SO > &matrix)
Returns the total number of non-zero elements in the matrix.
Definition Matrix.h:730
MT::ConstIterator cbegin(const Matrix< MT, SO > &matrix, size_t i)
Returns an iterator to the first element of row/column i.
Definition Matrix.h:562
size_t capacity(const Matrix< MT, SO > &matrix) noexcept
Returns the maximum capacity of the matrix.
Definition Matrix.h:692
constexpr void reset(Matrix< MT, SO > &matrix)
Resetting the given matrix.
Definition Matrix.h:806
constexpr size_t columns(const Matrix< MT, SO > &matrix) noexcept
Returns the current number of columns of the matrix.
Definition Matrix.h:660
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
MT::Iterator end(Matrix< MT, SO > &matrix, size_t i)
Returns an iterator just past the last element of row/column i.
Definition Matrix.h:584
MT::Iterator begin(Matrix< MT, SO > &matrix, size_t i)
Returns an iterator to the first element of row/column i.
Definition Matrix.h:518
#define BLAZE_ALWAYS_INLINE
Platform dependent setup of an enforced inline keyword.
Definition Inline.h:85
constexpr void MAYBE_UNUSED(const Args &...)
Suppression of unused parameter warnings.
Definition MaybeUnused.h:81
typename EnableIf< Condition, T >::Type EnableIf_t
Auxiliary type for the EnableIf class template.
Definition EnableIf.h:138
#define BLAZE_THROW_INVALID_ARGUMENT(MESSAGE)
Macro for the emission of a std::invalid_argument exception.
Definition Exception.h:235
typename EnableIf<!Condition, T >::Type DisableIf_t
Auxiliary type for the EnableIf class template.
Definition EnableIf.h:175
Header file for the exception macros of the math module.
Header file for the clear shim.
Header file for the reset shim.
System settings for the inline keywords.
Header file for basic type definitions.