//A. J. Kinderman and J. F. Monahan (1977)
//"Computer Generation of Random Variables Using the Ratio of Uniform Deviates,"
//ACM Transactions on Mathematical Software 3: 257-260.
return_type
kinderman_monahan_method() const
{
const final_type u = e_();
const final_type v = ( e_() - 0.5L ) * 4.0L * u * std::sqrt( - std::log( u ) );
return static_cast<return_type>( v / u );
}
return_type
cauchy_impl( const final_type c ) const
{
final_type u = e_();
while ( final_type( 0 ) == u || final_type(1) == u )
{ u = e_(); }
return c * std::tan( ( u - final_type(0.5) ) * 3.1415926535897932384626433 );
}
return_type
direct_impl( const return_type a, const return_type b ) const
{
final_type x = e_();
while ( final_type( 0 ) == x )
{
x = e_();
}
const final_type ans = std::pow( -b / std::log( x ), final_type( 1 ) / a );
return ans;
}
return_type
direct_impl_method() const
{
const final_type u = e_();
const final_type pi_2 = 3.1415926535897932384626433L / 2.0L;
const final_type ans = std::log( std::tan( u * pi_2 ) );
return ans;
}
return_type
gamma_impl( const final_type A, const final_type B ) const
{
const final_type x = e_();
const final_type y = gamm_type::do_generation( final_type( 1 ) / B, final_type( 1 ) );
const final_type z = A * std::pow( y, final_type( 1 ) / B );
return x > final_type( 0.5 ) ? z : -z;
}
return_type
coin_flip_method( const final_type P ) const noexcept
{
if ( e_() < p_ )
{ return 1; }
return 0;
}
return_type
direct_impl( const return_type delta ) const
{
const final_type u = e_();
const final_type tmp1 = - std::log( u );
const final_type tmp2 = std::sqrt( tmp1 );
const final_type ans = delta * tmp2;
return ans;
}
final_type
direct_burr_impl( const size_type N, const final_type C, const final_type K, const final_type R ) const noexcept
{
const final_type u = e_();
static const final_type l(1);
static const final_type ll(2);
// Note: c++0x support required here
// u c k r
// Burr, I. W. (1942). "Cumulative frequency functions". Annals of Mathematical Statistics 13 (2): 215¨C232. doi:10.1214/aoms/1177731607. JSTOR 2235756.
const std::function< final_type( final_type, final_type, final_type, final_type ) > inverse_function[12] =
{
// F1(x) = x
[]( const final_type u, const final_type c, const final_type k, const final_type r ) noexcept -> final_type
{ return u; },
// F2(x) = (1+e^{-x})^{-r}
[]( const final_type u, const final_type c, const final_type k, const final_type r ) noexcept -> final_type
{ return - std::log( -l + std::pow(u, -l/r) ); },
// F3(x) = (1+x^{-k})^{-r}
[]( const final_type u, const final_type c, const final_type k, const final_type r ) noexcept -> final_type
{ return std::pow( (std::pow( u, -l/r ) - l ), -l/k); },
// F4(x) = (1+((c-x)/x)^(1/c))^(-r)
[]( const final_type u, const final_type c, const final_type k, const final_type r ) noexcept -> final_type
{ return c / ( l + std::pow(std::pow(u, -l/r) - l, c) ); },
// F5(x) = ( 1 + k e^{-tan(x)} )^r
[]( const final_type u, const final_type c, const final_type k, const final_type r ) noexcept -> final_type
{ return std::atan( - std::log( (std::pow(u, -l/r)-l ) / k ) );},
// F6(x) = ( 1 + k e^{-sinh(x)} )^r
[]( const final_type u, const final_type c, const final_type k, const final_type r ) noexcept -> final_type
{ return std::asinh( - std::log( (std::pow(u, -l/r)-l ) / k ) );},
// F7(x) = 2^{-r}(1+tanh(x))^{r}
[]( const final_type u, const final_type c, const final_type k, const final_type r ) noexcept -> final_type
{ return std::atanh( std::pow(std::pow(ll, r)*u, l/r) - l);},
// F8(x) = \frac{2}{pi} arctan(e^x)
[]( const final_type u, const final_type c, const final_type k, const final_type r ) noexcept -> final_type
{ const final_type pi_2 = 1.5707963267948966142313216L; return std::log(std::tan(pi_2*std::pow(u, l/r)));},
// F9(x) = 1-\frac{2}{1+k((1+e^x)^r-1)}
[]( const final_type u, const final_type c, const final_type k, const final_type r ) noexcept -> final_type
{ return std::log(std::pow(l+(ll/(l-u)-l)/k, l/r)-l);},
// F10(x) = (1-e^{-x^2})^r
[]( const final_type u, const final_type c, const final_type k, const final_type r ) noexcept -> final_type
{ return std::sqrt(-std::log(-std::pow(u,l/r)+l));},
// F11(x) = ( x - \frac{\sin 2 \pi x}{2\pi})^r
[]( const final_type u, const final_type c, const final_type k, const final_type r ) noexcept -> final_type
{
const final_type two_pi = final_type(2) * 3.1415926535897932384626433;
std::function<final_type(final_type)> f = [&](final_type x) { return std::pow( x - std::sin(two_pi*x)/two_pi ,r); };
std::function<final_type(final_type)> df =[&](final_type x) {return std::pow( x - std::sin(two_pi*x)/two_pi ,r-l) * ( l - std::cos(two_pi*x) ); };
const final_type ans = (newton_raphson<final_type>(final_type(0), final_type(1), f, df))();
return ans;
},
// F12(x) = 1 - ( 1 + x^c ) ^ {-k}
[]( const final_type u, const final_type c, const final_type k, const final_type r ) noexcept -> final_type
{ return std::pow( std::pow(l-u, -l/k)-l, l/c);}
};
return inverse_function[N-1]( u, C, K, R );
}
return_type
gaussian_impl( const final_type c ) const
{
const final_type u = ( e_() - final_type(0.5) ) * 3.1415926535897932384626433;
final_type v = exponential_type::do_generation( final_type( 1 ) );
while ( final_type( 0 ) == v )
{ v = exponential_type::do_generation( final_type( 1 ) ); }
const final_type ans = c * std::sin( u ) * std::sqrt( v );
return ans + ans;
}
return_type
laplace_reject_impl( const final_type A, const final_type B ) const
{
const final_type b = std::pow( final_type( 1 ) / B, final_type( 1 ) / B );
for ( ;; )
{
const final_type x = laplace_type::do_generation( final_type(), b );
final_type y = e_();
while ( final_type( 0 ) == y )
{ y = e_(); }
const final_type z = std::fabs( x ) / b - final_type( 1 ) + final_type( 1 ) / B - std::pow( std::fabs( x ), B );
if ( std::log( y ) > z )
{ return A * x; }
}
}
return_type
gaussian_reject_impl( const final_type A, const final_type B ) const
{
const final_type b = std::pow( final_type( 1 ) / B, final_type( 1 ) / B );
for ( ;; )
{
const final_type x = normal_type::do_generation() * b;
final_type y = e_();
while ( final_type( 0 ) == y )
{ y = e_(); }
const final_type z = x * x / ( final_type( 2 ) * b * b ) + final_type( 1 ) / B - final_type( 0.5 ) - std::pow( std::fabs( x ), B );
if ( std::log( y ) > z )
{ return A * x; }
}
}
return_type
rectangle_wedge_tail_method( const final_type A, const final_type Variance ) const
{
const final_type s = A / Variance;
for ( ;; )
{
const final_type u = e_();
const final_type v = e_();
if ( final_type( 0 ) == u || final_type( 0 ) == v )
{ continue; }
const final_type x = std::sqrt( s * s - std::log( v ) );
if ( s >= x * u )
{ return x * Variance; }
}
}
//Marsaglia and Tsang, "A Simple Method for generating gamma variables",
//ACM Transactions on Mathematical Software, Vol 26, No 3 (2000), p363-372.
return_type
marsaglia_tsang_method( const final_type A ) const
{
const final_type a = A < final_type( 1 ) ? A + final_type( 1 ) : A;
const final_type d = a - final_type( 1 ) / final_type( 3 );
const final_type c = final_type( 1 ) / final_type( 3 ) / std::sqrt( d );
final_type u( 0 );
final_type v( 0 );
final_type x( 0 );
for ( ;; )
{
for ( ;; )
{
x = normal_type::do_generation(); //normal distribution
v = final_type( 1 ) + c * x;
if ( v > 0 )
{ break; }
}
const final_type xx = x * x;
v *= v * v;
u = e_();
if ( u < final_type( 1 ) - final_type( 0.0331 ) * xx * xx )
{ break; }
if ( std::log( u ) < 0.5 * xx + d *( final_type( 1 ) - v + std::log( v ) ) )
{ break; }
}
final_type ans = d * v;
if ( A < 1 )
{ ans *= std::pow( e_(), final_type( 1 ) / A ); }
return ans;
}
return_type
large_c_rejection_impl( const value_type c ) const
{
for ( ;; )
{
const final_type x = final_type( 1 ) + GHgB3_type::do_generation( final_type( 1 ), final_type( 1 ), c - final_type( 1 ) );
const final_type u = e_();
if ( x * u < final_type( 1 ) )
{ return x; }
}
}
void pedgelist_ (wgraph_s *g)
{
if (*(uint16_t *)GTNEXT()->lexeme == *(uint16_t *)"E") /*if (!strcmp(__GTNEXT()->lexeme, "E"))*/
if (GTNEXT()->type == T_EQU)
if (GTNEXT()->type == T_OPENBRACE)
e_(g);
pedgeparam_(g);
if (stream_->type == T_CLOSEBRACE)
return;
printf ("Syntax Error while parsing in edge list (edge #%d): %s\n", g->nedges, stream_->lexeme);
exit(EXIT_FAILURE);
}
//G. E. P. Box and Mervin E. Muller,
//A Note on the Generation of Random Normal Deviates,
//The Annals of Mathematical Statistics (1958), Vol. 29, No. 2 pp. 610¨C611
return_type
box_muller_method() const
{
final_type u1(0), u2(0);
final_type v1(0), v2(0);
final_type s(2);
while ( s > final_type( 1 ) )
{
u1 = e_();
u2 = e_();
v1 = u1 + u1 - final_type( 1 );
v2 = u2 + u2 - final_type( 1 );
s = v1 * v1 + v2 * v2;
}
const final_type tmp = -std::log( s );
const final_type ans = v1 * std::sqrt(( tmp + tmp ) / s );
return static_cast<return_type>( ans );
}
return_type
direct_invertion_method( const return_type mu, const return_type b ) const
{
for ( ;; )
{
const final_type u = e_() - final_type( 0.5 );
if ( final_type( 0 ) == u )
{ continue; }
const final_type ans = u > final_type( 0 ) ?
mu - b * std::log( 1 - u - u ) :
mu + b * std::log( 1 + u + u );
return ans;
}
}
return_type
direct_impl( const final_type c, const final_type alpha ) const
{
const final_type u = ( e_() - final_type(0.5) ) * 3.1415926535897932384626433;
final_type v = exponential_type::do_generation( final_type( 1 ) );
while ( final_type( 0 ) == v )
{ v = exponential_type::do_generation( final_type( 1 ) ); }
const final_type r_alpha = final_type( 1 ) / alpha;
const final_type u_alpha = u * alpha;
const final_type ans = c * std::pow( std::cos( u - u_alpha ) / v, r_alpha - final_type( 1 ) ) * std::sin( u_alpha ) * std::pow( std::cos( u ), -r_alpha );
return ans;
}
Function::Evaluators &Function::Evaluators::operator=(const Evaluators &e)
{
Function::Evaluators e_(e);
FunctionEvaluator *oldF = f;
f = e_.f;
GradientEvaluator *oldG = g;
g = e_.g;
HessianEvaluator *oldH = H;
H = e_.H;
e_.f = oldF;
e_.g = oldG;
e_.H = oldH;
return *this;
}
return_type
second_waiting_time_method( const size_type N, const final_type P )
{
const final_type p = P > 0.5 ? 1 - P : P;
const final_type q = -std::log( 1.0 - p );
return_type ans = 0;
final_type sum = 0;
for ( ;; )
{
const final_type e = -std::log( e_() );
sum += e / ( N - ans );
if ( sum > q )
{ break; }
++ans;
}
return p_ > 0.5 ? N - ans : ans;
}//second_waiting_time_method
void enable( bool f )
{
if( f != enabled_ ) { enabled_ = f ; e_( f ) ; }
}
void pedgeparam_ (wgraph_s *g)
{
while (GTNEXT()->type == T_COMMA)
e_(g);
}
int operator()() {
return (e_() >> shift_) + off_;
}
int operator()() {
return e_() / div_ + off_;
}
virtual double error() const {return e_(p_);}
