double solve()
{
double c, s;
int i, j, k, r;
r = n - 1;
k = r >> 1;
if (r & 1) {
c = exp(lgamma(r + 1) - lgamma(k + 1) - lgamma(r - k + 1) - r * l2);
for (s = 0., i = k, j = k + 1; i >= 0; i--, j++) {
s += c * (a[i] + a[j]);
c *= i / (double)(r - i + 1.);
}
} else {
c = exp(lgamma(r + 1) - 2 * lgamma(k + 1) - r * l2);
s = c * a[k];
c *= k / (double)(r - k + 1.);
for (i = k - 1, j = k + 1; i >= 0; i--, j++) {
s += c * (a[i] + a[j]);
c *= i / (double)(r - i + 1.);
}
}
return s;
}
// 2x2 (one-sided) Fisher's exact test
// see B. Moore. (2004) On Log Likelihood and the Significance of Rare Events
double fisher_exact(int cfe, int ce, int cf)
{
assert(cfe <= ce);
assert(cfe <= cf);
int a = cfe;
int b = (cf - cfe);
int c = (ce - cfe);
int d = (num_lines - ce - cf + cfe);
int n = a + b + c + d;
double cp = exp(lgamma(1+a+c) + lgamma(1+b+d) + lgamma(1+a+b) + lgamma(1+c+d) - lgamma(1+n) - lgamma(1+a) - lgamma(1+b) - lgamma(1+c) - lgamma(1+d));
double total_p = 0.0;
int tc = std::min(b,c);
for (int i=0; i<=tc; i++) {
total_p += cp;
// double lg = lgamma(1+a+c) + lgamma(1+b+d) + lgamma(1+a+b) + lgamma(1+c+d) - lgamma(1+n) - lgamma(1+a) - lgamma(1+b) - lgamma(1+c) - lgamma(1+d); double cp = exp(lg);
// print(a,b,c,d,cp);
double coef = (double)(b)*(double)(c)/(double)(a+1)/(double)(d+1);
cp *= coef;
++a;
--c;
++d;
--b;
}
return total_p;
}
void add(mymatrix *matrix, int smpls, unsigned l, int i)
{
unsigned j,k;
for (j = 0; j < l; ++j)
for (k = j; k < l; ++k)
matrix[OFFSET(i,samples[j],samples[k])].count++;
for (j = 0; j < smpls; ++j)
for (k = j + 1; k < smpls; ++k)
if (freq[j] || freq[k])
{
if (freq[j] < PRECMP && freq[k] < PRECMP) // The most common case is this one
{
unsigned offset = OFFSET(i,j,k);
matrix[offset].log += pow( prelog[freq[j]] - prelog[freq[k]], 2);
matrix[offset].sqrt += pow( presqrt[freq[j]] - presqrt[freq[k]], 2);
matrix[offset].lgamma += (freq[j] + freq[k] < PRECMP ? prelgamma[freq[j] + freq[k]] : lgamma(freq[j] + freq[k] + 1))
- prelgamma[freq[j]] - prelgamma[freq[k]] - (freq[j] + freq[k] + 1);
}
else
{
unsigned offset = OFFSET(i,j,k); // Rare case in our data
matrix[offset].log += pow( log(1+freq[j]) - log(1+freq[k]), 2);
matrix[offset].sqrt += pow( sqrt(freq[j]) - sqrt(freq[k]), 2);
matrix[offset].lgamma += lgamma(freq[j] + freq[k] + 1) - lgamma(freq[j] + 1)
- lgamma(freq[k] + 1) - (freq[j] + freq[k] + 1);
}
}
}
double compute_likelihood(document* doc, lda_model* model, double** phi, double* var_gamma) {
double likelihood = 0, digsum = 0, var_gamma_sum = 0, dig[model->num_topics];
int k = 0, n = 0, index = 0;
memset(dig,0.0,sizeof(dig));
for (k = 0; k < model->num_topics; k++)
{
dig[k] = digamma(var_gamma[k]);
var_gamma_sum += var_gamma[k];
}
digsum = digamma(var_gamma_sum);
likelihood = lgamma(model->alpha * model->num_topics) -
model->num_topics *
lgamma(model->alpha) -
lgamma(var_gamma_sum);
for (k = 0; k < model->num_topics; k++)
{
likelihood += (model->alpha - 1)*(dig[k] - digsum) + lgamma(var_gamma[k]) - (var_gamma[k] - 1)*(dig[k] - digsum);
for (n = 0; n < doc->length; n++)
{
if (phi[n][k] > 0)
{
index = doc->words[n];
likelihood += doc->counts[n]*
(phi[n][k]*((dig[k] - digsum) - log(phi[n][k])
+ model->log_prob_w[k][index]));
}
}
}
return(likelihood);
}
static double aterms(double mya, void *mydata) {
int i, t;
double val = 0;
double la = log(mya);
#ifdef A_DEBUG
float save_a = ddC.SX->a;
double like;
#endif
S_remake(ddC.SX, mya);
for (i=0; i<ddN.DT; i++) {
uint32_t Td_ = 0;
for (t=0; t<ddN.T; t++) {
Td_ += ddS.Tdt[i][t];
if ( ddS.Ndt[i][t]>1 ) {
val += S_S(ddC.SX,ddS.Ndt[i][t],ddS.Tdt[i][t]);
}
}
val += Td_*la + lgamma(ddP.bpar/mya+Td_) - lgamma(ddP.bpar/mya);
}
myarms_evals++;
#ifdef A_DEBUG
yap_message("Eval aterms(%lf) = %lf (S had %f)", mya, val, save_a);
ddP.apar = mya;
cache_update("a");
like = likelihood();
if ( last_val != 0 ) {
yap_message(", lp=%lf diffs=%lf vs %lf\n", like,
val-last_val, like-last_like);
}
last_like = like;
last_val = val;
#endif
return val;
}
static double awterms(double myaw, void *mydata) {
int i, t;
double val = 0;
double law = log(myaw);
#ifdef A_DEBUG
float save_a = ddC.SY->a;
double like;
#endif
S_remake(ddC.SY, myaw);
for (t=0; t<ddN.T; t++) {
uint32_t Tw_ = 0;
for (i=0; i<ddN.W; i++) {
Tw_ += ddS.Twt[i][t];
if ( ddS.Nwt[i][t]>1 ) {
val += S_S(ddC.SY,ddS.Nwt[i][t],ddS.Twt[i][t]);
}
}
val += Tw_*law + lgamma(ddP.bwpar/myaw+Tw_) - lgamma(ddP.bwpar/myaw);
}
myarms_evals++;
#ifdef A_DEBUG
yap_message("Eval awterms(%lf) = %lf (S had %f)", myaw, val, save_a);
ddP.awpar = myaw;
cache_update("aw");
like = likelihood();
if ( last_val != 0 ) {
yap_message(", lp=%lf diffs=%lf vs %lf\n", like,
val-last_val, like-last_like);
}
last_like = like;
last_val = val;
#endif
return val;
}
Float tweedie_logW(Float y, Float phi, Float p){
bool ok = (0 < y) && (0 < phi) && (1 < p) && (p < 2);
if (!ok) return NAN;
Float p1 = p - 1.0, p2 = 2.0 - p;
Float a = - p2 / p1, a1 = 1.0 / p1;
Float cc, w, sum_ww = 0.0, ww_max ;
double j;
/* only need the lower bound and the # terms to be stored */
int jh, jl, jd;
double jmax = 0;
Float logz = 0;
/* compute jmax for the given y > 0*/
cc = a * log(p1) - log(p2);
jmax = asDouble( fmax2(1.0, pow(y, p2) / (phi * p2)) );
logz = - a * log(y) - a1 * log(phi) + cc;
/* find bounds in the summation */
/* locate upper bound */
cc = logz + a1 + a * log(-a);
j = jmax ;
w = a1 * j ;
while (1) {
j += TWEEDIE_INCRE ;
if (j * (cc - a1 * log(j)) < (w - TWEEDIE_DROP))
break ;
}
jh = ceil(j);
/* locate lower bound */
j = jmax;
while (1) {
j -= TWEEDIE_INCRE ;
if (j < 1 || j * (cc - a1 * log(j)) < w - TWEEDIE_DROP)
break ;
}
jl = imax2(1, floor(j)) ;
jd = jh - jl + 1;
/* set limit for # terms in the sum */
int nterms = imin2(imax(&jd, 1), TWEEDIE_NTERM), iterm ;
Float *ww = Calloc(nterms, Float) ;
/* evaluate series using the finite sum*/
/* y > 0 */
sum_ww = 0.0 ;
iterm = imin2(jd, nterms) ;
for (int k = 0; k < iterm; k++) {
j = k + jl ;
ww[k] = j * logz - lgamma(1 + j) - lgamma(-a * j);
}
ww_max = dmax(ww, iterm) ;
for (int k = 0; k < iterm; k++)
sum_ww += exp(ww[k] - ww_max);
Float ans = log(sum_ww) + ww_max ;
Free(ww);
return ans;
}
void qcache_init(struct gcache_s *lgp, double p) {
lgp->par = p;
if ( p>0 )
lgp->lgpar = lgamma(1-2*p) - lgamma(1-p);
else
lgp->lgpar = 0;
memset(lgp->cache, 0, GCACHE*sizeof(lgp->cache[0]));
}
double dbeta(double x, double a, double b)
{
double out = (a-1)*std::log(x) +
(b-1)*std::log(1-x) +
(lgamma(a+b)) -
((lgamma(a)) + (lgamma(b)));
return(out);
}
double beta_logp(const T& x, const U& alpha, const V& beta) {
if(!arma::all(x > 0) || !arma::all(x < 1) ||
!arma::all(alpha > 0) || !arma::all(beta > 0))
return -std::numeric_limits<double>::infinity();
return arma::accu(lgamma(alpha+beta) - lgamma(alpha) - lgamma(beta)
+ schur_product(alpha - 1.0f, log_approx(x))
+ schur_product(beta - 1.0f, log_approx(1.0f - x)));
}
double lBeta(vector<vector<Brother> >& groups) {
double res = 0.0, mult = 1.0;
for (size_t i = 0; i < groups.size(); ++i) {
res += lgamma(groups[i].size());
mult *= groups[i].size();
}
return (res - lgamma(mult));
}
inline typename boost::math::tools::promote_args<T1, T2>::type
log_falling_factorial(const T1 x, const T2 n) {
if (is_nan(x) || is_nan(n))
return std::numeric_limits<double>::quiet_NaN();
static const char* fun = "log_falling_factorial";
check_positive(fun, "first argument", x);
return lgamma(x + 1) - lgamma(x - n + 1);
}
Type dbeta(Type x, Type shape1, Type shape2, int give_log)
{
Type res = exp(lgamma(shape1+shape2) - lgamma(shape1) - lgamma(shape2)) * pow(x,shape1-1) * pow(1-x,shape2-1);
if(!give_log)
return res;
else
return CppAD::CondExpEq(x,Type(0),log(res),lgamma(shape1+shape2) - lgamma(shape1) - lgamma(shape2) + (shape1-1)*log(x) + (shape2-1)*log(1-x));
}
static double lBeta ( const double * vector, const double length ) {
double result = 0;
int i;
for (i = 0; i < ALPHABET_SIZE; i++)
result += lgamma( vector[i] );
return (result - lgamma( length ));
}
//======================================================================
double dmvt(const Vector &x, const Vector &mu, const SpdMatrix &Siginv, double nu,
double ldsi, bool logscale){
long dim = mu.size();
double nc = lgamma( (nu + dim)/2.0 ) + .5 * ldsi
- lgamma(nu/2.0) - (.5*dim) * (log(nu) + Constants::log_pi);
double delta = Siginv.Mdist(x, mu);
double ans = nc - .5*(nu + dim)*(::log1p(delta/nu));
return logscale ? ans : exp(ans);
}
double NegBinomial(int kk, double rr, double pp)
{
double log_pmf = 0;
if ((kk>=0)&&(rr>0)&&(pp>=0)&&(pp<=1))
log_pmf = lgamma(kk+rr) - lgamma(kk+1) - lgamma(rr) + log(1-pp)*rr + log(pp)*kk;
return exp(log_pmf);
}
inline Type dnbinom(const Type &x, const Type &size, const Type &prob,
int give_log=0)
{
Type n=size;
Type p=prob;
Type logres = lgamma(x+n)-lgamma(n)-lgamma(x+Type(1))+
n*log(p)+x*log(Type(1)-p);
if (give_log) return logres; else return exp(logres);
}
// unnormalized log( P(alpha|k,n)) for crp
static double lcrpUNormPost(size_t k, size_t n, double alpha)
{
// sometimes alpha is zero because of floating point error
// ASSERT_GREATER_THAN_ZERO(std::cout, alpha);
ASSERT_GREATER_THAN_ZERO(std::cout, n);
ASSERT_GREATER_THAN_ZERO(std::cout, k);
return lgamma(alpha)+double(k)*log(alpha)-lgamma(alpha+double(n));
}
void dtweedielogwsmallp(double *y, double *phi, double *power, double *logw) {
double p,a,a1,r,drop=37,logz,jmax,j,cc,wmax,estlogw,oldestlogw;
int hij,lowj;
if (*power < 1) error("Error - power<1!");
if (*power > 2) error("Error - power>2!");
if (*phi <= 0) error("Error - phi<=0!");
if (*y <= 0) error("Error - y<=0!");
p = *power;
a = (2 - p)/(1 - p);
a1 = 1 - a;
r = -a * log(*y) + a * log(p - 1) - a1 * log(*phi) - log(2 - p);
logz = r;
jmax = (pow(*y,(2 - p)))/(*phi * (2 - p));
j = fmax2(1, jmax);
cc = logz + a1 + a * log(-a);
wmax = a1 * jmax;
estlogw = wmax;
while (estlogw > (wmax - drop)) {
j = j + 2;
estlogw = j * (cc - a1 * log(j));
}
hij = (int)ceil(j);
logz = r;
jmax = pow(*y,(2 - *power))/(*phi * (2 - *power));
j = fmax2(1, jmax);
wmax = a1 * jmax;
estlogw = wmax;
while ((estlogw > (wmax - drop)) && (j >= 2)) {
j = fmax2(1, j - 2);
oldestlogw = estlogw;
estlogw = j * (cc - a1 * log(j));
}
lowj = (int)fmax2(1, floor(j));
double newj[hij-lowj+1];
int k;
for(k=0;k<(hij-lowj+1);k++) newj[k] = lowj+k;
double g[hij-lowj+1];
for(k=0;k<hij-lowj+1;k++) g[k] = lgamma(newj[k]+1)+lgamma(-a*newj[k]);
double A[hij-lowj+1];
for(k=0;k<hij-lowj+1;k++) A[k] = r*(double)newj[k]-g[k];
double m=fmax2(A[0],hij-lowj+1);
for(k=0;k<(hij-lowj+1);k++) m = fmax2(A[k],hij-lowj+1);
double we[hij-lowj+1];
for(k=0;k<hij-lowj+1;k++) we[k] = exp(A[k]-m);
double sumwe=0;
for(k=0;k<hij-lowj+1;k++) sumwe+=we[k];
*logw=log(sumwe)+m;
}
double gammap (double a, double x)
{
/** Incomplete Gammafunction **/
if (x < 0 || a <= 0) return 0; /* invalid arguments */
if (x < a+1)
return gammap_sr(a,x,lgamma(a));
else
return 1-gammaq_cf(a,x,lgamma(a));
}
double entropia (double *Ni, int n) {
double N = 0, S = 0;
for (int i = 0; i < n; i++) {
N += Ni [i];
S -= lgamma (Ni[i] + 1);
}
S += lgamma (N + 1) - N * log ((double)n);
return S;
}
Type dbinom(Type k, Type size, Type prob, int give_log=0)
{
Type logres = lgamma(size + 1) - lgamma(k + 1) - lgamma(size - k + 1);
// Add 'k * log(prob)' only if k > 0
logres += CppAD::CondExpGt(k, Type(0), k * log(prob), Type(0) );
// Add '(size - k) * log(1 - prob)' only if size > k
logres += CppAD::CondExpGt(size, k, (size - k) * log(1 - prob), Type(0) );
if (!give_log) return exp(logres);
else return logres;
}
/**************************************************************************
* binomial exact
**************************************************************************/
double binomial_exact(int succ, int trials, double prob) {
double out;
//note:
//gamma(x + 1) = x!
//lgamma(x) = log(gamma(x)) = log((x-1)!)
out = lgamma(trials + 1) - lgamma(trials - succ + 1) - lgamma(succ + 1) +
log(prob) * succ + log(1.0-prob) * (trials - succ) ;
return exp(out);
}
TEST(AgradRev,lgamma) {
AVAR a = 3.0;
AVAR f = lgamma(a);
EXPECT_FLOAT_EQ(lgamma(3.0),f.val());
AVEC x = createAVEC(a);
VEC grad_f;
f.grad(x,grad_f);
EXPECT_FLOAT_EQ(boost::math::digamma(3.0),grad_f[0]);
}
int main()
{
int t, n;
for (scanf("%d", &t); t-- > 0 && scanf("%d", &n) == 1;)
printf("%.4f\n",
1. - exp(lgamma(n-1) - 2.*lgamma(n/2.) - (n-2)*log(2.)));
return 0;
}
double pdpmlm_logpcls( pdpm_t * obj, unsigned int cls ) {
pdpmlm_t * mdl = (pdpmlm_t *) obj->model;
double logp = 0.0;
if( obj->gcl[ cls ] == 0 ) { return logp; }
//compute posterior statistics
pdpmlm_parm( obj, cls, mdl->s, mdl->m, &mdl->a, &mdl->b, &mdl->d );
//compute posterior mass
logp = lgamma( mdl->a / 2 ) - ( mdl->a / 2 ) * log( mdl->b / 2 ) - mdl->d;
logp += obj->lam * lgamma( obj->gcl[ cls ] );
return logp;
}
double StudentsTLogPdf::f(double nu, double mu, double sigma, const double* xs, size_t n)
{
double part1 =
n * (lgamma((nu + 1) / 2) - lgamma(nu / 2) - fastlog(sqrt(nu * M_PI) * sigma));
double part2 = 0.0;
for (size_t i = 0; i < n; ++i) {
part2 += log1p(sq((xs[i] - mu) / sigma) / nu);
}
return part1 - ((nu + 1) / 2) * part2;
}
//-------------------------------------------------------------------------------------------------------
// calculate the logarithm of the beta-function for sum of two vectors. In Kimmens script |x| is
// defined as sum_xi, so |x| + |y| = | x + y | !!
// the first vector is an int
static double lBetaSum ( const Count * vector1,
const Count length1,
const double *vector2,
const Count length2) {
double result = 0;
int i;
for (i = 0; i < ALPHABET_SIZE; i++)
result += lgamma( vector1[i] + vector2[i]);
return (result - lgamma( length1 + length2 ));
}
//evaluates the ELBO for an individual who is a stayer
double getStayerProb(mm_modelExt model){
int stayerID = model.getStayerID();
double t1,t2,t3,t4;
double phi_sum = 0.0;
double elbo;
int j,k,r,n;
int K = model.getK();
int J = model.getJ();
double back_term;
double dg_phi_sum;
double phi_ik, delta_ijrnk;
//Calculate first line and second line
t1 = 0.0;
t2 = 0.0;
t3 = 0.0;
t4 = 0.0;
t1 = lgamma(sum(model.getAlpha())) - sum(lgamma(model.getAlpha()));
for(k = 0; k < K; k++) {
phi_sum += model.getPhi(stayerID,k);
}
dg_phi_sum = boost::math::digamma(phi_sum);
t4 += lgamma(phi_sum);
for(k = 0; k < K; k++) {
phi_ik = model.getPhi(stayerID,k);
back_term = (boost::math::digamma(phi_ik) - dg_phi_sum);
t1+= (model.getAlpha(k) - 1.0) * back_term;
t4 += -lgamma(phi_ik);
t4 += (phi_ik - 1.0) * back_term;
for(j = 0; j < J; j++) {
for(r = 0; r < model.getR(j); r++) {
for(n = 0; n < model.getN(stayerID, j, r); n++) {
delta_ijrnk = model.getDelta(stayerID, j, r, n, k);
t2 += delta_ijrnk*back_term;
t4 += delta_ijrnk*log(delta_ijrnk);
}
}
}
}
//compute 3rd line
t3 = getStayer_logf(model, stayerID);
elbo = t1 + t2 + t3 - t4;
return elbo;
}
int main(){
//Given the equation (2n)!/(n!)^2
int n = 20;
std::cout << "Calcuating number of routes..." << std::endl;
long long answer = exp(lgamma((n + n) + 1)) / (exp(lgamma(n + 1))*exp(lgamma(n + 1)));
std::cout << "The answer is: " << answer+1 << std::endl;
system("Pause");
return 0;
}
