Elements.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_ELEMENTS_H_
36 #define _BLAZE_MATH_ELEMENTS_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <blaze/math/Aliases.h>
47 #include <blaze/math/Exception.h>
51 #include <blaze/util/Random.h>
53 
54 
55 namespace blaze {
56 
57 //=================================================================================================
58 //
59 // RAND SPECIALIZATION FOR DENSE ELEMENT SELECTIONS
60 //
61 //=================================================================================================
62 
63 //*************************************************************************************************
70 template< typename VT // Type of the vector
71  , bool TF // Transpose flag
72  , size_t... CEAs > // Compile time element arguments
73 class Rand< Elements<VT,TF,true,CEAs...> >
74 {
75  public:
76  //**Randomize functions*************************************************************************
79  template< typename ET >
80  inline void randomize( ET&& elements ) const;
81 
82  template< typename ET, typename Arg >
83  inline void randomize( ET&& elements, const Arg& min, const Arg& max ) const;
85  //**********************************************************************************************
86 };
88 //*************************************************************************************************
89 
90 
91 //*************************************************************************************************
98 template< typename VT // Type of the vector
99  , bool TF // Transpose flag
100  , size_t... CEAs > // Compile time element arguments
101 template< typename ET > // Type of the element selection
102 inline void Rand< Elements<VT,TF,true,CEAs...> >::randomize( ET&& elements ) const
103 {
104  using blaze::randomize;
105 
106  using ElementsType = RemoveReference_<ET>;
107 
110 
111  for( size_t i=0UL; i<elements.size(); ++i ) {
112  randomize( elements[i] );
113  }
114 }
116 //*************************************************************************************************
117 
118 
119 //*************************************************************************************************
128 template< typename VT // Type of the vector
129  , bool TF // Transpose flag
130  , size_t... CEAs > // Compile time element arguments
131 template< typename ET // Type of the element selection
132  , typename Arg > // Min/max argument type
133 inline void Rand< Elements<VT,TF,true,CEAs...> >::randomize( ET&& elements, const Arg& min, const Arg& max ) const
134 {
135  using blaze::randomize;
136 
137  using ElementsType = RemoveReference_<ET>;
138 
141 
142  for( size_t i=0UL; i<elements.size(); ++i ) {
143  randomize( elements[i], min, max );
144  }
145 }
147 //*************************************************************************************************
148 
149 
150 
151 
152 //=================================================================================================
153 //
154 // RAND SPECIALIZATION FOR SPARSE ELEMENT SELECTIONS
155 //
156 //=================================================================================================
157 
158 //*************************************************************************************************
165 template< typename VT // Type of the vector
166  , bool TF // Transpose flag
167  , size_t... CEAs > // Compile time element arguments
168 class Rand< Elements<VT,TF,false,CEAs...> >
169 {
170  public:
171  //**Randomize functions*************************************************************************
174  template< typename ET >
175  inline void randomize( ET&& elements ) const;
176 
177  template< typename ET >
178  inline void randomize( ET&& elements, size_t nonzeros ) const;
179 
180  template< typename ET, typename Arg >
181  inline void randomize( ET&& elements, const Arg& min, const Arg& max ) const;
182 
183  template< typename ET, typename Arg >
184  inline void randomize( ET&& elements, size_t nonzeros, const Arg& min, const Arg& max ) const;
186  //**********************************************************************************************
187 };
189 //*************************************************************************************************
190 
191 
192 //*************************************************************************************************
199 template< typename VT // Type of the vector
200  , bool TF // Transpose flag
201  , size_t... CEAs > // Compile time element arguments
202 template< typename ET > // Type of the element selection
203 inline void Rand< Elements<VT,TF,false,CEAs...> >::randomize( ET&& elements ) const
204 {
205  using ElementsType = RemoveReference_<ET>;
206  using ElementType = ElementType_<ElementsType>;
207 
210 
211  const size_t size( elements.size() );
212 
213  if( size == 0UL ) return;
214 
215  const size_t nonzeros( rand<size_t>( 1UL, std::ceil( 0.5*size ) ) );
216 
217  elements.reset();
218  elements.reserve( nonzeros );
219 
220  while( elements.nonZeros() < nonzeros ) {
221  elements[ rand<size_t>( 0UL, size-1UL ) ] = rand<ElementType>();
222  }
223 }
225 //*************************************************************************************************
226 
227 
228 //*************************************************************************************************
237 template< typename VT // Type of the vector
238  , bool TF // Transpose flag
239  , size_t... CEAs > // Compile time element arguments
240 template< typename ET > // Type of the element selection
241 inline void Rand< Elements<VT,TF,false,CEAs...> >::randomize( ET&& elements, size_t nonzeros ) const
242 {
243  using ElementsType = RemoveReference_<ET>;
244  using ElementType = ElementType_<ElementsType>;
245 
248 
249  const size_t size( elements.size() );
250 
251  if( nonzeros > size ) {
252  BLAZE_THROW_INVALID_ARGUMENT( "Invalid number of non-zero elements" );
253  }
254 
255  if( size == 0UL ) return;
256 
257  elements.reset();
258  elements.reserve( nonzeros );
259 
260  while( elements.nonZeros() < nonzeros ) {
261  elements[ rand<size_t>( 0UL, size-1UL ) ] = rand<ElementType>();
262  }
263 }
265 //*************************************************************************************************
266 
267 
268 //*************************************************************************************************
277 template< typename VT // Type of the vector
278  , bool TF // Transpose flag
279  , size_t... CEAs > // Compile time element arguments
280 template< typename ET // Type of the element selection
281  , typename Arg > // Min/max argument type
282 inline void Rand< Elements<VT,TF,false,CEAs...> >::randomize( ET&& elements,
283  const Arg& min, const Arg& max ) const
284 {
285  using ElementsType = RemoveReference_<ET>;
286  using ElementType = ElementType_<ElementsType>;
287 
290 
291  const size_t size( elements.size() );
292 
293  if( size == 0UL ) return;
294 
295  const size_t nonzeros( rand<size_t>( 1UL, std::ceil( 0.5*size ) ) );
296 
297  elements.reset();
298  elements.reserve( nonzeros );
299 
300  while( elements.nonZeros() < nonzeros ) {
301  elements[ rand<size_t>( 0UL, size-1UL ) ] = rand<ElementType>( min, max );
302  }
303 }
305 //*************************************************************************************************
306 
307 
308 //*************************************************************************************************
319 template< typename VT // Type of the vector
320  , bool TF // Transpose flag
321  , size_t... CEAs > // Compile time element arguments
322 template< typename ET // Type of the element selection
323  , typename Arg > // Min/max argument type
324 inline void Rand< Elements<VT,TF,false,CEAs...> >::randomize( ET&& elements, size_t nonzeros,
325  const Arg& min, const Arg& max ) const
326 {
327  using ElementsType = RemoveReference_<ET>;
328  using ElementType = ElementType_<ElementsType>;
329 
332 
333  const size_t size( elements.size() );
334 
335  if( nonzeros > size ) {
336  BLAZE_THROW_INVALID_ARGUMENT( "Invalid number of non-zero elements" );
337  }
338 
339  if( size == 0UL ) return;
340 
341  elements.reset();
342  elements.reserve( nonzeros );
343 
344  while( elements.nonZeros() < nonzeros ) {
345  elements[ rand<size_t>( 0UL, size-1UL ) ] = rand<ElementType>( min, max );
346  }
347 }
349 //*************************************************************************************************
350 
351 } // namespace blaze
352 
353 #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 auxiliary alias declarations.
BLAZE_ALWAYS_INLINE size_t size(const Vector< VT, TF > &vector) noexcept
Returns the current size/dimension of the vector.
Definition: Vector.h:265
decltype(auto) ceil(const DenseMatrix< MT, SO > &dm)
Applies the ceil() function to each single element of the dense matrix dm.
Definition: DMatMapExpr.h:1234
#define BLAZE_CONSTRAINT_MUST_BE_ELEMENTS_TYPE(T)
Constraint on the data type.In case the given data type T is not an element selection (i...
Definition: Elements.h:61
void randomize(T &&value)
Randomization of a given variable.
Definition: Random.h:929
const ElementType_< MT > min(const DenseMatrix< MT, SO > &dm)
Returns the smallest element of the dense matrix.
Definition: DenseMatrix.h:1903
Constraint on the data type.
Implementation of a random number generator.
const ElementType_< MT > max(const DenseMatrix< MT, SO > &dm)
Returns the largest element of the dense matrix.
Definition: DenseMatrix.h:1950
void randomize(T &value) const
Randomization of the given variable with a new value in the range .
Definition: Random.h:292
Header file for the dense vector SMP implementation.
Namespace of the Blaze C++ math library.
Definition: Blaze.h:58
Type ElementType
Type of the compressed matrix elements.
Definition: CompressedMatrix.h:3079
#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:61
decltype(auto) elements(Vector< VT, TF > &vector, REAs... args)
Creating a view on a selection of elements of the given vector.
Definition: Elements.h:134
Constraint on the data type.
Header file for the exception macros of the math module.
Constraint on the data type.
Header file for the RemoveReference type trait.
#define BLAZE_CONSTRAINT_MUST_BE_DENSE_VECTOR_TYPE(T)
Constraint on the data type.In case the given data type T is not a dense, N-dimensional vector type...
Definition: DenseVector.h:61
Header file for the implementation of the Elements view.
Header file for the sparse vector SMP implementation.