Vector.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_VECTOR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_VECTOR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <blaze/math/Exception.h>
46 #include <blaze/system/Inline.h>
47 #include <blaze/util/Assert.h>
48 #include <blaze/util/DisableIf.h>
49 #include <blaze/util/EnableIf.h>
51 #include <blaze/util/Types.h>
53 #include <blaze/util/Unused.h>
54 
55 
56 namespace blaze {
57 
58 //=================================================================================================
59 //
60 // CLASS DEFINITION
61 //
62 //=================================================================================================
63 
64 //*************************************************************************************************
76 template< typename VT // Type of the vector
77  , bool TF > // Transpose flag
78 struct Vector
79 {
80  //**Type definitions****************************************************************************
81  using VectorType = VT;
82  //**********************************************************************************************
83 
84  //**Non-const conversion operator***************************************************************
90  return *static_cast<VectorType*>( this );
91  }
92  //**********************************************************************************************
93 
94  //**Const conversion operators******************************************************************
99  BLAZE_ALWAYS_INLINE const VectorType& operator~() const noexcept {
100  return *static_cast<const VectorType*>( this );
101  }
102  //**********************************************************************************************
103 };
104 //*************************************************************************************************
105 
106 
107 
108 
109 //=================================================================================================
110 //
111 // GLOBAL FUNCTIONS
112 //
113 //=================================================================================================
114 
115 //*************************************************************************************************
118 template< typename VT, bool TF >
120 
121 template< typename VT, bool TF >
122 BLAZE_ALWAYS_INLINE typename VT::ConstIterator begin( const Vector<VT,TF>& vector );
123 
124 template< typename VT, bool TF >
126 
127 template< typename VT, bool TF >
129 
130 template< typename VT, bool TF >
131 BLAZE_ALWAYS_INLINE typename VT::ConstIterator end( const Vector<VT,TF>& vector );
132 
133 template< typename VT, bool TF >
134 BLAZE_ALWAYS_INLINE typename VT::ConstIterator cend( const Vector<VT,TF>& vector );
135 
136 template< typename VT, bool TF >
137 BLAZE_ALWAYS_INLINE size_t size( const Vector<VT,TF>& vector ) noexcept;
138 
139 template< typename VT, bool TF >
140 BLAZE_ALWAYS_INLINE size_t capacity( const Vector<VT,TF>& vector ) noexcept;
141 
142 template< typename VT, bool TF >
143 BLAZE_ALWAYS_INLINE size_t nonZeros( const Vector<VT,TF>& vector );
144 
145 template< typename VT, bool TF >
146 BLAZE_ALWAYS_INLINE void resize( Vector<VT,TF>& vector, size_t n, bool preserve=true );
147 
148 template< typename VT, bool TF >
150 
151 template< typename VT, bool TF >
152 inline const typename VT::ResultType evaluate( const Vector<VT,TF>& vector );
153 
154 template< typename VT1, bool TF1, typename VT2, bool TF2 >
155 BLAZE_ALWAYS_INLINE bool isSame( const Vector<VT1,TF1>& a, const Vector<VT2,TF2>& b ) noexcept;
157 //*************************************************************************************************
158 
159 
160 //*************************************************************************************************
167 template< typename VT // Type of the vector
168  , bool TF > // Transpose flag of the vector
170 {
171  return (~vector).begin();
172 }
173 //*************************************************************************************************
174 
175 
176 //*************************************************************************************************
183 template< typename VT // Type of the vector
184  , bool TF > // Transpose flag of the vector
186 {
187  return (~vector).begin();
188 }
189 //*************************************************************************************************
190 
191 
192 //*************************************************************************************************
199 template< typename VT // Type of the vector
200  , bool TF > // Transpose flag of the vector
202 {
203  return (~vector).begin();
204 }
205 //*************************************************************************************************
206 
207 
208 //*************************************************************************************************
215 template< typename VT // Type of the vector
216  , bool TF > // Transpose flag of the vector
218 {
219  return (~vector).end();
220 }
221 //*************************************************************************************************
222 
223 
224 //*************************************************************************************************
231 template< typename VT // Type of the vector
232  , bool TF > // Transpose flag of the vector
234 {
235  return (~vector).end();
236 }
237 //*************************************************************************************************
238 
239 
240 //*************************************************************************************************
247 template< typename VT // Type of the vector
248  , bool TF > // Transpose flag of the vector
250 {
251  return (~vector).end();
252 }
253 //*************************************************************************************************
254 
255 
256 //*************************************************************************************************
263 template< typename VT // Type of the vector
264  , bool TF > // Transpose flag of the vector
265 BLAZE_ALWAYS_INLINE size_t size( const Vector<VT,TF>& vector ) noexcept
266 {
267  return (~vector).size();
268 }
269 //*************************************************************************************************
270 
271 
272 //*************************************************************************************************
279 template< typename VT // Type of the vector
280  , bool TF > // Transpose flag of the vector
281 BLAZE_ALWAYS_INLINE size_t capacity( const Vector<VT,TF>& vector ) noexcept
282 {
283  return (~vector).capacity();
284 }
285 //*************************************************************************************************
286 
287 
288 //*************************************************************************************************
298 template< typename VT // Type of the vector
299  , bool TF > // Transpose flag of the vector
301 {
302  return (~vector).nonZeros();
303 }
304 //*************************************************************************************************
305 
306 
307 //*************************************************************************************************
321 template< typename VT // Type of the vector
322  , bool TF > // Transpose flag of the vector
324  resize_backend( Vector<VT,TF>& vector, size_t n, bool preserve )
325 {
326  UNUSED_PARAMETER( preserve );
327 
328  if( (~vector).size() != n ) {
329  BLAZE_THROW_INVALID_ARGUMENT( "Vector cannot be resized" );
330  }
331 }
333 //*************************************************************************************************
334 
335 
336 //*************************************************************************************************
348 template< typename VT // Type of the vector
349  , bool TF > // Transpose flag of the vector
351  resize_backend( Vector<VT,TF>& vector, size_t n, bool preserve )
352 {
353  (~vector).resize( n, preserve );
354 }
356 //*************************************************************************************************
357 
358 
359 //*************************************************************************************************
387 template< typename VT // Type of the vector
388  , bool TF > // Transpose flag of the vector
389 BLAZE_ALWAYS_INLINE void resize( Vector<VT,TF>& vector, size_t n, bool preserve )
390 {
391  resize_backend( vector, n, preserve );
392 }
393 //*************************************************************************************************
394 
395 
396 //*************************************************************************************************
404 template< typename VT // Type of the vector
405  , bool TF > // Transpose flag of the vector
407  shrinkToFit_backend( Vector<VT,TF>& vector )
408 {
409  UNUSED_PARAMETER( vector );
410 }
412 //*************************************************************************************************
413 
414 
415 //*************************************************************************************************
423 template< typename VT // Type of the vector
424  , bool TF > // Transpose flag of the vector
426  shrinkToFit_backend( Vector<VT,TF>& vector )
427 {
428  (~vector).shrinkToFit();
429 }
431 //*************************************************************************************************
432 
433 
434 //*************************************************************************************************
447 template< typename VT // Type of the vector
448  , bool TF > // Transpose flag of the vector
450 {
451  shrinkToFit_backend( vector );
452 }
453 //*************************************************************************************************
454 
455 
456 //*************************************************************************************************
506 template< typename VT // Type of the vector
507  , bool TF > // Transpose flag of the vector
508 inline const typename VT::ResultType evaluate( const Vector<VT,TF>& vector )
509 {
510  const typename VT::ResultType tmp( ~vector );
511  return tmp;
512 }
513 //*************************************************************************************************
514 
515 
516 //*************************************************************************************************
546 template< typename VT1 // Type of the left-hand side vector
547  , bool TF1 // Transpose flag of the left-hand side vector
548  , typename VT2 // Type of the right-hand side vector
549  , bool TF2 > // Transpose flag of the right-hand side vector
550 BLAZE_ALWAYS_INLINE bool isSame( const Vector<VT1,TF1>& a, const Vector<VT2,TF2>& b ) noexcept
551 {
552  return ( IsSame<VT1,VT2>::value &&
553  reinterpret_cast<const void*>( &a ) == reinterpret_cast<const void*>( &b ) );
554 }
555 //*************************************************************************************************
556 
557 
558 //*************************************************************************************************
573 template< typename VT1 // Type of the left-hand side vector
574  , bool TF1 // Transpose flag of the left-hand side vector
575  , typename VT2 // Type of the right-hand side vector
576  , bool TF2 > // Transpose flag of the right-hand side vector
577 BLAZE_ALWAYS_INLINE void assign( Vector<VT1,TF1>& lhs, const Vector<VT2,TF2>& rhs )
578 {
580 
581  BLAZE_INTERNAL_ASSERT( (~lhs).size() == (~rhs).size(), "Invalid vector sizes" );
582  (~lhs).assign( ~rhs );
583 }
585 //*************************************************************************************************
586 
587 
588 //*************************************************************************************************
603 template< typename VT1 // Type of the left-hand side vector
604  , bool TF1 // Transpose flag of the left-hand side vector
605  , typename VT2 // Type of the right-hand side vector
606  , bool TF2 > // Transpose flag of the right-hand side vector
607 BLAZE_ALWAYS_INLINE void addAssign( Vector<VT1,TF1>& lhs, const Vector<VT2,TF2>& rhs )
608 {
610 
611  BLAZE_INTERNAL_ASSERT( (~lhs).size() == (~rhs).size(), "Invalid vector sizes" );
612  (~lhs).addAssign( ~rhs );
613 }
615 //*************************************************************************************************
616 
617 
618 //*************************************************************************************************
633 template< typename VT1 // Type of the left-hand side vector
634  , bool TF1 // Transpose flag of the left-hand side vector
635  , typename VT2 // Type of the right-hand side vector
636  , bool TF2 > // Transpose flag of the right-hand side vector
637 BLAZE_ALWAYS_INLINE void subAssign( Vector<VT1,TF1>& lhs, const Vector<VT2,TF2>& rhs )
638 {
640 
641  BLAZE_INTERNAL_ASSERT( (~lhs).size() == (~rhs).size(), "Invalid vector sizes" );
642  (~lhs).subAssign( ~rhs );
643 }
645 //*************************************************************************************************
646 
647 
648 //*************************************************************************************************
663 template< typename VT1 // Type of the left-hand side vector
664  , bool TF1 // Transpose flag of the left-hand side vector
665  , typename VT2 // Type of the right-hand side vector
666  , bool TF2 > // Transpose flag of the right-hand side vector
667 BLAZE_ALWAYS_INLINE void multAssign( Vector<VT1,TF1>& lhs, const Vector<VT2,TF2>& rhs )
668 {
670 
671  BLAZE_INTERNAL_ASSERT( (~lhs).size() == (~rhs).size(), "Invalid vector sizes" );
672  (~lhs).multAssign( ~rhs );
673 }
675 //*************************************************************************************************
676 
677 
678 //*************************************************************************************************
693 template< typename VT1 // Type of the left-hand side vector
694  , bool TF1 // Transpose flag of the left-hand side vector
695  , typename VT2 // Type of the right-hand side vector
696  , bool TF2 > // Transpose flag of the right-hand side vector
697 BLAZE_ALWAYS_INLINE void divAssign( Vector<VT1,TF1>& lhs, const Vector<VT2,TF2>& rhs )
698 {
700 
701  BLAZE_INTERNAL_ASSERT( (~lhs).size() == (~rhs).size(), "Invalid vector sizes" );
702  (~lhs).divAssign( ~rhs );
703 }
705 //*************************************************************************************************
706 
707 
708 //*************************************************************************************************
723 template< typename VT // Type of the vector
724  , bool TF // Transpose flag
725  , typename ET > // Type of the element
726 BLAZE_ALWAYS_INLINE bool trySet( const Vector<VT,TF>& vec, size_t index, const ET& value )
727 {
728  BLAZE_INTERNAL_ASSERT( index < (~vec).size(), "Invalid vector access index" );
729 
730  UNUSED_PARAMETER( vec, index, value );
731 
732  return true;
733 }
735 //*************************************************************************************************
736 
737 
738 //*************************************************************************************************
753 template< typename VT // Type of the vector
754  , bool TF // Transpose flag
755  , typename ET > // Type of the element
756 BLAZE_ALWAYS_INLINE bool tryAdd( const Vector<VT,TF>& vec, size_t index, const ET& value )
757 {
758  BLAZE_INTERNAL_ASSERT( index < (~vec).size(), "Invalid vector access index" );
759 
760  UNUSED_PARAMETER( vec, index, value );
761 
762  return true;
763 }
765 //*************************************************************************************************
766 
767 
768 //*************************************************************************************************
783 template< typename VT // Type of the vector
784  , bool TF // Transpose flag
785  , typename ET > // Type of the element
786 BLAZE_ALWAYS_INLINE bool trySub( const Vector<VT,TF>& vec, size_t index, const ET& value )
787 {
788  BLAZE_INTERNAL_ASSERT( index < (~vec).size(), "Invalid vector access index" );
789 
790  UNUSED_PARAMETER( vec, index, value );
791 
792  return true;
793 }
795 //*************************************************************************************************
796 
797 
798 //*************************************************************************************************
813 template< typename VT // Type of the vector
814  , bool TF // Transpose flag
815  , typename ET > // Type of the element
816 BLAZE_ALWAYS_INLINE bool tryMult( const Vector<VT,TF>& vec, size_t index, const ET& value )
817 {
818  BLAZE_INTERNAL_ASSERT( index < (~vec).size(), "Invalid vector access index" );
819 
820  UNUSED_PARAMETER( vec, index, value );
821 
822  return true;
823 }
825 //*************************************************************************************************
826 
827 
828 //*************************************************************************************************
844 template< typename VT // Type of the vector
845  , bool TF // Transpose flag
846  , typename ET > // Type of the element
848  tryMult( const Vector<VT,TF>& vec, size_t index, size_t size, const ET& value )
849 {
850  BLAZE_INTERNAL_ASSERT( index <= (~vec).size(), "Invalid vector access index" );
851  BLAZE_INTERNAL_ASSERT( index + size <= (~vec).size(), "Invalid range size" );
852 
853  UNUSED_PARAMETER( vec, index, size, value );
854 
855  return true;
856 }
858 //*************************************************************************************************
859 
860 
861 //*************************************************************************************************
876 template< typename VT // Type of the vector
877  , bool TF // Transpose flag
878  , typename ET > // Type of the element
879 BLAZE_ALWAYS_INLINE bool tryDiv( const Vector<VT,TF>& vec, size_t index, const ET& value )
880 {
881  BLAZE_INTERNAL_ASSERT( index < (~vec).size(), "Invalid vector access index" );
882 
883  UNUSED_PARAMETER( vec, index, value );
884 
885  return true;
886 }
888 //*************************************************************************************************
889 
890 
891 //*************************************************************************************************
907 template< typename VT // Type of the vector
908  , bool TF // Transpose flag
909  , typename ET > // Type of the element
911  tryDiv( const Vector<VT,TF>& vec, size_t index, size_t size, const ET& value )
912 {
913  BLAZE_INTERNAL_ASSERT( index <= (~vec).size(), "Invalid vector access index" );
914  BLAZE_INTERNAL_ASSERT( index + size <= (~vec).size(), "Invalid range size" );
915 
916  UNUSED_PARAMETER( vec, index, size, value );
917 
918  return true;
919 }
921 //*************************************************************************************************
922 
923 
924 //*************************************************************************************************
939 template< typename VT1 // Type of the left-hand side vector
940  , bool TF1 // Transpose flag of the left-hand side vector
941  , typename VT2 // Type of the right-hand side vector
942  , bool TF2 > // Transpose flag of the right-hand side vector
943 BLAZE_ALWAYS_INLINE bool tryAssign( const Vector<VT1,TF1>& lhs, const Vector<VT2,TF2>& rhs, size_t index )
944 {
945  BLAZE_INTERNAL_ASSERT( index <= (~lhs).size(), "Invalid vector access index" );
946  BLAZE_INTERNAL_ASSERT( index + (~rhs).size() <= (~lhs).size(), "Invalid vector size" );
947 
948  UNUSED_PARAMETER( lhs, rhs, index );
949 
950  return true;
951 }
953 //*************************************************************************************************
954 
955 
956 //*************************************************************************************************
971 template< typename VT1 // Type of the left-hand side vector
972  , bool TF1 // Transpose flag of the left-hand side vector
973  , typename VT2 // Type of the right-hand side vector
974  , bool TF2 > // Transpose flag of the right-hand side vector
975 BLAZE_ALWAYS_INLINE bool tryAddAssign( const Vector<VT1,TF1>& lhs, const Vector<VT2,TF2>& rhs, size_t index )
976 {
977  BLAZE_INTERNAL_ASSERT( index <= (~lhs).size(), "Invalid vector access index" );
978  BLAZE_INTERNAL_ASSERT( index + (~rhs).size() <= (~lhs).size(), "Invalid vector size" );
979 
980  UNUSED_PARAMETER( lhs, rhs, index );
981 
982  return true;
983 }
985 //*************************************************************************************************
986 
987 
988 //*************************************************************************************************
1003 template< typename VT1 // Type of the left-hand side vector
1004  , bool TF1 // Transpose flag of the left-hand side vector
1005  , typename VT2 // Type of the right-hand side vector
1006  , bool TF2 > // Transpose flag of the right-hand side vector
1007 BLAZE_ALWAYS_INLINE bool trySubAssign( const Vector<VT1,TF1>& lhs, const Vector<VT2,TF2>& rhs, size_t index )
1008 {
1009  BLAZE_INTERNAL_ASSERT( index <= (~lhs).size(), "Invalid vector access index" );
1010  BLAZE_INTERNAL_ASSERT( index + (~rhs).size() <= (~lhs).size(), "Invalid vector size" );
1011 
1012  UNUSED_PARAMETER( lhs, rhs, index );
1013 
1014  return true;
1015 }
1017 //*************************************************************************************************
1018 
1019 
1020 //*************************************************************************************************
1035 template< typename VT1 // Type of the left-hand side vector
1036  , bool TF1 // Transpose flag of the left-hand side vector
1037  , typename VT2 // Type of the right-hand side vector
1038  , bool TF2 > // Transpose flag of the right-hand side vector
1039 BLAZE_ALWAYS_INLINE bool tryMultAssign( const Vector<VT1,TF1>& lhs, const Vector<VT2,TF2>& rhs, size_t index )
1040 {
1041  BLAZE_INTERNAL_ASSERT( index <= (~lhs).size(), "Invalid vector access index" );
1042  BLAZE_INTERNAL_ASSERT( index + (~rhs).size() <= (~lhs).size(), "Invalid vector size" );
1043 
1044  UNUSED_PARAMETER( lhs, rhs, index );
1045 
1046  return true;
1047 }
1049 //*************************************************************************************************
1050 
1051 
1052 //*************************************************************************************************
1067 template< typename VT1 // Type of the left-hand side vector
1068  , bool TF1 // Transpose flag of the left-hand side vector
1069  , typename VT2 // Type of the right-hand side vector
1070  , bool TF2 > // Transpose flag of the right-hand side vector
1071 BLAZE_ALWAYS_INLINE bool tryDivAssign( const Vector<VT1,TF1>& lhs, const Vector<VT2,TF2>& rhs, size_t index )
1072 {
1073  BLAZE_INTERNAL_ASSERT( index <= (~lhs).size(), "Invalid vector access index" );
1074  BLAZE_INTERNAL_ASSERT( index + (~rhs).size() <= (~lhs).size(), "Invalid vector size" );
1075 
1076  UNUSED_PARAMETER( lhs, rhs, index );
1077 
1078  return true;
1079 }
1081 //*************************************************************************************************
1082 
1083 
1084 //*************************************************************************************************
1099 template< typename VT // Type of the vector
1100  , bool TF > // Transpose flag of the vector
1101 BLAZE_ALWAYS_INLINE VT& derestrict( Vector<VT,TF>& vector )
1102 {
1103  return ~vector;
1104 }
1106 //*************************************************************************************************
1107 
1108 } // namespace blaze
1109 
1110 #endif
#define BLAZE_THROW_INVALID_ARGUMENT(MESSAGE)
Macro for the emission of a std::invalid_argument exception.This macro encapsulates the default way o...
Definition: Exception.h:235
Header file for the UNUSED_PARAMETER function template.
BLAZE_ALWAYS_INLINE size_t capacity(const Matrix< MT, SO > &matrix) noexcept
Returns the maximum capacity of the matrix.
Definition: Matrix.h:522
BLAZE_ALWAYS_INLINE bool isSame(const Matrix< MT1, SO1 > &a, const Matrix< MT2, SO2 > &b) noexcept
Returns whether the two given matrices represent the same observable state.
Definition: Matrix.h:949
Header file for basic type definitions.
BLAZE_ALWAYS_INLINE size_t size(const Vector< VT, TF > &vector) noexcept
Returns the current size/dimension of the vector.
Definition: Vector.h:265
Header file for the IsSame and IsStrictlySame type traits.
This ResultType
Result type for expression template evaluations.
Definition: CompressedMatrix.h:3076
BLAZE_ALWAYS_INLINE MT::Iterator begin(Matrix< MT, SO > &matrix, size_t i)
Returns an iterator to the first element of row/column i.
Definition: Matrix.h:364
BLAZE_ALWAYS_INLINE void shrinkToFit(Matrix< MT, SO > &matrix)
Requesting the removal of unused capacity.
Definition: Matrix.h:775
typename DisableIf< Condition, T >::Type DisableIf_
Auxiliary type for the DisableIf class template.The DisableIf_ alias declaration provides a convenien...
Definition: DisableIf.h:224
BLAZE_ALWAYS_INLINE size_t nonZeros(const Matrix< MT, SO > &matrix)
Returns the total number of non-zero elements in the matrix.
Definition: Matrix.h:560
Type relationship analysis.This class tests if the two data types A and B are equal. For this type comparison, the cv-qualifiers of both data types are ignored. If A and B are the same data type (ignoring the cv-qualifiers), then the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType.
Definition: IsSame.h:140
Element * Iterator
Iterator over non-constant elements.
Definition: CompressedMatrix.h:3084
const MT::ResultType evaluate(const Matrix< MT, SO > &matrix)
Evaluates the given matrix expression.
Definition: Matrix.h:888
BLAZE_ALWAYS_INLINE VectorType & operator~() noexcept
Conversion operator for non-constant vectors.
Definition: Vector.h:89
BLAZE_ALWAYS_INLINE MT::ConstIterator cend(const Matrix< MT, SO > &matrix, size_t i)
Returns an iterator just past the last element of row/column i.
Definition: Matrix.h:474
BLAZE_ALWAYS_INLINE MT::ConstIterator cbegin(const Matrix< MT, SO > &matrix, size_t i)
Returns an iterator to the first element of row/column i.
Definition: Matrix.h:408
Header file for the DisableIf class template.
Namespace of the Blaze C++ math library.
Definition: Blaze.h:58
#define BLAZE_ALWAYS_INLINE
Platform dependent setup of an enforced inline keyword.
Definition: Inline.h:85
Expression object for sparse matrix-sparse vector multiplications.The TSMatSVecMultExpr class represe...
Definition: Forward.h:167
Header file for the IsShrinkable type trait.
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:3085
Header file for the exception macros of the math module.
BLAZE_ALWAYS_INLINE void resize(Matrix< MT, SO > &matrix, size_t rows, size_t columns, bool preserve=true)
Changing the size of the matrix.
Definition: Matrix.h:714
BLAZE_ALWAYS_INLINE MT::Iterator end(Matrix< MT, SO > &matrix, size_t i)
Returns an iterator just past the last element of row/column i.
Definition: Matrix.h:430
Header file for the EnableIf class template.
Header file for run time assertion macros.
#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
typename EnableIf< Condition, T >::Type EnableIf_
Auxiliary alias declaration for the EnableIf class template.The EnableIf_ alias declaration provides ...
Definition: EnableIf.h:224
Base class for N-dimensional vectors.The Vector class is a base class for all arbitrarily sized (N-di...
Definition: Forward.h:177
void UNUSED_PARAMETER(const Args &...)
Suppression of unused parameter warnings.
Definition: Unused.h:81
Header file for the IsResizable type trait.
System settings for the inline keywords.
#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 function trace functionality.
BLAZE_ALWAYS_INLINE const VectorType & operator~() const noexcept
Conversion operator for constant vectors.
Definition: Vector.h:99