ZeroMatrix.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_SPARSE_ZEROMATRIX_H_
36 #define _BLAZE_MATH_SPARSE_ZEROMATRIX_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <blaze/math/Aliases.h>
44 #include <blaze/math/Exception.h>
46 #include <blaze/math/Forward.h>
80 #include <blaze/util/Assert.h>
85 #include <blaze/util/EnableIf.h>
87 #include <blaze/util/TrueType.h>
88 #include <blaze/util/Types.h>
90 #include <blaze/util/Unused.h>
91 
92 
93 namespace blaze {
94 
95 //=================================================================================================
96 //
97 // CLASS DEFINITION
98 //
99 //=================================================================================================
100 
101 //*************************************************************************************************
176 template< typename Type // Data type of the matrix
177  , bool SO = defaultStorageOrder > // Storage order
178 class ZeroMatrix
179  : public SparseMatrix< ZeroMatrix<Type,SO>, SO >
180 {
181  private:
182  //**Type definitions****************************************************************************
184  //**********************************************************************************************
185 
186  public:
187  //**Type definitions****************************************************************************
190  using ResultType = This;
193  using ElementType = Type;
194  using ReturnType = const Type&;
195  using CompositeType = const This&;
196  using Reference = const Type&;
197  using ConstReference = const Type&;
198  using Iterator = Element*;
199  using ConstIterator = const Element*;
200  //**********************************************************************************************
201 
202  //**Rebind struct definition********************************************************************
205  template< typename NewType > // Data type of the other matrix
206  struct Rebind {
208  };
209  //**********************************************************************************************
210 
211  //**Resize struct definition********************************************************************
214  template< size_t NewM // Number of rows of the other matrix
215  , size_t NewN > // Number of columns of the other matrix
216  struct Resize {
218  };
219  //**********************************************************************************************
220 
221  //**Compilation flags***************************************************************************
223 
226  static constexpr bool smpAssignable = !IsSMPAssignable_v<Type>;
227  //**********************************************************************************************
228 
229  //**Constructors********************************************************************************
232  explicit inline constexpr ZeroMatrix() noexcept;
233  explicit inline constexpr ZeroMatrix( size_t m, size_t n ) noexcept;
234 
235  template< typename MT, bool SO2 >
236  explicit inline ZeroMatrix( const Matrix<MT,SO2>& m );
237 
238  ZeroMatrix( const ZeroMatrix& ) = default;
239  ZeroMatrix( ZeroMatrix&& ) = default;
241  //**********************************************************************************************
242 
243  //**Destructor**********************************************************************************
246  ~ZeroMatrix() = default;
248  //**********************************************************************************************
249 
250  //**Data access functions***********************************************************************
253  inline constexpr ConstReference operator()( size_t i, size_t j ) const noexcept;
254  inline ConstReference at( size_t i, size_t j ) const;
255  inline constexpr ConstIterator begin ( size_t i ) const noexcept;
256  inline constexpr ConstIterator cbegin( size_t i ) const noexcept;
257  inline constexpr ConstIterator end ( size_t i ) const noexcept;
258  inline constexpr ConstIterator cend ( size_t i ) const noexcept;
260  //**********************************************************************************************
261 
262  //**Assignment operators************************************************************************
265  template< typename MT, bool SO2 >
266  inline ZeroMatrix& operator=( const Matrix<MT,SO2>& rhs );
267 
268  ZeroMatrix& operator=( const ZeroMatrix& ) = default;
269  ZeroMatrix& operator=( ZeroMatrix&& ) = default;
271  //**********************************************************************************************
272 
273  //**Utility functions***************************************************************************
276  inline constexpr size_t rows() const noexcept;
277  inline constexpr size_t columns() const noexcept;
278  inline constexpr size_t capacity() const noexcept;
279  inline constexpr size_t capacity( size_t i ) const noexcept;
280  inline constexpr size_t nonZeros() const noexcept;
281  inline constexpr size_t nonZeros( size_t i ) const noexcept;
282  inline constexpr void clear() noexcept;
283  constexpr void resize( size_t m, size_t n ) noexcept;
284  inline constexpr void swap( ZeroMatrix& m ) noexcept;
286  //**********************************************************************************************
287 
288  //**Lookup functions****************************************************************************
291  inline ConstIterator find ( size_t i, size_t j ) const;
292  inline ConstIterator lowerBound( size_t i, size_t j ) const;
293  inline ConstIterator upperBound( size_t i, size_t j ) const;
295  //**********************************************************************************************
296 
297  //**Numeric functions***************************************************************************
300  inline constexpr ZeroMatrix& transpose() noexcept;
301  inline constexpr ZeroMatrix& ctranspose() noexcept;
303  //**********************************************************************************************
304 
305  //**Expression template evaluation functions****************************************************
308  template< typename Other > inline bool canAlias ( const Other* alias ) const noexcept;
309  template< typename Other > inline bool isAliased( const Other* alias ) const noexcept;
310 
311  inline bool canSMPAssign() const noexcept;
313  //**********************************************************************************************
314 
315  private:
316  //**Member variables****************************************************************************
319  size_t m_;
320  size_t n_;
321 
322  static const Type zero_;
323 
324  //**********************************************************************************************
325 
326  //**Compile time checks*************************************************************************
333  //**********************************************************************************************
334 };
335 //*************************************************************************************************
336 
337 
338 
339 
340 //=================================================================================================
341 //
342 // DEFINITION AND INITIALIZATION OF THE STATIC MEMBER VARIABLES
343 //
344 //=================================================================================================
345 
346 template< typename Type, bool SO >
347 const Type ZeroMatrix<Type,SO>::zero_{};
348 
349 
350 
351 
352 //=================================================================================================
353 //
354 // CONSTRUCTORS
355 //
356 //=================================================================================================
357 
358 //*************************************************************************************************
361 template< typename Type // Data type of the matrix
362  , bool SO > // Storage order
363 inline constexpr ZeroMatrix<Type,SO>::ZeroMatrix() noexcept
364  : m_( 0UL ) // The current number of rows of the zero matrix
365  , n_( 0UL ) // The current number of columns of the zero matrix
366 {}
367 //*************************************************************************************************
368 
369 
370 //*************************************************************************************************
376 template< typename Type // Data type of the matrix
377  , bool SO > // Storage order
378 inline constexpr ZeroMatrix<Type,SO>::ZeroMatrix( size_t m, size_t n ) noexcept
379  : m_( m ) // The current number of rows of the zero matrix
380  , n_( n ) // The current number of columns of the zero matrix
381 {}
382 //*************************************************************************************************
383 
384 
385 //*************************************************************************************************
394 template< typename Type // Data type of the matrix
395  , bool SO > // Storage order
396 template< typename MT // Type of the foreign zero matrix
397  , bool SO2 > // Storage order of the foreign zero matrix
399  : m_( (~m).rows() ) // The current number of rows of the zero matrix
400  , n_( (~m).columns() ) // The current number of columns of the zero matrix
401 {
402  if( !IsZero_v<MT> && !isZero( ~m ) ) {
403  BLAZE_THROW_INVALID_ARGUMENT( "Invalid setup of zero matrix" );
404  }
405 }
406 //*************************************************************************************************
407 
408 
409 
410 
411 //=================================================================================================
412 //
413 // DATA ACCESS FUNCTIONS
414 //
415 //=================================================================================================
416 
417 //*************************************************************************************************
427 template< typename Type // Data type of the matrix
428  , bool SO > // Storage order
429 inline constexpr typename ZeroMatrix<Type,SO>::ConstReference
430  ZeroMatrix<Type,SO>::operator()( size_t i, size_t j ) const noexcept
431 {
432  UNUSED_PARAMETER( i, j );
433 
434  BLAZE_USER_ASSERT( i < rows() , "Invalid zero matrix row access index" );
435  BLAZE_USER_ASSERT( j < columns(), "Invalid zero matrix column access index" );
436 
437  return zero_;
438 }
439 //*************************************************************************************************
440 
441 
442 //*************************************************************************************************
453 template< typename Type // Data type of the matrix
454  , bool SO > // Storage order
456  ZeroMatrix<Type,SO>::at( size_t i, size_t j ) const
457 {
458  if( i >= m_ ) {
459  BLAZE_THROW_OUT_OF_RANGE( "Invalid row access index" );
460  }
461  if( j >= n_ ) {
462  BLAZE_THROW_OUT_OF_RANGE( "Invalid column access index" );
463  }
464 
465  return zero_;
466 }
467 //*************************************************************************************************
468 
469 
470 //*************************************************************************************************
481 template< typename Type // Data type of the matrix
482  , bool SO > // Storage order
483 inline constexpr typename ZeroMatrix<Type,SO>::ConstIterator
484  ZeroMatrix<Type,SO>::begin( size_t i ) const noexcept
485 {
486  UNUSED_PARAMETER( i );
487 
488  BLAZE_USER_ASSERT( i < ( SO ? n_ : m_ ), "Invalid zero matrix row/column access index" );
489 
490  return nullptr;
491 }
492 //*************************************************************************************************
493 
494 
495 //*************************************************************************************************
506 template< typename Type // Data type of the matrix
507  , bool SO > // Storage order
508 inline constexpr typename ZeroMatrix<Type,SO>::ConstIterator
509  ZeroMatrix<Type,SO>::cbegin( size_t i ) const noexcept
510 {
511  UNUSED_PARAMETER( i );
512 
513  BLAZE_USER_ASSERT( i < ( SO ? n_ : m_ ), "Invalid zero matrix row/column access index" );
514 
515  return nullptr;
516 }
517 //*************************************************************************************************
518 
519 
520 //*************************************************************************************************
531 template< typename Type // Data type of the matrix
532  , bool SO > // Storage order
533 inline constexpr typename ZeroMatrix<Type,SO>::ConstIterator
534  ZeroMatrix<Type,SO>::end( size_t i ) const noexcept
535 {
536  UNUSED_PARAMETER( i );
537 
538  BLAZE_USER_ASSERT( i < ( SO ? n_ : m_ ), "Invalid zero matrix row/column access index" );
539 
540  return nullptr;
541 }
542 //*************************************************************************************************
543 
544 
545 //*************************************************************************************************
556 template< typename Type // Data type of the matrix
557  , bool SO > // Storage order
558 inline constexpr typename ZeroMatrix<Type,SO>::ConstIterator
559  ZeroMatrix<Type,SO>::cend( size_t i ) const noexcept
560 {
561  UNUSED_PARAMETER( i );
562 
563  BLAZE_USER_ASSERT( i < ( SO ? n_ : m_ ), "Invalid zero matrix row/column access index" );
564 
565  return nullptr;
566 }
567 //*************************************************************************************************
568 
569 
570 
571 
572 //=================================================================================================
573 //
574 // ASSIGNMENT OPERATORS
575 //
576 //=================================================================================================
577 
578 //*************************************************************************************************
588 template< typename Type // Data type of the matrix
589  , bool SO > // Storage order
590 template< typename MT // Type of the right-hand side zero matrix
591  , bool SO2 > // Storage order of the right-hand side zero matrix
592 inline ZeroMatrix<Type,SO>&
594 {
595  if( !IsZero_v<MT> && !isZero( ~rhs ) ) {
596  BLAZE_THROW_INVALID_ARGUMENT( "Invalid assignment of zero matrix" );
597  }
598 
599  const size_t m( (~rhs).rows() );
600  const size_t n( (~rhs).columns() );
601 
602  m_ = m;
603  n_ = n;
604 
605  return *this;
606 }
607 //*************************************************************************************************
608 
609 
610 
611 
612 //=================================================================================================
613 //
614 // UTILITY FUNCTIONS
615 //
616 //=================================================================================================
617 
618 //*************************************************************************************************
623 template< typename Type // Data type of the matrix
624  , bool SO > // Storage order
625 inline constexpr size_t ZeroMatrix<Type,SO>::rows() const noexcept
626 {
627  return m_;
628 }
629 //*************************************************************************************************
630 
631 
632 //*************************************************************************************************
637 template< typename Type // Data type of the matrix
638  , bool SO > // Storage order
639 inline constexpr size_t ZeroMatrix<Type,SO>::columns() const noexcept
640 {
641  return n_;
642 }
643 //*************************************************************************************************
644 
645 
646 //*************************************************************************************************
651 template< typename Type // Data type of the matrix
652  , bool SO > // Storage order
653 inline constexpr size_t ZeroMatrix<Type,SO>::capacity() const noexcept
654 {
655  return 0UL;
656 }
657 //*************************************************************************************************
658 
659 
660 //*************************************************************************************************
671 template< typename Type // Data type of the matrix
672  , bool SO > // Storage order
673 inline constexpr size_t ZeroMatrix<Type,SO>::capacity( size_t i ) const noexcept
674 {
675  UNUSED_PARAMETER( i );
676 
677  BLAZE_USER_ASSERT( i < ( SO ? n_ : m_ ), "Invalid zero matrix row/column access index" );
678 
679  return 0UL;
680 }
681 //*************************************************************************************************
682 
683 
684 //*************************************************************************************************
689 template< typename Type // Data type of the matrix
690  , bool SO > // Storage order
691 inline constexpr size_t ZeroMatrix<Type,SO>::nonZeros() const noexcept
692 {
693  return 0UL;
694 }
695 //*************************************************************************************************
696 
697 
698 //*************************************************************************************************
709 template< typename Type // Data type of the matrix
710  , bool SO > // Storage order
711 inline constexpr size_t ZeroMatrix<Type,SO>::nonZeros( size_t i ) const noexcept
712 {
713  UNUSED_PARAMETER( i );
714 
715  BLAZE_USER_ASSERT( i < ( SO ? n_ : m_ ), "Invalid zero matrix row/column access index" );
716 
717  return 0UL;
718 }
719 //*************************************************************************************************
720 
721 
722 //*************************************************************************************************
729 template< typename Type // Data type of the matrix
730  , bool SO > // Storage order
731 inline constexpr void ZeroMatrix<Type,SO>::clear() noexcept
732 {
733  m_ = 0UL;
734  n_ = 0UL;
735 }
736 //*************************************************************************************************
737 
738 
739 //*************************************************************************************************
750 template< typename Type // Data type of the matrix
751  , bool SO > // Storage order
752 void constexpr ZeroMatrix<Type,SO>::resize( size_t m, size_t n ) noexcept
753 {
754  m_ = m;
755  n_ = n;
756 }
757 //*************************************************************************************************
758 
759 
760 //*************************************************************************************************
766 template< typename Type // Data type of the matrix
767  , bool SO > // Storage order
768 inline constexpr void ZeroMatrix<Type,SO>::swap( ZeroMatrix& m ) noexcept
769 {
770  const size_t tmp1( m_ );
771  m_ = m.m_;
772  m.m_ = tmp1;
773 
774  const size_t tmp2( n_ );
775  n_ = m.n_;
776  m.n_ = tmp2;
777 }
778 //*************************************************************************************************
779 
780 
781 
782 
783 //=================================================================================================
784 //
785 // LOOKUP FUNCTIONS
786 //
787 //=================================================================================================
788 
789 //*************************************************************************************************
802 template< typename Type // Data type of the matrix
803  , bool SO > // Storage order
805  ZeroMatrix<Type,SO>::find( size_t i, size_t j ) const
806 {
807  UNUSED_PARAMETER( i, j );
808 
809  BLAZE_USER_ASSERT( SO || i < rows() , "Invalid zero matrix row access index" );
810  BLAZE_USER_ASSERT( !SO || j < columns(), "Invalid zero matrix column access index" );
811 
812  return nullptr;
813 }
814 //*************************************************************************************************
815 
816 
817 //*************************************************************************************************
830 template< typename Type // Data type of the matrix
831  , bool SO > // Storage order
833  ZeroMatrix<Type,SO>::lowerBound( size_t i, size_t j ) const
834 {
835  UNUSED_PARAMETER( i, j );
836 
837  BLAZE_USER_ASSERT( SO || i < rows() , "Invalid zero matrix row access index" );
838  BLAZE_USER_ASSERT( !SO || j < columns(), "Invalid zero matrix column access index" );
839 
840  return nullptr;
841 }
842 //*************************************************************************************************
843 
844 
845 //*************************************************************************************************
858 template< typename Type // Data type of the matrix
859  , bool SO > // Storage order
861  ZeroMatrix<Type,SO>::upperBound( size_t i, size_t j ) const
862 {
863  UNUSED_PARAMETER( i, j );
864 
865  BLAZE_USER_ASSERT( SO || i < rows() , "Invalid zero matrix row access index" );
866  BLAZE_USER_ASSERT( !SO || j < columns(), "Invalid zero matrix column access index" );
867 
868  return nullptr;
869 }
870 //*************************************************************************************************
871 
872 
873 
874 
875 //=================================================================================================
876 //
877 // NUMERIC FUNCTIONS
878 //
879 //=================================================================================================
880 
881 //*************************************************************************************************
886 template< typename Type // Data type of the matrix
887  , bool SO > // Storage order
889 {
890  const size_t tmp( m_ );
891  m_ = n_;
892  n_ = tmp;
893 
894  return *this;
895 }
896 //*************************************************************************************************
897 
898 
899 //*************************************************************************************************
904 template< typename Type // Data type of the matrix
905  , bool SO > // Storage order
907 {
908  const size_t tmp( m_ );
909  m_ = n_;
910  n_ = tmp;
911 
912  return *this;
913 }
914 //*************************************************************************************************
915 
916 
917 
918 
919 //=================================================================================================
920 //
921 // EXPRESSION TEMPLATE EVALUATION FUNCTIONS
922 //
923 //=================================================================================================
924 
925 //*************************************************************************************************
935 template< typename Type // Data type of the matrix
936  , bool SO > // Storage order
937 template< typename Other > // Data type of the foreign expression
938 inline bool ZeroMatrix<Type,SO>::canAlias( const Other* alias ) const noexcept
939 {
940  UNUSED_PARAMETER( alias );
941 
942  return false;
943 }
944 //*************************************************************************************************
945 
946 
947 //*************************************************************************************************
957 template< typename Type // Data type of the matrix
958  , bool SO > // Storage order
959 template< typename Other > // Data type of the foreign expression
960 inline bool ZeroMatrix<Type,SO>::isAliased( const Other* alias ) const noexcept
961 {
962  UNUSED_PARAMETER( alias );
963 
964  return false;
965 }
966 //*************************************************************************************************
967 
968 
969 //*************************************************************************************************
979 template< typename Type // Data type of the matrix
980  , bool SO > // Storage order
981 inline bool ZeroMatrix<Type,SO>::canSMPAssign() const noexcept
982 {
983  return false;
984 }
985 //*************************************************************************************************
986 
987 
988 
989 
990 
991 
992 
993 
994 //=================================================================================================
995 //
996 // ZEROMATRIX OPERATORS
997 //
998 //=================================================================================================
999 
1000 //*************************************************************************************************
1003 template< typename Type, bool SO >
1004 constexpr void reset( ZeroMatrix<Type,SO>& m ) noexcept;
1005 
1006 template< typename Type, bool SO >
1007 constexpr void reset( ZeroMatrix<Type,SO>& m, size_t i ) noexcept;
1008 
1009 template< typename Type, bool SO >
1010 constexpr void clear( ZeroMatrix<Type,SO>& m ) noexcept;
1011 
1012 template< bool RF, typename Type, bool SO >
1013 constexpr bool isDefault( const ZeroMatrix<Type,SO>& m ) noexcept;
1014 
1015 template< typename Type, bool SO >
1016 constexpr bool isIntact( const ZeroMatrix<Type,SO>& m ) noexcept;
1017 
1018 template< typename Type, bool SO >
1019 constexpr void swap( ZeroMatrix<Type,SO>& a, ZeroMatrix<Type,SO>& b ) noexcept;
1021 //*************************************************************************************************
1022 
1023 
1024 //*************************************************************************************************
1031 template< typename Type // Data type of the matrix
1032  , bool SO > // Storage order
1033 inline constexpr void reset( ZeroMatrix<Type,SO>& m ) noexcept
1034 {
1035  UNUSED_PARAMETER( m );
1036 }
1037 //*************************************************************************************************
1038 
1039 
1040 //*************************************************************************************************
1052 template< typename Type // Data type of the matrix
1053  , bool SO > // Storage order
1054 inline constexpr void reset( ZeroMatrix<Type,SO>& m, size_t i ) noexcept
1055 {
1056  UNUSED_PARAMETER( m, i );
1057 }
1058 //*************************************************************************************************
1059 
1060 
1061 //*************************************************************************************************
1068 template< typename Type // Data type of the matrix
1069  , bool SO > // Storage order
1070 inline constexpr void clear( ZeroMatrix<Type,SO>& m ) noexcept
1071 {
1072  m.clear();
1073 }
1074 //*************************************************************************************************
1075 
1076 
1077 //*************************************************************************************************
1102 template< bool RF // Relaxation flag
1103  , typename Type // Data type of the matrix
1104  , bool SO > // Storage order
1105 inline constexpr bool isDefault( const ZeroMatrix<Type,SO>& m ) noexcept
1106 {
1107  return ( m.rows() == 0UL && m.columns() == 0UL );
1108 }
1109 //*************************************************************************************************
1110 
1111 
1112 //*************************************************************************************************
1129 template< typename Type // Data type of the matrix
1130  , bool SO > // Storage order
1131 inline constexpr bool isIntact( const ZeroMatrix<Type,SO>& m ) noexcept
1132 {
1133  UNUSED_PARAMETER( m );
1134 
1135  return true;
1136 }
1137 //*************************************************************************************************
1138 
1139 
1140 //*************************************************************************************************
1148 template< typename Type // Data type of the matrix
1149  , bool SO > // Storage order
1150 inline constexpr void swap( ZeroMatrix<Type,SO>& a, ZeroMatrix<Type,SO>& b ) noexcept
1151 {
1152  a.swap( b );
1153 }
1154 //*************************************************************************************************
1155 
1156 
1157 //*************************************************************************************************
1167 template< typename Type // Data type of the matrix
1168  , bool SO > // Storage order
1169 inline void erase( ZeroMatrix<Type,SO>& m, size_t i, size_t j )
1170 {
1171  UNUSED_PARAMETER( m, i, j );
1172 }
1174 //*************************************************************************************************
1175 
1176 
1177 //*************************************************************************************************
1191 template< typename Type // Data type of the matrix
1192  , bool SO // Storage order
1193  , typename Iterator > // Type of the matrix iterator
1194 inline Iterator erase( ZeroMatrix<Type,SO>& m, size_t i, Iterator pos )
1195 {
1196  UNUSED_PARAMETER( m, i, pos );
1197  return Iterator();
1198 }
1200 //*************************************************************************************************
1201 
1202 
1203 //*************************************************************************************************
1219 template< typename Type // Data type of the matrix
1220  , bool SO // Storage order
1221  , typename Iterator > // Type of the matrix iterator
1222 inline Iterator erase( ZeroMatrix<Type,SO>& m, size_t i, Iterator first, Iterator last )
1223 {
1224  UNUSED_PARAMETER( m, i, first, last );
1225  return Iterator();
1226 }
1228 //*************************************************************************************************
1229 
1230 
1231 //*************************************************************************************************
1255 template< typename Type // Data type of the matrix
1256  , bool SO // Storage order
1257  , typename Pred > // Type of the unary predicate
1258 inline void erase( ZeroMatrix<Type,SO>& m, Pred predicate )
1259 {
1260  UNUSED_PARAMETER( m, predicate );
1261 }
1263 //*************************************************************************************************
1264 
1265 
1266 //*************************************************************************************************
1296 template< typename Type // Data type of the matrix
1297  , bool SO // Storage order
1298  , typename Iterator // Type of the matrix iterator
1299  , typename Pred > // Type of the unary predicate
1300 inline void erase( ZeroMatrix<Type,SO>& m, size_t i, Iterator first, Iterator last, Pred predicate )
1301 {
1302  UNUSED_PARAMETER( m, i, first, last, predicate );
1303 }
1305 //*************************************************************************************************
1306 
1307 
1308 
1309 
1310 //=================================================================================================
1311 //
1312 // GLOBAL FUNCTIONS
1313 //
1314 //=================================================================================================
1315 
1316 //*************************************************************************************************
1332 template< typename MT // Type of the matrix
1333  , bool SO > // Storage order
1334 inline ZeroMatrix<ElementType_t<MT>,SO>
1336 {
1338 
1339  return ZeroMatrix<ElementType_t<MT>,SO>( (~m).rows(), (~m).columns() );
1340 }
1341 //*************************************************************************************************
1342 
1343 
1344 
1345 
1346 //=================================================================================================
1347 //
1348 // ISUNIFORM SPECIALIZATIONS
1349 //
1350 //=================================================================================================
1351 
1352 //*************************************************************************************************
1354 template< typename Type, bool SO >
1355 struct IsUniform< ZeroMatrix<Type,SO> >
1356  : public TrueType
1357 {};
1359 //*************************************************************************************************
1360 
1361 
1362 
1363 
1364 //=================================================================================================
1365 //
1366 // ISZERO SPECIALIZATIONS
1367 //
1368 //=================================================================================================
1369 
1370 //*************************************************************************************************
1372 template< typename Type, bool SO >
1373 struct IsZero< ZeroMatrix<Type,SO> >
1374  : public TrueType
1375 {};
1377 //*************************************************************************************************
1378 
1379 
1380 
1381 
1382 //=================================================================================================
1383 //
1384 // ISRESIZABLE SPECIALIZATIONS
1385 //
1386 //=================================================================================================
1387 
1388 //*************************************************************************************************
1390 template< typename Type, bool SO >
1391 struct IsResizable< ZeroMatrix<Type,SO> >
1392  : public TrueType
1393 {};
1395 //*************************************************************************************************
1396 
1397 
1398 
1399 
1400 //=================================================================================================
1401 //
1402 // ADDTRAIT SPECIALIZATIONS
1403 //
1404 //=================================================================================================
1405 
1406 //*************************************************************************************************
1408 template< typename T1, typename T2 >
1409 struct AddTraitEval1< T1, T2
1410  , EnableIf_t< IsMatrix_v<T1> &&
1411  IsMatrix_v<T2> &&
1412  !IsZero_v<T1> && IsZero_v<T2> > >
1413 {
1414  using Type = Rebind_t< ResultType_t<T1>, AddTrait_t< ElementType_t<T1>, ElementType_t<T2> > >;
1415 };
1416 
1417 template< typename T1, typename T2 >
1418 struct AddTraitEval1< T1, T2
1419  , EnableIf_t< IsMatrix_v<T1> &&
1420  IsMatrix_v<T2> &&
1421  IsZero_v<T1> && !IsZero_v<T2> > >
1422 {
1423  using Type = Rebind_t< ResultType_t<T2>, AddTrait_t< ElementType_t<T1>, ElementType_t<T2> > >;
1424 };
1425 
1426 template< typename T1, typename T2 >
1427 struct AddTraitEval1< T1, T2
1428  , EnableIf_t< IsMatrix_v<T1> &&
1429  IsMatrix_v<T2> &&
1430  IsZero_v<T1> && IsZero_v<T2> > >
1431 {
1432  using ET1 = ElementType_t<T1>;
1433  using ET2 = ElementType_t<T2>;
1434 
1435  static constexpr bool SO = ( StorageOrder_v<T1> && StorageOrder_v<T2> );
1436 
1437  using Type = ZeroMatrix< AddTrait_t<ET1,ET2>, SO >;
1438 };
1440 //*************************************************************************************************
1441 
1442 
1443 
1444 
1445 //=================================================================================================
1446 //
1447 // SUBTRAIT SPECIALIZATIONS
1448 //
1449 //=================================================================================================
1450 
1451 //*************************************************************************************************
1453 template< typename T1, typename T2 >
1454 struct SubTraitEval1< T1, T2
1455  , EnableIf_t< IsMatrix_v<T1> &&
1456  IsMatrix_v<T2> &&
1457  !IsZero_v<T1> && IsZero_v<T2> > >
1458 {
1459  using Type = Rebind_t< ResultType_t<T1>, SubTrait_t< ElementType_t<T1>, ElementType_t<T2> > >;
1460 };
1461 
1462 template< typename T1, typename T2 >
1463 struct SubTraitEval1< T1, T2
1464  , EnableIf_t< IsMatrix_v<T1> &&
1465  IsMatrix_v<T2> &&
1466  IsZero_v<T1> && !IsZero_v<T2> && !IsIdentity_v<T2> > >
1467 {
1468  using Type = Rebind_t< ResultType_t<T2>, SubTrait_t< ElementType_t<T1>, ElementType_t<T2> > >;
1469 };
1470 
1471 template< typename T1, typename T2 >
1472 struct SubTraitEval1< T1, T2
1473  , EnableIf_t< IsMatrix_v<T1> &&
1474  IsMatrix_v<T2> &&
1475  IsZero_v<T1> && IsZero_v<T2> > >
1476 {
1477  using ET1 = ElementType_t<T1>;
1478  using ET2 = ElementType_t<T2>;
1479 
1480  static constexpr bool SO = ( StorageOrder_v<T1> && StorageOrder_v<T2> );
1481 
1482  using Type = ZeroMatrix< SubTrait_t<ET1,ET2>, SO >;
1483 };
1485 //*************************************************************************************************
1486 
1487 
1488 
1489 
1490 //=================================================================================================
1491 //
1492 // SCHURTRAIT SPECIALIZATIONS
1493 //
1494 //=================================================================================================
1495 
1496 //*************************************************************************************************
1498 template< typename T1, typename T2 >
1499 struct SchurTraitEval1< T1, T2
1500  , EnableIf_t< IsMatrix_v<T1> &&
1501  IsMatrix_v<T2> &&
1502  ( IsZero_v<T1> ||
1503  IsZero_v<T2> ||
1504  ( IsStrictlyLower_v<T1> && IsUpper_v<T2> ) ||
1505  ( IsStrictlyUpper_v<T1> && IsLower_v<T2> ) ||
1506  ( IsLower_v<T1> && IsStrictlyUpper_v<T2> ) ||
1507  ( IsUpper_v<T1> && IsStrictlyLower_v<T2> ) ) > >
1508 {
1509  using ET1 = ElementType_t<T1>;
1510  using ET2 = ElementType_t<T2>;
1511 
1512  static constexpr bool SO1 = StorageOrder_v<T1>;
1513  static constexpr bool SO2 = StorageOrder_v<T2>;
1514 
1515  static constexpr bool SO = ( IsSparseMatrix_v<T1> ^ IsSparseMatrix_v<T2>
1516  ? ( IsSparseMatrix_v<T1>
1517  ? SO1
1518  : SO2 )
1519  : SO1 && SO2 );
1520 
1521  using Type = ZeroMatrix< MultTrait_t<ET1,ET2>, SO >;
1522 };
1524 //*************************************************************************************************
1525 
1526 
1527 
1528 
1529 //=================================================================================================
1530 //
1531 // MULTTRAIT SPECIALIZATIONS
1532 //
1533 //=================================================================================================
1534 
1535 //*************************************************************************************************
1537 template< typename T1, typename T2 >
1538 struct MultTraitEval1< T1, T2
1539  , EnableIf_t< IsMatrix_v<T1> && IsZero_v<T1> && IsNumeric_v<T2> > >
1540 {
1541  using Type = ZeroMatrix< MultTrait_t< ElementType_t<T1>, T2 >, StorageOrder_v<T1> >;
1542 };
1543 
1544 template< typename T1, typename T2 >
1545 struct MultTraitEval1< T1, T2
1546  , EnableIf_t< IsNumeric_v<T1> && IsMatrix_v<T2> && IsZero_v<T2> > >
1547 {
1548  using Type = ZeroMatrix< MultTrait_t< T1, ElementType_t<T2> >, StorageOrder_v<T2> >;
1549 };
1550 
1551 template< typename T1, typename T2 >
1552 struct MultTraitEval1< T1, T2
1553  , EnableIf_t< IsColumnVector_v<T1> &&
1554  IsRowVector_v<T2> &&
1555  ( IsZero_v<T1> || IsZero_v<T2> ) > >
1556 {
1557  using ET1 = ElementType_t<T1>;
1558  using ET2 = ElementType_t<T2>;
1559 
1560  static constexpr bool SO = IsSparseVector_v<T1> && IsDenseVector_v<T2>;
1561 
1562  using Type = ZeroMatrix< MultTrait_t<ET1,ET2>, SO >;
1563 };
1564 
1565 template< typename T1, typename T2 >
1566 struct MultTraitEval1< T1, T2
1567  , EnableIf_t< IsMatrix_v<T1> &&
1568  IsMatrix_v<T2> &&
1569  ( IsZero_v<T1> || IsZero_v<T2> ) > >
1570 {
1571  using ET1 = ElementType_t<T1>;
1572  using ET2 = ElementType_t<T2>;
1573 
1574  static constexpr bool SO = ( IsZero_v<T1> ? StorageOrder_v<T1> : StorageOrder_v<T2> );
1575 
1576  using Type = ZeroMatrix< MultTrait_t<ET1,ET2>, SO >;
1577 };
1579 //*************************************************************************************************
1580 
1581 
1582 
1583 
1584 //=================================================================================================
1585 //
1586 // DIVTRAIT SPECIALIZATIONS
1587 //
1588 //=================================================================================================
1589 
1590 //*************************************************************************************************
1592 template< typename T1, typename T2 >
1593 struct DivTraitEval1< T1, T2
1594  , EnableIf_t< IsMatrix_v<T1> &&
1595  IsNumeric_v<T2> &&
1596  IsZero_v<T1> > >
1597 {
1598  using ET1 = ElementType_t<T1>;
1599 
1600  using Type = ZeroMatrix< DivTrait_t<ET1,T2>, StorageOrder_v<T1> >;
1601 };
1603 //*************************************************************************************************
1604 
1605 
1606 
1607 
1608 //=================================================================================================
1609 //
1610 // MAPTRAIT SPECIALIZATIONS
1611 //
1612 //=================================================================================================
1613 
1614 //*************************************************************************************************
1616 template< typename T, typename OP >
1617 struct UnaryMapTraitEval1< T, OP
1618  , EnableIf_t< IsMatrix_v<T> &&
1619  YieldsZero_v<OP,T> > >
1620 {
1621  using ET = ElementType_t<T>;
1622 
1623  using Type = ZeroMatrix< MapTrait_t<ET,OP>, StorageOrder_v<T> >;
1624 };
1626 //*************************************************************************************************
1627 
1628 
1629 //*************************************************************************************************
1631 template< typename T1, typename T2, typename OP >
1632 struct BinaryMapTraitEval1< T1, T2, OP
1633  , EnableIf_t< IsMatrix_v<T1> &&
1634  IsMatrix_v<T2> &&
1635  YieldsZero_v<OP,T1,T2> > >
1636 {
1637  using ET1 = ElementType_t<T1>;
1638  using ET2 = ElementType_t<T2>;
1639 
1640  static constexpr bool SO = StorageOrder_v<T1> && StorageOrder_v<T2>;
1641 
1642  using Type = ZeroMatrix< MapTrait_t<ET1,ET2,OP>, SO >;
1643 };
1645 //*************************************************************************************************
1646 
1647 
1648 
1649 
1650 //=================================================================================================
1651 //
1652 // EXPANDTRAIT SPECIALIZATIONS
1653 //
1654 //=================================================================================================
1655 
1656 //*************************************************************************************************
1658 template< typename T // Type to be expanded
1659  , size_t E > // Compile time expansion
1660 struct ExpandTraitEval1< T, E
1661  , EnableIf_t< IsVector_v<T> &&
1662  IsZero_v<T> > >
1663 {
1664  static constexpr bool TF = ( IsColumnVector_v<T> ? columnMajor : rowMajor );
1665 
1666  using Type = ZeroMatrix< ElementType_t<T>, TF >;
1667 };
1669 //*************************************************************************************************
1670 
1671 
1672 
1673 
1674 //=================================================================================================
1675 //
1676 // HIGHTYPE SPECIALIZATIONS
1677 //
1678 //=================================================================================================
1679 
1680 //*************************************************************************************************
1682 template< typename T1, bool SO, typename T2 >
1683 struct HighType< ZeroMatrix<T1,SO>, ZeroMatrix<T2,SO> >
1684 {
1685  using Type = ZeroMatrix< typename HighType<T1,T2>::Type, SO >;
1686 };
1688 //*************************************************************************************************
1689 
1690 
1691 
1692 
1693 //=================================================================================================
1694 //
1695 // LOWTYPE SPECIALIZATIONS
1696 //
1697 //=================================================================================================
1698 
1699 //*************************************************************************************************
1701 template< typename T1, bool SO, typename T2 >
1702 struct LowType< ZeroMatrix<T1,SO>, ZeroMatrix<T2,SO> >
1703 {
1704  using Type = ZeroMatrix< typename LowType<T1,T2>::Type, SO >;
1705 };
1707 //*************************************************************************************************
1708 
1709 
1710 
1711 
1712 //=================================================================================================
1713 //
1714 // SUBMATRIXTRAIT SPECIALIZATIONS
1715 //
1716 //=================================================================================================
1717 
1718 //*************************************************************************************************
1720 template< typename MT, size_t I, size_t J, size_t M, size_t N >
1721 struct SubmatrixTraitEval1< MT, I, J, M, N
1722  , EnableIf_t< IsZero_v<MT> > >
1723 {
1724  using Type = ZeroMatrix< RemoveConst_t< ElementType_t<MT> >, StorageOrder_v<MT> >;
1725 };
1727 //*************************************************************************************************
1728 
1729 
1730 
1731 
1732 //=================================================================================================
1733 //
1734 // ROWSTRAIT SPECIALIZATIONS
1735 //
1736 //=================================================================================================
1737 
1738 //*************************************************************************************************
1740 template< typename MT, size_t M >
1741 struct RowsTraitEval1< MT, M
1742  , EnableIf_t< IsZero_v<MT> > >
1743 {
1744  using Type = ZeroMatrix< RemoveConst_t< ElementType_t<MT> >, false >;
1745 };
1747 //*************************************************************************************************
1748 
1749 
1750 
1751 
1752 //=================================================================================================
1753 //
1754 // COLUMNSTRAIT SPECIALIZATIONS
1755 //
1756 //=================================================================================================
1757 
1758 //*************************************************************************************************
1760 template< typename MT, size_t N >
1761 struct ColumnsTraitEval1< MT, N
1762  , EnableIf_t< IsZero_v<MT> > >
1763 {
1764  using Type = ZeroMatrix< RemoveConst_t< ElementType_t<MT> >, true >;
1765 };
1767 //*************************************************************************************************
1768 
1769 } // namespace blaze
1770 
1771 #endif
Efficient implementation of an zero matrix.The ZeroMatrix class template is the representation of an...
Definition: Forward.h:50
constexpr ConstIterator end(size_t i) const noexcept
Returns an iterator just past the last non-zero element of row/column i.
Definition: ZeroMatrix.h:534
#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
Resize mechanism to obtain a ZeroMatrix with different fixed dimensions.
Definition: ZeroMatrix.h:216
Header file for auxiliary alias declarations.
Header file for the Schur product 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.
constexpr size_t nonZeros() const noexcept
Returns the number of non-zero elements in the zero matrix.
Definition: ZeroMatrix.h:691
Header file for the subtraction trait.
Header file for basic type definitions.
constexpr bool IsMatrix_v
Auxiliary variable template for the IsMatrix type trait.The IsMatrix_v variable template provides a c...
Definition: IsMatrix.h:139
const Type & Reference
Reference to a zero matrix element.
Definition: ZeroMatrix.h:196
Header file for the IsSparseMatrix type trait.
Header file for the isZero shim.
const Type & ReturnType
Return type for expression template evaluations.
Definition: ZeroMatrix.h:194
Header file for the YieldsZero type trait.
void reset(const DiagonalProxy< MT > &proxy)
Resetting the represented element to the default initial values.
Definition: DiagonalProxy.h:591
size_t m_
The current number of rows of the compressed matrix.
Definition: CompressedMatrix.h:3289
Header file for the IsRowVector type trait.
static constexpr bool smpAssignable
Compilation flag for SMP assignments.
Definition: ZeroMatrix.h:226
Header file for the IsIdentity type trait.
#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
BoolConstant< true > TrueType
Type traits base class.The TrueType class is used as base class for type traits and value traits that...
Definition: TrueType.h:61
Element * Iterator
Iterator over non-constant elements.
Definition: CompressedMatrix.h:3085
constexpr void swap(ZeroMatrix &m) noexcept
Swapping the contents of two zero matrices.
Definition: ZeroMatrix.h:768
constexpr void UNUSED_PARAMETER(const Args &...)
Suppression of unused parameter warnings.
Definition: Unused.h:81
constexpr size_t rows() const noexcept
Returns the current number of rows of the zero matrix.
Definition: ZeroMatrix.h:625
ConstIterator find(size_t i, size_t j) const
Searches for a specific matrix element.
Definition: ZeroMatrix.h:805
constexpr size_t columns(const Matrix< MT, SO > &matrix) noexcept
Returns the current number of columns of the matrix.
Definition: Matrix.h:514
constexpr bool rowMajor
Storage order flag for row-major matrices.
Definition: StorageOrder.h:71
ConstIterator upperBound(size_t i, size_t j) const
Returns an iterator to the first index greater then the given index.
Definition: ZeroMatrix.h:861
bool canSMPAssign() const noexcept
Returns whether the matrix can be used in SMP assignments.
Definition: ZeroMatrix.h:981
Base class for sparse matrices.The SparseMatrix class is a base class for all sparse matrix classes...
Definition: Forward.h:137
size_t m_
The current number of rows of the zero matrix.
Definition: ZeroMatrix.h:319
Constraint on the data type.
Header file for the IsMatrix type trait.
Header file for the SparseMatrix base class.
ConstReference at(size_t i, size_t j) const
Checked access to the matrix elements.
Definition: ZeroMatrix.h:456
bool isZero(const DiagonalProxy< MT > &proxy)
Returns whether the represented element is 0.
Definition: DiagonalProxy.h:673
typename EnableIf< Condition, T >::Type EnableIf_t
Auxiliary type for the EnableIf class template.The EnableIf_t alias declaration provides a convenient...
Definition: EnableIf.h:138
constexpr bool columnMajor
Storage order flag for column-major matrices.
Definition: StorageOrder.h:99
Header file for the ValueIndexPair class.
Header file for the LowType type trait.
Header file for the IsUniform type trait.
Header file for the multiplication trait.
Header file for the IsStrictlyUpper type trait.
bool canAlias(const Other *alias) const noexcept
Returns whether the matrix can alias with the given address alias.
Definition: ZeroMatrix.h:938
Namespace of the Blaze C++ math library.
Definition: Blaze.h:58
Rebind mechanism to obtain a ZeroMatrix with different data/element type.
Definition: ZeroMatrix.h:206
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
Header file for the IsSMPAssignable type trait.
Header file for the expand trait.
constexpr bool IsColumnVector_v
Auxiliary variable template for the IsColumnVector type trait.The IsColumnVector_v variable template ...
Definition: IsColumnVector.h:143
constexpr ConstReference operator()(size_t i, size_t j) const noexcept
2D-access to the zero matrix elements.
Definition: ZeroMatrix.h:430
#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
constexpr void clear() noexcept
Clearing the zero matrix.
Definition: ZeroMatrix.h:731
ZeroMatrix< Type, SO > This
Type of this ZeroMatrix instance.
Definition: ZeroMatrix.h:188
size_t n_
The current number of columns of the zero matrix.
Definition: ZeroMatrix.h:320
constexpr ZeroMatrix & transpose() noexcept
In-place transpose of the matrix.
Definition: ZeroMatrix.h:888
ConstIterator lowerBound(size_t i, size_t j) const
Returns an iterator to the first index not less then the given index.
Definition: ZeroMatrix.h:833
constexpr bool IsNumeric_v
Auxiliary variable template for the IsNumeric type trait.The IsNumeric_v variable template provides a...
Definition: IsNumeric.h:143
Constraint on the data type.
ZeroMatrix< ElementType_t< MT >, SO > declzero(const Matrix< MT, SO > &m)
Declares the given matrix expression m as zero matrix.
Definition: ZeroMatrix.h:1335
constexpr ZeroMatrix() noexcept
The default constructor for ZeroMatrix.
Definition: ZeroMatrix.h:363
Header file for the IsLower type trait.
constexpr size_t capacity() const noexcept
Returns the maximum capacity of the zero matrix.
Definition: ZeroMatrix.h:653
static const Type zero_
The zero element.
Definition: ZeroMatrix.h:322
constexpr bool IsVector_v
Auxiliary variable template for the IsVector type trait.The IsVector_v variable template provides a c...
Definition: IsVector.h:140
Header file for the default storage order for all vectors of the Blaze library.
const Type & ConstReference
Reference to a constant zero matrix element.
Definition: ZeroMatrix.h:197
Header file for the exception macros of the math module.
bool isAliased(const Other *alias) const noexcept
Returns whether the matrix is aliased with the given address alias.
Definition: ZeroMatrix.h:960
Header file for the IsVector type trait.
Header file for the EnableIf class template.
Header file for the IsStrictlyLower type trait.
void clear(const DiagonalProxy< MT > &proxy)
Clearing the represented element.
Definition: DiagonalProxy.h:611
constexpr bool IsZero_v
Auxiliary variable template for the IsZero type trait.The IsZero_v variable template provides a conve...
Definition: IsZero.h:165
Header file for the RemoveConst type trait.
Header file for the IsSparseVector type trait.
constexpr void resize(size_t m, size_t n) noexcept
Changing the size of the zero matrix.
Definition: ZeroMatrix.h:752
constexpr ConstIterator cend(size_t i) const noexcept
Returns an iterator just past the last non-zero element of row/column i.
Definition: ZeroMatrix.h:559
Header file for run time assertion macros.
Header file for the addition trait.
Header file for the division trait.
Header file for the submatrix trait.
Constraint on the data type.
Header file for the columns trait.
constexpr ZeroMatrix & ctranspose() noexcept
In-place conjugate transpose of the matrix.
Definition: ZeroMatrix.h:906
Header file for the IsZero type trait.
#define BLAZE_FUNCTION_TRACE
Function trace macro.This macro can be used to reliably trace function calls. In case function tracin...
Definition: FunctionTrace.h:94
#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
void swap(DiagonalMatrix< MT, SO, DF > &a, DiagonalMatrix< MT, SO, DF > &b) noexcept
Swapping the contents of two matrices.
Definition: DiagonalMatrix.h:281
Base class for matrices.The Matrix class is a base class for all dense and sparse matrix classes with...
Definition: Forward.h:109
Constraint on the data type.
Type ElementType
Type of the zero matrix elements.
Definition: ZeroMatrix.h:193
constexpr size_t rows(const Matrix< MT, SO > &matrix) noexcept
Returns the current number of rows of the matrix.
Definition: Matrix.h:498
Header file for the IsDenseVector type trait.
Header file for the rows trait.
constexpr ConstIterator begin(size_t i) const noexcept
Returns an iterator to the first non-zero element of row/column i.
Definition: ZeroMatrix.h:484
size_t n_
The current number of columns of the compressed matrix.
Definition: CompressedMatrix.h:3290
Index-value-pair for sparse vectors and matrices.The ValueIndexPair class represents a single index-v...
Definition: ValueIndexPair.h:73
static const Type zero_
Neutral element for accesses to zero elements.
Definition: CompressedMatrix.h:3295
Header file for the StorageOrder type trait.
Header file for the map trait.
bool isIntact(const DiagonalMatrix< MT, SO, DF > &m)
Returns whether the invariants of the given diagonal matrix are intact.
Definition: DiagonalMatrix.h:263
bool isDefault(const DiagonalProxy< MT > &proxy)
Returns whether the represented element is in default state.
Definition: DiagonalProxy.h:631
Header file for the IsUpper type trait.
Header file for the IsColumnVector type trait.
Header file for the IsResizable type trait.
constexpr ConstIterator cbegin(size_t i) const noexcept
Returns an iterator to the first non-zero element of row/column i.
Definition: ZeroMatrix.h:509
Header file for the HighType type trait.
Header file for the TrueType type/value trait base class.
Header file for the function trace functionality.
constexpr size_t columns() const noexcept
Returns the current number of columns of the zero matrix.
Definition: ZeroMatrix.h:639