InitializerMatrix.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_DENSE_INITIALIZERMATRIX_H_
36 #define _BLAZE_MATH_DENSE_INITIALIZERMATRIX_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <algorithm>
44 #include <iterator>
46 #include <blaze/math/Exception.h>
48 #include <blaze/math/Forward.h>
60 #include <blaze/util/Assert.h>
65 #include <blaze/util/TrueType.h>
66 #include <blaze/util/Types.h>
67 #include <blaze/util/Unused.h>
68 
69 
70 namespace blaze {
71 
72 //=================================================================================================
73 //
74 // CLASS DEFINITION
75 //
76 //=================================================================================================
77 
78 //*************************************************************************************************
181 template< typename Type > // Data type of the matrix
183  : public DenseMatrix< InitializerMatrix<Type>, false >
184 {
185  public:
186  //**Type definitions****************************************************************************
192  using ElementType = Type;
193  using ReturnType = const Type&;
194  using CompositeType = const This&;
195 
196  using Reference = const Type&;
197  using ConstReference = const Type&;
198  using Pointer = const Type*;
199  using ConstPointer = const Type*;
200 
203  //**********************************************************************************************
204 
205  //**Rebind struct definition********************************************************************
208  template< typename NewType > // Data type of the other matrix
209  struct Rebind {
211  };
212  //**********************************************************************************************
213 
214  //**Resize struct definition********************************************************************
217  template< size_t NewM // Number of rows of the other matrix
218  , size_t NewN > // Number of columns of the other matrix
219  struct Resize {
221  };
222  //**********************************************************************************************
223 
224  //**Compilation flags***************************************************************************
226 
230  enum : bool { simdEnabled = false };
231 
233 
236  enum : bool { smpAssignable = false };
237  //**********************************************************************************************
238 
239  //**Constructors********************************************************************************
242  explicit inline InitializerMatrix( initializer_list< initializer_list<Type> > list ) noexcept;
243  explicit inline InitializerMatrix( initializer_list< initializer_list<Type> > list, size_t n );
244  // No explicitly declared copy constructor.
246  //**********************************************************************************************
247 
248  //**Destructor**********************************************************************************
249  // No explicitly declared destructor.
250  //**********************************************************************************************
251 
252  //**Data access functions***********************************************************************
255  inline ConstReference operator()( size_t i, size_t j ) const noexcept;
256  inline ConstReference at( size_t i, size_t j ) const;
257  inline ConstPointer data () const noexcept;
258  inline ConstPointer data ( size_t i ) const noexcept;
259  inline ConstIterator begin ( size_t i ) const noexcept;
260  inline ConstIterator cbegin( size_t i ) const noexcept;
261  inline ConstIterator end ( size_t i ) const noexcept;
262  inline ConstIterator cend ( size_t i ) const noexcept;
264  //**********************************************************************************************
265 
266  //**Assignment operators************************************************************************
269  InitializerMatrix( const InitializerMatrix& ) = delete;
271  //**********************************************************************************************
272 
273  //**Utility functions***************************************************************************
276  inline size_t rows() const noexcept;
277  inline size_t columns() const noexcept;
278  inline size_t spacing() const noexcept;
279  inline size_t capacity() const noexcept;
280  inline size_t capacity( size_t i ) const noexcept;
281  inline size_t nonZeros() const;
282  inline size_t nonZeros( size_t i ) const;
283  inline void swap( InitializerMatrix& m ) noexcept;
285  //**********************************************************************************************
286 
287  //**Expression template evaluation functions****************************************************
290  template< typename Other > inline bool canAlias ( const Other* alias ) const noexcept;
291  template< typename Other > inline bool isAliased( const Other* alias ) const noexcept;
293  //**********************************************************************************************
294 
295  private:
296  //**Type definitions****************************************************************************
298  //**********************************************************************************************
299 
300  //**Member variables****************************************************************************
303  size_t m_;
304  size_t n_;
306 
315  static const Type zero_;
316 
317  //**********************************************************************************************
318 
319  //**Compile time checks*************************************************************************
326  //**********************************************************************************************
327 };
328 //*************************************************************************************************
329 
330 
331 
332 
333 //=================================================================================================
334 //
335 // DEFINITION AND INITIALIZATION OF THE STATIC MEMBER VARIABLES
336 //
337 //=================================================================================================
338 
339 template< typename Type > // Data type of the matrix
340 const Type InitializerMatrix<Type>::zero_{};
341 
342 
343 
344 
345 //=================================================================================================
346 //
347 // CONSTRUCTORS
348 //
349 //=================================================================================================
350 
351 //*************************************************************************************************
356 template< typename Type > // Data type of the matrix
358  : m_ ( list.size() ) // The current number of rows of the matrix
359  , n_ ( determineColumns( list ) ) // The current number of columns of the matrix
360  , list_( list ) // The initializer list represented by the matrix
361 {}
362 //*************************************************************************************************
363 
364 
365 //*************************************************************************************************
372 template< typename Type > // Data type of the matrix
374  : m_ ( list.size() ) // The current number of rows of the matrix
375  , n_ ( n ) // The current number of columns of the matrix
376  , list_( list ) // The initializer list represented by the matrix
377 {
378  if( n < determineColumns( list ) ) {
379  BLAZE_THROW_INVALID_ARGUMENT( "Invalid initializer list dimension" );
380  }
381 }
382 //*************************************************************************************************
383 
384 
385 
386 
387 //=================================================================================================
388 //
389 // DATA ACCESS FUNCTIONS
390 //
391 //=================================================================================================
392 
393 //*************************************************************************************************
403 template< typename Type > // Data type of the matrix
405  InitializerMatrix<Type>::operator()( size_t i, size_t j ) const noexcept
406 {
407  BLAZE_USER_ASSERT( i<m_, "Invalid row access index" );
408  BLAZE_USER_ASSERT( j<n_, "Invalid column access index" );
409 
410  const initializer_list<Type>& list( list_.begin()[i] );
411 
412  if( j < list.size() )
413  return list.begin()[j];
414  else
415  return zero_;
416 }
417 //*************************************************************************************************
418 
419 
420 //*************************************************************************************************
431 template< typename Type > // Data type of the matrix
433  InitializerMatrix<Type>::at( size_t i, size_t j ) const
434 {
435  if( i >= m_ ) {
436  BLAZE_THROW_OUT_OF_RANGE( "Invalid row access index" );
437  }
438  if( j >= n_ ) {
439  BLAZE_THROW_OUT_OF_RANGE( "Invalid column access index" );
440  }
441  return (*this)(i,j);
442 }
443 //*************************************************************************************************
444 
445 
446 //*************************************************************************************************
458 template< typename Type > // Data type of the matrix
461 {
462  return list_.begin()->begin();
463 }
464 //*************************************************************************************************
465 
466 
467 //*************************************************************************************************
475 template< typename Type > // Data type of the matrix
477  InitializerMatrix<Type>::data( size_t i ) const noexcept
478 {
479  BLAZE_USER_ASSERT( i < m_, "Invalid dense matrix row access index" );
480  return list_.begin()[i].begin();
481 }
482 //*************************************************************************************************
483 
484 
485 //*************************************************************************************************
493 template< typename Type > // Data type of the matrix
495  InitializerMatrix<Type>::begin( size_t i ) const noexcept
496 {
497  BLAZE_USER_ASSERT( i < m_, "Invalid dense matrix row access index" );
498  return ConstIterator( 0UL, list_.begin()[i] );
499 }
500 //*************************************************************************************************
501 
502 
503 //*************************************************************************************************
511 template< typename Type > // Data type of the matrix
513  InitializerMatrix<Type>::cbegin( size_t i ) const noexcept
514 {
515  BLAZE_USER_ASSERT( i < m_, "Invalid dense matrix row access index" );
516  return ConstIterator( 0UL, list_.begin()[i] );
517 }
518 //*************************************************************************************************
519 
520 
521 //*************************************************************************************************
529 template< typename Type > // Data type of the matrix
531  InitializerMatrix<Type>::end( size_t i ) const noexcept
532 {
533  BLAZE_USER_ASSERT( i < m_, "Invalid dense matrix row access index" );
534  return ConstIterator( n_, list_.begin()[i] );
535 }
536 //*************************************************************************************************
537 
538 
539 //*************************************************************************************************
547 template< typename Type > // Data type of the matrix
549  InitializerMatrix<Type>::cend( size_t i ) const noexcept
550 {
551  BLAZE_USER_ASSERT( i < m_, "Invalid dense matrix row access index" );
552  return ConstIterator( n_, list_.begin()[i] );
553 }
554 //*************************************************************************************************
555 
556 
557 
558 
559 //=================================================================================================
560 //
561 // UTILITY FUNCTIONS
562 //
563 //=================================================================================================
564 
565 //*************************************************************************************************
570 template< typename Type > // Data type of the matrix
571 inline size_t InitializerMatrix<Type>::rows() const noexcept
572 {
573  return m_;
574 }
575 //*************************************************************************************************
576 
577 
578 //*************************************************************************************************
583 template< typename Type > // Data type of the matrix
584 inline size_t InitializerMatrix<Type>::columns() const noexcept
585 {
586  return n_;
587 }
588 //*************************************************************************************************
589 
590 
591 //*************************************************************************************************
599 template< typename Type > // Data type of the matrix
600 inline size_t InitializerMatrix<Type>::spacing() const noexcept
601 {
602  return m_;
603 }
604 //*************************************************************************************************
605 
606 
607 //*************************************************************************************************
612 template< typename Type > // Data type of the matrix
613 inline size_t InitializerMatrix<Type>::capacity() const noexcept
614 {
615  return m_ * n_;
616 }
617 //*************************************************************************************************
618 
619 
620 //*************************************************************************************************
628 template< typename Type > // Data type of the matrix
629 inline size_t InitializerMatrix<Type>::capacity( size_t i ) const noexcept
630 {
631  UNUSED_PARAMETER( i );
632  BLAZE_USER_ASSERT( i < rows(), "Invalid row access index" );
633  return n_;
634 }
635 //*************************************************************************************************
636 
637 
638 //*************************************************************************************************
643 template< typename Type > // Data type of the matrix
645 {
646  size_t nonzeros( 0 );
647 
648  for( const auto& rowList : list_ ) {
649  for( size_t i=0UL; i<rowList.size(); ++i ) {
650  if( !isDefault( rowList.begin()[i] ) )
651  ++nonzeros;
652  }
653  }
654 
655  return nonzeros;
656 }
657 //*************************************************************************************************
658 
659 
660 //*************************************************************************************************
668 template< typename Type > // Data type of the matrix
669 inline size_t InitializerMatrix<Type>::nonZeros( size_t i ) const
670 {
671  using blaze::nonZeros;
672 
673  BLAZE_USER_ASSERT( i < rows(), "Invalid row access index" );
674 
675  return nonZeros( list_.begin()[i] );
676 }
677 //*************************************************************************************************
678 
679 
680 //*************************************************************************************************
686 template< typename Type > // Data type of the matrix
688 {
689  using std::swap;
690 
691  swap( m_ , m.m_ );
692  swap( n_ , m.n_ );
693  swap( list_, m.list_ );
694 }
695 //*************************************************************************************************
696 
697 
698 
699 
700 //=================================================================================================
701 //
702 // EXPRESSION TEMPLATE EVALUATION FUNCTIONS
703 //
704 //=================================================================================================
705 
706 //*************************************************************************************************
716 template< typename Type > // Data type of the matrix
717 template< typename Other > // Data type of the foreign expression
718 inline bool InitializerMatrix<Type>::canAlias( const Other* alias ) const noexcept
719 {
720  return static_cast<const void*>( this ) == static_cast<const void*>( alias );
721 }
722 //*************************************************************************************************
723 
724 
725 //*************************************************************************************************
735 template< typename Type > // Data type of the matrix
736 template< typename Other > // Data type of the foreign expression
737 inline bool InitializerMatrix<Type>::isAliased( const Other* alias ) const noexcept
738 {
739  return static_cast<const void*>( this ) == static_cast<const void*>( alias );
740 }
741 //*************************************************************************************************
742 
743 
744 
745 
746 //=================================================================================================
747 //
748 // INITIALIZERMATRIX OPERATORS
749 //
750 //=================================================================================================
751 
752 //*************************************************************************************************
755 template< typename Type >
756 inline bool isIntact( const InitializerMatrix<Type>& m ) noexcept;
757 
758 template< typename Type >
759 inline void swap( InitializerMatrix<Type>& a, InitializerMatrix<Type>& b ) noexcept;
761 //*************************************************************************************************
762 
763 
764 //*************************************************************************************************
781 template< typename Type >
782 inline bool isIntact( const InitializerMatrix<Type>& m ) noexcept
783 {
784  UNUSED_PARAMETER( m );
785 
786  return true;
787 }
788 //*************************************************************************************************
789 
790 
791 //*************************************************************************************************
799 template< typename Type >
801 {
802  a.swap( b );
803 }
804 //*************************************************************************************************
805 
806 
807 
808 
809 //=================================================================================================
810 //
811 // HASCONSTDATAACCESS SPECIALIZATIONS
812 //
813 //=================================================================================================
814 
815 //*************************************************************************************************
817 template< typename T >
818 struct HasConstDataAccess< InitializerMatrix<T> >
819  : public TrueType
820 {};
822 //*************************************************************************************************
823 
824 
825 
826 
827 //=================================================================================================
828 //
829 // ISINITIALIZER SPECIALIZATIONS
830 //
831 //=================================================================================================
832 
833 //*************************************************************************************************
835 template< typename T >
836 struct IsInitializer< InitializerMatrix<T> >
837  : public TrueType
838 {};
840 //*************************************************************************************************
841 
842 
843 
844 
845 //=================================================================================================
846 //
847 // HIGHTYPE SPECIALIZATIONS
848 //
849 //=================================================================================================
850 
851 //*************************************************************************************************
853 template< typename T1, typename T2 >
854 struct HighType< InitializerMatrix<T1>, InitializerMatrix<T2> >
855 {
857 };
859 //*************************************************************************************************
860 
861 
862 
863 
864 //=================================================================================================
865 //
866 // LOWTYPE SPECIALIZATIONS
867 //
868 //=================================================================================================
869 
870 //*************************************************************************************************
872 template< typename T1, typename T2 >
873 struct LowType< InitializerMatrix<T1>, InitializerMatrix<T2> >
874 {
876 };
878 //*************************************************************************************************
879 
880 
881 
882 
883 //=================================================================================================
884 //
885 // SUBMATRIXTRAIT SPECIALIZATIONS
886 //
887 //=================================================================================================
888 
889 //*************************************************************************************************
891 template< typename T, size_t I, size_t J, size_t M, size_t N >
892 struct SubmatrixTrait< InitializerMatrix<T>, I, J, M, N >
893 {
894  using Type = StaticMatrix<T,M,N,false>;
895 };
896 
897 template< typename T >
898 struct SubmatrixTrait< InitializerMatrix<T> >
899 {
900  using Type = DynamicMatrix<T,false>;
901 };
903 //*************************************************************************************************
904 
905 
906 
907 
908 //=================================================================================================
909 //
910 // ROWTRAIT SPECIALIZATIONS
911 //
912 //=================================================================================================
913 
914 //*************************************************************************************************
916 template< typename T, size_t... CRAs >
917 struct RowTrait< InitializerMatrix<T>, CRAs... >
918 {
919  using Type = DynamicVector<T,true>;
920 };
922 //*************************************************************************************************
923 
924 
925 
926 
927 //=================================================================================================
928 //
929 // ROWSTRAIT SPECIALIZATIONS
930 //
931 //=================================================================================================
932 
933 //*************************************************************************************************
935 template< typename T, size_t... CRAs >
936 struct RowsTrait< InitializerMatrix<T>, CRAs... >
937 {
938  using Type = DynamicMatrix<T,false>;
939 };
941 //*************************************************************************************************
942 
943 
944 
945 
946 //=================================================================================================
947 //
948 // COLUMNTRAIT SPECIALIZATIONS
949 //
950 //=================================================================================================
951 
952 //*************************************************************************************************
954 template< typename T, size_t... CCAs >
955 struct ColumnTrait< InitializerMatrix<T>, CCAs... >
956 {
957  using Type = DynamicVector<T,false>;
958 };
960 //*************************************************************************************************
961 
962 
963 
964 
965 //=================================================================================================
966 //
967 // COLUMNSTRAIT SPECIALIZATIONS
968 //
969 //=================================================================================================
970 
971 //*************************************************************************************************
973 template< typename T, size_t... CCAs >
974 struct ColumnsTrait< InitializerMatrix<T>, CCAs... >
975 {
976  using Type = DynamicMatrix<T,true>;
977 };
979 //*************************************************************************************************
980 
981 
982 
983 
984 //=================================================================================================
985 //
986 // BANDTRAIT SPECIALIZATIONS
987 //
988 //=================================================================================================
989 
990 //*************************************************************************************************
992 template< typename T, ptrdiff_t... CBAs >
993 struct BandTrait< InitializerMatrix<T>, CBAs... >
994 {
996 };
998 //*************************************************************************************************
999 
1000 } // namespace blaze
1001 
1002 #endif
ConstReference at(size_t i, size_t j) const
Checked access to the matrix elements.
Definition: InitializerMatrix.h:433
#define BLAZE_CONSTRAINT_MUST_NOT_BE_CONST(T)
Constraint on the data type.In case the given data type is a const-qualified type, a compilation error is created.
Definition: Const.h:79
#define BLAZE_THROW_INVALID_ARGUMENT(MESSAGE)
Macro for the emission of a std::invalid_argument exception.This macro encapsulates the default way o...
Definition: Exception.h:235
Pointer difference type of the Blaze library.
Compile time check for low-level access to constant data.This type trait tests whether the given data...
Definition: HasConstDataAccess.h:75
Header file for the IsInitializer type trait.
#define BLAZE_USER_ASSERT(expr, msg)
Run time assertion macro for user checks.In case of an invalid run time expression, the program execution is terminated. The BLAZE_USER_ASSERT macro can be disabled by setting the BLAZE_USER_ASSERT flag to zero or by defining NDEBUG during the compilation.
Definition: Assert.h:117
Header file for the UNUSED_PARAMETER function template.
Header file for basic type definitions.
Implementation of an iterator for (extended) initializer lists.The InitializerIterator represents a g...
Definition: InitializerIterator.h:56
Header file for the row trait.
Base template for the SubmatrixTrait class.
Definition: SubmatrixTrait.h:109
Base template for the ColumnTrait class.
Definition: ColumnTrait.h:108
Dense matrix representation of an initializer list.The InitializerMatrix class template is a dense ma...
Definition: InitializerMatrix.h:182
BLAZE_ALWAYS_INLINE size_t size(const Vector< VT, TF > &vector) noexcept
Returns the current size/dimension of the vector.
Definition: Vector.h:265
Generic wrapper for a compile time constant integral value.The IntegralConstant class template repres...
Definition: IntegralConstant.h:71
static const Type zero_
Neutral element for accesses to zero elements.
Definition: InitializerMatrix.h:315
const Type * ConstPointer
Pointer to a constant matrix value.
Definition: InitializerMatrix.h:199
const Type & Reference
Reference to a non-constant matrix value.
Definition: InitializerMatrix.h:196
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VOLATILE(T)
Constraint on the data type.In case the given data type is a volatile-qualified type, a compilation error is created.
Definition: Volatile.h:79
size_t m_
The current number of rows of the matrix.
Definition: InitializerMatrix.h:303
BLAZE_ALWAYS_INLINE size_t nonZeros(const Matrix< MT, SO > &matrix)
Returns the total number of non-zero elements in the matrix.
Definition: Matrix.h:560
const Type * Pointer
Pointer to a non-constant matrix value.
Definition: InitializerMatrix.h:198
Efficient implementation of an arbitrary sized vector.The DynamicVector class template is the represe...
Definition: DynamicVector.h:185
Header file for the extended initializer_list functionality.
Efficient implementation of a dynamic matrix.The DynamicMatrix class template is the representation ...
Definition: DynamicMatrix.h:217
size_t nonZeros() const
Returns the total number of non-zero elements in the matrix.
Definition: InitializerMatrix.h:644
Base template for the RowsTrait class.
Definition: RowsTrait.h:109
Base class for dense matrices.The DenseMatrix class is a base class for all dense matrix classes...
Definition: DenseMatrix.h:80
Header file for the band trait.
Constraint on the data type.
Base template for the RowTrait class.
Definition: RowTrait.h:109
InitializerIterator< Type > ConstIterator
Iterator over constant elements.
Definition: InitializerMatrix.h:202
Header file for the LowType type trait.
Base template for the HighType type trait.
Definition: HighType.h:133
ConstIterator begin(size_t i) const noexcept
Returns an iterator to the first element of row i.
Definition: InitializerMatrix.h:495
Namespace of the Blaze C++ math library.
Definition: Blaze.h:58
void swap(CompressedMatrix< Type, SO > &a, CompressedMatrix< Type, SO > &b) noexcept
Swapping the contents of two compressed matrices.
Definition: CompressedMatrix.h:5908
ListType list_
The initializer list represented by the matrix.
Definition: InitializerMatrix.h:305
size_t rows() const noexcept
Returns the current number of rows of the matrix.
Definition: InitializerMatrix.h:571
size_t columns() const noexcept
Returns the current number of columns of the matrix.
Definition: InitializerMatrix.h:584
Header file for all forward declarations of the math module.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_POINTER_TYPE(T)
Constraint on the data type.In case the given data type T is not a pointer type, a compilation error ...
Definition: Pointer.h:79
#define BLAZE_THROW_OUT_OF_RANGE(MESSAGE)
Macro for the emission of a std::out_of_range exception.This macro encapsulates the default way of Bl...
Definition: Exception.h:331
Efficient implementation of a fixed-sized matrix.The StaticMatrix class template is the representatio...
Definition: Forward.h:60
Header file for the DenseMatrix base class.
Constraint on the data type.
size_t spacing() const noexcept
Returns the spacing between the beginning of two rows.
Definition: InitializerMatrix.h:600
bool canAlias(const Other *alias) const noexcept
Returns whether the matrix can alias with the given address alias.
Definition: InitializerMatrix.h:718
Rebind mechanism to obtain a InitializerMatrix with different data/element type.
Definition: InitializerMatrix.h:209
ConstPointer data() const noexcept
Low-level data access to the matrix elements.
Definition: InitializerMatrix.h:460
Type ElementType
Type of the matrix elements.
Definition: InitializerMatrix.h:192
Header file for the exception macros of the math module.
ConstIterator cend(size_t i) const noexcept
Returns an iterator just past the last element of row i.
Definition: InitializerMatrix.h:549
Compile time check for custom data types.This type trait tests whether the given data type represents...
Definition: IsInitializer.h:82
ConstReference operator()(size_t i, size_t j) const noexcept
2D-access to the matrix elements.
Definition: InitializerMatrix.h:405
Base template for the LowType type trait.
Definition: LowType.h:133
Header file for the HasConstDataAccess type trait.
size_t determineColumns(initializer_list< initializer_list< Type > > list) noexcept
Determines the maximum number of columns specified by the given initializer list. ...
Definition: InitializerList.h:107
Header file for run time assertion macros.
Header file for the submatrix trait.
Constraint on the data type.
Header file for the columns trait.
Resize mechanism to obtain a InitializerMatrix with different fixed dimensions.
Definition: InitializerMatrix.h:219
ConstIterator cbegin(size_t i) const noexcept
Returns an iterator to the first element of row i.
Definition: InitializerMatrix.h:513
#define BLAZE_CONSTRAINT_MUST_NOT_BE_REFERENCE_TYPE(T)
Constraint on the data type.In case the given data type T is not a reference type, a compilation error is created.
Definition: Reference.h:79
Header file for the column trait.
Constraint on the data type.
void swap(InitializerMatrix &m) noexcept
Swapping the contents of two matrices.
Definition: InitializerMatrix.h:687
Header file for the rows trait.
InitializerMatrix(initializer_list< initializer_list< Type > > list) noexcept
Constructor for InitializerMatrix.
Definition: InitializerMatrix.h:357
ConstIterator end(size_t i) const noexcept
Returns an iterator just past the last element of row i.
Definition: InitializerMatrix.h:531
size_t n_
The current number of columns of the matrix.
Definition: InitializerMatrix.h:304
Base template for the ColumnsTrait class.
Definition: ColumnsTrait.h:109
bool isAliased(const Other *alias) const noexcept
Returns whether the matrix is aliased with the given address alias.
Definition: InitializerMatrix.h:737
Initializer list type of the Blaze library.
Header file for the InitializerIterator class template.
bool isIntact(const DiagonalMatrix< MT, SO, DF > &m)
Returns whether the invariants of the given diagonal matrix are intact.
Definition: DiagonalMatrix.h:254
bool isDefault(const DiagonalProxy< MT > &proxy)
Returns whether the represented element is in default state.
Definition: DiagonalProxy.h:628
const Type & ConstReference
Reference to a constant matrix value.
Definition: InitializerMatrix.h:197
void UNUSED_PARAMETER(const Args &...)
Suppression of unused parameter warnings.
Definition: Unused.h:81
size_t capacity() const noexcept
Returns the maximum capacity of the matrix.
Definition: InitializerMatrix.h:613
const Type & ReturnType
Return type for expression template evaluations.
Definition: InitializerMatrix.h:193
Header file for the HighType type trait.
Header file for the TrueType type/value trait base class.
Base template for the BandTrait class.
Definition: BandTrait.h:109