<!-- Begin

function a_div_b(form) {
    level = (form.level.value);
	knownp = (form.pest.value);
	a=eval(form.t.value);
	b=eval(form.n.value);
	alpha = level;
	var zcrit;
if (b =='' || b ==null)  { 
		form.n.focus()
		form.n.select()
      return false 
	}
if (a ==null)  {
		form.t.focus()
		form.t.select()
      return false 
}

if (alpha == .01) {zcrit = 2.5758313377586; }
if (alpha == .02) {zcrit = 2.326347874; }
if (alpha == .05) {zcrit = 1.959962787; }
if (alpha == .10) {zcrit = 1.644853476; }
if (alpha == .15) {zcrit = 1.439531471; }
if (alpha == .20) {zcrit = 1.281551566; }
if (alpha == .25) {zcrit = 1.15034938; }
if (alpha == .30) {zcrit = 1.036433389; }
if (alpha == .35) {zcrit = 0.934589291; }
if (alpha == .40) {zcrit = 0.841621234; }
if (alpha == .45) {zcrit = 0.755415026; }

if ((alpha == .01) && (a == b)) {zcrit = 2.32634699993243; }
if ((alpha == .02) && (a == b)) {zcrit = 2.053748911; }
if ((alpha == .05) && (a == b)) {zcrit = 1.644853476; }
if ((alpha == .10) && (a == b))  {zcrit = 1.28155193933735;}
if ((alpha == .15) && (a == b))  {zcrit = 1.036433389;}
if ((alpha == .20) && (a == b))  {zcrit = 0.841621234;}
if ((alpha == .25) && (a == b))  {zcrit = 0.67448975;}
if ((alpha == .30) && (a == b))  {zcrit = 0.524400513;}
if ((alpha == .35) && (a == b))  {zcrit = 0.385320466;}
if ((alpha == .40) && (a == b))  {zcrit = 0.253347103;}
if ((alpha == .45) && (a == b))  {zcrit = 0.125661347;}

if ((alpha == .01) && (a == 0)) {zcrit = 2.32634699993243; }
if ((alpha == .02) && (a == 0)) {zcrit = 2.053748911; }
if ((alpha == .05) && (a == 0)) {zcrit = 1.644853476; }
if ((alpha == .10) && (a == 0)) {zcrit = 1.28155193933735;}
if ((alpha == .15) && (a == 0))  {zcrit = 1.036433389;}
if ((alpha == .20) && (a == 0))  {zcrit = 0.841621234;}
if ((alpha == .25) && (a == 0))  {zcrit = 0.67448975;}
if ((alpha == .30) && (a == 0))  {zcrit = 0.524400513;}
if ((alpha == .35) && (a == 0))  {zcrit = 0.385320466;}
if ((alpha == .40) && (a == 0))  {zcrit = 0.253347103;}
if ((alpha == .45) && (a == 0))  {zcrit = 0.125661347;}

	p=a/b
	q=1-p
	v=q*p
	s=Math.sqrt(v)
	sqrtn=Math.sqrt(b)
	se=s/sqrtn
	
	b1=b+(zcrit*zcrit)
	a1=a+((zcrit*zcrit)/2)
	p1=a1/b1
	q1=1-p1
	v1=q1*p1
	s1=Math.sqrt(v1)
	sqrtn1=Math.sqrt(b1)
	se1=s1/sqrtn1
	
	low=p-(zcrit*se)
	low1=p1-(zcrit*se1)
	
	
	//When x=n
	lowxn=p1-(zcrit*se1)
	highxn=p1+(zcrit*se1)
	high=p+(zcrit*se)
	high1=p1+(zcrit*se1)
	
	
	//Wald Values	
	form.high.value = high.toFixed(4)
	form.low.value = low.toFixed(4)
		
	
	//Adjusted Wald Values
	form.alpha.value = level;
	
	margin_aw = (high1-low1)/2
 	margin_w = (high-low)/2

	
	form.margin_aw.value = margin_aw.toFixed(4)
	form.margin_w.value = margin_w.toFixed(4)

	
//When x=n
	
if((high1 > 0.9999) && (a < b))
	{
	form.high2.value = ">.9999";
	form.low2.value = low1.toFixed(4);
	}
else if ((high1 > 1.000) && (a == b))
	{
	high1 = "1.0000", low1 =lowxn;
	form.high2.value = high1;
	form.low2.value = lowxn.toFixed(4);
	}
else if (a == 0) 
	{
	high1 = highxn;
	low1 = 0.00;
	form.high2.value = high1.toFixed(4);
	form.low2.value = low1.toFixed(4);
	}
else if (low1 < 0.00) 
	{
	form.low2.value = "<.0001";
	form.high2.value = high1.toFixed(4);
	}
else 
	{
	form.high2.value = high1.toFixed(4);
	form.low2.value = low1.toFixed(4);
	}

	//***********Point Estimates***************
	
	lapl = (a+1)/(b+2)
	jeffr= (a+.5)/(b+1)
	
	if ((knownp == 1 ) && (p <= .500000)) {
	best_p = p1
	}
	else if ((knownp == 1 ) && (p >.5000000) && (p <=.900000)) {
	best_p = p
	}
	else if ((knownp == 1 ) && (p >.9000000) && (p <1.0000)) {
	best_p = lapl
	}
	else {
	best_p = lapl
	}
	
		
	//MLE
	form.mle.value = p.toFixed(4)
	
	//	LaPlace
	form.laplace.value = lapl.toFixed(4)
	
	//Jeffrey's
	form.jeffrey.value = jeffr.toFixed(4)
	
	//Wilson
	form.wilson.value = p1.toFixed(4)
	
	//Best Estimate
	form.best.value = best_p.toFixed(4)

	
}	
	

//Score Method

function approx(form) {
    level = (form.level.value)
	x=eval(form.t.value)
	n=eval(form.n.value)
	alpha = level
	var zcrit;
if (n =='' || n ==null)  { 
		form.n.focus()
		form.n.select()
      return false 
	}
if (x ==null)  {
                form.t.focus()
                form.t.select()
      return false 
}

if (alpha == .01) {zcrit = 2.5758313377586; }
if (alpha == .02) {zcrit = 2.326347874; }
if (alpha == .05) {zcrit = 1.959962787; }
if (alpha == .10) {zcrit = 1.644853476; }
if (alpha == .15) {zcrit = 1.439531471; }
if (alpha == .20) {zcrit = 1.281551566; }
if (alpha == .25) {zcrit = 1.15034938; }
if (alpha == .30) {zcrit = 1.036433389; }
if (alpha == .35) {zcrit = 0.934589291; }
if (alpha == .40) {zcrit = 0.841621234; }
if (alpha == .45) {zcrit = 0.755415026; }

if ((alpha == .01) && (x == n)) {zcrit = 2.32634699993243; }
if ((alpha == .02) && (x == n)) {zcrit = 2.053748911; }
if ((alpha == .05) && (x == n)) {zcrit = 1.644853476; }
if ((alpha == .10) && (x == n))  {zcrit = 1.28155193933735;}
if ((alpha == .15) && (x == b))  {zcrit = 1.036433389;}
if ((alpha == .20) && (x == b))  {zcrit = 0.841621234;}
if ((alpha == .25) && (x == b))  {zcrit = 0.67448975;}
if ((alpha == .30) && (x == b))  {zcrit = 0.524400513;}
if ((alpha == .35) && (x == b))  {zcrit = 0.385320466;}
if ((alpha == .40) && (x == b))  {zcrit = 0.253347103;}
if ((alpha == .45) && (x == b))  {zcrit = 0.125661347;}

if ((alpha == .01) && (x == 0)) {zcrit = 2.32634699993243; }
if ((alpha == .02) && (x == 0)) {zcrit = 2.053748911; }
if ((alpha == .05) && (x == 0)) {zcrit = 1.644853476; }
if ((alpha == .10) && (x == 0)) {zcrit = 1.28155193933735;}
if ((alpha == .15) && (x == 0))  {zcrit = 1.036433389;}
if ((alpha == .20) && (x == 0))  {zcrit = 0.841621234;}
if ((alpha == .25) && (x == 0))  {zcrit = 0.67448975;}
if ((alpha == .30) && (x == 0))  {zcrit = 0.524400513;}
if ((alpha == .35) && (x == 0))  {zcrit = 0.385320466;}
if ((alpha == .40) && (x == 0))  {zcrit = 0.253347103;}
if ((alpha == .45) && (x == 0))  {zcrit = 0.125661347;}

	prop= x/n
	xsq= x*x
	nsq = n*n
	zcritsq = zcrit*zcrit
	
	phat = 2*n*x+(zcritsq*n)
	phat_sq = phat*phat
	phat_next = nsq+zcritsq*n
	phat_next4= 4*phat_next
	phat_next2= 2*phat_next
	phat_next4Xsqrd = phat_next4*xsq
	phat_top = (phat_sq - phat_next4Xsqrd)
	phat_bottom = phat_next2
	phat_top_sqrt = Math.sqrt(phat_top)
	phat_plus = phat + phat_top_sqrt
	phat_minus = phat - phat_top_sqrt
	score_lowerci= phat_minus/phat_bottom
	score_upperci= phat_plus/phat_bottom
	score_margin = (score_upperci - score_lowerci)/2
		
	form.scorehigh.value = score_upperci.toFixed(4)
	form.scorelow.value = score_lowerci.toFixed(4)
    form.margin_s.value = score_margin.toFixed(4)

	
}
//Exact Interval Calculations

function tcalc(form) {

n=eval(form.n.value)
t=eval(form.t.value)
alpha=eval(form.level.value)

if (n > 9999) {
	alert("The Exact Interval Algorithm only computes for samples less than 10,000. With a sample size this large there will be virtually no difference between the confidence interval formulas. Using the Wald or Adjusted Wald is recommended.");	
	return false;
}
if (n =='' || n ==null)  { alert("Total Tested is a Required Value")
                form.n.focus()
                form.n.select()
      return false 
	}
if (t ==null )  { alert("Number Passed is a Required Value")
		form.t.focus()
		form.t.select()
      return false 
	}
if (n<=0)  { alert("The number of users tested must be greater than 0.")
                form.n.focus()
                form.n.select()
   return false 
 }

if ((t<0) || (t>n)) { alert("The number of successes must be between 0 and the total number tested.")
                form.t.focus()
                form.t.select()
                return false }

if ((alpha<=0) || (alpha>=1)) { alert("The alpha value must be between 0 and 1 (common values are .01, .05, .10")
                form.alpha.focus()
                form.alpha.select()
                return false }
nu1=2.0*(n-t+1)
nu2=2.0*t
critv=alpha/2

if ((alpha == .01) && (n == t)) {critv = alpha; }
if ((alpha == .05) && (n == t)) {critv= alpha; }
if ((alpha == .10) && (n == t)) {critv = alpha;}

if ((alpha == .01) && (t == 0)) {critv = alpha; }
if ((alpha == .05) && (t == 0)) {critv = alpha; }
if ((alpha == .10) && (t == 0)) {critv = alpha;}

if (t>0) ll=t/(t+AFishF(critv,nu1,nu2)*(n-t+1))
    else ll=0
nu1p=nu2+2
nu2p=nu1-2
if (t<n) pp=AFishF(critv,nu1p,nu2p)
    else pp=1

 ul=((t+1)*pp)/(n-t+(t+1)*pp)


 form.lowerci.value=format(ll,4)
 form.upperci.value = ul.toFixed(4) 
 //form.upperci.value=format(ul,4) 
 margin_e = (ul-ll)/2
 form.margin_e.value = margin_e.toFixed(4)
            
return true }


function FishF(f,n1,n2) {
    var x=n2/(n1*f+n2)
    if((n1%2)==0) { return StatCom(1-x,n2,n1+n2-4,n2-2)*Math.pow(x,n2/2) }
    if((n2%2)==0){ return 1-StatCom(x,n1,n1+n2-4,n1-2)*Math.pow(1-x,n1/2) }
    var th=Math.atan(Math.sqrt(n1*f/n2)); var a=th/PiD2; var sth=Math.sin(th); var cth=Math.cos(th)
    if(n2>1) { a=a+sth*cth*StatCom(cth*cth,2,n2-3,-1)/PiD2 }
    if(n1==1) { return 1-a }
    var c=4*StatCom(sth*sth,n2+1,n1+n2-4,n2-2)*sth*Math.pow(cth,n2)/Pi
    if(n2==1) { return 1-a+c/2 }
    var k=2; while(k<=(n2-1)/2) {c=c*k/(k-.5); k=k+1 }
    return 1-a+c
    }
function StatCom(q,i,j,b) {
    var zz=1; var z=zz; var k=i; while(k<=j) { zz=zz*q*k/(k-b); z=z+zz; k=k+2 }
    return z
    }
 function AFishF(p,n1,n2) { var v=0.5; var dv=0.5; var f=0
    while(dv>1e-6) { f=1/v-1; dv=dv/2; if(FishF(f,n1,n2)>p) { v=v-dv } else { v=v+dv } }
    return f
    }


MACHEP =  1.11022302462515654042e-16   /* 2**-53 */
UFLOWTHRESH =  2.22507385850720138309e-308 /* 2**-1022 */
MAXLOG =  7.09782712893383996732e2     /* log(MAXNUM) */
MINLOG = -7.451332191019412076235e2     /* log(2**-1075) */
MAXLOG =  7.08396418532264106224e2     /* log 2**1022 */
MINLOG = -7.08396418532264106224e2     /* log 2**-1022 */
MAXNUM =  1.79769313486231570815e308    /* 2**1024*(1-MACHEP) */
PI     =  3.14159265358979323846       /* pi */
PIO2   =  1.57079632679489661923       /* pi/2 */
PIO4   =  7.85398163397448309616e-1    /* pi/4 */
SQRT2  =  1.41421356237309504880       /* sqrt(2) */
SQRTH  =  7.07106781186547524401e-1    /* sqrt(2)/2 */
LOG2E  =  1.4426950408889634073599     /* 1/log(2) */
SQ2OPI =  7.9788456080286535587989e-1  /* sqrt( 2/pi ) */
LOGE2  =  6.93147180559945309417e-1    /* log(2) */
LOGSQ2 =  3.46573590279972654709e-1    /* log(2)/2 */
THPIO4 =  2.35619449019234492885       /* 3*pi/4 */
TWOOPI =  6.36619772367581343075535e-1 /* 2/pi */
INFINITY =  1.79769313486231570815e308    /* 2**1024*(1-MACHEP) */
NAN = 0.0
NEGZERO = 0.0
big = 4.503599627370496e15
biginv = 2.22044604925031308085e-16
MAXGAM = 171.624376956302725
LOGPI = 1.14472988584940017414
MAXSTIR = 143.01608
SQTPI = 2.50662827463100050242e0
LS2PI  =  0.91893853320467274178
MAXLGM = 2.556348e305


function MakeArray(n) {
this.length = n
for (var i = 1; i<= n; i++) {
 this[i] = 0
 }
return this
}


function format(value, decimal)
{
wi = (value < 0) ? Math.ceil(value) : Math.floor(value)
wd = Math.round((Math.abs(value - wi)) * Math.pow(10, decimal))
decim = Math.pow(10, (decimal-1))
tring = wd
for (var i = 2; wd < decim; i++)
        {
        decim = Math.pow(10, (decimal - i))
        tring = "0" + tring
        }
if (value < 0 && value > -1)
  return "-" + wi + "." + tring
else
  return wi + "." + tring
}

function display_number(x, form)
{
form.zval.value = format(x, 4)
}


function polevl(x, coef, N)
{
ans = coef[0]
i=0
while (++i < N+1)
{
 ans = ans * x + coef[i]
}
 return ans
}


function p1evl (x, coef, N)
{
ans = x + coef[0];
i = 0
while (++i < N)
{
 ans = ans * x + coef[i]
}
return ans
}


function incbi(aa, bb, yy0)
{

i = 0
if (yy0 <= 0)
	return 0.0
if (yy0 >= 1.0)
	return 1.0
x0 = 0.0
yl = 0.0
x1 = 1.0
yh = 1.0
nflg = 0
ihalve = false
newt = false


if (aa <= 1.0 || bb <= 1.0)
	{
	dithresh = 1.0e-6
	rflg = 0
	a = aa
	b = bb
	y0 = yy0
	x = a/(a+b)
	y = incbet(a, b, x)
//	goto ihalve
        ihalve = true
	}
else
	{
	dithresh = 1.0e-4
	}
/* approximation to inverse function */

if (!ihalve)
{
yp = -ndtri(yy0)

if (yy0 > 0.5)
	{
	rflg = 1
	a = bb
	b = aa
	y0 = 1.0 - yy0
	yp = -yp
	}
else
	{
	rflg = 0
	a = aa
	b = bb
	y0 = yy0
	}

lgm = (yp * yp - 3.0)/6.0
x = 2.0/(1.0/(2.0*a-1.0)  +  1.0/(2.0*b-1.0))
d = yp * Math.sqrt( x + lgm ) / x
	- ( 1.0/(2.0*b-1.0) - 1.0/(2.0*a-1.0) )
	* (lgm + 5.0/6.0 - 2.0/(3.0*x))
d = 2.0 * d
if( d < MINLOG )
	{
	x = 1.0
        return incbidone(0.0, rflg)
	}
x = a/(a + b * Math.exp(d))
y = incbet(a, b, x)
yp = (y - y0)/y0
if (Math.abs(yp) < 0.2)
{
        newt = true
//      goto newt
}
}
/* Resort to interval halving if not close enough. */


/*******************************************************
**
**   Start IHALVE
**
********************************************************/

// ihalve:
while (true)
{
if (!newt)
{
ihalve = false
dir = 0
di = 0.5
for (i=0; i<100; i++)
	{
	if (i != 0)
		{
		x = x0  +  di * (x1 - x0)
		if (x == 1.0)
			x = 1.0 - MACHEP
		if (x == 0.0)
			{
			di = 0.5
			x = x0  +  di * (x1 - x0)
			if (x == 0.0)
                           return incbidone(0.0, rflg)

			}
		y = incbet(a, b, x)
		yp = (x1 - x0)/(x1 + x0)
		if (Math.abs(yp) < dithresh)
                   {
                    newt = true
                    break
                   }
		yp = (y-y0)/y0
		if (Math.abs(yp) < dithresh)
                   {
                    newt = true
                    break
                   }
		}
	if (y < y0)
		{
		x0 = x
		yl = y
		if (dir < 0)
			{
			dir = 0
			di = 0.5
			}
		else if (dir > 3)
			di = 1.0 - (1.0 - di) * (1.0 - di)
		else if (dir > 1)
			di = 0.5 * di + 0.5 
		else
			di = (y0 - y)/(yh - yl)
		dir += 1
		if (x0 > 0.75)
			{
			if (rflg == 1)
				{
				rflg = 0
				a = aa
				b = bb
				y0 = yy0
				}
			else
				{
				rflg = 1
				a = bb
				b = aa
				y0 = 1.0 - yy0
				}
			x = 1.0 - x
			y = incbet(a, b, x)
			x0 = 0.0
			yl = 0.0
			x1 = 1.0
			yh = 1.0
                        ihalve = true
// 		goto ihalve
			}
		}
	else
		{
		x1 = x
		if (rflg == 1 && x1 < MACHEP)
			{
			x = 0.0
			return incbidone(x, rflg)
			}
		yh = y
		if (dir > 0)
			{
			dir = 0
			di = 0.5
			}
		else if (dir < -3)
			di = di * di
		else if (dir < -1)
			di = 0.5 * di
		else
			di = (y - y0)/(yh - yl)
		dir -= 1
		}
	}
}

if (!ihalve)
{

if (!newt)
{
mtherr("incbi", PLOSS)
if (x0 >= 1.0)
	{
	x = 1.0 - MACHEP
        return incbidone(x, rflg)
	}
if (x <= 0.0)
	{
	x = 0.0
        return incbidone(x, rflg)

	}
}

/**********************************************************
**
**   Begin NEWT 
**
***********************************************************/

if (nflg != 0)
    return incbidone(x, rflg)

nflg = 1
lgm = lgam(a+b) - lgam(a) - lgam(b)

for(i=0; i<8; i++)
	{
	/* Compute the function at this point. */
	if (i != 0)
		y = incbet(a,b,x)
	if (y < yl)
		{
		x = x0
		y = yl
		}
	else if (y > yh)
		{
		x = x1
		y = yh
		}
	else if (y < y0)
		{
		x0 = x
		yl = y
		}
	else
		{
		x1 = x
		yh = y
		}
	if (x == 1.0 || x == 0.0)
		break
	/* Compute the derivative of the function at this point. */
	d = (a - 1.0) * Math.log(x) + (b - 1.0) * Math.log(1.0-x) + lgm
	if (d < MINLOG)
                return incbidone(x, rflg)

	if (d > MAXLOG)
		break
	d = Math.exp(d)
	/* Compute the step to the next approximation of x. */
	d = (y - y0)/d
	xt = x - d
	if (xt <= x0)
		{
		y = (x - x0) / (x1 - x0)
		xt = x0 + 0.5 * y * (x - x0)
		if (xt <= 0.0)
			break
		}
	if (xt >= x1)
		{
		y = (x1 - x) / (x1 - x0)
		xt = x1 - 0.5 * y * (x1 - x)
		if (xt >= 1.0)
			break
		}
	x = xt
	if (Math.abs(d/x) < 128.0 * MACHEP)
              return incbidone(x, rflg)

	}

/* Did not converge.  */
dithresh = 256.0 * MACHEP
newt = false
}
}  // END IHALVE WHILE
return 0
}


function incbidone(x, rflg)
{
if (rflg != 0)
        {
        if (x <= MACHEP)
                x = 1.0 - MACHEP
        else
                x = 1.0 - x
        }
return x
}


/* Gamma function computed by Stirling's formula.
 * The polynomial STIR is valid for 33 <= x <= 172.
 */
function stirf(x)
{

STIR = new MakeArray(5)
STIR[0] = 7.87311395793093628397e-4
STIR[1] = -2.29549961613378126380e-4
STIR[2] = -2.68132617805781232825e-3
STIR[3] = 3.47222221605458667310e-3
STIR[4] = 8.33333333333482257126e-2


w = 1.0/x
w = 1.0 + w * polevl(w, STIR, 4)
y = Math.exp(x)
if (x > MAXSTIR)
	{ /* Avoid overflow in pow() */
	v = Math.pow(x, 0.5 * x - 0.25)
	y = v * (v / y)
	}
else
	{
	y = Math.pow(x, x - 0.5) / y
	}
y = SQTPI * y * w
return y
}


function gamma(x)
{
P = new MakeArray(7)
P[0] = 1.60119522476751861407e-4
P[1] = 1.19135147006586384913e-3
P[2] = 1.04213797561761569935e-2
P[3] = 4.76367800457137231464e-2
P[4] = 2.07448227648435975150e-1
P[5] = 4.94214826801497100753e-1
P[6] = 9.99999999999999996796e-1

Q = new MakeArray(8)
Q[1] = -2.31581873324120129819e-5
Q[2] =  5.39605580493303397842e-4
Q[3] = -4.45641913851797240494e-3
Q[4] =  1.18139785222060435552e-2
Q[5] =  3.58236398605498653373e-2
Q[6] = -2.34591795718243348568e-1
Q[7] =  7.14304917030273074085e-2
Q[8] =  1.00000000000000000320e0


sgngam = 1
q = Math.abs(x)

if (q > 33.0)
	{
	if (x < 0.0)
		{
		p = Math.floor(q)
		if (p == q)
                        return sgngam * MAXNUM
		i = p
		if ((i & 1) == 0)
			sgngam = -1
		z = q - p
		if (z > 0.5)
			{
			p += 1.0
			z = q - p
			}
		z = q * Math.sin( PI * z )
		if (z == 0.0)
			{
			return sgngam * MAXNUM
			}
		z = Math.abs(z)
		z = PI/(z * stirf(q))
		}
	else
		{
		z = stirf(x)
		}
	return sgngam * z 
	}

z = 1.0
while (x >= 3.0)
	{
	x -= 1.0
	z *= x
	}

while (x < 0.0)
	{
	if (x > -1.E-9)
           {
            temp = small_fun(x, z)
            return temp
           }
	z /= x
	x += 1.0
	}

while (x < 2.0)
	{
	if( x < 1.e-9 )
           {
            temp = small_fun(x, z)
            return temp
           }
	z /= x
	x += 1.0
	}

if ((x == 2.0) || (x == 3.0))
	return z

x -= 2.0
p = polevl(x, P, 6)
q = polevl(x, Q, 7)
return z * p / q
}


function small_fun(x, z)
{
if (x == 0.0)
        {
        return MAXNUM
        }
else
        return z/((1.0 + 0.5772156649015329 * x) * x)
}


/* A[]: Stirling's formula expansion of log gamma
 * B[], C[]: log gamma function between 2 and 3
 */

/* Logarithm of gamma function */


function lgam(x)
{
A = new MakeArray(5)
A[0] = 8.11614167470508450300e-4
A[1] = -5.95061904284301438324e-4
A[2] = 7.93650340457716943945e-4
A[3] = -2.77777777730099687205e-3
A[4] = 8.33333333333331927722e-2


B = new MakeArray(6)
B[0] = -1.37825152569120859100e3
B[1] = -3.88016315134637840924e4
B[2] = -3.31612992738871184744e5
B[3] = -1.16237097492762307383e6
B[4] = -1.72173700820839662146e6
B[5] = -8.53555664245765465627e5

C = new MakeArray(6)
C[0] = -3.51815701436523470549e2
C[1] = -1.70642106651881159223e4
C[2] = -2.20528590553854454839e5
C[3] = -1.13933444367982507207e6
C[4] = -2.53252307177582951285e6
C[5] = -2.01889141433532773231e6

var sgngam = 1

if (x < -34.0)
	{
var 	q = -x
var 	w = lgam(q)  /* note this modifies sgngam! */
var 	p = Math.floor(q)
	if (p == q)
          return sgngam * MAXNUM

var 	i = p
	if ((i & 1) == 0)
		sgngam = -1
	else
		sgngam = 1
var 	z = q - p
	if (z > 0.5)
		{
		p += 1.0
		z = p - q
		}
	z = q * Math.sin(PI * z)
	if (z == 0.0)
          return sgngam * MAXNUM

	z = LOGPI - Math.log( z ) - w
	return z
	}

if (x < 13.0)
	{
var 	z = 1.0
	while (x >= 3.0)
		{
		x -= 1.0
		z *= x
		}
	while (x < 2.0)
		{
		if (x == 0.0)
                   return sgngam * MAXNUM
		z /= x
		x += 1.0
		}
	if (z < 0.0)
		{
 		sgngam = -1
		z = -z
		}
	else
 		sgngam = 1
	if (x == 2.0)
		return Math.log(z)
	x -= 2.0
	p = x * polevl(x, B, 5) / p1evl(x, C, 6)
	return (Math.log(z) + p)
	}

if (x > MAXLGM)
	{
	return sgngam * MAXNUM
	}

q = (x - 0.5) * Math.log(x) - x + LS2PI
if (x > 1.0e8)
	return q

p = 1.0/(x*x)
if (x >= 1000.0)
	q += ((   7.9365079365079365079365e-4 * p
		- 2.7777777777777777777778e-3) * p
		+ 0.0833333333333333333333) / x
else
	q += polevl(p, A, 4) / x
return q
}


/*******************************************************************
**  INCBET - Incomplete Beta Function
********************************************************************/

function incbet(aa, bb, xx)
{

if (aa <= 0.0 || bb <= 0.0)
        return 0.0

if ((xx <= 0.0) || (xx >= 1.0))
        {
        if( xx == 0.0 )
                return 0.0
        if( xx == 1.0 )
                return 1.0
        return 0.0
        }

flag = 0
if ((bb * xx) <= 1.0 && xx <= 0.95)
        {
var        t = pseries(aa, bb, xx)
var        temp = is_done(flag, t)
        return temp
        }

var w = 1.0 - xx

/* Reverse a and b if x is greater than the mean. */
if (xx > (aa/(aa+bb)))
        {
var         flag = 1
var         a = bb
var         b = aa
var         xc = xx
var         x = w
        }
else
        {
var         a = aa
var         b = bb
var         xc = w
var         x = xx
        }

if (flag == 1 && (b * x) <= 1.0 && x <= 0.95)
        {
var         t = pseries(a, b, x)
var         temp = is_done(flag, t)
        return temp
        }

/* Choose expansion for better convergence. */
var y = x * (a + b - 2.0) - (a - 1.0)
if (y < 0.0)
        w = incbcf(a, b, x)
else
        w = incbd(a, b, x) / xc

/* Multiply w by the factor
     a      b   _             _     _
    x  (1-x)   | (a+b) / ( a | (a) | (b) ) .   */

y = a * Math.log(x)
t = b * Math.log(xc)
if ((a+b) < MAXGAM && Math.abs(y) < MAXLOG && Math.abs(t) < MAXLOG)
        {
        t = Math.pow(xc,b)
        t *= Math.pow(x,a)
        t /= a
        t *= w
        t *= gamma(a+b) / (gamma(a) * gamma(b))
        temp = is_done(flag, t)
        return temp
        }
/* Resort to logarithms.  */
y += t + lgam(a+b) - lgam(a) - lgam(b)
y += Math.log(w/a)
if (y < MINLOG)
        t = 0.0
else
        t = Math.exp(y)

temp = is_done(flag, t)
return temp
}


function is_done (flag, t)
{
if (flag == 1)
        {
        if (t <= MACHEP)
                t = 1.0 - MACHEP
        else
                t = 1.0 - t
        }
 return t
}


/****************************************
 * Continued fraction expansion #1
 * for incomplete beta integral
 ****************************************/

function incbcf(a, b, x)
{

var k1 = a
var k2 = a + b
var k3 = a
var k4 = a + 1.0
var k5 = 1.0
var k6 = b - 1.0
var k7 = k4
var k8 = a + 2.0

var pkm2 = 0.0
var qkm2 = 1.0
var pkm1 = 1.0
var qkm1 = 1.0
var ans = 1.0
var r = 1.0
var n = -1 
var thresh = 3.0 * MACHEP

while (++n < 300)
        {
var         xk = -(x * k1 * k2)/(k3 * k4)
var         pk = pkm1 +  pkm2 * xk
var         qk = qkm1 +  qkm2 * xk
        pkm2 = pkm1
        pkm1 = pk
        qkm2 = qkm1
        qkm1 = qk

        xk = (x * k5 * k6)/(k7 * k8)
        pk = pkm1 +  pkm2 * xk
        qk = qkm1 +  qkm2 * xk
        pkm2 = pkm1
        pkm1 = pk
        qkm2 = qkm1
        qkm1 = qk

        if (qk != 0)
                r = pk/qk
        if (r != 0)
                {
                t = Math.abs((ans - r)/r)
                ans = r
                }
        else
                t = 1.0


        if (t < thresh)
           break

        k1 += 1.0
        k2 += 1.0
        k3 += 2.0
        k4 += 2.0
        k5 += 1.0
        k6 -= 1.0
        k7 += 2.0
        k8 += 2.0

        if ((Math.abs(qk) + Math.abs(pk)) > big)
                {
                pkm2 *= biginv
                pkm1 *= biginv
                qkm2 *= biginv
                qkm1 *= biginv
                }
        if ((Math.abs(qk) < biginv) || (Math.abs(pk) < biginv))

                {
                pkm2 *= big
                pkm1 *= big
                qkm2 *= big
                qkm1 *= big
                }
        }
return ans
}


/*********************************
 * Continued fraction expansion #2
 * for incomplete beta integral
 *********************************/

function incbd(a, b, x)
{

var k1 = a
var k2 = b - 1.0
var k3 = a
var k4 = a + 1.0
var k5 = 1.0
var k6 = a + b
var k7 = a + 1.0
var k8 = a + 2.0

var pkm2 = 0.0
var qkm2 = 1.0
var pkm1 = 1.0
var qkm1 = 1.0
var z = x / (1.0-x)
var ans = 1.0
var r = 1.0
var n = -1
var thresh = 3.0 * MACHEP

while (++n < 300)
        {
var         xk = -(z * k1 * k2)/(k3 * k4)
var         pk = pkm1 +  pkm2 * xk
var         qk = qkm1 +  qkm2 * xk
        pkm2 = pkm1
        pkm1 = pk
        qkm2 = qkm1
        qkm1 = qk

        xk = (z * k5 * k6)/(k7 * k8)
        pk = pkm1 +  pkm2 * xk
        qk = qkm1 +  qkm2 * xk
        pkm2 = pkm1
        pkm1 = pk
        qkm2 = qkm1
        qkm1 = qk

        if (qk != 0)
                r = pk/qk
        if (r != 0)
                {
                t = Math.abs((ans - r)/r)
                ans = r
                }
        else
                t = 1.0

        if (t < thresh)
           break

        k1 += 1.0
        k2 -= 1.0
        k3 += 2.0
        k4 += 2.0
        k5 += 1.0
        k6 += 1.0
        k7 += 2.0
        k8 += 2.0

        if ((Math.abs(qk) + Math.abs(pk)) > big)
                {
                pkm2 *= biginv
                pkm1 *= biginv
                qkm2 *= biginv
                qkm1 *= biginv
                }
        if ((Math.abs(qk) < biginv) || (Math.abs(pk) < biginv))
                {
                pkm2 *= big
                pkm1 *= big
                qkm2 *= big
                qkm1 *= big
                }
        }
return ans
}


/************************************************
*  Power series for incomplete beta integral.
*  Use when b*x is small and x not too close to 1.  
*************************************************/

function pseries(a, b, x)
{

var ai = 1.0 / a
var u = (1.0 - b) * x
var v = u / (a + 1.0)
var t1 = v
var t = u
var n = 2.0
var s = 0.0
var z = MACHEP * ai
while (Math.abs(v) > z)
        {
        u = (n - b) * x / n
        t *= u
        v = t / (a + n)
        s += v
        n += 1.0
        }
s += t1
s += ai

u = a * Math.log(x)
if ((a+b) < MAXGAM && Math.abs(u) < MAXLOG)
        {
        t = gamma(a+b)/(gamma(a)*gamma(b))
        s = s * t * Math.pow(x,a)
        }
else
        {
        t = lgam(a+b) - lgam(a) - lgam(b) + u + Math.log(s)
        if (t < MINLOG)
                s = 0.0
        else
        s = Math.exp(t)
        }
return s
}


function stdtr(form)
{
var k = form.dof.value
var t = form.crit_value.value

if (k <= 0)
{
        form.tail_prob.value = format(0.0, 4)
        return 0.0
}

if (t == 0)
{
        form.tail_prob.value = format(0.5, 4)
        return 0.5
}

if (t < -2.0)
        {
var         rk = k
var         z = rk / (rk + t * t)
var         aa = 0.5 * rk
var         bb = 0.5
var         xx = z
var         p = 0.5 * incbet(aa, bb, xx)
        form.prob.value = format(p, 4)
        return p
        }

/*      compute integral from -t to + t */

var x = Math.abs(t)

var rk = k  /* degrees of freedom */
var z = 1.0 + (x * x)/rk

/* test if k is odd or even */
if ((k & 1) != 0)
        {

        /*      computation for odd k   */

        xsqk = x/Math.sqrt(rk)
        p = Math.atan(xsqk)
        if (k > 1)
                {
var                 f = 1.0
var                 tz = 1.0
var                 j = 3
                while ((j<=(k-2)) && ((tz/f) > MACHEP))
                        {
                        tz *= (j-1)/( z * j )
                        f += tz
                        j += 2
                        }
                p += f * xsqk/z
                }
        p *= 2.0/PI
        }

else
        {

        /*      computation for even k  */

var         f = 1.0
var         tz = 1.0
var         j = 2

        while ((j <= (k-2)) && ((tz/f) > MACHEP))
                {
                tz *= (j - 1)/( z * j )
                f += tz
                j += 2
                }
var         p = f * x/Math.sqrt(z*rk)
        }

/*      common exit     */


if ((t < 0) && (t > -2))
        p = -p  /* note destruction of relative accuracy */

        p = 0.5 + 0.5 * p

if (t < -2)
   p = 1.0 - p

form.tail_prob.value = format(p, 4)
return p
}


function stdtri(form)
{
k = parseFloat(form.dof.value)
p = parseFloat(form.tail_prob.value)


if (k <= 0 || p <= 0.0 || p >= 1.0)
        {
        form.crit_value.value = format(0.0, 4)
        return 0.0
        }

rk = k
alert(rk)
alert(k)

if (p > 0.25 && p < 0.75)
        {
        if (p == 0.5)
           {
                form.crit_value.value = format(0.0, 4)
                return 0.0
           }

        z = 1.0 - 2.0 * p
        alert(rk)
        alert(z)
        // z = incbi(0.5, 0.5*rk, Math.abs(z))
z = incbi(0.5, 6.0, .3)


        t = Math.sqrt(rk*z/(1.0-z));
        if (p < 0.5)
                t = -t
        form.crit_value.value = format(t, 4)
        return t
        }
rflg = -1
if (p >= 0.5)
        {
        p = 1.0 - p
        rflg = 1
        }


z = incbi(0.5*rk, 0.5, 2.0*p)

if (MAXNUM * z < rk)
        return rflg * MAXNUM
t = Math.sqrt(rk/z - rk)
x = rflg * t

form.crit_value.value = format(x, 4)
return x


}
// stop hiding from other browsers -->