All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
SMatSMatSubExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_SMATSMATSUBEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_SMATSMATSUBEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <stdexcept>
69 #include <blaze/util/Assert.h>
70 #include <blaze/util/DisableIf.h>
71 #include <blaze/util/EnableIf.h>
73 #include <blaze/util/mpl/Max.h>
74 #include <blaze/util/SelectType.h>
75 #include <blaze/util/Types.h>
78 
79 
80 namespace blaze {
81 
82 //=================================================================================================
83 //
84 // CLASS SMATSMATSUBEXPR
85 //
86 //=================================================================================================
87 
88 //*************************************************************************************************
95 template< typename MT1 // Type of the left-hand side sparse matrix
96  , typename MT2 > // Type of the right-hand side sparse matrix
97 class SMatSMatSubExpr : public SparseMatrix< SMatSMatSubExpr<MT1,MT2>, false >
98  , private MatMatSubExpr
99  , private Computation
100 {
101  private:
102  //**Type definitions****************************************************************************
103  typedef typename MT1::ResultType RT1;
104  typedef typename MT2::ResultType RT2;
105  typedef typename MT1::ReturnType RN1;
106  typedef typename MT2::ReturnType RN2;
107  typedef typename MT1::CompositeType CT1;
108  typedef typename MT2::CompositeType CT2;
109  //**********************************************************************************************
110 
111  //**Return type evaluation**********************************************************************
113 
118  enum { returnExpr = !IsTemporary<RN1>::value && !IsTemporary<RN2>::value };
119 
122  //**********************************************************************************************
123 
124  //**Serial evaluation strategy******************************************************************
126 
131  template< typename T1, typename T2, typename T3 >
132  struct UseSymmetricKernel {
135  };
137  //**********************************************************************************************
138 
139  //**Parallel evaluation strategy****************************************************************
141 
146  template< typename MT >
147  struct UseSMPAssign {
148  enum { value = MT::smpAssignable };
149  };
151  //**********************************************************************************************
152 
153  public:
154  //**Type definitions****************************************************************************
160 
163 
165  typedef const ResultType CompositeType;
166 
168  typedef typename SelectType< IsExpression<MT1>::value, const MT1, const MT1& >::Type LeftOperand;
169 
171  typedef typename SelectType< IsExpression<MT2>::value, const MT2, const MT2& >::Type RightOperand;
172  //**********************************************************************************************
173 
174  //**Compilation flags***************************************************************************
176  enum { smpAssignable = 0 };
177  //**********************************************************************************************
178 
179  //**Constructor*********************************************************************************
185  explicit inline SMatSMatSubExpr( const MT1& lhs, const MT2& rhs )
186  : lhs_( lhs ) // Left-hand side sparse matrix of the subtraction expression
187  , rhs_( rhs ) // Right-hand side sparse matrix of the subtraction expression
188  {
189  BLAZE_INTERNAL_ASSERT( lhs.rows() == rhs.rows() , "Invalid number of rows" );
190  BLAZE_INTERNAL_ASSERT( lhs.columns() == rhs.columns(), "Invalid number of columns" );
191  }
192  //**********************************************************************************************
193 
194  //**Access operator*****************************************************************************
201  inline ReturnType operator()( size_t i, size_t j ) const {
202  BLAZE_INTERNAL_ASSERT( i < lhs_.rows() , "Invalid row access index" );
203  BLAZE_INTERNAL_ASSERT( j < lhs_.columns(), "Invalid column access index" );
204  return lhs_(i,j) - rhs_(i,j);
205  }
206  //**********************************************************************************************
207 
208  //**Rows function*******************************************************************************
213  inline size_t rows() const {
214  return lhs_.rows();
215  }
216  //**********************************************************************************************
217 
218  //**Columns function****************************************************************************
223  inline size_t columns() const {
224  return lhs_.columns();
225  }
226  //**********************************************************************************************
227 
228  //**NonZeros function***************************************************************************
233  inline size_t nonZeros() const {
234  return lhs_.nonZeros() + rhs_.nonZeros();
235  }
236  //**********************************************************************************************
237 
238  //**NonZeros function***************************************************************************
244  inline size_t nonZeros( size_t i ) const {
245  return lhs_.nonZeros(i) + rhs_.nonZeros(i);
246  }
247  //**********************************************************************************************
248 
249  //**Left operand access*************************************************************************
254  inline LeftOperand leftOperand() const {
255  return lhs_;
256  }
257  //**********************************************************************************************
258 
259  //**Right operand access************************************************************************
264  inline RightOperand rightOperand() const {
265  return rhs_;
266  }
267  //**********************************************************************************************
268 
269  //**********************************************************************************************
275  template< typename T >
276  inline bool canAlias( const T* alias ) const {
277  return ( lhs_.canAlias( alias ) || rhs_.canAlias( alias ) );
278  }
279  //**********************************************************************************************
280 
281  //**********************************************************************************************
287  template< typename T >
288  inline bool isAliased( const T* alias ) const {
289  return ( lhs_.isAliased( alias ) || rhs_.isAliased( alias ) );
290  }
291  //**********************************************************************************************
292 
293  private:
294  //**Member variables****************************************************************************
297  //**********************************************************************************************
298 
299  //**Assignment to dense matrices****************************************************************
311  template< typename MT // Type of the target dense matrix
312  , bool SO > // Storage order of the target dense matrix
313  friend inline void assign( DenseMatrix<MT,SO>& lhs, const SMatSMatSubExpr& rhs )
314  {
316 
317  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
318  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
319 
320  typedef typename RemoveReference<CT2>::Type::ConstIterator RightIterator;
321 
322  assign( ~lhs, rhs.lhs_ );
323 
325  subAssign( ~lhs, rhs.rhs_ );
326  }
327  else
328  {
329  CT2 B( serial( rhs.rhs_ ) ); // Evaluation of the right-hand side sparse matrix operand
330 
331  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
332  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
333  BLAZE_INTERNAL_ASSERT( B.rows() == (~lhs).rows() , "Invalid number of rows" );
334  BLAZE_INTERNAL_ASSERT( B.columns() == (~lhs).columns() , "Invalid number of columns" );
335 
336  for( size_t i=0UL; i<(~lhs).rows(); ++i ) {
337  const RightIterator end( B.end(i) );
338  for( RightIterator element=B.begin(i); element!=end; ++element ) {
339  if( isDefault( (~lhs)(i,element->index()) ) )
340  (~lhs)(i,element->index()) = -element->value();
341  else
342  (~lhs)(i,element->index()) -= element->value();
343  }
344  }
345  }
346  }
348  //**********************************************************************************************
349 
350  //**Assignment to row-major sparse matrices*****************************************************
362  template< typename MT > // Type of the target sparse matrix
363  friend inline void assign( SparseMatrix<MT,false>& lhs, const SMatSMatSubExpr& rhs )
364  {
366 
367  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
368  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
369 
370  typedef typename RemoveReference<CT1>::Type::ConstIterator LeftIterator;
371  typedef typename RemoveReference<CT2>::Type::ConstIterator RightIterator;
372 
373  CT1 A( serial( rhs.lhs_ ) ); // Evaluation of the left-hand side sparse matrix operand
374  CT2 B( serial( rhs.rhs_ ) ); // Evaluation of the right-hand side sparse matrix operand
375 
376  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.lhs_.rows() , "Invalid number of rows" );
377  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.lhs_.columns(), "Invalid number of columns" );
378  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
379  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
380  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
381  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).columns() , "Invalid number of columns" );
382 
383  // Final memory allocation (based on the evaluated operands)
384  (~lhs).reserve( A.nonZeros() + B.nonZeros() );
385 
386  // Performing the matrix subtraction
387  for( size_t i=0UL; i<(~lhs).rows(); ++i )
388  {
389  const LeftIterator lend( A.end(i) );
390  const RightIterator rend( B.end(i) );
391 
392  LeftIterator l( A.begin(i) );
393  RightIterator r( B.begin(i) );
394 
395  while( l != lend && r != rend )
396  {
397  if( l->index() < r->index() ) {
398  (~lhs).append( i, l->index(), l->value() );
399  ++l;
400  }
401  else if( l->index() > r->index() ) {
402  (~lhs).append( i, r->index(), -r->value() );
403  ++r;
404  }
405  else {
406  (~lhs).append( i, l->index(), l->value()-r->value() );
407  ++l;
408  ++r;
409  }
410  }
411 
412  while( l != lend ) {
413  (~lhs).append( i, l->index(), l->value() );
414  ++l;
415  }
416 
417  while( r != rend ) {
418  (~lhs).append( i, r->index(), -r->value() );
419  ++r;
420  }
421 
422  (~lhs).finalize( i );
423  }
424  }
426  //**********************************************************************************************
427 
428  //**Assignment to column-major sparse matrices**************************************************
440  template< typename MT > // Type of the target sparse matrix
441  friend inline typename DisableIf< UseSymmetricKernel<MT,MT1,MT2> >::Type
442  assign( SparseMatrix<MT,true>& lhs, const SMatSMatSubExpr& rhs )
443  {
445 
447 
448  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
449  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
450 
451  typedef typename RemoveReference<CT1>::Type::ConstIterator LeftIterator;
452  typedef typename RemoveReference<CT2>::Type::ConstIterator RightIterator;
453 
454  CT1 A( serial( rhs.lhs_ ) ); // Evaluation of the left-hand side sparse matrix operand
455  CT2 B( serial( rhs.rhs_ ) ); // Evaluation of the right-hand side sparse matrix operand
456 
457  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.lhs_.rows() , "Invalid number of rows" );
458  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.lhs_.columns(), "Invalid number of columns" );
459  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
460  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
461  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
462  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).columns() , "Invalid number of columns" );
463 
464  const size_t m( rhs.rows() );
465  const size_t n( rhs.columns() );
466 
467  // Counting the number of elements per column
468  std::vector<size_t> nonzeros( n, 0UL );
469  for( size_t i=0UL; i<m; ++i )
470  {
471  const LeftIterator lend( A.end(i) );
472  const RightIterator rend( B.end(i) );
473 
474  LeftIterator l( A.begin(i) );
475  RightIterator r( B.begin(i) );
476 
477  while( l != lend && r != rend )
478  {
479  if( l->index() < r->index() ) {
480  ++nonzeros[l->index()];
481  ++l;
482  }
483  else if( l->index() > r->index() ) {
484  ++nonzeros[r->index()];
485  ++r;
486  }
487  else {
488  ++nonzeros[l->index()];
489  ++l;
490  ++r;
491  }
492  }
493 
494  while( l != lend ) {
495  ++nonzeros[l->index()];
496  ++l;
497  }
498 
499  while( r != rend ) {
500  ++nonzeros[r->index()];
501  ++r;
502  }
503  }
504 
505  // Resizing the left-hand side sparse matrix
506  for( size_t j=0UL; j<n; ++j ) {
507  (~lhs).reserve( j, nonzeros[j] );
508  }
509 
510  // Performing the matrix subtraction
511  for( size_t i=0UL; i<m; ++i )
512  {
513  const LeftIterator lend( A.end(i) );
514  const RightIterator rend( B.end(i) );
515 
516  LeftIterator l( A.begin(i) );
517  RightIterator r( B.begin(i) );
518 
519  while( l != lend && r != rend )
520  {
521  if( l->index() < r->index() ) {
522  (~lhs).append( i, l->index(), l->value() );
523  ++l;
524  }
525  else if( l->index() > r->index() ) {
526  (~lhs).append( i, r->index(), -r->value() );
527  ++r;
528  }
529  else {
530  (~lhs).append( i, l->index(), l->value()-r->value() );
531  ++l;
532  ++r;
533  }
534  }
535 
536  while( l != lend ) {
537  (~lhs).append( i, l->index(), l->value() );
538  ++l;
539  }
540 
541  while( r != rend ) {
542  (~lhs).append( i, r->index(), -r->value() );
543  ++r;
544  }
545  }
546  }
548  //**********************************************************************************************
549 
550  //**Assignment to column-major sparse matrices**************************************************
562  template< typename MT > // Type of the target sparse matrix
563  friend inline typename EnableIf< UseSymmetricKernel<MT,MT1,MT2> >::Type
564  assign( SparseMatrix<MT,true>& lhs, const SMatSMatSubExpr& rhs )
565  {
567 
569 
570  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
571  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
572 
573  assign( ~lhs, trans( rhs.lhs_ ) - trans( rhs.rhs_ ) );
574  }
576  //**********************************************************************************************
577 
578  //**Addition assignment to dense matrices*******************************************************
590  template< typename MT // Type of the target dense matrix
591  , bool SO > // Storage order of the target dense matrix
592  friend inline void addAssign( DenseMatrix<MT,SO>& lhs, const SMatSMatSubExpr& rhs )
593  {
595 
596  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
597  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
598 
599  addAssign( ~lhs, rhs.lhs_ );
600  subAssign( ~lhs, rhs.rhs_ );
601  }
603  //**********************************************************************************************
604 
605  //**Addition assignment to sparse matrices******************************************************
606  // No special implementation for the addition assignment to sparse matrices.
607  //**********************************************************************************************
608 
609  //**Subtraction assignment to dense matrices****************************************************
621  template< typename MT // Type of the target dense matrix
622  , bool SO > // Storage order of the target dense matrix
623  friend inline void subAssign( DenseMatrix<MT,SO>& lhs, const SMatSMatSubExpr& rhs )
624  {
626 
627  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
628  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
629 
630  subAssign( ~lhs, rhs.lhs_ );
631  addAssign( ~lhs, rhs.rhs_ );
632  }
634  //**********************************************************************************************
635 
636  //**Subtraction assignment to sparse matrices***************************************************
637  // No special implementation for the subtraction assignment to sparse matrices.
638  //**********************************************************************************************
639 
640  //**Multiplication assignment to dense matrices*************************************************
641  // No special implementation for the multiplication assignment to dense matrices.
642  //**********************************************************************************************
643 
644  //**Multiplication assignment to sparse matrices************************************************
645  // No special implementation for the multiplication assignment to sparse matrices.
646  //**********************************************************************************************
647 
648  //**SMP assignment to dense matrices************************************************************
649  // No special implementation for the SMP assignment to dense matrices.
650  //**********************************************************************************************
651 
652  //**SMP assignment to sparse matrices***********************************************************
653  // No special implementation for the SMP assignment to sparse matrices.
654  //**********************************************************************************************
655 
656  //**SMP addition assignment to dense matrices***************************************************
670  template< typename MT // Type of the target dense matrix
671  , bool SO > // Storage order of the target dense matrix
672  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
673  smpAddAssign( DenseMatrix<MT,SO>& lhs, const SMatSMatSubExpr& rhs )
674  {
676 
677  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
678  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
679 
680  smpAddAssign( ~lhs, rhs.lhs_ );
681  smpSubAssign( ~lhs, rhs.rhs_ );
682  }
684  //**********************************************************************************************
685 
686  //**SMP addition assignment to sparse matrices**************************************************
687  // No special implementation for the SMP addition assignment to sparse matrices.
688  //**********************************************************************************************
689 
690  //**SMP subtraction assignment to dense matrices************************************************
705  template< typename MT // Type of the target dense matrix
706  , bool SO > // Storage order of the target dense matrix
707  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
708  smpSubAssign( DenseMatrix<MT,SO>& lhs, const SMatSMatSubExpr& rhs )
709  {
711 
712  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
713  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
714 
715  smpSubAssign( ~lhs, rhs.lhs_ );
716  smpAddAssign( ~lhs, rhs.rhs_ );
717  }
719  //**********************************************************************************************
720 
721  //**SMP subtraction assignment to sparse matrices***********************************************
722  // No special implementation for the SMP subtraction assignment to sparse matrices.
723  //**********************************************************************************************
724 
725  //**SMP multiplication assignment to dense matrices*********************************************
726  // No special implementation for the SMP multiplication assignment to dense matrices.
727  //**********************************************************************************************
728 
729  //**SMP multiplication assignment to sparse matrices********************************************
730  // No special implementation for the SMP multiplication assignment to sparse matrices.
731  //**********************************************************************************************
732 
733  //**Compile time checks*************************************************************************
741  //**********************************************************************************************
742 };
743 //*************************************************************************************************
744 
745 
746 
747 
748 //=================================================================================================
749 //
750 // GLOBAL BINARY ARITHMETIC OPERATORS
751 //
752 //=================================================================================================
753 
754 //*************************************************************************************************
780 template< typename T1 // Type of the left-hand side sparse matrix
781  , typename T2 > // Type of the right-hand side sparse matrix
782 inline const SMatSMatSubExpr<T1,T2>
784 {
786 
787  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() )
788  throw std::invalid_argument( "Matrix sizes do not match" );
789 
790  return SMatSMatSubExpr<T1,T2>( ~lhs, ~rhs );
791 }
792 //*************************************************************************************************
793 
794 
795 
796 
797 //=================================================================================================
798 //
799 // ROWS SPECIALIZATIONS
800 //
801 //=================================================================================================
802 
803 //*************************************************************************************************
805 template< typename MT1, typename MT2 >
806 struct Rows< SMatSMatSubExpr<MT1,MT2> >
807  : public Max< Rows<MT1>, Rows<MT2> >::Type
808 {};
810 //*************************************************************************************************
811 
812 
813 
814 
815 //=================================================================================================
816 //
817 // COLUMNS SPECIALIZATIONS
818 //
819 //=================================================================================================
820 
821 //*************************************************************************************************
823 template< typename MT1, typename MT2 >
824 struct Columns< SMatSMatSubExpr<MT1,MT2> >
825  : public Max< Columns<MT1>, Columns<MT2> >::Type
826 {};
828 //*************************************************************************************************
829 
830 
831 
832 
833 //=================================================================================================
834 //
835 // ISSYMMETRIC SPECIALIZATIONS
836 //
837 //=================================================================================================
838 
839 //*************************************************************************************************
841 template< typename MT1, typename MT2 >
842 struct IsSymmetric< SMatSMatSubExpr<MT1,MT2> >
843  : public IsTrue< IsSymmetric<MT1>::value && IsSymmetric<MT2>::value >
844 {};
846 //*************************************************************************************************
847 
848 
849 
850 
851 //=================================================================================================
852 //
853 // ISLOWER SPECIALIZATIONS
854 //
855 //=================================================================================================
856 
857 //*************************************************************************************************
859 template< typename MT1, typename MT2 >
860 struct IsLower< SMatSMatSubExpr<MT1,MT2> >
861  : public IsTrue< IsLower<MT1>::value && IsLower<MT2>::value >
862 {};
864 //*************************************************************************************************
865 
866 
867 
868 
869 //=================================================================================================
870 //
871 // ISUPPER SPECIALIZATIONS
872 //
873 //=================================================================================================
874 
875 //*************************************************************************************************
877 template< typename MT1, typename MT2 >
878 struct IsUpper< SMatSMatSubExpr<MT1,MT2> >
879  : public IsTrue< IsUpper<MT1>::value && IsUpper<MT2>::value >
880 {};
882 //*************************************************************************************************
883 
884 
885 
886 
887 //=================================================================================================
888 //
889 // EXPRESSION TRAIT SPECIALIZATIONS
890 //
891 //=================================================================================================
892 
893 //*************************************************************************************************
895 template< typename MT1, typename MT2, bool AF >
896 struct SubmatrixExprTrait< SMatSMatSubExpr<MT1,MT2>, AF >
897 {
898  public:
899  //**********************************************************************************************
900  typedef typename SubExprTrait< typename SubmatrixExprTrait<const MT1,AF>::Type
901  , typename SubmatrixExprTrait<const MT2,AF>::Type >::Type Type;
902  //**********************************************************************************************
903 };
905 //*************************************************************************************************
906 
907 
908 //*************************************************************************************************
910 template< typename MT1, typename MT2 >
911 struct RowExprTrait< SMatSMatSubExpr<MT1,MT2> >
912 {
913  public:
914  //**********************************************************************************************
915  typedef typename SubExprTrait< typename RowExprTrait<const MT1>::Type
916  , typename RowExprTrait<const MT2>::Type >::Type Type;
917  //**********************************************************************************************
918 };
920 //*************************************************************************************************
921 
922 
923 //*************************************************************************************************
925 template< typename MT1, typename MT2 >
926 struct ColumnExprTrait< SMatSMatSubExpr<MT1,MT2> >
927 {
928  public:
929  //**********************************************************************************************
930  typedef typename SubExprTrait< typename ColumnExprTrait<const MT1>::Type
931  , typename ColumnExprTrait<const MT2>::Type >::Type Type;
932  //**********************************************************************************************
933 };
935 //*************************************************************************************************
936 
937 } // namespace blaze
938 
939 #endif
Constraint on the data type.
Header file for the Max class template.
MT2::CompositeType CT2
Composite type of the right-hand side sparse matrix expression.
Definition: SMatSMatSubExpr.h:108
Compile time check whether the given type is a temporary vector or matrix type.This type trait class ...
Definition: IsTemporary.h:87
Header file for the Rows type trait.
Header file for the subtraction trait.
size_t nonZeros(size_t i) const
Returns the number of non-zero elements in the specified row.
Definition: SMatSMatSubExpr.h:244
LeftOperand leftOperand() const
Returns the left-hand side sparse matrix operand.
Definition: SMatSMatSubExpr.h:254
BLAZE_ALWAYS_INLINE MT::Iterator end(Matrix< MT, SO > &matrix, size_t i)
Returns an iterator just past the last element of row/column i.
Definition: Matrix.h:258
bool canAlias(const T *alias) const
Returns whether the expression can alias with the given address alias.
Definition: SMatSMatSubExpr.h:276
Efficient implementation of a compressed matrix.The CompressedMatrix class template is the represent...
Definition: CompressedMatrix.h:205
Header file for the ColumnExprTrait class template.
MT2::ReturnType RN2
ReturnType type of the right-hand side sparse matrix expression.
Definition: SMatSMatSubExpr.h:106
size_t nonZeros() const
Returns the number of non-zero elements in the sparse matrix.
Definition: SMatSMatSubExpr.h:233
SelectType< IsExpression< MT1 >::value, const MT1, const MT1 & >::Type LeftOperand
Composite type of the left-hand side sparse matrix expression.
Definition: SMatSMatSubExpr.h:168
const This & CompositeType
Data type for composite expression templates.
Definition: CompressedMatrix.h:2478
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:257
BLAZE_ALWAYS_INLINE size_t rows(const Matrix< MT, SO > &matrix)
Returns the current number of rows of the matrix.
Definition: Matrix.h:316
SMatSMatSubExpr< MT1, MT2 > This
Type of this SMatSMatSubExpr instance.
Definition: SMatSMatSubExpr.h:155
const SelectType< returnExpr, ExprReturnType, ElementType >::Type ReturnType
Return type for expression template evaluations.
Definition: SMatSMatSubExpr.h:162
ResultType::OppositeType OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: SMatSMatSubExpr.h:157
const DMatSerialExpr< MT, SO > serial(const DenseMatrix< MT, SO > &dm)
Forces the serial evaluation of the given dense matrix expression dm.
Definition: DMatSerialExpr.h:695
ResultType::ElementType ElementType
Resulting element type.
Definition: SMatSMatSubExpr.h:159
Header file for the Computation base class.
Header file for the RequiresEvaluation type trait.
size_t columns() const
Returns the current number of columns of the matrix.
Definition: SMatSMatSubExpr.h:223
const ResultType CompositeType
Data type for composite expression templates.
Definition: SMatSMatSubExpr.h:165
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
MT1::ReturnType RN1
ReturnType type of the left-hand side sparse matrix expression.
Definition: SMatSMatSubExpr.h:105
Header file for the SparseMatrix base class.
Constraint on the data type.
RightOperand rightOperand() const
Returns the right-hand side sparse matrix operand.
Definition: SMatSMatSubExpr.h:264
Compile time type selection.The SelectType class template selects one of the two given types T1 and T...
Definition: SelectType.h:59
Header file for the DisableIf class template.
Header file for the IsTemporary type trait class.
Header file for the IsSymmetric type trait.
SubTrait< RT1, RT2 >::Type ResultType
Result type for expression template evaluations.
Definition: SMatSMatSubExpr.h:156
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: SMatSMatSubExpr.h:201
#define BLAZE_CONSTRAINT_MUST_BE_COLUMN_MAJOR_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is not a column-major dense or sparse matri...
Definition: StorageOrder.h:161
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:2482
BLAZE_ALWAYS_INLINE void assign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the assignment of a matrix to a matrix.
Definition: Matrix.h:635
Header file for the Columns type trait.
Header file for the MatMatSubExpr base class.
Header file for the IsLower type trait.
LeftOperand lhs_
Left-hand side sparse matrix of the subtraction expression.
Definition: SMatSMatSubExpr.h:295
MT1::CompositeType CT1
Composite type of the left-hand side sparse matrix expression.
Definition: SMatSMatSubExpr.h:107
Constraints on the storage order of matrix types.
Compile time check for symmetric matrices.This type trait tests whether or not the given template par...
Definition: IsSymmetric.h:85
Evaluation of the return type of a subtraction expression.Via this type trait it is possible to evalu...
Definition: SubExprTrait.h:104
Header file for the SelectType class template.
Header file for the RowExprTrait class template.
Header file for all forward declarations for expression class templates.
Header file for the EnableIf class template.
bool isAliased(const T *alias) const
Returns whether the expression is aliased with the given address alias.
Definition: SMatSMatSubExpr.h:288
Header file for the serial shim.
Compile time check for resizable data types.This type trait tests whether the given data type is a re...
Definition: IsResizable.h:75
EnableIf< IsDenseMatrix< MT1 > >::Type smpSubAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP subtraction assignment of a matrix to dense matrix.
Definition: DenseMatrix.h:160
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SYMMETRIC_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is a symmetric matrix type, a compilation error is created.
Definition: Symmetric.h:116
Header file for the SubmatrixExprTrait class template.
#define BLAZE_CONSTRAINT_MUST_BE_ROW_MAJOR_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is not a row-major dense or sparse matrix t...
Definition: StorageOrder.h:81
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:2477
Removal of reference modifiers.The RemoveCV type trait removes any reference modifiers from the given...
Definition: RemoveReference.h:69
RightOperand rhs_
Right-hand side sparse matrix of the subtraction expression.
Definition: SMatSMatSubExpr.h:296
Header file for run time assertion macros.
Expression object for sparse matrix-sparse matrix subtractions.The SMatSMatSubExpr class represents t...
Definition: Forward.h:98
BLAZE_ALWAYS_INLINE void addAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the addition assignment of a matrix to a matrix.
Definition: Matrix.h:742
const DenseIterator< Type > operator-(const DenseIterator< Type > &it, ptrdiff_t inc)
Subtraction between a DenseIterator and an integral value.
Definition: DenseIterator.h:585
SubExprTrait< RN1, RN2 >::Type ExprReturnType
Expression return type for the subscript operator.
Definition: SMatSMatSubExpr.h:121
Header file for the isDefault shim.
BLAZE_ALWAYS_INLINE bool isDefault(const NonNumericProxy< MT > &proxy)
Returns whether the represented element is in default state.
Definition: NonNumericProxy.h:874
Constraint on the data type.
MT2::ResultType RT2
Result type of the right-hand side sparse matrix expression.
Definition: SMatSMatSubExpr.h:104
SelectType< IsExpression< MT2 >::value, const MT2, const MT2 & >::Type RightOperand
Composite type of the right-hand side sparse matrix expression.
Definition: SMatSMatSubExpr.h:171
ResultType::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: SMatSMatSubExpr.h:158
Header file for the RemoveReference type trait.
const DMatTransExpr< MT,!SO > trans(const DenseMatrix< MT, SO > &dm)
Calculation of the transpose of the given dense matrix.
Definition: DMatTransExpr.h:932
Header file for the IsComputation type trait class.
size_t rows() const
Returns the current number of rows of the matrix.
Definition: SMatSMatSubExpr.h:213
EnableIf< IsDenseMatrix< MT1 > >::Type smpAddAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP addition assignment of a matrix to a dense matrix.
Definition: DenseMatrix.h:129
#define BLAZE_FUNCTION_TRACE
Function trace macro.This macro can be used to reliably trace function calls. In case function tracin...
Definition: FunctionTrace.h:157
This ResultType
Result type for expression template evaluations.
Definition: CompressedMatrix.h:2473
Header file for the IsTrue value trait.
BLAZE_ALWAYS_INLINE size_t columns(const Matrix< MT, SO > &matrix)
Returns the current number of columns of the matrix.
Definition: Matrix.h:332
MT1::ResultType RT1
Result type of the left-hand side sparse matrix expression.
Definition: SMatSMatSubExpr.h:103
Header file for basic type definitions.
#define BLAZE_CONSTRAINT_MUST_FORM_VALID_MATMATSUBEXPR(T1, T2)
Constraint on the data type.In case the given data types T1 and T2 do not form a valid matrix/matrix ...
Definition: MatMatSubExpr.h:165
Base template for the SubTrait class.
Definition: SubTrait.h:142
Header file for the IsUpper type trait.
Header file for the IsResizable type trait.
Header file for the SubExprTrait class template.
SMatSMatSubExpr(const MT1 &lhs, const MT2 &rhs)
Constructor for the SMatSMatSubExpr class.
Definition: SMatSMatSubExpr.h:185
#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
#define BLAZE_CONSTRAINT_MUST_BE_SPARSE_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is not a sparse, N-dimensional matrix type...
Definition: SparseMatrix.h:79
Header file for the IsExpression type trait class.
Header file for the FunctionTrace class.
BLAZE_ALWAYS_INLINE void subAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the subtraction assignment of a matrix to matrix.
Definition: Matrix.h:849