void addstr_ArrayUint (char *to, const char *add, int high,
unsigned int val[])
{
int j;
strcat (to, add);
addstr_Uint (to, "(", val[0]);
for (j = 1; (j < high) && (j < 5); j++)
addstr_Uint (to, ", ", val[j]);
if (high > 5)
strcat (to, ", ... )");
else
strcat (to, ")");
}
unif01_Gen * utaus_CreateLongTaus (unsigned int k, unsigned int q,
unsigned int s, ulonglong Y)
{
unif01_Gen *gen;
LongTaus_param *param;
LongTaus_state *state;
size_t len;
char name[LEN0 + 1];
ulonglong B;
util_Assert ((k <= 64) && (k > 2 * q) && (s <= k - q) && (s >= 1) &&
(q >= 1), "utaus_CreateLongTaus: Invalid Parameter");
gen = util_Malloc (sizeof (unif01_Gen));
param = util_Malloc (sizeof (LongTaus_param));
state = util_Malloc (sizeof (LongTaus_state));
strncpy (name, "utaus_CreateLongTaus", (size_t) LEN0);
addstr_Uint (name, ": k = ", k);
addstr_Uint (name, ", q = ", q);
addstr_Uint (name, ", s = ", s);
addstr_ULONG (name, ", Y = ", Y);
len = strlen (name);
gen->name = util_Calloc (len + 1, sizeof (char));
strncpy (gen->name, name, len);
param->Q1 = q;
param->K1mS1 = k - s;
param->S1 = s;
B = num_TwoExp[64 - k] - 1.0; /* k most signif. bits at 1 */
param->M1 = ~B;
util_Assert (Y > 0, "utaus_CreateLongTaus: Y = 0");
state->ST1 = Y & param->M1;
/* make sure that the initial state is not 0 */
while (state->ST1 == 0) {
Y *= 2;
state->ST1 = Y & param->M1;
}
B = ((state->ST1 << param->Q1) ^ state->ST1) >> k;
state->ST1 ^= B;
gen->GetBits = &LongTaus_Bits;
gen->GetU01 = &LongTaus_U01;
gen->Write = &WrLongTaus;
gen->param = param;
gen->state = state;
return gen;
}
static unif01_Gen *CreateDenga (unsigned long m, unsigned long b, int k,
unsigned long S[], int id)
{
unif01_Gen *gen;
DX02_state *state;
DX02_param *param;
size_t leng;
char name[LEN + 1];
int j;
gen = util_Malloc (sizeof (unif01_Gen));
state = util_Malloc (sizeof (DX02_state));
param = util_Malloc (sizeof (DX02_param));
if (0 == id) {
util_Assert (k < 129, "udeng_CreateDL00a: k > 128");
} else {
util_Assert (k < 129, "udeng_CreateDX02a: k > 128");
}
state->X = util_Calloc (MASK1 + 1, sizeof (double));
for (j = 0; j < k; j++)
state->X[k - j - 1] = S[j] % m;
state->s = k - 1;
state->K = k;
param->b = b;
param->m = m;
if (0 == id)
strcpy (name, "udeng_CreateDL00a:");
else
#ifdef LAC
strcpy (name, "udeng_CreateDX02a, Lac = {0, 101, 102}:");
#else
strcpy (name, "udeng_CreateDX02a:");
#endif
addstr_Ulong (name, " m = ", m);
addstr_Ulong (name, ", b = ", b);
addstr_Uint (name, ", k = ", (unsigned) k);
addstr_ArrayUlong (name, ", S = ", k, S);
leng = strlen (name);
gen->name = util_Calloc (leng + 1, sizeof (char));
strncpy (gen->name, name, leng);
gen->param = param;
gen->state = state;
if (0 == id) {
gen->GetBits = &DL00a_Bits;
gen->GetU01 = &DL00a_U01;
} else {
gen->GetBits = &DX02a_Bits;
gen->GetU01 = &DX02a_U01;
}
gen->Write = &WrDX02a;
return gen;
}
unif01_Gen *utaus_CreateTausJ (unsigned int k, unsigned int q,
unsigned int s, unsigned int j, unsigned int Y)
{
unif01_Gen *gen;
Taus_param *param;
unsigned int pos;
int found;
size_t len;
char str[LEN1 + 1] = "";
gen = CreateTaus_0 ("utaus_CreateTausJ", k, q, s, Y);
param = gen->param;
param->J = j;
gen->GetBits = &TausJ_Bits;
gen->GetU01 = &TausJ_U01;
addstr_Uint (str, ", j = ", j);
len = strlen (gen->name) + strlen (str);
gen->name = util_Realloc (gen->name, (len + 1) * sizeof (char));
mystr_Position (", Y =", gen->name, 0, &pos, &found);
mystr_Insert (gen->name, str, pos);
return gen;
}
unif01_Gen * utaus_CreateCombTaus3 (unsigned int k1, unsigned int k2,
unsigned int k3, unsigned int q1, unsigned int q2, unsigned int q3,
unsigned int s1, unsigned int s2, unsigned int s3, unsigned int Y1,
unsigned int Y2, unsigned int Y3)
{
unif01_Gen *gen;
CombTaus3_param *param;
CombTaus3_state *state;
size_t len;
char name[LEN0 + 1];
unsigned int B;
util_Assert (
(k1 <= 32) && (k1 > 2 * q1) && (s1 <= k1 - q1) && (s1 > 0) &&
(k2 <= 32) && (k2 > 2 * q2) && (s2 <= k2 - q2) && (s2 > 0) &&
(k3 <= 32) && (k3 > 2 * q3) && (s3 <= k3 - q3) && (s3 > 0) &&
(q1 > 0) && (q2 > 0) && (q3 > 0) && (k1 >= k2) && (k2 >= k3),
"utaus_CreateCombTaus3: Invalid Parameter");
strncpy (name, "utaus_CreateCombTaus3:", (size_t) LEN0);
addstr_Uint (name, " (k1, k2, k3) = ", k1);
addstr_Uint (name, ", ", k2);
addstr_Uint (name, ", ", k3);
addstr_Uint (name, ", (q1, q2, q3) = ", q1);
addstr_Uint (name, ", ", q2);
addstr_Uint (name, ", ", q3);
addstr_Uint (name, ", (s1, s2, s3) = ", s1);
addstr_Uint (name, ", ", s2);
addstr_Uint (name, ", ", s3);
addstr_Uint (name, ", (Y1, Y2, Y3) = ", Y1);
addstr_Uint (name, ", ", Y2);
addstr_Uint (name, ", ", Y3);
gen = util_Malloc (sizeof (unif01_Gen));
param = gen->param = util_Malloc (sizeof (CombTaus3_param));
state = gen->state = util_Malloc (sizeof (CombTaus3_state));
gen->GetU01 = &CombTaus3_U01;
gen->GetBits = &CombTaus3_Bits;
gen->Write = &WrCombTaus3;
len = strlen (name);
gen->name = util_Calloc (len + 1, sizeof (char));
strncpy (gen->name, name, len);
param->Q1 = q1;
param->S1 = s1;
param->K1mS1 = k1 - s1;
param->M1 = num_TwoExp[32 - k1] - 1; /* k1 most sig. bits at 1 */
param->M1 = ~param->M1;
param->Q2 = q2;
param->S2 = s2;
param->K2mS2 = k2 - s2;
param->M2 = num_TwoExp[32 - k2] - 1; /* k2 most sig. bits at 1 */
param->M2 = ~param->M2;
param->Q3 = q3;
param->S3 = s3;
param->K3mS3 = k3 - s3;
param->M3 = num_TwoExp[32 - k3] - 1; /* k3 most sig. bits at 1 */
param->M3 = ~param->M3;
/* Initialisation as in L'Ecuyer 1996. */
util_Assert (Y1 > 0, "utaus_CreateCombTaus3: seed1 = 0");
state->ST1 = Y1 & param->M1;
while (state->ST1 == 0) { /* Make sure the initial state is not 0 */
Y1 = Y1 * 2;
state->ST1 = Y1 & param->M1;
}
B = ((state->ST1 << param->Q1) ^ state->ST1) >> k1;
if (k1 >= 8 * sizeof (int))
B = 0; /* B = B >> 32 does not work */
state->ST1 = state->ST1 ^ B;
util_Assert (Y2 > 0, "utaus_CreateCombTaus3: seed2 = 0");
state->ST2 = Y2 & param->M2;
while (state->ST2 == 0) { /* Make sure the initial state is not 0 */
Y2 = Y2 * 2;
state->ST2 = Y2 & param->M2;
}
B = ((state->ST2 << param->Q2) ^ state->ST2) >> k2;
if (k2 >= 8 * sizeof (int))
B = 0; /* B = B >> 32 does not work */
state->ST2 = state->ST2 ^ B;
util_Assert (Y3 > 0, "utaus_CreateCombTaus3: seed3 = 0");
state->ST3 = Y3 & param->M3;
while (state->ST3 == 0) { /* Make sure the initial state is not 0 */
Y3 = Y3 * 2;
state->ST3 = Y3 & param->M3;
}
B = ((state->ST3 << param->Q3) ^ state->ST3) >> k3;
if (k3 >= 8 * sizeof (int))
B = 0; /* B = B >> 32 does not work */
state->ST3 = state->ST3 ^ B;
return gen;
}
static unif01_Gen * CreateTaus_0 (char *na, unsigned int k, unsigned int q,
unsigned int s, unsigned int Y)
{
unif01_Gen *gen;
Taus_param *param;
Taus_state *state;
size_t len;
char name[LEN0 + 1];
char str[LEN1 + 1];
unsigned int B;
strncpy (str, na, (size_t) LEN1);
strncat (str, ": Invalid Parameter", (size_t) LEN1 - 30);
util_Assert ((k <= 32) && (k > 2 * q) && (s <= k - q) &&
(s >= 1) && (q >= 1), str);
/* These restrictions implies, for 32 bits int, */
/* 0 < k <= 32 ; 0 < q < 16 ; 0 < s < 32 ; 0 < k - s < 32 */
gen = util_Malloc (sizeof (unif01_Gen));
param = util_Malloc (sizeof (Taus_param));
state = util_Malloc (sizeof (Taus_state));
strncpy (name, na, (size_t) LEN0);
addstr_Uint (name, ": k = ", k);
addstr_Uint (name, ", q = ", q);
addstr_Uint (name, ", s = ", s);
addstr_Uint (name, ", Y = ", Y);
len = strlen (name);
gen->name = util_Calloc (len + 1, sizeof (char));
strncpy (gen->name, name, len);
param->Q1 = q;
param->K1mS1 = k - s;
param->S1 = s;
/* k most signif. bits at 1 */
B = num_TwoExp[32 - k] - 1.0;
param->M1 = ~B;
util_Assert (param->M1 > 0, "CreateTaus_0: M1 = 0");
strncpy (str, na, (size_t) LEN1);
strncat (str, ": Y = 0", (size_t) LEN1 - 30);
util_Assert (Y > 0, str);
state->ST1 = Y & param->M1;
/* make sure that the initial state is not 0 */
while (state->ST1 == 0) {
Y *= 2;
state->ST1 = Y & param->M1;
}
B = ((state->ST1 << param->Q1) ^ state->ST1) >> k;
if (k >= 8 * sizeof (int))
B = 0; /* B = B >> 32 does not work */
state->ST1 ^= B;
gen->GetBits = &Taus_Bits;
gen->GetU01 = &Taus_U01;
gen->Write = &WrTaus;
gen->param = param;
gen->state = state;
return gen;
}
