Blaze 3.9
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>
52#include <blaze/util/Random.h>
54
55
56namespace blaze {
57
58//=================================================================================================
59//
60// RAND SPECIALIZATION FOR DENSE COLUMNS
61//
62//=================================================================================================
63
64//*************************************************************************************************
71template< typename MT // Type of the matrix
72 , bool SO // Storage order
73 , bool SF // Symmetry flag
74 , size_t... CCAs > // Compile time column arguments
75class Rand< Column<MT,SO,true,SF,CCAs...> >
76{
77 public:
78 //*************************************************************************************************
84 template< typename CT > // Type of the column
85 inline void randomize( CT&& column ) const
86 {
87 using blaze::randomize;
88
89 using ColumnType = RemoveReference_t<CT>;
90
93
94 for( size_t i=0UL; i<column.size(); ++i ) {
95 randomize( column[i] );
96 }
97 }
98 //*************************************************************************************************
99
100 //*************************************************************************************************
108 template< typename CT // Type of the column
109 , typename Arg > // Min/max argument type
110 inline void randomize( CT&& column, const Arg& min, const Arg& max ) const
111 {
112 using blaze::randomize;
113
114 using ColumnType = RemoveReference_t<CT>;
115
118
119 for( size_t i=0UL; i<column.size(); ++i ) {
120 randomize( column[i], min, max );
121 }
122 }
123 //*************************************************************************************************
124};
126//*************************************************************************************************
127
128
129
130
131//=================================================================================================
132//
133// RAND SPECIALIZATION FOR SPARSE COLUMNS
134//
135//=================================================================================================
136
137//*************************************************************************************************
144template< typename MT // Type of the matrix
145 , bool SO // Storage order
146 , bool SF // Symmetry flag
147 , size_t... CCAs > // Compile time column arguments
148class Rand< Column<MT,SO,false,SF,CCAs...> >
149{
150 public:
151 //*************************************************************************************************
157 template< typename CT > // Type of the column
158 inline void randomize( CT&& column ) const
159 {
160 using ColumnType = RemoveReference_t<CT>;
161 using ElementType = ElementType_t<ColumnType>;
162
165
166 const size_t size( column.size() );
167
168 if( size == 0UL ) return;
169
170 const size_t nonzeros( rand<size_t>( 1UL, std::ceil( 0.5*size ) ) );
171
172 column.reset();
173 column.reserve( nonzeros );
174
175 while( column.nonZeros() < nonzeros ) {
176 column[ rand<size_t>( 0UL, size-1UL ) ] = rand<ElementType>();
177 }
178 }
179 //*************************************************************************************************
180
181 //*************************************************************************************************
189 template< typename CT > // Type of the column
190 inline void randomize( CT&& column, size_t nonzeros ) const
191 {
192 using ColumnType = RemoveReference_t<CT>;
193 using ElementType = ElementType_t<ColumnType>;
194
197
198 const size_t size( column.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 column.reset();
207 column.reserve( nonzeros );
208
209 while( column.nonZeros() < nonzeros ) {
210 column[ rand<size_t>( 0UL, size-1UL ) ] = rand<ElementType>();
211 }
212 }
213 //*************************************************************************************************
214
215 //*************************************************************************************************
223 template< typename CT // Type of the column
224 , typename Arg > // Min/max argument type
225 inline void randomize( CT&& column, const Arg& min, const Arg& max ) const
226 {
227 using ColumnType = RemoveReference_t<CT>;
228 using ElementType = ElementType_t<ColumnType>;
229
232
233 const size_t size( column.size() );
234
235 if( size == 0UL ) return;
236
237 const size_t nonzeros( rand<size_t>( 1UL, std::ceil( 0.5*size ) ) );
238
239 column.reset();
240 column.reserve( nonzeros );
241
242 while( column.nonZeros() < nonzeros ) {
243 column[ rand<size_t>( 0UL, size-1UL ) ] = rand<ElementType>( min, max );
244 }
245 }
246 //*************************************************************************************************
247
248 //*************************************************************************************************
258 template< typename CT // Type of the column
259 , typename Arg > // Min/max argument type
260 inline void randomize( CT&& column, size_t nonzeros, const Arg& min, const Arg& max ) const
261 {
262 using ColumnType = RemoveReference_t<CT>;
263 using ElementType = ElementType_t<ColumnType>;
264
267
268 const size_t size( column.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 column.reset();
277 column.reserve( nonzeros );
278
279 while( column.nonZeros() < nonzeros ) {
280 column[ 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) column(Matrix< MT, SO > &&matrix, size_t index, RCAs... args)
Creating a view on a specific column of the given temporary matrix.
Definition: Column.h:340
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_COLUMN_TYPE(T)
Constraint on the data type.
Definition: Column.h:61
#define BLAZE_CONSTRAINT_MUST_BE_DENSE_VECTOR_TYPE(T)
Constraint on the data type.
Definition: DenseVector.h:61
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
#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 Column view.
Header file for the implementation of the Row view.