<s> from __future__ import division , print_function , absolute_import <EOL> from scipy import special <EOL> from scipy . special import entr , gammaln as gamln <EOL> from scipy . misc import logsumexp <EOL> from numpy import floor , ceil , log , exp , sqrt , log1p , expm1 , tanh , cosh , sinh <EOL> import numpy as np <EOL> from . _distn_infrastructure import ( <EOL> rv_discrete , _lazywhere , _ncx2_pdf , _ncx2_cdf , get_distribution_names ) <EOL> class binom_gen ( rv_discrete ) : <EOL> """<STR_LIT>""" <EOL> def _rvs ( self , n , p ) : <EOL> return self . _random_state . binomial ( n , p , self . _size ) <EOL> def _argcheck ( self , n , p ) : <EOL> self . b = n <EOL> return ( n >= <NUM_LIT:0> ) & ( p >= <NUM_LIT:0> ) & ( p <= <NUM_LIT:1> ) <EOL> def _logpmf ( self , x , n , p ) : <EOL> k = floor ( x ) <EOL> combiln = ( gamln ( n + <NUM_LIT:1> ) - ( gamln ( k + <NUM_LIT:1> ) + gamln ( n - k + <NUM_LIT:1> ) ) ) <EOL> return combiln + special . xlogy ( k , p ) + special . xlog1py ( n - k , - p ) <EOL> def _pmf ( self , x , n , p ) : <EOL> return exp ( self . _logpmf ( x , n , p ) ) <EOL> def _cdf ( self , x , n , p ) : <EOL> k = floor ( x ) <EOL> vals = special . bdtr ( k , n , p ) <EOL> return vals <EOL> def _sf ( self , x , n , p ) : <EOL> k = floor ( x ) <EOL> return special . bdtrc ( k , n , p ) <EOL> def _ppf ( self , q , n , p ) : <EOL> vals = ceil ( special . bdtrik ( q , n , p ) ) <EOL> vals1 = np . maximum ( vals - <NUM_LIT:1> , <NUM_LIT:0> ) <EOL> temp = special . bdtr ( vals1 , n , p ) <EOL> return np . where ( temp >= q , vals1 , vals ) <EOL> def _stats ( self , n , p , moments = '<STR_LIT>' ) : <EOL> q = <NUM_LIT:1.0> - p <EOL> mu = n * p <EOL> var = n * p * q <EOL> g1 , g2 = None , None <EOL> if '<STR_LIT:s>' in moments : <EOL> g1 = ( q - p ) / sqrt ( var ) <EOL> if '<STR_LIT:k>' in moments : <EOL> g2 = ( <NUM_LIT:1.0> - <NUM_LIT:6> * p * q ) / var <EOL> return mu , var , g1 , g2 <EOL> def _entropy ( self , n , p ) : <EOL> k = np . r_ [ <NUM_LIT:0> : n + <NUM_LIT:1> ] <EOL> vals = self . _pmf ( k , n , p ) <EOL> return np . sum ( entr ( vals ) , axis = <NUM_LIT:0> ) <EOL> binom = binom_gen ( name = '<STR_LIT>' ) <EOL> class bernoulli_gen ( binom_gen ) : <EOL> """<STR_LIT>""" <EOL> def _rvs ( self , p ) : <EOL> return binom_gen . _rvs ( self , <NUM_LIT:1> , p ) <EOL> def _argcheck ( self , p ) : <EOL> return ( p >= <NUM_LIT:0> ) & ( p <= <NUM_LIT:1> ) <EOL> def _logpmf ( self , x , p ) : <EOL> return binom . _logpmf ( x , <NUM_LIT:1> , p ) <EOL> def _pmf ( self , x , p ) : <EOL> return binom . _pmf ( x , <NUM_LIT:1> , p ) <EOL> def _cdf ( self , x , p ) : <EOL> return binom . _cdf ( x , <NUM_LIT:1> , p ) <EOL> def _sf ( self , x , p ) : <EOL> return binom . _sf ( x , <NUM_LIT:1> , p ) <EOL> def _ppf ( self , q , p ) : <EOL> return binom . _ppf ( q , <NUM_LIT:1> , p ) <EOL> def _stats ( self , p ) : <EOL> return binom . _stats ( <NUM_LIT:1> , p ) <EOL> def _entropy ( self , p ) : <EOL> return entr ( p ) + entr ( <NUM_LIT:1> - p ) <EOL> bernoulli = bernoulli_gen ( b = <NUM_LIT:1> , name = '<STR_LIT>' ) <EOL> class nbinom_gen ( rv_discrete ) : <EOL> """<STR_LIT>""" <EOL> def _rvs ( self , n , p ) : <EOL> return self . _random_state . negative_binomial ( n , p , self . _size ) <EOL> def _argcheck ( self , n , p ) : <EOL> return ( n > <NUM_LIT:0> ) & ( p >= <NUM_LIT:0> ) & ( p <= <NUM_LIT:1> ) <EOL> def _pmf ( self , x , n , p ) : <EOL> return exp ( self . _logpmf ( x , n , p ) ) <EOL> def _logpmf ( self , x , n , p ) : <EOL> coeff = gamln ( n + x ) - gamln ( x + <NUM_LIT:1> ) - gamln ( n ) <EOL> return coeff + n * log ( p ) + special . xlog1py ( x , - p ) <EOL> def _cdf ( self , x , n , p ) : <EOL> k = floor ( x ) <EOL> return special . betainc ( n , k + <NUM_LIT:1> , p ) <EOL> def _sf_skip ( self , x , n , p ) : <EOL> k = floor ( x ) <EOL> return special . nbdtrc ( k , n , p ) <EOL> def _ppf ( self , q , n , p ) : <EOL> vals = ceil ( special . nbdtrik ( q , n , p ) ) <EOL> vals1 = ( vals - <NUM_LIT:1> ) . clip ( <NUM_LIT:0.0> , np . inf ) <EOL> temp = self . _cdf ( vals1 , n , p ) <EOL> return np . where ( temp >= q , vals1 , vals ) <EOL> def _stats ( self , n , p ) : <EOL> Q = <NUM_LIT:1.0> / p <EOL> P = Q - <NUM_LIT:1.0> <EOL> mu = n * P <EOL> var = n * P * Q <EOL> g1 = ( Q + P ) / sqrt ( n * P * Q ) <EOL> g2 = ( <NUM_LIT:1.0> + <NUM_LIT:6> * P * Q ) / ( n * P * Q ) <EOL> return mu , var , g1 , g2 <EOL> nbinom = nbinom_gen ( name = '<STR_LIT>' ) <EOL> class geom_gen ( rv_discrete ) : <EOL> """<STR_LIT>""" <EOL> def _rvs ( self , p ) : <EOL> return self . _random_state . geometric ( p , size = self . _size ) <EOL> def _argcheck ( self , p ) : <EOL> return ( p <= <NUM_LIT:1> ) & ( p >= <NUM_LIT:0> ) <EOL> def _pmf ( self , k , p ) : <EOL> return np . power ( <NUM_LIT:1> - p , k - <NUM_LIT:1> ) * p <EOL> def _logpmf ( self , k , p ) : <EOL> return special . xlog1py ( k - <NUM_LIT:1> , - p ) + log ( p ) <EOL> def _cdf ( self , x , p ) : <EOL> k = floor ( x ) <EOL> return - expm1 ( log1p ( - p ) * k ) <EOL> def _sf ( self , x , p ) : <EOL> return np . exp ( self . _logsf ( x , p ) ) <EOL> def _logsf ( self , x , p ) : <EOL> k = floor ( x ) <EOL> return k * log1p ( - p ) <EOL> def _ppf ( self , q , p ) : <EOL> vals = ceil ( log ( <NUM_LIT:1.0> - q ) / log ( <NUM_LIT:1> - p ) ) <EOL> temp = self . _cdf ( vals - <NUM_LIT:1> , p ) <EOL> return np . where ( ( temp >= q ) & ( vals > <NUM_LIT:0> ) , vals - <NUM_LIT:1> , vals ) <EOL> def _stats ( self , p ) : <EOL> mu = <NUM_LIT:1.0> / p <EOL> qr = <NUM_LIT:1.0> - p <EOL> var = qr / p / p <EOL> g1 = ( <NUM_LIT> - p ) / sqrt ( qr ) <EOL> g2 = np . polyval ( [ <NUM_LIT:1> , - <NUM_LIT:6> , <NUM_LIT:6> ] , p ) / ( <NUM_LIT:1.0> - p ) <EOL> return mu , var , g1 , g2 <EOL> geom = geom_gen ( a = <NUM_LIT:1> , name = '<STR_LIT>' , longname = "<STR_LIT>" ) <EOL> class hypergeom_gen ( rv_discrete ) : <EOL> """<STR_LIT>""" <EOL> def _rvs ( self , M , n , N ) : <EOL> return self . _random_state . hypergeometric ( n , M - n , N , size = self . _size ) <EOL> def _argcheck ( self , M , n , N ) : <EOL> cond = ( M > <NUM_LIT:0> ) & ( n >= <NUM_LIT:0> ) & ( N >= <NUM_LIT:0> ) <EOL> cond &= ( n <= M ) & ( N <= M ) <EOL> self . a = max ( N - ( M - n ) , <NUM_LIT:0> ) <EOL> self . b = min ( n , N ) <EOL> return cond <EOL> def _logpmf ( self , k , M , n , N ) : <EOL> tot , good = M , n <EOL> bad = tot - good <EOL> return gamln ( good + <NUM_LIT:1> ) - gamln ( good - k + <NUM_LIT:1> ) - gamln ( k + <NUM_LIT:1> ) + gamln ( bad + <NUM_LIT:1> ) - gamln ( bad - N + k + <NUM_LIT:1> ) - gamln ( N - k + <NUM_LIT:1> ) - gamln ( tot + <NUM_LIT:1> ) + gamln ( tot - N + <NUM_LIT:1> ) + gamln ( N + <NUM_LIT:1> ) <EOL> def _pmf ( self , k , M , n , N ) : <EOL> return exp ( self . _logpmf ( k , M , n , N ) ) <EOL> def _stats ( self , M , n , N ) : <EOL> M , n , N = <NUM_LIT:1.> * M , <NUM_LIT:1.> * n , <NUM_LIT:1.> * N <EOL> m = M - n <EOL> p = n / M <EOL> mu = N * p <EOL> var = m * n * N * ( M - N ) * <NUM_LIT:1.0> / ( M * M * ( M - <NUM_LIT:1> ) ) <EOL> g1 = ( m - n ) * ( M - <NUM_LIT:2> * N ) / ( M - <NUM_LIT> ) * sqrt ( ( M - <NUM_LIT:1.0> ) / ( m * n * N * ( M - N ) ) ) <EOL> g2 = M * ( M + <NUM_LIT:1> ) - <NUM_LIT> * N * ( M - N ) - <NUM_LIT> * n * m <EOL> g2 *= ( M - <NUM_LIT:1> ) * M * M <EOL> g2 += <NUM_LIT> * n * N * ( M - N ) * m * ( <NUM_LIT> * M - <NUM_LIT:6> ) <EOL> g2 /= n * N * ( M - N ) * m * ( M - <NUM_LIT> ) * ( M - <NUM_LIT> ) <EOL> return mu , var , g1 , g2 <EOL> def _entropy ( self , M , n , N ) : <EOL> k = np . r_ [ N - ( M - n ) : min ( n , N ) + <NUM_LIT:1> ] <EOL> vals = self . pmf ( k , M , n , N ) <EOL> return np . sum ( entr ( vals ) , axis = <NUM_LIT:0> ) <EOL> def _sf ( self , k , M , n , N ) : <EOL> """<STR_LIT>""" <EOL> res = [ ] <EOL> for quant , tot , good , draw in zip ( k , M , n , N ) : <EOL> k2 = np . arange ( quant + <NUM_LIT:1> , draw + <NUM_LIT:1> ) <EOL> res . append ( np . sum ( self . _pmf ( k2 , tot , good , draw ) ) ) <EOL> return np . asarray ( res ) <EOL> def _logsf ( self , k , M , n , N ) : <EOL> """<STR_LIT>""" <EOL> res = [ ] <EOL> for quant , tot , good , draw in zip ( k , M , n , N ) : <EOL> k2 = np . arange ( quant + <NUM_LIT:1> , draw + <NUM_LIT:1> ) <EOL> res . append ( logsumexp ( self . _logpmf ( k2 , tot , good , draw ) ) ) <EOL> return np . asarray ( res ) <EOL> hypergeom = hypergeom_gen ( name = '<STR_LIT>' ) <EOL> class logser_gen ( rv_discrete ) : <EOL> """<STR_LIT>""" <EOL> def _rvs ( self , p ) : <EOL> return self . _random_state . logseries ( p , size = self . _size ) <EOL> def _argcheck ( self , p ) : <EOL> return ( p > <NUM_LIT:0> ) & ( p < <NUM_LIT:1> ) <EOL> def _pmf ( self , k , p ) : <EOL> return - np . power ( p , k ) * <NUM_LIT:1.0> / k / log ( <NUM_LIT:1> - p ) <EOL> def _stats ( self , p ) : <EOL> r = log ( <NUM_LIT:1> - p ) <EOL> mu = p / ( p - <NUM_LIT:1.0> ) / r <EOL> mu2p = - p / r / ( p - <NUM_LIT:1.0> ) ** <NUM_LIT:2> <EOL> var = mu2p - mu * mu <EOL> mu3p = - p / r * ( <NUM_LIT:1.0> + p ) / ( <NUM_LIT:1.0> - p ) ** <NUM_LIT:3> <EOL> mu3 = mu3p - <NUM_LIT:3> * mu * mu2p + <NUM_LIT:2> * mu ** <NUM_LIT:3> <EOL> g1 = mu3 / np . power ( var , <NUM_LIT> ) <EOL> mu4p = - p / r * ( <EOL> <NUM_LIT:1.0> / ( p - <NUM_LIT:1> ) ** <NUM_LIT:2> - <NUM_LIT:6> * p / ( p - <NUM_LIT:1> ) ** <NUM_LIT:3> + <NUM_LIT:6> * p * p / ( p - <NUM_LIT:1> ) ** <NUM_LIT:4> ) <EOL> mu4 = mu4p - <NUM_LIT:4> * mu3p * mu + <NUM_LIT:6> * mu2p * mu * mu - <NUM_LIT:3> * mu ** <NUM_LIT:4> <EOL> g2 = mu4 / var ** <NUM_LIT:2> - <NUM_LIT> <EOL> return mu , var , g1 , g2 <EOL> logser = logser_gen ( a = <NUM_LIT:1> , name = '<STR_LIT>' , longname = '<STR_LIT>' ) <EOL> class poisson_gen ( rv_discrete ) : <EOL> """<STR_LIT>""" <EOL> def _argcheck ( self , mu ) : <EOL> return mu >= <NUM_LIT:0> <EOL> def _rvs ( self , mu ) : <EOL> return self . _random_state . poisson ( mu , self . _size ) <EOL> def _logpmf ( self , k , mu ) : <EOL> Pk = special . xlogy ( k , mu ) - gamln ( k + <NUM_LIT:1> ) - mu <EOL> return Pk <EOL> def _pmf ( self , k , mu ) : <EOL> return exp ( self . _logpmf ( k , mu ) ) <EOL> def _cdf ( self , x , mu ) : <EOL> k = floor ( x ) <EOL> return special . pdtr ( k , mu ) <EOL> def _sf ( self , x , mu ) : <EOL> k = floor ( x ) <EOL> return special . pdtrc ( k , mu ) <EOL> def _ppf ( self , q , mu ) : <EOL> vals = ceil ( special . pdtrik ( q , mu ) ) <EOL> vals1 = np . maximum ( vals - <NUM_LIT:1> , <NUM_LIT:0> ) <EOL> temp = special . pdtr ( vals1 , mu ) <EOL> return np . where ( temp >= q , vals1 , vals ) <EOL> def _stats ( self , mu ) : <EOL> var = mu <EOL> tmp = np . asarray ( mu ) <EOL> mu_nonzero = tmp > <NUM_LIT:0> <EOL> g1 = _lazywhere ( mu_nonzero , ( tmp , ) , lambda x : sqrt ( <NUM_LIT:1.0> / x ) , np . inf ) <EOL> g2 = _lazywhere ( mu_nonzero , ( tmp , ) , lambda x : <NUM_LIT:1.0> / x , np . inf ) <EOL> return mu , var , g1 , g2 <EOL> poisson = poisson_gen ( name = "<STR_LIT>" , longname = '<STR_LIT>' ) <EOL> class planck_gen ( rv_discrete ) : <EOL> """<STR_LIT>""" <EOL> def _argcheck ( self , lambda_ ) : <EOL> if ( lambda_ > <NUM_LIT:0> ) : <EOL> self . a = <NUM_LIT:0> <EOL> self . b = np . inf <EOL> return <NUM_LIT:1> <EOL> elif ( lambda_ < <NUM_LIT:0> ) : <EOL> self . a = - np . inf <EOL> self . b = <NUM_LIT:0> <EOL> return <NUM_LIT:1> <EOL> else : <EOL> return <NUM_LIT:0> <EOL> def _pmf ( self , k , lambda_ ) : <EOL> fact = ( <NUM_LIT:1> - exp ( - lambda_ ) ) <EOL> return fact * exp ( - lambda_ * k ) <EOL> def _cdf ( self , x , lambda_ ) : <EOL> k = floor ( x ) <EOL> return <NUM_LIT:1> - exp ( - lambda_ * ( k + <NUM_LIT:1> ) ) <EOL> def _ppf ( self , q , lambda_ ) : <EOL> vals = ceil ( - <NUM_LIT:1.0> / lambda_ * log1p ( - q ) - <NUM_LIT:1> ) <EOL> vals1 = ( vals - <NUM_LIT:1> ) . clip ( self . a , np . inf ) <EOL> temp = self . _cdf ( vals1 , lambda_ ) <EOL> return np . where ( temp >= q , vals1 , vals ) <EOL> def _stats ( self , lambda_ ) : <EOL> mu = <NUM_LIT:1> / ( exp ( lambda_ ) - <NUM_LIT:1> ) <EOL> var = exp ( - lambda_ ) / ( expm1 ( - lambda_ ) ) ** <NUM_LIT:2> <EOL> g1 = <NUM_LIT:2> * cosh ( lambda_ / <NUM_LIT> ) <EOL> g2 = <NUM_LIT:4> + <NUM_LIT:2> * cosh ( lambda_ ) <EOL> return mu , var , g1 , g2 <EOL> def _entropy ( self , lambda_ ) : <EOL> l = lambda_ <EOL> C = ( <NUM_LIT:1> - exp ( - l ) ) <EOL> return l * exp ( - l ) / C - log ( C ) <EOL> planck = planck_gen ( name = '<STR_LIT>' , longname = '<STR_LIT>' ) <EOL> class boltzmann_gen ( rv_discrete ) : <EOL> """<STR_LIT>""" <EOL> def _pmf ( self , k , lambda_ , N ) : <EOL> fact = ( <NUM_LIT:1> - exp ( - lambda_ ) ) / ( <NUM_LIT:1> - exp ( - lambda_ * N ) ) <EOL> return fact * exp ( - lambda_ * k ) <EOL> def _cdf ( self , x , lambda_ , N ) : <EOL> k = floor ( x ) <EOL> return ( <NUM_LIT:1> - exp ( - lambda_ * ( k + <NUM_LIT:1> ) ) ) / ( <NUM_LIT:1> - exp ( - lambda_ * N ) ) <EOL> def _ppf ( self , q , lambda_ , N ) : <EOL> qnew = q * ( <NUM_LIT:1> - exp ( - lambda_ * N ) ) <EOL> vals = ceil ( - <NUM_LIT:1.0> / lambda_ * log ( <NUM_LIT:1> - qnew ) - <NUM_LIT:1> ) <EOL> vals1 = ( vals - <NUM_LIT:1> ) . clip ( <NUM_LIT:0.0> , np . inf ) <EOL> temp = self . _cdf ( vals1 , lambda_ , N ) <EOL> return np . where ( temp >= q , vals1 , vals ) <EOL> def _stats ( self , lambda_ , N ) : <EOL> z = exp ( - lambda_ ) <EOL> zN = exp ( - lambda_ * N ) <EOL> mu = z / ( <NUM_LIT:1.0> - z ) - N * zN / ( <NUM_LIT:1> - zN ) <EOL> var = z / ( <NUM_LIT:1.0> - z ) ** <NUM_LIT:2> - N * N * zN / ( <NUM_LIT:1> - zN ) ** <NUM_LIT:2> <EOL> trm = ( <NUM_LIT:1> - zN ) / ( <NUM_LIT:1> - z ) <EOL> trm2 = ( z * trm ** <NUM_LIT:2> - N * N * zN ) <EOL> g1 = z * ( <NUM_LIT:1> + z ) * trm ** <NUM_LIT:3> - N ** <NUM_LIT:3> * zN * ( <NUM_LIT:1> + zN ) <EOL> g1 = g1 / trm2 ** ( <NUM_LIT> ) <EOL> g2 = z * ( <NUM_LIT:1> + <NUM_LIT:4> * z + z * z ) * trm ** <NUM_LIT:4> - N ** <NUM_LIT:4> * zN * ( <NUM_LIT:1> + <NUM_LIT:4> * zN + zN * zN ) <EOL> g2 = g2 / trm2 / trm2 <EOL> return mu , var , g1 , g2 <EOL> boltzmann = boltzmann_gen ( name = '<STR_LIT>' , <EOL> longname = '<STR_LIT>' ) <EOL> class randint_gen ( rv_discrete ) : <EOL> """<STR_LIT>""" <EOL> def _argcheck ( self , low , high ) : <EOL> self . a = low <EOL> self . b = high - <NUM_LIT:1> <EOL> return ( high > low ) <EOL> def _pmf ( self , k , low , high ) : <EOL> p = np . ones_like ( k ) / ( high - low ) <EOL> return np . where ( ( k >= low ) & ( k < high ) , p , <NUM_LIT:0.> ) <EOL> def _cdf ( self , x , low , high ) : <EOL> k = floor ( x ) <EOL> return ( k - low + <NUM_LIT:1.> ) / ( high - low ) <EOL> def _ppf ( self , q , low , high ) : <EOL> vals = ceil ( q * ( high - low ) + low ) - <NUM_LIT:1> <EOL> vals1 = ( vals - <NUM_LIT:1> ) . clip ( low , high ) <EOL> temp = self . _cdf ( vals1 , low , high ) <EOL> return np . where ( temp >= q , vals1 , vals ) <EOL> def _stats ( self , low , high ) : <EOL> m2 , m1 = np . asarray ( high ) , np . asarray ( low ) <EOL> mu = ( m2 + m1 - <NUM_LIT:1.0> ) / <NUM_LIT:2> <EOL> d = m2 - m1 <EOL> var = ( d * d - <NUM_LIT:1> ) / <NUM_LIT> <EOL> g1 = <NUM_LIT:0.0> <EOL> g2 = - <NUM_LIT> / <NUM_LIT> * ( d * d + <NUM_LIT:1.0> ) / ( d * d - <NUM_LIT:1.0> ) <EOL> return mu , var , g1 , g2 <EOL> def _rvs ( self , low , high = None ) : <EOL> """<STR_LIT>""" <EOL> return self . _random_state . randint ( low , high , self . _size ) <EOL> def _entropy ( self , low , high ) : <EOL> return log ( high - low ) <EOL> randint = randint_gen ( name = '<STR_LIT>' , longname = '<STR_LIT>' <EOL> '<STR_LIT>' ) <EOL> class zipf_gen ( rv_discrete ) : <EOL> """<STR_LIT>""" <EOL> def _rvs ( self , a ) : <EOL> return self . _random_state . zipf ( a , size = self . _size ) <EOL> def _argcheck ( self , a ) : <EOL> return a > <NUM_LIT:1> <EOL> def _pmf ( self , k , a ) : <EOL> Pk = <NUM_LIT:1.0> / special . zeta ( a , <NUM_LIT:1> ) / k ** a <EOL> return Pk <EOL> def _munp ( self , n , a ) : <EOL> return _lazywhere ( <EOL> a > n + <NUM_LIT:1> , ( a , n ) , <EOL> lambda a , n : special . zeta ( a - n , <NUM_LIT:1> ) / special . zeta ( a , <NUM_LIT:1> ) , <EOL> np . inf ) <EOL> zipf = zipf_gen ( a = <NUM_LIT:1> , name = '<STR_LIT>' , longname = '<STR_LIT>' ) <EOL> class dlaplace_gen ( rv_discrete ) : <EOL> """<STR_LIT>""" <EOL> def _pmf ( self , k , a ) : <EOL> return tanh ( a / <NUM_LIT> ) * exp ( - a * abs ( k ) ) <EOL> def _cdf ( self , x , a ) : <EOL> k = floor ( x ) <EOL> f = lambda k , a : <NUM_LIT:1.0> - exp ( - a * k ) / ( exp ( a ) + <NUM_LIT:1> ) <EOL> f2 = lambda k , a : exp ( a * ( k + <NUM_LIT:1> ) ) / ( exp ( a ) + <NUM_LIT:1> ) <EOL> return _lazywhere ( k >= <NUM_LIT:0> , ( k , a ) , f = f , f2 = f2 ) <EOL> def _ppf ( self , q , a ) : <EOL> const = <NUM_LIT:1> + exp ( a ) <EOL> vals = ceil ( np . where ( q < <NUM_LIT:1.0> / ( <NUM_LIT:1> + exp ( - a ) ) , log ( q * const ) / a - <NUM_LIT:1> , <EOL> - log ( ( <NUM_LIT:1> - q ) * const ) / a ) ) <EOL> vals1 = vals - <NUM_LIT:1> <EOL> return np . where ( self . _cdf ( vals1 , a ) >= q , vals1 , vals ) <EOL> def _stats ( self , a ) : <EOL> ea = exp ( a ) <EOL> mu2 = <NUM_LIT> * ea / ( ea - <NUM_LIT:1.> ) ** <NUM_LIT:2> <EOL> mu4 = <NUM_LIT> * ea * ( ea ** <NUM_LIT:2> + <NUM_LIT> * ea + <NUM_LIT:1.> ) / ( ea - <NUM_LIT:1.> ) ** <NUM_LIT:4> <EOL> return <NUM_LIT:0.> , mu2 , <NUM_LIT:0.> , mu4 / mu2 ** <NUM_LIT:2> - <NUM_LIT> <EOL> def _entropy ( self , a ) : <EOL> return a / sinh ( a ) - log ( tanh ( a / <NUM_LIT> ) ) <EOL> dlaplace = dlaplace_gen ( a = - np . inf , <EOL> name = '<STR_LIT>' , longname = '<STR_LIT>' ) <EOL> class skellam_gen ( rv_discrete ) : <EOL> """<STR_LIT>""" <EOL> def _rvs ( self , mu1 , mu2 ) : <EOL> n = self . _size <EOL> return ( self . _random_state . poisson ( mu1 , n ) - <EOL> self . _random_state . poisson ( mu2 , n ) ) <EOL> def _pmf ( self , x , mu1 , mu2 ) : <EOL> px = np . where ( x < <NUM_LIT:0> , <EOL> _ncx2_pdf ( <NUM_LIT:2> * mu2 , <NUM_LIT:2> * ( <NUM_LIT:1> - x ) , <NUM_LIT:2> * mu1 ) * <NUM_LIT:2> , <EOL> _ncx2_pdf ( <NUM_LIT:2> * mu1 , <NUM_LIT:2> * ( <NUM_LIT:1> + x ) , <NUM_LIT:2> * mu2 ) * <NUM_LIT:2> ) <EOL> return px <EOL> def _cdf ( self , x , mu1 , mu2 ) : <EOL> x = floor ( x ) <EOL> px = np . where ( x < <NUM_LIT:0> , <EOL> _ncx2_cdf ( <NUM_LIT:2> * mu2 , - <NUM_LIT:2> * x , <NUM_LIT:2> * mu1 ) , <EOL> <NUM_LIT:1> - _ncx2_cdf ( <NUM_LIT:2> * mu1 , <NUM_LIT:2> * ( x + <NUM_LIT:1> ) , <NUM_LIT:2> * mu2 ) ) <EOL> return px <EOL> def _stats ( self , mu1 , mu2 ) : <EOL> mean = mu1 - mu2 <EOL> var = mu1 + mu2 <EOL> g1 = mean / sqrt ( ( var ) ** <NUM_LIT:3> ) <EOL> g2 = <NUM_LIT:1> / var <EOL> return mean , var , g1 , g2 <EOL> skellam = skellam_gen ( a = - np . inf , name = "<STR_LIT>" , longname = '<STR_LIT>' ) <EOL> pairs = list ( globals ( ) . items ( ) ) <EOL> _distn_names , _distn_gen_names = get_distribution_names ( pairs , rv_discrete ) <EOL> __all__ = _distn_names + _distn_gen_names </s>
