void do_print_all (stack *stack) {
DEBUGS ('m', show_stack (stack));
int size = size_stack (stack);
for (int index = 0; index < size; ++index) {
print_bigint (peek_stack (stack, index));
}
}
void do_print_all (stack *stack) {
int size = size_stack (stack);
for (int index = 0; index < size; ++index) {
if (peek_stack(stack, index) != NULL){
print_bigint (peek_stack (stack, index), stdout);
}
}
}
void do_binop (stack *stack, bigint_binop binop) {
if (size_stack(stack) < 2){
fprintf(stderr, "mydc: stack empty\n");
return;
}
bigint *right = pop_stack (stack);
bigint *left = pop_stack (stack);
bigint *answer = binop (left, right);
push_stack (stack, answer);
free_bigint (left);
free_bigint (right);
}
void do_binop (stack *stack, bigint_binop binop) {
DEBUGS ('m', show_stack (stack));
if (size_stack(stack) >= 2) {
bigint *right = pop_stack (stack);
bigint *left = pop_stack (stack);
bigint *answer = binop (left, right);
push_stack (stack, answer);
free_bigint (left);
free_bigint (right);
}
else {
fprintf(stderr, "mydc: stack empty\n");
}
}
gsl_ran_discrete_t *
gsl_ran_discrete_preproc(size_t Kevents, const double *ProbArray)
{
size_t k,b,s;
gsl_ran_discrete_t *g;
size_t nBigs, nSmalls;
gsl_stack_t *Bigs;
gsl_stack_t *Smalls;
double *E;
double pTotal = 0.0, mean, d;
if (Kevents < 1) {
/* Could probably treat Kevents=1 as a special case */
GSL_ERROR_VAL ("number of events must be a positive integer",
GSL_EINVAL, 0);
}
/* Make sure elements of ProbArray[] are positive.
* Won't enforce that sum is unity; instead will just normalize
*/
for (k=0; k<Kevents; ++k) {
if (ProbArray[k] < 0) {
GSL_ERROR_VAL ("probabilities must be non-negative",
GSL_EINVAL, 0) ;
}
pTotal += ProbArray[k];
}
/* Begin setting up the main "object" (just a struct, no steroids) */
g = (gsl_ran_discrete_t *)malloc(sizeof(gsl_ran_discrete_t));
g->K = Kevents;
g->F = (double *)malloc(sizeof(double)*Kevents);
g->A = (size_t *)malloc(sizeof(size_t)*Kevents);
E = (double *)malloc(sizeof(double)*Kevents);
if (E==NULL) {
GSL_ERROR_VAL ("Cannot allocate memory for randevent", GSL_ENOMEM, 0);
}
for (k=0; k<Kevents; ++k) {
E[k] = ProbArray[k]/pTotal;
}
/* Now create the Bigs and the Smalls */
mean = 1.0/Kevents;
nSmalls=nBigs=0;
for (k=0; k<Kevents; ++k) {
if (E[k] < mean) ++nSmalls;
else ++nBigs;
}
Bigs = new_stack(nBigs);
Smalls = new_stack(nSmalls);
for (k=0; k<Kevents; ++k) {
if (E[k] < mean) {
push_stack(Smalls,k);
}
else {
push_stack(Bigs,k);
}
}
/* Now work through the smalls */
while (size_stack(Smalls) > 0) {
s = pop_stack(Smalls);
if (size_stack(Bigs) == 0) {
(g->A)[s]=s;
(g->F)[s]=1.0;
continue;
}
b = pop_stack(Bigs);
(g->A)[s]=b;
(g->F)[s]=Kevents*E[s];
#if DEBUG
fprintf(stderr,"s=%2d, A=%2d, F=%.4f\n",s,(g->A)[s],(g->F)[s]);
#endif
d = mean - E[s];
E[s] += d; /* now E[s] == mean */
E[b] -= d;
if (E[b] < mean) {
push_stack(Smalls,b); /* no longer big, join ranks of the small */
}
else if (E[b] > mean) {
push_stack(Bigs,b); /* still big, put it back where you found it */
}
else {
/* E[b]==mean implies it is finished too */
(g->A)[b]=b;
(g->F)[b]=1.0;
}
}
while (size_stack(Bigs) > 0) {
b = pop_stack(Bigs);
(g->A)[b]=b;
(g->F)[b]=1.0;
}
/* Stacks have been emptied, and A and F have been filled */
if ( size_stack(Smalls) != 0) {
GSL_ERROR_VAL ("Smalls stack has not been emptied",
GSL_ESANITY, 0 );
}
#if 0
/* if 1, then artificially set all F[k]'s to unity. This will
* give wrong answers, but you'll get them faster. But, not
* that much faster (I get maybe 20%); that's an upper bound
* on what the optimal preprocessing would give.
*/
for (k=0; k<Kevents; ++k) {
(g->F)[k] = 1.0;
}
#endif
#if KNUTH_CONVENTION
/* For convenience, set F'[k]=(k+F[k])/K */
/* This saves some arithmetic in gsl_ran_discrete(); I find that
* it doesn't actually make much difference.
*/
for (k=0; k<Kevents; ++k) {
(g->F)[k] += k;
(g->F)[k] /= Kevents;
}
#endif
free_stack(Bigs);
free_stack(Smalls);
free((char *)E);
return g;
}
