TSMatSMatSchurExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_TSMATSMATSCHUREXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_TSMATSMATSCHUREXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <blaze/math/Aliases.h>
50 #include <blaze/math/Exception.h>
73 #include <blaze/util/Assert.h>
74 #include <blaze/util/DisableIf.h>
75 #include <blaze/util/EnableIf.h>
78 #include <blaze/util/mpl/And.h>
79 #include <blaze/util/mpl/If.h>
80 #include <blaze/util/mpl/Maximum.h>
81 #include <blaze/util/mpl/Or.h>
82 #include <blaze/util/Types.h>
84 #include <blaze/util/Unused.h>
85 
86 
87 namespace blaze {
88 
89 //=================================================================================================
90 //
91 // CLASS TSMATSMATSCHUREXPR
92 //
93 //=================================================================================================
94 
95 //*************************************************************************************************
102 template< typename MT1 // Type of the left-hand side sparse matrix
103  , typename MT2 > // Type of the right-hand side sparse matrix
104 class TSMatSMatSchurExpr
105  : public SchurExpr< SparseMatrix< TSMatSMatSchurExpr<MT1,MT2>, false > >
106  , private Computation
107 {
108  private:
109  //**Type definitions****************************************************************************
116  //**********************************************************************************************
117 
118  //**Return type evaluation**********************************************************************
120 
125  enum : bool { returnExpr = !IsTemporary<RN1>::value && !IsTemporary<RN2>::value };
126 
129  //**********************************************************************************************
130 
131  //**Serial evaluation strategy******************************************************************
133 
139  template< typename T1, typename T2 >
140  struct UseSymmetricKernel {
142  enum : bool { value = IsSymmetric<T2>::value };
143  };
145  //**********************************************************************************************
146 
147  public:
148  //**Type definitions****************************************************************************
154 
157 
159  using CompositeType = const ResultType;
160 
162  using LeftOperand = If_< IsExpression<MT1>, const MT1, const MT1& >;
163 
165  using RightOperand = If_< IsExpression<MT2>, const MT2, const MT2& >;
166  //**********************************************************************************************
167 
168  //**Compilation flags***************************************************************************
170  enum : bool { smpAssignable = false };
171  //**********************************************************************************************
172 
173  //**Constructor*********************************************************************************
179  explicit inline TSMatSMatSchurExpr( const MT1& lhs, const MT2& rhs ) noexcept
180  : lhs_( lhs ) // Left-hand side sparse matrix of the Schur product expression
181  , rhs_( rhs ) // Right-hand side sparse matrix of the Schur product expression
182  {
183  BLAZE_INTERNAL_ASSERT( lhs.rows() == rhs.rows() , "Invalid number of rows" );
184  BLAZE_INTERNAL_ASSERT( lhs.columns() == rhs.columns(), "Invalid number of columns" );
185  }
186  //**********************************************************************************************
187 
188  //**Access operator*****************************************************************************
195  inline ReturnType operator()( size_t i, size_t j ) const {
196  BLAZE_INTERNAL_ASSERT( i < lhs_.rows() , "Invalid row access index" );
197  BLAZE_INTERNAL_ASSERT( j < lhs_.columns(), "Invalid column access index" );
198  return lhs_(i,j) * rhs_(i,j);
199  }
200  //**********************************************************************************************
201 
202  //**At function*********************************************************************************
210  inline ReturnType at( size_t i, size_t j ) const {
211  if( i >= lhs_.rows() ) {
212  BLAZE_THROW_OUT_OF_RANGE( "Invalid row access index" );
213  }
214  if( j >= lhs_.columns() ) {
215  BLAZE_THROW_OUT_OF_RANGE( "Invalid column access index" );
216  }
217  return (*this)(i,j);
218  }
219  //**********************************************************************************************
220 
221  //**Rows function*******************************************************************************
226  inline size_t rows() const noexcept {
227  return lhs_.rows();
228  }
229  //**********************************************************************************************
230 
231  //**Columns function****************************************************************************
236  inline size_t columns() const noexcept {
237  return lhs_.columns();
238  }
239  //**********************************************************************************************
240 
241  //**NonZeros function***************************************************************************
246  inline size_t nonZeros() const {
247  return min( lhs_.nonZeros(), rhs_.nonZeros() );
248  }
249  //**********************************************************************************************
250 
251  //**NonZeros function***************************************************************************
257  inline size_t nonZeros( size_t i ) const {
258  return min( lhs_.nonZeros(i), rhs_.nonZeros(i) );
259  }
260  //**********************************************************************************************
261 
262  //**Left operand access*************************************************************************
267  inline LeftOperand leftOperand() const noexcept {
268  return lhs_;
269  }
270  //**********************************************************************************************
271 
272  //**Right operand access************************************************************************
277  inline RightOperand rightOperand() const noexcept {
278  return rhs_;
279  }
280  //**********************************************************************************************
281 
282  //**********************************************************************************************
288  template< typename T >
289  inline bool canAlias( const T* alias ) const noexcept {
290  return ( lhs_.canAlias( alias ) || rhs_.canAlias( alias ) );
291  }
292  //**********************************************************************************************
293 
294  //**********************************************************************************************
300  template< typename T >
301  inline bool isAliased( const T* alias ) const noexcept {
302  return ( lhs_.isAliased( alias ) || rhs_.isAliased( alias ) );
303  }
304  //**********************************************************************************************
305 
306  private:
307  //**Member variables****************************************************************************
310  //**********************************************************************************************
311 
312  //**Assignment to row-major dense matrices******************************************************
325  template< typename MT > // Type of the target dense matrix
327  assign( DenseMatrix<MT,false>& lhs, const TSMatSMatSchurExpr& rhs )
328  {
330 
331  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
332  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
333 
334  // Evaluation of the left-hand side sparse matrix operand
335  const OppositeType_<RT1> A( serial( rhs.lhs_ ) );
336 
337  // Evaluation of the right-hand side sparse matrix operand
338  CT2 B( serial( rhs.rhs_ ) );
339 
340  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.lhs_.rows() , "Invalid number of rows" );
341  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.lhs_.columns(), "Invalid number of columns" );
342  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
343  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
344  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
345  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).columns() , "Invalid number of columns" );
346 
347  assign( ~lhs, A % B );
348  }
350  //**********************************************************************************************
351 
352  //**Assignment to column-major dense matrices***************************************************
365  template< typename MT > // Type of the target dense matrix
367  assign( DenseMatrix<MT,true>& lhs, const TSMatSMatSchurExpr& rhs )
368  {
370 
372 
373  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
374  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
375 
376  // Evaluation of the left-hand side sparse matrix operand
377  CT1 A( serial( rhs.lhs_ ) );
378 
379  // Evaluation of the right-hand side sparse matrix operand
380  const OppositeType_<RT2> B( serial( rhs.rhs_ ) );
381 
382  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.lhs_.rows() , "Invalid number of rows" );
383  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.lhs_.columns(), "Invalid number of columns" );
384  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
385  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
386  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
387  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).columns() , "Invalid number of columns" );
388 
389  assign( ~lhs, A % B );
390  }
392  //**********************************************************************************************
393 
394  //**Assignment to row-major sparse matrices*****************************************************
407  template< typename MT > // Type of the target sparse matrix
409  assign( SparseMatrix<MT,false>& lhs, const TSMatSMatSchurExpr& rhs )
410  {
412 
413  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
414  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
415 
416  // Evaluation of the left-hand side sparse matrix operand
417  const OppositeType_<RT1> A( serial( rhs.lhs_ ) );
418 
419  // Evaluation of the right-hand side sparse matrix operand
420  CT2 B( serial( rhs.rhs_ ) );
421 
422  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.lhs_.rows() , "Invalid number of rows" );
423  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.lhs_.columns(), "Invalid number of columns" );
424  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
425  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
426  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
427  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).columns() , "Invalid number of columns" );
428 
429  assign( ~lhs, A % B );
430  }
432  //**********************************************************************************************
433 
434  //**Assignment to column-major sparse matrices**************************************************
447  template< typename MT > // Type of the target sparse matrix
449  assign( SparseMatrix<MT,true>& lhs, const TSMatSMatSchurExpr& rhs )
450  {
452 
454 
455  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
456  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
457 
458  // Evaluation of the left-hand side sparse matrix operand
459  CT1 A( serial( rhs.lhs_ ) );
460 
461  // Evaluation of the right-hand side sparse matrix operand
462  const OppositeType_<RT2> B( serial( rhs.rhs_ ) );
463 
464  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.lhs_.rows() , "Invalid number of rows" );
465  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.lhs_.columns(), "Invalid number of columns" );
466  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
467  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
468  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
469  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).columns() , "Invalid number of columns" );
470 
471  assign( ~lhs, A % B );
472  }
474  //**********************************************************************************************
475 
476  //**Restructuring assignment to row-major matrices**********************************************
489  template< typename MT > // Type of the target matrix
491  assign( Matrix<MT,false>& lhs, const TSMatSMatSchurExpr& rhs )
492  {
494 
495  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
496  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
497 
498  assign( ~lhs, trans( rhs.lhs_ ) % rhs.rhs_ );
499  }
501  //**********************************************************************************************
502 
503  //**Restructuring assignment to column-major matrices*******************************************
516  template< typename MT > // Type of the target matrix
518  assign( Matrix<MT,true>& lhs, const TSMatSMatSchurExpr& rhs )
519  {
521 
523 
524  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
525  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
526 
527  assign( ~lhs, rhs.lhs_ % trans( rhs.rhs_ ) );
528  }
530  //**********************************************************************************************
531 
532  //**Addition assignment to row-major dense matrices*********************************************
545  template< typename MT > // Type of the target dense matrix
547  addAssign( DenseMatrix<MT,false>& lhs, const TSMatSMatSchurExpr& rhs )
548  {
550 
551  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
552  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
553 
554  // Evaluation of the left-hand side sparse matrix operand
555  const OppositeType_<RT1> A( serial( rhs.lhs_ ) );
556 
557  // Evaluation of the right-hand side sparse matrix operand
558  CT2 B( serial( rhs.rhs_ ) );
559 
560  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.lhs_.rows() , "Invalid number of rows" );
561  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.lhs_.columns(), "Invalid number of columns" );
562  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
563  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
564  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
565  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).columns() , "Invalid number of columns" );
566 
567  addAssign( ~lhs, A % B );
568  }
570  //**********************************************************************************************
571 
572  //**Addition assignment to column-major dense matrices******************************************
585  template< typename MT > // Type of the target dense matrix
587  addAssign( DenseMatrix<MT,true>& lhs, const TSMatSMatSchurExpr& rhs )
588  {
590 
592 
593  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
594  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
595 
596  // Evaluation of the left-hand side sparse matrix operand
597  CT1 A( serial( rhs.lhs_ ) );
598 
599  // Evaluation of the right-hand side sparse matrix operand
600  const OppositeType_<RT2> B( serial( rhs.rhs_ ) );
601 
602  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.lhs_.rows() , "Invalid number of rows" );
603  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.lhs_.columns(), "Invalid number of columns" );
604  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
605  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
606  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
607  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).columns() , "Invalid number of columns" );
608 
609  addAssign( ~lhs, A % B );
610  }
612  //**********************************************************************************************
613 
614  //**Restructuring addition assignment to row-major matrices*************************************
627  template< typename MT > // Type of the target matrix
629  addAssign( Matrix<MT,false>& lhs, const TSMatSMatSchurExpr& rhs )
630  {
632 
633  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
634  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
635 
636  addAssign( ~lhs, trans( rhs.lhs_ ) % rhs.rhs_ );
637  }
639  //**********************************************************************************************
640 
641  //**Restructuring addition assignment to column-major matrices**********************************
654  template< typename MT > // Type of the target matrix
656  addAssign( Matrix<MT,true>& lhs, const TSMatSMatSchurExpr& rhs )
657  {
659 
661 
662  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
663  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
664 
665  addAssign( ~lhs, rhs.lhs_ % trans( rhs.rhs_ ) );
666  }
668  //**********************************************************************************************
669 
670  //**Addition assignment to sparse matrices******************************************************
671  // No special implementation for the addition assignment to sparse matrices.
672  //**********************************************************************************************
673 
674  //**Subtraction assignment to row-major dense matrices******************************************
687  template< typename MT > // Type of the target dense matrix
689  subAssign( DenseMatrix<MT,false>& lhs, const TSMatSMatSchurExpr& rhs )
690  {
692 
693  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
694  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
695 
696  // Evaluation of the left-hand side sparse matrix operand
697  const OppositeType_<RT1> A( serial( rhs.lhs_ ) );
698 
699  // Evaluation of the right-hand side sparse matrix operand
700  CT2 B( serial( rhs.rhs_ ) );
701 
702  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.lhs_.rows() , "Invalid number of rows" );
703  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.lhs_.columns(), "Invalid number of columns" );
704  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
705  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
706  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
707  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).columns() , "Invalid number of columns" );
708 
709  subAssign( ~lhs, A % B );
710  }
712  //**********************************************************************************************
713 
714  //**Subtraction assignment to column-major dense matrices***************************************
727  template< typename MT > // Type of the target dense matrix
729  subAssign( DenseMatrix<MT,true>& lhs, const TSMatSMatSchurExpr& rhs )
730  {
732 
734 
735  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
736  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
737 
738  // Evaluation of the left-hand side sparse matrix operand
739  CT1 A( serial( rhs.lhs_ ) );
740 
741  // Evaluation of the right-hand side sparse matrix operand
742  const OppositeType_<RT2> B( serial( rhs.rhs_ ) );
743 
744  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.lhs_.rows() , "Invalid number of rows" );
745  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.lhs_.columns(), "Invalid number of columns" );
746  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
747  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
748  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
749  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).columns() , "Invalid number of columns" );
750 
751  subAssign( ~lhs, A % B );
752  }
754  //**********************************************************************************************
755 
756  //**Restructuring subtraction assignment to row-major matrices**********************************
769  template< typename MT > // Type of the target matrix
771  subAssign( Matrix<MT,false>& lhs, const TSMatSMatSchurExpr& rhs )
772  {
774 
775  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
776  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
777 
778  subAssign( ~lhs, trans( rhs.lhs_ ) % rhs.rhs_ );
779  }
781  //**********************************************************************************************
782 
783  //**Restructuring subtraction assignment to column-major matrices*******************************
796  template< typename MT > // Type of the target matrix
798  subAssign( Matrix<MT,true>& lhs, const TSMatSMatSchurExpr& rhs )
799  {
801 
803 
804  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
805  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
806 
807  subAssign( ~lhs, rhs.lhs_ % trans( rhs.rhs_ ) );
808  }
810  //**********************************************************************************************
811 
812  //**Subtraction assignment to sparse matrices***************************************************
813  // No special implementation for the subtraction assignment to sparse matrices.
814  //**********************************************************************************************
815 
816  //**Schur product assignment to row-major dense matrices****************************************
829  template< typename MT > // Type of the target dense matrix
831  schurAssign( DenseMatrix<MT,false>& lhs, const TSMatSMatSchurExpr& rhs )
832  {
834 
835  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
836  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
837 
838  // Evaluation of the left-hand side sparse matrix operand
839  const OppositeType_<RT1> A( serial( rhs.lhs_ ) );
840 
841  // Evaluation of the right-hand side sparse matrix operand
842  CT2 B( serial( rhs.rhs_ ) );
843 
844  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.lhs_.rows() , "Invalid number of rows" );
845  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.lhs_.columns(), "Invalid number of columns" );
846  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
847  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
848  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
849  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).columns() , "Invalid number of columns" );
850 
851  schurAssign( ~lhs, A % B );
852  }
854  //**********************************************************************************************
855 
856  //**Schur product assignment to column-major dense matrices*************************************
869  template< typename MT > // Type of the target dense matrix
871  schurAssign( DenseMatrix<MT,true>& lhs, const TSMatSMatSchurExpr& rhs )
872  {
874 
876 
877  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
878  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
879 
880  // Evaluation of the left-hand side sparse matrix operand
881  CT1 A( serial( rhs.lhs_ ) );
882 
883  // Evaluation of the right-hand side sparse matrix operand
884  const OppositeType_<RT2> B( serial( rhs.rhs_ ) );
885 
886  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.lhs_.rows() , "Invalid number of rows" );
887  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.lhs_.columns(), "Invalid number of columns" );
888  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
889  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
890  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
891  BLAZE_INTERNAL_ASSERT( A.columns() == (~lhs).columns() , "Invalid number of columns" );
892 
893  schurAssign( ~lhs, A % B );
894  }
896  //**********************************************************************************************
897 
898  //**Restructuring Schur product assignment to row-major matrices********************************
911  template< typename MT > // Type of the target matrix
913  schurAssign( Matrix<MT,false>& lhs, const TSMatSMatSchurExpr& rhs )
914  {
916 
917  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
918  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
919 
920  schurAssign( ~lhs, trans( rhs.lhs_ ) % rhs.rhs_ );
921  }
923  //**********************************************************************************************
924 
925  //**Restructuring Schur product assignment to column-major matrices*****************************
938  template< typename MT > // Type of the target matrix
940  schurAssign( Matrix<MT,true>& lhs, const TSMatSMatSchurExpr& rhs )
941  {
943 
945 
946  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
947  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
948 
949  schurAssign( ~lhs, rhs.lhs_ % trans( rhs.rhs_ ) );
950  }
952  //**********************************************************************************************
953 
954  //**Multiplication assignment to dense matrices*************************************************
955  // No special implementation for the multiplication assignment to dense matrices.
956  //**********************************************************************************************
957 
958  //**Multiplication assignment to sparse matrices************************************************
959  // No special implementation for the multiplication assignment to sparse matrices.
960  //**********************************************************************************************
961 
962  //**SMP assignment to dense matrices************************************************************
963  // No special implementation for the SMP assignment to dense matrices.
964  //**********************************************************************************************
965 
966  //**SMP assignment to sparse matrices***********************************************************
967  // No special implementation for the SMP assignment to sparse matrices.
968  //**********************************************************************************************
969 
970  //**SMP addition assignment to dense matrices***************************************************
971  // No special implementation for the SMP addition assignment to dense matrices.
972  //**********************************************************************************************
973 
974  //**SMP addition assignment to sparse matrices**************************************************
975  // No special implementation for the SMP addition assignment to sparse matrices.
976  //**********************************************************************************************
977 
978  //**SMP subtraction assignment to dense matrices************************************************
979  // No special implementation for the SMP subtraction assignment to dense matrices.
980  //**********************************************************************************************
981 
982  //**SMP subtraction assignment to sparse matrices***********************************************
983  // No special implementation for the SMP subtraction assignment to sparse matrices.
984  //**********************************************************************************************
985 
986  //**SMP Schur product assignment to dense matrices**********************************************
999  template< typename MT // Type of the target dense matrix
1000  , bool SO > // Storage order of the target dense matrix
1001  friend inline void smpSchurAssign( DenseMatrix<MT,SO>& lhs, const TSMatSMatSchurExpr& rhs )
1002  {
1004 
1005  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
1006  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
1007 
1008  smpSchurAssign( ~lhs, rhs.lhs_ );
1009  smpSchurAssign( ~lhs, rhs.rhs_ );
1010  }
1012  //**********************************************************************************************
1013 
1014  //**SMP Schur product assignment to sparse matrices*********************************************
1015  // No special implementation for the SMP Schur product assignment to sparse matrices.
1016  //**********************************************************************************************
1017 
1018  //**SMP multiplication assignment to dense matrices*********************************************
1019  // No special implementation for the SMP multiplication assignment to dense matrices.
1020  //**********************************************************************************************
1021 
1022  //**SMP multiplication assignment to sparse matrices********************************************
1023  // No special implementation for the SMP multiplication assignment to sparse matrices.
1024  //**********************************************************************************************
1025 
1026  //**Compile time checks*************************************************************************
1034  //**********************************************************************************************
1035 };
1036 //*************************************************************************************************
1037 
1038 
1039 
1040 
1041 //=================================================================================================
1042 //
1043 // GLOBAL BINARY ARITHMETIC OPERATORS
1044 //
1045 //=================================================================================================
1046 
1047 //*************************************************************************************************
1060 template< typename MT1 // Type of the left-hand side sparse matrix
1061  , typename MT2 // Type of the right-hand side sparse matrix
1064 inline const TSMatSMatSchurExpr<MT1,MT2>
1065  tsmatsmatschur( const SparseMatrix<MT1,true>& lhs, const SparseMatrix<MT2,false>& rhs )
1066 {
1068 
1069  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == (~rhs).rows() , "Invalid number of rows" );
1070  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == (~rhs).columns(), "Invalid number of columns" );
1071 
1072  return TSMatSMatSchurExpr<MT1,MT2>( ~lhs, ~rhs );
1073 }
1075 //*************************************************************************************************
1076 
1077 
1078 //*************************************************************************************************
1091 template< typename MT1 // Type of the left-hand side sparse matrix
1092  , typename MT2 // Type of the right-hand side sparse matrix
1093  , typename = EnableIf_< Or< And< IsUniLower<MT1>, IsUniUpper<MT2> >
1094  , And< IsUniUpper<MT1>, IsUniLower<MT2> > > > >
1096  tsmatsmatschur( const SparseMatrix<MT1,true>& lhs, const SparseMatrix<MT2,false>& rhs )
1097 {
1099 
1100  UNUSED_PARAMETER( rhs );
1101 
1102  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == (~rhs).rows() , "Invalid number of rows" );
1103  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == (~rhs).columns(), "Invalid number of columns" );
1104 
1105  return IdentityMatrix< MultTrait_< ElementType_<MT1>, ElementType_<MT2> >, true >( (~lhs).rows() );
1106 }
1108 //*************************************************************************************************
1109 
1110 
1111 //*************************************************************************************************
1140 template< typename MT1 // Type of the left-hand side sparse matrix
1141  , typename MT2 > // Type of the right-hand side sparse matrix
1142 inline decltype(auto)
1143  operator%( const SparseMatrix<MT1,true>& lhs, const SparseMatrix<MT2,false>& rhs )
1144 {
1146 
1147  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() ) {
1148  BLAZE_THROW_INVALID_ARGUMENT( "Matrix sizes do not match" );
1149  }
1150 
1151  return tsmatsmatschur( ~lhs, ~rhs );
1152 }
1153 //*************************************************************************************************
1154 
1155 
1156 
1157 
1158 //=================================================================================================
1159 //
1160 // ROWS SPECIALIZATIONS
1161 //
1162 //=================================================================================================
1163 
1164 //*************************************************************************************************
1166 template< typename MT1, typename MT2 >
1167 struct Rows< TSMatSMatSchurExpr<MT1,MT2> >
1168  : public Maximum< Rows<MT1>, Rows<MT2> >
1169 {};
1171 //*************************************************************************************************
1172 
1173 
1174 
1175 
1176 //=================================================================================================
1177 //
1178 // COLUMNS SPECIALIZATIONS
1179 //
1180 //=================================================================================================
1181 
1182 //*************************************************************************************************
1184 template< typename MT1, typename MT2 >
1185 struct Columns< TSMatSMatSchurExpr<MT1,MT2> >
1186  : public Maximum< Columns<MT1>, Columns<MT2> >
1187 {};
1189 //*************************************************************************************************
1190 
1191 
1192 
1193 
1194 //=================================================================================================
1195 //
1196 // ISSYMMETRIC SPECIALIZATIONS
1197 //
1198 //=================================================================================================
1199 
1200 //*************************************************************************************************
1202 template< typename MT1, typename MT2 >
1203 struct IsSymmetric< TSMatSMatSchurExpr<MT1,MT2> >
1204  : public BoolConstant< IsSymmetric<MT1>::value && IsSymmetric<MT2>::value >
1205 {};
1207 //*************************************************************************************************
1208 
1209 
1210 
1211 
1212 //=================================================================================================
1213 //
1214 // ISHERMITIAN SPECIALIZATIONS
1215 //
1216 //=================================================================================================
1217 
1218 //*************************************************************************************************
1220 template< typename MT1, typename MT2 >
1221 struct IsHermitian< TSMatSMatSchurExpr<MT1,MT2> >
1222  : public BoolConstant< IsHermitian<MT1>::value && IsHermitian<MT2>::value >
1223 {};
1225 //*************************************************************************************************
1226 
1227 
1228 
1229 
1230 //=================================================================================================
1231 //
1232 // ISLOWER SPECIALIZATIONS
1233 //
1234 //=================================================================================================
1235 
1236 //*************************************************************************************************
1238 template< typename MT1, typename MT2 >
1239 struct IsLower< TSMatSMatSchurExpr<MT1,MT2> >
1240  : public BoolConstant< Or< IsLower<MT1>, IsLower<MT2> >::value >
1241 {};
1243 //*************************************************************************************************
1244 
1245 
1246 
1247 
1248 //=================================================================================================
1249 //
1250 // ISUNILOWER SPECIALIZATIONS
1251 //
1252 //=================================================================================================
1253 
1254 //*************************************************************************************************
1256 template< typename MT1, typename MT2 >
1257 struct IsUniLower< TSMatSMatSchurExpr<MT1,MT2> >
1258  : public BoolConstant< And< IsUniLower<MT1>, IsUniLower<MT2> >::value >
1259 {};
1261 //*************************************************************************************************
1262 
1263 
1264 
1265 
1266 //=================================================================================================
1267 //
1268 // ISSTRICTLYLOWER SPECIALIZATIONS
1269 //
1270 //=================================================================================================
1271 
1272 //*************************************************************************************************
1274 template< typename MT1, typename MT2 >
1275 struct IsStrictlyLower< TSMatSMatSchurExpr<MT1,MT2> >
1276  : public BoolConstant< Or< IsStrictlyLower<MT1>, IsStrictlyLower<MT2> >::value >
1277 {};
1279 //*************************************************************************************************
1280 
1281 
1282 
1283 
1284 //=================================================================================================
1285 //
1286 // ISUPPER SPECIALIZATIONS
1287 //
1288 //=================================================================================================
1289 
1290 //*************************************************************************************************
1292 template< typename MT1, typename MT2 >
1293 struct IsUpper< TSMatSMatSchurExpr<MT1,MT2> >
1294  : public BoolConstant< Or< IsUpper<MT1>, IsUpper<MT2> >::value >
1295 {};
1297 //*************************************************************************************************
1298 
1299 
1300 
1301 
1302 //=================================================================================================
1303 //
1304 // ISUNIUPPER SPECIALIZATIONS
1305 //
1306 //=================================================================================================
1307 
1308 //*************************************************************************************************
1310 template< typename MT1, typename MT2 >
1311 struct IsUniUpper< TSMatSMatSchurExpr<MT1,MT2> >
1312  : public BoolConstant< And< IsUniUpper<MT1>, IsUniUpper<MT2> >::value >
1313 {};
1315 //*************************************************************************************************
1316 
1317 
1318 
1319 
1320 //=================================================================================================
1321 //
1322 // ISSTRICTLYUPPER SPECIALIZATIONS
1323 //
1324 //=================================================================================================
1325 
1326 //*************************************************************************************************
1328 template< typename MT1, typename MT2 >
1329 struct IsStrictlyUpper< TSMatSMatSchurExpr<MT1,MT2> >
1330  : public BoolConstant< Or< IsStrictlyUpper<MT1>, IsStrictlyUpper<MT2> >::value >
1331 {};
1333 //*************************************************************************************************
1334 
1335 } // namespace blaze
1336 
1337 #endif
SchurTrait_< RT1, RT2 > ResultType
Result type for expression template evaluations.
Definition: TSMatSMatSchurExpr.h:150
#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
ReturnType_< MT2 > RN2
Return type of the right-hand side sparse matrix expression.
Definition: TSMatSMatSchurExpr.h:113
Header file for auxiliary alias declarations.
Headerfile for the generic min algorithm.
Header file for the Schur product trait.
Compile time check whether the given type is a temporary vector or matrix type.This type trait class ...
Definition: IsTemporary.h:70
Header file for the Rows type trait.
Header file for the UNUSED_PARAMETER function template.
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.
CompositeType_< MT1 > CT1
Composite type of the left-hand side sparse matrix expression.
Definition: TSMatSMatSchurExpr.h:114
MultExprTrait_< RN1, RN2 > ExprReturnType
Expression return type for the subscript operator.
Definition: TSMatSMatSchurExpr.h:128
Header file for the serial shim.
Generic wrapper for a compile time constant integral value.The IntegralConstant class template repres...
Definition: IntegralConstant.h:71
If_< IsExpression< MT1 >, const MT1, const MT1 &> LeftOperand
Composite type of the left-hand side sparse matrix expression.
Definition: TSMatSMatSchurExpr.h:162
ResultType_< MT1 > RT1
Result type of the left-hand side sparse matrix expression.
Definition: TSMatSMatSchurExpr.h:110
typename DisableIf< Condition, T >::Type DisableIf_
Auxiliary type for the DisableIf class template.The DisableIf_ alias declaration provides a convenien...
Definition: DisableIf.h:224
size_t columns() const noexcept
Returns the current number of columns of the matrix.
Definition: TSMatSMatSchurExpr.h:236
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:1762
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:88
Header file for the Computation base class.
Compile time check for upper triangular matrices.This type trait tests whether or not the given templ...
Definition: IsUpper.h:88
Constraints on the storage order of matrix types.
size_t rows() const noexcept
Returns the current number of rows of the matrix.
Definition: TSMatSMatSchurExpr.h:226
LeftOperand lhs_
Left-hand side sparse matrix of the Schur product expression.
Definition: TSMatSMatSchurExpr.h:308
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
size_t nonZeros(size_t i) const
Returns the number of non-zero elements in the specified row.
Definition: TSMatSMatSchurExpr.h:257
#define BLAZE_CONSTRAINT_MUST_FORM_VALID_SCHUREXPR(T1, T2)
Constraint on the data type.In case the given data types T1 and T2 do not form a valid matrix/matrix ...
Definition: SchurExpr.h:108
RightOperand rhs_
Right-hand side sparse matrix of the Schur product expression.
Definition: TSMatSMatSchurExpr.h:309
RightOperand rightOperand() const noexcept
Returns the right-hand side sparse matrix operand.
Definition: TSMatSMatSchurExpr.h:277
Base class for dense matrices.The DenseMatrix class is a base class for all dense matrix classes...
Definition: DenseMatrix.h:78
Base class for sparse matrices.The SparseMatrix class is a base class for all sparse matrix classes...
Definition: Forward.h:129
Header file for all forward declarations for sparse vectors and matrices.
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.
Constraint on the data type.
Header file for the Maximum class template.
typename MultExprTrait< T1, T2 >::Type MultExprTrait_
Auxiliary alias declaration for the MultExprTrait class template.The MultExprTrait_ alias declaration...
Definition: MultExprTrait.h:112
Header file for the MultExprTrait class template.
typename T::CompositeType CompositeType_
Alias declaration for nested CompositeType type definitions.The CompositeType_ alias declaration prov...
Definition: Aliases.h:83
Compile time check for upper unitriangular matrices.This type trait tests whether or not the given te...
Definition: IsUniUpper.h:86
Efficient implementation of an identity matrix.The IdentityMatrix class template is the representati...
Definition: Forward.h:49
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.
Namespace of the Blaze C++ math library.
Definition: Blaze.h:57
Header file for the If class template.
TransposeType_< ResultType > TransposeType
Transpose type for expression template evaluations.
Definition: TSMatSMatSchurExpr.h:152
#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
const IfTrue_< returnExpr, ExprReturnType, ElementType > ReturnType
Return type for expression template evaluations.
Definition: TSMatSMatSchurExpr.h:156
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
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: TSMatSMatSchurExpr.h:195
Header file for the Columns type trait.
bool isAliased(const T *alias) const noexcept
Returns whether the expression is aliased with the given address alias.
Definition: TSMatSMatSchurExpr.h:301
typename T::ElementType ElementType_
Alias declaration for nested ElementType type definitions.The ElementType_ alias declaration provides...
Definition: Aliases.h:163
Header file for the IsLower type trait.
typename SchurTrait< T1, T2 >::Type SchurTrait_
Auxiliary alias declaration for the SchurTrait class template.The SchurTrait_ alias declaration provi...
Definition: SchurTrait.h:167
CompositeType_< MT2 > CT2
Composite type of the right-hand side sparse matrix expression.
Definition: TSMatSMatSchurExpr.h:115
Constraints on the storage order of matrix types.
Compile time check for symmetric matrices.This type trait tests whether or not the given template par...
Definition: IsSymmetric.h:85
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
Header file for all forward declarations for expression class templates.
Header file for the EnableIf class template.
Header file for the IsStrictlyLower type trait.
ReturnType_< MT1 > RN1
Return type of the left-hand side sparse matrix expression.
Definition: TSMatSMatSchurExpr.h:112
ElementType_< ResultType > ElementType
Resulting element type.
Definition: TSMatSMatSchurExpr.h:153
#define BLAZE_CONSTRAINT_MATRICES_MUST_HAVE_DIFFERENT_STORAGE_ORDER(T1, T2)
Constraint on the data type.In case either of the two given data types T1 or T2 is not a matrix type ...
Definition: StorageOrder.h:106
Compile time check for lower unitriangular matrices.This type trait tests whether or not the given te...
Definition: IsUniLower.h:86
size_t nonZeros() const
Returns the number of non-zero elements in the sparse matrix.
Definition: TSMatSMatSchurExpr.h:246
#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
TSMatSMatSchurExpr(const MT1 &lhs, const MT2 &rhs) noexcept
Constructor for the TSMatSMatSchurExpr class.
Definition: TSMatSMatSchurExpr.h:179
Header file for run time assertion macros.
const ResultType CompositeType
Data type for composite expression templates.
Definition: TSMatSMatSchurExpr.h:159
OppositeType_< ResultType > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: TSMatSMatSchurExpr.h:151
LeftOperand leftOperand() const noexcept
Returns the left-hand side transpose sparse matrix operand.
Definition: TSMatSMatSchurExpr.h:267
Header file for the SchurExpr base class.
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
If_< IsExpression< MT2 >, const MT2, const MT2 &> RightOperand
Composite type of the right-hand side sparse matrix expression.
Definition: TSMatSMatSchurExpr.h:165
#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
Compile time check for Hermitian matrices.This type trait tests whether or not the given template par...
Definition: IsHermitian.h:85
Base class for matrices.The Matrix class is a base class for all dense and sparse matrix classes with...
Definition: Forward.h:101
Constraint on the data type.
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:819
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
decltype(auto) trans(const DenseMatrix< MT, SO > &dm)
Calculation of the transpose of the given dense matrix.
Definition: DMatTransExpr.h:790
ReturnType at(size_t i, size_t j) const
Checked access to the matrix elements.
Definition: TSMatSMatSchurExpr.h:210
Header file for the IsComputation type trait class.
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:75
Compile time evaluation of the number of rows of a matrix.The Rows type trait evaluates the number of...
Definition: Rows.h:75
Compile time logical and evaluation.The And alias declaration performs at compile time a logical and ...
Definition: And.h:76
typename T::TransposeType TransposeType_
Alias declaration for nested TransposeType type definitions.The TransposeType_ alias declaration prov...
Definition: Aliases.h:423
bool canAlias(const T *alias) const noexcept
Returns whether the expression can alias with the given address alias.
Definition: TSMatSMatSchurExpr.h:289
Header file for the IsUpper type trait.
void UNUSED_PARAMETER(const Args &...)
Suppression of unused parameter warnings.
Definition: Unused.h:81
ResultType_< MT2 > RT2
Result type of the right-hand side sparse matrix expression.
Definition: TSMatSMatSchurExpr.h:111
Header file for the IsHermitian type trait.
#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
Expression object for transpose sparse matrix-sparse matrix Schur products.The TSMatSMatSchurExpr cla...
Definition: Forward.h:165
Header file for the IsExpression type trait class.
Header file for the function trace functionality.
Constraint on the data type.