SMatTSMatMultExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_SMATTSMATMULTEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_SMATTSMATMULTEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <blaze/math/Aliases.h>
49 #include <blaze/math/Exception.h>
54 #include <blaze/math/Functions.h>
89 #include <blaze/util/Assert.h>
90 #include <blaze/util/DisableIf.h>
91 #include <blaze/util/EnableIf.h>
93 #include <blaze/util/InvalidType.h>
95 #include <blaze/util/mpl/And.h>
96 #include <blaze/util/mpl/If.h>
97 #include <blaze/util/mpl/Or.h>
98 #include <blaze/util/Types.h>
100 #include <blaze/util/Unused.h>
101 
102 
103 namespace blaze {
104 
105 //=================================================================================================
106 //
107 // CLASS SMATTSMATMULTEXPR
108 //
109 //=================================================================================================
110 
111 //*************************************************************************************************
118 template< typename MT1 // Type of the left-hand side sparse matrix
119  , typename MT2 > // Type of the right-hand side sparse matrix
120 class SMatTSMatMultExpr : public SparseMatrix< SMatTSMatMultExpr<MT1,MT2>, false >
121  , private MatMatMultExpr
122  , private Computation
123 {
124  private:
125  //**Type definitions****************************************************************************
130  //**********************************************************************************************
131 
132  //**********************************************************************************************
134 
141  template< typename T1, typename T2, typename T3 >
142  struct CanExploitSymmetry {
143  enum : bool { value = ( IsRowMajorMatrix<T1>::value && IsSymmetric<T3>::value ) ||
145  };
147  //**********************************************************************************************
148 
149  public:
150  //**Type definitions****************************************************************************
156  typedef const ElementType ReturnType;
157  typedef const ResultType CompositeType;
158 
160  typedef If_< IsExpression<MT1>, const MT1, const MT1& > LeftOperand;
161 
163  typedef If_< IsExpression<MT2>, const MT2, const MT2& > RightOperand;
164  //**********************************************************************************************
165 
166  //**Compilation flags***************************************************************************
168  enum : bool { smpAssignable = false };
169  //**********************************************************************************************
170 
171  //**Constructor*********************************************************************************
177  explicit inline SMatTSMatMultExpr( const MT1& lhs, const MT2& rhs ) noexcept
178  : lhs_( lhs ) // Left-hand side sparse matrix of the multiplication expression
179  , rhs_( rhs ) // Right-hand side sparse matrix of the multiplication expression
180  {
181  BLAZE_INTERNAL_ASSERT( lhs.columns() == rhs.rows(), "Invalid matrix sizes" );
182  }
183  //**********************************************************************************************
184 
185  //**Access operator*****************************************************************************
192  inline ReturnType operator()( size_t i, size_t j ) const {
193  BLAZE_INTERNAL_ASSERT( i < lhs_.rows() , "Invalid row access index" );
194  BLAZE_INTERNAL_ASSERT( j < rhs_.columns(), "Invalid column access index" );
195 
196  return row( lhs_, i ) * column( rhs_, j );
197  }
198  //**********************************************************************************************
199 
200  //**At function*********************************************************************************
208  inline ReturnType at( size_t i, size_t j ) const {
209  if( i >= lhs_.rows() ) {
210  BLAZE_THROW_OUT_OF_RANGE( "Invalid row access index" );
211  }
212  if( j >= rhs_.columns() ) {
213  BLAZE_THROW_OUT_OF_RANGE( "Invalid column access index" );
214  }
215  return (*this)(i,j);
216  }
217  //**********************************************************************************************
218 
219  //**Rows function*******************************************************************************
224  inline size_t rows() const noexcept {
225  return lhs_.rows();
226  }
227  //**********************************************************************************************
228 
229  //**Columns function****************************************************************************
234  inline size_t columns() const noexcept {
235  return rhs_.columns();
236  }
237  //**********************************************************************************************
238 
239  //**NonZeros function***************************************************************************
244  inline constexpr size_t nonZeros() const noexcept {
245  return 0UL;
246  }
247  //**********************************************************************************************
248 
249  //**NonZeros function***************************************************************************
255  inline size_t nonZeros( size_t i ) const noexcept {
256  UNUSED_PARAMETER( i );
257  return 0UL;
258  }
259  //**********************************************************************************************
260 
261  //**Left operand access*************************************************************************
266  inline LeftOperand leftOperand() const noexcept {
267  return lhs_;
268  }
269  //**********************************************************************************************
270 
271  //**Right operand access************************************************************************
276  inline RightOperand rightOperand() const noexcept {
277  return rhs_;
278  }
279  //**********************************************************************************************
280 
281  //**********************************************************************************************
287  template< typename T >
288  inline bool canAlias( const T* alias ) const noexcept {
289  return ( lhs_.isAliased( alias ) || rhs_.isAliased( alias ) );
290  }
291  //**********************************************************************************************
292 
293  //**********************************************************************************************
299  template< typename T >
300  inline bool isAliased( const T* alias ) const noexcept {
301  return ( lhs_.isAliased( alias ) || rhs_.isAliased( alias ) );
302  }
303  //**********************************************************************************************
304 
305  //**********************************************************************************************
310  inline bool canSMPAssign() const noexcept {
311  return ( rows() * columns() >= SMP_SMATTSMATMULT_THRESHOLD );
312  }
313  //**********************************************************************************************
314 
315  private:
316  //**Member variables****************************************************************************
317  LeftOperand lhs_;
318  RightOperand rhs_;
319  //**********************************************************************************************
320 
321  //**Assignment to row-major matrices************************************************************
334  template< typename MT > // Type of the target matrix
336  assign( Matrix<MT,false>& lhs, const SMatTSMatMultExpr& rhs )
337  {
339 
340  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
341  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
342 
344 
345  const OppositeType_<MT2> tmp( serial( rhs.rhs_ ) );
346  assign( ~lhs, rhs.lhs_ * tmp );
347  }
349  //**********************************************************************************************
350 
351  //**Restructuring assignment to row-major matrices**********************************************
366  template< typename MT > // Type of the target matrix
368  assign( Matrix<MT,false>& lhs, const SMatTSMatMultExpr& rhs )
369  {
371 
372  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
373  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
374 
375  assign( ~lhs, rhs.lhs_ * trans( rhs.rhs_ ) );
376  }
378  //**********************************************************************************************
379 
380  //**Assignment to column-major matrices*********************************************************
393  template< typename MT > // Type of the target matrix
394  friend inline DisableIf_< CanExploitSymmetry<MT,MT1,MT2> >
395  assign( Matrix<MT,true>& lhs, const SMatTSMatMultExpr& rhs )
396  {
398 
400 
401  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
402  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
403 
405 
406  const OppositeType_<MT1> tmp( serial( rhs.lhs_ ) );
407  assign( ~lhs, tmp * rhs.rhs_ );
408  }
410  //**********************************************************************************************
411 
412  //**Restructuring assignment to column-major matrices*******************************************
427  template< typename MT > // Type of the target matrix
428  friend inline EnableIf_< CanExploitSymmetry<MT,MT1,MT2> >
429  assign( Matrix<MT,true>& lhs, const SMatTSMatMultExpr& rhs )
430  {
432 
434 
435  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
436  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
437 
438  assign( ~lhs, trans( rhs.lhs_ ) * rhs.rhs_ );
439  }
441  //**********************************************************************************************
442 
443  //**Addition assignment to row-major dense matrices*********************************************
456  template< typename MT > // Type of the target dense matrix
457  friend inline DisableIf_< CanExploitSymmetry<MT,MT1,MT2> >
458  addAssign( DenseMatrix<MT,false>& lhs, const SMatTSMatMultExpr& rhs )
459  {
461 
462  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
463  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
464 
466 
467  const OppositeType_<MT2> tmp( serial( rhs.rhs_ ) );
468  addAssign( ~lhs, rhs.lhs_ * tmp );
469  }
471  //**********************************************************************************************
472 
473  //**Restructuring addition assignment to row-major matrices*************************************
488  template< typename MT > // Type of the target matrix
489  friend inline EnableIf_< CanExploitSymmetry<MT,MT1,MT2> >
490  addAssign( Matrix<MT,false>& lhs, const SMatTSMatMultExpr& rhs )
491  {
493 
494  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
495  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
496 
497  addAssign( ~lhs, rhs.lhs_ * trans( rhs.rhs_ ) );
498  }
500  //**********************************************************************************************
501 
502  //**Addition assignment to column-major dense matrices******************************************
515  template< typename MT > // Type of the target dense matrix
516  friend inline DisableIf_< CanExploitSymmetry<MT,MT1,MT2> >
517  addAssign( DenseMatrix<MT,true>& lhs, const SMatTSMatMultExpr& rhs )
518  {
520 
522 
523  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
524  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
525 
527 
528  const OppositeType_<MT1> tmp( serial( rhs.lhs_ ) );
529  addAssign( ~lhs, tmp * rhs.rhs_ );
530  }
532  //**********************************************************************************************
533 
534  //**Restructuring addition assignment to column-major matrices**********************************
549  template< typename MT > // Type of the target matrix
550  friend inline EnableIf_< CanExploitSymmetry<MT,MT1,MT2> >
551  addAssign( Matrix<MT,true>& lhs, const SMatTSMatMultExpr& rhs )
552  {
554 
556 
557  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
558  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
559 
560  addAssign( ~lhs, trans( rhs.lhs_ ) * rhs.rhs_ );
561  }
563  //**********************************************************************************************
564 
565  //**Addition assignment to sparse matrices******************************************************
566  // No special implementation for the addition assignment to sparse matrices.
567  //**********************************************************************************************
568 
569  //**Subtraction assignment to row-major dense matrices******************************************
582  template< typename MT > // Type of the target dense matrix
583  friend inline DisableIf_< CanExploitSymmetry<MT,MT1,MT2> >
584  subAssign( DenseMatrix<MT,false>& lhs, const SMatTSMatMultExpr& rhs )
585  {
587 
588  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
589  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
590 
592 
593  const OppositeType_<MT2> tmp( serial( rhs.rhs_ ) );
594  subAssign( ~lhs, rhs.lhs_ * tmp );
595  }
597  //**********************************************************************************************
598 
599  //**Restructuring subtraction assignment to row-major matrices**********************************
614  template< typename MT > // Type of the target matrix
615  friend inline EnableIf_< CanExploitSymmetry<MT,MT1,MT2> >
616  subAssign( Matrix<MT,false>& lhs, const SMatTSMatMultExpr& rhs )
617  {
619 
620  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
621  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
622 
623  subAssign( ~lhs, rhs.lhs_ * trans( rhs.rhs_ ) );
624  }
626  //**********************************************************************************************
627 
628  //**Subtraction assignment to column-major dense matrices***************************************
641  template< typename MT > // Type of the target dense matrix
642  friend inline DisableIf_< CanExploitSymmetry<MT,MT1,MT2> >
643  subAssign( DenseMatrix<MT,true>& lhs, const SMatTSMatMultExpr& rhs )
644  {
646 
648 
649  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
650  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
651 
653 
654  const OppositeType_<MT1> tmp( serial( rhs.lhs_ ) );
655  subAssign( ~lhs, tmp * rhs.rhs_ );
656  }
658  //**********************************************************************************************
659 
660  //**Restructuring subtraction assignment to column-major matrices*******************************
675  template< typename MT > // Type of the target matrix
676  friend inline EnableIf_< CanExploitSymmetry<MT,MT1,MT2> >
677  subAssign( Matrix<MT,true>& lhs, const SMatTSMatMultExpr& rhs )
678  {
680 
682 
683  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
684  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
685 
686  subAssign( ~lhs, trans( rhs.lhs_ ) * rhs.rhs_ );
687  }
689  //**********************************************************************************************
690 
691  //**Subtraction assignment to sparse matrices***************************************************
692  // No special implementation for the subtraction assignment to sparse matrices.
693  //**********************************************************************************************
694 
695  //**Multiplication assignment to dense matrices*************************************************
696  // No special implementation for the multiplication assignment to dense matrices.
697  //**********************************************************************************************
698 
699  //**Multiplication assignment to sparse matrices************************************************
700  // No special implementation for the multiplication assignment to sparse matrices.
701  //**********************************************************************************************
702 
703  //**SMP assignment to row-major matrices********************************************************
718  template< typename MT > // Type of the target matrix
719  friend inline DisableIf_< CanExploitSymmetry<MT,MT1,MT2> >
720  smpAssign( Matrix<MT,false>& lhs, const SMatTSMatMultExpr& 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 
728 
729  const OppositeType_<MT2> tmp( rhs.rhs_ );
730  smpAssign( ~lhs, rhs.lhs_ * tmp );
731  }
733  //**********************************************************************************************
734 
735  //**Restructuring SMP assignment to row-major matrices******************************************
750  template< typename MT > // Type of the target matrix
751  friend inline EnableIf_< CanExploitSymmetry<MT,MT1,MT2> >
752  smpAssign( Matrix<MT,false>& lhs, const SMatTSMatMultExpr& rhs )
753  {
755 
756  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
757  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
758 
759  smpAssign( ~lhs, rhs.lhs_ * trans( rhs.rhs_ ) );
760  }
762  //**********************************************************************************************
763 
764  //**SMP assignment to column-major matrices*****************************************************
779  template< typename MT > // Type of the target matrix
780  friend inline DisableIf_< CanExploitSymmetry<MT,MT1,MT2> >
781  smpAssign( Matrix<MT,true>& lhs, const SMatTSMatMultExpr& rhs )
782  {
784 
786 
787  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
788  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
789 
791 
792  const OppositeType_<MT1> tmp( rhs.lhs_ );
793  smpAssign( ~lhs, tmp * rhs.rhs_ );
794  }
796  //**********************************************************************************************
797 
798  //**Restructuring SMP assignment to column-major matrices***************************************
813  template< typename MT > // Type of the target matrix
814  friend inline EnableIf_< CanExploitSymmetry<MT,MT1,MT2> >
815  smpAssign( Matrix<MT,true>& lhs, const SMatTSMatMultExpr& rhs )
816  {
818 
820 
821  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
822  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
823 
824  smpAssign( ~lhs, trans( rhs.lhs_ ) * rhs.rhs_ );
825  }
827  //**********************************************************************************************
828 
829  //**SMP addition assignment to row-major dense matrices*****************************************
844  template< typename MT > // Type of the target dense matrix
845  friend inline DisableIf_< CanExploitSymmetry<MT,MT1,MT2> >
846  smpAddAssign( DenseMatrix<MT,false>& lhs, const SMatTSMatMultExpr& rhs )
847  {
849 
850  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
851  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
852 
854 
855  const OppositeType_<MT2> tmp( rhs.rhs_ );
856  smpAddAssign( ~lhs, rhs.lhs_ * tmp );
857  }
859  //**********************************************************************************************
860 
861  //**SMP addition assignment to column-major dense matrices**************************************
876  template< typename MT > // Type of the target dense matrix
877  friend inline DisableIf_< CanExploitSymmetry<MT,MT1,MT2> >
878  smpAddAssign( DenseMatrix<MT,true>& lhs, const SMatTSMatMultExpr& rhs )
879  {
881 
883 
884  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
885  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
886 
888 
889  const OppositeType_<MT1> tmp( rhs.lhs_ );
890  smpAddAssign( ~lhs, tmp * rhs.rhs_ );
891  }
893  //**********************************************************************************************
894 
895  //**Restructuring SMP addition assignment to row-major matrices*********************************
910  template< typename MT > // Type of the target matrix
911  friend inline EnableIf_< CanExploitSymmetry<MT,MT1,MT2> >
912  smpAddAssign( Matrix<MT,false>& lhs, const SMatTSMatMultExpr& rhs )
913  {
915 
916  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
917  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
918 
919  smpAddAssign( ~lhs, rhs.lhs_ * trans( rhs.rhs_ ) );
920  }
922  //**********************************************************************************************
923 
924  //**Restructuring SMP addition assignment to column-major matrices******************************
939  template< typename MT > // Type of the target matrix
940  friend inline EnableIf_< CanExploitSymmetry<MT,MT1,MT2> >
941  smpAddAssign( Matrix<MT,true>& lhs, const SMatTSMatMultExpr& rhs )
942  {
944 
946 
947  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
948  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
949 
950  smpAddAssign( ~lhs, trans( rhs.lhs_ ) * rhs.rhs_ );
951  }
953  //**********************************************************************************************
954 
955  //**SMP addition assignment to sparse matrices**************************************************
956  // No special implementation for the SMP addition assignment to sparse matrices.
957  //**********************************************************************************************
958 
959  //**SMP subtraction assignment to row-major dense matrices**************************************
974  template< typename MT > // Type of the target dense matrix
975  friend inline DisableIf_< CanExploitSymmetry<MT,MT1,MT2> >
976  smpSubAssign( DenseMatrix<MT,false>& lhs, const SMatTSMatMultExpr& rhs )
977  {
979 
980  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
981  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
982 
984 
985  const OppositeType_<MT2> tmp( rhs.rhs_ );
986  smpSubAssign( ~lhs, rhs.lhs_ * tmp );
987  }
989  //**********************************************************************************************
990 
991  //**SMP subtraction assignment to column-major dense matrices***********************************
1006  template< typename MT > // Type of the target dense matrix
1007  friend inline DisableIf_< CanExploitSymmetry<MT,MT1,MT2> >
1008  smpSubAssign( DenseMatrix<MT,true>& lhs, const SMatTSMatMultExpr& rhs )
1009  {
1011 
1013 
1014  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
1015  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
1016 
1018 
1019  const OppositeType_<MT1> tmp( rhs.lhs_ );
1020  smpSubAssign( ~lhs, tmp * rhs.rhs_ );
1021  }
1023  //**********************************************************************************************
1024 
1025  //**Restructuring SMP subtraction assignment to row-major matrices******************************
1040  template< typename MT > // Type of the target matrix
1041  friend inline EnableIf_< CanExploitSymmetry<MT,MT1,MT2> >
1042  smpSubAssign( Matrix<MT,false>& lhs, const SMatTSMatMultExpr& rhs )
1043  {
1045 
1046  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
1047  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
1048 
1049  smpSubAssign( ~lhs, rhs.lhs_ * trans( rhs.rhs_ ) );
1050  }
1052  //**********************************************************************************************
1053 
1054  //**Restructuring SMP subtraction assignment to column-major matrices***************************
1069  template< typename MT > // Type of the target matrix
1070  friend inline EnableIf_< CanExploitSymmetry<MT,MT1,MT2> >
1071  smpSubAssign( Matrix<MT,true>& lhs, const SMatTSMatMultExpr& rhs )
1072  {
1074 
1076 
1077  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
1078  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
1079 
1080  smpSubAssign( ~lhs, trans( rhs.lhs_ ) * rhs.rhs_ );
1081  }
1083  //**********************************************************************************************
1084 
1085  //**SMP subtraction assignment to sparse matrices***********************************************
1086  // No special implementation for the SMP subtraction assignment to sparse matrices.
1087  //**********************************************************************************************
1088 
1089  //**SMP multiplication assignment to dense matrices*********************************************
1090  // No special implementation for the SMP multiplication assignment to dense matrices.
1091  //**********************************************************************************************
1092 
1093  //**SMP multiplication assignment to sparse matrices********************************************
1094  // No special implementation for the SMP multiplication assignment to sparse matrices.
1095  //**********************************************************************************************
1096 
1097  //**Compile time checks*************************************************************************
1105  //**********************************************************************************************
1106 };
1107 //*************************************************************************************************
1108 
1109 
1110 
1111 
1112 //=================================================================================================
1113 //
1114 // GLOBAL BINARY ARITHMETIC OPERATORS
1115 //
1116 //=================================================================================================
1117 
1118 //*************************************************************************************************
1148 template< typename T1 // Type of the left-hand side sparse matrix
1149  , typename T2 > // Type of the right-hand side sparse matrix
1150 inline const SMatTSMatMultExpr<T1,T2>
1152 {
1154 
1155  if( (~lhs).columns() != (~rhs).rows() ) {
1156  BLAZE_THROW_INVALID_ARGUMENT( "Matrix sizes do not match" );
1157  }
1158 
1159  return SMatTSMatMultExpr<T1,T2>( ~lhs, ~rhs );
1160 }
1161 //*************************************************************************************************
1162 
1163 
1164 
1165 
1166 //=================================================================================================
1167 //
1168 // ROWS SPECIALIZATIONS
1169 //
1170 //=================================================================================================
1171 
1172 //*************************************************************************************************
1174 template< typename MT1, typename MT2 >
1175 struct Rows< SMatTSMatMultExpr<MT1,MT2> > : public Rows<MT1>
1176 {};
1178 //*************************************************************************************************
1179 
1180 
1181 
1182 
1183 //=================================================================================================
1184 //
1185 // COLUMNS SPECIALIZATIONS
1186 //
1187 //=================================================================================================
1188 
1189 //*************************************************************************************************
1191 template< typename MT1, typename MT2 >
1192 struct Columns< SMatTSMatMultExpr<MT1,MT2> > : public Columns<MT2>
1193 {};
1195 //*************************************************************************************************
1196 
1197 
1198 
1199 
1200 //=================================================================================================
1201 //
1202 // ISLOWER SPECIALIZATIONS
1203 //
1204 //=================================================================================================
1205 
1206 //*************************************************************************************************
1208 template< typename MT1, typename MT2 >
1209 struct IsLower< SMatTSMatMultExpr<MT1,MT2> >
1210  : public BoolConstant< And< IsLower<MT1>, IsLower<MT2> >::value >
1211 {};
1213 //*************************************************************************************************
1214 
1215 
1216 
1217 
1218 //=================================================================================================
1219 //
1220 // ISUNILOWER SPECIALIZATIONS
1221 //
1222 //=================================================================================================
1223 
1224 //*************************************************************************************************
1226 template< typename MT1, typename MT2 >
1227 struct IsUniLower< SMatTSMatMultExpr<MT1,MT2> >
1228  : public BoolConstant< And< IsUniLower<MT1>, IsUniLower<MT2> >::value >
1229 {};
1231 //*************************************************************************************************
1232 
1233 
1234 
1235 
1236 //=================================================================================================
1237 //
1238 // ISSTRICTLYLOWER SPECIALIZATIONS
1239 //
1240 //=================================================================================================
1241 
1242 //*************************************************************************************************
1244 template< typename MT1, typename MT2 >
1245 struct IsStrictlyLower< SMatTSMatMultExpr<MT1,MT2> >
1246  : public BoolConstant< Or< And< IsStrictlyLower<MT1>, IsLower<MT2> >
1247  , And< IsStrictlyLower<MT2>, IsLower<MT1> > >::value >
1248 {};
1250 //*************************************************************************************************
1251 
1252 
1253 
1254 
1255 //=================================================================================================
1256 //
1257 // ISUPPER SPECIALIZATIONS
1258 //
1259 //=================================================================================================
1260 
1261 //*************************************************************************************************
1263 template< typename MT1, typename MT2 >
1264 struct IsUpper< SMatTSMatMultExpr<MT1,MT2> >
1265  : public BoolConstant< And< IsUpper<MT1>, IsUpper<MT2> >::value >
1266 {};
1268 //*************************************************************************************************
1269 
1270 
1271 
1272 
1273 //=================================================================================================
1274 //
1275 // ISUNIUPPER SPECIALIZATIONS
1276 //
1277 //=================================================================================================
1278 
1279 //*************************************************************************************************
1281 template< typename MT1, typename MT2 >
1282 struct IsUniUpper< SMatTSMatMultExpr<MT1,MT2> >
1283  : public BoolConstant< And< IsUniUpper<MT1>, IsUniUpper<MT2> >::value >
1284 {};
1286 //*************************************************************************************************
1287 
1288 
1289 
1290 
1291 //=================================================================================================
1292 //
1293 // ISSTRICTLYUPPER SPECIALIZATIONS
1294 //
1295 //=================================================================================================
1296 
1297 //*************************************************************************************************
1299 template< typename MT1, typename MT2 >
1300 struct IsStrictlyUpper< SMatTSMatMultExpr<MT1,MT2> >
1301  : public BoolConstant< Or< And< IsStrictlyUpper<MT1>, IsUpper<MT2> >
1302  , And< IsStrictlyUpper<MT2>, IsUpper<MT1> > >::value >
1303 {};
1305 //*************************************************************************************************
1306 
1307 
1308 
1309 
1310 //=================================================================================================
1311 //
1312 // EXPRESSION TRAIT SPECIALIZATIONS
1313 //
1314 //=================================================================================================
1315 
1316 //*************************************************************************************************
1318 template< typename MT1, typename MT2, typename VT >
1319 struct SMatDVecMultExprTrait< SMatTSMatMultExpr<MT1,MT2>, VT >
1320 {
1321  public:
1322  //**********************************************************************************************
1323  using Type = If_< And< IsSparseMatrix<MT1>, IsRowMajorMatrix<MT1>
1324  , IsSparseMatrix<MT2>, IsColumnMajorMatrix<MT2>
1325  , IsDenseVector<VT>, IsColumnVector<VT> >
1326  , SMatDVecMultExprTrait_< MT1, TSMatDVecMultExprTrait_<MT2,VT> >
1327  , INVALID_TYPE >;
1328  //**********************************************************************************************
1329 };
1331 //*************************************************************************************************
1332 
1333 
1334 //*************************************************************************************************
1336 template< typename MT1, typename MT2, typename VT >
1337 struct SMatSVecMultExprTrait< SMatTSMatMultExpr<MT1,MT2>, VT >
1338 {
1339  public:
1340  //**********************************************************************************************
1341  using Type = If_< And< IsSparseMatrix<MT1>, IsRowMajorMatrix<MT1>
1342  , IsSparseMatrix<MT2>, IsColumnMajorMatrix<MT2>
1343  , IsSparseVector<VT>, IsColumnVector<VT> >
1344  , SMatSVecMultExprTrait_< MT1, TSMatSVecMultExprTrait_<MT2,VT> >
1345  , INVALID_TYPE >;
1346  //**********************************************************************************************
1347 };
1349 //*************************************************************************************************
1350 
1351 
1352 //*************************************************************************************************
1354 template< typename VT, typename MT1, typename MT2 >
1355 struct TDVecSMatMultExprTrait< VT, SMatTSMatMultExpr<MT1,MT2> >
1356 {
1357  public:
1358  //**********************************************************************************************
1359  using Type = If_< And< IsDenseVector<VT>, IsRowVector<VT>
1360  , IsSparseMatrix<MT1>, IsRowMajorMatrix<MT1>
1361  , IsSparseMatrix<MT2>, IsColumnMajorMatrix<MT2> >
1362  , TDVecTSMatMultExprTrait_< TDVecSMatMultExprTrait_<VT,MT1>, MT2 >
1363  , INVALID_TYPE >;
1364  //**********************************************************************************************
1365 };
1367 //*************************************************************************************************
1368 
1369 
1370 //*************************************************************************************************
1372 template< typename VT, typename MT1, typename MT2 >
1373 struct TSVecSMatMultExprTrait< VT, SMatTSMatMultExpr<MT1,MT2> >
1374 {
1375  public:
1376  //**********************************************************************************************
1377  using Type = If_< And< IsSparseVector<VT>, IsRowVector<VT>
1378  , IsSparseMatrix<MT1>, IsRowMajorMatrix<MT1>
1379  , IsSparseMatrix<MT2>, IsColumnMajorMatrix<MT2> >
1380  , TDVecTSMatMultExprTrait_< TDVecSMatMultExprTrait_<VT,MT1>, MT2 >
1381  , INVALID_TYPE >;
1382  //**********************************************************************************************
1383 };
1385 //*************************************************************************************************
1386 
1387 
1388 //*************************************************************************************************
1390 template< typename MT1, typename MT2, bool AF >
1391 struct SubmatrixExprTrait< SMatTSMatMultExpr<MT1,MT2>, AF >
1392 {
1393  public:
1394  //**********************************************************************************************
1395  using Type = MultExprTrait_< SubmatrixExprTrait_<const MT1,AF>
1396  , SubmatrixExprTrait_<const MT2,AF> >;
1397  //**********************************************************************************************
1398 };
1400 //*************************************************************************************************
1401 
1402 
1403 //*************************************************************************************************
1405 template< typename MT1, typename MT2 >
1406 struct RowExprTrait< SMatTSMatMultExpr<MT1,MT2> >
1407 {
1408  public:
1409  //**********************************************************************************************
1410  using Type = MultExprTrait_< RowExprTrait_<const MT1>, MT2 >;
1411  //**********************************************************************************************
1412 };
1414 //*************************************************************************************************
1415 
1416 
1417 //*************************************************************************************************
1419 template< typename MT1, typename MT2 >
1420 struct ColumnExprTrait< SMatTSMatMultExpr<MT1,MT2> >
1421 {
1422  public:
1423  //**********************************************************************************************
1424  using Type = MultExprTrait_< MT1, ColumnExprTrait_<const MT2> >;
1425  //**********************************************************************************************
1426 };
1428 //*************************************************************************************************
1429 
1430 } // namespace blaze
1431 
1432 #endif
#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
ResultType_< MT1 > RT1
Result type of the left-hand side sparse matrix expression.
Definition: SMatTSMatMultExpr.h:126
OppositeType_< ResultType > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: SMatTSMatMultExpr.h:153
Header file for auxiliary alias declarations.
TransposeType_< ResultType > TransposeType
Transpose type for expression template evaluations.
Definition: SMatTSMatMultExpr.h:154
Header file for mathematical functions.
Header file for the SMatDVecMultExprTrait class template.
size_t rows() const noexcept
Returns the current number of rows of the matrix.
Definition: SMatTSMatMultExpr.h:224
Header file for the Rows type trait.
Header file for the UNUSED_PARAMETER function template.
Header file for the IsUniUpper type trait.
const DMatDMatMultExpr< T1, T2 > operator*(const DenseMatrix< T1, false > &lhs, const DenseMatrix< T2, false > &rhs)
Multiplication operator for the multiplication of two row-major dense matrices ( ).
Definition: DMatDMatMultExpr.h:7800
Header file for basic type definitions.
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 IsSparseMatrix type trait.
Header file for the serial shim.
Header file for the ColumnExprTrait class template.
Header file for the IsColumnMajorMatrix type trait.
MultTrait_< RT1, RT2 > ResultType
Result type for expression template evaluations.
Definition: SMatTSMatMultExpr.h:152
Header file for the TSVecTSMatMultExprTrait class template.
Header file for the IsRowVector type trait.
typename DisableIf< Condition, T >::Type DisableIf_
Auxiliary type for the DisableIf class template.The DisableIf_ alias declaration provides a convenien...
Definition: DisableIf.h:223
Header file for the And class template.
Header file for the TDVecSMatMultExprTrait 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:723
typename MultTrait< T1, T2 >::Type MultTrait_
Auxiliary alias declaration for the MultTrait class template.The MultTrait_ alias declaration provide...
Definition: MultTrait.h:245
Header file for the Computation base class.
Header file for the MatMatMultExpr base class.
bool isAliased(const T *alias) const noexcept
Returns whether the expression is aliased with the given address alias.
Definition: SMatTSMatMultExpr.h:300
Constraints on the storage order of matrix types.
Header file for the RequiresEvaluation type trait.
Header file for the TSVecSMatMultExprTrait class template.
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
DisableIf_< Or< IsComputation< MT >, IsTransExpr< MT > >, ColumnExprTrait_< MT > > column(Matrix< MT, SO > &matrix, size_t index)
Creating a view on a specific column of the given matrix.
Definition: Column.h:126
Base class for sparse matrices.The SparseMatrix class is a base class for all sparse matrix classes...
Definition: Forward.h:109
Header file for the SparseMatrix base class.
SMatTSMatMultExpr< MT1, MT2 > This
Type of this SMatTSMatMultExpr instance.
Definition: SMatTSMatMultExpr.h:151
const ElementType ReturnType
Return type for expression template evaluations.
Definition: SMatTSMatMultExpr.h:156
Constraint on the data type.
Expression object for sparse matrix-transpose sparse matrix multiplications.The SMatTSMatMultExpr cla...
Definition: Forward.h:107
Header file for the MultExprTrait class template.
typename T::CompositeType CompositeType_
Alias declaration for nested CompositeType type definitions.The CompositeType_ alias declaration prov...
Definition: Aliases.h:83
Header file for the DisableIf class template.
Header file for the multiplication trait.
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.
Compile time check for row-major matrix types.This type trait tests whether or not the given template...
Definition: IsRowMajorMatrix.h:83
#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
EnableIf_< IsDenseMatrix< MT1 > > smpAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP assignment of a matrix to a dense matrix.
Definition: DenseMatrix.h:98
Header file for the Or class template.
Header file for the TDVecTSMatMultExprTrait class template.
#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.
Header file for the TSMatDVecMultExprTrait class template.
typename T::ElementType ElementType_
Alias declaration for nested ElementType type definitions.The ElementType_ alias declaration provides...
Definition: Aliases.h:163
LeftOperand leftOperand() const noexcept
Returns the left-hand side sparse matrix operand.
Definition: SMatTSMatMultExpr.h:266
Header file for the IsLower type trait.
bool canAlias(const T *alias) const noexcept
Returns whether the expression can alias with the given address alias.
Definition: SMatTSMatMultExpr.h:288
BLAZE_ALWAYS_INLINE size_t columns(const Matrix< MT, SO > &matrix) noexcept
Returns the current number of columns of the matrix.
Definition: Matrix.h:330
Header file for the SMatSVecMultExprTrait class template.
RightOperand rightOperand() const noexcept
Returns the right-hand side transpose sparse matrix operand.
Definition: SMatTSMatMultExpr.h:276
Compile time check for symmetric matrices.This type trait tests whether or not the given template par...
Definition: IsSymmetric.h:85
Header file for the exception macros of the math module.
size_t columns() const noexcept
Returns the current number of columns of the matrix.
Definition: SMatTSMatMultExpr.h:234
Header file for the RowExprTrait class template.
Header file for all forward declarations for expression class templates.
SMatTSMatMultExpr(const MT1 &lhs, const MT2 &rhs) noexcept
Constructor for the SMatTSMatMultExpr class.
Definition: SMatTSMatMultExpr.h:177
ReturnType at(size_t i, size_t j) const
Checked access to the matrix elements.
Definition: SMatTSMatMultExpr.h:208
Header file for the EnableIf class template.
Header file for the IsStrictlyLower type trait.
#define BLAZE_CONSTRAINT_MUST_FORM_VALID_MATMATMULTEXPR(T1, T2)
Constraint on the data type.In case the given data types T1 and T2 do not form a valid matrix/matrix ...
Definition: MatMatMultExpr.h:109
constexpr size_t nonZeros() const noexcept
Returns the number of non-zero elements in the sparse matrix.
Definition: SMatTSMatMultExpr.h:244
DisableIf_< Or< IsComputation< MT >, IsTransExpr< MT > >, RowExprTrait_< MT > > row(Matrix< MT, SO > &matrix, size_t index)
Creating a view on a specific row of the given matrix.
Definition: Row.h:126
const ResultType CompositeType
Data type for composite expression templates.
Definition: SMatTSMatMultExpr.h:157
Header file for the IsSparseVector type trait.
#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
Header file for run time assertion macros.
Compile time check for column-major matrix types.This type trait tests whether or not the given templ...
Definition: IsColumnMajorMatrix.h:83
If_< IsExpression< MT1 >, const MT1, const MT1 & > LeftOperand
Composite type of the left-hand side sparse matrix expression.
Definition: SMatTSMatMultExpr.h:160
Utility type for generic codes.
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
Base class for matrices.The Matrix class is a base class for all dense and sparse matrix classes with...
Definition: Forward.h:89
Constraint on the data type.
CompositeType_< MT1 > CT1
Composite type of the left-hand side sparse matrix expression.
Definition: SMatTSMatMultExpr.h:128
Constraints on the storage order of matrix types.
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: SMatTSMatMultExpr.h:192
IntegralConstant< bool, B > BoolConstant
Generic wrapper for a compile time constant boolean value.The BoolConstant class template represents ...
Definition: IntegralConstant.h:100
LeftOperand lhs_
Left-hand side sparse matrix of the multiplication expression.
Definition: SMatTSMatMultExpr.h:317
Header file for the RemoveReference type trait.
ResultType_< MT2 > RT2
Result type of the right-hand side sparse matrix expression.
Definition: SMatTSMatMultExpr.h:127
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
CompositeType_< MT2 > CT2
Composite type of the right-hand side sparse matrix expression.
Definition: SMatTSMatMultExpr.h:129
Header file for the IsDenseVector type trait.
bool canSMPAssign() const noexcept
Returns whether the expression can be used in SMP assignments.
Definition: SMatTSMatMultExpr.h:310
BLAZE_ALWAYS_INLINE size_t rows(const Matrix< MT, SO > &matrix) noexcept
Returns the current number of rows of the matrix.
Definition: Matrix.h:314
size_t nonZeros(size_t i) const noexcept
Returns the number of non-zero elements in the specified row.
Definition: SMatTSMatMultExpr.h:255
Header file for the IsRowMajorMatrix type trait.
const DMatTransExpr< MT,!SO > trans(const DenseMatrix< MT, SO > &dm)
Calculation of the transpose of the given dense matrix.
Definition: DMatTransExpr.h:950
Header file for the IsComputation type trait class.
#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
Header file for the IntegralConstant class template.
RightOperand rhs_
Right-hand side sparse matrix of the multiplication expression.
Definition: SMatTSMatMultExpr.h:318
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.
void UNUSED_PARAMETER(const Args &...)
Suppression of unused parameter warnings.
Definition: Unused.h:81
If_< IsExpression< MT2 >, const MT2, const MT2 & > RightOperand
Composite type of the right-hand side sparse matrix expression.
Definition: SMatTSMatMultExpr.h:163
Header file for the IsColumnVector type trait.
Constraint on the data type.
Header file for the thresholds for matrix/vector and matrix/matrix multiplications.
#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:61
Header file for the IsExpression type trait class.
Header file for the TSMatSVecMultExprTrait class template.
Header file for the FunctionTrace class.
ElementType_< ResultType > ElementType
Resulting element type.
Definition: SMatTSMatMultExpr.h:155