TSMatSMatSubExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_TSMATSMATSUBEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_TSMATSMATSUBEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <blaze/math/Aliases.h>
50 #include <blaze/math/Exception.h>
76 #include <blaze/util/Assert.h>
77 #include <blaze/util/DisableIf.h>
78 #include <blaze/util/EnableIf.h>
81 #include <blaze/util/mpl/And.h>
82 #include <blaze/util/mpl/If.h>
83 #include <blaze/util/mpl/Max.h>
84 #include <blaze/util/Types.h>
86 
87 
88 namespace blaze {
89 
90 //=================================================================================================
91 //
92 // CLASS TSMATSMATSUBEXPR
93 //
94 //=================================================================================================
95 
96 //*************************************************************************************************
103 template< typename MT1 // Type of the left-hand side sparse matrix
104  , typename MT2 > // Type of the right-hand side sparse matrix
105 class TSMatSMatSubExpr : public SparseMatrix< TSMatSMatSubExpr<MT1,MT2>, false >
106  , private MatMatSubExpr
107  , private Computation
108 {
109  private:
110  //**Type definitions****************************************************************************
117  //**********************************************************************************************
118 
119  //**Return type evaluation**********************************************************************
121 
126  enum : bool { returnExpr = !IsTemporary<RN1>::value && !IsTemporary<RN2>::value };
127 
130  //**********************************************************************************************
131 
132  //**Serial evaluation strategy******************************************************************
134 
140  template< typename T1, typename T2 >
141  struct UseSymmetricKernel {
143  enum : bool { value = IsSymmetric<T2>::value };
144  };
146  //**********************************************************************************************
147 
148  //**Parallel evaluation strategy****************************************************************
150 
155  template< typename MT >
156  struct UseSMPAssign {
157  enum : bool { value = MT::smpAssignable };
158  };
160  //**********************************************************************************************
161 
162  public:
163  //**Type definitions****************************************************************************
169 
172 
174  typedef const ResultType CompositeType;
175 
177  typedef If_< IsExpression<MT1>, const MT1, const MT1& > LeftOperand;
178 
180  typedef If_< IsExpression<MT2>, const MT2, const MT2& > RightOperand;
181  //**********************************************************************************************
182 
183  //**Compilation flags***************************************************************************
185  enum : bool { smpAssignable = false };
186  //**********************************************************************************************
187 
188  //**Constructor*********************************************************************************
194  explicit inline TSMatSMatSubExpr( const MT1& lhs, const MT2& rhs ) noexcept
195  : lhs_( lhs ) // Left-hand side sparse matrix of the subtraction expression
196  , rhs_( rhs ) // Right-hand side sparse matrix of the subtraction expression
197  {
198  BLAZE_INTERNAL_ASSERT( lhs.rows() == rhs.rows() , "Invalid number of rows" );
199  BLAZE_INTERNAL_ASSERT( lhs.columns() == rhs.columns(), "Invalid number of columns" );
200  }
201  //**********************************************************************************************
202 
203  //**Access operator*****************************************************************************
210  inline ReturnType operator()( size_t i, size_t j ) const {
211  BLAZE_INTERNAL_ASSERT( i < lhs_.rows() , "Invalid row access index" );
212  BLAZE_INTERNAL_ASSERT( j < lhs_.columns(), "Invalid column access index" );
213  return lhs_(i,j) - rhs_(i,j);
214  }
215  //**********************************************************************************************
216 
217  //**At function*********************************************************************************
225  inline ReturnType at( size_t i, size_t j ) const {
226  if( i >= lhs_.rows() ) {
227  BLAZE_THROW_OUT_OF_RANGE( "Invalid row access index" );
228  }
229  if( j >= lhs_.columns() ) {
230  BLAZE_THROW_OUT_OF_RANGE( "Invalid column access index" );
231  }
232  return (*this)(i,j);
233  }
234  //**********************************************************************************************
235 
236  //**Rows function*******************************************************************************
241  inline size_t rows() const noexcept {
242  return lhs_.rows();
243  }
244  //**********************************************************************************************
245 
246  //**Columns function****************************************************************************
251  inline size_t columns() const noexcept {
252  return lhs_.columns();
253  }
254  //**********************************************************************************************
255 
256  //**NonZeros function***************************************************************************
261  inline size_t nonZeros() const {
262  return lhs_.nonZeros() + rhs_.nonZeros();
263  }
264  //**********************************************************************************************
265 
266  //**NonZeros function***************************************************************************
272  inline size_t nonZeros( size_t i ) const {
273  return lhs_.nonZeros(i) + rhs_.nonZeros(i);
274  }
275  //**********************************************************************************************
276 
277  //**Left operand access*************************************************************************
282  inline LeftOperand leftOperand() const noexcept {
283  return lhs_;
284  }
285  //**********************************************************************************************
286 
287  //**Right operand access************************************************************************
292  inline RightOperand rightOperand() const noexcept {
293  return rhs_;
294  }
295  //**********************************************************************************************
296 
297  //**********************************************************************************************
303  template< typename T >
304  inline bool canAlias( const T* alias ) const noexcept {
305  return ( lhs_.canAlias( alias ) || rhs_.canAlias( alias ) );
306  }
307  //**********************************************************************************************
308 
309  //**********************************************************************************************
315  template< typename T >
316  inline bool isAliased( const T* alias ) const noexcept {
317  return ( lhs_.isAliased( alias ) || rhs_.isAliased( alias ) );
318  }
319  //**********************************************************************************************
320 
321  private:
322  //**Member variables****************************************************************************
323  LeftOperand lhs_;
324  RightOperand rhs_;
325  //**********************************************************************************************
326 
327  //**Assignment to dense matrices****************************************************************
339  template< typename MT // Type of the target dense matrix
340  , bool SO > // Storage order of the target dense matrix
341  friend inline void assign( DenseMatrix<MT,SO>& lhs, const TSMatSMatSubExpr& rhs )
342  {
344 
345  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
346  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
347 
348  typedef ConstIterator_< RemoveReference_<CT2> > RightIterator;
349 
350  assign( ~lhs, rhs.lhs_ );
351 
352  if( !IsResizable< ElementType_<MT> >::value ) {
353  subAssign( ~lhs, rhs.rhs_ );
354  }
355  else
356  {
357  CT2 B( serial( rhs.rhs_ ) ); // Evaluation of the right-hand side sparse matrix operand
358 
359  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
360  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
361  BLAZE_INTERNAL_ASSERT( B.rows() == (~lhs).rows() , "Invalid number of rows" );
362  BLAZE_INTERNAL_ASSERT( B.columns() == (~lhs).columns() , "Invalid number of columns" );
363 
364  for( size_t i=0UL; i<(~lhs).rows(); ++i ) {
365  const RightIterator end( B.end(i) );
366  for( RightIterator element=B.begin(i); element!=end; ++element ) {
367  if( isDefault( (~lhs)(i,element->index()) ) )
368  (~lhs)(i,element->index()) = -element->value();
369  else
370  (~lhs)(i,element->index()) -= element->value();
371  }
372  }
373  }
374  }
376  //**********************************************************************************************
377 
378  //**Assignment to row-major sparse matrices*****************************************************
391  template< typename MT > // Type of the target sparse matrix
393  assign( SparseMatrix<MT,false>& lhs, const TSMatSMatSubExpr& rhs )
394  {
396 
397  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
398  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
399 
400  typedef ConstIterator_< OppositeType_<RT1> > LeftIterator;
401  typedef ConstIterator_< RemoveReference_<CT2> > RightIterator;
402 
403  // Evaluation of the left-hand side sparse matrix operand
404  const OppositeType_<RT1> A( serial( rhs.lhs_ ) );
405 
406  // Evaluation of the right-hand side sparse matrix operand
407  CT2 B( serial( rhs.rhs_ ) );
408 
409  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.lhs_.rows() , "Invalid number of rows" );
410  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.lhs_.columns(), "Invalid number of columns" );
411  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
412  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
413  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
414  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).columns() , "Invalid number of columns" );
415 
416  // Final memory allocation (based on the evaluated operands)
417  (~lhs).reserve( A.nonZeros() + B.nonZeros() );
418 
419  // Performing the matrix subtraction
420  for( size_t i=0UL; i<(~lhs).rows(); ++i )
421  {
422  const LeftIterator lend( A.end(i) );
423  const RightIterator rend( B.end(i) );
424 
425  LeftIterator l( A.begin(i) );
426  RightIterator r( B.begin(i) );
427 
428  while( l != lend && r != rend )
429  {
430  if( l->index() < r->index() ) {
431  (~lhs).append( i, l->index(), l->value() );
432  ++l;
433  }
434  else if( l->index() > r->index() ) {
435  (~lhs).append( i, r->index(), -r->value() );
436  ++r;
437  }
438  else {
439  (~lhs).append( i, l->index(), l->value()-r->value() );
440  ++l;
441  ++r;
442  }
443  }
444 
445  while( l != lend ) {
446  (~lhs).append( i, l->index(), l->value() );
447  ++l;
448  }
449 
450  while( r != rend ) {
451  (~lhs).append( i, r->index(), -r->value() );
452  ++r;
453  }
454 
455  (~lhs).finalize( i );
456  }
457  }
459  //**********************************************************************************************
460 
461  //**Assignment to row-major sparse matrices*****************************************************
474  template< typename MT > // Type of the target sparse matrix
476  assign( SparseMatrix<MT,false>& lhs, const TSMatSMatSubExpr& rhs )
477  {
479 
480  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
481  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
482 
483  assign( ~lhs, trans( rhs.lhs_ ) - rhs.rhs_ );
484  }
486  //**********************************************************************************************
487 
488  //**Assignment to column-major sparse matrices**************************************************
501  template< typename MT > // Type of the target sparse matrix
503  assign( SparseMatrix<MT,true>& lhs, const TSMatSMatSubExpr& rhs )
504  {
506 
508 
509  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
510  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
511 
512  typedef ConstIterator_< RemoveReference_<CT1> > LeftIterator;
513  typedef ConstIterator_< OppositeType_<RT2> > RightIterator;
514 
515  // Evaluation of the left-hand side sparse matrix operand
516  CT1 A( serial( rhs.lhs_ ) );
517 
518  // Evaluation of the right-hand side sparse matrix operand
519  const OppositeType_<RT2> B( serial( rhs.rhs_ ) );
520 
521  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.lhs_.rows() , "Invalid number of rows" );
522  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.lhs_.columns(), "Invalid number of columns" );
523  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
524  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
525  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
526  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).columns() , "Invalid number of columns" );
527 
528  // Final memory allocation (based on the evaluated operands)
529  (~lhs).reserve( A.nonZeros() + B.nonZeros() );
530 
531  // Performing the matrix subtraction
532  for( size_t j=0UL; j<(~lhs).columns(); ++j )
533  {
534  const LeftIterator lend( A.end(j) );
535  const RightIterator rend( B.end(j) );
536 
537  LeftIterator l( A.begin(j) );
538  RightIterator r( B.begin(j) );
539 
540  while( l != lend && r != rend )
541  {
542  if( l->index() < r->index() ) {
543  (~lhs).append( l->index(), j, l->value() );
544  ++l;
545  }
546  else if( l->index() > r->index() ) {
547  (~lhs).append( r->index(), j, -r->value() );
548  ++r;
549  }
550  else {
551  (~lhs).append( l->index(), j, l->value()-r->value() );
552  ++l;
553  ++r;
554  }
555  }
556 
557  while( l != lend ) {
558  (~lhs).append( l->index(), j, l->value() );
559  ++l;
560  }
561 
562  while( r != rend ) {
563  (~lhs).append( r->index(), j, -r->value() );
564  ++r;
565  }
566 
567  (~lhs).finalize( j );
568  }
569  }
571  //**********************************************************************************************
572 
573  //**Assignment to column-major sparse matrices**************************************************
586  template< typename MT > // Type of the target sparse matrix
588  assign( SparseMatrix<MT,true>& lhs, const TSMatSMatSubExpr& rhs )
589  {
591 
593 
594  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
595  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
596 
597  assign( ~lhs, rhs.lhs_ - trans( rhs.rhs_ ) );
598  }
600  //**********************************************************************************************
601 
602  //**Addition assignment to dense matrices*******************************************************
615  template< typename MT // Type of the target dense matrix
616  , bool SO > // Storage order of the target dense matrix
617  friend inline void addAssign( DenseMatrix<MT,SO>& lhs, const TSMatSMatSubExpr& rhs )
618  {
620 
621  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
622  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
623 
624  addAssign( ~lhs, rhs.lhs_ );
625  subAssign( ~lhs, rhs.rhs_ );
626  }
628  //**********************************************************************************************
629 
630  //**Addition assignment to sparse matrices******************************************************
631  // No special implementation for the addition assignment to sparse matrices.
632  //**********************************************************************************************
633 
634  //**Subtraction assignment to dense matrices****************************************************
647  template< typename MT // Type of the target dense matrix
648  , bool SO > // Storage order of the target dense matrix
649  friend inline void subAssign( DenseMatrix<MT,SO>& lhs, const TSMatSMatSubExpr& rhs )
650  {
652 
653  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
654  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
655 
656  subAssign( ~lhs, rhs.lhs_ );
657  addAssign( ~lhs, rhs.rhs_ );
658  }
660  //**********************************************************************************************
661 
662  //**Subtraction assignment to sparse matrices***************************************************
663  // No special implementation for the subtraction assignment to sparse matrices.
664  //**********************************************************************************************
665 
666  //**Multiplication assignment to dense matrices*************************************************
667  // No special implementation for the multiplication assignment to dense matrices.
668  //**********************************************************************************************
669 
670  //**Multiplication assignment to sparse matrices************************************************
671  // No special implementation for the multiplication assignment to sparse matrices.
672  //**********************************************************************************************
673 
674  //**SMP assignment to dense matrices************************************************************
675  // No special implementation for the SMP assignment to dense matrices.
676  //**********************************************************************************************
677 
678  //**SMP assignment to sparse matrices***********************************************************
679  // No special implementation for the SMP assignment to sparse matrices.
680  //**********************************************************************************************
681 
682  //**SMP addition assignment to dense matrices*******************************************************
697  template< typename MT // Type of the target dense matrix
698  , bool SO > // Storage order of the target dense matrix
699  friend inline EnableIf_< UseSMPAssign<MT> >
701  {
703 
704  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
705  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
706 
707  smpAddAssign( ~lhs, rhs.lhs_ );
708  smpSubAssign( ~lhs, rhs.rhs_ );
709  }
711  //**********************************************************************************************
712 
713  //**SMP addition assignment to sparse matrices**************************************************
714  // No special implementation for the SMP addition assignment to sparse matrices.
715  //**********************************************************************************************
716 
717  //**SMP subtraction assignment to dense matrices************************************************
732  template< typename MT // Type of the target dense matrix
733  , bool SO > // Storage order of the target dense matrix
734  friend inline EnableIf_< UseSMPAssign<MT> >
736  {
738 
739  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
740  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
741 
742  smpSubAssign( ~lhs, rhs.lhs_ );
743  smpAddAssign( ~lhs, rhs.rhs_ );
744  }
746  //**********************************************************************************************
747 
748  //**SMP subtraction assignment to sparse matrices***********************************************
749  // No special implementation for the SMP subtraction assignment to sparse matrices.
750  //**********************************************************************************************
751 
752  //**SMP multiplication assignment to dense matrices*********************************************
753  // No special implementation for the SMP multiplication assignment to dense matrices.
754  //**********************************************************************************************
755 
756  //**SMP multiplication assignment to sparse matrices********************************************
757  // No special implementation for the SMP multiplication assignment to sparse matrices.
758  //**********************************************************************************************
759 
760  //**Compile time checks*************************************************************************
768  //**********************************************************************************************
769 };
770 //*************************************************************************************************
771 
772 
773 
774 
775 //=================================================================================================
776 //
777 // GLOBAL BINARY ARITHMETIC OPERATORS
778 //
779 //=================================================================================================
780 
781 //*************************************************************************************************
810 template< typename T1 // Type of the left-hand side sparse matrix
811  , typename T2 > // Type of the right-hand side sparse matrix
812 inline const TSMatSMatSubExpr<T1,T2>
814 {
816 
817  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() ) {
818  BLAZE_THROW_INVALID_ARGUMENT( "Matrix sizes do not match" );
819  }
820 
821  return TSMatSMatSubExpr<T1,T2>( ~lhs, ~rhs );
822 }
823 //*************************************************************************************************
824 
825 
826 
827 
828 //=================================================================================================
829 //
830 // ROWS SPECIALIZATIONS
831 //
832 //=================================================================================================
833 
834 //*************************************************************************************************
836 template< typename MT1, typename MT2 >
837 struct Rows< TSMatSMatSubExpr<MT1,MT2> >
838  : public Max< Rows<MT1>, Rows<MT2> >
839 {};
841 //*************************************************************************************************
842 
843 
844 
845 
846 //=================================================================================================
847 //
848 // COLUMNS SPECIALIZATIONS
849 //
850 //=================================================================================================
851 
852 //*************************************************************************************************
854 template< typename MT1, typename MT2 >
855 struct Columns< TSMatSMatSubExpr<MT1,MT2> >
856  : public Max< Columns<MT1>, Columns<MT2> >
857 {};
859 //*************************************************************************************************
860 
861 
862 
863 
864 //=================================================================================================
865 //
866 // ISSYMMETRIC SPECIALIZATIONS
867 //
868 //=================================================================================================
869 
870 //*************************************************************************************************
872 template< typename MT1, typename MT2 >
873 struct IsSymmetric< TSMatSMatSubExpr<MT1,MT2> >
874  : public BoolConstant< IsSymmetric<MT1>::value && IsSymmetric<MT2>::value >
875 {};
877 //*************************************************************************************************
878 
879 
880 
881 
882 //=================================================================================================
883 //
884 // ISHERMITIAN SPECIALIZATIONS
885 //
886 //=================================================================================================
887 
888 //*************************************************************************************************
890 template< typename MT1, typename MT2 >
891 struct IsHermitian< TSMatSMatSubExpr<MT1,MT2> >
892  : public BoolConstant< IsHermitian<MT1>::value && IsHermitian<MT2>::value >
893 {};
895 //*************************************************************************************************
896 
897 
898 
899 
900 //=================================================================================================
901 //
902 // ISLOWER SPECIALIZATIONS
903 //
904 //=================================================================================================
905 
906 //*************************************************************************************************
908 template< typename MT1, typename MT2 >
909 struct IsLower< TSMatSMatSubExpr<MT1,MT2> >
910  : public BoolConstant< And< IsLower<MT1>, IsLower<MT2> >::value >
911 {};
913 //*************************************************************************************************
914 
915 
916 
917 
918 //=================================================================================================
919 //
920 // ISUNILOWER SPECIALIZATIONS
921 //
922 //=================================================================================================
923 
924 //*************************************************************************************************
926 template< typename MT1, typename MT2 >
927 struct IsUniLower< TSMatSMatSubExpr<MT1,MT2> >
928  : public BoolConstant< And< IsUniLower<MT1>, IsStrictlyLower<MT2> >::value >
929 {};
931 //*************************************************************************************************
932 
933 
934 
935 
936 //=================================================================================================
937 //
938 // ISSTRICTLYLOWER SPECIALIZATIONS
939 //
940 //=================================================================================================
941 
942 //*************************************************************************************************
944 template< typename MT1, typename MT2 >
945 struct IsStrictlyLower< TSMatSMatSubExpr<MT1,MT2> >
946  : public BoolConstant< And< IsStrictlyLower<MT1>, IsStrictlyLower<MT2> >::value >
947 {};
949 //*************************************************************************************************
950 
951 
952 
953 
954 //=================================================================================================
955 //
956 // ISUPPER SPECIALIZATIONS
957 //
958 //=================================================================================================
959 
960 //*************************************************************************************************
962 template< typename MT1, typename MT2 >
963 struct IsUpper< TSMatSMatSubExpr<MT1,MT2> >
964  : public BoolConstant< And< IsUpper<MT1>, IsUpper<MT2> >::value >
965 {};
967 //*************************************************************************************************
968 
969 
970 
971 
972 //=================================================================================================
973 //
974 // ISUNIUPPER SPECIALIZATIONS
975 //
976 //=================================================================================================
977 
978 //*************************************************************************************************
980 template< typename MT1, typename MT2 >
981 struct IsUniUpper< TSMatSMatSubExpr<MT1,MT2> >
982  : public BoolConstant< And< IsUniUpper<MT1>, IsStrictlyUpper<MT2> >::value >
983 {};
985 //*************************************************************************************************
986 
987 
988 
989 
990 //=================================================================================================
991 //
992 // ISSTRICTLYUPPER SPECIALIZATIONS
993 //
994 //=================================================================================================
995 
996 //*************************************************************************************************
998 template< typename MT1, typename MT2 >
999 struct IsStrictlyUpper< TSMatSMatSubExpr<MT1,MT2> >
1000  : public BoolConstant< And< IsStrictlyUpper<MT1>, IsStrictlyUpper<MT2> >::value >
1001 {};
1003 //*************************************************************************************************
1004 
1005 
1006 
1007 
1008 //=================================================================================================
1009 //
1010 // EXPRESSION TRAIT SPECIALIZATIONS
1011 //
1012 //=================================================================================================
1013 
1014 //*************************************************************************************************
1016 template< typename MT1, typename MT2, bool AF >
1017 struct SubmatrixExprTrait< TSMatSMatSubExpr<MT1,MT2>, AF >
1018 {
1019  public:
1020  //**********************************************************************************************
1023  //**********************************************************************************************
1024 };
1026 //*************************************************************************************************
1027 
1028 
1029 //*************************************************************************************************
1031 template< typename MT1, typename MT2 >
1032 struct RowExprTrait< TSMatSMatSubExpr<MT1,MT2> >
1033 {
1034  public:
1035  //**********************************************************************************************
1038  //**********************************************************************************************
1039 };
1041 //*************************************************************************************************
1042 
1043 
1044 //*************************************************************************************************
1046 template< typename MT1, typename MT2 >
1047 struct ColumnExprTrait< TSMatSMatSubExpr<MT1,MT2> >
1048 {
1049  public:
1050  //**********************************************************************************************
1053  //**********************************************************************************************
1054 };
1056 //*************************************************************************************************
1057 
1058 } // namespace blaze
1059 
1060 #endif
typename SubmatrixExprTrait< MT, AF >::Type SubmatrixExprTrait_
Auxiliary alias declaration for the SubmatrixExprTrait type trait.The SubmatrixExprTrait_ alias decla...
Definition: SubmatrixExprTrait.h:134
Constraint on the data type.
#define BLAZE_THROW_INVALID_ARGUMENT(MESSAGE)
Macro for the emission of a std::invalid_argument exception.This macro encapsulates the default way o...
Definition: Exception.h:235
size_t rows() const noexcept
Returns the current number of rows of the matrix.
Definition: TSMatSMatSubExpr.h:241
Header file for auxiliary alias declarations.
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:70
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.
CompositeType_< MT1 > CT1
Composite type of the left-hand side sparse matrix expression.
Definition: TSMatSMatSubExpr.h:115
SubExprTrait_< RN1, RN2 > ExprReturnType
Expression return type for the subscript operator.
Definition: TSMatSMatSubExpr.h:129
RightOperand rightOperand() const noexcept
Returns the right-hand side sparse matrix operand.
Definition: TSMatSMatSubExpr.h:292
size_t columns() const noexcept
Returns the current number of columns of the matrix.
Definition: TSMatSMatSubExpr.h:251
bool isAliased(const T *alias) const noexcept
Returns whether the expression is aliased with the given address alias.
Definition: TSMatSMatSubExpr.h:316
EnableIf_< IsDenseMatrix< MT1 > > 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
Header file for the serial shim.
Generic wrapper for a compile time constant integral value.The IntegralConstant class template repres...
Definition: IntegralConstant.h:71
Header file for the ColumnExprTrait class template.
typename DisableIf< Condition, T >::Type DisableIf_
Auxiliary type for the DisableIf class template.The DisableIf_ alias declaration provides a convenien...
Definition: DisableIf.h:223
LeftOperand leftOperand() const noexcept
Returns the left-hand side transpose sparse matrix operand.
Definition: TSMatSMatSubExpr.h:282
Header file for the And class template.
Compile time check for lower triangular matrices.This type trait tests whether or not the given templ...
Definition: IsLower.h:88
const DMatSerialExpr< MT, SO > serial(const DenseMatrix< MT, SO > &dm)
Forces the serial evaluation of the given dense matrix expression dm.
Definition: DMatSerialExpr.h:721
Header file for the Computation base class.
Compile time check for upper triangular matrices.This type trait tests whether or not the given templ...
Definition: IsUpper.h:88
const DenseIterator< Type, AF > operator-(const DenseIterator< Type, AF > &it, ptrdiff_t inc) noexcept
Subtraction between a DenseIterator and an integral value.
Definition: DenseIterator.h:731
Constraints on the storage order of matrix types.
ResultType_< MT1 > RT1
Result type of the left-hand side sparse matrix expression.
Definition: TSMatSMatSubExpr.h:111
Header file for the IsUniLower type trait.
typename T::ResultType ResultType_
Alias declaration for nested ResultType type definitions.The ResultType_ alias declaration provides a...
Definition: Aliases.h:323
EnableIf_< IsDenseMatrix< MT1 > > 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
Base class for dense matrices.The DenseMatrix class is a base class for all dense matrix classes...
Definition: DenseMatrix.h:71
Base class for sparse matrices.The SparseMatrix class is a base class for all sparse matrix classes...
Definition: Forward.h:119
typename IfTrue< Condition, T1, T2 >::Type IfTrue_
Auxiliary alias declaration for the IfTrue class template.The IfTrue_ alias declaration provides a co...
Definition: If.h:109
typename T::ReturnType ReturnType_
Alias declaration for nested ReturnType type definitions.The ReturnType_ alias declaration provides a...
Definition: Aliases.h:343
Header file for the SparseMatrix base class.
typename SubExprTrait< T1, T2 >::Type SubExprTrait_
Auxiliary alias declaration for the SubExprTrait class template.The SubExprTrait_ alias declaration p...
Definition: SubExprTrait.h:220
Constraint on the data type.
ResultType_< MT2 > RT2
Result type of the right-hand side sparse matrix expression.
Definition: TSMatSMatSubExpr.h:112
typename T::CompositeType CompositeType_
Alias declaration for nested CompositeType type definitions.The CompositeType_ alias declaration prov...
Definition: Aliases.h:83
Compile time check for upper unitriangular matrices.This type trait tests whether or not the given te...
Definition: IsUniUpper.h:86
Header file for the DisableIf class template.
typename RowExprTrait< MT >::Type RowExprTrait_
Auxiliary alias declaration for the RowExprTrait type trait.The RowExprTrait_ alias declaration provi...
Definition: RowExprTrait.h:134
Header file for the IsTemporary type trait class.
Header file for the IsStrictlyUpper type trait.
Header file for the IsSymmetric type trait.
Namespace of the Blaze C++ math library.
Definition: Blaze.h:57
Header file for the If class template.
#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: ColumnMajorMatrix.h:61
TSMatSMatSubExpr(const MT1 &lhs, const MT2 &rhs) noexcept
Constructor for the TSMatSMatSubExpr class.
Definition: TSMatSMatSubExpr.h:194
CompositeType_< MT2 > CT2
Composite type of the right-hand side sparse matrix expression.
Definition: TSMatSMatSubExpr.h:116
#define BLAZE_THROW_OUT_OF_RANGE(MESSAGE)
Macro for the emission of a std::out_of_range exception.This macro encapsulates the default way of Bl...
Definition: Exception.h:331
Header file for the Columns type trait.
OppositeType_< ResultType > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: TSMatSMatSubExpr.h:166
typename T::ElementType ElementType_
Alias declaration for nested ElementType type definitions.The ElementType_ alias declaration provides...
Definition: Aliases.h:163
Header file for the MatMatSubExpr base class.
Evaluation of the expression type type of a submatrix operation.Via this type trait it is possible to...
Definition: SubmatrixExprTrait.h:80
Header file for the IsLower type trait.
typename ColumnExprTrait< MT >::Type ColumnExprTrait_
Auxiliary alias declaration for the ColumnExprTrait type trait.The ColumnExprTrait_ alias declaration...
Definition: ColumnExprTrait.h:133
bool canAlias(const T *alias) const noexcept
Returns whether the expression can alias with the given address alias.
Definition: TSMatSMatSubExpr.h:304
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
SubTrait_< RT1, RT2 > ResultType
Result type for expression template evaluations.
Definition: TSMatSMatSubExpr.h:165
Header file for the exception macros of the math module.
Compile time check for strictly upper triangular matrices.This type trait tests whether or not the gi...
Definition: IsStrictlyUpper.h:86
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: TSMatSMatSubExpr.h:210
ReturnType_< MT1 > RN1
Return type of the left-hand side sparse matrix expression.
Definition: TSMatSMatSubExpr.h:113
Evaluation of the expression type type of a row operation.Via this type trait it is possible to evalu...
Definition: RowExprTrait.h:79
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:260
Header file for the RowExprTrait class template.
Header file for all forward declarations for expression class templates.
const ResultType CompositeType
Data type for composite expression templates.
Definition: TSMatSMatSubExpr.h:174
If_< IsExpression< MT2 >, const MT2, const MT2 &> RightOperand
Composite type of the right-hand side sparse matrix expression.
Definition: TSMatSMatSubExpr.h:180
Header file for the EnableIf class template.
Header file for the IsStrictlyLower type trait.
#define BLAZE_CONSTRAINT_MATRICES_MUST_HAVE_DIFFERENT_STORAGE_ORDER(T1, T2)
Constraint on the data type.In case either of the two given data types T1 or T2 is not a matrix type ...
Definition: StorageOrder.h:106
Compile time check for lower unitriangular matrices.This type trait tests whether or not the given te...
Definition: IsUniLower.h:86
size_t nonZeros(size_t i) const
Returns the number of non-zero elements in the specified row.
Definition: TSMatSMatSubExpr.h:272
Compile time check for resizable data types.This type trait tests whether the given data type is a re...
Definition: IsResizable.h:75
#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:79
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: RowMajorMatrix.h:61
If_< IsExpression< MT1 >, const MT1, const MT1 &> LeftOperand
Composite type of the left-hand side sparse matrix expression.
Definition: TSMatSMatSubExpr.h:177
Header file for run time assertion macros.
Compile time value evaluation.The Max class template selects the larger of the two given template arg...
Definition: Max.h:72
typename If< T1, T2, T3 >::Type If_
Auxiliary alias declaration for the If class template.The If_ alias declaration provides a convenient...
Definition: If.h:160
#define BLAZE_FUNCTION_TRACE
Function trace macro.This macro can be used to reliably trace function calls. In case function tracin...
Definition: FunctionTrace.h:93
ReturnType_< MT2 > RN2
Return type of the right-hand side sparse matrix expression.
Definition: TSMatSMatSubExpr.h:114
Header file for the isDefault shim.
Compile time check for Hermitian matrices.This type trait tests whether or not the given template par...
Definition: IsHermitian.h:85
TransposeType_< ResultType > TransposeType
Transpose type for expression template evaluations.
Definition: TSMatSMatSubExpr.h:167
Constraint on the data type.
Constraints on the storage order of matrix types.
LeftOperand lhs_
Left-hand side sparse matrix of the subtraction expression.
Definition: TSMatSMatSubExpr.h:323
Header file for the RemoveReference type trait.
typename EnableIf< Condition, T >::Type EnableIf_
Auxiliary alias declaration for the EnableIf class template.The EnableIf_ alias declaration provides ...
Definition: EnableIf.h:223
typename T::OppositeType OppositeType_
Alias declaration for nested OppositeType type definitions.The OppositeType_ alias declaration provid...
Definition: Aliases.h:243
Compile time check for strictly lower triangular matrices.This type trait tests whether or not the gi...
Definition: IsStrictlyLower.h:86
typename T::ConstIterator ConstIterator_
Alias declaration for nested ConstIterator type definitions.The ConstIterator_ alias declaration prov...
Definition: Aliases.h:103
TSMatSMatSubExpr< MT1, MT2 > This
Type of this TSMatSMatSubExpr instance.
Definition: TSMatSMatSubExpr.h:164
const DMatTransExpr< MT,!SO > trans(const DenseMatrix< MT, SO > &dm)
Calculation of the transpose of the given dense matrix.
Definition: DMatTransExpr.h:733
Header file for the IsComputation type trait class.
ReturnType at(size_t i, size_t j) const
Checked access to the matrix elements.
Definition: TSMatSMatSubExpr.h:225
typename SubTrait< T1, T2 >::Type SubTrait_
Auxiliary alias declaration for the SubTrait class template.The SubTrait_ alias declaration provides ...
Definition: SubTrait.h:245
Header file for the IntegralConstant class template.
Compile time evaluation of the number of columns of a matrix.The Columns type trait evaluates the num...
Definition: Columns.h:76
Compile time evaluation of the number of rows of a matrix.The Rows type trait evaluates the number of...
Definition: Rows.h:76
size_t nonZeros() const
Returns the number of non-zero elements in the sparse matrix.
Definition: TSMatSMatSubExpr.h:261
#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:109
bool isDefault(const DiagonalProxy< MT > &proxy)
Returns whether the represented element is in default state.
Definition: DiagonalProxy.h:573
ElementType_< ResultType > ElementType
Resulting element type.
Definition: TSMatSMatSubExpr.h:168
typename T::TransposeType TransposeType_
Alias declaration for nested TransposeType type definitions.The TransposeType_ alias declaration prov...
Definition: Aliases.h:403
Header file for the IsUpper type trait.
Expression object for transpose sparse matrix-sparse matrix subtractions.The TSMatSMatSubExpr class r...
Definition: Forward.h:154
const IfTrue_< returnExpr, ExprReturnType, ElementType > ReturnType
Return type for expression template evaluations.
Definition: TSMatSMatSubExpr.h:171
Header file for the IsHermitian type trait.
Header file for the IsResizable type trait.
Header file for the SubExprTrait class template.
Evaluation of the expression type type of a column operation.Via this type trait it is possible to ev...
Definition: ColumnExprTrait.h:78
#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
RightOperand rhs_
Right-hand side sparse matrix of the subtraction expression.
Definition: TSMatSMatSubExpr.h:324
#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:61
Header file for the IsExpression type trait class.
Header file for the function trace functionality.