reference

This documentation is automatically generated from the openFrameworks source code using doxygen and refers to the most recent release, version 0.12.0.

of::random Namespace Reference

Classes

class  Engine
 

Functions

template<typename T = float, typename ... Args>
std::enable_if_t< std::is_floating_point_v< T >, T > uniform (Args &&... args)
 
template<typename T , typename ... Args>
std::enable_if_t< std::is_integral_v< T >, T > uniform (Args &&... args)
 
template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec2 >, T > uniform (double min, double max)
 
template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec2 >, T > uniform (T min, T max)
 
template<typename T , typename ... Args>
std::enable_if_t< std::is_same_v< T, glm::vec3 >, T > uniform (Args &&... args)
 
template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec3 >, T > uniform (T min, T max)
 
template<typename T = float>
std::enable_if_t< std::is_arithmetic_v< T >, T > normal (T mean, T stddev)
 
template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec2 >, T > normal (float mean, float stddev)
 
template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec2 >, T > normal (T mean, T stddev)
 
template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec3 >, T > normal (float mean, float stddev)
 
template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec3 >, T > normal (T mean, T stddev)
 
template<typename T = float>
std::enable_if_t< std::is_arithmetic_v< T >, T > lognormal (double mean, double stddev)
 
template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec2 >, T > lognormal (double mean, double stddev)
 
template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec2 >, T > lognormal (T mean, T stddev)
 
template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec3 >, T > lognormal (double mean, double stddev)
 
template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec3 >, T > lognormal (T mean, T stddev)
 
template<typename T = float>
std::enable_if_t< std::is_arithmetic_v< T >, T > gamma (double alpha, double beta)
 
template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec2 >, T > gamma (double alpha, double beta)
 
template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec2 >, T > gamma (T alpha, T beta)
 
template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec3 >, T > gamma (double alpha, double beta)
 
template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec3 >, T > gamma (T alpha, T beta)
 
template<typename T = float>
std::enable_if_t< std::is_arithmetic_v< T >, T > poisson (double mean)
 
template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec2 >, T > poisson (double mean)
 
template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec2 >, T > poisson (T mean)
 
template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec3 >, T > poisson (double mean)
 
template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec3 >, T > poisson (T mean)
 
template<typename T = float>
std::enable_if_t< std::is_arithmetic_v< T >, T > exponential (T lambda)
 
template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec2 >, T > exponential (double lambda)
 
template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec2 >, T > exponential (T lambda)
 
template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec3 >, T > exponential (double lambda)
 
template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec3 >, T > exponential (T lambda)
 
template<typename T = float>
std::enable_if_t< std::is_arithmetic_v< T >, T > chi_squared (T n)
 
template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec2 >, T > chi_squared (double n)
 
template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec2 >, T > chi_squared (T n)
 
template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec3 >, T > chi_squared (double n)
 
template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec3 >, T > chi_squared (T n)
 
template<typename T = int>
std::enable_if_t< std::is_arithmetic_v< T >, T > binomial (int p, double t)
 
template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec2 >, T > binomial (int p, double t)
 
template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec2 >, T > binomial (T p, T t)
 
template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec3 >, T > binomial (int p, double t)
 
template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec3 >, T > binomial (T p, T t)
 
template<typename T = int>
std::enable_if_t< std::is_arithmetic_v< T >, T > geometric ()
 
template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec2 >, T > geometric ()
 
template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec3 >, T > geometric ()
 
template<typename T = bool>
auto bernoulli (double p)
 
template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec2 >, T > bernoulli (double p)
 
template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec2 >, T > bernoulli (T p)
 
template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec3 >, T > bernoulli (double p)
 
template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec3 >, T > bernoulli (T p)
 
template<typename... Args>
auto gaussian (Args &&... args) -> decltype(normal(std::forward< Args >(args)...))
 
template<typename... Args>
auto yes (Args &&... args) -> decltype(bernoulli(std::forward< Args >(args)...))
 
template<class T >
auto gaussian (T min, T max) -> decltype(normal< T >(min, max))
 
template<class T >
auto yes (T p) -> decltype(bernoulli(p))
 
template<class T = float>
bound_normal (float min, float max, float focus=4.0f)
 
template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec2 >, T > bound_normal (T min, T max, T focus={4.0f, 4.0f})
 
template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec3 >, T > bound_normal (T min, T max, T focus={4.0f, 4.0f, 4.0f})
 
auto engine ()
 
auto & gen ()
 
void seed (unsigned long seed)
 Passes a value to seed the mt19937 generator within the ending instance.
 
template<class T >
void shuffle (T &values)
 Shuffles the order of the elements within the passed container, using the centralized random engine.
 

Function Documentation

◆ bernoulli() [1/5]

template<typename T = bool>
auto of::random::bernoulli ( double  p)

◆ bernoulli() [2/5]

template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec2 >, T > of::random::bernoulli ( double  p)

◆ bernoulli() [3/5]

template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec3 >, T > of::random::bernoulli ( double  p)

◆ bernoulli() [4/5]

template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec2 >, T > of::random::bernoulli ( p)

◆ bernoulli() [5/5]

template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec3 >, T > of::random::bernoulli ( p)

◆ binomial() [1/5]

template<typename T = int>
std::enable_if_t< std::is_arithmetic_v< T >, T > of::random::binomial ( int  p,
double  t 
)

◆ binomial() [2/5]

template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec2 >, T > of::random::binomial ( int  p,
double  t 
)

◆ binomial() [3/5]

template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec3 >, T > of::random::binomial ( int  p,
double  t 
)

◆ binomial() [4/5]

template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec2 >, T > of::random::binomial ( p,
t 
)

◆ binomial() [5/5]

template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec3 >, T > of::random::binomial ( p,
t 
)

◆ bound_normal() [1/3]

template<class T = float>
T of::random::bound_normal ( float  min,
float  max,
float  focus = 4.0f 
)

◆ bound_normal() [2/3]

template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec3 >, T > of::random::bound_normal ( min,
max,
focus = {4.0f, 4.0f, 4.0f} 
)

◆ bound_normal() [3/3]

template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec2 >, T > of::random::bound_normal ( min,
max,
focus = {4.0f, 4.0f} 
)

◆ chi_squared() [1/5]

template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec2 >, T > of::random::chi_squared ( double  n)

◆ chi_squared() [2/5]

template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec3 >, T > of::random::chi_squared ( double  n)

◆ chi_squared() [3/5]

template<typename T = float>
std::enable_if_t< std::is_arithmetic_v< T >, T > of::random::chi_squared ( n)

◆ chi_squared() [4/5]

template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec2 >, T > of::random::chi_squared ( n)

◆ chi_squared() [5/5]

template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec3 >, T > of::random::chi_squared ( n)

◆ engine()

auto of::random::engine ( )
inline
Returns
a reference to the engine singleton instance

◆ exponential() [1/5]

template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec2 >, T > of::random::exponential ( double  lambda)

◆ exponential() [2/5]

template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec3 >, T > of::random::exponential ( double  lambda)

◆ exponential() [3/5]

template<typename T = float>
std::enable_if_t< std::is_arithmetic_v< T >, T > of::random::exponential ( lambda)

◆ exponential() [4/5]

template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec2 >, T > of::random::exponential ( lambda)

◆ exponential() [5/5]

template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec3 >, T > of::random::exponential ( lambda)

◆ gamma() [1/5]

template<typename T = float>
std::enable_if_t< std::is_arithmetic_v< T >, T > of::random::gamma ( double  alpha,
double  beta 
)

◆ gamma() [2/5]

template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec2 >, T > of::random::gamma ( double  alpha,
double  beta 
)

◆ gamma() [3/5]

template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec3 >, T > of::random::gamma ( double  alpha,
double  beta 
)

◆ gamma() [4/5]

template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec2 >, T > of::random::gamma ( alpha,
beta 
)

◆ gamma() [5/5]

template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec3 >, T > of::random::gamma ( alpha,
beta 
)

◆ gaussian() [1/2]

template<typename... Args>
auto of::random::gaussian ( Args &&...  args) -> decltype(normal(std::forward<Args>(args)...))

◆ gaussian() [2/2]

template<class T >
auto of::random::gaussian ( min,
max 
) -> decltype(normal<T>(min, max))

◆ gen()

auto & of::random::gen ( )
inline
Returns
a reference to the generator within the engine instance

◆ geometric() [1/3]

template<typename T = int>
std::enable_if_t< std::is_arithmetic_v< T >, T > of::random::geometric ( )

◆ geometric() [2/3]

template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec2 >, T > of::random::geometric ( )

◆ geometric() [3/3]

template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec3 >, T > of::random::geometric ( )

◆ lognormal() [1/5]

template<typename T = float>
std::enable_if_t< std::is_arithmetic_v< T >, T > of::random::lognormal ( double  mean,
double  stddev 
)

◆ lognormal() [2/5]

template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec2 >, T > of::random::lognormal ( double  mean,
double  stddev 
)

◆ lognormal() [3/5]

template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec3 >, T > of::random::lognormal ( double  mean,
double  stddev 
)

◆ lognormal() [4/5]

template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec2 >, T > of::random::lognormal ( mean,
stddev 
)

◆ lognormal() [5/5]

template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec3 >, T > of::random::lognormal ( mean,
stddev 
)

◆ normal() [1/5]

template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec2 >, T > of::random::normal ( float  mean,
float  stddev 
)

◆ normal() [2/5]

template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec3 >, T > of::random::normal ( float  mean,
float  stddev 
)

◆ normal() [3/5]

template<typename T = float>
std::enable_if_t< std::is_arithmetic_v< T >, T > of::random::normal ( mean,
stddev 
)

◆ normal() [4/5]

template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec2 >, T > of::random::normal ( mean,
stddev 
)

◆ normal() [5/5]

template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec3 >, T > of::random::normal ( mean,
stddev 
)

◆ poisson() [1/5]

template<typename T = float>
std::enable_if_t< std::is_arithmetic_v< T >, T > of::random::poisson ( double  mean)

◆ poisson() [2/5]

template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec2 >, T > of::random::poisson ( double  mean)

◆ poisson() [3/5]

template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec3 >, T > of::random::poisson ( double  mean)

◆ poisson() [4/5]

template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec2 >, T > of::random::poisson ( mean)

◆ poisson() [5/5]

template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec3 >, T > of::random::poisson ( mean)

◆ seed()

void of::random::seed ( unsigned long  seed)
inline

Passes a value to seed the mt19937 generator within the ending instance.

◆ shuffle()

template<class T >
void of::random::shuffle ( T &  values)

Shuffles the order of the elements within the passed container, using the centralized random engine.

◆ uniform() [1/6]

template<typename T = float, typename ... Args>
std::enable_if_t< std::is_floating_point_v< T >, T > of::random::uniform ( Args &&...  args)

◆ uniform() [2/6]

template<typename T , typename ... Args>
std::enable_if_t< std::is_integral_v< T >, T > of::random::uniform ( Args &&...  args)

◆ uniform() [3/6]

template<typename T , typename ... Args>
std::enable_if_t< std::is_same_v< T, glm::vec3 >, T > of::random::uniform ( Args &&...  args)

◆ uniform() [4/6]

template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec2 >, T > of::random::uniform ( double  min,
double  max 
)

◆ uniform() [5/6]

template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec2 >, T > of::random::uniform ( min,
max 
)

◆ uniform() [6/6]

template<typename T >
std::enable_if_t< std::is_same_v< T, glm::vec3 >, T > of::random::uniform ( min,
max 
)

◆ yes() [1/2]

template<typename... Args>
auto of::random::yes ( Args &&...  args) -> decltype(bernoulli(std::forward<Args>(args)...))

◆ yes() [2/2]

template<class T >
auto of::random::yes ( p) -> decltype(bernoulli(p))