All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
SVecSVecAddExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_SVECSVECADDEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_SVECSVECADDEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <stdexcept>
50 #include <blaze/math/Functions.h>
60 #include <blaze/util/Assert.h>
62 #include <blaze/util/DisableIf.h>
63 #include <blaze/util/EnableIf.h>
65 #include <blaze/util/SelectType.h>
66 #include <blaze/util/Types.h>
68 
69 
70 namespace blaze {
71 
72 //=================================================================================================
73 //
74 // CLASS SVECSVECADDEXPR
75 //
76 //=================================================================================================
77 
78 //*************************************************************************************************
85 template< typename VT1 // Type of the left-hand side sparse vector
86  , typename VT2 // Type of the right-hand side sparse vector
87  , bool TF > // Transpose flag
88 class SVecSVecAddExpr : public SparseVector< SVecSVecAddExpr<VT1,VT2,TF>, TF >
89  , private VecVecAddExpr
90  , private Computation
91 {
92  private:
93  //**Type definitions****************************************************************************
94  typedef typename VT1::ResultType RT1;
95  typedef typename VT2::ResultType RT2;
96  typedef typename VT1::ReturnType RN1;
97  typedef typename VT2::ReturnType RN2;
98  typedef typename VT1::CompositeType CT1;
99  typedef typename VT2::CompositeType CT2;
100  typedef typename VT1::TransposeType TT1;
101  typedef typename VT2::TransposeType TT2;
102  //**********************************************************************************************
103 
104  //**Return type evaluation**********************************************************************
106 
111  enum { returnExpr = !IsTemporary<RN1>::value && !IsTemporary<RN2>::value };
112 
115  //**********************************************************************************************
116 
117  //**Parallel evaluation strategy****************************************************************
119 
124  template< typename VT >
125  struct UseSMPAssign {
126  enum { value = VT::smpAssignable };
127  };
129  //**********************************************************************************************
130 
131  public:
132  //**Type definitions****************************************************************************
137 
140 
142  typedef const ResultType CompositeType;
143 
145  typedef typename SelectType< IsExpression<VT1>::value, const VT1, const VT1& >::Type LeftOperand;
146 
148  typedef typename SelectType< IsExpression<VT2>::value, const VT2, const VT2& >::Type RightOperand;
149  //**********************************************************************************************
150 
151  //**Compilation flags***************************************************************************
153  enum { smpAssignable = 0 };
154  //**********************************************************************************************
155 
156  //**Constructor*********************************************************************************
159  explicit inline SVecSVecAddExpr( const VT1& lhs, const VT2& rhs )
160  : lhs_( lhs ) // Left-hand side sparse vector of the addition expression
161  , rhs_( rhs ) // Right-hand side sparse vector of the addition expression
162  {
163  BLAZE_INTERNAL_ASSERT( lhs.size() == rhs.size(), "Invalid vector sizes" );
164  }
165  //**********************************************************************************************
166 
167  //**Subscript operator**************************************************************************
173  inline ReturnType operator[]( size_t index ) const {
174  BLAZE_INTERNAL_ASSERT( index < lhs_.size(), "Invalid vector access index" );
175  return lhs_[index] + rhs_[index];
176  }
177  //**********************************************************************************************
178 
179  //**Size function*******************************************************************************
184  inline size_t size() const {
185  return lhs_.size();
186  }
187  //**********************************************************************************************
188 
189  //**NonZeros function***************************************************************************
194  inline size_t nonZeros() const {
195  return min( lhs_.size(), lhs_.nonZeros() + rhs_.nonZeros() );
196  }
197  //**********************************************************************************************
198 
199  //**Left operand access*************************************************************************
204  inline LeftOperand leftOperand() const {
205  return lhs_;
206  }
207  //**********************************************************************************************
208 
209  //**Right operand access************************************************************************
214  inline RightOperand rightOperand() const {
215  return rhs_;
216  }
217  //**********************************************************************************************
218 
219  //**********************************************************************************************
225  template< typename T >
226  inline bool canAlias( const T* alias ) const {
227  return ( lhs_.canAlias( alias ) || rhs_.canAlias( alias ) );
228  }
229  //**********************************************************************************************
230 
231  //**********************************************************************************************
237  template< typename T >
238  inline bool isAliased( const T* alias ) const {
239  return ( lhs_.isAliased( alias ) || rhs_.isAliased( alias ) );
240  }
241  //**********************************************************************************************
242 
243  private:
244  //**Member variables****************************************************************************
247  //**********************************************************************************************
248 
249  //**Default assignment to dense vectors*********************************************************
262  template< typename VT > // Type of the target dense vector
263  friend inline typename EnableIf< IsResizable<typename VT::ElementType> >::Type
264  assign( DenseVector<VT,TF>& lhs, const SVecSVecAddExpr& rhs )
265  {
267 
268  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
269 
270  typedef typename RemoveReference<CT1>::Type::ConstIterator LeftIterator;
271  typedef typename RemoveReference<CT2>::Type::ConstIterator RightIterator;
272 
273  CT1 x( serial( rhs.lhs_ ) ); // Evaluation of the left-hand side sparse vector operand
274  CT2 y( serial( rhs.rhs_ ) ); // Evaluation of the right-hand side sparse vector operand
275 
276  BLAZE_INTERNAL_ASSERT( x.size() == rhs.lhs_.size(), "Invalid vector size" );
277  BLAZE_INTERNAL_ASSERT( y.size() == rhs.rhs_.size(), "Invalid vector size" );
278  BLAZE_INTERNAL_ASSERT( x.size() == (~lhs).size() , "Invalid vector size" );
279 
280  const LeftIterator lend( x.end() );
281  const RightIterator rend( y.end() );
282 
283  for( LeftIterator l=x.begin(); l!=lend; ++l ) {
284  (~lhs)[l->index()] = l->value();
285  }
286 
287  for( RightIterator r=y.begin(); r!=rend; ++r ) {
288  if( isDefault( (~lhs)[r->index()] ) )
289  (~lhs)[r->index()] = r->value();
290  else
291  (~lhs)[r->index()] += r->value();
292  }
293  }
295  //**********************************************************************************************
296 
297  //**Optimized assignment to dense vectors*******************************************************
310  template< typename VT > // Type of the target dense vector
311  friend inline typename DisableIf< IsResizable<typename VT::ElementType> >::Type
312  assign( DenseVector<VT,TF>& lhs, const SVecSVecAddExpr& rhs )
313  {
315 
316  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
317 
318  typedef typename RemoveReference<CT1>::Type::ConstIterator LeftIterator;
319  typedef typename RemoveReference<CT2>::Type::ConstIterator RightIterator;
320 
321  CT1 x( serial( rhs.lhs_ ) ); // Evaluation of the left-hand side sparse vector operand
322  CT2 y( serial( rhs.rhs_ ) ); // Evaluation of the right-hand side sparse vector operand
323 
324  BLAZE_INTERNAL_ASSERT( x.size() == rhs.lhs_.size(), "Invalid vector size" );
325  BLAZE_INTERNAL_ASSERT( y.size() == rhs.rhs_.size(), "Invalid vector size" );
326  BLAZE_INTERNAL_ASSERT( x.size() == (~lhs).size() , "Invalid vector size" );
327 
328  const LeftIterator lend( x.end() );
329  const RightIterator rend( y.end() );
330 
331  for( LeftIterator l=x.begin(); l!=lend; ++l ) {
332  (~lhs)[l->index()] = l->value();
333  }
334 
335  for( RightIterator r=y.begin(); r!=rend; ++r ) {
336  (~lhs)[r->index()] += r->value();
337  }
338  }
340  //**********************************************************************************************
341 
342  //**Assignment to sparse vectors****************************************************************
354  template< typename VT > // Type of the target sparse vector
355  friend inline void assign( SparseVector<VT,TF>& lhs, const SVecSVecAddExpr& rhs )
356  {
358 
359  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
360 
361  typedef typename RemoveReference<CT1>::Type::ConstIterator LeftIterator;
362  typedef typename RemoveReference<CT2>::Type::ConstIterator RightIterator;
363 
364  CT1 x( serial( rhs.lhs_ ) ); // Evaluation of the left-hand side sparse vector operand
365  CT2 y( serial( rhs.rhs_ ) ); // Evaluation of the right-hand side sparse vector operand
366 
367  BLAZE_INTERNAL_ASSERT( x.size() == rhs.lhs_.size(), "Invalid vector size" );
368  BLAZE_INTERNAL_ASSERT( y.size() == rhs.rhs_.size(), "Invalid vector size" );
369  BLAZE_INTERNAL_ASSERT( x.size() == (~lhs).size() , "Invalid vector size" );
370 
371  const LeftIterator lend( x.end() );
372  const RightIterator rend( y.end() );
373 
374  LeftIterator l( x.begin() );
375  RightIterator r( y.begin() );
376 
377  while( l != lend && r != rend )
378  {
379  if( l->index() < r->index() ) {
380  (~lhs).append( l->index(), l->value() );
381  ++l;
382  }
383  else if( l->index() > r->index() ) {
384  (~lhs).append( r->index(), r->value() );
385  ++r;
386  }
387  else {
388  (~lhs).append( l->index(), l->value() + r->value() );
389  ++l;
390  ++r;
391  }
392  }
393 
394  while( l != lend ) {
395  (~lhs).append( l->index(), l->value() );
396  ++l;
397  }
398 
399  while( r != rend ) {
400  (~lhs).append( r->index(), r->value() );
401  ++r;
402  }
403  }
405  //**********************************************************************************************
406 
407  //**Addition assignment to dense vectors********************************************************
419  template< typename VT > // Type of the target dense vector
420  friend inline void addAssign( DenseVector<VT,TF>& lhs, const SVecSVecAddExpr& rhs )
421  {
423 
424  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
425 
426  addAssign( ~lhs, rhs.lhs_ );
427  addAssign( ~lhs, rhs.rhs_ );
428  }
430  //**********************************************************************************************
431 
432  //**Addition assignment to sparse vectors*******************************************************
433  // No special implementation for the addition assignment to sparse vectors.
434  //**********************************************************************************************
435 
436  //**Subtraction assignment to dense vectors*****************************************************
448  template< typename VT > // Type of the target dense vector
449  friend inline void subAssign( DenseVector<VT,TF>& lhs, const SVecSVecAddExpr& rhs )
450  {
452 
453  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
454 
455  subAssign( ~lhs, rhs.lhs_ );
456  subAssign( ~lhs, rhs.rhs_ );
457  }
459  //**********************************************************************************************
460 
461  //**Subtraction assignment to sparse vectors****************************************************
462  // No special implementation for the subtraction assignment to sparse vectors.
463  //**********************************************************************************************
464 
465  //**Multiplication assignment to dense vectors**************************************************
477  template< typename VT > // Type of the target dense vector
478  friend inline void multAssign( DenseVector<VT,TF>& lhs, const SVecSVecAddExpr& rhs )
479  {
481 
485 
486  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
487 
488  const ResultType tmp( serial( rhs ) );
489  multAssign( ~lhs, tmp );
490  }
492  //**********************************************************************************************
493 
494  //**Multiplication assignment to sparse vectors*************************************************
495  // No special implementation for the multiplication assignment to sparse vectors.
496  //**********************************************************************************************
497 
498  //**SMP assignment to dense vectors*************************************************************
499  // No special implementation for the SMP assignment to dense vectors.
500  //**********************************************************************************************
501 
502  //**SMP assignment to sparse vectors************************************************************
503  // No special implementation for the SMP assignment to sparse vectors.
504  //**********************************************************************************************
505 
506  //**SMP addition assignment to dense vectors****************************************************
520  template< typename VT > // Type of the target dense vector
521  friend inline typename EnableIf< UseSMPAssign<VT> >::Type
522  smpAddAssign( DenseVector<VT,TF>& lhs, const SVecSVecAddExpr& rhs )
523  {
525 
526  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
527 
528  smpAddAssign( ~lhs, rhs.lhs_ );
529  smpAddAssign( ~lhs, rhs.rhs_ );
530  }
532  //**********************************************************************************************
533 
534  //**SMP addition assignment to sparse vectors***************************************************
535  // No special implementation for the SMP addition assignment to sparse vectors.
536  //**********************************************************************************************
537 
538  //**SMP subtraction assignment to dense vectors*************************************************
552  template< typename VT > // Type of the target dense vector
553  friend inline typename EnableIf< UseSMPAssign<VT> >::Type
554  smpSubAssign( DenseVector<VT,TF>& lhs, const SVecSVecAddExpr& rhs )
555  {
557 
558  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
559 
560  smpSubAssign( ~lhs, rhs.lhs_ );
561  smpSubAssign( ~lhs, rhs.rhs_ );
562  }
564  //**********************************************************************************************
565 
566  //**SMP subtraction assignment to sparse vectors************************************************
567  // No special implementation for the SMP subtraction assignment to sparse vectors.
568  //**********************************************************************************************
569 
570  //**SMP multiplication assignment to dense vectors**********************************************
585  template< typename VT > // Type of the target dense vector
586  friend inline typename EnableIf< UseSMPAssign<VT> >::Type
587  smpMultAssign( DenseVector<VT,TF>& lhs, const SVecSVecAddExpr& rhs )
588  {
590 
594 
595  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
596 
597  const ResultType tmp( rhs );
598  smpMultAssign( ~lhs, tmp );
599  }
601  //**********************************************************************************************
602 
603  //**SMP multiplication assignment to sparse vectors*********************************************
604  // No special implementation for the SMP multiplication assignment to sparse vectors.
605  //**********************************************************************************************
606 
607  //**Compile time checks*************************************************************************
614  //**********************************************************************************************
615 };
616 //*************************************************************************************************
617 
618 
619 
620 
621 //=================================================================================================
622 //
623 // GLOBAL BINARY ARITHMETIC OPERATORS
624 //
625 //=================================================================================================
626 
627 //*************************************************************************************************
651 template< typename T1 // Type of the left-hand side sparse vector
652  , typename T2 // Type of the right-hand side sparse vector
653  , bool TF > // Transpose flag
654 inline const SVecSVecAddExpr<T1,T2,TF>
656 {
658 
659  if( (~lhs).size() != (~rhs).size() )
660  throw std::invalid_argument( "Vector sizes do not match" );
661 
662  return SVecSVecAddExpr<T1,T2,TF>( ~lhs, ~rhs );
663 }
664 //*************************************************************************************************
665 
666 
667 
668 
669 //=================================================================================================
670 //
671 // EXPRESSION TRAIT SPECIALIZATIONS
672 //
673 //=================================================================================================
674 
675 //*************************************************************************************************
677 template< typename VT1, typename VT2, bool TF, bool AF >
678 struct SubvectorExprTrait< SVecSVecAddExpr<VT1,VT2,TF>, AF >
679 {
680  public:
681  //**********************************************************************************************
682  typedef typename AddExprTrait< typename SubvectorExprTrait<const VT1,AF>::Type
683  , typename SubvectorExprTrait<const VT2,AF>::Type >::Type Type;
684  //**********************************************************************************************
685 };
687 //*************************************************************************************************
688 
689 } // namespace blaze
690 
691 #endif
Header file for mathematical functions.
Evaluation of the return type of an addition expression.Via this type trait it is possible to evaluat...
Definition: AddExprTrait.h:103
Compile time check whether the given type is a temporary vector or matrix type.This type trait class ...
Definition: IsTemporary.h:87
VT2::ResultType RT2
Result type of the right-hand side sparse vector expression.
Definition: SVecSVecAddExpr.h:95
Header file for the SparseVector base class.
void smpSubAssign(DenseMatrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP subtraction assignment of a matrix to dense matrix.
Definition: DenseMatrix.h:152
bool isDefault(const DynamicMatrix< Type, SO > &m)
Returns whether the given dense matrix is in default state.
Definition: DynamicMatrix.h:4642
Efficient implementation of a compressed matrix.The CompressedMatrix class template is the represent...
Definition: CompressedMatrix.h:199
void smpMultAssign(DenseVector< VT1, TF1 > &lhs, const Vector< VT2, TF2 > &rhs)
Default implementation of the SMP multiplication assignment of a vector to a dense vector...
Definition: DenseVector.h:179
LeftOperand leftOperand() const
Returns the left-hand side sparse vector operand.
Definition: SVecSVecAddExpr.h:204
const This & CompositeType
Data type for composite expression templates.
Definition: CompressedMatrix.h:2408
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:251
VT1::ReturnType RN1
Return type of the left-hand side sparse vector expression.
Definition: SVecSVecAddExpr.h:96
AddExprTrait< RN1, RN2 >::Type ExprReturnType
Expression return type for the subscript operator.
Definition: SVecSVecAddExpr.h:114
Header file for the AddExprTrait class template.
const DMatSerialExpr< MT, SO > serial(const DenseMatrix< MT, SO > &dm)
Forces the serial evaluation of the given dense matrix expression dm.
Definition: DMatSerialExpr.h:690
Header file for the Computation base class.
bool isAliased(const T *alias) const
Returns whether the expression is aliased with the given address alias.
Definition: SVecSVecAddExpr.h:238
RightOperand rhs_
Right-hand side sparse vector of the addition expression.
Definition: SVecSVecAddExpr.h:246
Constraint on the data type.
Expression object for sparse vector-sparse vector additions.The SVecSVecAddExpr class represents the ...
Definition: Forward.h:117
void smpAddAssign(DenseMatrix< 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:122
SVecSVecAddExpr< VT1, VT2, TF > This
Type of this SVecSVecAddExpr instance.
Definition: SVecSVecAddExpr.h:133
const This & CompositeType
Data type for composite expression templates.
Definition: CompressedMatrix.h:253
Compile time type selection.The SelectType class template selects one of the two given types T1 and T...
Definition: SelectType.h:59
Header file for the DisableIf class template.
Header file for the IsTemporary type trait class.
RightOperand rightOperand() const
Returns the right-hand side sparse vector operand.
Definition: SVecSVecAddExpr.h:214
Header file for the VecVecAddExpr base class.
VT2::TransposeType TT2
Transpose type of the right-hand side sparse vector expression.
Definition: SVecSVecAddExpr.h:101
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:2412
bool canAlias(const T *alias) const
Returns whether the expression can alias with the given address alias.
Definition: SVecSVecAddExpr.h:226
size_t nonZeros() const
Returns the number of non-zero elements in the sparse vector.
Definition: SVecSVecAddExpr.h:194
void assign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the assignment of a matrix to a matrix.
Definition: Matrix.h:271
const DenseIterator< Type > operator+(const DenseIterator< Type > &it, ptrdiff_t inc)
Addition between a DenseIterator and an integral value.
Definition: DenseIterator.h:556
Base class for N-dimensional dense vectors.The DenseVector class is a base class for all arbitrarily ...
Definition: DenseVector.h:70
#define BLAZE_CONSTRAINT_MUST_BE_SPARSE_VECTOR_TYPE(T)
Constraint on the data type.In case the given data type T is not a sparse, N-dimensional vector type...
Definition: SparseVector.h:79
Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_REFERENCE_TYPE(T)
Constraint on the data type.In case the given data type T is not a reference type, a compilation error is created.
Definition: Reference.h:78
CompressedMatrix< Type, false > TransposeType
Transpose type for expression template evaluations.
Definition: CompressedMatrix.h:2405
void multAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the multiplication assignment of a matrix to a matrix.
Definition: Matrix.h:361
Header file for the SelectType class template.
Header file for all forward declarations for expression class templates.
Constraint on the data type.
Header file for the EnableIf class template.
VT1::CompositeType CT1
Composite type of the left-hand side sparse vector expression.
Definition: SVecSVecAddExpr.h:98
Header file for the serial shim.
VT1::ResultType RT1
Result type of the left-hand side sparse vector expression.
Definition: SVecSVecAddExpr.h:94
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:2407
Removal of reference modifiers.The RemoveCV type trait removes any reference modifiers from the given...
Definition: RemoveReference.h:69
const ResultType CompositeType
Data type for composite expression templates.
Definition: SVecSVecAddExpr.h:142
Header file for run time assertion macros.
Base template for the AddTrait class.
Definition: AddTrait.h:141
Header file for the addition trait.
ResultType::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: SVecSVecAddExpr.h:135
void addAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the addition assignment of a matrix to a matrix.
Definition: Matrix.h:301
Substitution Failure Is Not An Error (SFINAE) class.The EnableIf class template is an auxiliary tool ...
Definition: EnableIf.h:184
VT2::ReturnType RN2
Return type of the right-hand side sparse vector expression.
Definition: SVecSVecAddExpr.h:97
VT2::CompositeType CT2
Composite type of the right-hand side sparse vector expression.
Definition: SVecSVecAddExpr.h:99
void subAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the subtraction assignment of a matrix to matrix.
Definition: Matrix.h:331
size_t size() const
Returns the current size/dimension of the vector.
Definition: SVecSVecAddExpr.h:184
Header file for the isDefault shim.
SVecSVecAddExpr(const VT1 &lhs, const VT2 &rhs)
Constructor for the SVecSVecAddExpr class.
Definition: SVecSVecAddExpr.h:159
VT1::TransposeType TT1
Transpose type of the left-hand side sparse vector expression.
Definition: SVecSVecAddExpr.h:100
SelectType< IsExpression< VT2 >::value, const VT2, const VT2 & >::Type RightOperand
Composite type of the right-hand side sparse vector expression.
Definition: SVecSVecAddExpr.h:148
Header file for the RemoveReference type trait.
Substitution Failure Is Not An Error (SFINAE) class.The DisableIf class template is an auxiliary tool...
Definition: DisableIf.h:184
ResultType::ElementType ElementType
Resulting element type.
Definition: SVecSVecAddExpr.h:136
const SelectType< returnExpr, ExprReturnType, ElementType >::Type ReturnType
Return type for expression template evaluations.
Definition: SVecSVecAddExpr.h:139
AddTrait< RT1, RT2 >::Type ResultType
Result type for expression template evaluations.
Definition: SVecSVecAddExpr.h:134
Header file for the IsComputation type trait class.
SelectType< IsExpression< VT1 >::value, const VT1, const VT1 & >::Type LeftOperand
Composite type of the left-hand side sparse vector expression.
Definition: SVecSVecAddExpr.h:145
Base class for sparse vectors.The SparseVector class is a base class for all arbitrarily sized (N-dim...
Definition: Forward.h:108
#define BLAZE_FUNCTION_TRACE
Function trace macro.This macro can be used to reliably trace function calls. In case function tracin...
Definition: FunctionTrace.h:157
This ResultType
Result type for expression template evaluations.
Definition: CompressedMatrix.h:2403
Header file for basic type definitions.
Header file for the SubvectorExprTrait class template.
ReturnType operator[](size_t index) const
Subscript operator for the direct access to the vector elements.
Definition: SVecSVecAddExpr.h:173
LeftOperand lhs_
Left-hand side sparse vector of the addition expression.
Definition: SVecSVecAddExpr.h:245
Header file for the IsResizable type trait.
#define BLAZE_CONSTRAINT_MUST_BE_VECTOR_WITH_TRANSPOSE_FLAG(T, TF)
Constraint on the data type.In case the given data type T is not a dense or sparse vector type and in...
Definition: TransposeFlag.h:238
#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
Header file for the IsExpression type trait class.
Header file for the FunctionTrace class.