Column.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_COLUMN_H_
36 #define _BLAZE_MATH_COLUMN_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <blaze/math/Aliases.h>
44 #include <blaze/math/Exception.h>
48 #include <blaze/math/views/Row.h>
49 #include <blaze/util/Random.h>
50 
51 
52 namespace blaze {
53 
54 //=================================================================================================
55 //
56 // RAND SPECIALIZATION FOR DENSE COLUMNS
57 //
58 //=================================================================================================
59 
60 //*************************************************************************************************
67 template< typename MT // Type of the dense matrix
68  , bool SO // Storage order
69  , bool SF > // Symmetry flag
70 class Rand< Column<MT,SO,true,SF> >
71 {
72  public:
73  //**Randomize functions*************************************************************************
76  inline void randomize( Column<MT,SO,true,SF>& column ) const;
77 
78  template< typename Arg >
79  inline void randomize( Column<MT,SO,true,SF>& column, const Arg& min, const Arg& max ) const;
81  //**********************************************************************************************
82 };
84 //*************************************************************************************************
85 
86 
87 //*************************************************************************************************
94 template< typename MT // Type of the dense matrix
95  , bool SO // Storage order
96  , bool SF > // Symmetry flag
97 inline void Rand< Column<MT,SO,true,SF> >::randomize( Column<MT,SO,true,SF>& column ) const
98 {
99  using blaze::randomize;
100 
101  for( size_t i=0UL; i<column.size(); ++i ) {
102  randomize( column[i] );
103  }
104 }
106 //*************************************************************************************************
107 
108 
109 //*************************************************************************************************
118 template< typename MT // Type of the dense matrix
119  , bool SO // Storage order
120  , bool SF > // Symmetry flag
121 template< typename Arg > // Min/max argument type
122 inline void Rand< Column<MT,SO,true,SF> >::randomize( Column<MT,SO,true,SF>& column,
123  const Arg& min, const Arg& max ) const
124 {
125  using blaze::randomize;
126 
127  for( size_t i=0UL; i<column.size(); ++i ) {
128  randomize( column[i], min, max );
129  }
130 }
132 //*************************************************************************************************
133 
134 
135 
136 
137 //=================================================================================================
138 //
139 // RAND SPECIALIZATION FOR SPARSE COLUMNS
140 //
141 //=================================================================================================
142 
143 //*************************************************************************************************
150 template< typename MT // Type of the sparse matrix
151  , bool SO // Storage order
152  , bool SF > // Symmetry flag
153 class Rand< Column<MT,SO,false,SF> >
154 {
155  public:
156  //**Randomize functions*************************************************************************
159  inline void randomize( Column<MT,SO,false,SF>& column ) const;
160  inline void randomize( Column<MT,SO,false,SF>& column, size_t nonzeros ) const;
161 
162  template< typename Arg >
163  inline void randomize( Column<MT,SO,false,SF>& column, const Arg& min, const Arg& max ) const;
164 
165  template< typename Arg >
166  inline void randomize( Column<MT,SO,false,SF>& column, size_t nonzeros, const Arg& min, const Arg& max ) const;
168  //**********************************************************************************************
169 };
171 //*************************************************************************************************
172 
173 
174 //*************************************************************************************************
181 template< typename MT // Type of the sparse matrix
182  , bool SO // Storage order
183  , bool SF > // Symmetry flag
184 inline void Rand< Column<MT,SO,false,SF> >::randomize( Column<MT,SO,false,SF>& column ) const
185 {
186  using ElementType = ElementType_< Column<MT,SO,false,SF> >;
187 
188  const size_t size( column.size() );
189 
190  if( size == 0UL ) return;
191 
192  const size_t nonzeros( rand<size_t>( 1UL, std::ceil( 0.5*size ) ) );
193 
194  column.reset();
195  column.reserve( nonzeros );
196 
197  while( column.nonZeros() < nonzeros ) {
198  column[ rand<size_t>( 0UL, size-1UL ) ] = rand<ElementType>();
199  }
200 }
202 //*************************************************************************************************
203 
204 
205 //*************************************************************************************************
214 template< typename MT // Type of the sparse matrix
215  , bool SO // Storage order
216  , bool SF > // Symmetry flag
217 inline void Rand< Column<MT,SO,false,SF> >::randomize( Column<MT,SO,false,SF>& column, size_t nonzeros ) const
218 {
219  using ElementType = ElementType_< Column<MT,SO,false,SF> >;
220 
221  const size_t size( column.size() );
222 
223  if( nonzeros > size ) {
224  BLAZE_THROW_INVALID_ARGUMENT( "Invalid number of non-zero elements" );
225  }
226 
227  if( size == 0UL ) return;
228 
229  column.reset();
230  column.reserve( nonzeros );
231 
232  while( column.nonZeros() < nonzeros ) {
233  column[ rand<size_t>( 0UL, size-1UL ) ] = rand<ElementType>();
234  }
235 }
237 //*************************************************************************************************
238 
239 
240 //*************************************************************************************************
249 template< typename MT // Type of the sparse matrix
250  , bool SO // Storage order
251  , bool SF > // Symmetry flag
252 template< typename Arg > // Min/max argument type
253 inline void Rand< Column<MT,SO,false,SF> >::randomize( Column<MT,SO,false,SF>& column,
254  const Arg& min, const Arg& max ) const
255 {
256  using ElementType = ElementType_< Column<MT,SO,false,SF> >;
257 
258  const size_t size( column.size() );
259 
260  if( size == 0UL ) return;
261 
262  const size_t nonzeros( rand<size_t>( 1UL, std::ceil( 0.5*size ) ) );
263 
264  column.reset();
265  column.reserve( nonzeros );
266 
267  while( column.nonZeros() < nonzeros ) {
268  column[ rand<size_t>( 0UL, size-1UL ) ] = rand<ElementType>( min, max );
269  }
270 }
272 //*************************************************************************************************
273 
274 
275 //*************************************************************************************************
286 template< typename MT // Type of the sparse matrix
287  , bool SO // Storage order
288  , bool SF > // Symmetry flag
289 template< typename Arg > // Min/max argument type
290 inline void Rand< Column<MT,SO,false,SF> >::randomize( Column<MT,SO,false,SF>& column, size_t nonzeros,
291  const Arg& min, const Arg& max ) const
292 {
293  using ElementType = ElementType_< Column<MT,SO,false,SF> >;
294 
295  const size_t size( column.size() );
296 
297  if( nonzeros > size ) {
298  BLAZE_THROW_INVALID_ARGUMENT( "Invalid number of non-zero elements" );
299  }
300 
301  if( size == 0UL ) return;
302 
303  column.reset();
304  column.reserve( nonzeros );
305 
306  while( column.nonZeros() < nonzeros ) {
307  column[ rand<size_t>( 0UL, size-1UL ) ] = rand<ElementType>( min, max );
308  }
309 }
311 //*************************************************************************************************
312 
313 } // namespace blaze
314 
315 #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
void randomize(T &value)
Randomization of a given variable.
Definition: Random.h:927
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
const ElementType_< MT > min(const DenseMatrix< MT, SO > &dm)
Returns the smallest element of the dense matrix.
Definition: DenseMatrix.h:1762
Implementation of a random number generator.
Column< MT > column(Matrix< MT, SO > &matrix, size_t index)
Creating a view on a specific column of the given matrix.
Definition: Column.h:124
const ElementType_< MT > max(const DenseMatrix< MT, SO > &dm)
Returns the largest element of the dense matrix.
Definition: DenseMatrix.h:1809
void randomize(T &value) const
Randomization of the given variable with a new value in the range .
Definition: Random.h:290
Header file for the dense vector SMP implementation.
Namespace of the Blaze C++ math library.
Definition: Blaze.h:57
Type ElementType
Type of the compressed matrix elements.
Definition: CompressedMatrix.h:3081
Header file for the exception macros of the math module.
Header file for all restructuring column functions.
Header file for the sparse vector SMP implementation.
Header file for the implementation of the Row view.