/* not canonicalized */
void _lsrt_mpq_set_decimal(mpq_t q, const char *ptr, int radix)
{
mpz_t num, dec, exp;
mpq_t addend;
int ex, expdigits;
int s, e;
char ch = '+';
if (radix != 10)
lsrt_error("unsupported radix for exact decimal number: %d", radix);
mpz_init_set_ui(num, 0);
mpz_init_set_ui(dec, 0);
mpz_init(exp);
mpq_init(addend);
e = 0;
sscanf(ptr, "%[+-]%n", &ch, &e);
ptr += e;
e = 0;
gmp_sscanf(ptr, "%Zd%n", num, &e);
ptr += e;
s = 0;
e = 0;
expdigits = 0;
gmp_sscanf(ptr, ".%n%Zd%n", &s, dec, &e);
ptr += e;
if (e >= s)
expdigits = e - s;
s = 0;
e = 0;
ex = 0;
sscanf(ptr, "@%n%d%n", &s, &ex, &e);
if (e - s >= 5 || ex >= 256)
lsrt_error("decimal number out of range");
mpz_set(mpq_numref(q), dec);
mpz_ui_pow_ui(mpq_denref(q), radix, expdigits);
mpq_set_z(addend, num);
mpq_add(q, q, addend);
if (ex > 0) {
mpz_ui_pow_ui(exp, 10, ex); /* exponent is always in radix 10 */
mpz_mul(mpq_numref(q), mpq_numref(q), exp);
} else if (ex < 0) {
mpz_ui_pow_ui(exp, 10, -ex);
mpz_mul(mpq_denref(q), mpq_denref(q), exp);
}
if (ch == '-')
mpz_neg(mpq_numref(q), mpq_numref(q));
mpq_clear(addend);
mpz_clear(exp);
mpz_clear(num);
mpz_clear(dec);
}
int
fun_gmp_sscanf (const char *input, const char *fmt, void *a1, void *a2)
{
if (a2 == NULL)
return gmp_sscanf (input, fmt, a1);
else
return gmp_sscanf (input, fmt, a1, a2);
}
/*------------------------------------------------------------------*/
uint32 read_last_line(msieve_obj *obj, mpz_t n) {
uint32 last_line = 0;
char buf[LINE_BUF_SIZE];
FILE *linefile;
mpz_t read_n;
sprintf(buf, "%s.line", obj->savefile.name);
linefile = fopen(buf, "r");
if (linefile == NULL)
return last_line;
fgets(buf, (int)sizeof(buf), linefile);
mpz_init_set_ui(read_n, 0);
if (buf[0] == 'N')
gmp_sscanf(buf + 2, "%Zd", read_n);
if (mpz_cmp(n, read_n) == 0) {
fgets(buf, (int)sizeof(buf), linefile);
last_line = atoi(buf);
}
fclose(linefile);
mpz_clear(read_n);
return last_line;
}
int main(int argc, char **argv)
{
int width, height;
mpz_t index;
if (argc < 3 || argc > 4)
{
fprintf(stderr, "Usage: %s width height [index]\n", argv[0]);
return EX_USAGE;
}
width = atoi(argv[1]);
height = atoi(argv[2]);
if (width <= 0 || height <= 0)
{
fprintf(stderr, "Usage: %s width height [index]\n", argv[0]);
fprintf(stderr, "width and height must be positive\n");
return EX_USAGE;
}
if (argc == 3)
{
print_count(width, height);
return 0;
}
/* Construct a maze by index */
mpz_init(index);
gmp_sscanf(argv[3], "%Zd", &index);
print_maze(width, height, index);
mpz_clear(index);
return 0;
}
void special_tests(void)
{
mpz_t n, d, q, q2, r;
mpz_init(n); mpz_init(d);
mpz_init(q); mpz_init(q2); mpz_init(r);
gmp_sscanf("7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "%Zx", n);
gmp_sscanf("20000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", "%Zx", d);
mpz_tdiv_q(q, n, d);
mpz_tdiv_qr(q2, r, n, d);
if (mpz_cmp(q, q2) != 0)
{
fprintf (stderr, "ERROR\n");
fprintf (stderr, "dividend = "); debug_mp (n, -16);
fprintf (stderr, "divisor = "); debug_mp (d, -16);
fprintf (stderr, "q1 = "); debug_mp (q, -16);
fprintf (stderr, "q2 = "); debug_mp (q2, -16);
abort();
}
gmp_sscanf("3FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", "%Zx", n);
gmp_sscanf("400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFC00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", "%Zx", d);
mpz_tdiv_q(q, n, d);
mpz_tdiv_qr(q2, r, n, d);
if (mpz_cmp(q, q2) != 0)
{
fprintf (stderr, "ERROR\n");
fprintf (stderr, "dividend = "); debug_mp (n, -16);
fprintf (stderr, "divisor = "); debug_mp (d, -16);
fprintf (stderr, "q1 = "); debug_mp (q, -16);
fprintf (stderr, "q2 = "); debug_mp (q2, -16);
abort();
}
mpz_clear(n); mpz_clear(d);
mpz_clear(q); mpz_clear(q2); mpz_clear(r);
}
void hash_payload(mpz_t hashed, mpz_t payload) {
int i;
char payload_str[strlen(DHE_PRIME)]; //not going to be hashing anything larger
char hex_hash[HEX_HASH_STR_LEN];
gmp_sprintf(payload_str, "%Zx", payload);
memcpy(hex_hash, SHA256_hash(payload_str), HEX_HASH_STR_LEN);
gmp_sscanf(hex_hash, "%Zx", hashed);
}
void getnum(mpz_t rop)
{
size_t ila=0, s, i;
char *il = 0;
mpz_init(rop);
if (getline(&il,&ila,stdin)<=0) {
fprintf(stderr,"reading number failed\n");
exit(-1);
}
if (gmp_sscanf(il,"%Zd",rop)!=1) {
fprintf(stderr,"number corrupt\n");
exit(-1);
}
}
Zr PairingGroup::IntegerToZr(const Integer &in) const
{
mpz_t z;
mpz_init(z);
QByteArray b = in.GetByteArray().toHex();
const char *bytes = b.constData();
int ret;
if((ret = gmp_sscanf(bytes, "%Zx", z)) != 1) {
//qDebug() << "Bad string of len" << b.count() << ":" << bytes;
//qDebug() << "Read" << ret;
qFatal("Could not convert integer");
}
Zr e(*_pairing, z);
Q_ASSERT(e.isElementPresent());
mpz_clear(z);
return e;
}
void parse_input(int argc, const char* argv[], mpz_t seed, uint32_t* min, uint32_t* max){
int tmp;
if(argc <= 1 || argc > 4){
printf(help_msg);
exit(-1);
}
tmp = gmp_sscanf(argv[1], "%Zd\n", seed);
*min = MIN_DEFAULT;
*max = MAX_DEFAULT;
if(argc >= 3){
sscanf(argv[2], "%u", min);
}
if(argc == 3){
*max = *min;
}else if(argc == 4){
sscanf(argv[3], "%u", max);
}
}
void
check_input (void)
{
static const char *point[] = {
".", ",", "WU", "STR", "ZTV***"
};
static const struct {
const char *str;
double d;
} data[] = {
{ "1%s", 1.0 },
{ "1%s0", 1.0 },
{ "1%s00", 1.0 },
{ "%s5", 0.5 },
{ "0%s5", 0.5 },
{ "00%s5", 0.5 },
{ "00%s50", 0.5 },
{ "1%s5", 1.5 },
{ "1%s5e1", 15.0 },
};
int i, j, neg, ret;
char str[128];
mpf_t f;
double d;
mpf_init (f);
for (i = 0; i < numberof (point); i++)
{
decimal_point = (const char *) point[i];
for (neg = 0; neg <= 1; neg++)
{
for (j = 0; j < numberof (data); j++)
{
strcpy (str, neg ? "-" : "");
sprintf (str+strlen(str), data[j].str, decimal_point);
d = data[j].d;
if (neg)
d = -d;
mpf_set_d (f, 123.0);
if (mpf_set_str (f, str, 10) != 0)
{
printf ("mpf_set_str error\n");
printf (" point %s\n", decimal_point);
printf (" str %s\n", str);
abort ();
}
if (mpf_cmp_d (f, d) != 0)
{
printf ("mpf_set_str wrong result\n");
printf (" point %s\n", decimal_point);
printf (" str %s\n", str);
mpf_trace (" f", f);
printf (" d=%g\n", d);
abort ();
}
mpf_set_d (f, 123.0);
ret = gmp_sscanf (str, "%Ff", f);
if (ret != 1)
{
printf ("gmp_sscanf wrong return value\n");
printf (" point %s\n", decimal_point);
printf (" str %s\n", str);
printf (" ret %d\n", ret);
abort ();
}
if (mpf_cmp_d (f, d) != 0)
{
printf ("gmp_sscanf wrong result\n");
printf (" point %s\n", decimal_point);
printf (" str %s\n", str);
mpf_trace (" f", f);
printf (" d=%g\n", d);
abort ();
}
}
}
}
mpf_clear (f);
}
void
check_misc (void)
{
int ret, cmp;
{
int a=9, b=8, c=7, n=66;
mpz_t z;
mpz_init (z);
ret = gmp_sscanf ("1 2 3 4", "%d %d %d %Zd%n",
&a, &b, &c, z, &n);
ASSERT_ALWAYS (ret == 4);
ASSERT_ALWAYS (a == 1);
ASSERT_ALWAYS (b == 2);
ASSERT_ALWAYS (c == 3);
ASSERT_ALWAYS (n == 7);
ASSERT_ALWAYS (mpz_cmp_ui (z, 4L) == 0);
mpz_clear (z);
}
{
int a=9, b=8, c=7, n=66;
mpz_t z;
mpz_init (z);
ret = fromstring_gmp_fscanf ("1 2 3 4", "%d %d %d %Zd%n",
&a, &b, &c, z, &n);
ASSERT_ALWAYS (ret == 4);
ASSERT_ALWAYS (a == 1);
ASSERT_ALWAYS (b == 2);
ASSERT_ALWAYS (c == 3);
ASSERT_ALWAYS (mpz_cmp_ui (z, 4L) == 0);
ASSERT_ALWAYS (n == 7);
ASSERT_ALWAYS (got_ftell == 7);
mpz_clear (z);
}
{
int a=9, n=8;
mpz_t z;
mpz_init (z);
ret = gmp_sscanf ("1 2 3 4", "%d %*d %*d %Zd%n", &a, z, &n);
ASSERT_ALWAYS (ret == 2);
ASSERT_ALWAYS (a == 1);
ASSERT_ALWAYS (mpz_cmp_ui (z, 4L) == 0);
ASSERT_ALWAYS (n == 7);
mpz_clear (z);
}
{
int a=9, n=8;
mpz_t z;
mpz_init (z);
ret = fromstring_gmp_fscanf ("1 2 3 4", "%d %*d %*d %Zd%n",
&a, z, &n);
ASSERT_ALWAYS (ret == 2);
ASSERT_ALWAYS (a == 1);
ASSERT_ALWAYS (mpz_cmp_ui (z, 4L) == 0);
ASSERT_ALWAYS (n == 7);
ASSERT_ALWAYS (got_ftell == 7);
mpz_clear (z);
}
/* EOF for no matching */
{
char buf[128];
ret = gmp_sscanf (" ", "%s", buf);
ASSERT_ALWAYS (ret == EOF);
ret = fromstring_gmp_fscanf (" ", "%s", buf);
ASSERT_ALWAYS (ret == EOF);
if (option_libc_scanf)
{
ret = sscanf (" ", "%s", buf);
ASSERT_ALWAYS (ret == EOF);
ret = fun_fscanf (" ", "%s", buf, NULL);
ASSERT_ALWAYS (ret == EOF);
}
}
/* suppressed field, then eof */
{
int x;
if (test_sscanf_eof_ok ())
{
ret = gmp_sscanf ("123", "%*d%d", &x);
ASSERT_ALWAYS (ret == EOF);
}
ret = fromstring_gmp_fscanf ("123", "%*d%d", &x);
ASSERT_ALWAYS (ret == EOF);
if (option_libc_scanf)
{
ret = sscanf ("123", "%*d%d", &x);
ASSERT_ALWAYS (ret == EOF);
ret = fun_fscanf ("123", "%*d%d", &x, NULL);
ASSERT_ALWAYS (ret == EOF);
}
}
{
mpz_t x;
mpz_init (x);
ret = gmp_sscanf ("123", "%*Zd%Zd", x);
ASSERT_ALWAYS (ret == EOF);
ret = fromstring_gmp_fscanf ("123", "%*Zd%Zd", x);
ASSERT_ALWAYS (ret == EOF);
mpz_clear (x);
}
/* %[...], glibc only */
#ifdef __GLIBC__
{
char buf[128];
int n = -1;
buf[0] = '\0';
ret = gmp_sscanf ("abcdefgh", "%[a-d]ef%n", buf, &n);
ASSERT_ALWAYS (ret == 1);
cmp = strcmp (buf, "abcd");
ASSERT_ALWAYS (cmp == 0);
ASSERT_ALWAYS (n == 6);
}
{
char buf[128];
int n = -1;
buf[0] = '\0';
ret = gmp_sscanf ("xyza", "%[^a]a%n", buf, &n);
ASSERT_ALWAYS (ret == 1);
cmp = strcmp (buf, "xyz");
ASSERT_ALWAYS (cmp == 0);
ASSERT_ALWAYS (n == 4);
}
{
char buf[128];
int n = -1;
buf[0] = '\0';
ret = gmp_sscanf ("ab]ab]", "%[]ab]%n", buf, &n);
ASSERT_ALWAYS (ret == 1);
cmp = strcmp (buf, "ab]ab]");
ASSERT_ALWAYS (cmp == 0);
ASSERT_ALWAYS (n == 6);
}
{
char buf[128];
int n = -1;
buf[0] = '\0';
ret = gmp_sscanf ("xyzb", "%[^]ab]b%n", buf, &n);
ASSERT_ALWAYS (ret == 1);
cmp = strcmp (buf, "xyz");
ASSERT_ALWAYS (cmp == 0);
ASSERT_ALWAYS (n == 4);
}
#endif
/* %zd etc won't be accepted by sscanf on old systems, and running
something to see if they work might be bad, so only try it on glibc,
and only on a new enough version (glibc 2.0 doesn't have %zd) */
#if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ > 0)
{
mpz_t z;
size_t s = -1;
mpz_init (z);
ret = gmp_sscanf ("456 789", "%zd %Zd", &s, z);
ASSERT_ALWAYS (ret == 2);
ASSERT_ALWAYS (s == 456);
ASSERT_ALWAYS (mpz_cmp_ui (z, 789L) == 0);
mpz_clear (z);
}
{
mpz_t z;
ptrdiff_t d = -1;
mpz_init (z);
ret = gmp_sscanf ("456 789", "%td %Zd", &d, z);
ASSERT_ALWAYS (ret == 2);
ASSERT_ALWAYS (d == 456);
ASSERT_ALWAYS (mpz_cmp_ui (z, 789L) == 0);
mpz_clear (z);
}
{
mpz_t z;
long long ll = -1;
mpz_init (z);
ret = gmp_sscanf ("456 789", "%Ld %Zd", &ll, z);
ASSERT_ALWAYS (ret == 2);
ASSERT_ALWAYS (ll == 456);
ASSERT_ALWAYS (mpz_cmp_ui (z, 789L) == 0);
mpz_clear (z);
}
#endif
}
void
check_n (void)
{
int ret;
/* %n suppressed */
{
int n = 123;
gmp_sscanf (" ", " %*n", &n);
ASSERT_ALWAYS (n == 123);
}
{
int n = 123;
fromstring_gmp_fscanf (" ", " %*n", &n);
ASSERT_ALWAYS (n == 123);
}
#define CHECK_N(type, string) \
do { \
type x[2]; \
char fmt[128]; \
int ret; \
\
x[0] = ~ (type) 0; \
x[1] = ~ (type) 0; \
sprintf (fmt, "abc%%%sn", string); \
ret = gmp_sscanf ("abc", fmt, &x[0]); \
\
ASSERT_ALWAYS (ret == 0); \
\
/* should write whole of x[0] and none of x[1] */ \
ASSERT_ALWAYS (x[0] == 3); \
ASSERT_ALWAYS (x[1] == (type) ~ (type) 0); \
\
} while (0)
CHECK_N (char, "hh");
CHECK_N (long, "l");
#if HAVE_LONG_LONG
CHECK_N (long long, "L");
#endif
#if HAVE_INTMAX_T
CHECK_N (intmax_t, "j");
#endif
#if HAVE_PTRDIFF_T
CHECK_N (ptrdiff_t, "t");
#endif
CHECK_N (short, "h");
CHECK_N (size_t, "z");
/* %Zn */
{
mpz_t x[2];
mpz_init_set_si (x[0], -987L);
mpz_init_set_si (x[1], 654L);
ret = gmp_sscanf ("xyz ", "xyz%Zn", x[0]);
MPZ_CHECK_FORMAT (x[0]);
MPZ_CHECK_FORMAT (x[1]);
ASSERT_ALWAYS (ret == 0);
ASSERT_ALWAYS (mpz_cmp_ui (x[0], 3L) == 0);
ASSERT_ALWAYS (mpz_cmp_ui (x[1], 654L) == 0);
mpz_clear (x[0]);
mpz_clear (x[1]);
}
{
mpz_t x;
mpz_init (x);
ret = fromstring_gmp_fscanf ("xyz ", "xyz%Zn", x);
ASSERT_ALWAYS (ret == 0);
ASSERT_ALWAYS (mpz_cmp_ui (x, 3L) == 0);
mpz_clear (x);
}
/* %Qn */
{
mpq_t x[2];
mpq_init (x[0]);
mpq_init (x[1]);
mpq_set_ui (x[0], -987L, 654L);
mpq_set_ui (x[1], 4115L, 226L);
ret = gmp_sscanf ("xyz ", "xyz%Qn", x[0]);
MPQ_CHECK_FORMAT (x[0]);
MPQ_CHECK_FORMAT (x[1]);
ASSERT_ALWAYS (ret == 0);
ASSERT_ALWAYS (mpq_cmp_ui (x[0], 3L, 1L) == 0);
ASSERT_ALWAYS (mpq_cmp_ui (x[1], 4115L, 226L) == 0);
mpq_clear (x[0]);
mpq_clear (x[1]);
}
{
mpq_t x;
mpq_init (x);
ret = fromstring_gmp_fscanf ("xyz ", "xyz%Qn", x);
ASSERT_ALWAYS (ret == 0);
ASSERT_ALWAYS (mpq_cmp_ui (x, 3L, 1L) == 0);
mpq_clear (x);
}
/* %Fn */
{
mpf_t x[2];
mpf_init (x[0]);
mpf_init (x[1]);
mpf_set_ui (x[0], -987L);
mpf_set_ui (x[1], 654L);
ret = gmp_sscanf ("xyz ", "xyz%Fn", x[0]);
MPF_CHECK_FORMAT (x[0]);
MPF_CHECK_FORMAT (x[1]);
ASSERT_ALWAYS (ret == 0);
ASSERT_ALWAYS (mpf_cmp_ui (x[0], 3L) == 0);
ASSERT_ALWAYS (mpf_cmp_ui (x[1], 654L) == 0);
mpf_clear (x[0]);
mpf_clear (x[1]);
}
{
mpf_t x;
mpf_init (x);
ret = fromstring_gmp_fscanf ("xyz ", "xyz%Fn", x);
ASSERT_ALWAYS (ret == 0);
ASSERT_ALWAYS (mpf_cmp_ui (x, 3L) == 0);
mpf_clear (x);
}
}
static void arg_to_mpz(mpz_t result, const char *arg) {
char guard;
if (gmp_sscanf(arg, "%Zi%c", result, &guard) != 1)
fatal("invalid argument: '%s'", arg);
}
//Jianmin :: NLSystemContext* -> Effect -> IO
void Jianmin(NLSystemContext* ctx) {
uint32 i;
unsigned long exponent;
//Reactions:
bigFloat r[78]; //temp-storage during calculations
bigFloat r_f[78]; //forward reaction
bigFloat r_b[78]; //backward reaction
//Note: 'theta_H' is initialized in second bigFloat group below.
bigFloat theta_A, theta_B, theta_C, theta_D, theta_E, theta_F, theta_G, theta_I, theta_J, theta_K,
theta_L, theta_M, theta_N, theta_O, theta_P, theta_Q, theta_R, theta_S, theta_T, theta_U,
theta_V, theta_W, theta_X, theta_Y, theta_Z, theta_Z1;
bigFloat free, theta_H, theta_OH, theta_H2O, theta_CH, theta_CH2, theta_CH3, theta_CH4,
theta_CO, theta_CHO, theta_CH2O, theta_CH3O, theta_CH3OH;
bigFloat K_H;
bigFloat temp;
bigFloat e;
// define constants for forward and reverse rate constants.
//NOTE: constants for k_f[55]-k_f[70] are not defined! (same for k_b[].)
double in_k_f[78] = {
6.249e7, 1.831e3, 9.567e2, 8.447e3, 1.863e5, 5.509e8, 5.982, 2.106e10, 7.139e4, 2.243e8,
2.418e7, 1.247e8, 1.100e2, 5.791e12, 1.114e9, 9.955e3, 5.396e2, 3.706e3, 2.705e8, 7.040e9,
5.501e8, 2.335e4, 1.630e10, 6.622e2, 6.464e2, 2.109e8, 8.910, 3.268e5, 1.890e5, 9.014e11,
7.631e3, 6.303e2, 1.075e2, 9.362e7, 9.540e4, 2.636e8, 3.368e8, 1.615e10, 3.290e-3, 1.004e3,
1.457e5, 2.380e2, 3.845e7, 3.778e7, 9.432e3, 1.666e3, 3.094e8, 1.557e7, 6.575e1, 1.372e2,
3.003, 3.044e13, 1.047e16, 2.092e12, 1.020e3, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 5.056e9, 1.396e9, 4.831e9, 9.712e6, 4.000, 2.403e6, 1.404e-1};
double in_k_b[78] = {
5.885e4, 3.070e6, 2.885e7, 8.560e1, 8.721, 3.131e5, 6.828e-12, 4.823e3, 1.020e4, 1.566,
5.024e5, 3.056e6, 6.318e-1, 1.247e8, 8.518e-3, 6.388e10, 1.625e7, 1.514e5, 4.864e5, 1.941e2,
1.750e6, 8.974e1, 5.505e-2, 1.555e1, 2.380e7, 1.986, 1.865e7, 1.668, 1.108e7, 1.962,
1.902e11, 5.235e1, 1.311e7, 2.729, 2.606e8, 5.388e6, 4.689, 1.170e4, 2.457e-15, 1.833e-6,
7.225e-5, 5.142e8, 4.046e12, 9.921e9, 3.620e7, 2.431e7, 1.802e13, 2.232e8, 7.117e7, 6.635e7,
7.879e7, 1.230e8, 1.740e8, 1.640e8, 6.696e7, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 2.126e8, 1.611, 1.848e6, 1.828e2, 3.558e8, 1.593e5, 1.336e10};
bigFloat k_f[78];
bigFloat k_b[78];
// define partial pressures, Boltzman constant and temperature.
// guaiacol, H2, catechol, phenol, benzene, anisole.
bigFloat p_A, p_H2, p_M, p_S, p_X, p_K,
p_CO, p_H2O, p_CH4, p_CH3OH, KB, T;
double partialPressures[12] = {1.0, 1.0, 1.0e-5, 1.0e-5, 1.0e-5, 1.0e-5,
1.0e-6, 0.0, 0.0, 0.0, 8.6173324e-5, 573};
//---------------------------------------------------------
//INITIALIZATIONS:
//init r[]:
for(i = 0; i < 78; i++) {
mpf_init(r[i]);
}
//init r_f[]:
for(i = 0; i < 78; i++) {
mpf_init(r_f[i]);
}
//init r_b[]:
for(i = 0; i < 78; i++) {
mpf_init(r_b[i]);
}
//init forward and reverse rate constants:
initArray(k_f, in_k_f, 78);
initArray(k_b, in_k_b, 78);
//init the various thetas:
mpf_init_set(theta_A , ctx->state[0]);
mpf_init_set(theta_E , ctx->state[1]);
mpf_init_set(theta_F , ctx->state[2]);
mpf_init_set(theta_G , ctx->state[3]);
mpf_init_set(theta_I , ctx->state[4]);
mpf_init_set(theta_L , ctx->state[5]);
mpf_init_set(theta_M , ctx->state[6]);
mpf_init_set(theta_N , ctx->state[7]);
mpf_init_set(theta_O , ctx->state[8]);
mpf_init_set(theta_R , ctx->state[9]);
mpf_init_set(theta_S , ctx->state[10]);
mpf_init_set(theta_U , ctx->state[11]);
mpf_init_set(theta_V , ctx->state[12]);
mpf_init_set(theta_X , ctx->state[13]);
mpf_init_set(free , ctx->state[14]);
mpf_init_set(theta_H , ctx->state[15]);
mpf_init_set(theta_OH , ctx->state[16]);
mpf_init_set(theta_H2O , ctx->state[17]);
mpf_init_set(theta_CH , ctx->state[18]);
mpf_init_set(theta_CH2 , ctx->state[19]);
mpf_init_set(theta_CH3 , ctx->state[20]);
mpf_init_set(theta_CH4 , ctx->state[21]);
mpf_init_set(theta_CHO , ctx->state[22]);
mpf_init_set(theta_CH2O , ctx->state[23]);
mpf_init_set(theta_CH3O , ctx->state[24]);
mpf_init_set(theta_CH3OH , ctx->state[25]);
mpf_init_set(theta_W , ctx->state[26]);
mpf_init_set(theta_T , ctx->state[27]);
mpf_init_set(theta_B , ctx->state[28]);
mpf_init_set(theta_J , ctx->state[29]);
mpf_init_set(theta_P , ctx->state[30]);
mpf_init_set(theta_C , ctx->state[31]);
mpf_init_set(theta_D , ctx->state[32]);
mpf_init_set(theta_K , ctx->state[33]);
mpf_init_set(theta_Q , ctx->state[34]);
mpf_init_set(theta_Y , ctx->state[35]);
mpf_init_set(theta_Z , ctx->state[36]);
mpf_init_set(theta_Z1 , ctx->state[37]);
mpf_init_set(theta_CO , ctx->state[38]);
//init K_H, temp, and e:
mpf_init(K_H);
mpf_init(temp);
mpf_init(e);
//define e to 50 digits of precision:
gmp_sscanf("2.71828182845904523536028747135266249775724709369995", "%F", e);
//init partial pressures:
mpf_init_set_d(p_A , partialPressures[0]);
mpf_init_set_d(p_H2 , partialPressures[1]);
mpf_init_set_d(p_M , partialPressures[2]);
mpf_init_set_d(p_S , partialPressures[3]);
mpf_init_set_d(p_X , partialPressures[4]);
mpf_init_set_d(p_K , partialPressures[5]);
mpf_init_set_d(p_CO , partialPressures[6]);
mpf_init_set_d(p_H2O , partialPressures[7]);
mpf_init_set_d(p_CH4 , partialPressures[8]);
mpf_init_set_d(p_CH3OH , partialPressures[9]);
mpf_init_set_d(KB , partialPressures[10]);
mpf_init_set_d(T , partialPressures[11]);
//---------------------------------------------------------
//MAIN MATH KERNEL:
//FORWARD REACTION RATES:
// calculate rates for all elementary steps.
mpf_mul( r_f[0], k_f[0], p_A);
mpf_mul( r_f[0], r_f[0], free);
mpf_mul( r_f[0], r_f[0], free);
mpf_mul( r_f[0], r_f[0], free);
mpf_mul( r_f[0], r_f[0], free);
mpf_mul( r_f[1], k_f[1], theta_A);
mpf_mul( r_f[1], r_f[1], theta_H);
//r_f[2] and r_f[3] handled later on...
mpf_mul( r_f[4], k_f[4], theta_A);
mpf_mul( r_f[4], r_f[4], free);
mpf_mul( r_f[5], k_f[5], theta_A);
mpf_mul( r_f[5], r_f[5], free);
mpf_mul( r_f[6], k_f[6], theta_A);
mpf_mul( r_f[6], r_f[6], free);
mpf_mul( r_f[7], k_f[7], theta_A);
mpf_mul( r_f[7], r_f[7], free);
mpf_mul( r_f[8], k_f[8], theta_B);
mpf_mul( r_f[8], r_f[8], free);
mpf_mul( r_f[8], r_f[8], free);
//r_f[9] and r_f[10] handled later on...
mpf_mul( r_f[11], k_f[11], theta_E);
mpf_mul( r_f[11], r_f[11], theta_H);
mpf_mul( r_f[12], k_f[12], theta_F);
mpf_mul( r_f[12], r_f[12], free);
mpf_mul( r_f[13], k_f[13], theta_F);
mpf_mul( r_f[13], r_f[13], free);
mpf_mul( r_f[14], k_f[14], theta_F);
mpf_mul( r_f[15], k_f[15], theta_G);
mpf_mul( r_f[15], r_f[15], theta_H);
mpf_mul( r_f[16], k_f[16], theta_G);
mpf_mul( r_f[16], r_f[16], free);
mpf_mul( r_f[17], k_f[17], theta_I);
mpf_mul( r_f[17], r_f[17], free);
mpf_mul( r_f[18], k_f[18], theta_I);
mpf_mul( r_f[18], r_f[18], free);
mpf_mul( r_f[18], r_f[18], free);
mpf_mul( r_f[19], k_f[19], theta_J);
//r_f[20] handled later on...
mpf_mul( r_f[21], k_f[21], theta_L);
mpf_mul( r_f[21], r_f[21], free);
mpf_mul( r_f[22], k_f[22], theta_L);
mpf_mul( r_f[22], r_f[22], free);
mpf_mul( r_f[23], k_f[23], theta_M);
mpf_mul( r_f[23], r_f[23], free);
mpf_mul( r_f[24], k_f[24], theta_M);
mpf_mul( r_f[24], r_f[24], theta_H);
mpf_mul( r_f[25], k_f[25], theta_N);
mpf_mul( r_f[25], r_f[25], theta_H);
mpf_mul( r_f[26], k_f[26], theta_O);
mpf_mul( r_f[26], r_f[26], free);
mpf_mul( r_f[27], k_f[27], theta_O);
mpf_mul( r_f[27], r_f[27], free);
mpf_mul( r_f[28], k_f[28], theta_P);
mpf_mul( r_f[28], r_f[28], theta_H);
//r[29] handled later on...
mpf_mul( r_f[30], k_f[30], theta_R);
mpf_mul( r_f[30], r_f[30], theta_H);
mpf_mul( r_f[31], k_f[31], theta_S);
mpf_mul( r_f[31], r_f[31], free);
mpf_mul( r_f[32], k_f[32], theta_S);
mpf_mul( r_f[32], r_f[32], theta_H);
mpf_mul( r_f[33], k_f[33], theta_T);
mpf_mul( r_f[33], r_f[33], free);
mpf_mul( r_f[34], k_f[34], theta_U);
mpf_mul( r_f[34], r_f[34], theta_H);
mpf_mul( r_f[35], k_f[35], theta_V);
mpf_mul( r_f[35], r_f[35], theta_H);
mpf_mul( r_f[36], k_f[36], theta_W);
mpf_mul( r_f[37], k_f[37], theta_F);
mpf_mul( r_f[37], r_f[37], free);
//what happened to r_38?!
mpf_mul( r_f[39], k_f[39], theta_I);
mpf_mul( r_f[39], r_f[39], free);
mpf_mul( r_f[39], r_f[39], free);
mpf_mul( r_f[40], k_f[40], theta_B);
mpf_mul( r_f[40], r_f[40], free);
mpf_mul( r_f[40], r_f[40], free);
mpf_mul( r_f[41], k_f[41], theta_CH3O);
mpf_mul( r_f[41], r_f[41], theta_H);
mpf_mul( r_f[42], k_f[42], theta_CH);
mpf_mul( r_f[42], r_f[42], theta_H);
mpf_mul( r_f[43], k_f[43], theta_CH2);
mpf_mul( r_f[43], r_f[43], theta_H);
mpf_mul( r_f[44], k_f[44], theta_CH3);
mpf_mul( r_f[44], r_f[44], theta_H);
mpf_mul( r_f[45], k_f[45], theta_OH);
mpf_mul( r_f[45], r_f[45], theta_H);
mpf_mul( r_f[46], k_f[46], theta_CHO);
mpf_mul( r_f[46], r_f[46], theta_H);
mpf_mul( r_f[47], k_f[47], theta_CH2O);
mpf_mul( r_f[47], r_f[47], theta_H);
mpf_mul( r_f[48], k_f[48], theta_S);
mpf_mul( r_f[49], k_f[49], theta_M);
mpf_mul( r_f[50], k_f[50], theta_X);
mpf_mul( r_f[51], k_f[51], theta_CH3OH);
mpf_mul( r_f[52], k_f[52], theta_CH4);
mpf_mul( r_f[53], k_f[53], theta_H2O);
mpf_mul( r_f[54], k_f[54], theta_K);
//not using r_f[55] through r_f[74]?!
//also, consider making below assignments in-order (might help optimizer).
mpf_mul( r_f[71], k_f[71], theta_O);
mpf_mul( r_f[71], r_f[71], free);
mpf_mul( r_f[72], k_f[72], theta_Z);
mpf_mul( r_f[72], r_f[72], free);
mpf_mul( r_f[73], k_f[73], theta_Z);
mpf_mul( r_f[73], r_f[73], free);
mpf_mul( r_f[74], k_f[74], theta_Z1);
mpf_mul( r_f[75], k_f[75], theta_G);
mpf_mul( r_f[75], r_f[75], theta_H);
mpf_mul( r_f[76], k_f[76], theta_Y);
mpf_mul( r_f[76], r_f[76], free);
mpf_mul( r_f[77], k_f[77], theta_CO);
mpf_mul( r_f[77], r_f[77], theta_H);
//
// steps including C, D, K, Q.
mpf_mul( r_f[2], k_f[2], theta_A);
mpf_mul( r_f[2], r_f[2], theta_H);
mpf_mul( r_f[3], k_f[3], theta_A);
mpf_mul( r_f[3], r_f[3], free);
mpf_mul( r_f[9], k_f[9], theta_C);
mpf_mul( r_f[9], r_f[9], free);
mpf_mul( r_f[10], k_f[10], theta_D);
mpf_mul( r_f[10], r_f[10], theta_H);
mpf_mul( r_f[20], k_f[20], theta_K);
mpf_mul( r_f[20], r_f[20], free);
mpf_mul( r_f[29], k_f[29], theta_Q);
mpf_mul( r_f[29], r_f[29], free);
//REVERSE REACTION RATES:
mpf_mul( r_b[0], k_b[0], theta_A);
mpf_mul( r_b[1], k_b[1], theta_B);
mpf_mul( r_b[1], r_b[1], free);
//r[2] and r[3] handled later on...
mpf_mul( r_b[4], k_b[4], theta_E);
mpf_mul( r_b[4], r_b[4], theta_CH3O);
mpf_mul( r_b[5], k_b[5], theta_F);
mpf_mul( r_b[5], r_b[5], theta_H);
mpf_mul( r_b[6], k_b[6], theta_G);
mpf_mul( r_b[6], r_b[6], theta_CH3);
mpf_mul( r_b[7], k_b[7], theta_I);
mpf_mul( r_b[7], r_b[7], theta_H);
mpf_mul( r_b[8], k_b[8], theta_J);
mpf_mul( r_b[8], r_b[8], theta_H);
//r[9] and r[10] handled later on...
mpf_mul( r_b[11], k_b[11], theta_S);
mpf_mul( r_b[11], r_b[11], free);
mpf_mul( r_b[12], k_b[12], theta_E);
mpf_mul( r_b[12], r_b[12], theta_CH2O);
mpf_mul( r_b[13], k_b[13], theta_L);
mpf_mul( r_b[13], r_b[13], theta_H);
mpf_mul( r_b[14], k_b[14], theta_G);
mpf_mul( r_b[14], r_b[14], theta_CH2);
mpf_mul( r_b[15], k_b[15], theta_M);
mpf_mul( r_b[15], r_b[15], free);
mpf_mul( r_b[16], k_b[16], theta_N);
mpf_mul( r_b[16], r_b[16], theta_OH);
mpf_mul( r_b[17], k_b[17], theta_N);
mpf_mul( r_b[17], r_b[17], theta_CH3O);
mpf_mul( r_b[18], k_b[18], theta_O);
mpf_mul( r_b[18], r_b[18], theta_H);
mpf_mul( r_b[19], k_b[19], theta_P);
mpf_mul( r_b[19], r_b[19], theta_CH2);
//r[20] handled later on...
mpf_mul( r_b[21], k_b[21], theta_E);
mpf_mul( r_b[21], r_b[21], theta_CHO);
mpf_mul( r_b[22], k_b[22], theta_G);
mpf_mul( r_b[22], r_b[22], theta_CH);
mpf_mul( r_b[23], k_b[23], theta_E);
mpf_mul( r_b[23], r_b[23], theta_OH);
mpf_mul( r_b[24], k_b[24], theta_T);
mpf_mul( r_b[25], k_b[25], theta_R);
mpf_mul( r_b[25], r_b[25], free);
mpf_mul( r_b[26], k_b[26], theta_N);
mpf_mul( r_b[26], r_b[26], theta_CH2O);
mpf_mul( r_b[27], k_b[27], theta_U);
mpf_mul( r_b[27], r_b[27], theta_CH2);
mpf_mul( r_b[28], k_b[28], theta_T);
mpf_mul( r_b[28], r_b[28], free);
//r[29] handled later on...
mpf_mul( r_b[30], k_b[30], theta_S);
mpf_mul( r_b[30], r_b[30], free);
mpf_mul( r_b[31], k_b[31], theta_V);
mpf_mul( r_b[31], r_b[31], theta_OH);
mpf_mul( r_b[32], k_b[32], theta_W);
mpf_mul( r_b[32], r_b[32], free);
mpf_mul( r_b[33], k_b[33], theta_S);
mpf_mul( r_b[33], r_b[33], theta_OH);
mpf_mul( r_b[34], k_b[34], theta_G);
mpf_mul( r_b[34], r_b[34], free);
mpf_mul( r_b[34], r_b[34], free);
mpf_mul( r_b[35], k_b[35], theta_X);
mpf_mul( r_b[35], r_b[35], free);
mpf_mul( r_b[35], r_b[35], free);
mpf_mul( r_b[36], k_b[36], theta_X);
mpf_mul( r_b[36], r_b[36], theta_OH);
mpf_mul( r_b[37], k_b[37], theta_O);
mpf_mul( r_b[37], r_b[37], theta_H);
//what happened to r_38?!
mpf_mul( r_b[39], k_b[39], theta_U);
mpf_mul( r_b[39], r_b[39], theta_CH3);
mpf_mul( r_b[40], k_b[40], theta_S);
mpf_mul( r_b[40], r_b[40], theta_CH3O);
mpf_mul( r_b[41], k_b[41], theta_CH3OH);
mpf_mul( r_b[41], r_b[41], free);
mpf_mul( r_b[42], k_b[42], theta_CH2);
mpf_mul( r_b[42], r_b[42], free);
mpf_mul( r_b[43], k_b[43], theta_CH3);
mpf_mul( r_b[43], r_b[43], free);
mpf_mul( r_b[44], k_b[44], theta_CH4);
mpf_mul( r_b[44], r_b[44], free);
mpf_mul( r_b[45], k_b[45], theta_H2O);
mpf_mul( r_b[45], r_b[45], free);
mpf_mul( r_b[46], k_b[46], theta_CH2O);
mpf_mul( r_b[46], r_b[46], free);
mpf_mul( r_b[47], k_b[47], theta_CH3O);
mpf_mul( r_b[47], r_b[47], free);
mpf_mul( r_b[47], r_b[47], free);
mpf_mul( r_b[48], k_b[48], p_S);
mpf_mul( r_b[48], r_b[48], free);
mpf_mul( r_b[48], r_b[48], free);
mpf_mul( r_b[48], r_b[48], free);
mpf_mul( r_b[48], r_b[48], free);
mpf_mul( r_b[49], k_b[49], p_M);
mpf_mul( r_b[49], r_b[49], free);
mpf_mul( r_b[49], r_b[49], free);
mpf_mul( r_b[49], r_b[49], free);
mpf_mul( r_b[49], r_b[49], free);
mpf_mul( r_b[50], k_b[50], p_X);
mpf_mul( r_b[50], r_b[50], free);
mpf_mul( r_b[50], r_b[50], free);
mpf_mul( r_b[50], r_b[50], free);
mpf_mul( r_b[51], k_b[51], p_CH3OH);
mpf_mul( r_b[51], r_b[51], free);
mpf_mul( r_b[52], k_b[52], p_CH4);
mpf_mul( r_b[52], r_b[52], free);
mpf_mul( r_b[53], k_b[53], p_H2O);
mpf_mul( r_b[53], r_b[53], free);
mpf_mul( r_b[54], k_b[54], p_K);
mpf_mul( r_b[54], r_b[54], free);
mpf_mul( r_b[54], r_b[54], free);
mpf_mul( r_b[54], r_b[54], free);
mpf_mul( r_b[54], r_b[54], free);
//not using r[55] through r[74]?!
//also, consider making below assignments in-order (might help optimizer).
mpf_mul( r_b[71], k_b[71], theta_Z);
mpf_mul( r_b[71], r_b[71], theta_H);
mpf_mul( r_b[72], k_b[72], theta_U);
mpf_mul( r_b[72], r_b[72], theta_CH);
mpf_mul( r_b[73], k_b[73], theta_Z1);
mpf_mul( r_b[73], r_b[73], theta_H);
mpf_mul( r_b[74], k_b[74], theta_N);
mpf_mul( r_b[74], r_b[74], theta_CO);
mpf_mul( r_b[75], k_b[75], theta_Y);
mpf_mul( r_b[75], r_b[75], free);
mpf_mul( r_b[76], k_b[76], theta_R);
mpf_mul( r_b[76], r_b[76], theta_OH);
mpf_mul( r_b[77], k_b[77], theta_CHO);
//
// steps including C, D, K, Q.
mpf_mul( r_b[2], k_b[2], theta_C);
mpf_mul( r_b[2], r_b[2], free);
mpf_mul( r_b[3], k_b[3], theta_D);
mpf_mul( r_b[3], r_b[3], theta_OH);
mpf_mul( r_b[9], k_b[9], theta_K);
mpf_mul( r_b[9], r_b[9], theta_OH);
mpf_mul( r_b[10], k_b[10], theta_K);
mpf_mul( r_b[10], r_b[10], free);
mpf_mul( r_b[20], k_b[20], theta_Q);
mpf_mul( r_b[20], r_b[20], theta_H);
mpf_mul( r_b[29], k_b[29], theta_R);
mpf_mul( r_b[29], r_b[29], theta_CH2);
//OVERALL REACTION RATES:
for(i = 0; i < 78; i++) {
mpf_sub( r[i], r_f[i], r_b[i]);
}
//---------------------------------------------------------
// apply the steady state approximation for all thetas.
//NOTE: need to put in GNU MP ops + rewrite to array accesses.
/*out[0] = r_04 + r_12 + r_21 + r_23 - r_11; // d(theta_E)/dt=0
out[1] = r_05 - r_12 - r_13 - r_14 - r_37; // d(theta_F)/dt=0
out[2] = r_06 + r_14 + r_22 + r_34 - r_15 - r_16 - r_75; // d(theta_G)/dt=0
out[3] = r_07 - r_17 - r_18 - r_39; // d(theta_I)/dt=0
out[4] = r_13 - r_21 - r_22; // d(theta_L)/dt=0
out[5] = r_15 - r_23 - r_24 - r_49; // d(theta_M)/dt=0 catechol
out[6] = r_16 + r_17 + r_26 + r_74 - r_25; // d(theta_N)/dt=0
out[7] = r_18 + r_37 - r_26 - r_27 - r_71; // d(theta_O)/dt=0
out[8] = r_25 + r_29 + r_76 - r_30; // d(theta_R)/dt=0
out[9] = r_11 + r_30 + r_33 + r_40 - r_31 - r_32 - r_48; // d(theta_S)/dt=0 phenol
out[10] = r_27 + r_39 + r_72 - r_34; // d(theta_U)/dt=0
out[11] = r_31 - r_35; // d(theta_V)/dt=0
out[12] = r_35 + r_36 - r_50; // d(theta_X)/dt=0 benzene
out[13] = r_03 + r_09 + r_23 + r_31 + r_31 + r_33 - r_45; // d(theta_OH)/dt=0
out[14] = r_45 - r_53; // d(theta_H2O)/dt=0
out[15] = r_22 + r_72 - r_42; // d(theta_CH)/dt =0
out[16] = r_14 + r_19 + r_27 + r_29 + r_42 - r_43; // d(theta_CH2)/dt=0
out[17] = r_06 + r_43 - r_44; // d(theta_CH3)/dt=0
out[18] = r_44 - r_52; // d(theta_CH4)/dt=0
out[19] = r_21 + r_77 - r_46; // d(theta_CHO)/dt=0
out[20] = r_12 + r_26 + r_46 - r_47; // d(theta_CH2O)/dt=0
out[21] = r_04 + r_17 + r_47 - r_41; // d(theta_CH3O)/dt=0
out[22] = r_41 - r_51; // d(theta_CH3OH)/dt=0
out[23] = r_00 - r_01 - r_04 - r_05 - r_06 - r_07; // d(theta_A)/dt=0
// out[23] = theta_A - k_00_f/k_00_b*p_A*free*free*free*free; // d(theta_A)/dt=0 if step 0 is in equilibrium.
out[24] = r_32 - r_36; // d(theta_W)/dt=0
out[25] = r_24 + r_28 - r_33; // d(theta_T)/dt=0
out[26] = r_01 - r_08 - r_40; // d(theta_B)/dt=0
out[27] = r_08 - r_19; // d(theta_J)/dt=0
out[28] = r_19 - r_28; // d(theta_P)/dt=0
out[29] = theta_H - exp(-( (-1.374+0.076+0.683)/2 + 2*0.084*(theta_H-0.139))/KB/T)*pow(p_H2,0.5)*free; //theta_H
out[30] = r_02 - r_09; // d(theta_C)/dt=0
out[31] = r_03 - r_10; // d(theta_D)/dt=0
out[32] = r_09 + r_10 - r_20 - r_54; // d(theta_K)/dt=0
out[33] = r_20 - r_29; // d(theta_Q)/dt=0
out[34] = r_75 - r_76; // d(theta_Y)/dt=0
out[35] = r_71 - r_72 - r_73; // d(theta_Z)/dt=0
out[36] = r_73 - r_74; // d(theta_Z1)/dt=0
out[37] = theta_CO - exp(-(-2.131+0.028+1.764)/KB/T)*p_CO*free; // d(theta_CO)/dt=0*/
// finally the summation of all thetas should be 1.
//NOTE: need to put in GNU MP ops.
/*mpf_set(out[38], ( 4*ctx->state[0] + 4*ctx->state[1] + 4*ctx->state[2] + 4*ctx->state[3]
+ 4*ctx->state[4] + 4*ctx->state[5] + 4*ctx->state[6] + 4*ctx->state[7]
+ 4*ctx->state[8] + 4*ctx->state[9] + 4*ctx->state[10] + 5*ctx->state[11]
+ 3*ctx->state[12] + 3*ctx->state[13] + ctx->state[14] + ctx->state[15]
+ ctx->state[16] + ctx->state[17] + ctx->state[18] + 2*ctx->state[19]
+ ctx->state[20] + ctx->state[21] + 2*ctx->state[22] + 2*ctx->state[23]
+ ctx->state[24] + ctx->state[25] + 4*ctx->state[26] + 5*ctx->state[27]
+ 4*ctx->state[28] + 4*ctx->state[29] + 5*ctx->state[30] + 4*ctx->state[31]
+ 4*ctx->state[32] + 4*ctx->state[33] + 5*ctx->state[34] + 4*ctx->state[35]
+ 4*ctx->state[36] + 4*ctx->state[37] + ctx->state[38] - 1.00 )
);*/
//NOTE: need to put in GNU MP ops + rewrite to array accesses.
/*K_H = exp(-( (-1.374+0.076+0.683)/2 + 2*0.084*(theta_H-0.139))/KB/T);*/
//---------------------------------------------------------
//OUTPUT:
//To send output to a file, run this program like so:
//`$ ./theta.exe > output.txt`
printf("OVERALL REACTION RATES:\n");
for(i = 0; i < 78; i++) {
gmp_printf("r[%d] = %Fg\n", i, r[i]);
}
gmp_printf("K_H = %Fg\n", K_H);
printf("\nFORWARD REACTION RATES:\n");
for(i = 0; i < 78; i++) {
gmp_printf("r_f[%d] = %Fg\n", i, r_f[i]);
}
printf("\nREVERSE REACTION RATES:\n");
for(i = 0; i < 78; i++) {
gmp_printf("r_b[%d] = %Fg\n", i, r_b[i]);
}
//---------------------------------------------------------
//FREES:
//free up the memory GNU MP allocated behind the scenes:
//free r[]:
for(i = 0; i < 78; i++) {
mpf_clear(r[i]);
}
//free r_f[]:
for(i = 0; i < 78; i++) {
mpf_clear(r_f[i]);
}
//free r_b[]:
for(i = 0; i < 78; i++) {
mpf_clear(r_b[i]);
}
//free forward and reverse rate constants:
clearArray(k_f, 78);
clearArray(k_b, 78);
//free the various thetas:
mpf_clear(theta_A);
mpf_clear(theta_E);
mpf_clear(theta_F);
mpf_clear(theta_G);
mpf_clear(theta_I);
mpf_clear(theta_L);
mpf_clear(theta_M);
mpf_clear(theta_N);
mpf_clear(theta_O);
mpf_clear(theta_R);
mpf_clear(theta_S);
mpf_clear(theta_U);
mpf_clear(theta_V);
mpf_clear(theta_X);
mpf_clear(free);
mpf_clear(theta_H);
mpf_clear(theta_OH);
mpf_clear(theta_H2O);
mpf_clear(theta_CH);
mpf_clear(theta_CH2);
mpf_clear(theta_CH3);
mpf_clear(theta_CH4);
mpf_clear(theta_CHO);
mpf_clear(theta_CH2O);
mpf_clear(theta_CH3O);
mpf_clear(theta_CH3OH);
mpf_clear(theta_W);
mpf_clear(theta_T);
mpf_clear(theta_B);
mpf_clear(theta_J);
mpf_clear(theta_P);
mpf_clear(theta_C);
mpf_clear(theta_D);
mpf_clear(theta_K);
mpf_clear(theta_Q);
mpf_clear(theta_Y);
mpf_clear(theta_Z);
mpf_clear(theta_Z1);
mpf_clear(theta_CO);
//free K_H, temp, and e:
mpf_clear(K_H);
mpf_clear(temp);
mpf_clear(e);
//free partial pressures:
mpf_clear(p_A);
mpf_clear(p_H2);
mpf_clear(p_M);
mpf_clear(p_S);
mpf_clear(p_X);
mpf_clear(p_K);
mpf_clear(p_CO);
mpf_clear(p_H2O);
mpf_clear(p_CH4);
mpf_clear(p_CH3OH);
mpf_clear(KB);
mpf_clear(T);
//---------------------------------------------------------
}
AB_VALUE *AB_Value_fromString(const char *s) {
AB_VALUE *v;
const char *currency=NULL;
int conversion_succeeded = 1; // assume conversion will succeed
char *tmpString=NULL;
char *p;
char *t;
char decimalComma;
int isNeg=0;
if( !s ) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "Attempt to convert a NULL value");
return NULL;
}
tmpString=strdup(s);
p=tmpString;
while(*p && *p<33)
p++;
if (*p=='-') {
isNeg=1;
p++;
}
else if (*p=='+') {
p++;
}
t=strchr(p, ':');
if (t) {
currency=t+1;
*t=0;
}
/* remove thousand's comma */
decimalComma=AB_Value_determineDecimalComma(p);
if (decimalComma) {
char *s1, *d1;
s1=p;
d1=p;
while(*s1) {
register char c;
c=*(s1++);
if (isdigit(c) || c=='/')
*(d1++)=c;
else if (c==decimalComma)
/* always use '.' as decimal comma */
*(d1++)='.';
}
*d1=0;
}
v=AB_Value_new();
t=strchr(p, '.');
if (t) {
// remove comma and calculate denominator
unsigned long denominator = 1;
char *next;
do {
next=t+1;
*t=*next;
if (*next != 0)
denominator *= 10;
t++;
} while (*next);
// set denominator to the calculated value
mpz_set_ui(mpq_denref(v->value), denominator);
// set numerator to the resulting integer string without comma
if (mpz_set_str(mpq_numref(v->value), p, 10) == -1) {
conversion_succeeded = 0;
}
}
else {
/*DBG_ERROR(0, "Scanning this value: %s\n", p);*/
conversion_succeeded = (gmp_sscanf(p, "%Qu", v->value) == 1);
}
/* set currency (if any) */
if (currency)
v->currency=strdup(currency);
/* temporary string no longer needed */
free(tmpString);
if (!conversion_succeeded) {
DBG_ERROR(AQBANKING_LOGDOMAIN, "[%s] is not a valid value", s);
AB_Value_free(v);
return NULL;
}
if (isNeg)
mpq_neg(v->value, v->value);
return v;
}
void ZComputationVerifier::init_qap(const char *file_name_qap) {
// compute these based on values set by the compiler
poly_A = (poly_compressed *) malloc(num_aij * sizeof(poly_compressed));
poly_B = (poly_compressed *) malloc(num_bij * sizeof(poly_compressed));
poly_C = (poly_compressed *) malloc(num_cij * sizeof(poly_compressed));
for (int i=0; i<num_aij; i++)
alloc_init_scalar(poly_A[i].coefficient);
for (int i=0; i<num_bij; i++)
alloc_init_scalar(poly_B[i].coefficient);
for (int i=0; i<num_cij; i++)
alloc_init_scalar(poly_C[i].coefficient);
// create vectors to store the evaluations of the polynomial at tau
alloc_init_vec(&eval_poly_A, n+1);
alloc_init_vec(&eval_poly_B, n+1);
alloc_init_vec(&eval_poly_C, n+1);
alloc_init_vec(&A_tau_io, num_repetitions*(size_input+size_output+1));
alloc_init_vec(&B_tau_io, num_repetitions*(size_input+size_output+1));
alloc_init_vec(&C_tau_io, num_repetitions*(size_input+size_output+1));
// open the file
FILE *fp = fopen(file_name_qap, "r");
if (fp == NULL) {
cout<<"Cannot read "<<file_name_qap<<endl;
exit(1);
}
char line[BUFLEN];
mpz_t temp;
alloc_init_scalar(temp);
// fill the array of struct: poly_A, poly_B, and poly_C
int line_num = 0;
while (fgets(line, sizeof line, fp) != NULL) {
if (line[0] == '\n')
continue;
if (line_num < num_aij) {
gmp_sscanf(line, "%d %d %Zd", &poly_A[line_num].i, &poly_A[line_num].j, poly_A[line_num].coefficient);
} else if (line_num >= num_aij && line_num < num_aij+num_bij) {
gmp_sscanf(line, "%d %d %Zd", &poly_B[line_num-num_aij].i, &poly_B[line_num-num_aij].j, poly_B[line_num-num_aij].coefficient);
} else {
gmp_sscanf(line, "%d %d %Zd", &poly_C[line_num-num_aij-num_bij].i, &poly_C[line_num-num_aij-num_bij].j, poly_C[line_num-num_aij-num_bij].coefficient);
}
line_num++;
}
fclose(fp);
clear_scalar(temp);
// set prime size based on name of the computation in case of Zaatar
string str(file_name_qap);
if (str.find("bisect_sfdl") != std::string::npos) {
num_bits_in_prime = 220;
} else if (str.find("pd2_sfdl") != std::string::npos) {
num_bits_in_prime = 220;
} else {
num_bits_in_prime = 128;
}
cout<<"LOG: Using a prime of size "<<num_bits_in_prime<<endl;
}
PairingGroup::PairingGroup(GroupSize s) :
_size(s)
{
switch(s) {
case TESTING_128:
_param_str = QByteArray(_param_bytes_128);
break;
case TESTING_256:
_param_str = QByteArray(_param_bytes_256);
break;
case PRODUCTION_512:
_param_str = QByteArray(_param_bytes_512);
break;
case PRODUCTION_768:
_param_str = QByteArray(_param_bytes_768);
break;
case PRODUCTION_1024:
_param_str = QByteArray(_param_bytes_1024);
break;
case PRODUCTION_1280:
_param_str = QByteArray(_param_bytes_1280);
break;
case PRODUCTION_1536:
_param_str = QByteArray(_param_bytes_1536);
break;
default:
qFatal("Unknown parameter type");
}
_pairing = QSharedPointer<Pairing>(new Pairing(_param_str.constData(), _param_str.count()));
// Maxlen = 32 kb
const int maxlen = 1024*32;
int ret;
QByteArray buf(maxlen, 0);
mpz_t p, q;
mpz_init(p);
mpz_init(q);
if((ret = gmp_sscanf(_param_str, "type a q %Zd h %*Zd r %Zd", p, q)) != 2)
qFatal("gmp_sscanf failed");
// PBC calls the field size "q" while we
// call it p. This is the field size of G1 and G2 in a type-A pairing.
// The field size for GT is (field_size)^2
if((ret = gmp_snprintf(buf.data(), buf.count(), "%Zx", p)) >= maxlen)
qFatal("gmp_snprintf failed");
_field = Integer(QByteArray::fromHex(buf.left(ret)));
// PBC calls the order "r", while we call it "q"
if((ret = gmp_snprintf(buf.data(), buf.count(), "%Zx", q)) >= maxlen)
qFatal("gmp_snprintf failed");
_order = Integer(QByteArray::fromHex(buf.left(ret)));
mpz_clear(p);
mpz_clear(q);
Q_ASSERT(_pairing->isPairingPresent());
}
unsigned long combine_large_primes(QS_t * qs_inf, linalg_t * la_inf, poly_t * poly_inf,
FILE *COMB, mpz_t factor)
{
char new_relation[MPQS_STRING_LENGTH], buf[MPQS_STRING_LENGTH];
mpqs_lp_entry e[2]; /* we'll use the two alternatingly */
unsigned long *ei;
long ei_size = qs_inf->num_primes;
mpz_t * N = &qs_inf->mpz_n;
long old_q;
mpz_t inv_q, Y1, Y2, new_Y, new_Y1;
mpz_init(inv_q); mpz_init(Y1); mpz_init(Y2); mpz_init(new_Y); mpz_init(new_Y1);
long i, l, c = 0;
unsigned long newrels = 0;
if (!fgets(buf, MPQS_STRING_LENGTH, COMB)) return 0; /* should not happen */
ei = (unsigned long *) malloc(sizeof(unsigned long)*ei_size);
/* put first lp relation in row 0 of e */
set_lp_entry(&e[0], buf);
i = 1; /* second relation will go into row 1 */
old_q = e[0].q;
mpz_set_ui(inv_q, old_q);
while (!mpz_invert(inv_q, inv_q, *N)) /* can happen */
{
/* We have found a factor. It could be N when N is quite small;
or we might just have found a divisor by sheer luck. */
mpz_gcd_ui(inv_q, *N, old_q);
if (!mpz_cmp(inv_q, *N)) /* pity */
{
if (!fgets(buf, MPQS_STRING_LENGTH, COMB)) { return 0; }
set_lp_entry(&e[0], buf);
old_q = e[0].q;
mpz_set_ui(inv_q, old_q);
continue;
}
mpz_set(factor, inv_q);
free(ei);
mpz_clear(inv_q); mpz_clear(Y1); mpz_clear(Y2); mpz_clear(new_Y); mpz_clear(new_Y1);
return c;
}
gmp_sscanf(e[0].Y, "%Zd", Y1);
while (fgets(buf, MPQS_STRING_LENGTH, COMB))
{
set_lp_entry(&e[i], buf);
if (e[i].q != old_q)
{
/* switch to combining a new bunch, swapping the rows */
old_q = e[i].q;
mpz_set_ui(inv_q, old_q);
while (!mpz_invert(inv_q, inv_q, *N)) /* can happen */
{
mpz_gcd_ui(inv_q, *N, old_q);
if (!mpz_cmp(inv_q, *N)) /* pity */
{
old_q = -1; /* sentinel */
continue; /* discard this combination */
}
mpz_set(factor, inv_q);
free(ei);
mpz_clear(inv_q); mpz_clear(Y1); mpz_clear(Y2); mpz_clear(new_Y); mpz_clear(new_Y1);
return c;
}
gmp_sscanf(e[i].Y, "%Zd", Y1);
i = 1 - i; /* subsequent relations go to other row */
continue;
}
/* count and combine the two we've got, and continue in the same row */
memset((void *)ei, 0, ei_size * sizeof(long));
set_exponents(ei, e[0].E);
set_exponents(ei, e[1].E);
gmp_sscanf(e[i].Y, "%Zd", Y2);
if (mpz_cmpabs(Y1,Y2)!=0)
{
unsigned long * small = la_inf->small;
fac_t * factor = la_inf->factor;
unsigned long num_factors = 0;
unsigned long small_primes = qs_inf->small_primes;
unsigned long num_primes = qs_inf->num_primes;
c++;
mpz_mul(new_Y, Y1, Y2);
mpz_mul(new_Y, new_Y, inv_q);
mpz_mod(new_Y, new_Y, *N);
mpz_sub(new_Y1, *N, new_Y);
if (mpz_cmpabs(new_Y1, new_Y) < 0) mpz_set(new_Y, new_Y1);
for (l = 0; l < small_primes; l++)
{
small[l] = ei[l];
}
for (l = small_primes; l < num_primes; l++)
{
if (ei[l])
{
factor[num_factors].ind = l;
factor[num_factors].exp = ei[l];
num_factors++;
}
}
la_inf->num_factors = num_factors;
newrels += insert_relation(qs_inf, la_inf, poly_inf, new_Y);
}
} /* while */
free(ei);
mpz_clear(inv_q); mpz_clear(Y1); mpz_clear(Y2); mpz_clear(new_Y); mpz_clear(new_Y1);
return newrels;
}
