void sknuth_CouponCollector (unif01_Gen * gen, sres_Chi2 * res,
long N, long n, int r, int d)
{
long Seq; /* Replication number */
long Segm;
const int t = MAXT;
long tt = t;
int dInt = d;
long dd = d;
int s, k;
long NbGroups;
double Moydes;
double Mult;
double dReal = d;
double **M;
double *NbExp;
long *Loca;
long *Nb;
lebool Occurs[1 + MAXT];
double X2;
double V[1]; /* Number degrees of freedom for Chi2 */
char str[LENGTH + 1];
lebool localRes = FALSE;
chrono_Chrono *Timer;
char *TestName = "sknuth_CouponCollector test";
Timer = chrono_Create ();
if (swrite_Basic)
WriteDataCoupCol (gen, TestName, N, n, r, d);
util_Assert (d < MAXT, "sknuth_CouponCollector: d >= 62");
util_Assert (d > 1, "sknuth_CouponCollector: d < 2");
if (res == NULL) {
localRes = TRUE;
res = sres_CreateChi2 ();
}
sres_InitChi2 (res, N, MAXT, "sknuth_CouponCollector");
NbExp = res->NbExp;
Nb = res->Count;
Loca = res->Loc;
/* Compute the expected number of segments of each length */
/* NbExp [s] = n * d! * Stirling (d-1, s-1) / d^s for d <= s <= t - 1 */
/* NbExp [t] = n * (1 - d! * Stirling (d, t-1) / d^{t-1}) */
dInt = d;
num2_CalcMatStirling (&M, d, t - 1);
Mult = n;
for (s = 1; s <= d; s++) {
Mult *= s / dReal;
}
NbExp[d] = Mult;
Moydes = d * Mult;
for (s = d + 1; s < t; s++) {
Mult /= dReal;
NbExp[s] = Mult * M[d - 1][s - 1];
Moydes += s * NbExp[s];
}
NbExp[t] = n - Mult * M[d][t - 1];
Moydes += t * NbExp[t];
Moydes /= n;
/*
if (swrite_Basic) {
printf (" Expected value of s = ");
num_WriteD (Moydes, 10, 2, 2);
printf ("\n\n");
}
*/
if (swrite_Classes)
gofs_WriteClasses (NbExp, Loca, d, t, 0);
gofs_MergeClasses (NbExp, Loca, &dd, &tt, &NbGroups);
if (swrite_Classes)
gofs_WriteClasses (NbExp, Loca, dd, tt, NbGroups);
res->jmin = dd;
res->jmax = tt;
res->degFree = NbGroups - 1;
if (res->degFree < 1) {
if (localRes)
sres_DeleteChi2 (res);
return;
}
sprintf (str, "The N statistic values (a ChiSquare with %1ld degrees"
" of freedom):", NbGroups - 1);
statcoll_SetDesc (res->sVal1, str);
/* Beginning of test */
for (Seq = 1; Seq <= N; Seq++) {
for (s = dInt; s <= MAXT; s++)
Nb[s] = 0;
for (Segm = 1; Segm <= n; Segm++) {
/* One collection of values. */
for (k = 0; k < dInt; k++)
Occurs[k] = FALSE;
++Nb[Loca[NRepet (gen, dInt, r, Occurs)]];
}
if (swrite_Counters)
tables_WriteTabL (Nb, dd, tt, 5, 10, "Observed numbers:");
X2 = gofs_Chi2 (NbExp, Nb, dd, tt);
statcoll_AddObs (res->sVal1, X2);
}
V[0] = NbGroups - 1;
gofw_ActiveTests2 (res->sVal1->V, res->pVal1->V, N, wdist_ChiSquare, V,
res->sVal2, res->pVal2);
res->pVal1->NObs = N;
sres_GetChi2SumStat (res);
if (swrite_Collectors) {
statcoll_Write (res->sVal1, 5, 14, 4, 3);
}
if (swrite_Basic) {
swrite_AddStrChi (str, LENGTH, res->degFree);
gofw_WriteActiveTests2 (N, res->sVal2, res->pVal2, str);
swrite_Chi2SumTest (N, res);
swrite_Final (gen, Timer);
}
num2_FreeMatStirling (&M, d);
if (localRes)
sres_DeleteChi2 (res);
chrono_Delete (Timer);
}
void sknuth_SimpPoker (unif01_Gen *gen, sres_Chi2 *res,
long N, long n, int r, int d, int k)
{
long Seq; /* Replication number */
long NbGroups; /* Number of classes */
long jhigh;
long jlow;
long Groupe;
long L;
int Minkd;
int s, j;
double X2;
double Mult;
double *NbExp;
long *Loca;
long *Nb;
lebool Occurs[1 + Maxkd];
double **M;
double V[1]; /* Number degrees of freedom for Chi2 */
char str[LENGTH + 1];
lebool localRes = FALSE;
chrono_Chrono *Timer;
char *TestName = "sknuth_SimpPoker test";
Timer = chrono_Create ();
if (swrite_Basic)
WriteDataPoker (gen, TestName, N, n, r, d, k);
util_Assert (d <= Maxkd, "sknuth_SimpPoker: d > 127");
util_Assert (k <= Maxkd, "sknuth_SimpPoker: k > 127");
util_Assert (d > 1, "sknuth_SimpPoker: d < 2");
util_Assert (k > 1, "sknuth_SimpPoker: k < 2");
if (k < d)
Minkd = k;
else
Minkd = d;
num2_CalcMatStirling (&M, Minkd, k);
if (res == NULL) {
localRes = TRUE;
res = sres_CreateChi2 ();
}
sres_InitChi2 (res, N, Minkd, "sknuth_SimpPoker");
NbExp = res->NbExp;
Nb = res->Count;
Loca = res->Loc;
/* NbExp[s] = n * d * (d-1) * ... * (d-s+1) * M [s,k] / d^k. */
Mult = n * pow ((double) d, -(double) k);
for (s = 1; s <= Minkd; s++) {
Mult *= d - s + 1;
NbExp[s] = Mult * M[s][k];
}
jlow = 1;
jhigh = Minkd;
if (swrite_Classes)
gofs_WriteClasses (NbExp, Loca, jlow, jhigh, 0);
gofs_MergeClasses (NbExp, Loca, &jlow, &jhigh, &NbGroups);
if (swrite_Classes)
gofs_WriteClasses (NbExp, Loca, jlow, jhigh, NbGroups);
res->jmin = jlow;
res->jmax = jhigh;
res->degFree = NbGroups - 1;
if (res->degFree < 1) {
if (localRes)
sres_DeleteChi2 (res);
return;
}
sprintf (str, "The N statistic values (a ChiSquare with %1ld degrees"
" of freedom):", NbGroups - 1);
statcoll_SetDesc (res->sVal1, str);
for (Seq = 1; Seq <= N; Seq++) {
for (s = 1; s <= Minkd; s++)
Nb[s] = 0;
for (Groupe = 1; Groupe <= n; Groupe++) {
/* Draw one poker hand */
for (j = 0; j < d; j++)
Occurs[j] = FALSE;
s = 0; /* s = number of different values */
for (j = 1; j <= k; j++) {
L = unif01_StripL (gen, r, d);
if (!Occurs[L]) {
Occurs[L] = TRUE;
++s;
}
}
++Nb[Loca[s]];
}
if (swrite_Counters)
tables_WriteTabL (Nb, jlow, jhigh, 5, 10, "Observed numbers:");
X2 = gofs_Chi2 (NbExp, Nb, jlow, jhigh);
statcoll_AddObs (res->sVal1, X2);
}
V[0] = NbGroups - 1;
gofw_ActiveTests2 (res->sVal1->V, res->pVal1->V, N, wdist_ChiSquare, V,
res->sVal2, res->pVal2);
res->pVal1->NObs = N;
sres_GetChi2SumStat (res);
if (swrite_Collectors) {
statcoll_Write (res->sVal1, 5, 14, 4, 3);
}
if (swrite_Basic) {
swrite_AddStrChi (str, LENGTH, res->degFree);
gofw_WriteActiveTests2 (N, res->sVal2, res->pVal2, str);
swrite_Chi2SumTest (N, res);
swrite_Final (gen, Timer);
}
num2_FreeMatStirling (&M, Minkd);
if (localRes)
sres_DeleteChi2 (res);
chrono_Delete (Timer);
}
static int svaria_CollisionArgMax_00 (unif01_Gen *gen, sres_Chi2 *res,
long N, long n, int r, long k, long m)
/*
* Return 0 if no error, otherwise return != 0.
*/
{
double X;
double U;
double Max;
long NbColl;
long Indice = -1;
long j;
long i;
long Rep;
long Seq;
long NbClasses;
long *Loc;
int *Urne;
double V[1];
fmass_INFO Q;
lebool localRes = FALSE;
chrono_Chrono *chro, *Timer;
char *TestName = "svaria_CollisionArgMax test";
char chaine[LEN1 + 1] = "";
char str[LEN2 + 1];
Timer = chrono_Create ();
if (swrite_Basic)
WriteDataArgMax (gen, TestName, N, n, r, k, m);
util_Assert (n <= 4 * k, "svaria_CollisionArgMax: n > 4k");
/* util_Assert (m > 2.0 * gofs_MinExpected,
"svaria_CollisionArgMax: m <= 2*gofs_MinExpected"); */
if (res == NULL) {
localRes = TRUE;
res = sres_CreateChi2 ();
}
sres_InitChi2 (res, N, n, "svaria_CollisionArgMax");
Loc = res->Loc;
Urne = util_Calloc ((size_t) k + 1, sizeof (int));
if (svaria_Timer) {
printf ("-----------------------------------------------");
printf ("\nCPU time to initialize the collision distribution: ");
chro = chrono_Create ();
}
Q = smultin_CreateCollisions (n, (smultin_CellType) k);
if (svaria_Timer) {
chrono_Write (chro, chrono_hms);
printf ("\n\n");
}
/* Compute the expected numbers of collisions: m*P(j) */
for (j = 0; j <= n; j++)
res->NbExp[j] = m * smultin_CollisionsTerm (Q, j);
smultin_DeleteCollisions (Q);
res->jmin = 0;
res->jmax = n;
if (swrite_Classes)
gofs_WriteClasses (res->NbExp, Loc, res->jmin, res->jmax, 0);
gofs_MergeClasses (res->NbExp, Loc, &res->jmin, &res->jmax, &NbClasses);
if (swrite_Classes)
gofs_WriteClasses (res->NbExp, Loc, res->jmin, res->jmax, NbClasses);
strncpy (chaine, "CollisionArgMax sVal1: chi2 with ", (size_t) LEN1);
sprintf (str, "%ld", NbClasses - 1);
strncat (chaine, str, (size_t) LEN2);
strncat (chaine, " degrees of freedom", (size_t) LEN1);
statcoll_SetDesc (res->sVal1, chaine);
res->degFree = NbClasses - 1;
if (res->degFree < 1) {
if (localRes)
sres_DeleteChi2 (res);
return 1;
}
if (svaria_Timer)
chrono_Init (chro);
for (Seq = 1; Seq <= N; Seq++) {
for (j = 0; j <= n; j++)
res->Count[j] = 0;
for (Rep = 1; Rep <= m; Rep++) {
for (j = 0; j <= k; j++)
Urne[j] = -1;
NbColl = 0;
for (j = 1; j <= n; j++) {
Max = -1.0;
for (i = 1; i <= k; i++) {
U = unif01_StripD (gen, r);
if (U > Max) {
Max = U;
Indice = i;
}
}
if (Urne[Indice] < 0)
Urne[Indice] = 1;
else
++NbColl;
}
if (NbColl > res->jmax)
++res->Count[res->jmax];
else
++res->Count[Loc[NbColl]];
}
if (swrite_Counters)
tables_WriteTabL (res->Count, res->jmin, res->jmax, 5, 10,
"Observed numbers:");
X = gofs_Chi2 (res->NbExp, res->Count, res->jmin, res->jmax);
statcoll_AddObs (res->sVal1, X);
}
if (svaria_Timer) {
printf ("\n----------------------------------------------\n"
"CPU time for the test : ");
chrono_Write (chro, chrono_hms);
printf ("\n\n");
chrono_Delete (chro);
}
V[0] = NbClasses - 1;
gofw_ActiveTests2 (res->sVal1->V, res->pVal1->V, N, wdist_ChiSquare, V,
res->sVal2, res->pVal2);
res->pVal1->NObs = N;
sres_GetChi2SumStat (res);
if (swrite_Collectors)
statcoll_Write (res->sVal1, 5, 14, 4, 3);
if (swrite_Basic) {
swrite_AddStrChi (str, LEN2, res->degFree);
gofw_WriteActiveTests2 (N, res->sVal2, res->pVal2, str);
swrite_Chi2SumTest (N, res);
swrite_Final (gen, Timer);
}
util_Free (Urne);
if (localRes)
sres_DeleteChi2 (res);
chrono_Delete (Timer);
return 0;
}
void svaria_SumCollector (unif01_Gen * gen, sres_Chi2 * res,
long N, long n, int r, double g)
{
const double gmax = 10.0; /* Maximal value of g */
const int jmax = 50; /* Maximal number of classes */
int j; /* Class index */
long Seq;
long i;
double X;
double Y;
double Sum;
long NbClasses;
long *Loc;
double V[1];
lebool localRes = FALSE;
chrono_Chrono *Timer;
char *TestName = "svaria_SumCollector test";
char chaine[LEN1 + 1] = "";
char str[LEN2 + 1];
Timer = chrono_Create ();
if (swrite_Basic)
WriteDataSumColl (gen, TestName, N, n, r, g);
if (g < 1.0 || g > gmax) {
util_Error ("svaria_SumCollector: g < 1.0 or g > 10.0");
}
if (res == NULL) {
localRes = TRUE;
res = sres_CreateChi2 ();
}
sres_InitChi2 (res, N, jmax, "svaria_SumCollector");
Loc = res->Loc;
res->jmin = g;
res->jmax = jmax;
Sum = 0.0;
for (j = res->jmin; j < jmax; j++) {
res->NbExp[j] = n * ProbabiliteG (res->jmin, j, g);
Sum += res->NbExp[j];
}
res->NbExp[jmax] = util_Max (0.0, n - Sum);
if (swrite_Classes)
gofs_WriteClasses (res->NbExp, Loc, res->jmin, res->jmax, 0);
gofs_MergeClasses (res->NbExp, Loc, &res->jmin, &res->jmax, &NbClasses);
if (swrite_Classes)
gofs_WriteClasses (res->NbExp, Loc, res->jmin, res->jmax, NbClasses);
strncpy (chaine, "SumCollector sVal1: chi2 with ", (size_t) LEN1);
sprintf (str, "%ld", NbClasses - 1);
strncat (chaine, str, (size_t) LEN2);
strncat (chaine, " degrees of freedom", (size_t) LEN1);
statcoll_SetDesc (res->sVal1, chaine);
res->degFree = NbClasses - 1;
if (res->degFree < 1) {
if (localRes)
sres_DeleteChi2 (res);
return;
}
for (Seq = 1; Seq <= N; Seq++) {
for (j = 1; j <= jmax; j++)
res->Count[j] = 0;
for (i = 1; i <= n; i++) {
X = 0.0;
j = 0;
do {
X += unif01_StripD (gen, r);
++j;
}
while (X <= g);
if (j > res->jmax)
++res->Count[res->jmax];
else
++res->Count[Loc[j - 1]];
}
if (swrite_Counters)
tables_WriteTabL (res->Count, res->jmin, res->jmax, 5, 10,
"Observed numbers:");
Y = gofs_Chi2 (res->NbExp, res->Count, res->jmin, res->jmax);
statcoll_AddObs (res->sVal1, Y);
}
V[0] = NbClasses - 1;
gofw_ActiveTests2 (res->sVal1->V, res->pVal1->V, N, wdist_ChiSquare, V,
res->sVal2, res->pVal2);
res->pVal1->NObs = N;
sres_GetChi2SumStat (res);
if (swrite_Collectors)
statcoll_Write (res->sVal1, 5, 14, 4, 3);
if (swrite_Basic) {
swrite_AddStrChi (str, LEN2, res->degFree);
gofw_WriteActiveTests2 (N, res->sVal2, res->pVal2, str);
swrite_Chi2SumTest (N, res);
swrite_Final (gen, Timer);
}
if (localRes)
sres_DeleteChi2 (res);
chrono_Delete (Timer);
}
void svaria_WeightDistrib (unif01_Gen * gen, sres_Chi2 * res,
long N, long n, int r, long k, double Alpha, double Beta)
{
long W;
long j;
long i;
long Seq;
double X;
double U;
double p;
double nLR = n;
double V[1];
long NbClasses;
long *Loc;
fmass_INFO Q;
lebool localRes = FALSE;
chrono_Chrono *Timer;
char *TestName = "svaria_WeightDistrib test";
char chaine[LEN1 + 1] = "";
char str[LEN2 + 1];
Timer = chrono_Create ();
if (swrite_Basic)
WriteDataWeight (gen, TestName, N, n, r, k, Alpha, Beta);
/* util_Assert (n >= 3.0 * gofs_MinExpected,
"svaria_WeightDistrib: n is too small"); */
util_Assert (Alpha <= 1.0 && Alpha >= 0.0,
"svaria_WeightDistrib: Alpha must be in [0, 1]");
util_Assert (Beta <= 1.0 && Beta >= 0.0,
"svaria_WeightDistrib: Beta must be in [0, 1]");
p = Beta - Alpha;
if (res == NULL) {
localRes = TRUE;
res = sres_CreateChi2 ();
}
sres_InitChi2 (res, N, k, "svaria_WeightDistrib");
Loc = res->Loc;
/* Compute binomial probabilities and multiply by n */
Q = fmass_CreateBinomial (k, p, 1.0 - p);
for (i = 0; i <= k; i++)
res->NbExp[i] = nLR * fmass_BinomialTerm2 (Q, i);
fmass_DeleteBinomial (Q);
res->jmin = 0;
res->jmax = k;
if (swrite_Classes)
gofs_WriteClasses (res->NbExp, Loc, res->jmin, res->jmax, 0);
/* Merge classes for the chi-square */
gofs_MergeClasses (res->NbExp, Loc, &res->jmin, &res->jmax, &NbClasses);
if (swrite_Classes)
gofs_WriteClasses (res->NbExp, Loc, res->jmin, res->jmax, NbClasses);
strncpy (chaine, "WeightDistrib sVal1: chi2 with ", (size_t) LEN1);
sprintf (str, "%ld", NbClasses - 1);
strncat (chaine, str, (size_t) LEN2);
strncat (chaine, " degrees of freedom", (size_t) LEN1);
statcoll_SetDesc (res->sVal1, chaine);
res->degFree = NbClasses - 1;
if (res->degFree < 1) {
if (localRes)
sres_DeleteChi2 (res);
return;
}
for (Seq = 1; Seq <= N; Seq++) {
for (i = 0; i <= k; i++)
res->Count[i] = 0;
for (i = 1; i <= n; i++) {
W = 0;
for (j = 1; j <= k; j++) {
U = unif01_StripD (gen, r);
if (U >= Alpha && U < Beta)
++W;
}
if (W > res->jmax)
++res->Count[res->jmax];
else
++res->Count[Loc[W]];
}
if (swrite_Counters)
tables_WriteTabL (res->Count, res->jmin, res->jmax, 5, 10,
"Observed numbers:");
X = gofs_Chi2 (res->NbExp, res->Count, res->jmin, res->jmax);
statcoll_AddObs (res->sVal1, X);
}
V[0] = NbClasses - 1;
gofw_ActiveTests2 (res->sVal1->V, res->pVal1->V, N, wdist_ChiSquare, V,
res->sVal2, res->pVal2);
res->pVal1->NObs = N;
sres_GetChi2SumStat (res);
if (swrite_Collectors)
statcoll_Write (res->sVal1, 5, 14, 4, 3);
if (swrite_Basic) {
swrite_AddStrChi (str, LEN2, res->degFree);
gofw_WriteActiveTests2 (N, res->sVal2, res->pVal2, str);
swrite_Chi2SumTest (N, res);
swrite_Final (gen, Timer);
}
if (localRes)
sres_DeleteChi2 (res);
chrono_Delete (Timer);
}
