TSMatTSMatMultExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_TSMATTSMATMULTEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_TSMATTSMATMULTEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <algorithm>
44 #include <vector>
45 #include <blaze/math/Aliases.h>
50 #include <blaze/math/Exception.h>
55 #include <blaze/math/Functions.h>
56 #include <blaze/math/Infinity.h>
58 #include <blaze/math/shims/Reset.h>
91 #include <blaze/util/Assert.h>
92 #include <blaze/util/DisableIf.h>
93 #include <blaze/util/EnableIf.h>
96 #include <blaze/util/InvalidType.h>
97 #include <blaze/util/mpl/And.h>
98 #include <blaze/util/mpl/If.h>
99 #include <blaze/util/mpl/Or.h>
100 #include <blaze/util/Types.h>
103 #include <blaze/util/Unused.h>
104 
105 
106 namespace blaze {
107 
108 //=================================================================================================
109 //
110 // CLASS TSMATTSMATMULTEXPR
111 //
112 //=================================================================================================
113 
114 //*************************************************************************************************
121 template< typename MT1 // Type of the left-hand side sparse matrix
122  , typename MT2 > // Type of the right-hand side sparse matrix
123 class TSMatTSMatMultExpr : public SparseMatrix< TSMatTSMatMultExpr<MT1,MT2>, true >
124  , private MatMatMultExpr
125  , private Computation
126 {
127  private:
128  //**Type definitions****************************************************************************
133  //**********************************************************************************************
134 
135  //**********************************************************************************************
137  enum : bool { evaluateLeft = RequiresEvaluation<MT1>::value };
138  //**********************************************************************************************
139 
140  //**********************************************************************************************
142  enum : bool { evaluateRight = RequiresEvaluation<MT2>::value };
143  //**********************************************************************************************
144 
145  //**********************************************************************************************
147 
152  template< typename T1, typename T2, typename T3 >
153  struct CanExploitSymmetry {
154  enum : bool { value = IsRowMajorMatrix<T1>::value &&
156  };
158  //**********************************************************************************************
159 
160  //**********************************************************************************************
162 
167  template< typename T1, typename T2, typename T3 >
168  struct IsEvaluationRequired {
169  enum : bool { value = ( evaluateLeft || evaluateRight ) &&
170  !CanExploitSymmetry<T1,T2,T3>::value };
171  };
173  //**********************************************************************************************
174 
175  public:
176  //**Type definitions****************************************************************************
182  typedef const ElementType ReturnType;
183  typedef const ResultType CompositeType;
184 
186  typedef If_< IsExpression<MT1>, const MT1, const MT1& > LeftOperand;
187 
189  typedef If_< IsExpression<MT2>, const MT2, const MT2& > RightOperand;
190  //**********************************************************************************************
191 
192  //**Compilation flags***************************************************************************
194  enum : bool { smpAssignable = !evaluateLeft && MT1::smpAssignable &&
195  !evaluateRight && MT2::smpAssignable };
196  //**********************************************************************************************
197 
198  //**Constructor*********************************************************************************
204  explicit inline TSMatTSMatMultExpr( const MT1& lhs, const MT2& rhs ) noexcept
205  : lhs_( lhs ) // Left-hand side sparse matrix of the multiplication expression
206  , rhs_( rhs ) // Right-hand side sparse matrix of the multiplication expression
207  {
208  BLAZE_INTERNAL_ASSERT( lhs.columns() == rhs.rows(), "Invalid matrix sizes" );
209  }
210  //**********************************************************************************************
211 
212  //**Access operator*****************************************************************************
219  inline ReturnType operator()( size_t i, size_t j ) const {
220  BLAZE_INTERNAL_ASSERT( i < lhs_.rows() , "Invalid row access index" );
221  BLAZE_INTERNAL_ASSERT( j < rhs_.columns(), "Invalid column access index" );
222 
223  if( IsDiagonal<MT1>::value ) {
224  return lhs_(i,i) * rhs_(i,j);
225  }
226  else if( IsDiagonal<MT2>::value ) {
227  return lhs_(i,j) * rhs_(j,j);
228  }
230  const size_t begin( ( IsUpper<MT1>::value )
231  ?( ( IsLower<MT2>::value )
232  ?( max( ( IsStrictlyUpper<MT1>::value ? i+1UL : i )
233  , ( IsStrictlyLower<MT2>::value ? j+1UL : j ) ) )
234  :( IsStrictlyUpper<MT1>::value ? i+1UL : i ) )
235  :( ( IsLower<MT2>::value )
236  ?( IsStrictlyLower<MT2>::value ? j+1UL : j )
237  :( 0UL ) ) );
238  const size_t end( ( IsLower<MT1>::value )
239  ?( ( IsUpper<MT2>::value )
240  ?( min( ( IsStrictlyLower<MT1>::value ? i : i+1UL )
241  , ( IsStrictlyUpper<MT2>::value ? j : j+1UL ) ) )
242  :( IsStrictlyLower<MT1>::value ? i : i+1UL ) )
243  :( ( IsUpper<MT2>::value )
244  ?( IsStrictlyUpper<MT2>::value ? j : j+1UL )
245  :( lhs_.columns() ) ) );
246 
247  if( begin >= end ) return ElementType();
248 
249  const size_t n( end - begin );
250 
251  return subvector( row( lhs_, i ), begin, n ) * subvector( column( rhs_, j ), begin, n );
252  }
253  else {
254  return row( lhs_, i ) * column( rhs_, j );
255  }
256  }
257  //**********************************************************************************************
258 
259  //**At function*********************************************************************************
267  inline ReturnType at( size_t i, size_t j ) const {
268  if( i >= lhs_.rows() ) {
269  BLAZE_THROW_OUT_OF_RANGE( "Invalid row access index" );
270  }
271  if( j >= rhs_.columns() ) {
272  BLAZE_THROW_OUT_OF_RANGE( "Invalid column access index" );
273  }
274  return (*this)(i,j);
275  }
276  //**********************************************************************************************
277 
278  //**Rows function*******************************************************************************
283  inline size_t rows() const noexcept {
284  return lhs_.rows();
285  }
286  //**********************************************************************************************
287 
288  //**Columns function****************************************************************************
293  inline size_t columns() const noexcept {
294  return rhs_.columns();
295  }
296  //**********************************************************************************************
297 
298  //**NonZeros function***************************************************************************
303  inline constexpr size_t nonZeros() const noexcept {
304  return 0UL;
305  }
306  //**********************************************************************************************
307 
308  //**NonZeros function***************************************************************************
314  inline size_t nonZeros( size_t i ) const noexcept {
315  UNUSED_PARAMETER( i );
316  return 0UL;
317  }
318  //**********************************************************************************************
319 
320  //**Left operand access*************************************************************************
325  inline LeftOperand leftOperand() const noexcept {
326  return lhs_;
327  }
328  //**********************************************************************************************
329 
330  //**Right operand access************************************************************************
335  inline RightOperand rightOperand() const noexcept {
336  return rhs_;
337  }
338  //**********************************************************************************************
339 
340  //**********************************************************************************************
346  template< typename T >
347  inline bool canAlias( const T* alias ) const noexcept {
348  return ( lhs_.isAliased( alias ) || rhs_.isAliased( alias ) );
349  }
350  //**********************************************************************************************
351 
352  //**********************************************************************************************
358  template< typename T >
359  inline bool isAliased( const T* alias ) const noexcept {
360  return ( lhs_.isAliased( alias ) || rhs_.isAliased( alias ) );
361  }
362  //**********************************************************************************************
363 
364  //**********************************************************************************************
369  inline bool canSMPAssign() const noexcept {
370  return ( rows() * columns() >= SMP_TSMATTSMATMULT_THRESHOLD );
371  }
372  //**********************************************************************************************
373 
374  private:
375  //**Member variables****************************************************************************
376  LeftOperand lhs_;
377  RightOperand rhs_;
378  //**********************************************************************************************
379 
380  //**Assignment to dense matrices****************************************************************
393  template< typename MT // Type of the target dense matrix
394  , bool SO > // Storage order of the target dense matrix
396  assign( DenseMatrix<MT,SO>& lhs, const TSMatTSMatMultExpr& rhs )
397  {
399 
400  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
401  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
402 
403  CT1 A( serial( rhs.lhs_ ) ); // Evaluation of the left-hand side sparse matrix operand
404  CT2 B( serial( rhs.rhs_ ) ); // Evaluation of the right-hand side sparse matrix operand
405 
406  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.lhs_.rows() , "Invalid number of rows" );
407  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.lhs_.columns(), "Invalid number of columns" );
408  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
409  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
410  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
411  BLAZE_INTERNAL_ASSERT( B.columns() == (~lhs).columns() , "Invalid number of columns" );
412 
413  TSMatTSMatMultExpr::selectAssignKernel( ~lhs, A, B );
414  }
416  //**********************************************************************************************
417 
418  //**Default assignment to dense matrices********************************************************
432  template< typename MT3 // Type of the left-hand side target matrix
433  , typename MT4 // Type of the left-hand side matrix operand
434  , typename MT5 > // Type of the right-hand side matrix operand
435  static inline void selectAssignKernel( MT3& C, const MT4& A, const MT5& B )
436  {
437  typedef ConstIterator_<MT4> LeftIterator;
438  typedef ConstIterator_<MT5> RightIterator;
439 
440  for( size_t j=0UL; j<C.columns(); ++j ) {
441  const RightIterator rend( B.end(j) );
442  for( RightIterator relem=B.begin(j); relem!=rend; ++relem ) {
443  const LeftIterator lend( A.end( relem->index() ) );
444  for( LeftIterator lelem=A.begin( relem->index() ); lelem!=lend; ++lelem )
445  {
446  if( IsResizable< ElementType_<MT3> >::value &&
447  isDefault( C(lelem->index(),j) ) ) {
448  C(lelem->index(),j) = lelem->value() * relem->value();
449  }
450  else {
451  C(lelem->index(),j) += lelem->value() * relem->value();
452  }
453  }
454  }
455  }
456  }
458  //**********************************************************************************************
459 
460  //**Assignment to row-major sparse matrices*****************************************************
473  template< typename MT > // Type of the target sparse matrix
475  assign( SparseMatrix<MT,false>& lhs, const TSMatTSMatMultExpr& rhs )
476  {
478 
480 
481  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
482  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
483 
486 
487  const ResultType tmp( serial( rhs ) );
488  (~lhs).reserve( tmp.nonZeros() );
489  assign( ~lhs, tmp );
490  }
492  //**********************************************************************************************
493 
494  //**Assignment to column-major sparse matrices**************************************************
507  template< typename MT > // Type of the target sparse matrix
508  friend inline void assign( SparseMatrix<MT,true>& lhs, const TSMatTSMatMultExpr& rhs )
509  {
511 
512  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
513  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
514 
515  typedef ConstIterator_< RemoveReference_<CT1> > LeftIterator;
516  typedef ConstIterator_< RemoveReference_<CT2> > RightIterator;
517 
518  CT1 A( serial( rhs.lhs_ ) ); // Evaluation of the left-hand side sparse matrix operand
519  CT2 B( serial( rhs.rhs_ ) ); // Evaluation of the right-hand side sparse matrix operand
520 
521  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.lhs_.rows() , "Invalid number of rows" );
522  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.lhs_.columns(), "Invalid number of columns" );
523  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
524  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
525  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
526  BLAZE_INTERNAL_ASSERT( B.columns() == (~lhs).columns() , "Invalid number of columns" );
527 
528  // (Over-)Estimating the number of non-zero entries in the resulting matrix
529  size_t nonzeros( 0UL );
530 
531  for( size_t j=0UL; j<(~lhs).columns(); ++j ) {
532  const RightIterator rend( B.end(j) );
533  for( RightIterator relem=B.begin(j); relem!=rend; ++relem ) {
534  nonzeros += A.nonZeros( relem->index() );
535  }
536  }
537 
538  if( nonzeros > (~lhs).rows() * (~lhs).columns() ) {
539  nonzeros = (~lhs).rows() * (~lhs).columns();
540  }
541 
542  (~lhs).reserve( nonzeros );
543  nonzeros = 0UL;
544 
545  // Performing the matrix-matrix multiplication
546  std::vector<ElementType> values ( (~lhs).rows(), ElementType() );
547  std::vector<byte_t> valid ( (~lhs).rows(), 0 );
548  std::vector<size_t> indices( (~lhs).rows(), 0UL );
549  size_t minIndex( inf ), maxIndex( 0UL );
550 
551  for( size_t j=0UL; j<(~lhs).columns(); ++j )
552  {
553  const RightIterator rend( B.end(j) );
554  for( RightIterator relem=B.begin(j); relem!=rend; ++relem )
555  {
556  const LeftIterator lend( A.end( relem->index() ) );
557  for( LeftIterator lelem=A.begin( relem->index() ); lelem!=lend; ++lelem )
558  {
559  if( !valid[lelem->index()] ) {
560  values[lelem->index()] = lelem->value() * relem->value();
561  valid [lelem->index()] = 1;
562  indices[nonzeros] = lelem->index();
563  ++nonzeros;
564  if( lelem->index() < minIndex ) minIndex = lelem->index();
565  if( lelem->index() > maxIndex ) maxIndex = lelem->index();
566  }
567  else {
568  values[lelem->index()] += lelem->value() * relem->value();
569  }
570  }
571  }
572 
573  BLAZE_INTERNAL_ASSERT( nonzeros <= (~lhs).rows(), "Invalid number of non-zero elements" );
574 
575  if( nonzeros > 0UL )
576  {
577  BLAZE_INTERNAL_ASSERT( minIndex <= maxIndex, "Invalid index detected" );
578 
579  if( ( nonzeros + nonzeros ) < ( maxIndex - minIndex ) )
580  {
581  std::sort( indices.begin(), indices.begin() + nonzeros );
582 
583  for( size_t i=0UL; i<nonzeros; ++i )
584  {
585  const size_t index( indices[i] );
586  if( !isDefault( values[index] ) ) {
587  (~lhs).append( index, j, values[index] );
588  reset( values[index] );
589  }
590 
591  reset( valid [index] );
592  }
593  }
594  else {
595  for( size_t i=minIndex; i<=maxIndex; ++i )
596  {
597  if( !isDefault( values[i] ) ) {
598  (~lhs).append( i, j, values[i] );
599  reset( values[i] );
600  }
601 
602  reset( valid [i] );
603  }
604  }
605 
606  nonzeros = 0UL;
607  minIndex = inf;
608  maxIndex = 0UL;
609  }
610 
611  (~lhs).finalize( j );
612  }
613  }
615  //**********************************************************************************************
616 
617  //**Restructuring assignment to row-major matrices**********************************************
632  template< typename MT > // Type of the target matrix
634  assign( Matrix<MT,false>& lhs, const TSMatTSMatMultExpr& rhs )
635  {
637 
639 
640  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
641  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
642 
643  assign( ~lhs, trans( rhs.lhs_ ) * trans( rhs.rhs_ ) );
644  }
646  //**********************************************************************************************
647 
648  //**Addition assignment to dense matrices*******************************************************
661  template< typename MT // Type of the target dense matrix
662  , bool SO > // Storage order of the target dense matarix
664  addAssign( DenseMatrix<MT,SO>& lhs, const TSMatTSMatMultExpr& rhs )
665  {
667 
668  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
669  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
670 
671  CT1 A( serial( rhs.lhs_ ) ); // Evaluation of the left-hand side sparse matrix operand
672  CT2 B( serial( rhs.rhs_ ) ); // Evaluation of the right-hand side sparse matrix operand
673 
674  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.lhs_.rows() , "Invalid number of rows" );
675  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.lhs_.columns(), "Invalid number of columns" );
676  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
677  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
678  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
679  BLAZE_INTERNAL_ASSERT( B.columns() == (~lhs).columns() , "Invalid number of columns" );
680 
681  TSMatTSMatMultExpr::selectAddAssignKernel( ~lhs, A, B );
682  }
684  //**********************************************************************************************
685 
686  //**Default addition assignment to dense matrices***********************************************
700  template< typename MT3 // Type of the left-hand side target matrix
701  , typename MT4 // Type of the left-hand side matrix operand
702  , typename MT5 > // Type of the right-hand side matrix operand
703  static inline void selectAddAssignKernel( MT3& C, const MT4& A, const MT5& B )
704  {
705  typedef ConstIterator_<MT4> LeftIterator;
706  typedef ConstIterator_<MT5> RightIterator;
707 
708  for( size_t j=0UL; j<C.columns(); ++j ) {
709  const RightIterator rend( B.end(j) );
710  for( RightIterator relem=B.begin(j); relem!=rend; ++relem ) {
711  const LeftIterator lend( A.end( relem->index() ) );
712  for( LeftIterator lelem=A.begin( relem->index() ); lelem!=lend; ++lelem ) {
713  C(lelem->index(),j) += lelem->value() * relem->value();
714  }
715  }
716  }
717  }
719  //**********************************************************************************************
720 
721  //**Restructuring addition assignment to row-major matrices*************************************
736  template< typename MT > // Type of the target matrix
738  addAssign( Matrix<MT,false>& lhs, const TSMatTSMatMultExpr& rhs )
739  {
741 
743 
744  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
745  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
746 
747  addAssign( ~lhs, trans( rhs.lhs_ ) * trans( rhs.rhs_ ) );
748  }
750  //**********************************************************************************************
751 
752  //**Addition assignment to sparse matrices******************************************************
753  // No special implementation for the addition assignment to sparse matrices.
754  //**********************************************************************************************
755 
756  //**Subtraction assignment to dense matrices****************************************************
769  template< typename MT // Type of the target dense matrix
770  , bool SO > // Storage order of the target dense matarix
772  subAssign( DenseMatrix<MT,SO>& lhs, const TSMatTSMatMultExpr& rhs )
773  {
775 
776  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
777  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
778 
779  CT1 A( serial( rhs.lhs_ ) ); // Evaluation of the left-hand side sparse matrix operand
780  CT2 B( serial( rhs.rhs_ ) ); // Evaluation of the right-hand side sparse matrix operand
781 
782  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.lhs_.rows() , "Invalid number of rows" );
783  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.lhs_.columns(), "Invalid number of columns" );
784  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
785  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
786  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
787  BLAZE_INTERNAL_ASSERT( B.columns() == (~lhs).columns() , "Invalid number of columns" );
788 
789  TSMatTSMatMultExpr::selectSubAssignKernel( ~lhs, A, B );
790  }
792  //**********************************************************************************************
793 
794  //**Default subtraction assignment to dense matrices********************************************
808  template< typename MT3 // Type of the left-hand side target matrix
809  , typename MT4 // Type of the left-hand side matrix operand
810  , typename MT5 > // Type of the right-hand side matrix operand
811  static inline void selectSubAssignKernel( MT3& C, const MT4& A, const MT5& B )
812  {
813  typedef ConstIterator_<MT4> LeftIterator;
814  typedef ConstIterator_<MT5> RightIterator;
815 
816  for( size_t j=0UL; j<C.columns(); ++j ) {
817  const RightIterator rend( B.end(j) );
818  for( RightIterator relem=B.begin(j); relem!=rend; ++relem ) {
819  const LeftIterator lend( A.end( relem->index() ) );
820  for( LeftIterator lelem=A.begin( relem->index() ); lelem!=lend; ++lelem ) {
821  C(lelem->index(),j) -= lelem->value() * relem->value();
822  }
823  }
824  }
825  }
827  //**********************************************************************************************
828 
829  //**Restructuring subtraction assignment to row-major matrices**********************************
845  template< typename MT > // Type of the target matrix
847  subAssign( Matrix<MT,false>& lhs, const TSMatTSMatMultExpr& rhs )
848  {
850 
852 
853  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
854  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
855 
856  subAssign( ~lhs, trans( rhs.lhs_ ) * trans( rhs.rhs_ ) );
857  }
859  //**********************************************************************************************
860 
861  //**Subtraction assignment to sparse matrices***************************************************
862  // No special implementation for the subtraction assignment to sparse matrices.
863  //**********************************************************************************************
864 
865  //**Multiplication assignment to dense matrices*************************************************
866  // No special implementation for the multiplication assignment to dense matrices.
867  //**********************************************************************************************
868 
869  //**Multiplication assignment to sparse matrices************************************************
870  // No special implementation for the multiplication assignment to sparse matrices.
871  //**********************************************************************************************
872 
873  //**SMP assignment to matrices******************************************************************
889  template< typename MT // Type of the target matrix
890  , bool SO > // Storage order of the target matrix
892  smpAssign( Matrix<MT,SO>& lhs, const TSMatTSMatMultExpr& rhs )
893  {
895 
896  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
897  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
898 
899  CT1 A( rhs.lhs_ ); // Evaluation of the left-hand side sparse matrix operand
900  CT2 B( rhs.rhs_ ); // Evaluation of the right-hand side sparse matrix operand
901 
902  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.lhs_.rows() , "Invalid number of rows" );
903  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.lhs_.columns(), "Invalid number of columns" );
904  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
905  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
906  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
907  BLAZE_INTERNAL_ASSERT( B.columns() == (~lhs).columns() , "Invalid number of columns" );
908 
909  smpAssign( ~lhs, A * B );
910  }
912  //**********************************************************************************************
913 
914  //**Restructuring SMP assignment to row-major matrices******************************************
929  template< typename MT > // Type of the target matrix
931  smpAssign( Matrix<MT,false>& lhs, const TSMatTSMatMultExpr& rhs )
932  {
934 
936 
937  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
938  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
939 
940  smpAssign( ~lhs, trans( rhs.lhs_ ) * trans( rhs.rhs_ ) );
941  }
943  //**********************************************************************************************
944 
945  //**SMP addition assignment to dense matrices***************************************************
961  template< typename MT // Type of the target dense matrix
962  , bool SO > // Storage order of the target dense matarix
965  {
967 
968  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
969  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
970 
971  CT1 A( rhs.lhs_ ); // Evaluation of the left-hand side sparse matrix operand
972  CT2 B( rhs.rhs_ ); // Evaluation of the right-hand side sparse matrix operand
973 
974  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.lhs_.rows() , "Invalid number of rows" );
975  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.lhs_.columns(), "Invalid number of columns" );
976  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
977  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
978  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
979  BLAZE_INTERNAL_ASSERT( B.columns() == (~lhs).columns() , "Invalid number of columns" );
980 
981  smpAddAssign( ~lhs, A * B );
982  }
984  //**********************************************************************************************
985 
986  //**Restructuring SMP addition assignment to row-major matrices*********************************
1002  template< typename MT > // Type of the target matrix
1005  {
1007 
1009 
1010  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
1011  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
1012 
1013  smpAddAssign( ~lhs, trans( rhs.lhs_ ) * trans( rhs.rhs_ ) );
1014  }
1016  //**********************************************************************************************
1017 
1018  //**SMP addition assignment to sparse matrices**************************************************
1019  // No special implementation for the SMP addition assignment to sparse matrices.
1020  //**********************************************************************************************
1021 
1022  //**SMP subtraction assignment to dense matrices************************************************
1038  template< typename MT // Type of the target dense matrix
1039  , bool SO > // Storage order of the target dense matarix
1042  {
1044 
1045  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
1046  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
1047 
1048  CT1 A( rhs.lhs_ ); // Evaluation of the left-hand side sparse matrix operand
1049  CT2 B( rhs.rhs_ ); // Evaluation of the right-hand side sparse matrix operand
1050 
1051  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.lhs_.rows() , "Invalid number of rows" );
1052  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.lhs_.columns(), "Invalid number of columns" );
1053  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
1054  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
1055  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
1056  BLAZE_INTERNAL_ASSERT( B.columns() == (~lhs).columns() , "Invalid number of columns" );
1057 
1058  smpSubAssign( ~lhs, A * B );
1059  }
1061  //**********************************************************************************************
1062 
1063  //**Restructuring SMP subtraction assignment to row-major matrices******************************
1079  template< typename MT > // Type of the target matrix
1082  {
1084 
1086 
1087  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
1088  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
1089 
1090  smpSubAssign( ~lhs, trans( rhs.lhs_ ) * trans( rhs.rhs_ ) );
1091  }
1093  //**********************************************************************************************
1094 
1095  //**SMP subtraction assignment to sparse matrices***********************************************
1096  // No special implementation for the SMP subtraction assignment to sparse matrices.
1097  //**********************************************************************************************
1098 
1099  //**SMP multiplication assignment to dense matrices*********************************************
1100  // No special implementation for the SMP multiplication assignment to dense matrices.
1101  //**********************************************************************************************
1102 
1103  //**SMP multiplication assignment to sparse matrices********************************************
1104  // No special implementation for the SMP multiplication assignment to sparse matrices.
1105  //**********************************************************************************************
1106 
1107  //**Compile time checks*************************************************************************
1115  //**********************************************************************************************
1116 };
1117 //*************************************************************************************************
1118 
1119 
1120 
1121 
1122 //=================================================================================================
1123 //
1124 // GLOBAL BINARY ARITHMETIC OPERATORS
1125 //
1126 //=================================================================================================
1127 
1128 //*************************************************************************************************
1155 template< typename T1 // Type of the left-hand side sparse matrix
1156  , typename T2 > // Type of the right-hand side sparse matrix
1157 inline const TSMatTSMatMultExpr<T1,T2>
1159 {
1161 
1162  if( (~lhs).columns() != (~rhs).rows() ) {
1163  BLAZE_THROW_INVALID_ARGUMENT( "Matrix sizes do not match" );
1164  }
1165 
1166  return TSMatTSMatMultExpr<T1,T2>( ~lhs, ~rhs );
1167 }
1168 //*************************************************************************************************
1169 
1170 
1171 
1172 
1173 //=================================================================================================
1174 //
1175 // ROWS SPECIALIZATIONS
1176 //
1177 //=================================================================================================
1178 
1179 //*************************************************************************************************
1181 template< typename MT1, typename MT2 >
1182 struct Rows< TSMatTSMatMultExpr<MT1,MT2> > : public Rows<MT1>
1183 {};
1185 //*************************************************************************************************
1186 
1187 
1188 
1189 
1190 //=================================================================================================
1191 //
1192 // COLUMNS SPECIALIZATIONS
1193 //
1194 //=================================================================================================
1195 
1196 //*************************************************************************************************
1198 template< typename MT1, typename MT2 >
1199 struct Columns< TSMatTSMatMultExpr<MT1,MT2> > : public Columns<MT2>
1200 {};
1202 //*************************************************************************************************
1203 
1204 
1205 
1206 
1207 //=================================================================================================
1208 //
1209 // ISLOWER SPECIALIZATIONS
1210 //
1211 //=================================================================================================
1212 
1213 //*************************************************************************************************
1215 template< typename MT1, typename MT2 >
1216 struct IsLower< TSMatTSMatMultExpr<MT1,MT2> >
1217  : public BoolConstant< And< IsLower<MT1>, IsLower<MT2> >::value >
1218 {};
1220 //*************************************************************************************************
1221 
1222 
1223 
1224 
1225 //=================================================================================================
1226 //
1227 // ISUNILOWER SPECIALIZATIONS
1228 //
1229 //=================================================================================================
1230 
1231 //*************************************************************************************************
1233 template< typename MT1, typename MT2 >
1234 struct IsUniLower< TSMatTSMatMultExpr<MT1,MT2> >
1235  : public BoolConstant< And< IsUniLower<MT1>, IsUniLower<MT2> >::value >
1236 {};
1238 //*************************************************************************************************
1239 
1240 
1241 
1242 
1243 //=================================================================================================
1244 //
1245 // ISSTRICTLYLOWER SPECIALIZATIONS
1246 //
1247 //=================================================================================================
1248 
1249 //*************************************************************************************************
1251 template< typename MT1, typename MT2 >
1252 struct IsStrictlyLower< TSMatTSMatMultExpr<MT1,MT2> >
1253  : public BoolConstant< Or< And< IsStrictlyLower<MT1>, IsLower<MT2> >
1254  , And< IsStrictlyLower<MT2>, IsLower<MT1> > >::value >
1255 {};
1257 //*************************************************************************************************
1258 
1259 
1260 
1261 
1262 //=================================================================================================
1263 //
1264 // ISUPPER SPECIALIZATIONS
1265 //
1266 //=================================================================================================
1267 
1268 //*************************************************************************************************
1270 template< typename MT1, typename MT2 >
1271 struct IsUpper< TSMatTSMatMultExpr<MT1,MT2> >
1272  : public BoolConstant< And< IsUpper<MT1>, IsUpper<MT2> >::value >
1273 {};
1275 //*************************************************************************************************
1276 
1277 
1278 
1279 
1280 //=================================================================================================
1281 //
1282 // ISUNIUPPER SPECIALIZATIONS
1283 //
1284 //=================================================================================================
1285 
1286 //*************************************************************************************************
1288 template< typename MT1, typename MT2 >
1289 struct IsUniUpper< TSMatTSMatMultExpr<MT1,MT2> >
1290  : public BoolConstant< And< IsUniUpper<MT1>, IsUniUpper<MT2> >::value >
1291 {};
1293 //*************************************************************************************************
1294 
1295 
1296 
1297 
1298 //=================================================================================================
1299 //
1300 // ISSTRICTLYUPPER SPECIALIZATIONS
1301 //
1302 //=================================================================================================
1303 
1304 //*************************************************************************************************
1306 template< typename MT1, typename MT2 >
1307 struct IsStrictlyUpper< TSMatTSMatMultExpr<MT1,MT2> >
1308  : public BoolConstant< Or< And< IsStrictlyUpper<MT1>, IsUpper<MT2> >
1309  , And< IsStrictlyUpper<MT2>, IsUpper<MT1> > >::value >
1310 {};
1312 //*************************************************************************************************
1313 
1314 
1315 
1316 
1317 //=================================================================================================
1318 //
1319 // EXPRESSION TRAIT SPECIALIZATIONS
1320 //
1321 //=================================================================================================
1322 
1323 //*************************************************************************************************
1325 template< typename MT1, typename MT2, typename VT >
1326 struct TSMatDVecMultExprTrait< TSMatTSMatMultExpr<MT1,MT2>, VT >
1327 {
1328  public:
1329  //**********************************************************************************************
1334  , INVALID_TYPE >;
1335  //**********************************************************************************************
1336 };
1338 //*************************************************************************************************
1339 
1340 
1341 //*************************************************************************************************
1343 template< typename MT1, typename MT2, typename VT >
1344 struct TSMatSVecMultExprTrait< TSMatTSMatMultExpr<MT1,MT2>, VT >
1345 {
1346  public:
1347  //**********************************************************************************************
1352  , INVALID_TYPE >;
1353  //**********************************************************************************************
1354 };
1356 //*************************************************************************************************
1357 
1358 
1359 //*************************************************************************************************
1361 template< typename VT, typename MT1, typename MT2 >
1362 struct TDVecTSMatMultExprTrait< VT, TSMatTSMatMultExpr<MT1,MT2> >
1363 {
1364  public:
1365  //**********************************************************************************************
1370  , INVALID_TYPE >;
1371  //**********************************************************************************************
1372 };
1374 //*************************************************************************************************
1375 
1376 
1377 //*************************************************************************************************
1379 template< typename VT, typename MT1, typename MT2 >
1380 struct TSVecTSMatMultExprTrait< VT, TSMatTSMatMultExpr<MT1,MT2> >
1381 {
1382  public:
1383  //**********************************************************************************************
1388  , INVALID_TYPE >;
1389  //**********************************************************************************************
1390 };
1392 //*************************************************************************************************
1393 
1394 
1395 //*************************************************************************************************
1397 template< typename MT1, typename MT2, bool AF >
1398 struct SubmatrixExprTrait< TSMatTSMatMultExpr<MT1,MT2>, AF >
1399 {
1400  public:
1401  //**********************************************************************************************
1404  //**********************************************************************************************
1405 };
1407 //*************************************************************************************************
1408 
1409 
1410 //*************************************************************************************************
1412 template< typename MT1, typename MT2 >
1413 struct RowExprTrait< TSMatTSMatMultExpr<MT1,MT2> >
1414 {
1415  public:
1416  //**********************************************************************************************
1417  using Type = MultExprTrait_< RowExprTrait_<const MT1>, MT2 >;
1418  //**********************************************************************************************
1419 };
1421 //*************************************************************************************************
1422 
1423 
1424 //*************************************************************************************************
1426 template< typename MT1, typename MT2 >
1427 struct ColumnExprTrait< TSMatTSMatMultExpr<MT1,MT2> >
1428 {
1429  public:
1430  //**********************************************************************************************
1432  //**********************************************************************************************
1433 };
1435 //*************************************************************************************************
1436 
1437 } // namespace blaze
1438 
1439 #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
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.
Header file for mathematical functions.
size_t rows() const noexcept
Returns the current number of rows of the matrix.
Definition: TSMatTSMatMultExpr.h:283
Header file for the Rows type trait.
Header file for the UNUSED_PARAMETER function template.
TSMatTSMatMultExpr(const MT1 &lhs, const MT2 &rhs) noexcept
Constructor for the TSMatTSMatMultExpr class.
Definition: TSMatTSMatMultExpr.h:204
Header file for the IsUniUpper type trait.
OppositeType_< ResultType > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: TSMatTSMatMultExpr.h:179
const ElementType ReturnType
Return type for expression template evaluations.
Definition: TSMatTSMatMultExpr.h:182
Compile time check for triangular matrix types.This type trait tests whether or not the given templat...
Definition: IsTriangular.h:87
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.
If_< IsExpression< MT1 >, const MT1, const MT1 &> LeftOperand
Composite type of the left-hand side sparse matrix expression.
Definition: TSMatTSMatMultExpr.h:186
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.
BLAZE_ALWAYS_INLINE MT::Iterator begin(Matrix< MT, SO > &matrix, size_t i)
Returns an iterator to the first element of row/column i.
Definition: Matrix.h:194
Header file for the IsColumnMajorMatrix type trait.
If_< IsExpression< MT2 >, const MT2, const MT2 &> RightOperand
Composite type of the right-hand side sparse matrix expression.
Definition: TSMatTSMatMultExpr.h:189
void reset(const DiagonalProxy< MT > &proxy)
Resetting the represented element to the default initial values.
Definition: DiagonalProxy.h:533
Header file for the TSVecTSMatMultExprTrait class template.
LeftOperand leftOperand() const noexcept
Returns the left-hand side transpose sparse matrix operand.
Definition: TSMatTSMatMultExpr.h:325
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.
const ElementType_< MT > min(const DenseMatrix< MT, SO > &dm)
Returns the smallest element of the dense matrix.
Definition: DenseMatrix.h:1755
Compile time check for lower triangular matrices.This type trait tests whether or not the given templ...
Definition: IsLower.h:88
const DMatSerialExpr< MT, SO > serial(const DenseMatrix< MT, SO > &dm)
Forces the serial evaluation of the given dense matrix expression dm.
Definition: DMatSerialExpr.h:721
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.
ElementType_< ResultType > ElementType
Resulting element type.
Definition: TSMatTSMatMultExpr.h:181
Compile time check for upper triangular matrices.This type trait tests whether or not the given templ...
Definition: IsUpper.h:88
Header file for the RequiresEvaluation type trait.
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
const ElementType_< MT > max(const DenseMatrix< MT, SO > &dm)
Returns the largest element of the dense matrix.
Definition: DenseMatrix.h:1802
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
bool canSMPAssign() const noexcept
Returns whether the expression can be used in SMP assignments.
Definition: TSMatTSMatMultExpr.h:369
Header file for the SparseMatrix base class.
Constraint on the data type.
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.
Compile time check to query the requirement to evaluate an expression.Via this type trait it is possi...
Definition: RequiresEvaluation.h:72
SubvectorExprTrait_< VT, unaligned > subvector(Vector< VT, TF > &vector, size_t index, size_t size)
Creating a view on a specific subvector of the given vector.
Definition: Subvector.h:152
typename T::CompositeType CompositeType_
Alias declaration for nested CompositeType type definitions.The CompositeType_ alias declaration prov...
Definition: Aliases.h:83
Compile time check for upper unitriangular matrices.This type trait tests whether or not the given te...
Definition: IsUniUpper.h:86
Header file for the DisableIf class template.
Compile time check for dense vector types.This type trait tests whether or not the given template par...
Definition: IsDenseVector.h:78
Header file for the multiplication trait.
Header file for the IsStrictlyUpper type trait.
Header file for the IsSymmetric type trait.
constexpr size_t nonZeros() const noexcept
Returns the number of non-zero elements in the sparse matrix.
Definition: TSMatTSMatMultExpr.h:303
Namespace of the Blaze C++ math library.
Definition: Blaze.h:57
Header file for the If class template.
size_t columns() const noexcept
Returns the current number of columns of the matrix.
Definition: TSMatTSMatMultExpr.h:293
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
Evaluation of the expression type of a dense vector/transpose sparse matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a dense vector/transpose sparse matrix multiplication. Given the transpose dense vector type VT and the column-major sparse matrix type MT, the nested type Type corresponds to the resulting expression type. In case either VT is not a transpose dense vector type or MT is not a column-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE.
Definition: TDVecTSMatMultExprTrait.h:79
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.
Numerical infinity for built-in data types.
RightOperand rhs_
Right-hand side sparse matrix of the multiplication expression.
Definition: TSMatTSMatMultExpr.h:377
typename T::ElementType ElementType_
Alias declaration for nested ElementType type definitions.The ElementType_ alias declaration provides...
Definition: Aliases.h:163
Expression object for transpose sparse matrix-transpose sparse matrix multiplications.The TSMatTSMatMultExpr class represents the compile time expression for multiplications between two column-major sparse matrices.
Definition: Forward.h:158
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.
Compile time check for diagonal matrices.This type trait tests whether or not the given template para...
Definition: IsDiagonal.h:90
LeftOperand lhs_
Left-hand side sparse matrix of the multiplication expression.
Definition: TSMatTSMatMultExpr.h:376
typename TSMatDVecMultExprTrait< MT, VT >::Type TSMatDVecMultExprTrait_
Auxiliary alias declaration for the TSMatDVecMultExprTrait class template.The TSMatDVecMultExprTrait_...
Definition: TSMatDVecMultExprTrait.h:124
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
ReturnType at(size_t i, size_t j) const
Checked access to the matrix elements.
Definition: TSMatTSMatMultExpr.h:267
Header file for the IsTriangular type trait.
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
BLAZE_ALWAYS_INLINE MT::Iterator end(Matrix< MT, SO > &matrix, size_t i)
Returns an iterator just past the last element of row/column i.
Definition: Matrix.h:260
Header file for the RowExprTrait class template.
Header file for all forward declarations for expression class templates.
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.
#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
bool canAlias(const T *alias) const noexcept
Returns whether the expression can alias with the given address alias.
Definition: TSMatTSMatMultExpr.h:347
TransposeType_< ResultType > TransposeType
Transpose type for expression template evaluations.
Definition: TSMatTSMatMultExpr.h:180
size_t nonZeros(size_t i) const noexcept
Returns the number of non-zero elements in the specified row.
Definition: TSMatTSMatMultExpr.h:314
Evaluation of the expression type of a transpose sparse matrix/sparse vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse matrix/sparse vector multiplication. Given the column-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 column-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: TSMatSVecMultExprTrait.h:79
CompositeType_< MT2 > CT2
Composite type of the right-hand side sparse matrix expression.
Definition: TSMatTSMatMultExpr.h:132
Compile time check for resizable data types.This type trait tests whether the given data type is a re...
Definition: IsResizable.h:75
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.
ResultType_< MT1 > RT1
Result type of the left-hand side sparse matrix expression.
Definition: TSMatTSMatMultExpr.h:129
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
Utility type for generic codes.
RightOperand rightOperand() const noexcept
Returns the right-hand side transpose sparse matrix operand.
Definition: TSMatTSMatMultExpr.h:335
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 isAliased(const T *alias) const noexcept
Returns whether the expression is aliased with the given address alias.
Definition: TSMatTSMatMultExpr.h:359
Header file for the reset shim.
#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
Header file for the isDefault shim.
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.
Constraints on the storage order of matrix types.
Header file for the RemoveReference type trait.
typename EnableIf< Condition, T >::Type EnableIf_
Auxiliary alias declaration for the EnableIf class template.The EnableIf_ alias declaration provides ...
Definition: EnableIf.h:223
ResultType_< MT2 > RT2
Result type of the right-hand side sparse matrix expression.
Definition: TSMatTSMatMultExpr.h:130
typename T::OppositeType OppositeType_
Alias declaration for nested OppositeType type definitions.The OppositeType_ alias declaration provid...
Definition: Aliases.h:243
Header file for the IsDenseVector type trait.
TSMatTSMatMultExpr< MT1, MT2 > This
Type of this TSMatTSMatMultExpr instance.
Definition: TSMatTSMatMultExpr.h:177
Compile time check for strictly lower triangular matrices.This type trait tests whether or not the gi...
Definition: IsStrictlyLower.h:86
typename T::ConstIterator ConstIterator_
Alias declaration for nested ConstIterator type definitions.The ConstIterator_ alias declaration prov...
Definition: Aliases.h:103
const ResultType CompositeType
Data type for composite expression templates.
Definition: TSMatTSMatMultExpr.h:183
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.
Evaluation of the expression type of a transpose sparse matrix/dense vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse matrix/dense vector multiplication. Given the column-major sparse matrix type MT and the non-transpose dense vector type VT, the nested type Type corresponds to the resulting expression type. In case either MT is not a column-major sparse matrix type or VT is not a non-transpose dense vector type, the resulting data type Type is set to INVALID_TYPE.
Definition: TSMatDVecMultExprTrait.h:81
Header file for the IsBuiltin type trait.
MultTrait_< RT1, RT2 > ResultType
Result type for expression template evaluations.
Definition: TSMatTSMatMultExpr.h:178
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: TSMatTSMatMultExpr.h:219
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
constexpr Infinity inf
Global Infinity instance.The blaze::inf instance can be used wherever a built-in data type is expecte...
Definition: Infinity.h:1073
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
typename TSVecTSMatMultExprTrait< VT, MT >::Type TSVecTSMatMultExprTrait_
Auxiliary alias declaration for the TSVecTSMatMultExprTrait class template.The TSVecTSMatMultExprTrai...
Definition: TSVecTSMatMultExprTrait.h:124
bool isDefault(const DiagonalProxy< MT > &proxy)
Returns whether the represented element is in default state.
Definition: DiagonalProxy.h:573
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
Header file for the IsColumnVector type trait.
Constraint on the data type.
Header file for the IsResizable type trait.
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
Evaluation of the expression type of a sparse vector/transpose sparse matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector/transpose sparse matrix multiplication. Given the transpose sparse vector type VT and the column-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 column-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE.
Definition: TSVecTSMatMultExprTrait.h:81
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.
CompositeType_< MT1 > CT1
Composite type of the left-hand side sparse matrix expression.
Definition: TSMatTSMatMultExpr.h:131