35#ifndef _BLAZE_MATH_STRICTLYUPPERMATRIX_H_
36#define _BLAZE_MATH_STRICTLYUPPERMATRIX_H_
82class Rand< StrictlyUpperMatrix<MT,SO,DF> >
90 inline const StrictlyUpperMatrix<MT,SO,DF>
generate()
const
94 StrictlyUpperMatrix<MT,SO,DF> matrix;
106 inline const StrictlyUpperMatrix<MT,SO,DF>
generate(
size_t n )
const
110 StrictlyUpperMatrix<MT,SO,DF> matrix( n );
124 inline const StrictlyUpperMatrix<MT,SO,DF>
generate(
size_t n,
size_t nonzeros )
const
129 if( nonzeros > StrictlyUpperMatrix<MT,SO,DF>::maxNonZeros( n ) ) {
133 StrictlyUpperMatrix<MT,SO,DF> matrix( n );
147 template<
typename Arg >
148 inline const StrictlyUpperMatrix<MT,SO,DF>
generate(
const Arg&
min,
const Arg&
max )
const
152 StrictlyUpperMatrix<MT,SO,DF> matrix;
166 template<
typename Arg >
167 inline const StrictlyUpperMatrix<MT,SO,DF>
172 StrictlyUpperMatrix<MT,SO,DF> matrix( n );
188 template<
typename Arg >
189 inline const StrictlyUpperMatrix<MT,SO,DF>
190 generate(
size_t n,
size_t nonzeros,
const Arg&
min,
const Arg&
max )
const
195 if( nonzeros > StrictlyUpperMatrix<MT,SO,DF>::maxNonZeros( n ) ) {
199 StrictlyUpperMatrix<MT,SO,DF> matrix( n );
212 inline void randomize( StrictlyUpperMatrix<MT,SO,DF>& matrix )
const
214 randomize( matrix,
typename IsDenseMatrix<MT>::Type() );
226 inline void randomize( StrictlyUpperMatrix<MT,false,DF>& matrix,
size_t nonzeros )
const
230 using ET = ElementType_t<MT>;
232 const size_t n( matrix.rows() );
234 if( nonzeros > StrictlyUpperMatrix<MT,SO,DF>::maxNonZeros( n ) ) {
238 if( n == 0UL || n == 1UL )
return;
241 matrix.reserve( nonzeros );
243 std::vector<size_t> dist( n-1UL );
245 for(
size_t nz=0UL; nz<nonzeros; ) {
246 const size_t index = rand<size_t>( 0UL, n-2UL );
247 if( dist[index] == n - index - 1UL )
continue;
252 for(
size_t i=0UL; i<n-1UL; ++i ) {
253 const Indices<size_t> indices( i+1UL, n-1UL, dist[i] );
254 for(
size_t j : indices ) {
255 matrix.append( i, j, rand<ET>() );
257 matrix.finalize( i );
260 matrix.finalize( n-1UL );
272 inline void randomize( StrictlyUpperMatrix<MT,true,DF>& matrix,
size_t nonzeros )
const
276 using ET = ElementType_t<MT>;
278 const size_t n( matrix.rows() );
280 if( nonzeros > StrictlyUpperMatrix<MT,SO,DF>::maxNonZeros( n ) ) {
284 if( n == 0UL || n == 1UL )
return;
287 matrix.reserve( nonzeros );
288 matrix.finalize( 0UL );
290 std::vector<size_t> dist( n );
292 for(
size_t nz=0UL; nz<nonzeros; ) {
293 const size_t index = rand<size_t>( 1UL, n-1UL );
294 if( dist[index] == index )
continue;
299 for(
size_t j=1UL; j<n; ++j ) {
300 const Indices<size_t> indices( 0UL, j-1UL, dist[j] );
301 for(
size_t i : indices ) {
302 matrix.append( i, j, rand<ET>() );
304 matrix.finalize( j );
317 template<
typename Arg >
318 inline void randomize( StrictlyUpperMatrix<MT,SO,DF>& matrix,
const Arg&
min,
const Arg&
max )
const
334 template<
typename Arg >
335 inline void randomize( StrictlyUpperMatrix<MT,false,DF>& matrix,
336 size_t nonzeros,
const Arg&
min,
const Arg&
max )
const
340 using ET = ElementType_t<MT>;
342 const size_t n( matrix.rows() );
344 if( nonzeros > StrictlyUpperMatrix<MT,SO,DF>::maxNonZeros( n ) ) {
348 if( n == 0UL || n == 1UL )
return;
351 matrix.reserve( nonzeros );
353 std::vector<size_t> dist( n-1UL );
355 for(
size_t nz=0UL; nz<nonzeros; ) {
356 const size_t index = rand<size_t>( 0UL, n-2UL );
357 if( dist[index] == n - index - 1UL )
continue;
362 for(
size_t i=0UL; i<n-1UL; ++i ) {
363 const Indices<size_t> indices( i+1UL, n-1UL, dist[i] );
364 for(
size_t j : indices ) {
365 matrix.append( i, j, rand<ET>(
min,
max ) );
367 matrix.finalize( i );
370 matrix.finalize( n-1UL );
384 template<
typename Arg >
385 inline void randomize( StrictlyUpperMatrix<MT,true,DF>& matrix,
386 size_t nonzeros,
const Arg&
min,
const Arg&
max )
const
390 using ET = ElementType_t<MT>;
392 const size_t n( matrix.rows() );
394 if( nonzeros > StrictlyUpperMatrix<MT,SO,DF>::maxNonZeros( n ) ) {
398 if( n == 0UL || n == 1UL )
return;
401 matrix.reserve( nonzeros );
402 matrix.finalize( 0UL );
404 std::vector<size_t> dist( n );
406 for(
size_t nz=0UL; nz<nonzeros; ) {
407 const size_t index = rand<size_t>( 1UL, n-1UL );
408 if( dist[index] == index )
continue;
413 for(
size_t j=1UL; j<n; ++j ) {
414 const Indices<size_t> indices( 0UL, j-1UL, dist[j] );
415 for(
size_t i : indices ) {
416 matrix.append( i, j, rand<ET>(
min,
max ) );
418 matrix.finalize( j );
434 using ET = ElementType_t<MT>;
436 const size_t n( matrix.rows() );
438 for(
size_t i=0UL; i<n; ++i ) {
439 for(
size_t j=i+1UL; j<n; ++j ) {
440 matrix(i,j) = rand<ET>();
456 const size_t n( matrix.rows() );
458 if( n == 0UL || n == 1UL )
return;
460 const size_t nonzeros( rand<size_t>( 1UL,
std::ceil( 0.2*n*n ) ) );
474 template<
typename Arg >
475 inline void randomize( StrictlyUpperMatrix<MT,SO,DF>& matrix,
480 using ET = ElementType_t<MT>;
482 const size_t n( matrix.rows() );
484 for(
size_t i=0UL; i<n; ++i ) {
485 for(
size_t j=i+1UL; j<n; ++j ) {
486 matrix(i,j) = rand<ET>(
min,
max );
500 template<
typename Arg >
501 inline void randomize( StrictlyUpperMatrix<MT,SO,DF>& matrix,
506 const size_t n( matrix.rows() );
508 if( n == 0UL || n == 1UL )
return;
510 const size_t nonzeros( rand<size_t>( 1UL,
std::ceil( 0.2*n*n ) ) );
Header file for auxiliary alias declarations.
Header file for all basic DenseMatrix functionality.
Header file for the Indices class.
Header file for the IntegralConstant class template.
Header file for the IsDenseMatrix type trait.
Constraint on the data type.
Header file for all basic SparseMatrix functionality.
Header file for the complete StrictlyLowerMatrix implementation.
Header file for the complete ZeroMatrix implementation.
Header file for the implementation of a strictly upper triangular matrix adaptor.
Header file for the implementation of a upper unitriangular matrix adaptor.
Header file for the implementation of an upper matrix adaptor.
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
decltype(auto) generate(size_t m, size_t n, OP op)
Generates a new dense matrix filled via the given custom binary operation.
Definition: DMatGenExpr.h:675
#define BLAZE_CONSTRAINT_MUST_BE_DENSE_MATRIX_TYPE(T)
Constraint on the data type.
Definition: DenseMatrix.h:61
#define BLAZE_CONSTRAINT_MUST_NOT_BE_RESIZABLE_TYPE(T)
Constraint on the data type.
Definition: Resizable.h:81
#define BLAZE_CONSTRAINT_MUST_BE_SPARSE_MATRIX_TYPE(T)
Constraint on the data type.
Definition: SparseMatrix.h:61
#define BLAZE_CONSTRAINT_MUST_BE_RESIZABLE_TYPE(T)
Constraint on the data type.
Definition: Resizable.h:61
void randomize(T &&value)
Randomization of a given variable.
Definition: Random.h:626
BoolConstant< true > TrueType
Type traits base class.
Definition: IntegralConstant.h:132
BoolConstant< false > FalseType
Type/value traits base class.
Definition: IntegralConstant.h:121
#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.
Implementation of a random number generator.
Header file for basic type definitions.