All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
SVecSVecSubExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_SVECSVECSUBEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_SVECSVECSUBEXPR_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 SVECSVECSUBEXPR
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 SVecSVecSubExpr : public SparseVector< SVecSVecSubExpr<VT1,VT2,TF>, TF >
89  , private VecVecSubExpr
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 SVecSVecSubExpr( const VT1& lhs, const VT2& rhs )
160  : lhs_( lhs ) // Left-hand side sparse vector of the subtraction expression
161  , rhs_( rhs ) // Right-hand side sparse vector of the subtraction 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 SVecSVecSubExpr& 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 SVecSVecSubExpr& 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 SVecSVecSubExpr& 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 SVecSVecSubExpr& rhs )
421  {
423 
424  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
425 
426  addAssign( ~lhs, rhs.lhs_ );
427  subAssign( ~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 SVecSVecSubExpr& rhs )
450  {
452 
453  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
454 
455  subAssign( ~lhs, rhs.lhs_ );
456  addAssign( ~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 SVecSVecSubExpr& 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 SVecSVecSubExpr& rhs )
523  {
525 
526  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
527 
528  smpAddAssign( ~lhs, rhs.lhs_ );
529  smpSubAssign( ~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*************************************************
553  template< typename VT > // Type of the target dense vector
554  friend inline typename EnableIf< UseSMPAssign<VT> >::Type
555  smpSubAssign( DenseVector<VT,TF>& lhs, const SVecSVecSubExpr& rhs )
556  {
558 
559  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
560 
561  smpSubAssign( ~lhs, rhs.lhs_ );
562  smpAddAssign( ~lhs, rhs.rhs_ );
563  }
565  //**********************************************************************************************
566 
567  //**SMP subtraction assignment to sparse vectors************************************************
568  // No special implementation for the SMP subtraction assignment to sparse vectors.
569  //**********************************************************************************************
570 
571  //**SMP multiplication assignment to dense vectors**********************************************
586  template< typename VT > // Type of the target dense vector
587  friend inline typename EnableIf< UseSMPAssign<VT> >::Type
588  smpMultAssign( DenseVector<VT,TF>& lhs, const SVecSVecSubExpr& rhs )
589  {
591 
595 
596  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
597 
598  const ResultType tmp( rhs );
599  smpMultAssign( ~lhs, tmp );
600  }
602  //**********************************************************************************************
603 
604  //**SMP multiplication assignment to sparse vectors*********************************************
605  // No special implementation for the SMP multiplication assignment to sparse vectors.
606  //**********************************************************************************************
607 
608  //**Compile time checks*************************************************************************
615  //**********************************************************************************************
616 };
617 //*************************************************************************************************
618 
619 
620 
621 
622 //=================================================================================================
623 //
624 // GLOBAL BINARY ARITHMETIC OPERATORS
625 //
626 //=================================================================================================
627 
628 //*************************************************************************************************
652 template< typename T1 // Type of the left-hand side sparse vector
653  , typename T2 // Type of the right-hand side sparse vector
654  , bool TF > // Transpose flag
655 inline const SVecSVecSubExpr<T1,T2,TF>
657 {
659 
660  if( (~lhs).size() != (~rhs).size() )
661  throw std::invalid_argument( "Vector sizes do not match" );
662 
663  return SVecSVecSubExpr<T1,T2,TF>( ~lhs, ~rhs );
664 }
665 //*************************************************************************************************
666 
667 
668 
669 
670 //=================================================================================================
671 //
672 // EXPRESSION TRAIT SPECIALIZATIONS
673 //
674 //=================================================================================================
675 
676 //*************************************************************************************************
678 template< typename VT1, typename VT2, bool TF, bool AF >
679 struct SubvectorExprTrait< SVecSVecSubExpr<VT1,VT2,TF>, AF >
680 {
681  public:
682  //**********************************************************************************************
683  typedef typename SubExprTrait< typename SubvectorExprTrait<const VT1,AF>::Type
684  , typename SubvectorExprTrait<const VT2,AF>::Type >::Type Type;
685  //**********************************************************************************************
686 };
688 //*************************************************************************************************
689 
690 } // namespace blaze
691 
692 #endif
Header file for mathematical functions.
Compile time check whether the given type is a temporary vector or matrix type.This type trait class ...
Definition: IsTemporary.h:87
Header file for the subtraction trait.
Header file for the SparseVector base class.
RightOperand rhs_
Right-hand side sparse vector of the subtraction expression.
Definition: SVecSVecSubExpr.h:246
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
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
bool canAlias(const T *alias) const
Returns whether the expression can alias with the given address alias.
Definition: SVecSVecSubExpr.h:226
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
ResultType::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: SVecSVecSubExpr.h:135
Header file for the Computation base class.
VT2::ResultType RT2
Result type of the right-hand side sparse vector expression.
Definition: SVecSVecSubExpr.h:95
const SelectType< returnExpr, ExprReturnType, ElementType >::Type ReturnType
Return type for expression template evaluations.
Definition: SVecSVecSubExpr.h:139
Constraint on the data type.
bool isAliased(const T *alias) const
Returns whether the expression is aliased with the given address alias.
Definition: SVecSVecSubExpr.h:238
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
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.
Expression object for sparse vector-sparse vector subtractions.The SVecSVecSubExpr class represents t...
Definition: Forward.h:120
size_t nonZeros() const
Returns the number of non-zero elements in the sparse vector.
Definition: SVecSVecSubExpr.h:194
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:2412
VT1::CompositeType CT1
Composite type of the left-hand side sparse vector expression.
Definition: SVecSVecSubExpr.h:98
RightOperand rightOperand() const
Returns the right-hand side sparse vector operand.
Definition: SVecSVecSubExpr.h:214
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
VT1::TransposeType TT1
Transpose type of the left-hand side sparse vector expression.
Definition: SVecSVecSubExpr.h:100
VT2::CompositeType CT2
Composite type of the right-hand side sparse vector expression.
Definition: SVecSVecSubExpr.h:99
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
Evaluation of the return type of a subtraction expression.Via this type trait it is possible to evalu...
Definition: SubExprTrait.h:103
LeftOperand leftOperand() const
Returns the left-hand side sparse vector operand.
Definition: SVecSVecSubExpr.h:204
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 VecVecSubExpr base class.
Header file for the SelectType class template.
Header file for all forward declarations for expression class templates.
Constraint on the data type.
SelectType< IsExpression< VT1 >::value, const VT1, const VT1 & >::Type LeftOperand
Composite type of the left-hand side sparse vector expression.
Definition: SVecSVecSubExpr.h:145
SubExprTrait< RN1, RN2 >::Type ExprReturnType
Expression return type for the subscript operator.
Definition: SVecSVecSubExpr.h:114
Header file for the EnableIf class template.
Header file for the serial shim.
SelectType< IsExpression< VT2 >::value, const VT2, const VT2 & >::Type RightOperand
Composite type of the right-hand side sparse vector expression.
Definition: SVecSVecSubExpr.h:148
SVecSVecSubExpr(const VT1 &lhs, const VT2 &rhs)
Constructor for the SVecSVecSubExpr class.
Definition: SVecSVecSubExpr.h:159
const ResultType CompositeType
Data type for composite expression templates.
Definition: SVecSVecSubExpr.h:142
LeftOperand lhs_
Left-hand side sparse vector of the subtraction expression.
Definition: SVecSVecSubExpr.h:245
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
Header file for run time assertion macros.
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
const DenseIterator< Type > operator-(const DenseIterator< Type > &it, ptrdiff_t inc)
Subtraction between a DenseIterator and an integral value.
Definition: DenseIterator.h:585
Substitution Failure Is Not An Error (SFINAE) class.The EnableIf class template is an auxiliary tool ...
Definition: EnableIf.h:184
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
Header file for the isDefault shim.
VT1::ResultType RT1
Result type of the left-hand side sparse vector expression.
Definition: SVecSVecSubExpr.h:94
size_t size() const
Returns the current size/dimension of the vector.
Definition: SVecSVecSubExpr.h:184
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
VT1::ReturnType RN1
Return type of the left-hand side sparse vector expression.
Definition: SVecSVecSubExpr.h:96
ReturnType operator[](size_t index) const
Subscript operator for the direct access to the vector elements.
Definition: SVecSVecSubExpr.h:173
Header file for the IsComputation type trait class.
VT2::TransposeType TT2
Transpose type of the right-hand side sparse vector expression.
Definition: SVecSVecSubExpr.h:101
Base class for sparse vectors.The SparseVector class is a base class for all arbitrarily sized (N-dim...
Definition: Forward.h:108
VT2::ReturnType RN2
Return type of the right-hand side sparse vector expression.
Definition: SVecSVecSubExpr.h:97
#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
SVecSVecSubExpr< VT1, VT2, TF > This
Type of this SVecSVecSubExpr instance.
Definition: SVecSVecSubExpr.h:133
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.
Base template for the SubTrait class.
Definition: SubTrait.h:141
ResultType::ElementType ElementType
Resulting element type.
Definition: SVecSVecSubExpr.h:136
SubTrait< RT1, RT2 >::Type ResultType
Result type for expression template evaluations.
Definition: SVecSVecSubExpr.h:134
Header file for the IsResizable type trait.
Header file for the SubExprTrait class template.
#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.