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>
94 #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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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  //**********************************************************************************************
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  //**********************************************************************************************
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  //**********************************************************************************************
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  //**********************************************************************************************
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  //**********************************************************************************************
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  //**********************************************************************************************
1425  //**********************************************************************************************
1426 };
1428 //*************************************************************************************************
1429 
1430 } // namespace blaze
1431 
1432 #endif
typename SubmatrixExprTrait< MT, AF >::Type SubmatrixExprTrait_
Auxiliary alias declaration for the SubmatrixExprTrait type trait.The SubmatrixExprTrait_ alias decla...
Definition: SubmatrixExprTrait.h:134
#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
Compile time check for row vector types.This type trait tests whether or not the given template argum...
Definition: IsRowVector.h:80
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.
Header file for the Rows type trait.
Header file for the UNUSED_PARAMETER function template.
Header file for the IsUniUpper type trait.
Header file for basic type definitions.
size_t columns() const noexcept
Returns the current number of columns of the matrix.
Definition: SMatTSMatMultExpr.h:234
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.
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.
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.
Compile time check for lower triangular matrices.This type trait tests whether or not the given templ...
Definition: IsLower.h:88
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:721
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.
RightOperand rightOperand() const noexcept
Returns the right-hand side transpose sparse matrix operand.
Definition: SMatTSMatMultExpr.h:276
Compile time check for upper triangular matrices.This type trait tests whether or not the given templ...
Definition: IsUpper.h:88
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
Evaluation of the expression type of a sparse matrix/dense vector multiplication.Via this type trait ...
Definition: SMatDVecMultExprTrait.h:78
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
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:117
typename MultExprTrait< T1, T2 >::Type MultExprTrait_
Auxiliary alias declaration for the MultExprTrait class template.The MultExprTrait_ alias declaration...
Definition: MultExprTrait.h:344
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
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: SMatTSMatMultExpr.h:192
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.
Compile time check for dense vector types.This type trait tests whether or not the given template par...
Definition: IsDenseVector.h:78
LeftOperand leftOperand() const noexcept
Returns the left-hand side sparse matrix operand.
Definition: SMatTSMatMultExpr.h:266
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
bool isAliased(const T *alias) const noexcept
Returns whether the expression is aliased with the given address alias.
Definition: SMatTSMatMultExpr.h:300
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.
typename SMatSVecMultExprTrait< MT, VT >::Type SMatSVecMultExprTrait_
Auxiliary alias declaration for the SMatSVecMultExprTrait class template.The SMatSVecMultExprTrait_ a...
Definition: SMatSVecMultExprTrait.h:123
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.
constexpr size_t nonZeros() const noexcept
Returns the number of non-zero elements in the sparse matrix.
Definition: SMatTSMatMultExpr.h:244
typename T::ElementType ElementType_
Alias declaration for nested ElementType type definitions.The ElementType_ alias declaration provides...
Definition: Aliases.h:163
Compile time check for sparse vector types.This type trait tests whether or not the given template pa...
Definition: IsSparseVector.h:78
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.
Evaluation of the expression type of a sparse matrix/sparse vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix/sparse vector multiplication. Given the row-major sparse matrix type MT and the non-transpose sparse vector type VT, the nested type Type corresponds to the resulting expression type. In case either MT is not a row-major sparse matrix type or VT is not a non-transpose sparse vector type, the resulting data type Type is set to INVALID_TYPE.
Definition: SMatSVecMultExprTrait.h:80
Evaluation of the expression type of a dense vector/sparse matrix multiplication.Via this type trait ...
Definition: TDVecSMatMultExprTrait.h:80
Header file for the SMatSVecMultExprTrait class template.
DisableIf_< Or< IsComputation< MT >, IsTransExpr< MT >, IsDeclExpr< 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:128
Evaluation of the expression type of a sparse vector/sparse matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector/sparse matrix multiplication. Given the transpose sparse vector type VT and the row-major sparse matrix type MT, the nested type Type corresponds to the resulting expression type. In case either VT is not a transpose sparse vector type or MT is not a row-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE.
Definition: TSVecSMatMultExprTrait.h:78
Compile time check for column vector types.This type trait tests whether or not the given template ar...
Definition: IsColumnVector.h:80
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.
Compile time check for strictly upper triangular matrices.This type trait tests whether or not the gi...
Definition: IsStrictlyUpper.h:86
Evaluation of the expression type type of a row operation.Via this type trait it is possible to evalu...
Definition: RowExprTrait.h:79
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
DisableIf_< Or< IsComputation< MT >, IsTransExpr< MT >, IsDeclExpr< 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:128
Header file for the EnableIf class template.
Header file for the IsStrictlyLower type trait.
size_t rows() const noexcept
Returns the current number of rows of the matrix.
Definition: SMatTSMatMultExpr.h:224
#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
Compile time check for lower unitriangular matrices.This type trait tests whether or not the given te...
Definition: IsUniLower.h:86
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
bool canAlias(const T *alias) const noexcept
Returns whether the expression can alias with the given address alias.
Definition: SMatTSMatMultExpr.h:288
ReturnType at(size_t i, size_t j) const
Checked access to the matrix elements.
Definition: SMatTSMatMultExpr.h:208
#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
Base class for matrices.The Matrix class is a base class for all dense and sparse matrix classes with...
Definition: Forward.h:94
typename TDVecTSMatMultExprTrait< VT, MT >::Type TDVecTSMatMultExprTrait_
Auxiliary alias declaration for the TDVecTSMatMultExprTrait class template.The TDVecTSMatMultExprTrai...
Definition: TDVecTSMatMultExprTrait.h:120
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.
typename SMatDVecMultExprTrait< MT, VT >::Type SMatDVecMultExprTrait_
Auxiliary alias declaration for the SMatDVecMultExprTrait class template.The SMatDVecMultExprTrait_ a...
Definition: SMatDVecMultExprTrait.h:119
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.
Compile time check for strictly lower triangular matrices.This type trait tests whether or not the gi...
Definition: IsStrictlyLower.h:86
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:733
Header file for the IsComputation type trait class.
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 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
Compile time check for sparse matrix types.This type trait tests whether or not the given template pa...
Definition: IsSparseMatrix.h:78
RightOperand rhs_
Right-hand side sparse matrix of the multiplication expression.
Definition: SMatTSMatMultExpr.h:318
bool canSMPAssign() const noexcept
Returns whether the expression can be used in SMP assignments.
Definition: SMatTSMatMultExpr.h:310
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.
const DMatDMatMultExpr< T1, T2, false, false, false, false > 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:7505
Header file for the thresholds for matrix/vector and matrix/matrix multiplications.
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
#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 function trace functionality.
ElementType_< ResultType > ElementType
Resulting element type.
Definition: SMatTSMatMultExpr.h:155