TSMatTSMatSubExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_TSMATTSMATSUBEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_TSMATTSMATSUBEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <stdexcept>
73 #include <blaze/util/Assert.h>
74 #include <blaze/util/DisableIf.h>
75 #include <blaze/util/EnableIf.h>
77 #include <blaze/util/mpl/And.h>
78 #include <blaze/util/mpl/Max.h>
79 #include <blaze/util/SelectType.h>
80 #include <blaze/util/Types.h>
83 
84 
85 namespace blaze {
86 
87 //=================================================================================================
88 //
89 // CLASS TSMATTSMATSUBEXPR
90 //
91 //=================================================================================================
92 
93 //*************************************************************************************************
100 template< typename MT1 // Type of the left-hand side sparse matrix
101  , typename MT2 > // Type of the right-hand side sparse matrix
102 class TSMatTSMatSubExpr : public SparseMatrix< TSMatTSMatSubExpr<MT1,MT2>, true >
103  , private MatMatSubExpr
104  , private Computation
105 {
106  private:
107  //**Type definitions****************************************************************************
108  typedef typename MT1::ResultType RT1;
109  typedef typename MT2::ResultType RT2;
110  typedef typename MT1::ReturnType RN1;
111  typedef typename MT2::ReturnType RN2;
112  typedef typename MT1::CompositeType CT1;
113  typedef typename MT2::CompositeType CT2;
114  //**********************************************************************************************
115 
116  //**Return type evaluation**********************************************************************
118 
123  enum { returnExpr = !IsTemporary<RN1>::value && !IsTemporary<RN2>::value };
124 
127  //**********************************************************************************************
128 
129  //**Serial evaluation strategy******************************************************************
131 
136  template< typename T1, typename T2, typename T3 >
137  struct UseSymmetricKernel {
140  };
142  //**********************************************************************************************
143 
144  //**Parallel evaluation strategy****************************************************************
146 
151  template< typename MT >
152  struct UseSMPAssign {
153  enum { value = MT::smpAssignable };
154  };
156  //**********************************************************************************************
157 
158  public:
159  //**Type definitions****************************************************************************
165 
168 
170  typedef const ResultType CompositeType;
171 
173  typedef typename SelectType< IsExpression<MT1>::value, const MT1, const MT1& >::Type LeftOperand;
174 
176  typedef typename SelectType< IsExpression<MT2>::value, const MT2, const MT2& >::Type RightOperand;
177  //**********************************************************************************************
178 
179  //**Compilation flags***************************************************************************
181  enum { smpAssignable = 0 };
182  //**********************************************************************************************
183 
184  //**Constructor*********************************************************************************
190  explicit inline TSMatTSMatSubExpr( const MT1& lhs, const MT2& rhs )
191  : lhs_( lhs ) // Left-hand side sparse matrix of the subtraction expression
192  , rhs_( rhs ) // Right-hand side sparse matrix of the subtraction expression
193  {
194  BLAZE_INTERNAL_ASSERT( lhs.rows() == rhs.rows() , "Invalid number of rows" );
195  BLAZE_INTERNAL_ASSERT( lhs.columns() == rhs.columns(), "Invalid number of columns" );
196  }
197  //**********************************************************************************************
198 
199  //**Access operator*****************************************************************************
206  inline ReturnType operator()( size_t i, size_t j ) const {
207  BLAZE_INTERNAL_ASSERT( i < lhs_.rows() , "Invalid row access index" );
208  BLAZE_INTERNAL_ASSERT( j < lhs_.columns(), "Invalid column access index" );
209  return lhs_(i,j) - rhs_(i,j);
210  }
211  //**********************************************************************************************
212 
213  //**Rows function*******************************************************************************
218  inline size_t rows() const {
219  return lhs_.rows();
220  }
221  //**********************************************************************************************
222 
223  //**Columns function****************************************************************************
228  inline size_t columns() const {
229  return lhs_.columns();
230  }
231  //**********************************************************************************************
232 
233  //**NonZeros function***************************************************************************
238  inline size_t nonZeros() const {
239  return lhs_.nonZeros() + rhs_.nonZeros();
240  }
241  //**********************************************************************************************
242 
243  //**NonZeros function***************************************************************************
249  inline size_t nonZeros( size_t i ) const {
250  return lhs_.nonZeros(i) + rhs_.nonZeros(i);
251  }
252  //**********************************************************************************************
253 
254  //**Left operand access*************************************************************************
259  inline LeftOperand leftOperand() const {
260  return lhs_;
261  }
262  //**********************************************************************************************
263 
264  //**Right operand access************************************************************************
269  inline RightOperand rightOperand() const {
270  return rhs_;
271  }
272  //**********************************************************************************************
273 
274  //**********************************************************************************************
280  template< typename T >
281  inline bool canAlias( const T* alias ) const {
282  return ( lhs_.canAlias( alias ) || rhs_.canAlias( alias ) );
283  }
284  //**********************************************************************************************
285 
286  //**********************************************************************************************
292  template< typename T >
293  inline bool isAliased( const T* alias ) const {
294  return ( lhs_.isAliased( alias ) || rhs_.isAliased( alias ) );
295  }
296  //**********************************************************************************************
297 
298  private:
299  //**Member variables****************************************************************************
300  LeftOperand lhs_;
301  RightOperand rhs_;
302  //**********************************************************************************************
303 
304  //**Assignment to dense matrices****************************************************************
317  template< typename MT // Type of the target dense matrix
318  , bool SO > // Storage order of the target dense matrix
319  friend inline void assign( DenseMatrix<MT,SO>& lhs, const TSMatTSMatSubExpr& rhs )
320  {
322 
323  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
324  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
325 
326  typedef typename RemoveReference<CT2>::Type::ConstIterator RightIterator;
327 
328  assign( ~lhs, rhs.lhs_ );
329 
331  subAssign( ~lhs, rhs.rhs_ );
332  }
333  else
334  {
335  CT2 B( serial( rhs.rhs_ ) ); // Evaluation of the right-hand side sparse matrix operand
336 
337  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
338  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
339  BLAZE_INTERNAL_ASSERT( B.rows() == (~lhs).rows() , "Invalid number of rows" );
340  BLAZE_INTERNAL_ASSERT( B.columns() == (~lhs).columns() , "Invalid number of columns" );
341 
342  for( size_t j=0UL; j<(~lhs).columns(); ++j ) {
343  const RightIterator end( B.end(j) );
344  for( RightIterator element=B.begin(j); element!=end; ++element ) {
345  if( isDefault( (~lhs)(element->index(),j) ) )
346  (~lhs)(element->index(),j) = -element->value();
347  else
348  (~lhs)(element->index(),j) -= element->value();
349  }
350  }
351  }
352  }
354  //**********************************************************************************************
355 
356  //**Assignment to row-major sparse matrices*****************************************************
369  template< typename MT > // Type of the target sparse matrix
370  friend inline typename DisableIf< UseSymmetricKernel<MT,MT1,MT2> >::Type
372  {
374 
376 
377  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
378  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
379 
380  typedef typename RemoveReference<CT1>::Type::ConstIterator LeftIterator;
381  typedef typename RemoveReference<CT2>::Type::ConstIterator RightIterator;
382 
383  CT1 A( serial( rhs.lhs_ ) ); // Evaluation of the left-hand side sparse matrix operand
384  CT2 B( serial( rhs.rhs_ ) ); // Evaluation of the right-hand side sparse matrix operand
385 
386  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.lhs_.rows() , "Invalid number of rows" );
387  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.lhs_.columns(), "Invalid number of columns" );
388  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
389  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
390  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
391  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).columns() , "Invalid number of columns" );
392 
393  const size_t m( rhs.rows() );
394  const size_t n( rhs.columns() );
395 
396  // Counting the number of elements per column
397  std::vector<size_t> nonzeros( m, 0UL );
398  for( size_t j=0UL; j<n; ++j )
399  {
400  const LeftIterator lend( A.end(j) );
401  const RightIterator rend( B.end(j) );
402 
403  LeftIterator l( A.begin(j) );
404  RightIterator r( B.begin(j) );
405 
406  while( l != lend && r != rend )
407  {
408  if( l->index() < r->index() ) {
409  ++nonzeros[l->index()];
410  ++l;
411  }
412  else if( l->index() > r->index() ) {
413  ++nonzeros[r->index()];
414  ++r;
415  }
416  else {
417  ++nonzeros[l->index()];
418  ++l;
419  ++r;
420  }
421  }
422 
423  while( l != lend ) {
424  ++nonzeros[l->index()];
425  ++l;
426  }
427 
428  while( r != rend ) {
429  ++nonzeros[r->index()];
430  ++r;
431  }
432  }
433 
434  // Resizing the left-hand side sparse matrix
435  for( size_t i=0UL; i<m; ++i ) {
436  (~lhs).reserve( i, nonzeros[i] );
437  }
438 
439  // Performing the matrix subtraction
440  for( size_t j=0UL; j<n; ++j )
441  {
442  const LeftIterator lend( A.end(j) );
443  const RightIterator rend( B.end(j) );
444 
445  LeftIterator l( A.begin(j) );
446  RightIterator r( B.begin(j) );
447 
448  while( l != lend && r != rend )
449  {
450  if( l->index() < r->index() ) {
451  (~lhs).append( l->index(), j, l->value() );
452  ++l;
453  }
454  else if( l->index() > r->index() ) {
455  (~lhs).append( r->index(), j, -r->value() );
456  ++r;
457  }
458  else {
459  (~lhs).append( l->index(), j, l->value()-r->value() );
460  ++l;
461  ++r;
462  }
463  }
464 
465  while( l != lend ) {
466  (~lhs).append( l->index(), j, l->value() );
467  ++l;
468  }
469 
470  while( r != rend ) {
471  (~lhs).append( r->index(), j, -r->value() );
472  ++r;
473  }
474  }
475  }
477  //**********************************************************************************************
478 
479  //**Assignment to row-major sparse matrices*****************************************************
492  template< typename MT > // Type of the target sparse matrix
493  friend inline typename EnableIf< UseSymmetricKernel<MT,MT1,MT2> >::Type
494  assign( SparseMatrix<MT,false>& lhs, const TSMatTSMatSubExpr& rhs )
495  {
497 
499 
500  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
501  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
502 
503  assign( ~lhs, trans( rhs.lhs_ ) - trans( rhs.rhs_ ) );
504  }
506  //**********************************************************************************************
507 
508  //**Assignment to column-major sparse matrices**************************************************
521  template< typename MT > // Type of the target sparse matrix
522  friend inline void assign( SparseMatrix<MT,true>& lhs, const TSMatTSMatSubExpr& rhs )
523  {
525 
526  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
527  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
528 
529  typedef typename RemoveReference<CT1>::Type::ConstIterator LeftIterator;
530  typedef typename RemoveReference<CT2>::Type::ConstIterator RightIterator;
531 
532  CT1 A( serial( rhs.lhs_ ) ); // Evaluation of the left-hand side sparse matrix operand
533  CT2 B( serial( rhs.rhs_ ) ); // Evaluation of the right-hand side sparse matrix operand
534 
535  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.lhs_.rows() , "Invalid number of rows" );
536  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.lhs_.columns(), "Invalid number of columns" );
537  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
538  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
539  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
540  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).columns() , "Invalid number of columns" );
541 
542  // Final memory allocation (based on the evaluated operands)
543  (~lhs).reserve( A.nonZeros() + B.nonZeros() );
544 
545  // Performing the matrix subtraction
546  for( size_t j=0UL; j<(~lhs).columns(); ++j )
547  {
548  const LeftIterator lend( A.end(j) );
549  const RightIterator rend( B.end(j) );
550 
551  LeftIterator l( A.begin(j) );
552  RightIterator r( B.begin(j) );
553 
554  while( l != lend && r != rend )
555  {
556  if( l->index() < r->index() ) {
557  (~lhs).append( l->index(), j, l->value() );
558  ++l;
559  }
560  else if( l->index() > r->index() ) {
561  (~lhs).append( r->index(), j, -r->value() );
562  ++r;
563  }
564  else {
565  (~lhs).append( l->index(), j, l->value()-r->value() );
566  ++l;
567  ++r;
568  }
569  }
570 
571  while( l != lend ) {
572  (~lhs).append( l->index(), j, l->value() );
573  ++l;
574  }
575 
576  while( r != rend ) {
577  (~lhs).append( r->index(), j, -r->value() );
578  ++r;
579  }
580 
581  (~lhs).finalize( j );
582  }
583  }
585  //**********************************************************************************************
586 
587  //**Addition assignment to dense matrices*******************************************************
600  template< typename MT // Type of the target dense matrix
601  , bool SO > // Storage order of the target dense matrix
602  friend inline void addAssign( DenseMatrix<MT,SO>& lhs, const TSMatTSMatSubExpr& rhs )
603  {
605 
606  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
607  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
608 
609  addAssign( ~lhs, rhs.lhs_ );
610  subAssign( ~lhs, rhs.rhs_ );
611  }
613  //**********************************************************************************************
614 
615  //**Addition assignment to sparse matrices******************************************************
616  // No special implementation for the addition assignment to sparse matrices.
617  //**********************************************************************************************
618 
619  //**Subtraction assignment to dense matrices****************************************************
632  template< typename MT // Type of the target dense matrix
633  , bool SO > // Storage order of the target dense matrix
634  friend inline void subAssign( DenseMatrix<MT,SO>& lhs, const TSMatTSMatSubExpr& rhs )
635  {
637 
638  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
639  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
640 
641  subAssign( ~lhs, rhs.lhs_ );
642  addAssign( ~lhs, rhs.rhs_ );
643  }
645  //**********************************************************************************************
646 
647  //**Subtraction assignment to sparse matrices***************************************************
648  // No special implementation for the subtraction assignment to sparse matrices.
649  //**********************************************************************************************
650 
651  //**Multiplication assignment to dense matrices*************************************************
652  // No special implementation for the multiplication assignment to dense matrices.
653  //**********************************************************************************************
654 
655  //**Multiplication assignment to sparse matrices************************************************
656  // No special implementation for the multiplication assignment to sparse matrices.
657  //**********************************************************************************************
658 
659  //**SMP assignment to dense matrices************************************************************
660  // No special implementation for the SMP assignment to dense matrices.
661  //**********************************************************************************************
662 
663  //**SMP assignment to sparse matrices***********************************************************
664  // No special implementation for the SMP assignment to sparse matrices.
665  //**********************************************************************************************
666 
667  //**SMP addition assignment to dense matrices***************************************************
682  template< typename MT // Type of the target dense matrix
683  , bool SO > // Storage order of the target dense matrix
684  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
685  smpAddAssign( DenseMatrix<MT,SO>& lhs, const TSMatTSMatSubExpr& rhs )
686  {
688 
689  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
690  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
691 
692  smpAddAssign( ~lhs, rhs.lhs_ );
693  smpSubAssign( ~lhs, rhs.rhs_ );
694  }
696  //**********************************************************************************************
697 
698  //**SMP addition assignment to sparse matrices**************************************************
699  // No special implementation for the SMP addition assignment to sparse matrices.
700  //**********************************************************************************************
701 
702  //**SMP subtraction assignment to dense matrices************************************************
717  template< typename MT // Type of the target dense matrix
718  , bool SO > // Storage order of the target dense matrix
719  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
720  smpSubAssign( DenseMatrix<MT,SO>& lhs, const TSMatTSMatSubExpr& rhs )
721  {
723 
724  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
725  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
726 
727  smpSubAssign( ~lhs, rhs.lhs_ );
728  smpAddAssign( ~lhs, rhs.rhs_ );
729  }
731  //**********************************************************************************************
732 
733  //**SMP subtraction assignment to sparse matrices***********************************************
734  // No special implementation for the SMP subtraction assignment to sparse matrices.
735  //**********************************************************************************************
736 
737  //**SMP multiplication assignment to dense matrices*********************************************
738  // No special implementation for the SMP multiplication assignment to dense matrices.
739  //**********************************************************************************************
740 
741  //**SMP multiplication assignment to sparse matrices********************************************
742  // No special implementation for the SMP multiplication assignment to sparse matrices.
743  //**********************************************************************************************
744 
745  //**Compile time checks*************************************************************************
753  //**********************************************************************************************
754 };
755 //*************************************************************************************************
756 
757 
758 
759 
760 //=================================================================================================
761 //
762 // GLOBAL BINARY ARITHMETIC OPERATORS
763 //
764 //=================================================================================================
765 
766 //*************************************************************************************************
793 template< typename T1 // Type of the left-hand side sparse matrix
794  , typename T2 > // Type of the right-hand side sparse matrix
795 inline const TSMatTSMatSubExpr<T1,T2>
797 {
799 
800  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() )
801  throw std::invalid_argument( "Matrix sizes do not match" );
802 
803  return TSMatTSMatSubExpr<T1,T2>( ~lhs, ~rhs );
804 }
805 //*************************************************************************************************
806 
807 
808 
809 
810 //=================================================================================================
811 //
812 // ROWS SPECIALIZATIONS
813 //
814 //=================================================================================================
815 
816 //*************************************************************************************************
818 template< typename MT1, typename MT2 >
819 struct Rows< TSMatTSMatSubExpr<MT1,MT2> >
820  : public Max< Rows<MT1>, Rows<MT2> >::Type
821 {};
823 //*************************************************************************************************
824 
825 
826 
827 
828 //=================================================================================================
829 //
830 // COLUMNS SPECIALIZATIONS
831 //
832 //=================================================================================================
833 
834 //*************************************************************************************************
836 template< typename MT1, typename MT2 >
837 struct Columns< TSMatTSMatSubExpr<MT1,MT2> >
838  : public Max< Columns<MT1>, Columns<MT2> >::Type
839 {};
841 //*************************************************************************************************
842 
843 
844 
845 
846 //=================================================================================================
847 //
848 // ISSYMMETRIC SPECIALIZATIONS
849 //
850 //=================================================================================================
851 
852 //*************************************************************************************************
854 template< typename MT1, typename MT2 >
855 struct IsSymmetric< TSMatTSMatSubExpr<MT1,MT2> >
856  : public IsTrue< IsSymmetric<MT1>::value && IsSymmetric<MT2>::value >
857 {};
859 //*************************************************************************************************
860 
861 
862 
863 
864 //=================================================================================================
865 //
866 // ISLOWER SPECIALIZATIONS
867 //
868 //=================================================================================================
869 
870 //*************************************************************************************************
872 template< typename MT1, typename MT2 >
873 struct IsLower< TSMatTSMatSubExpr<MT1,MT2> >
874  : public IsTrue< And< IsLower<MT1>, IsLower<MT2> >::value >
875 {};
877 //*************************************************************************************************
878 
879 
880 
881 
882 //=================================================================================================
883 //
884 // ISUNILOWER SPECIALIZATIONS
885 //
886 //=================================================================================================
887 
888 //*************************************************************************************************
890 template< typename MT1, typename MT2 >
891 struct IsUniLower< TSMatTSMatSubExpr<MT1,MT2> >
892  : public IsTrue< And< IsUniLower<MT1>, IsStrictlyLower<MT2> >::value >
893 {};
895 //*************************************************************************************************
896 
897 
898 
899 
900 //=================================================================================================
901 //
902 // ISSTRICTLYLOWER SPECIALIZATIONS
903 //
904 //=================================================================================================
905 
906 //*************************************************************************************************
908 template< typename MT1, typename MT2 >
909 struct IsStrictlyLower< TSMatTSMatSubExpr<MT1,MT2> >
910  : public IsTrue< And< IsStrictlyLower<MT1>, IsStrictlyLower<MT2> >::value >
911 {};
913 //*************************************************************************************************
914 
915 
916 
917 
918 //=================================================================================================
919 //
920 // ISUPPER SPECIALIZATIONS
921 //
922 //=================================================================================================
923 
924 //*************************************************************************************************
926 template< typename MT1, typename MT2 >
927 struct IsUpper< TSMatTSMatSubExpr<MT1,MT2> >
928  : public IsTrue< And< IsUpper<MT1>, IsUpper<MT2> >::value >
929 {};
931 //*************************************************************************************************
932 
933 
934 
935 
936 //=================================================================================================
937 //
938 // ISUNIUPPER SPECIALIZATIONS
939 //
940 //=================================================================================================
941 
942 //*************************************************************************************************
944 template< typename MT1, typename MT2 >
945 struct IsUniUpper< TSMatTSMatSubExpr<MT1,MT2> >
946  : public IsTrue< And< IsUniUpper<MT1>, IsStrictlyUpper<MT2> >::value >
947 {};
949 //*************************************************************************************************
950 
951 
952 
953 
954 //=================================================================================================
955 //
956 // ISSTRICTLYUPPER SPECIALIZATIONS
957 //
958 //=================================================================================================
959 
960 //*************************************************************************************************
962 template< typename MT1, typename MT2 >
963 struct IsStrictlyUpper< TSMatTSMatSubExpr<MT1,MT2> >
964  : public IsTrue< And< IsStrictlyUpper<MT1>, IsStrictlyUpper<MT2> >::value >
965 {};
967 //*************************************************************************************************
968 
969 
970 
971 
972 //=================================================================================================
973 //
974 // EXPRESSION TRAIT SPECIALIZATIONS
975 //
976 //=================================================================================================
977 
978 //*************************************************************************************************
980 template< typename MT1, typename MT2, bool AF >
981 struct SubmatrixExprTrait< TSMatTSMatSubExpr<MT1,MT2>, AF >
982 {
983  public:
984  //**********************************************************************************************
985  typedef typename SubExprTrait< typename SubmatrixExprTrait<const MT1,AF>::Type
986  , typename SubmatrixExprTrait<const MT2,AF>::Type >::Type Type;
987  //**********************************************************************************************
988 };
990 //*************************************************************************************************
991 
992 
993 //*************************************************************************************************
995 template< typename MT1, typename MT2 >
996 struct RowExprTrait< TSMatTSMatSubExpr<MT1,MT2> >
997 {
998  public:
999  //**********************************************************************************************
1000  typedef typename SubExprTrait< typename RowExprTrait<const MT1>::Type
1001  , typename RowExprTrait<const MT2>::Type >::Type Type;
1002  //**********************************************************************************************
1003 };
1005 //*************************************************************************************************
1006 
1007 
1008 //*************************************************************************************************
1010 template< typename MT1, typename MT2 >
1011 struct ColumnExprTrait< TSMatTSMatSubExpr<MT1,MT2> >
1012 {
1013  public:
1014  //**********************************************************************************************
1015  typedef typename SubExprTrait< typename ColumnExprTrait<const MT1>::Type
1016  , typename ColumnExprTrait<const MT2>::Type >::Type Type;
1017  //**********************************************************************************************
1018 };
1020 //*************************************************************************************************
1021 
1022 } // namespace blaze
1023 
1024 #endif
Constraint on the data type.
MT2::ResultType RT2
Result type of the right-hand side sparse matrix expression.
Definition: TSMatTSMatSubExpr.h:109
SelectType< IsExpression< MT2 >::value, const MT2, const MT2 & >::Type RightOperand
Composite type of the right-hand side sparse matrix expression.
Definition: TSMatTSMatSubExpr.h:176
Header file for the Max class template.
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 IsUniUpper type trait.
Header file for the subtraction trait.
Header file for basic type definitions.
MT1::CompositeType CT1
Composite type of the left-hand side sparse matrix expression.
Definition: TSMatTSMatSubExpr.h:112
TSMatTSMatSubExpr< MT1, MT2 > This
Type of this TSMatTSMatSubExpr instance.
Definition: TSMatTSMatSubExpr.h:160
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
const SelectType< returnExpr, ExprReturnType, ElementType >::Type ReturnType
Return type for expression template evaluations.
Definition: TSMatTSMatSubExpr.h:167
Efficient implementation of a compressed matrix.The CompressedMatrix class template is the represent...
Definition: CompressedMatrix.h:209
const ResultType CompositeType
Data type for composite expression templates.
Definition: TSMatTSMatSubExpr.h:170
MT1::ReturnType RN1
Return type of the left-hand side sparse matrix expression.
Definition: TSMatTSMatSubExpr.h:110
Header file for the ColumnExprTrait class template.
RightOperand rightOperand() const
Returns the right-hand side transpose sparse matrix operand.
Definition: TSMatTSMatSubExpr.h:269
const This & CompositeType
Data type for composite expression templates.
Definition: CompressedMatrix.h:2507
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:261
BLAZE_ALWAYS_INLINE size_t rows(const Matrix< MT, SO > &matrix)
Returns the current number of rows of the matrix.
Definition: Matrix.h:316
Header file for the And class template.
const DMatSerialExpr< MT, SO > serial(const DenseMatrix< MT, SO > &dm)
Forces the serial evaluation of the given dense matrix expression dm.
Definition: DMatSerialExpr.h:699
Header file for the Computation base class.
Header file for the RequiresEvaluation type trait.
Header file for the IsUniLower type trait.
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
bool isDefault(const DiagonalProxy< MT > &proxy)
Returns whether the represented element is in default state.
Definition: DiagonalProxy.h:861
LeftOperand lhs_
Left-hand side sparse matrix of the subtraction expression.
Definition: TSMatTSMatSubExpr.h:300
MT2::CompositeType CT2
Composite type of the right-hand side sparse matrix expression.
Definition: TSMatTSMatSubExpr.h:113
Header file for the SparseMatrix base class.
Constraint on the data type.
size_t nonZeros() const
Returns the number of non-zero elements in the sparse matrix.
Definition: TSMatTSMatSubExpr.h:238
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 IsStrictlyUpper type trait.
ResultType::ElementType ElementType
Resulting element type.
Definition: TSMatTSMatSubExpr.h:164
Header file for the IsSymmetric type trait.
Namespace of the Blaze C++ math library.
Definition: Blaze.h:57
#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:2511
size_t rows() const
Returns the current number of rows of the matrix.
Definition: TSMatTSMatSubExpr.h:218
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.
ResultType::OppositeType OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: TSMatTSMatSubExpr.h:162
Header file for the MatMatSubExpr base class.
Header file for the IsLower type trait.
SubExprTrait< RN1, RN2 >::Type ExprReturnType
Expression return type for the subscript operator.
Definition: TSMatTSMatSubExpr.h:126
Constraints on the storage order of matrix types.
size_t columns() const
Returns the current number of columns of the matrix.
Definition: TSMatTSMatSubExpr.h:228
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
RightOperand rhs_
Right-hand side sparse matrix of the subtraction expression.
Definition: TSMatTSMatSubExpr.h:301
Header file for the SelectType class template.
Header file for the RowExprTrait class template.
Header file for all forward declarations for expression class templates.
bool isAliased(const T *alias) const
Returns whether the expression is aliased with the given address alias.
Definition: TSMatTSMatSubExpr.h:293
Header file for the EnableIf class template.
Header file for the IsStrictlyLower type trait.
SelectType< IsExpression< MT1 >::value, const MT1, const MT1 & >::Type LeftOperand
Composite type of the left-hand side sparse matrix expression.
Definition: TSMatTSMatSubExpr.h:173
Header file for the serial shim.
MT2::ReturnType RN2
Return type of the right-hand side sparse matrix expression.
Definition: TSMatTSMatSubExpr.h:111
Compile time check for resizable data types.This type trait tests whether the given data type is a re...
Definition: IsResizable.h:75
size_t nonZeros(size_t i) const
Returns the number of non-zero elements in the specified row.
Definition: TSMatTSMatSubExpr.h:249
LeftOperand leftOperand() const
Returns the left-hand side transpose sparse matrix operand.
Definition: TSMatTSMatSubExpr.h:259
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:2506
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.
Expression object for transpose sparse matrix-transpose sparse matrix subtractions.The TSMatTSMatSubExpr class represents the compile time expression for subtractions between two column-major sparse matrices.
Definition: Forward.h:146
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
TSMatTSMatSubExpr(const MT1 &lhs, const MT2 &rhs)
Constructor for the TSMatTSMatSubExpr class.
Definition: TSMatTSMatSubExpr.h:190
Header file for the isDefault shim.
Constraint on the data type.
Header file for the RemoveReference type trait.
Substitution Failure Is Not An Error (SFINAE) class.The DisableIf class template is an auxiliary tool...
Definition: DisableIf.h:184
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: TSMatTSMatSubExpr.h:206
SubTrait< RT1, RT2 >::Type ResultType
Result type for expression template evaluations.
Definition: TSMatTSMatSubExpr.h:161
const DMatTransExpr< MT,!SO > trans(const DenseMatrix< MT, SO > &dm)
Calculation of the transpose of the given dense matrix.
Definition: DMatTransExpr.h:937
Header file for the IsComputation type trait class.
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:2502
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
bool canAlias(const T *alias) const
Returns whether the expression can alias with the given address alias.
Definition: TSMatTSMatSubExpr.h:281
#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:150
Header file for the IsUpper type trait.
MT1::ResultType RT1
Result type of the left-hand side sparse matrix expression.
Definition: TSMatTSMatSubExpr.h:108
Header file for the IsResizable type trait.
Header file for the SubExprTrait class template.
#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
ResultType::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: TSMatTSMatSubExpr.h:163
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