DenseMatrix.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_DENSE_DENSEMATRIX_H_
36 #define _BLAZE_MATH_DENSE_DENSEMATRIX_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <blaze/math/Aliases.h>
48 #include <blaze/math/Functions.h>
50 #include <blaze/math/shims/Equal.h>
52 #include <blaze/math/shims/IsNaN.h>
53 #include <blaze/math/shims/IsOne.h>
70 #include <blaze/util/Assert.h>
71 #include <blaze/util/EnableIf.h>
72 #include <blaze/util/FalseType.h>
73 #include <blaze/util/mpl/If.h>
74 #include <blaze/util/TrueType.h>
75 #include <blaze/util/Types.h>
78 
79 
80 namespace blaze {
81 
82 //=================================================================================================
83 //
84 // GLOBAL OPERATORS
85 //
86 //=================================================================================================
87 
88 //*************************************************************************************************
91 template< typename T1, typename T2 >
92 inline bool operator==( const DenseMatrix<T1,false>& lhs, const DenseMatrix<T2,false>& rhs );
93 
94 template< typename T1, typename T2 >
95 inline bool operator==( const DenseMatrix<T1,true>& lhs, const DenseMatrix<T2,true>& rhs );
96 
97 template< typename T1, typename T2, bool SO >
98 inline bool operator==( const DenseMatrix<T1,SO>& lhs, const DenseMatrix<T2,!SO>& rhs );
99 
100 template< typename T1, typename T2, bool SO >
101 inline bool operator==( const DenseMatrix<T1,SO>& lhs, const SparseMatrix<T2,false>& rhs );
102 
103 template< typename T1, typename T2, bool SO >
104 inline bool operator==( const DenseMatrix<T1,SO>& lhs, const SparseMatrix<T2,true>& rhs );
105 
106 template< typename T1, bool SO1, typename T2, bool SO2 >
107 inline bool operator==( const SparseMatrix<T1,SO1>& lhs, const DenseMatrix<T2,SO2>& rhs );
108 
109 template< typename T1, typename T2 >
110 inline EnableIf_<IsNumeric<T2>, bool > operator==( const DenseMatrix<T1,false>& mat, T2 scalar );
111 
112 template< typename T1, typename T2 >
113 inline EnableIf_<IsNumeric<T2>, bool > operator==( const DenseMatrix<T1,true>& mat, T2 scalar );
114 
115 template< typename T1, typename T2, bool SO >
116 inline EnableIf_<IsNumeric<T2>, bool > operator==( T1 scalar, const DenseMatrix<T2,SO>& mat );
117 
118 template< typename T1, bool SO1, typename T2, bool SO2 >
119 inline bool operator!=( const DenseMatrix<T1,SO1>& lhs, const DenseMatrix<T2,SO2>& rhs );
120 
121 template< typename T1, bool SO1, typename T2, bool SO2 >
122 inline bool operator!=( const DenseMatrix<T1,SO1>& lhs, const SparseMatrix<T2,SO2>& rhs );
123 
124 template< typename T1, bool SO1, typename T2, bool SO2 >
125 inline bool operator!=( const SparseMatrix<T1,SO1>& lhs, const DenseMatrix<T2,SO2>& rhs );
126 
127 template< typename T1, typename T2, bool SO >
128 inline EnableIf_<IsNumeric<T2>, bool > operator!=( const DenseMatrix<T1,SO>& mat, T2 scalar );
129 
130 template< typename T1, typename T2, bool SO >
131 inline EnableIf_<IsNumeric<T2>, bool > operator!=( T1 scalar, const DenseMatrix<T2,SO>& mat );
133 //*************************************************************************************************
134 
135 
136 //*************************************************************************************************
144 template< typename T1 // Type of the left-hand side dense matrix
145  , typename T2 > // Type of the right-hand side dense matrix
146 inline bool operator==( const DenseMatrix<T1,false>& lhs, const DenseMatrix<T2,false>& rhs )
147 {
148  typedef CompositeType_<T1> CT1;
149  typedef CompositeType_<T2> CT2;
150 
151  // Early exit in case the matrix sizes don't match
152  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() )
153  return false;
154 
155  // Evaluation of the two dense matrix operands
156  CT1 A( ~lhs );
157  CT2 B( ~rhs );
158 
159  // In order to compare the two matrices, the data values of the lower-order data
160  // type are converted to the higher-order data type within the equal function.
161  for( size_t i=0; i<A.rows(); ++i ) {
162  for( size_t j=0; j<A.columns(); ++j ) {
163  if( !equal( A(i,j), B(i,j) ) ) return false;
164  }
165  }
166 
167  return true;
168 }
169 //*************************************************************************************************
170 
171 
172 //*************************************************************************************************
180 template< typename T1 // Type of the left-hand side dense matrix
181  , typename T2 > // Type of the right-hand side dense matrix
182 inline bool operator==( const DenseMatrix<T1,true>& lhs, const DenseMatrix<T2,true>& rhs )
183 {
184  typedef CompositeType_<T1> CT1;
185  typedef CompositeType_<T2> CT2;
186 
187  // Early exit in case the matrix sizes don't match
188  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() )
189  return false;
190 
191  // Evaluation of the two dense matrix operands
192  CT1 A( ~lhs );
193  CT2 B( ~rhs );
194 
195  // In order to compare the two matrices, the data values of the lower-order data
196  // type are converted to the higher-order data type within the equal function.
197  for( size_t j=0; j<A.columns(); ++j ) {
198  for( size_t i=0; i<A.rows(); ++i ) {
199  if( !equal( A(i,j), B(i,j) ) ) return false;
200  }
201  }
202 
203  return true;
204 }
205 //*************************************************************************************************
206 
207 
208 //*************************************************************************************************
216 template< typename T1 // Type of the left-hand side dense matrix
217  , typename T2 // Type of the right-hand side dense matrix
218  , bool SO > // Storage order
219 inline bool operator==( const DenseMatrix<T1,SO>& lhs, const DenseMatrix<T2,!SO>& rhs )
220 {
221  typedef CompositeType_<T1> CT1;
222  typedef CompositeType_<T2> CT2;
223 
224  // Early exit in case the matrix sizes don't match
225  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() )
226  return false;
227 
228  // Evaluation of the two dense matrix operands
229  CT1 A( ~lhs );
230  CT2 B( ~rhs );
231 
232  // In order to compare the two matrices, the data values of the lower-order data
233  // type are converted to the higher-order data type within the equal function.
234  const size_t rows ( A.rows() );
235  const size_t columns( A.columns() );
236  const size_t block ( 16 );
237 
238  for( size_t ii=0; ii<rows; ii+=block ) {
239  const size_t iend( ( rows < ii+block )?( rows ):( ii+block ) );
240  for( size_t jj=0; jj<columns; jj+=block ) {
241  const size_t jend( ( columns < jj+block )?( columns ):( jj+block ) );
242  for( size_t i=ii; i<iend; ++i ) {
243  for( size_t j=jj; j<jend; ++j ) {
244  if( !equal( A(i,j), B(i,j) ) ) return false;
245  }
246  }
247  }
248  }
249 
250  return true;
251 }
252 //*************************************************************************************************
253 
254 
255 //*************************************************************************************************
263 template< typename T1 // Type of the left-hand side dense matrix
264  , typename T2 // Type of the right-hand side sparse matrix
265  , bool SO > // Storage order of the left-hand side dense matrix
266 inline bool operator==( const DenseMatrix<T1,SO>& lhs, const SparseMatrix<T2,false>& rhs )
267 {
268  typedef CompositeType_<T1> CT1;
269  typedef CompositeType_<T2> CT2;
271 
272  // Early exit in case the matrix sizes don't match
273  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() )
274  return false;
275 
276  // Evaluation of the dense matrix and sparse matrix operand
277  CT1 A( ~lhs );
278  CT2 B( ~rhs );
279 
280  // In order to compare the two matrices, the data values of the lower-order data
281  // type are converted to the higher-order data type within the equal function.
282  size_t j( 0 );
283 
284  for( size_t i=0; i<B.rows(); ++i ) {
285  j = 0;
286  for( ConstIterator element=B.begin(i); element!=B.end(i); ++element, ++j ) {
287  for( ; j<element->index(); ++j ) {
288  if( !isDefault( A(i,j) ) ) return false;
289  }
290  if( !equal( element->value(), A(i,j) ) ) return false;
291  }
292  for( ; j<A.columns(); ++j ) {
293  if( !isDefault( A(i,j) ) ) return false;
294  }
295  }
296 
297  return true;
298 }
299 //*************************************************************************************************
300 
301 
302 //*************************************************************************************************
310 template< typename T1 // Type of the left-hand side dense matrix
311  , typename T2 // Type of the right-hand side sparse matrix
312  , bool SO > // Storage order of the left-hand side dense matrix
313 inline bool operator==( const DenseMatrix<T1,SO>& lhs, const SparseMatrix<T2,true>& rhs )
314 {
315  typedef CompositeType_<T1> CT1;
316  typedef CompositeType_<T2> CT2;
318 
319  // Early exit in case the matrix sizes don't match
320  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() )
321  return false;
322 
323  // Evaluation of the dense matrix and sparse matrix operand
324  CT1 A( ~lhs );
325  CT2 B( ~rhs );
326 
327  // In order to compare the two matrices, the data values of the lower-order data
328  // type are converted to the higher-order data type within the equal function.
329  size_t i( 0 );
330 
331  for( size_t j=0; j<B.columns(); ++j ) {
332  i = 0;
333  for( ConstIterator element=B.begin(j); element!=B.end(j); ++element, ++i ) {
334  for( ; i<element->index(); ++i ) {
335  if( !isDefault( A(i,j) ) ) return false;
336  }
337  if( !equal( element->value(), A(i,j) ) ) return false;
338  }
339  for( ; i<A.rows(); ++i ) {
340  if( !isDefault( A(i,j) ) ) return false;
341  }
342  }
343 
344  return true;
345 }
346 //*************************************************************************************************
347 
348 
349 //*************************************************************************************************
357 template< typename T1 // Type of the left-hand side sparse matrix
358  , bool SO1 // Storage order of the left-hand side sparse matrix
359  , typename T2 // Type of the right-hand side dense matrix
360  , bool SO2 > // Storage order of the right-hand side sparse matrix
361 inline bool operator==( const SparseMatrix<T1,SO1>& lhs, const DenseMatrix<T2,SO2>& rhs )
362 {
363  return ( rhs == lhs );
364 }
365 //*************************************************************************************************
366 
367 
368 //*************************************************************************************************
380 template< typename T1 // Type of the left-hand side dense matrix
381  , typename T2 > // Type of the right-hand side scalar
382 inline EnableIf_<IsNumeric<T2>, bool > operator==( const DenseMatrix<T1,false>& mat, T2 scalar )
383 {
384  typedef CompositeType_<T1> CT1;
385 
386  // Evaluation of the dense matrix operand
387  CT1 A( ~mat );
388 
389  // In order to compare the matrix and the scalar value, the data values of the lower-order
390  // data type are converted to the higher-order data type within the equal function.
391  for( size_t i=0; i<A.rows(); ++i ) {
392  for( size_t j=0; j<A.columns(); ++j ) {
393  if( !equal( A(i,j), scalar ) ) return false;
394  }
395  }
396 
397  return true;
398 }
399 //*************************************************************************************************
400 
401 
402 //*************************************************************************************************
414 template< typename T1 // Type of the left-hand side dense matrix
415  , typename T2 > // Type of the right-hand side scalar
416 inline EnableIf_<IsNumeric<T2>, bool > operator==( const DenseMatrix<T1,true>& mat, T2 scalar )
417 {
418  typedef CompositeType_<T1> CT1;
419 
420  // Evaluation of the dense matrix operand
421  CT1 A( ~mat );
422 
423  // In order to compare the matrix and the scalar value, the data values of the lower-order
424  // data type are converted to the higher-order data type within the equal function.
425  for( size_t j=0; j<A.columns(); ++j ) {
426  for( size_t i=0; i<A.rows(); ++i ) {
427  if( !equal( A(i,j), scalar ) ) return false;
428  }
429  }
430 
431  return true;
432 }
433 //*************************************************************************************************
434 
435 
436 //*************************************************************************************************
448 template< typename T1 // Type of the left-hand side scalar
449  , typename T2 // Type of the right-hand side dense matrix
450  , bool SO > // Storage order
451 inline EnableIf_<IsNumeric<T1>, bool > operator==( T1 scalar, const DenseMatrix<T2,SO>& mat )
452 {
453  return ( mat == scalar );
454 }
455 //*************************************************************************************************
456 
457 
458 //*************************************************************************************************
466 template< typename T1 // Type of the left-hand side dense matrix
467  , bool SO1 // Storage order of the left-hand side dense matrix
468  , typename T2 // Type of the right-hand side dense matrix
469  , bool SO2 > // Storage order of the right-hand side dense matrix
470 inline bool operator!=( const DenseMatrix<T1,SO1>& lhs, const DenseMatrix<T2,SO2>& rhs )
471 {
472  return !( lhs == rhs );
473 }
474 //*************************************************************************************************
475 
476 
477 //*************************************************************************************************
485 template< typename T1 // Type of the left-hand side dense matrix
486  , bool SO1 // Storage order of the left-hand side dense matrix
487  , typename T2 // Type of the right-hand side sparse matrix
488  , bool SO2 > // Storage order of the right-hand side sparse matrix
489 inline bool operator!=( const DenseMatrix<T1,SO1>& lhs, const SparseMatrix<T2,SO2>& rhs )
490 {
491  return !( lhs == rhs );
492 }
493 //*************************************************************************************************
494 
495 
496 //*************************************************************************************************
504 template< typename T1 // Type of the left-hand side sparse matrix
505  , bool SO1 // Storage order of the left-hand side sparse matrix
506  , typename T2 // Type of the right-hand side dense matrix
507  , bool SO2 > // Storage order right-hand side dense matrix
508 inline bool operator!=( const SparseMatrix<T1,SO1>& lhs, const DenseMatrix<T2,SO2>& rhs )
509 {
510  return !( rhs == lhs );
511 }
512 //*************************************************************************************************
513 
514 
515 //*************************************************************************************************
527 template< typename T1 // Type of the left-hand side dense matrix
528  , typename T2 // Type of the right-hand side scalar
529  , bool SO > // Storage order
530 inline EnableIf_<IsNumeric<T2>, bool > operator!=( const DenseMatrix<T1,SO>& mat, T2 scalar )
531 {
532  return !( mat == scalar );
533 }
534 //*************************************************************************************************
535 
536 
537 //*************************************************************************************************
549 template< typename T1 // Type of the left-hand side scalar
550  , typename T2 // Type of the right-hand side dense matrix
551  , bool SO > // Storage order
552 inline EnableIf_<IsNumeric<T1>, bool > operator!=( T1 scalar, const DenseMatrix<T2,SO>& mat )
553 {
554  return !( mat == scalar );
555 }
556 //*************************************************************************************************
557 
558 
559 
560 
561 //=================================================================================================
562 //
563 // GLOBAL FUNCTIONS
564 //
565 //=================================================================================================
566 
567 //*************************************************************************************************
570 template< typename MT, bool SO >
571 bool isnan( const DenseMatrix<MT,SO>& dm );
572 
573 template< bool RF, typename MT, bool SO >
574 bool isSymmetric( const DenseMatrix<MT,SO>& dm );
575 
576 template< bool RF, typename MT, bool SO >
577 bool isHermitian( const DenseMatrix<MT,SO>& dm );
578 
579 template< bool RF, typename MT, bool SO >
580 bool isUniform( const DenseMatrix<MT,SO>& dm );
581 
582 template< bool RF, typename MT, bool SO >
583 bool isLower( const DenseMatrix<MT,SO>& dm );
584 
585 template< bool RF, typename MT, bool SO >
586 bool isUniLower( const DenseMatrix<MT,SO>& dm );
587 
588 template< bool RF, typename MT, bool SO >
589 bool isStrictlyLower( const DenseMatrix<MT,SO>& dm );
590 
591 template< bool RF, typename MT, bool SO >
592 bool isUpper( const DenseMatrix<MT,SO>& dm );
593 
594 template< bool RF, typename MT, bool SO >
595 bool isUniUpper( const DenseMatrix<MT,SO>& dm );
596 
597 template< bool RF, typename MT, bool SO >
598 bool isStrictlyUpper( const DenseMatrix<MT,SO>& dm );
599 
600 template< bool RF, typename MT, bool SO >
601 bool isDiagonal( const DenseMatrix<MT,SO>& dm );
602 
603 template< bool RF, typename MT, bool SO >
604 bool isIdentity( const DenseMatrix<MT,SO>& dm );
605 
606 template< typename MT, bool SO >
607 const ElementType_<MT> min( const DenseMatrix<MT,SO>& dm );
608 
609 template< typename MT, bool SO >
610 const ElementType_<MT> max( const DenseMatrix<MT,SO>& dm );
612 //*************************************************************************************************
613 
614 
615 //*************************************************************************************************
635 template< typename MT // Type of the dense matrix
636  , bool SO > // Storage order
637 bool isnan( const DenseMatrix<MT,SO>& dm )
638 {
639  typedef CompositeType_<MT> CT;
640 
641  CT A( ~dm ); // Evaluation of the dense matrix operand
642 
643  if( SO == rowMajor ) {
644  for( size_t i=0UL; i<A.rows(); ++i ) {
645  for( size_t j=0UL; j<A.columns(); ++j )
646  if( isnan( A(i,j) ) ) return true;
647  }
648  }
649  else {
650  for( size_t j=0UL; j<A.columns(); ++j ) {
651  for( size_t i=0UL; i<A.rows(); ++i )
652  if( isnan( A(i,j) ) ) return true;
653  }
654  }
655 
656  return false;
657 }
658 //*************************************************************************************************
659 
660 
661 //*************************************************************************************************
694 template< bool RF // Relaxation flag
695  , typename MT // Type of the dense matrix
696  , bool SO > // Storage order
698 {
699  typedef CompositeType_<MT> CT;
700 
702  return true;
703 
704  if( !isSquare( ~dm ) )
705  return false;
706 
707  if( (~dm).rows() < 2UL )
708  return true;
709 
711  return isDiagonal( ~dm );
712 
713  CT A( ~dm ); // Evaluation of the dense matrix operand
714 
715  if( SO == rowMajor ) {
716  for( size_t i=1UL; i<A.rows(); ++i ) {
717  for( size_t j=0UL; j<i; ++j ) {
718  if( !equal<RF>( A(i,j), A(j,i) ) )
719  return false;
720  }
721  }
722  }
723  else {
724  for( size_t j=1UL; j<A.columns(); ++j ) {
725  for( size_t i=0UL; i<j; ++i ) {
726  if( !equal<RF>( A(i,j), A(j,i) ) )
727  return false;
728  }
729  }
730  }
731 
732  return true;
733 }
734 //*************************************************************************************************
735 
736 
737 //*************************************************************************************************
772 template< bool RF // Relaxation flag
773  , typename MT // Type of the dense matrix
774  , bool SO > // Storage order
776 {
777  typedef ElementType_<MT> ET;
778  typedef CompositeType_<MT> CT;
779 
781  return true;
782 
783  if( !IsNumeric<ET>::value || !isSquare( ~dm ) )
784  return false;
785 
786  CT A( ~dm ); // Evaluation of the dense matrix operand
787 
788  if( SO == rowMajor ) {
789  for( size_t i=0UL; i<A.rows(); ++i ) {
790  for( size_t j=0UL; j<i; ++j ) {
791  if( !equal<RF>( A(i,j), conj( A(j,i) ) ) )
792  return false;
793  }
794  if( !isReal<RF>( A(i,i) ) )
795  return false;
796  }
797  }
798  else {
799  for( size_t j=0UL; j<A.columns(); ++j ) {
800  for( size_t i=0UL; i<j; ++i ) {
801  if( !equal<RF>( A(i,j), conj( A(j,i) ) ) )
802  return false;
803  }
804  if( !isReal<RF>( A(j,j) ) )
805  return false;
806  }
807  }
808 
809  return true;
810 }
811 //*************************************************************************************************
812 
813 
814 //*************************************************************************************************
822 template< bool RF // Relaxation flag
823  , typename MT > // Type of the dense matrix
824 bool isUniform_backend( const DenseMatrix<MT,false>& dm, TrueType )
825 {
828 
829  BLAZE_INTERNAL_ASSERT( (~dm).rows() != 0UL, "Invalid number of rows detected" );
830  BLAZE_INTERNAL_ASSERT( (~dm).columns() != 0UL, "Invalid number of columns detected" );
831 
832  const size_t ibegin( ( IsStrictlyLower<MT>::value )?( 1UL ):( 0UL ) );
833  const size_t iend ( ( IsStrictlyUpper<MT>::value )?( (~dm).rows()-1UL ):( (~dm).rows() ) );
834 
835  for( size_t i=ibegin; i<iend; ++i ) {
836  if( !IsUpper<MT>::value ) {
837  for( size_t j=0UL; j<i; ++j ) {
838  if( !isDefault<RF>( (~dm)(i,j) ) )
839  return false;
840  }
841  }
842  if( !isDefault<RF>( (~dm)(i,i) ) )
843  return false;
844  if( !IsLower<MT>::value ) {
845  for( size_t j=i+1UL; j<(~dm).columns(); ++j ) {
846  if( !isDefault<RF>( (~dm)(i,j) ) )
847  return false;
848  }
849  }
850  }
851 
852  return true;
853 }
855 //*************************************************************************************************
856 
857 
858 //*************************************************************************************************
866 template< bool RF // Relaxation flag
867  , typename MT > // Type of the dense matrix
868 bool isUniform_backend( const DenseMatrix<MT,true>& dm, TrueType )
869 {
872 
873  BLAZE_INTERNAL_ASSERT( (~dm).rows() != 0UL, "Invalid number of rows detected" );
874  BLAZE_INTERNAL_ASSERT( (~dm).columns() != 0UL, "Invalid number of columns detected" );
875 
876  const size_t jbegin( ( IsStrictlyUpper<MT>::value )?( 1UL ):( 0UL ) );
877  const size_t jend ( ( IsStrictlyLower<MT>::value )?( (~dm).columns()-1UL ):( (~dm).columns() ) );
878 
879  for( size_t j=jbegin; j<jend; ++j ) {
880  if( !IsLower<MT>::value ) {
881  for( size_t i=0UL; i<j; ++i ) {
882  if( !isDefault<RF>( (~dm)(i,j) ) )
883  return false;
884  }
885  }
886  if( !isDefault<RF>( (~dm)(j,j) ) )
887  return false;
888  if( !IsUpper<MT>::value ) {
889  for( size_t i=j+1UL; i<(~dm).rows(); ++i ) {
890  if( !isDefault<RF>( (~dm)(i,j) ) )
891  return false;
892  }
893  }
894  }
895 
896  return true;
897 }
899 //*************************************************************************************************
900 
901 
902 //*************************************************************************************************
910 template< bool RF // Relaxation flag
911  , typename MT > // Type of the dense matrix
912 bool isUniform_backend( const DenseMatrix<MT,false>& dm, FalseType )
913 {
916 
917  BLAZE_INTERNAL_ASSERT( (~dm).rows() != 0UL, "Invalid number of rows detected" );
918  BLAZE_INTERNAL_ASSERT( (~dm).columns() != 0UL, "Invalid number of columns detected" );
919 
920  ConstReference_<MT> cmp( (~dm)(0UL,0UL) );
921 
922  for( size_t i=0UL; i<(~dm).rows(); ++i ) {
923  for( size_t j=0UL; j<(~dm).columns(); ++j ) {
924  if( (~dm)(i,j) != cmp )
925  return false;
926  }
927  }
928 
929  return true;
930 }
932 //*************************************************************************************************
933 
934 
935 //*************************************************************************************************
943 template< bool RF // Relaxation flag
944  , typename MT > // Type of the dense matrix
945 bool isUniform_backend( const DenseMatrix<MT,true>& dm, FalseType )
946 {
949 
950  BLAZE_INTERNAL_ASSERT( (~dm).rows() != 0UL, "Invalid number of rows detected" );
951  BLAZE_INTERNAL_ASSERT( (~dm).columns() != 0UL, "Invalid number of columns detected" );
952 
953  ConstReference_<MT> cmp( (~dm)(0UL,0UL) );
954 
955  for( size_t j=0UL; j<(~dm).columns(); ++j ) {
956  for( size_t i=0UL; i<(~dm).rows(); ++i ) {
957  if( (~dm)(i,j) != cmp )
958  return false;
959  }
960  }
961 
962  return true;
963 }
965 //*************************************************************************************************
966 
967 
968 //*************************************************************************************************
1001 template< bool RF // Relaxation flag
1002  , typename MT // Type of the dense matrix
1003  , bool SO > // Storage order
1005 {
1007  return false;
1008 
1009  if( (~dm).rows() == 0UL || (~dm).columns() == 0UL ||
1010  ( (~dm).rows() == 1UL && (~dm).columns() == 1UL ) )
1011  return true;
1012 
1013  CompositeType_<MT> A( ~dm ); // Evaluation of the dense matrix operand
1014 
1015  return isUniform_backend<RF>( A, typename IsTriangular<MT>::Type() );
1016 }
1017 //*************************************************************************************************
1018 
1019 
1020 //*************************************************************************************************
1063 template< bool RF // Relaxation flag
1064  , typename MT // Type of the dense matrix
1065  , bool SO > // Storage order
1066 bool isLower( const DenseMatrix<MT,SO>& dm )
1067 {
1068  typedef ResultType_<MT> RT;
1069  typedef ReturnType_<MT> RN;
1070  typedef CompositeType_<MT> CT;
1071  typedef If_< IsExpression<RN>, const RT, CT > Tmp;
1072 
1073  if( IsLower<MT>::value )
1074  return true;
1075 
1076  if( !isSquare( ~dm ) )
1077  return false;
1078 
1079  if( (~dm).rows() < 2UL )
1080  return true;
1081 
1082  Tmp A( ~dm ); // Evaluation of the dense matrix operand
1083 
1084  if( SO == rowMajor ) {
1085  for( size_t i=0UL; i<A.rows()-1UL; ++i ) {
1086  for( size_t j=i+1UL; j<A.columns(); ++j ) {
1087  if( !isDefault<RF>( A(i,j) ) )
1088  return false;
1089  }
1090  }
1091  }
1092  else {
1093  for( size_t j=1UL; j<A.columns(); ++j ) {
1094  for( size_t i=0UL; i<j; ++i ) {
1095  if( !isDefault<RF>( A(i,j) ) )
1096  return false;
1097  }
1098  }
1099  }
1100 
1101  return true;
1102 }
1103 //*************************************************************************************************
1104 
1105 
1106 //*************************************************************************************************
1148 template< bool RF // Relaxation flag
1149  , typename MT // Type of the dense matrix
1150  , bool SO > // Storage order
1152 {
1153  typedef ResultType_<MT> RT;
1154  typedef ReturnType_<MT> RN;
1155  typedef CompositeType_<MT> CT;
1156  typedef If_< IsExpression<RN>, const RT, CT > Tmp;
1157 
1158  if( IsUniLower<MT>::value )
1159  return true;
1160 
1161  if( !isSquare( ~dm ) )
1162  return false;
1163 
1164  Tmp A( ~dm ); // Evaluation of the dense matrix operand
1165 
1166  if( SO == rowMajor ) {
1167  for( size_t i=0UL; i<A.rows(); ++i ) {
1168  if( !isOne<RF>( A(i,i) ) )
1169  return false;
1170  for( size_t j=i+1UL; j<A.columns(); ++j ) {
1171  if( !isZero<RF>( A(i,j) ) )
1172  return false;
1173  }
1174  }
1175  }
1176  else {
1177  for( size_t j=0UL; j<A.columns(); ++j ) {
1178  for( size_t i=0UL; i<j; ++i ) {
1179  if( !isZero<RF>( A(i,j) ) )
1180  return false;
1181  }
1182  if( !isOne<RF>( A(j,j) ) )
1183  return false;
1184  }
1185  }
1186 
1187  return true;
1188 }
1189 //*************************************************************************************************
1190 
1191 
1192 //*************************************************************************************************
1235 template< bool RF // Relaxation flag
1236  , typename MT // Type of the dense matrix
1237  , bool SO > // Storage order
1239 {
1240  typedef ResultType_<MT> RT;
1241  typedef ReturnType_<MT> RN;
1242  typedef CompositeType_<MT> CT;
1243  typedef If_< IsExpression<RN>, const RT, CT > Tmp;
1244 
1246  return true;
1247 
1249  return false;
1250 
1251  Tmp A( ~dm ); // Evaluation of the dense matrix operand
1252 
1253  if( SO == rowMajor ) {
1254  for( size_t i=0UL; i<A.rows(); ++i ) {
1255  for( size_t j=i; j<A.columns(); ++j ) {
1256  if( !isDefault<RF>( A(i,j) ) )
1257  return false;
1258  }
1259  }
1260  }
1261  else {
1262  for( size_t j=0UL; j<A.columns(); ++j ) {
1263  for( size_t i=0UL; i<=j; ++i ) {
1264  if( !isDefault<RF>( A(i,j) ) )
1265  return false;
1266  }
1267  }
1268  }
1269 
1270  return true;
1271 }
1272 //*************************************************************************************************
1273 
1274 
1275 //*************************************************************************************************
1318 template< bool RF // Relaxation flag
1319  , typename MT // Type of the dense matrix
1320  , bool SO > // Storage order
1321 bool isUpper( const DenseMatrix<MT,SO>& dm )
1322 {
1323  typedef ResultType_<MT> RT;
1324  typedef ReturnType_<MT> RN;
1325  typedef CompositeType_<MT> CT;
1326  typedef If_< IsExpression<RN>, const RT, CT > Tmp;
1327 
1328  if( IsUpper<MT>::value )
1329  return true;
1330 
1331  if( !isSquare( ~dm ) )
1332  return false;
1333 
1334  if( (~dm).rows() < 2UL )
1335  return true;
1336 
1337  Tmp A( ~dm ); // Evaluation of the dense matrix operand
1338 
1339  if( SO == rowMajor ) {
1340  for( size_t i=1UL; i<A.rows(); ++i ) {
1341  for( size_t j=0UL; j<i; ++j ) {
1342  if( !isDefault<RF>( A(i,j) ) )
1343  return false;
1344  }
1345  }
1346  }
1347  else {
1348  for( size_t j=0UL; j<A.columns()-1UL; ++j ) {
1349  for( size_t i=j+1UL; i<A.rows(); ++i ) {
1350  if( !isDefault<RF>( A(i,j) ) )
1351  return false;
1352  }
1353  }
1354  }
1355 
1356  return true;
1357 }
1358 //*************************************************************************************************
1359 
1360 
1361 //*************************************************************************************************
1403 template< bool RF // Relaxation flag
1404  , typename MT // Type of the dense matrix
1405  , bool SO > // Storage order
1407 {
1408  typedef ResultType_<MT> RT;
1409  typedef ReturnType_<MT> RN;
1410  typedef CompositeType_<MT> CT;
1411  typedef If_< IsExpression<RN>, const RT, CT > Tmp;
1412 
1413  if( IsUniUpper<MT>::value )
1414  return true;
1415 
1416  if( !isSquare( ~dm ) )
1417  return false;
1418 
1419  Tmp A( ~dm ); // Evaluation of the dense matrix operand
1420 
1421  if( SO == rowMajor ) {
1422  for( size_t i=0UL; i<A.rows(); ++i ) {
1423  for( size_t j=0UL; j<i; ++j ) {
1424  if( !isZero<RF>( A(i,j) ) )
1425  return false;
1426  }
1427  if( !isOne<RF>( A(i,i) ) )
1428  return false;
1429  }
1430  }
1431  else {
1432  for( size_t j=0UL; j<A.columns(); ++j ) {
1433  if( !isOne<RF>( A(j,j) ) )
1434  return false;
1435  for( size_t i=j+1UL; i<A.rows(); ++i ) {
1436  if( !isZero<RF>( A(i,j) ) )
1437  return false;
1438  }
1439  }
1440  }
1441 
1442  return true;
1443 }
1444 //*************************************************************************************************
1445 
1446 
1447 //*************************************************************************************************
1490 template< bool RF // Relaxation flag
1491  , typename MT // Type of the dense matrix
1492  , bool SO > // Storage order
1494 {
1495  typedef ResultType_<MT> RT;
1496  typedef ReturnType_<MT> RN;
1497  typedef CompositeType_<MT> CT;
1498  typedef If_< IsExpression<RN>, const RT, CT > Tmp;
1499 
1501  return true;
1502 
1504  return false;
1505 
1506  Tmp A( ~dm ); // Evaluation of the dense matrix operand
1507 
1508  if( SO == rowMajor ) {
1509  for( size_t i=0UL; i<A.rows(); ++i ) {
1510  for( size_t j=0UL; j<=i; ++j ) {
1511  if( !isDefault<RF>( A(i,j) ) )
1512  return false;
1513  }
1514  }
1515  }
1516  else {
1517  for( size_t j=0UL; j<A.columns(); ++j ) {
1518  for( size_t i=j; i<A.rows(); ++i ) {
1519  if( !isDefault<RF>( A(i,j) ) )
1520  return false;
1521  }
1522  }
1523  }
1524 
1525  return true;
1526 }
1527 //*************************************************************************************************
1528 
1529 
1530 //*************************************************************************************************
1574 template< bool RF // Relaxation flag
1575  , typename MT // Type of the dense matrix
1576  , bool SO > // Storage order
1578 {
1579  typedef ResultType_<MT> RT;
1580  typedef ReturnType_<MT> RN;
1581  typedef CompositeType_<MT> CT;
1582  typedef If_< IsExpression<RN>, const RT, CT > Tmp;
1583 
1584  if( IsDiagonal<MT>::value )
1585  return true;
1586 
1587  if( !isSquare( ~dm ) )
1588  return false;
1589 
1590  if( (~dm).rows() < 2UL )
1591  return true;
1592 
1593  Tmp A( ~dm ); // Evaluation of the dense matrix operand
1594 
1595  if( SO == rowMajor ) {
1596  for( size_t i=0UL; i<A.rows(); ++i ) {
1597  if( !IsUpper<MT>::value ) {
1598  for( size_t j=0UL; j<i; ++j ) {
1599  if( !isDefault<RF>( A(i,j) ) )
1600  return false;
1601  }
1602  }
1603  if( !IsLower<MT>::value ) {
1604  for( size_t j=i+1UL; j<A.columns(); ++j ) {
1605  if( !isDefault<RF>( A(i,j) ) )
1606  return false;
1607  }
1608  }
1609  }
1610  }
1611  else {
1612  for( size_t j=0UL; j<A.columns(); ++j ) {
1613  if( !IsLower<MT>::value ) {
1614  for( size_t i=0UL; i<j; ++i ) {
1615  if( !isDefault<RF>( A(i,j) ) )
1616  return false;
1617  }
1618  }
1619  if( !IsUpper<MT>::value ) {
1620  for( size_t i=j+1UL; i<A.rows(); ++i ) {
1621  if( !isDefault<RF>( A(i,j) ) )
1622  return false;
1623  }
1624  }
1625  }
1626  }
1627 
1628  return true;
1629 }
1630 //*************************************************************************************************
1631 
1632 
1633 //*************************************************************************************************
1676 template< bool RF // Relaxation flag
1677  , typename MT // Type of the dense matrix
1678  , bool SO > // Storage order
1680 {
1681  typedef ResultType_<MT> RT;
1682  typedef ReturnType_<MT> RN;
1683  typedef CompositeType_<MT> CT;
1684  typedef If_< IsExpression<RN>, const RT, CT > Tmp;
1685 
1686  if( IsIdentity<MT>::value )
1687  return true;
1688 
1689  if( !isSquare( ~dm ) )
1690  return false;
1691 
1692  if( (~dm).rows() == 0UL )
1693  return true;
1694 
1695  Tmp A( ~dm ); // Evaluation of the dense matrix operand
1696 
1697  if( SO == rowMajor ) {
1698  for( size_t i=0UL; i<A.rows(); ++i ) {
1699  if( !IsUpper<MT>::value ) {
1700  for( size_t j=0UL; j<i; ++j ) {
1701  if( !isZero<RF>( A(i,j) ) )
1702  return false;
1703  }
1704  }
1705  if( !IsUniLower<MT>::value && !IsUniUpper<MT>::value && !isOne<RF>( A(i,i) ) ) {
1706  return false;
1707  }
1708  if( !IsLower<MT>::value ) {
1709  for( size_t j=i+1UL; j<A.columns(); ++j ) {
1710  if( !isZero<RF>( A(i,j) ) )
1711  return false;
1712  }
1713  }
1714  }
1715  }
1716  else {
1717  for( size_t j=0UL; j<A.columns(); ++j ) {
1718  if( !IsLower<MT>::value ) {
1719  for( size_t i=0UL; i<j; ++i ) {
1720  if( !isZero<RF>( A(i,j) ) )
1721  return false;
1722  }
1723  }
1724  if( !IsUniLower<MT>::value && !IsUniUpper<MT>::value && !isOne<RF>( A(j,j) ) ) {
1725  return false;
1726  }
1727  if( !IsUpper<MT>::value ) {
1728  for( size_t i=j+1UL; i<A.rows(); ++i ) {
1729  if( !isZero<RF>( A(i,j) ) )
1730  return false;
1731  }
1732  }
1733  }
1734  }
1735 
1736  return true;
1737 }
1738 //*************************************************************************************************
1739 
1740 
1741 //*************************************************************************************************
1753 template< typename MT // Type of the dense matrix
1754  , bool SO > // Storage order
1756 {
1757  using blaze::min;
1758 
1759  typedef ElementType_<MT> ET;
1760  typedef CompositeType_<MT> CT;
1761 
1762  CT A( ~dm ); // Evaluation of the dense matrix operand
1763 
1764  if( A.rows() == 0UL || A.columns() == 0UL ) return ET();
1765 
1766  ET minimum( A(0,0) );
1767 
1768  if( SO == rowMajor ) {
1769  for( size_t j=1UL; j<A.columns(); ++j )
1770  minimum = min( minimum, A(0UL,j) );
1771  for( size_t i=1UL; i<A.rows(); ++i )
1772  for( size_t j=0UL; j<A.columns(); ++j )
1773  minimum = min( minimum, A(i,j) );
1774  }
1775  else {
1776  for( size_t i=1UL; i<A.rows(); ++i )
1777  minimum = min( minimum, A(i,0UL) );
1778  for( size_t j=1UL; j<A.columns(); ++j )
1779  for( size_t i=0UL; i<A.rows(); ++i )
1780  minimum = min( minimum, A(i,j) );
1781  }
1782 
1783  return minimum;
1784 }
1785 //*************************************************************************************************
1786 
1787 
1788 //*************************************************************************************************
1800 template< typename MT // Type of the dense matrix
1801  , bool SO > // Transpose flag
1803 {
1804  using blaze::max;
1805 
1806  typedef ElementType_<MT> ET;
1807  typedef CompositeType_<MT> CT;
1808 
1809  CT A( ~dm ); // Evaluation of the dense matrix operand
1810 
1811  if( A.rows() == 0UL || A.columns() == 0UL ) return ET();
1812 
1813  ET maximum( A(0,0) );
1814 
1815  if( SO == rowMajor ) {
1816  for( size_t j=1UL; j<A.columns(); ++j )
1817  maximum = max( maximum, A(0UL,j) );
1818  for( size_t i=1UL; i<A.rows(); ++i )
1819  for( size_t j=0UL; j<A.columns(); ++j )
1820  maximum = max( maximum, A(i,j) );
1821  }
1822  else {
1823  for( size_t i=1UL; i<A.rows(); ++i )
1824  maximum = max( maximum, A(i,0UL) );
1825  for( size_t j=1UL; j<A.columns(); ++j )
1826  for( size_t i=0UL; i<A.rows(); ++i )
1827  maximum = max( maximum, A(i,j) );
1828  }
1829 
1830  return maximum;
1831 }
1832 //*************************************************************************************************
1833 
1834 } // namespace blaze
1835 
1836 #endif
#define BLAZE_CONSTRAINT_MUST_BE_TRIANGULAR_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is not a lower or upper triangular matrix t...
Definition: Triangular.h:61
Header file for the isnan shim.
const DMatForEachExpr< MT, Conj, SO > conj(const DenseMatrix< MT, SO > &dm)
Returns a matrix containing the complex conjugate of each single element of dm.
Definition: DMatForEachExpr.h:1214
Header file for auxiliary alias declarations.
Compile time check for numeric types.This type trait tests whether or not the given template paramete...
Definition: IsNumeric.h:79
Header file for mathematical functions.
bool isLower(const DenseMatrix< MT, SO > &dm)
Checks if the given dense matrix is a lower triangular matrix.
Definition: DenseMatrix.h:1066
bool isUpper(const DenseMatrix< MT, SO > &dm)
Checks if the given dense matrix is an upper triangular matrix.
Definition: DenseMatrix.h:1321
bool isStrictlyLower(const DenseMatrix< MT, SO > &dm)
Checks if the given dense matrix is a strictly lower triangular matrix.
Definition: DenseMatrix.h:1238
Header file for the IsUniUpper type trait.
Compile time check for triangular matrix types.This type trait tests whether or not the given templat...
Definition: IsTriangular.h:87
Header file for basic type definitions.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_TRIANGULAR_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is a lower or upper triangular matrix type...
Definition: Triangular.h:81
constexpr bool equal(const T1 &a, const T2 &b)
Generic equality check.
Definition: Equal.h:76
Header file for the FalseType type/value trait base class.
Header file for the IsDiagonal type trait.
Generic wrapper for a compile time constant integral value.The IntegralConstant class template repres...
Definition: IntegralConstant.h:71
bool isUniLower(const DenseMatrix< MT, SO > &dm)
Checks if the given dense matrix is a lower unitriangular matrix.
Definition: DenseMatrix.h:1151
const ElementType_< MT > min(const DenseMatrix< MT, SO > &dm)
Returns the smallest element of the dense matrix.
Definition: DenseMatrix.h:1755
Compile time check for lower triangular matrices.This type trait tests whether or not the given templ...
Definition: IsLower.h:88
Header file for the IsIdentity type trait.
bool isDiagonal(const DenseMatrix< MT, SO > &dm)
Checks if the give dense matrix is diagonal.
Definition: DenseMatrix.h:1577
Compile time check for upper triangular matrices.This type trait tests whether or not the given templ...
Definition: IsUpper.h:88
Header file for the IsUniLower type trait.
typename T::ResultType ResultType_
Alias declaration for nested ResultType type definitions.The ResultType_ alias declaration provides a...
Definition: Aliases.h:323
const ElementType_< MT > max(const DenseMatrix< MT, SO > &dm)
Returns the largest element of the dense matrix.
Definition: DenseMatrix.h:1802
Base class for dense matrices.The DenseMatrix class is a base class for all dense matrix classes...
Definition: DenseMatrix.h:71
Base class for sparse matrices.The SparseMatrix class is a base class for all sparse matrix classes...
Definition: Forward.h:119
bool isIdentity(const DenseMatrix< MT, SO > &dm)
Checks if the give dense matrix is an identity matrix.
Definition: DenseMatrix.h:1679
typename T::ReturnType ReturnType_
Alias declaration for nested ReturnType type definitions.The ReturnType_ alias declaration provides a...
Definition: Aliases.h:343
Header file for the SparseMatrix base class.
Header file for the matrix storage order types.
Constraint on the data type.
typename T::CompositeType CompositeType_
Alias declaration for nested CompositeType type definitions.The CompositeType_ alias declaration prov...
Definition: Aliases.h:83
Compile time check for upper unitriangular matrices.This type trait tests whether or not the given te...
Definition: IsUniUpper.h:86
Header file for the IsStrictlyUpper type trait.
Header file for the IsSymmetric type trait.
Namespace of the Blaze C++ math library.
Definition: Blaze.h:57
Header file for the If class template.
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:2939
Header file for the DenseMatrix base class.
Header file for the isZero shim.
constexpr bool operator==(const NegativeAccuracy< A > &lhs, const T &rhs)
Equality comparison between a NegativeAccuracy object and a floating point value. ...
Definition: Accuracy.h:250
typename T::ElementType ElementType_
Alias declaration for nested ElementType type definitions.The ElementType_ alias declaration provides...
Definition: Aliases.h:163
Header file for the IsLower type trait.
Compile time check for diagonal matrices.This type trait tests whether or not the given template para...
Definition: IsDiagonal.h:90
BLAZE_ALWAYS_INLINE size_t columns(const Matrix< MT, SO > &matrix) noexcept
Returns the current number of columns of the matrix.
Definition: Matrix.h:336
Header file for the equal shim.
Header file for the IsUniTriangular type trait.
Header file for the IsTriangular type trait.
Compile time check for symmetric matrices.This type trait tests whether or not the given template par...
Definition: IsSymmetric.h:85
bool isnan(const DiagonalProxy< MT > &proxy)
Returns whether the represented element is not a number.
Definition: DiagonalProxy.h:655
Compile time check for strictly upper triangular matrices.This type trait tests whether or not the gi...
Definition: IsStrictlyUpper.h:86
bool isUniform(const DenseMatrix< MT, SO > &dm)
Checks if the given dense matrix is a uniform matrix.
Definition: DenseMatrix.h:1004
constexpr bool operator!=(const NegativeAccuracy< A > &lhs, const T &rhs)
Inequality comparison between a NegativeAccuracy object and a floating point value.
Definition: Accuracy.h:290
Constraint on the data type.
Header file for the EnableIf class template.
Header file for the IsStrictlyLower type trait.
Header file for the isOne shim.
Compile time check for lower unitriangular matrices.This type trait tests whether or not the given te...
Definition: IsUniLower.h:86
Header file for the conjugate shim.
Header file for the IsNumeric type trait.
Compile time check for identity matrices.This type trait tests whether or not the given template para...
Definition: IsIdentity.h:90
bool isStrictlyUpper(const DenseMatrix< MT, SO > &dm)
Checks if the given dense matrix is a strictly upper triangular matrix.
Definition: DenseMatrix.h:1493
Header file for run time assertion macros.
typename If< T1, T2, T3 >::Type If_
Auxiliary alias declaration for the If class template.The If_ alias declaration provides a convenient...
Definition: If.h:160
bool isHermitian(const DenseMatrix< MT, SO > &dm)
Checks if the given dense matrix is Hermitian.
Definition: DenseMatrix.h:775
Header file for the isDefault shim.
Compile time check for Hermitian matrices.This type trait tests whether or not the given template par...
Definition: IsHermitian.h:85
bool isSymmetric(const DenseMatrix< MT, SO > &dm)
Checks if the given dense matrix is symmetric.
Definition: DenseMatrix.h:697
#define BLAZE_CONSTRAINT_MUST_NOT_REQUIRE_EVALUATION(T)
Constraint on the data type.In case the given data type T requires an intermediate evaluation within ...
Definition: RequiresEvaluation.h:81
Header file for the RemoveReference type trait.
typename EnableIf< Condition, T >::Type EnableIf_
Auxiliary alias declaration for the EnableIf class template.The EnableIf_ alias declaration provides ...
Definition: EnableIf.h:223
Compile time check for strictly lower triangular matrices.This type trait tests whether or not the gi...
Definition: IsStrictlyLower.h:86
typename T::ConstReference ConstReference_
Alias declaration for nested ConstReference type definitions.The ConstReference_ alias declaration pr...
Definition: Aliases.h:143
BLAZE_ALWAYS_INLINE size_t rows(const Matrix< MT, SO > &matrix) noexcept
Returns the current number of rows of the matrix.
Definition: Matrix.h:320
typename T::ConstIterator ConstIterator_
Alias declaration for nested ConstIterator type definitions.The ConstIterator_ alias declaration prov...
Definition: Aliases.h:103
const bool rowMajor
Storage order flag for row-major matrices.
Definition: StorageOrder.h:71
bool isUniUpper(const DenseMatrix< MT, SO > &dm)
Checks if the given dense matrix is an upper unitriangular matrix.
Definition: DenseMatrix.h:1406
bool isDefault(const DiagonalProxy< MT > &proxy)
Returns whether the represented element is in default state.
Definition: DiagonalProxy.h:573
Header file for the IsUpper type trait.
Header file for the IsHermitian type trait.
BLAZE_ALWAYS_INLINE bool isSquare(const Matrix< MT, SO > &matrix) noexcept
Checks if the given matrix is a square matrix.
Definition: Matrix.h:677
Header file for the isReal shim.
#define BLAZE_INTERNAL_ASSERT(expr, msg)
Run time assertion macro for internal checks.In case of an invalid run time expression, the program execution is terminated. The BLAZE_INTERNAL_ASSERT macro can be disabled by setting the BLAZE_USER_ASSERTION flag to zero or by defining NDEBUG during the compilation.
Definition: Assert.h:101
Header file for the TrueType type/value trait base class.
Compile time check for unitriangular matrix types.This type trait tests whether or not the given temp...
Definition: IsUniTriangular.h:87
Header file for the IsExpression type trait class.