TSMatTSMatAddExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_TSMATTSMATADDEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_TSMATTSMATADDEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <blaze/math/Aliases.h>
50 #include <blaze/math/Exception.h>
72 #include <blaze/util/Assert.h>
73 #include <blaze/util/DisableIf.h>
74 #include <blaze/util/EnableIf.h>
76 #include <blaze/util/mpl/And.h>
77 #include <blaze/util/mpl/If.h>
78 #include <blaze/util/mpl/Maximum.h>
79 #include <blaze/util/mpl/Or.h>
80 #include <blaze/util/Types.h>
82 
83 
84 namespace blaze {
85 
86 //=================================================================================================
87 //
88 // CLASS TSMATTSMATADDEXPR
89 //
90 //=================================================================================================
91 
92 //*************************************************************************************************
99 template< typename MT1 // Type of the left-hand side sparse matrix
100  , typename MT2 > // Type of the right-hand side sparse matrix
101 class TSMatTSMatAddExpr
102  : public MatMatAddExpr< SparseMatrix< TSMatTSMatAddExpr<MT1,MT2>, true > >
103  , private Computation
104 {
105  private:
106  //**Type definitions****************************************************************************
113  //**********************************************************************************************
114 
115  //**Return type evaluation**********************************************************************
117 
122  enum : bool { returnExpr = !IsTemporary<RN1>::value && !IsTemporary<RN2>::value };
123 
126  //**********************************************************************************************
127 
128  //**Serial evaluation strategy******************************************************************
130 
135  template< typename T1, typename T2, typename T3 >
136  struct UseSymmetricKernel {
138  enum : bool { value = IsSymmetric<T2>::value && IsSymmetric<T3>::value };
139  };
141  //**********************************************************************************************
142 
143  //**Parallel evaluation strategy****************************************************************
145 
150  template< typename MT >
151  struct UseSMPAssign {
152  enum : bool { value = MT::smpAssignable };
153  };
155  //**********************************************************************************************
156 
157  public:
158  //**Type definitions****************************************************************************
164 
167 
169  using CompositeType = const ResultType;
170 
172  using LeftOperand = If_< IsExpression<MT1>, const MT1, const MT1& >;
173 
175  using RightOperand = If_< IsExpression<MT2>, const MT2, const MT2& >;
176  //**********************************************************************************************
177 
178  //**Compilation flags***************************************************************************
180  enum : bool { smpAssignable = false };
181  //**********************************************************************************************
182 
183  //**Constructor*********************************************************************************
189  explicit inline TSMatTSMatAddExpr( const MT1& lhs, const MT2& rhs ) noexcept
190  : lhs_( lhs ) // Left-hand side sparse matrix of the addition expression
191  , rhs_( rhs ) // Right-hand side sparse matrix of the addition expression
192  {
193  BLAZE_INTERNAL_ASSERT( lhs.rows() == rhs.rows() , "Invalid number of rows" );
194  BLAZE_INTERNAL_ASSERT( lhs.columns() == rhs.columns(), "Invalid number of columns" );
195  }
196  //**********************************************************************************************
197 
198  //**Access operator*****************************************************************************
205  inline ReturnType operator()( size_t i, size_t j ) const {
206  BLAZE_INTERNAL_ASSERT( i < lhs_.rows() , "Invalid row access index" );
207  BLAZE_INTERNAL_ASSERT( j < lhs_.columns(), "Invalid column access index" );
208  return lhs_(i,j) + rhs_(i,j);
209  }
210  //**********************************************************************************************
211 
212  //**At function*********************************************************************************
220  inline ReturnType at( size_t i, size_t j ) const {
221  if( i >= lhs_.rows() ) {
222  BLAZE_THROW_OUT_OF_RANGE( "Invalid row access index" );
223  }
224  if( j >= lhs_.columns() ) {
225  BLAZE_THROW_OUT_OF_RANGE( "Invalid column access index" );
226  }
227  return (*this)(i,j);
228  }
229  //**********************************************************************************************
230 
231  //**Rows function*******************************************************************************
236  inline size_t rows() const noexcept {
237  return lhs_.rows();
238  }
239  //**********************************************************************************************
240 
241  //**Columns function****************************************************************************
246  inline size_t columns() const noexcept {
247  return lhs_.columns();
248  }
249  //**********************************************************************************************
250 
251  //**NonZeros function***************************************************************************
256  inline size_t nonZeros() const {
257  return lhs_.nonZeros() + rhs_.nonZeros();
258  }
259  //**********************************************************************************************
260 
261  //**NonZeros function***************************************************************************
267  inline size_t nonZeros( size_t i ) const {
268  return lhs_.nonZeros(i) + rhs_.nonZeros(i);
269  }
270  //**********************************************************************************************
271 
272  //**Left operand access*************************************************************************
277  inline LeftOperand leftOperand() const noexcept {
278  return lhs_;
279  }
280  //**********************************************************************************************
281 
282  //**Right operand access************************************************************************
287  inline RightOperand rightOperand() const noexcept {
288  return rhs_;
289  }
290  //**********************************************************************************************
291 
292  //**********************************************************************************************
298  template< typename T >
299  inline bool canAlias( const T* alias ) const noexcept {
300  return ( lhs_.canAlias( alias ) || rhs_.canAlias( alias ) );
301  }
302  //**********************************************************************************************
303 
304  //**********************************************************************************************
310  template< typename T >
311  inline bool isAliased( const T* alias ) const noexcept {
312  return ( lhs_.isAliased( alias ) || rhs_.isAliased( alias ) );
313  }
314  //**********************************************************************************************
315 
316  private:
317  //**Member variables****************************************************************************
320  //**********************************************************************************************
321 
322  //**Assignment to dense matrices****************************************************************
335  template< typename MT // Type of the target dense matrix
336  , bool SO > // Storage order of the target dense matrix
337  friend inline void assign( DenseMatrix<MT,SO>& lhs, const TSMatTSMatAddExpr& rhs )
338  {
340 
341  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
342  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
343 
344  using RightIterator = ConstIterator_< RemoveReference_<CT2> >;
345 
346  assign( ~lhs, rhs.lhs_ );
347 
348  if( !IsResizable< ElementType_<MT> >::value ) {
349  addAssign( ~lhs, rhs.rhs_ );
350  }
351  else
352  {
353  CT2 B( serial( rhs.rhs_ ) ); // Evaluation of the right-hand side sparse matrix operand
354 
355  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
356  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
357  BLAZE_INTERNAL_ASSERT( B.rows() == (~lhs).rows() , "Invalid number of rows" );
358  BLAZE_INTERNAL_ASSERT( B.columns() == (~lhs).columns() , "Invalid number of columns" );
359 
360  for( size_t j=0UL; j<(~lhs).columns(); ++j ) {
361  const RightIterator end( B.end(j) );
362  for( RightIterator element=B.begin(j); element!=end; ++element ) {
363  if( isDefault( (~lhs)(element->index(),j) ) )
364  (~lhs)(element->index(),j) = element->value();
365  else
366  (~lhs)(element->index(),j) += element->value();
367  }
368  }
369  }
370  }
372  //**********************************************************************************************
373 
374  //**Assignment to row-major sparse matrices*****************************************************
387  template< typename MT > // Type of the target sparse matrix
389  assign( SparseMatrix<MT,false>& lhs, const TSMatTSMatAddExpr& rhs )
390  {
392 
394 
395  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
396  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
397 
398  using LeftIterator = ConstIterator_< RemoveReference_<CT1> >;
399  using RightIterator = ConstIterator_< RemoveReference_<CT2> >;
400 
401  CT1 A( serial( rhs.lhs_ ) ); // Evaluation of the left-hand side sparse matrix operand
402  CT2 B( serial( rhs.rhs_ ) ); // Evaluation of the right-hand side sparse matrix operand
403 
404  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.lhs_.rows() , "Invalid number of rows" );
405  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.lhs_.columns(), "Invalid number of columns" );
406  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
407  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
408  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
409  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).columns() , "Invalid number of columns" );
410 
411  const size_t m( rhs.rows() );
412  const size_t n( rhs.columns() );
413 
414  // Counting the number of elements per column
415  std::vector<size_t> nonzeros( m, 0UL );
416  for( size_t j=0UL; j<n; ++j )
417  {
418  const LeftIterator lend( A.end(j) );
419  const RightIterator rend( B.end(j) );
420 
421  LeftIterator l( A.begin(j) );
422  RightIterator r( B.begin(j) );
423 
424  while( l != lend && r != rend )
425  {
426  if( l->index() < r->index() ) {
427  ++nonzeros[l->index()];
428  ++l;
429  }
430  else if( l->index() > r->index() ) {
431  ++nonzeros[r->index()];
432  ++r;
433  }
434  else {
435  ++nonzeros[l->index()];
436  ++l;
437  ++r;
438  }
439  }
440 
441  while( l != lend ) {
442  ++nonzeros[l->index()];
443  ++l;
444  }
445 
446  while( r != rend ) {
447  ++nonzeros[r->index()];
448  ++r;
449  }
450  }
451 
452  // Resizing the left-hand side sparse matrix
453  for( size_t i=0UL; i<m; ++i ) {
454  (~lhs).reserve( i, nonzeros[i] );
455  }
456 
457  // Performing the matrix addition
458  for( size_t j=0UL; j<n; ++j )
459  {
460  const LeftIterator lend( A.end(j) );
461  const RightIterator rend( B.end(j) );
462 
463  LeftIterator l( A.begin(j) );
464  RightIterator r( B.begin(j) );
465 
466  while( l != lend && r != rend )
467  {
468  if( l->index() < r->index() ) {
469  (~lhs).append( l->index(), j, l->value() );
470  ++l;
471  }
472  else if( l->index() > r->index() ) {
473  (~lhs).append( r->index(), j, r->value() );
474  ++r;
475  }
476  else {
477  (~lhs).append( l->index(), j, l->value() + r->value() );
478  ++l;
479  ++r;
480  }
481  }
482 
483  while( l != lend ) {
484  (~lhs).append( l->index(), j, l->value() );
485  ++l;
486  }
487 
488  while( r != rend ) {
489  (~lhs).append( r->index(), j, r->value() );
490  ++r;
491  }
492  }
493  }
495  //**********************************************************************************************
496 
497  //**Assignment to row-major sparse matrices*****************************************************
510  template< typename MT > // Type of the target sparse matrix
512  assign( SparseMatrix<MT,false>& lhs, const TSMatTSMatAddExpr& rhs )
513  {
515 
517 
518  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
519  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
520 
521  assign( ~lhs, trans( rhs.lhs_ ) + trans( rhs.rhs_ ) );
522  }
524  //**********************************************************************************************
525 
526  //**Assignment to column-major sparse matrices**************************************************
539  template< typename MT > // Type of the target sparse matrix
540  friend inline void assign( SparseMatrix<MT,true>& lhs, const TSMatTSMatAddExpr& rhs )
541  {
543 
544  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
545  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
546 
547  using LeftIterator = ConstIterator_< RemoveReference_<CT1> >;
548  using RightIterator = ConstIterator_< RemoveReference_<CT2> >;
549 
550  CT1 A( serial( rhs.lhs_ ) ); // Evaluation of the left-hand side sparse matrix operand
551  CT2 B( serial( rhs.rhs_ ) ); // Evaluation of the right-hand side sparse matrix operand
552 
553  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.lhs_.rows() , "Invalid number of rows" );
554  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.lhs_.columns(), "Invalid number of columns" );
555  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
556  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
557  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
558  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).columns() , "Invalid number of columns" );
559 
560  // Final memory allocation (based on the evaluated operands)
561  (~lhs).reserve( A.nonZeros() + B.nonZeros() );
562 
563  // Performing the matrix addition
564  for( size_t j=0UL; j<(~lhs).columns(); ++j )
565  {
566  const LeftIterator lend( A.end(j) );
567  const RightIterator rend( B.end(j) );
568 
569  LeftIterator l( A.begin(j) );
570  RightIterator r( B.begin(j) );
571 
572  while( l != lend && r != rend )
573  {
574  if( l->index() < r->index() ) {
575  (~lhs).append( l->index(), j, l->value() );
576  ++l;
577  }
578  else if( l->index() > r->index() ) {
579  (~lhs).append( r->index(), j, r->value() );
580  ++r;
581  }
582  else {
583  (~lhs).append( l->index(), j, l->value() + r->value() );
584  ++l;
585  ++r;
586  }
587  }
588 
589  while( l != lend ) {
590  (~lhs).append( l->index(), j, l->value() );
591  ++l;
592  }
593 
594  while( r != rend ) {
595  (~lhs).append( r->index(), j, r->value() );
596  ++r;
597  }
598 
599  (~lhs).finalize( j );
600  }
601  }
603  //**********************************************************************************************
604 
605  //**Addition assignment to dense matrices*******************************************************
618  template< typename MT // Type of the target dense matrix
619  , bool SO > // Storage order of the target dense matrix
620  friend inline void addAssign( DenseMatrix<MT,SO>& lhs, const TSMatTSMatAddExpr& rhs )
621  {
623 
624  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
625  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
626 
627  addAssign( ~lhs, rhs.lhs_ );
628  addAssign( ~lhs, rhs.rhs_ );
629  }
631  //**********************************************************************************************
632 
633  //**Addition assignment to sparse matrices******************************************************
634  // No special implementation for the addition assignment to sparse matrices.
635  //**********************************************************************************************
636 
637  //**Subtraction assignment to dense matrices****************************************************
650  template< typename MT // Type of the target dense matrix
651  , bool SO > // Storage order of the target dense matrix
652  friend inline void subAssign( DenseMatrix<MT,SO>& lhs, const TSMatTSMatAddExpr& rhs )
653  {
655 
656  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
657  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
658 
659  subAssign( ~lhs, rhs.lhs_ );
660  subAssign( ~lhs, rhs.rhs_ );
661  }
663  //**********************************************************************************************
664 
665  //**Subtraction assignment to sparse matrices***************************************************
666  // No special implementation for the subtraction assignment to sparse matrices.
667  //**********************************************************************************************
668 
669  //**Schur product assignment to dense matrices**************************************************
682  template< typename MT // Type of the target dense matrix
683  , bool SO > // Storage order of the target dense matrix
684  friend inline void schurAssign( DenseMatrix<MT,SO>& lhs, const TSMatTSMatAddExpr& rhs )
685  {
687 
691 
692  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
693  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
694 
695  const ResultType tmp( serial( rhs ) );
696  schurAssign( ~lhs, tmp );
697  }
699  //**********************************************************************************************
700 
701  //**Schur product assignment to sparse matrices*************************************************
702  // No special implementation for the Schur product assignment to sparse matrices.
703  //**********************************************************************************************
704 
705  //**Multiplication assignment to dense matrices*************************************************
706  // No special implementation for the multiplication assignment to dense matrices.
707  //**********************************************************************************************
708 
709  //**Multiplication assignment to sparse matrices************************************************
710  // No special implementation for the multiplication assignment to sparse matrices.
711  //**********************************************************************************************
712 
713  //**SMP assignment to dense matrices************************************************************
714  // No special implementation for the SMP assignment to dense matrices.
715  //**********************************************************************************************
716 
717  //**SMP assignment to sparse matrices***********************************************************
718  // No special implementation for the SMP assignment to sparse matrices.
719  //**********************************************************************************************
720 
721  //**SMP addition assignment to dense matrices***************************************************
736  template< typename MT // Type of the target dense matrix
737  , bool SO > // Storage order of the target dense matrix
738  friend inline EnableIf_< UseSMPAssign<MT> >
740  {
742 
743  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
744  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
745 
746  smpAddAssign( ~lhs, rhs.lhs_ );
747  smpAddAssign( ~lhs, rhs.rhs_ );
748  }
750  //**********************************************************************************************
751 
752  //**SMP addition assignment to sparse matrices**************************************************
753  // No special implementation for the SMP addition assignment to sparse matrices.
754  //**********************************************************************************************
755 
756  //**SMP subtraction assignment to dense matrices************************************************
771  template< typename MT // Type of the target dense matrix
772  , bool SO > // Storage order of the target dense matrix
773  friend inline EnableIf_< UseSMPAssign<MT> >
775  {
777 
778  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
779  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
780 
781  smpSubAssign( ~lhs, rhs.lhs_ );
782  smpSubAssign( ~lhs, rhs.rhs_ );
783  }
785  //**********************************************************************************************
786 
787  //**SMP subtraction assignment to sparse matrices***********************************************
788  // No special implementation for the SMP subtraction assignment to sparse matrices.
789  //**********************************************************************************************
790 
791  //**SMP Schur product assignment to dense matrices**********************************************
807  template< typename MT // Type of the target dense matrix
808  , bool SO > // Storage order of the target dense matrix
809  friend inline EnableIf_< UseSMPAssign<MT> >
811  {
813 
817 
818  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
819  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
820 
821  const ResultType tmp( rhs );
822  smpSchurAssign( ~lhs, tmp );
823  }
825  //**********************************************************************************************
826 
827  //**SMP Schur product assignment to sparse matrices*********************************************
828  // No special implementation for the SMP Schur product assignment to sparse matrices.
829  //**********************************************************************************************
830 
831  //**SMP multiplication assignment to dense matrices*********************************************
832  // No special implementation for the SMP multiplication assignment to dense matrices.
833  //**********************************************************************************************
834 
835  //**SMP multiplication assignment to sparse matrices********************************************
836  // No special implementation for the SMP multiplication assignment to sparse matrices.
837  //**********************************************************************************************
838 
839  //**Compile time checks*************************************************************************
847  //**********************************************************************************************
848 };
849 //*************************************************************************************************
850 
851 
852 
853 
854 //=================================================================================================
855 //
856 // GLOBAL BINARY ARITHMETIC OPERATORS
857 //
858 //=================================================================================================
859 
860 //*************************************************************************************************
886 template< typename MT1 // Type of the left-hand side sparse matrix
887  , typename MT2 > // Type of the right-hand side sparse matrix
888 inline decltype(auto)
889  operator+( const SparseMatrix<MT1,true>& lhs, const SparseMatrix<MT2,true>& rhs )
890 {
892 
893  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() ) {
894  BLAZE_THROW_INVALID_ARGUMENT( "Matrix sizes do not match" );
895  }
896 
898  return ReturnType( ~lhs, ~rhs );
899 }
900 //*************************************************************************************************
901 
902 
903 
904 
905 //=================================================================================================
906 //
907 // SIZE SPECIALIZATIONS
908 //
909 //=================================================================================================
910 
911 //*************************************************************************************************
913 template< typename MT1, typename MT2 >
914 struct Size< TSMatTSMatAddExpr<MT1,MT2>, 0UL >
915  : public Maximum< Size<MT1,0UL>, Size<MT2,0UL> >
916 {};
917 
918 template< typename MT1, typename MT2 >
919 struct Size< TSMatTSMatAddExpr<MT1,MT2>, 1UL >
920  : public Maximum< Size<MT1,1UL>, Size<MT2,1UL> >
921 {};
923 //*************************************************************************************************
924 
925 
926 
927 
928 //=================================================================================================
929 //
930 // ISSYMMETRIC SPECIALIZATIONS
931 //
932 //=================================================================================================
933 
934 //*************************************************************************************************
936 template< typename MT1, typename MT2 >
937 struct IsSymmetric< TSMatTSMatAddExpr<MT1,MT2> >
938  : public And< IsSymmetric<MT1>, IsSymmetric<MT2> >
939 {};
941 //*************************************************************************************************
942 
943 
944 
945 
946 //=================================================================================================
947 //
948 // ISHERMITIAN SPECIALIZATIONS
949 //
950 //=================================================================================================
951 
952 //*************************************************************************************************
954 template< typename MT1, typename MT2 >
955 struct IsHermitian< TSMatTSMatAddExpr<MT1,MT2> >
956  : public And< IsHermitian<MT1>, IsHermitian<MT2> >
957 {};
959 //*************************************************************************************************
960 
961 
962 
963 
964 //=================================================================================================
965 //
966 // ISLOWER SPECIALIZATIONS
967 //
968 //=================================================================================================
969 
970 //*************************************************************************************************
972 template< typename MT1, typename MT2 >
973 struct IsLower< TSMatTSMatAddExpr<MT1,MT2> >
974  : public And< IsLower<MT1>, IsLower<MT2> >
975 {};
977 //*************************************************************************************************
978 
979 
980 
981 
982 //=================================================================================================
983 //
984 // ISUNILOWER SPECIALIZATIONS
985 //
986 //=================================================================================================
987 
988 //*************************************************************************************************
990 template< typename MT1, typename MT2 >
991 struct IsUniLower< TSMatTSMatAddExpr<MT1,MT2> >
992  : public Or< And< IsUniLower<MT1>, IsStrictlyLower<MT2> >
993  , And< IsUniLower<MT2>, IsStrictlyLower<MT1> > >
994 {};
996 //*************************************************************************************************
997 
998 
999 
1000 
1001 //=================================================================================================
1002 //
1003 // ISSTRICTLYLOWER SPECIALIZATIONS
1004 //
1005 //=================================================================================================
1006 
1007 //*************************************************************************************************
1009 template< typename MT1, typename MT2 >
1010 struct IsStrictlyLower< TSMatTSMatAddExpr<MT1,MT2> >
1011  : public And< IsStrictlyLower<MT1>, IsStrictlyLower<MT2> >
1012 {};
1014 //*************************************************************************************************
1015 
1016 
1017 
1018 
1019 //=================================================================================================
1020 //
1021 // ISUPPER SPECIALIZATIONS
1022 //
1023 //=================================================================================================
1024 
1025 //*************************************************************************************************
1027 template< typename MT1, typename MT2 >
1028 struct IsUpper< TSMatTSMatAddExpr<MT1,MT2> >
1029  : public And< IsUpper<MT1>, IsUpper<MT2> >
1030 {};
1032 //*************************************************************************************************
1033 
1034 
1035 
1036 
1037 //=================================================================================================
1038 //
1039 // ISUNIUPPER SPECIALIZATIONS
1040 //
1041 //=================================================================================================
1042 
1043 //*************************************************************************************************
1045 template< typename MT1, typename MT2 >
1046 struct IsUniUpper< TSMatTSMatAddExpr<MT1,MT2> >
1047  : public Or< And< IsUniUpper<MT1>, IsStrictlyUpper<MT2> >
1048  , And< IsUniUpper<MT2>, IsStrictlyUpper<MT1> > >
1049 {};
1051 //*************************************************************************************************
1052 
1053 
1054 
1055 
1056 //=================================================================================================
1057 //
1058 // ISSTRICTLYUPPER SPECIALIZATIONS
1059 //
1060 //=================================================================================================
1061 
1062 //*************************************************************************************************
1064 template< typename MT1, typename MT2 >
1065 struct IsStrictlyUpper< TSMatTSMatAddExpr<MT1,MT2> >
1066  : public And< IsStrictlyUpper<MT1>, IsStrictlyUpper<MT2> >
1067 {};
1069 //*************************************************************************************************
1070 
1071 } // namespace blaze
1072 
1073 #endif
CompositeType_< MT2 > CT2
Composite type of the right-hand side sparse matrix expression.
Definition: TSMatTSMatAddExpr.h:112
#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
Header file for auxiliary alias declarations.
size_t nonZeros(size_t i) const
Returns the number of non-zero elements in the specified row.
Definition: TSMatTSMatAddExpr.h:267
const IfTrue_< returnExpr, ExprReturnType, ElementType > ReturnType
Return type for expression template evaluations.
Definition: TSMatTSMatAddExpr.h:166
Compile time check whether the given type is a temporary vector or matrix type.This type trait class ...
Definition: IsTemporary.h:69
Header file for the IsUniUpper type trait.
EnableIf_< IsDenseMatrix< MT1 > > smpSchurAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP Schur product assignment of a matrix to dense matrix.
Definition: DenseMatrix.h:196
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:164
Header file for the serial shim.
AddTrait_< RT1, RT2 > ResultType
Result type for expression template evaluations.
Definition: TSMatTSMatAddExpr.h:160
LeftOperand lhs_
Left-hand side sparse matrix of the addition expression.
Definition: TSMatTSMatAddExpr.h:318
typename DisableIf< Condition, T >::Type DisableIf_
Auxiliary type for the DisableIf class template.The DisableIf_ alias declaration provides a convenien...
Definition: DisableIf.h:224
Header file for the And class template.
Compile time value evaluation.The Maximum alias declaration selects the larger of the two given templ...
Definition: Maximum.h:73
Compile time check for lower triangular matrices.This type trait tests whether or not the given templ...
Definition: IsLower.h:87
If_< IsExpression< MT1 >, const MT1, const MT1 &> LeftOperand
Composite type of the left-hand side sparse matrix expression.
Definition: TSMatTSMatAddExpr.h:172
Header file for the AddExprTrait class template.
Header file for the Computation base class.
Compile time check for upper triangular matrices.This type trait tests whether or not the given templ...
Definition: IsUpper.h:87
Constraints on the storage order of matrix types.
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:343
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:133
TSMatTSMatAddExpr(const MT1 &lhs, const MT2 &rhs) noexcept
Constructor for the TSMatTSMatAddExpr class.
Definition: TSMatTSMatAddExpr.h:189
Base class for dense matrices.The DenseMatrix class is a base class for all dense matrix classes...
Definition: DenseMatrix.h:80
Base class for sparse matrices.The SparseMatrix class is a base class for all sparse matrix classes...
Definition: Forward.h:129
size_t nonZeros() const
Returns the number of non-zero elements in the sparse matrix.
Definition: TSMatTSMatAddExpr.h:256
typename IfTrue< Condition, T1, T2 >::Type IfTrue_
Auxiliary alias declaration for the IfTrue class template.The IfTrue_ alias declaration provides a co...
Definition: If.h:109
typename T::ReturnType ReturnType_
Alias declaration for nested ReturnType type definitions.The ReturnType_ alias declaration provides a...
Definition: Aliases.h:363
Header file for the SparseMatrix base class.
ElementType_< ResultType > ElementType
Resulting element type.
Definition: TSMatTSMatAddExpr.h:163
Constraint on the data type.
Header file for the Maximum class template.
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
If_< IsExpression< MT2 >, const MT2, const MT2 &> RightOperand
Composite type of the right-hand side sparse matrix expression.
Definition: TSMatTSMatAddExpr.h:175
const ResultType CompositeType
Data type for composite expression templates.
Definition: TSMatTSMatAddExpr.h:169
Header file for the DisableIf class template.
Header file for the IsTemporary type trait class.
Header file for the IsStrictlyUpper type trait.
Header file for the IsSymmetric type trait.
typename AddExprTrait< T1, T2 >::Type AddExprTrait_
Auxiliary alias declaration for the AddExprTrait class template.The AddExprTrait_ alias declaration p...
Definition: AddExprTrait.h:112
CompositeType_< MT1 > CT1
Composite type of the left-hand side sparse matrix expression.
Definition: TSMatTSMatAddExpr.h:111
Namespace of the Blaze C++ math library.
Definition: Blaze.h:58
bool canAlias(const T *alias) const noexcept
Returns whether the expression can alias with the given address alias.
Definition: TSMatTSMatAddExpr.h:299
Header file for the If class template.
size_t columns() const noexcept
Returns the current number of columns of the matrix.
Definition: TSMatTSMatAddExpr.h:246
#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
Expression object for transpose sparse matrix-transpose sparse matrix additions.The TSMatTSMatAddExpr...
Definition: Forward.h:169
RightOperand rhs_
Right-hand side sparse matrix of the addition expression.
Definition: TSMatTSMatAddExpr.h:319
Header file for the Or 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
typename T::ElementType ElementType_
Alias declaration for nested ElementType type definitions.The ElementType_ alias declaration provides...
Definition: Aliases.h:163
bool isAliased(const T *alias) const noexcept
Returns whether the expression is aliased with the given address alias.
Definition: TSMatTSMatAddExpr.h:311
ReturnType_< MT2 > RN2
Return type of the right-hand side sparse matrix expression.
Definition: TSMatTSMatAddExpr.h:110
Header file for the IsLower type trait.
Compile time check for symmetric matrices.This type trait tests whether or not the given template par...
Definition: IsSymmetric.h:85
OppositeType_< ResultType > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: TSMatTSMatAddExpr.h:161
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
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:430
#define BLAZE_CONSTRAINT_MUST_FORM_VALID_MATMATADDEXPR(T1, T2)
Constraint on the data type.In case the given data types T1 and T2 do not form a valid matrix/matrix ...
Definition: MatMatAddExpr.h:107
Constraint on the data type.
Header file for all forward declarations for expression class templates.
ReturnType_< MT1 > RN1
Return type of the left-hand side sparse matrix expression.
Definition: TSMatTSMatAddExpr.h:109
Header file for the EnableIf class template.
Header file for the IsStrictlyLower type trait.
AddExprTrait_< RN1, RN2 > ExprReturnType
Expression return type for the subscript operator.
Definition: TSMatTSMatAddExpr.h:125
Compile time check for lower unitriangular matrices.This type trait tests whether or not the given te...
Definition: IsUniLower.h:86
Compile time check for resizable data types.This type trait tests whether the given data type is a re...
Definition: IsResizable.h:75
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SYMMETRIC_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is a symmetric matrix type, a compilation error is created.
Definition: Symmetric.h:79
#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.
Header file for the addition trait.
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:154
Constraint on the data type.
size_t rows() const noexcept
Returns the current number of rows of the matrix.
Definition: TSMatTSMatAddExpr.h:236
#define BLAZE_FUNCTION_TRACE
Function trace macro.This macro can be used to reliably trace function calls. In case function tracin...
Definition: FunctionTrace.h:94
Header file for the isDefault shim.
Compile time check for Hermitian matrices.This type trait tests whether or not the given template par...
Definition: IsHermitian.h:85
Constraint on the data type.
ResultType_< MT2 > RT2
Result type of the right-hand side sparse matrix expression.
Definition: TSMatTSMatAddExpr.h:108
Constraints on the storage order of matrix types.
decltype(auto) serial(const DenseMatrix< MT, SO > &dm)
Forces the serial evaluation of the given dense matrix expression dm.
Definition: DMatSerialExpr.h:816
#define BLAZE_CONSTRAINT_MUST_NOT_REQUIRE_EVALUATION(T)
Constraint on the data type.In case the given data type T requires an intermediate evaluation within ...
Definition: RequiresEvaluation.h:81
Header file for the MatMatAddExpr base class.
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:224
typename T::OppositeType OppositeType_
Alias declaration for nested OppositeType type definitions.The OppositeType_ alias declaration provid...
Definition: Aliases.h:263
Compile time check for strictly lower triangular matrices.This type trait tests whether or not the gi...
Definition: IsStrictlyLower.h:86
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:3080
typename T::ConstIterator ConstIterator_
Alias declaration for nested ConstIterator type definitions.The ConstIterator_ alias declaration prov...
Definition: Aliases.h:103
decltype(auto) trans(const DenseMatrix< MT, SO > &dm)
Calculation of the transpose of the given dense matrix.
Definition: DMatTransExpr.h:789
Header file for the IsComputation type trait class.
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: TSMatTSMatAddExpr.h:205
Compile time logical &#39;or&#39; evaluation.The Or alias declaration performs at compile time a logical &#39;or&#39;...
Definition: Or.h:76
Compile time evaluation of the size of vectors and matrices.The Size type trait evaluates the size of...
Definition: Size.h:80
TransposeType_< ResultType > TransposeType
Transpose type for expression template evaluations.
Definition: TSMatTSMatAddExpr.h:162
Compile time logical &#39;and&#39; evaluation.The And alias declaration performs at compile time a logical &#39;a...
Definition: And.h:76
ReturnType at(size_t i, size_t j) const
Checked access to the matrix elements.
Definition: TSMatTSMatAddExpr.h:220
bool isDefault(const DiagonalProxy< MT > &proxy)
Returns whether the represented element is in default state.
Definition: DiagonalProxy.h:628
RightOperand rightOperand() const noexcept
Returns the right-hand side transpose sparse matrix operand.
Definition: TSMatTSMatAddExpr.h:287
typename T::TransposeType TransposeType_
Alias declaration for nested TransposeType type definitions.The TransposeType_ alias declaration prov...
Definition: Aliases.h:423
Header file for the IsUpper type trait.
LeftOperand leftOperand() const noexcept
Returns the left-hand side transpose sparse matrix operand.
Definition: TSMatTSMatAddExpr.h:277
Header file for the IsHermitian type trait.
ResultType_< MT1 > RT1
Result type of the left-hand side sparse matrix expression.
Definition: TSMatTSMatAddExpr.h:107
Header file for the IsResizable type trait.
Header file for the Size type trait.
typename AddTrait< T1, T2 >::Type AddTrait_
Auxiliary alias declaration for the AddTrait class template.The AddTrait_ alias declaration provides ...
Definition: AddTrait.h:291
#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 function trace functionality.