All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
DenseMatrix.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_DENSEMATRIX_H_
36 #define _BLAZE_MATH_DENSEMATRIX_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
86 #include <blaze/math/Matrix.h>
87 #include <blaze/math/shims/Equal.h>
89 #include <blaze/math/shims/IsNaN.h>
93 #include <blaze/util/Assert.h>
94 #include <blaze/util/EnableIf.h>
95 #include <blaze/util/Types.h>
98 
99 
100 namespace blaze {
101 
102 //=================================================================================================
103 //
104 // GLOBAL OPERATORS
105 //
106 //=================================================================================================
107 
108 //*************************************************************************************************
111 template< typename T1, typename T2 >
112 inline bool operator==( const DenseMatrix<T1,false>& lhs, const DenseMatrix<T2,false>& rhs );
113 
114 template< typename T1, typename T2 >
115 inline bool operator==( const DenseMatrix<T1,true>& lhs, const DenseMatrix<T2,true>& rhs );
116 
117 template< typename T1, typename T2, bool SO >
118 inline bool operator==( const DenseMatrix<T1,SO>& lhs, const DenseMatrix<T2,!SO>& rhs );
119 
120 template< typename T1, typename T2, bool SO >
121 inline bool operator==( const DenseMatrix<T1,SO>& lhs, const SparseMatrix<T2,false>& rhs );
122 
123 template< typename T1, typename T2, bool SO >
124 inline bool operator==( const DenseMatrix<T1,SO>& lhs, const SparseMatrix<T2,true>& rhs );
125 
126 template< typename T1, bool SO1, typename T2, bool SO2 >
127 inline bool operator==( const SparseMatrix<T1,SO1>& lhs, const DenseMatrix<T2,SO2>& rhs );
128 
129 template< typename T1, typename T2 >
130 inline typename EnableIf< IsNumeric<T2>, bool >::Type
131  operator==( const DenseMatrix<T1,false>& mat, T2 scalar );
132 
133 template< typename T1, typename T2 >
134 inline typename EnableIf< IsNumeric<T2>, bool >::Type
135  operator==( const DenseMatrix<T1,true>& mat, T2 scalar );
136 
137 template< typename T1, typename T2, bool SO >
138 inline typename EnableIf< IsNumeric<T2>, bool >::Type
139  operator==( T1 scalar, const DenseMatrix<T2,SO>& mat );
140 
141 template< typename T1, bool SO1, typename T2, bool SO2 >
142 inline bool operator!=( const DenseMatrix<T1,SO1>& lhs, const DenseMatrix<T2,SO2>& rhs );
143 
144 template< typename T1, bool SO1, typename T2, bool SO2 >
145 inline bool operator!=( const DenseMatrix<T1,SO1>& lhs, const SparseMatrix<T2,SO2>& rhs );
146 
147 template< typename T1, bool SO1, typename T2, bool SO2 >
148 inline bool operator!=( const SparseMatrix<T1,SO1>& lhs, const DenseMatrix<T2,SO2>& rhs );
149 
150 template< typename T1, typename T2, bool SO >
151 inline typename EnableIf< IsNumeric<T2>, bool >::Type
152  operator!=( const DenseMatrix<T1,SO>& mat, T2 scalar );
153 
154 template< typename T1, typename T2, bool SO >
155 inline typename EnableIf< IsNumeric<T2>, bool >::Type
156  operator!=( T1 scalar, const DenseMatrix<T2,SO>& mat );
158 //*************************************************************************************************
159 
160 
161 //*************************************************************************************************
169 template< typename T1 // Type of the left-hand side dense matrix
170  , typename T2 > // Type of the right-hand side dense matrix
171 inline bool operator==( const DenseMatrix<T1,false>& lhs, const DenseMatrix<T2,false>& rhs )
172 {
173  typedef typename T1::CompositeType CT1;
174  typedef typename T2::CompositeType CT2;
175 
176  // Early exit in case the matrix sizes don't match
177  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() )
178  return false;
179 
180  // Evaluation of the two dense matrix operands
181  CT1 A( ~lhs );
182  CT2 B( ~rhs );
183 
184  // In order to compare the two matrices, the data values of the lower-order data
185  // type are converted to the higher-order data type within the equal function.
186  for( size_t i=0; i<A.rows(); ++i ) {
187  for( size_t j=0; j<A.columns(); ++j ) {
188  if( !equal( A(i,j), B(i,j) ) ) return false;
189  }
190  }
191 
192  return true;
193 }
194 //*************************************************************************************************
195 
196 
197 //*************************************************************************************************
205 template< typename T1 // Type of the left-hand side dense matrix
206  , typename T2 > // Type of the right-hand side dense matrix
207 inline bool operator==( const DenseMatrix<T1,true>& lhs, const DenseMatrix<T2,true>& rhs )
208 {
209  typedef typename T1::CompositeType CT1;
210  typedef typename T2::CompositeType CT2;
211 
212  // Early exit in case the matrix sizes don't match
213  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() )
214  return false;
215 
216  // Evaluation of the two dense matrix operands
217  CT1 A( ~lhs );
218  CT2 B( ~rhs );
219 
220  // In order to compare the two matrices, the data values of the lower-order data
221  // type are converted to the higher-order data type within the equal function.
222  for( size_t j=0; j<A.columns(); ++j ) {
223  for( size_t i=0; i<A.rows(); ++i ) {
224  if( !equal( A(i,j), B(i,j) ) ) return false;
225  }
226  }
227 
228  return true;
229 }
230 //*************************************************************************************************
231 
232 
233 //*************************************************************************************************
241 template< typename T1 // Type of the left-hand side dense matrix
242  , typename T2 // Type of the right-hand side dense matrix
243  , bool SO > // Storage order
244 inline bool operator==( const DenseMatrix<T1,SO>& lhs, const DenseMatrix<T2,!SO>& rhs )
245 {
246  typedef typename T1::CompositeType CT1;
247  typedef typename T2::CompositeType CT2;
248 
249  // Early exit in case the matrix sizes don't match
250  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() )
251  return false;
252 
253  // Evaluation of the two dense matrix operands
254  CT1 A( ~lhs );
255  CT2 B( ~rhs );
256 
257  // In order to compare the two matrices, the data values of the lower-order data
258  // type are converted to the higher-order data type within the equal function.
259  const size_t rows ( A.rows() );
260  const size_t columns( A.columns() );
261  const size_t block ( 16 );
262 
263  for( size_t ii=0; ii<rows; ii+=block ) {
264  const size_t iend( ( rows < ii+block )?( rows ):( ii+block ) );
265  for( size_t jj=0; jj<columns; jj+=block ) {
266  const size_t jend( ( columns < jj+block )?( columns ):( jj+block ) );
267  for( size_t i=ii; i<iend; ++i ) {
268  for( size_t j=jj; j<jend; ++j ) {
269  if( !equal( A(i,j), B(i,j) ) ) return false;
270  }
271  }
272  }
273  }
274 
275  return true;
276 }
277 //*************************************************************************************************
278 
279 
280 //*************************************************************************************************
288 template< typename T1 // Type of the left-hand side dense matrix
289  , typename T2 // Type of the right-hand side sparse matrix
290  , bool SO > // Storage order of the left-hand side dense matrix
291 inline bool operator==( const DenseMatrix<T1,SO>& lhs, const SparseMatrix<T2,false>& rhs )
292 {
293  typedef typename T1::CompositeType CT1;
294  typedef typename T2::CompositeType CT2;
296 
297  // Early exit in case the matrix sizes don't match
298  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() )
299  return false;
300 
301  // Evaluation of the dense matrix and sparse matrix operand
302  CT1 A( ~lhs );
303  CT2 B( ~rhs );
304 
305  // In order to compare the two matrices, the data values of the lower-order data
306  // type are converted to the higher-order data type within the equal function.
307  size_t j( 0 );
308 
309  for( size_t i=0; i<B.rows(); ++i ) {
310  j = 0;
311  for( ConstIterator element=B.begin(i); element!=B.end(i); ++element, ++j ) {
312  for( ; j<element->index(); ++j ) {
313  if( !isDefault( A(i,j) ) ) return false;
314  }
315  if( !equal( element->value(), A(i,j) ) ) return false;
316  }
317  for( ; j<A.columns(); ++j ) {
318  if( !isDefault( A(i,j) ) ) return false;
319  }
320  }
321 
322  return true;
323 }
324 //*************************************************************************************************
325 
326 
327 //*************************************************************************************************
335 template< typename T1 // Type of the left-hand side dense matrix
336  , typename T2 // Type of the right-hand side sparse matrix
337  , bool SO > // Storage order of the left-hand side dense matrix
338 inline bool operator==( const DenseMatrix<T1,SO>& lhs, const SparseMatrix<T2,true>& rhs )
339 {
340  typedef typename T1::CompositeType CT1;
341  typedef typename T2::CompositeType CT2;
343 
344  // Early exit in case the matrix sizes don't match
345  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() )
346  return false;
347 
348  // Evaluation of the dense matrix and sparse matrix operand
349  CT1 A( ~lhs );
350  CT2 B( ~rhs );
351 
352  // In order to compare the two matrices, the data values of the lower-order data
353  // type are converted to the higher-order data type within the equal function.
354  size_t i( 0 );
355 
356  for( size_t j=0; j<B.columns(); ++j ) {
357  i = 0;
358  for( ConstIterator element=B.begin(j); element!=B.end(j); ++element, ++i ) {
359  for( ; i<element->index(); ++i ) {
360  if( !isDefault( A(i,j) ) ) return false;
361  }
362  if( !equal( element->value(), A(i,j) ) ) return false;
363  }
364  for( ; i<A.rows(); ++i ) {
365  if( !isDefault( A(i,j) ) ) return false;
366  }
367  }
368 
369  return true;
370 }
371 //*************************************************************************************************
372 
373 
374 //*************************************************************************************************
382 template< typename T1 // Type of the left-hand side sparse matrix
383  , bool SO1 // Storage order of the left-hand side sparse matrix
384  , typename T2 // Type of the right-hand side dense matrix
385  , bool SO2 > // Storage order of the right-hand side sparse matrix
386 inline bool operator==( const SparseMatrix<T1,SO1>& lhs, const DenseMatrix<T2,SO2>& rhs )
387 {
388  return ( rhs == lhs );
389 }
390 //*************************************************************************************************
391 
392 
393 //*************************************************************************************************
405 template< typename T1 // Type of the left-hand side dense matrix
406  , typename T2 > // Type of the right-hand side scalar
407 inline typename EnableIf< IsNumeric<T2>, bool >::Type
408  operator==( const DenseMatrix<T1,false>& mat, T2 scalar )
409 {
410  typedef typename T1::CompositeType CT1;
411 
412  // Evaluation of the dense matrix operand
413  CT1 A( ~mat );
414 
415  // In order to compare the matrix and the scalar value, the data values of the lower-order
416  // data type are converted to the higher-order data type within the equal function.
417  for( size_t i=0; i<A.rows(); ++i ) {
418  for( size_t j=0; j<A.columns(); ++j ) {
419  if( !equal( A(i,j), scalar ) ) return false;
420  }
421  }
422 
423  return true;
424 }
425 //*************************************************************************************************
426 
427 
428 //*************************************************************************************************
440 template< typename T1 // Type of the left-hand side dense matrix
441  , typename T2 > // Type of the right-hand side scalar
442 inline typename EnableIf< IsNumeric<T2>, bool >::Type
443  operator==( const DenseMatrix<T1,true>& mat, T2 scalar )
444 {
445  typedef typename T1::CompositeType CT1;
446 
447  // Evaluation of the dense matrix operand
448  CT1 A( ~mat );
449 
450  // In order to compare the matrix and the scalar value, the data values of the lower-order
451  // data type are converted to the higher-order data type within the equal function.
452  for( size_t j=0; j<A.columns(); ++j ) {
453  for( size_t i=0; i<A.rows(); ++i ) {
454  if( !equal( A(i,j), scalar ) ) return false;
455  }
456  }
457 
458  return true;
459 }
460 //*************************************************************************************************
461 
462 
463 //*************************************************************************************************
475 template< typename T1 // Type of the left-hand side scalar
476  , typename T2 // Type of the right-hand side dense matrix
477  , bool SO > // Storage order
478 inline typename EnableIf< IsNumeric<T1>, bool >::Type
479  operator==( T1 scalar, const DenseMatrix<T2,SO>& mat )
480 {
481  return ( mat == scalar );
482 }
483 //*************************************************************************************************
484 
485 
486 //*************************************************************************************************
494 template< typename T1 // Type of the left-hand side dense matrix
495  , bool SO1 // Storage order of the left-hand side dense matrix
496  , typename T2 // Type of the right-hand side dense matrix
497  , bool SO2 > // Storage order of the right-hand side dense matrix
498 inline bool operator!=( const DenseMatrix<T1,SO1>& lhs, const DenseMatrix<T2,SO2>& rhs )
499 {
500  return !( lhs == rhs );
501 }
502 //*************************************************************************************************
503 
504 
505 //*************************************************************************************************
513 template< typename T1 // Type of the left-hand side dense matrix
514  , bool SO1 // Storage order of the left-hand side dense matrix
515  , typename T2 // Type of the right-hand side sparse matrix
516  , bool SO2 > // Storage order of the right-hand side sparse matrix
517 inline bool operator!=( const DenseMatrix<T1,SO1>& lhs, const SparseMatrix<T2,SO2>& rhs )
518 {
519  return !( lhs == rhs );
520 }
521 //*************************************************************************************************
522 
523 
524 //*************************************************************************************************
532 template< typename T1 // Type of the left-hand side sparse matrix
533  , bool SO1 // Storage order of the left-hand side sparse matrix
534  , typename T2 // Type of the right-hand side dense matrix
535  , bool SO2 > // Storage order right-hand side dense matrix
536 inline bool operator!=( const SparseMatrix<T1,SO1>& lhs, const DenseMatrix<T2,SO2>& rhs )
537 {
538  return !( rhs == lhs );
539 }
540 //*************************************************************************************************
541 
542 
543 //*************************************************************************************************
555 template< typename T1 // Type of the left-hand side dense matrix
556  , typename T2 // Type of the right-hand side scalar
557  , bool SO > // Storage order
558 inline typename EnableIf< IsNumeric<T2>, bool >::Type
559  operator!=( const DenseMatrix<T1,SO>& mat, T2 scalar )
560 {
561  return !( mat == scalar );
562 }
563 //*************************************************************************************************
564 
565 
566 //*************************************************************************************************
578 template< typename T1 // Type of the left-hand side scalar
579  , typename T2 // Type of the right-hand side dense matrix
580  , bool SO > // Storage order
581 inline typename EnableIf< IsNumeric<T1>, bool >::Type
582  operator!=( T1 scalar, const DenseMatrix<T2,SO>& mat )
583 {
584  return !( mat == scalar );
585 }
586 //*************************************************************************************************
587 
588 
589 
590 
591 //=================================================================================================
592 //
593 // GLOBAL FUNCTIONS
594 //
595 //=================================================================================================
596 
597 //*************************************************************************************************
600 template< typename MT, bool SO >
601 bool isnan( const DenseMatrix<MT,SO>& dm );
602 
603 template< typename MT, bool SO >
604 bool isDiagonal( const DenseMatrix<MT,SO>& dm );
605 
606 template< typename MT, bool SO >
607 bool isSymmetric( const DenseMatrix<MT,SO>& dm );
608 
609 template< typename MT, bool SO >
610 const typename MT::ElementType min( const DenseVector<MT,SO>& dm );
611 
612 template< typename MT, bool SO >
613 const typename MT::ElementType max( const DenseVector<MT,SO>& dm );
615 //*************************************************************************************************
616 
617 
618 //*************************************************************************************************
638 template< typename MT // Type of the dense matrix
639  , bool SO > // Storage order
640 bool isnan( const DenseMatrix<MT,SO>& dm )
641 {
642  typedef typename MT::CompositeType CT;
643 
644  CT A( ~dm ); // Evaluation of the dense matrix operand
645 
646  if( SO == rowMajor ) {
647  for( size_t i=0UL; i<A.rows(); ++i ) {
648  for( size_t j=0UL; j<A.columns(); ++j )
649  if( isnan( A(i,j) ) ) return true;
650  }
651  }
652  else {
653  for( size_t j=0UL; j<A.columns(); ++j ) {
654  for( size_t i=0UL; i<A.rows(); ++i )
655  if( isnan( A(i,j) ) ) return true;
656  }
657  }
658 
659  return false;
660 }
661 //*************************************************************************************************
662 
663 
664 //*************************************************************************************************
683 template< typename MT // Type of the dense matrix
684  , bool SO > // Storage order
686 {
687  const size_t rows ( (~dm).rows() );
688  const size_t columns( (~dm).columns() );
689 
690  if( rows != columns ) return false;
691 
692  if( SO == rowMajor ) {
693  for( size_t i=1UL; i<rows; ++i ) {
694  for( size_t j=0UL; j<i; ++j ) {
695  if( !isDefault( (~dm)(i,j) ) || !isDefault( (~dm)(j,i) ) )
696  return false;
697  }
698  }
699  }
700  else {
701  for( size_t j=1UL; j<columns; ++j ) {
702  for( size_t i=0UL; i<j; ++i ) {
703  if( !isDefault( (~dm)(i,j) ) || !isDefault( (~dm)(j,i) ) )
704  return false;
705  }
706  }
707  }
708 
709  return true;
710 }
711 //*************************************************************************************************
712 
713 
714 //*************************************************************************************************
721 template< typename MT // Type of the dense matrix
722  , bool SO > // Storage order
724 {
725  const size_t rows ( (~dm).rows() );
726  const size_t columns( (~dm).columns() );
727 
728  if( rows != columns ) return false;
729 
730  if( SO == rowMajor ) {
731  for( size_t i=1UL; i<rows; ++i ) {
732  for( size_t j=0UL; j<i; ++j ) {
733  if( !equal( (~dm)(i,j), (~dm)(j,i) ) )
734  return false;
735  }
736  }
737  }
738  else {
739  for( size_t j=1UL; j<columns; ++j ) {
740  for( size_t i=0UL; i<j; ++i ) {
741  if( !equal( (~dm)(i,j), (~dm)(j,i) ) )
742  return false;
743  }
744  }
745  }
746 
747  return true;
748 }
749 //*************************************************************************************************
750 
751 
752 //*************************************************************************************************
764 template< typename MT // Type of the dense matrix
765  , bool SO > // Storage order
766 const typename MT::ElementType min( const DenseMatrix<MT,SO>& dm )
767 {
768  using blaze::min;
769 
770  typedef typename MT::ElementType ET;
771  typedef typename MT::CompositeType CT;
772 
773  CT A( ~dm ); // Evaluation of the dense matrix operand
774 
775  if( A.rows() == 0UL || A.columns() == 0UL ) return ET();
776 
777  ET minimum( A(0,0) );
778 
779  if( SO == rowMajor ) {
780  for( size_t j=1UL; j<A.columns(); ++j )
781  minimum = min( minimum, A(0UL,j) );
782  for( size_t i=1UL; i<A.rows(); ++i )
783  for( size_t j=0UL; j<A.columns(); ++j )
784  minimum = min( minimum, A(i,j) );
785  }
786  else {
787  for( size_t i=1UL; i<A.rows(); ++i )
788  minimum = min( minimum, A(i,0UL) );
789  for( size_t j=1UL; j<A.columns(); ++j )
790  for( size_t i=0UL; i<A.rows(); ++i )
791  minimum = min( minimum, A(i,j) );
792  }
793 
794  return minimum;
795 }
796 //*************************************************************************************************
797 
798 
799 //*************************************************************************************************
811 template< typename MT // Type of the dense matrix
812  , bool SO > // Transpose flag
813 const typename MT::ElementType max( const DenseMatrix<MT,SO>& dm )
814 {
815  using blaze::max;
816 
817  typedef typename MT::ElementType ET;
818  typedef typename MT::CompositeType CT;
819 
820  CT A( ~dm ); // Evaluation of the dense matrix operand
821 
822  if( A.rows() == 0UL || A.columns() == 0UL ) return ET();
823 
824  ET maximum( A(0,0) );
825 
826  if( SO == rowMajor ) {
827  for( size_t j=1UL; j<A.columns(); ++j )
828  maximum = max( maximum, A(0UL,j) );
829  for( size_t i=1UL; i<A.rows(); ++i )
830  for( size_t j=0UL; j<A.columns(); ++j )
831  maximum = max( maximum, A(i,j) );
832  }
833  else {
834  for( size_t i=1UL; i<A.rows(); ++i )
835  maximum = max( maximum, A(i,0UL) );
836  for( size_t j=1UL; j<A.columns(); ++j )
837  for( size_t i=0UL; i<A.rows(); ++i )
838  maximum = max( maximum, A(i,j) );
839  }
840 
841  return maximum;
842 }
843 //*************************************************************************************************
844 
845 } // namespace blaze
846 
847 #endif
Header file for the isnan shim.
Header file for the dense vector/dense vector outer product expression.
bool isDiagonal(const DenseMatrix< MT, SO > &dm)
Checks if the give dense matrix is diagonal.
Definition: DenseMatrix.h:685
Header file for the transpose dense vector/dense matrix multiplication expression.
Header file for the dense matrix/dense vector multiplication expression.
Header file for the dense matrix/dense matrix addition expression.
Header file for the dense matrix/sparse vector multiplication expression.
bool isDefault(const DynamicMatrix< Type, SO > &m)
Returns whether the given dense matrix is in default state.
Definition: DynamicMatrix.h:4642
bool isSymmetric(const DenseMatrix< MT, SO > &dm)
Checks if the given dense matrix is symmetric.
Definition: DenseMatrix.h:723
Header file for the transpose sparse matrix/transpose dense matrix multiplication expression...
Header file for the sparse matrix SMP implementation.
const This & CompositeType
Data type for composite expression templates.
Definition: CompressedMatrix.h:2408
bool isnan(const DenseMatrix< MT, SO > &dm)
Checks the given dense matrix for not-a-number elements.
Definition: DenseMatrix.h:640
Header file for the dense matrix/dense matrix subtraction expression.
Header file for the sparse matrix/transpose dense matrix multiplication expression.
Header file for the transpose dense matrix/dense matrix multiplication expression.
Header file for the transpose dense matrix/sparse matrix multiplication expression.
Base class for dense matrices.The DenseMatrix class is a base class for all dense matrix classes...
Definition: DenseMatrix.h:70
Base class for sparse matrices.The SparseMatrix class is a base class for all sparse matrix classes...
Definition: Forward.h:107
Header file for the dense matrix/transpose dense matrix addition expression.
Header file for the SparseMatrix base class.
Header file for the transpose sparse vector/dense matrix multiplication expression.
Header file for the matrix storage order types.
Header file for the transpose sparse matrix/dense matrix subtraction expression.
Header file for the dense matrix/transpose sparse matrix addition expression.
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:2412
Header file for the dense matrix SMP implementation.
Header file for the DenseMatrix base class.
Header file for the transpose sparse vector/transpose dense matrix multiplication expression...
Header file for the sparse matrix/dense matrix subtraction expression.
Header file for the transpose sparse matrix/dense matrix multiplication expression.
Header file for the dense matrix/scalar multiplication expression.
Header file for the transpose dense matrix/dense vector multiplication expression.
Header file for the dense matrix/sparse matrix addition expression.
Header file for the transpose dense matrix/sparse vector multiplication expression.
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:2406
Header file for the sparse matrix/transpose dense matrix subtraction expression.
Header file for the EnableIf class template.
Header file for the dense matrix/scalar division expression.
Header file for the equal shim.
Header file for the dense matrix evaluation expression.
Header file for the transpose dense matrix/transpose sparse matrix multiplication expression...
Header file for the transpose dense matrix/transpose dense matrix multiplication expression.
Header file for the dense matrix transposer.
Header file for the IsNumeric type trait.
Header file for all basic Matrix functionality.
Header file for the dense matrix/transpose sparse matrix subtraction expression.
Removal of reference modifiers.The RemoveCV type trait removes any reference modifiers from the given...
Definition: RemoveReference.h:69
Header file for run time assertion macros.
Header file for the dense matrix/dense matrix multiplication expression.
bool equal(const T1 &a, const T2 &b)
Generic equality check.
Definition: Equal.h:352
Header file for the dense matrix/sparse matrix subtraction expression.
Header file for the dense matrix/sparse matrix multiplication expression.
Header file for the dense matrix/transpose dense matrix multiplication expression.
Header file for the dense matrix/transpose sparse matrix multiplication expression.
const VT::ElementType max(const SparseVector< VT, TF > &sv)
Returns the largest element of the sparse vector.
Definition: SparseVector.h:408
Header file for the isDefault shim.
Header file for the dense matrix serial evaluation expression.
Header file for the transpose dense matrix/sparse matrix addition expression.
Header file for the RemoveReference type trait.
Header file for the dense matrix absolute value expression.
Header file for the dense matrix/transpose dense matrix subtraction expression.
const bool rowMajor
Storage order flag for row-major matrices.
Definition: StorageOrder.h:71
Header file for the transpose dense matrix/sparse matrix subtraction expression.
bool operator==(const NegativeAccuracy< A > &lhs, const T &rhs)
Equality comparison between a NegativeAccuracy object and a floating point value. ...
Definition: Accuracy.h:249
size_t columns(const Matrix< MT, SO > &m)
Returns the current number of columns of the matrix.
Definition: Matrix.h:170
bool operator!=(const NegativeAccuracy< A > &lhs, const T &rhs)
Inequality comparison between a NegativeAccuracy object and a floating point value.
Definition: Accuracy.h:289
Header file for basic type definitions.
Header file for the sparse matrix/dense matrix multiplication expression.
Header file for the dense matrix transpose expression.
const VT::ElementType min(const SparseVector< VT, TF > &sv)
Returns the smallest element of the sparse vector.
Definition: SparseVector.h:351
Header file for the transpose dense vector/transpose dense matrix multiplication expression.
size_t rows(const Matrix< MT, SO > &m)
Returns the current number of rows of the matrix.
Definition: Matrix.h:154