int main(void)
{
long idum=(-17);
int i,ibin,j;
float chsq,df,prob,x,*bins1,*bins2;
bins1=vector(1,NBINS);
bins2=vector(1,NBINS);
for (j=1;j<=NBINS;j++) {
bins1[j]=0.0;
bins2[j]=0.0;
}
for (i=1;i<=NPTS;i++) {
x=expdev(&idum);
ibin=(int) (x*NBINS/3.0+1);
if (ibin <= NBINS) ++bins1[ibin];
x=expdev(&idum);
ibin=(int) (x*NBINS/3.0+1);
if (ibin <= NBINS) ++bins2[ibin];
}
chstwo(bins1,bins2,NBINS,0,&df,&chsq,&prob);
printf("\n%15s %15s\n","dataset 1","dataset 2");
for (i=1;i<=NBINS;i++)
printf("%13.2f %15.2f\n",bins1[i],bins2[i]);
printf("\n%18s %12.4f\n","chi-squared:",chsq);
printf("%18s %12.4f\n","probability:",prob);
free_vector(bins2,1,NBINS);
free_vector(bins1,1,NBINS);
return 0;
}
void Customer::Handler(BeginMsg &) {
float x;
x = Time + expdev(&idum)/mu;
Schedule(x); // schedule the completion event
}
void Source::Handler(CalendarMsg &) {
float x;
Customer * customer;
customer = new Customer; // create a new customer
customer->ts = Time; // timestamp the customer
customer->station = station1; // route the customer to station 1
customer->station->Request(customer); // serve or queue the customer
x = Time + expdev(&idum)/lambda;
Schedule(x); // schedule the next arrival
arrivals++; // count the number of arrivals
}
static size_t randomSize(unsigned long i)
{
/* Distribution centered on mean. Verify that allocations
below min and above max are handled correctly */
size_t s = (size_max - size_mean)/4;
size_t m = size_mean;
double r;
double x;
testlib_unused(i);
/* per SGR */
do {
r = expdev();
x = (double)s * sqrt(2 * r);
x += (double)m;
} while (x <= 1.0);
return (size_t)x;
}
/**
* Description not yet available.
* \param
*/
double sgamma(double a,const random_number_generator& _rng)
/*
**********************************************************************
(STANDARD-) G A M M A DISTRIBUTION
**********************************************************************
**********************************************************************
PARAMETER A >= 1.0 !
**********************************************************************
FOR DETAILS SEE:
AHRENS, J.H. AND DIETER, U.
GENERATING GAMMA VARIATES BY A
MODIFIED REJECTION TECHNIQUE.
COMM. ACM, 25,1 (JAN. 1982), 47 - 54.
STEP NUMBERS CORRESPOND TO ALGORITHM 'GD' IN THE ABOVE PAPER
(STRAIGHTFORWARD IMPLEMENTATION)
Modified by Barry W. Brown, Feb 3, 1988 to use RANF instead of
SUNIF. The argument IR thus goes away.
**********************************************************************
PARAMETER 0.0 < A < 1.0 !
**********************************************************************
FOR DETAILS SEE:
AHRENS, J.H. AND DIETER, U.
COMPUTER METHODS FOR SAMPLING FROM GAMMA,
BETA, POISSON AND BINOMIAL DISTRIBUTIONS.
COMPUTING, 12 (1974), 223 - 246.
(ADAPTED IMPLEMENTATION OF ALGORITHM 'GS' IN THE ABOVE PAPER)
**********************************************************************
INPUT: A =PARAMETER (MEAN) OF THE STANDARD GAMMA DISTRIBUTION
OUTPUT: SGAMMA = SAMPLE FROM THE GAMMA-(A)-DISTRIBUTION
COEFFICIENTS Q(K) - FOR Q0 = SUM(Q(K)*A**(-K))
COEFFICIENTS A(K) - FOR Q = Q0+(T*T/2)*SUM(A(K)*V**K)
COEFFICIENTS E(K) - FOR EXP(Q)-1 = SUM(E(K)*Q**K)
PREVIOUS A PRE-SET TO ZERO - AA IS A', AAA IS A"
SQRT32 IS THE SQUAREROOT OF 32 = 5.656854249492380
*/
{
random_number_generator& rng=(random_number_generator&) _rng;
static double q1 = 4.166669E-2;
static double q2 = 2.083148E-2;
static double q3 = 8.01191E-3;
static double q4 = 1.44121E-3;
static double q5 = -7.388E-5;
static double q6 = 2.4511E-4;
static double q7 = 2.424E-4;
static double a1 = 0.3333333;
static double a2 = -0.250003;
static double a3 = 0.2000062;
static double a4 = -0.1662921;
static double a5 = 0.1423657;
static double a6 = -0.1367177;
static double a7 = 0.1233795;
static double e1 = 1.0;
static double e2 = 0.4999897;
static double e3 = 0.166829;
static double e4 = 4.07753E-2;
static double e5 = 1.0293E-2;
static double aa = 0.0;
static double aaa = 0.0;
static double sqrt32 = 5.656854;
/* JJV added b0 to fix rare and subtle bug */
static double sgamma,s2,s,d,t,x,u,r,q0,b,b0,si,c,v,q,e,w,p;
if(a == aa) goto S10;
if(a < 1.0) goto S120;
/*
STEP 1: RECALCULATIONS OF S2,S,D IF A HAS CHANGED
*/
aa = a;
s2 = a-0.5;
s = sqrt(s2);
d = sqrt32-12.0*s;
S10:
/*
STEP 2: T=STANDARD NORMAL DEVIATE,
X=(S,1/2)-NORMAL DEVIATE.
IMMEDIATE ACCEPTANCE (I)
*/
t = gasdev(rng);
x = s+0.5*t;
sgamma = x*x;
if(t >= 0.0)
return sgamma;
/*
STEP 3: U= 0,1 -UNIFORM SAMPLE. SQUEEZE ACCEPTANCE (S)
*/
u = rng.better_rand();
//u=ranf();
if(d*u <= t*t*t) return sgamma;
/*
STEP 4: RECALCULATIONS OF Q0,B,SI,C IF NECESSARY
*/
if(a == aaa) goto S40;
aaa = a;
r = 1.0/ a;
q0 = ((((((q7*r+q6)*r+q5)*r+q4)*r+q3)*r+q2)*r+q1)*r;
/*
APPROXIMATION DEPENDING ON SIZE OF PARAMETER A
THE CONSTANTS IN THE EXPRESSIONS FOR B, SI AND
C WERE ESTABLISHED BY NUMERICAL EXPERIMENTS
*/
if(a <= 3.686) goto S30;
if(a <= 13.022) goto S20;
/*
CASE 3: A .GT. 13.022
*/
b = 1.77;
si = 0.75;
c = 0.1515/s;
goto S40;
S20:
/*
CASE 2: 3.686 .LT. A .LE. 13.022
*/
b = 1.654+7.6E-3*s2;
si = 1.68/s+0.275;
c = 6.2E-2/s+2.4E-2;
goto S40;
S30:
/*
CASE 1: A .LE. 3.686
*/
b = 0.463+s+0.178*s2;
si = 1.235;
c = 0.195/s-7.9E-2+1.6E-1*s;
S40:
/*
STEP 5: NO QUOTIENT TEST IF X NOT POSITIVE
*/
if(x <= 0.0) goto S70;
/*
STEP 6: CALCULATION OF V AND QUOTIENT Q
*/
v = t/(s+s);
if(fabs(v) <= 0.25) goto S50;
q = q0-s*t+0.25*t*t+(s2+s2)*log(1.0+v);
goto S60;
S50:
q = q0+0.5*t*t*((((((a7*v+a6)*v+a5)*v+a4)*v+a3)*v+a2)*v+a1)*v;
S60:
/*
STEP 7: QUOTIENT ACCEPTANCE (Q)
*/
if(log(1.0-u) <= q) return sgamma;
S70:
/*
STEP 8: E=STANDARD EXPONENTIAL DEVIATE
U= 0,1 -UNIFORM DEVIATE
T=(B,SI)-DOUBLE EXPONENTIAL (LAPLACE) SAMPLE
*/
e = expdev(rng);
u = rng.better_rand();
// u = ranf();
u += (u-1.0);
t = b+fsign(si*e,u);
/*
STEP 9: REJECTION IF T .LT. TAU(1) = -.71874483771719
*/
if(t < -0.7187449) goto S70;
/*
STEP 10: CALCULATION OF V AND QUOTIENT Q
*/
v = t/(s+s);
if(fabs(v) <= 0.25) goto S80;
q = q0-s*t+0.25*t*t+(s2+s2)*log(1.0+v);
goto S90;
S80:
q = q0+0.5*t*t*((((((a7*v+a6)*v+a5)*v+a4)*v+a3)*v+a2)*v+a1)*v;
S90:
/*
STEP 11: HAT ACCEPTANCE (H) (IF Q NOT POSITIVE GO TO STEP 8)
*/
if(q <= 0.0) goto S70;
if(q <= 0.5) goto S100;
/*
* JJV modified the code through line 115 to handle large Q case
*/
if(q < 15.0) goto S95;
/*
* JJV Here Q is large enough that Q = log(exp(Q) - 1.0) (for real Q)
* JJV so reformulate test at 110 in terms of one EXP, if not too big
* JJV 87.49823 is close to the largest real which can be
* JJV exponentiated (87.49823 = log(1.0E38))
*/
if((q+e-0.5*t*t) > 87.49823) goto S115;
if(c*fabs(u) > exp(q+e-0.5*t*t)) goto S70;
goto S115;
S95:
w = exp(q)-1.0;
goto S110;
S100:
w = ((((e5*q+e4)*q+e3)*q+e2)*q+e1)*q;
S110:
/*
IF T IS REJECTED, SAMPLE AGAIN AT STEP 8
*/
if(c*fabs(u) > w*exp(e-0.5*t*t)) goto S70;
S115:
x = s+0.5*t;
sgamma = x*x;
return sgamma;
S120:
/*
ALTERNATE METHOD FOR PARAMETERS A BELOW 1 (.3678794=EXP(-1.))
JJV changed B to B0 (which was added to declarations for this)
JJV in 120 to END to fix rare and subtle bug.
JJV Line: 'aa = 0.0' was removed (unnecessary, wasteful).
JJV Reasons: the state of AA only serves to tell the A >= 1.0
JJV case if certain A-dependent constants need to be recalculated.
JJV The A < 1.0 case (here) no longer changes any of these, and
JJV the recalculation of B (which used to change with an
JJV A < 1.0 call) is governed by the state of AAA anyway.
aa = 0.0;
*/
b0 = 1.0+0.3678794*a;
S130:
p = b0*rng.better_rand();
// p = b0*ranf();
if(p >= 1.0) goto S140;
sgamma = exp(log(p)/ a);
if(expdev(rng) < sgamma) goto S130;
return sgamma;
S140:
sgamma = -log((b0-p)/ a);
if(expdev(rng) < (1.0-a)*log(sgamma)) goto S130;
return sgamma;
}