Blaze 3.9
Subvector.h
Go to the documentation of this file.
1//=================================================================================================
33//=================================================================================================
34
35#ifndef _BLAZE_MATH_SUBVECTOR_H_
36#define _BLAZE_MATH_SUBVECTOR_H_
37
38
39//*************************************************************************************************
40// Includes
41//*************************************************************************************************
42
43#include <blaze/math/Aliases.h>
52#include <blaze/util/Random.h>
54
55
56namespace blaze {
57
58//=================================================================================================
59//
60// RAND SPECIALIZATION FOR DENSE SUBVECTORS
61//
62//=================================================================================================
63
64//*************************************************************************************************
71template< typename VT // Type of the vector
72 , AlignmentFlag AF // Alignment flag
73 , bool TF // Transpose flag
74 , size_t... CSAs > // Compile time subvector arguments
75class Rand< Subvector<VT,AF,TF,true,CSAs...> >
76{
77 public:
78 //**********************************************************************************************
84 template< typename SVT > // Type of the subvector
85 inline void randomize( SVT&& subvector ) const
86 {
87 using blaze::randomize;
88
89 using SubvectorType = RemoveReference_t<SVT>;
90
93
94 for( size_t i=0UL; i<subvector.size(); ++i ) {
95 randomize( subvector[i] );
96 }
97 }
98 //**********************************************************************************************
99
100 //**********************************************************************************************
108 template< typename SVT // Type of the subvector
109 , typename Arg > // Min/max argument type
110 inline void randomize( SVT&& subvector, const Arg& min, const Arg& max ) const
111 {
112 using blaze::randomize;
113
114 using SubvectorType = RemoveReference_t<SVT>;
115
118
119 for( size_t i=0UL; i<subvector.size(); ++i ) {
120 randomize( subvector[i], min, max );
121 }
122 }
123 //**********************************************************************************************
124};
126//*************************************************************************************************
127
128
129
130
131//=================================================================================================
132//
133// RAND SPECIALIZATION FOR SPARSE SUBVECTORS
134//
135//=================================================================================================
136
137//*************************************************************************************************
144template< typename VT // Type of the vector
145 , AlignmentFlag AF // Alignment flag
146 , bool TF // Transpose flag
147 , size_t... CSAs > // Compile time subvector arguments
148class Rand< Subvector<VT,AF,TF,false,CSAs...> >
149{
150 public:
151 //**********************************************************************************************
157 template< typename SVT > // Type of the subvector
158 inline void randomize( SVT&& subvector ) const
159 {
160 using SubvectorType = RemoveReference_t<SVT>;
161 using ElementType = ElementType_t<SubvectorType>;
162
165
166 const size_t size( subvector.size() );
167
168 if( size == 0UL ) return;
169
170 const size_t nonzeros( rand<size_t>( 1UL, std::ceil( 0.5*size ) ) );
171
172 subvector.reset();
173 subvector.reserve( nonzeros );
174
175 while( subvector.nonZeros() < nonzeros ) {
176 subvector[ rand<size_t>( 0UL, size-1UL ) ] = rand<ElementType>();
177 }
178 }
179 //*************************************************************************************************
180
181 //*************************************************************************************************
189 template< typename SVT > // Type of the subvector
190 inline void randomize( SVT&& subvector, size_t nonzeros ) const
191 {
192 using SubvectorType = RemoveReference_t<SVT>;
193 using ElementType = ElementType_t<SubvectorType>;
194
197
198 const size_t size( subvector.size() );
199
200 if( nonzeros > size ) {
201 BLAZE_THROW_INVALID_ARGUMENT( "Invalid number of non-zero elements" );
202 }
203
204 if( size == 0UL ) return;
205
206 subvector.reset();
207 subvector.reserve( nonzeros );
208
209 while( subvector.nonZeros() < nonzeros ) {
210 subvector[ rand<size_t>( 0UL, size-1UL ) ] = rand<ElementType>();
211 }
212 }
213 //*************************************************************************************************
214
215 //*************************************************************************************************
223 template< typename SVT // Type of the subvector
224 , typename Arg > // Min/max argument type
225 inline void randomize( SVT&& subvector, const Arg& min, const Arg& max ) const
226 {
227 using SubvectorType = RemoveReference_t<SVT>;
228 using ElementType = ElementType_t<SubvectorType>;
229
232
233 const size_t size( subvector.size() );
234
235 if( size == 0UL ) return;
236
237 const size_t nonzeros( rand<size_t>( 1UL, std::ceil( 0.5*size ) ) );
238
239 subvector.reset();
240 subvector.reserve( nonzeros );
241
242 while( subvector.nonZeros() < nonzeros ) {
243 subvector[ rand<size_t>( 0UL, size-1UL ) ] = rand<ElementType>( min, max );
244 }
245 }
246 //*************************************************************************************************
247
248 //*************************************************************************************************
258 template< typename SVT // Type of the subvector
259 , typename Arg > // Min/max argument type
260 inline void randomize( SVT&& subvector, size_t nonzeros, const Arg& min, const Arg& max ) const
261 {
262 using SubvectorType = RemoveReference_t<SVT>;
263 using ElementType = ElementType_t<SubvectorType>;
264
267
268 const size_t size( subvector.size() );
269
270 if( nonzeros > size ) {
271 BLAZE_THROW_INVALID_ARGUMENT( "Invalid number of non-zero elements" );
272 }
273
274 if( size == 0UL ) return;
275
276 subvector.reset();
277 subvector.reserve( nonzeros );
278
279 while( subvector.nonZeros() < nonzeros ) {
280 subvector[ rand<size_t>( 0UL, size-1UL ) ] = rand<ElementType>( min, max );
281 }
282 }
283 //*************************************************************************************************
284};
286//*************************************************************************************************
287
288} // namespace blaze
289
290#endif
Header file for auxiliary alias declarations.
Header file for the RemoveReference type trait.
Constraint on the data type.
Constraint on the data type.
Constraint on the data type.
decltype(auto) min(const DenseMatrix< MT1, SO1 > &lhs, const DenseMatrix< MT2, SO2 > &rhs)
Computes the componentwise minimum of the dense matrices lhs and rhs.
Definition: DMatDMatMapExpr.h:1339
decltype(auto) max(const DenseMatrix< MT1, SO1 > &lhs, const DenseMatrix< MT2, SO2 > &rhs)
Computes the componentwise maximum of the dense matrices lhs and rhs.
Definition: DMatDMatMapExpr.h:1375
decltype(auto) ceil(const DenseMatrix< MT, SO > &dm)
Applies the ceil() function to each single element of the dense matrix dm.
Definition: DMatMapExpr.h:1380
#define BLAZE_CONSTRAINT_MUST_BE_SPARSE_VECTOR_TYPE(T)
Constraint on the data type.
Definition: SparseVector.h:61
#define BLAZE_CONSTRAINT_MUST_BE_DENSE_VECTOR_TYPE(T)
Constraint on the data type.
Definition: DenseVector.h:61
#define BLAZE_CONSTRAINT_MUST_BE_SUBVECTOR_TYPE(T)
Constraint on the data type.
Definition: Subvector.h:61
AlignmentFlag
Alignment flag for (un-)aligned vectors and matrices.
Definition: AlignmentFlag.h:63
constexpr size_t size(const Matrix< MT, SO > &matrix) noexcept
Returns the total number of elements of the matrix.
Definition: Matrix.h:676
void randomize(T &&value)
Randomization of a given variable.
Definition: Random.h:626
decltype(auto) subvector(Vector< VT, TF > &, RSAs...)
Creating a view on a specific subvector of the given vector.
Definition: Subvector.h:158
#define BLAZE_THROW_INVALID_ARGUMENT(MESSAGE)
Macro for the emission of a std::invalid_argument exception.
Definition: Exception.h:235
Header file for the exception macros of the math module.
Header file for the dense vector SMP implementation.
Header file for the sparse vector SMP implementation.
Implementation of a random number generator.
Header file for the implementation of the Submatrix view.
Header file for the implementation of the Subvector view.