void ssx_eval_col(SSX *ssx)
{ int m = ssx->m;
int n = ssx->n;
int *A_ptr = ssx->A_ptr;
int *A_ind = ssx->A_ind;
mpq_t *A_val = ssx->A_val;
int *Q_col = ssx->Q_col;
int q = ssx->q;
mpq_t *aq = ssx->aq;
int i, k, ptr;
xassert(1 <= q && q <= n);
/* aq := 0 */
for (i = 1; i <= m; i++) mpq_set_si(aq[i], 0, 1);
/* aq := N[q] */
k = Q_col[m+q]; /* x[k] = xN[q] */
if (k <= m)
{ /* N[q] is a column of the unity matrix I */
mpq_set_si(aq[k], 1, 1);
}
else
{ /* N[q] is a column of the original constraint matrix -A */
for (ptr = A_ptr[k-m]; ptr < A_ptr[k-m+1]; ptr++)
mpq_neg(aq[A_ind[ptr]], A_val[ptr]);
}
/* aq := inv(B) * aq */
bfx_ftran(ssx->binv, aq, 1);
/* aq := - aq */
for (i = 1; i <= m; i++) mpq_neg(aq[i], aq[i]);
return;
}
game_t *game_new(int graph_type, int g_p1, int g_p2, mpq_t p_c)
{
game_t *game = (game_t *)g_malloc(sizeof(game_t));
game->graph = graph_new(graph_type, g_p1, g_p2);
mpq_init(game->s);
mpq_set_si(game->s, S_MIN, 1);
mpq_init(game->t);
mpq_set_si(game->t, T_MIN, 1);
mpq_init(game->p_c);
mpq_set(game->p_c, p_c);
game->initial_config = (int *)g_malloc(sizeof(int) * game->graph->n);
game->current_config = (int *)g_malloc(sizeof(int) * game->graph->n);
game->next_config = (int *)g_malloc(sizeof(int) * game->graph->n);
int i;
for(i = 0; i < game->graph->n; ++i)
{
game->initial_config[i] = 0;
game->current_config[i] = 0;
game->next_config[i] = 0;
}
return game;
}
void game_get_alpha(game_t *game, mpq_t alpha)
{
mpq_t max_t_1;
mpq_t min_s_0;
mpq_init(max_t_1);
mpq_init(min_s_0);
//MAX(game->t, 1)
if(mpq_cmp_si(game->t, 1, 1) > 0)
{
mpq_set(max_t_1, game->t);
}
else
{
mpq_set_si(max_t_1, 1, 1);
}
//MIN(game->s, 0)
if(mpq_cmp_si(game->s, 0, 1) < 0)
{
mpq_set(min_s_0, game->s);
}
else
{
mpq_set_si(min_s_0, 0, 1);
}
//return MAX(game->t, 1) - MIN(game->s, 0);
mpq_sub(alpha, max_t_1, min_s_0);
mpq_clear(max_t_1);
mpq_clear(min_s_0);
}
void bisect_sfdlProverExo::exogenous_fAtMidpt(mpq_t& f, mpq_t* a, mpq_t* b) {
mpq_t t2;
mpq_t t3;
alloc_init_scalar(t2);
alloc_init_scalar(t3);
mpq_set_ui(f, 0, 1);
int m = bisect_sfdl_cons::m;
int rctr = 0;
for(int i = 0; i < m; i++) {
mpq_add(t2, a[i], b[i]);
mpq_set_si(t3, bisect_sfdl_cons::fAtMidpt_FUNCTION_STATIC_RANDOM_INT[rctr++], 1);
mpq_mul(t2, t3, t2);
mpq_div_2exp(t2, t2, 1);
mpq_add(f, f, t2);
}
for(int i = 0; i < m; i++) {
for(int j = 0; j < m; j++) {
mpq_add(t2, a[i], b[i]);
mpq_add(t3, a[j], b[j]);
mpq_mul(t2, t2, t3);
mpq_set_si(t3, bisect_sfdl_cons::fAtMidpt_FUNCTION_STATIC_RANDOM_INT[rctr++], 1);
mpq_mul(t2, t2, t3);
mpq_div_2exp(t2, t2, 2);
mpq_add(f, f, t2);
}
}
mpq_clear(t2);
mpq_clear(t3);
}
void tollingProverExo::baseline(const mpq_t* input_q, int num_inputs,
mpq_t* output_recomputed, int num_outputs) {
struct In input;
struct Out output;
// Fill code here to prepare input from input_q.
int inp = 0;
for(int i = 0; i < NUM_CK_BITS/8; i++) {
input.commitmentCK.bit[i] = mpz_get_ui(mpq_numref(input_q[inp++]));
}
for(int i = 0; i < NUM_COMMITMENT_CHUNKS; i++) {
input.commitment.bit[i] = mpz_get_ui(mpq_numref(input_q[inp++]));
}
for(int i = 0; i < tolling_cons::MAX_SPOTCHECKS; i++) {
tuple_t* tuple = &input.verifier_in.spotchecks[i];
tuple->time = mpz_get_si(mpq_numref(input_q[inp++]));
tuple->toll_booth_id = mpz_get_ui(mpq_numref(input_q[inp++]));
tuple->toll = mpz_get_ui(mpq_numref(input_q[inp++]));
}
input.verifier_in.time_threshold = mpz_get_si(mpq_numref(input_q[inp++]));
// Do the computation
compute(&input, &output);
// Fill code here to dump output to output_recomputed.
mpq_set_si(output_recomputed[0], 0, 1);
mpq_set_si(output_recomputed[1], output.rejected, 1);
mpq_set_ui(output_recomputed[2], output.cost, 1);
}
void game_get_payoff_of_player(game_t *game, int i, mpq_t payoff)
{
GSList *list = graph_get_neighbours_of(game->graph, i);
int n = g_slist_length(list) + 1;
int delta = game_get_number_of_cooperators_in_list(game, list);
delta += game->current_config[i];
//printf("n= %d, d= %d", n, delta);
mpq_t tmp;
mpq_init(tmp);
//double payoff = 0;
if(game->current_config[i] == COOPERATE)
{
//int pay = (delta - 1) + ((n - delta) * -1);
//printf("pay = %d", pay);
//payoff = (delta - 1) + (n - delta) * game->s;
mpq_set_si(tmp, (n - delta), 1);
mpq_mul(tmp, game->s, tmp);
mpq_set(payoff, tmp);
mpq_set_si(tmp, (delta - 1), 1);
mpq_add(payoff, tmp, payoff);
}
else
{
//payoff = delta * game->t;
mpq_set_si(tmp, delta, 1);
mpq_mul(payoff, tmp, game->t);
}
mpq_clear(tmp);
}
void tree_dbProverExo::baseline(const mpq_t* input_q, int num_inputs,
mpq_t* output_recomputed, int num_outputs) {
struct In input;
struct Out output;
for(int i = 0; i < num_inputs; i++) {
input.hash.bit[i] = mpz_get_ui(mpq_numref(input_q[i]));
}
compute(&input, &output);
mpq_set_si(output_recomputed[0], 0, 1);
mpq_set_si(output_recomputed[1], output.rows, 1);
for (int i = 0; i < 3; i++) {
mpq_set_ui(output_recomputed[2 + i * 10 + 0], output.result[i].KEY, 1);
mpq_set_ui(output_recomputed[2 + i * 10 + 1], output.result[i].FName, 1);
mpq_set_ui(output_recomputed[2 + i * 10 + 2], output.result[i].LName, 1);
mpq_set_ui(output_recomputed[2 + i * 10 + 3], output.result[i].Age, 1);
mpq_set_ui(output_recomputed[2 + i * 10 + 4], output.result[i].Major, 1);
mpq_set_ui(output_recomputed[2 + i * 10 + 5], output.result[i].State, 1);
mpq_set_ui(output_recomputed[2 + i * 10 + 6], output.result[i].PhoneNum, 1);
mpq_set_ui(output_recomputed[2 + i * 10 + 7], output.result[i].Class, 1);
mpq_set_ui(output_recomputed[2 + i * 10 + 8], output.result[i].Credits, 1);
mpq_set_ui(output_recomputed[2 + i * 10 + 9], output.result[i].Average, 1);
}
}
void
ovm_q_mul(oregister_t *l, oregister_t *r)
{
switch (r->t) {
case t_void:
l->t = t_word;
l->v.w = 0;
break;
case t_word:
mpq_set_si(oqr(r), r->v.w, 1);
mpq_mul(oqr(l), oqr(l), oqr(r));
check_mpq(l);
break;
case t_float:
l->t = t_float;
l->v.d = mpq_get_d(oqr(l)) * r->v.d;
break;
case t_mpz:
mpz_set_ui(ozs(r), 1);
mpq_mul(oqr(l), oqr(l), oqr(r));
check_mpq(l);
break;
case t_rat:
mpq_set_si(oqr(r), rat_num(r->v.r), rat_den(r->v.r));
mpq_mul(oqr(l), oqr(l), oqr(r));
check_mpq(l);
break;
case t_mpq:
mpq_mul(oqr(l), oqr(l), oqr(r));
check_mpq(l);
break;
case t_mpr:
l->t = t_mpr;
mpfr_set_q(orr(l), oqr(l), thr_rnd);
mpfr_mul(orr(l), orr(l), orr(r), thr_rnd);
break;
case t_cdd:
l->t = t_cdd;
l->v.dd = mpq_get_d(oqr(l)) * r->v.dd;
check_cdd(l);
break;
case t_cqq:
l->t = t_cqq;
mpq_set_ui(oqi(l), 0, 1);
cqq_mul(oqq(l), oqq(l), oqq(r));
check_cqq(l);
break;
case t_mpc:
l->t = t_mpc;
mpc_set_q(occ(l), oqr(l), thr_rndc);
mpc_mul(occ(l), occ(l), occ(r), thr_rndc);
check_mpc(l);
break;
default:
ovm_raise(except_not_a_number);
}
}
static void from_double(mpq_t n, double f, int level)
{
double fa;
int nfa;
mpq_t ni, nn;
bool neg;
//fprintf(stderr, "from_double: %.14g\n", f);
if (level >= 10)
goto __DEFAULT;
fa = fabs(f);
if (fa >= 1E8 || fa <= 1E-8)
goto __DEFAULT;
neg = (f < 0);
nfa = (int)fa;
if (nfa >= 1)
fa -= nfa;
//fprintf(stderr, "fa = %.14g %.14g\n", fa, (fa*1E8) - (int)(fa*1E8));
if (nfa && fa < 1E-8)
{
mpq_set_si(n, 0, 1);
}
else if (((fa*1E8) - (int)(fa*1E8)) < 1E-8)
{
mpq_set_si(n, (int)(fa*1E8), 100000000);
}
else
{
mpq_init(ni);
from_double(ni, 1 / fa, level + 1);
mpq_inv(n, ni);
mpq_clear(ni);
}
mpq_init(nn);
mpq_set_si(nn, nfa, 1);
mpq_add(n, n, nn);
mpq_clear(nn);
if (neg)
mpq_neg(n, n);
mpq_canonicalize(n);
return;
__DEFAULT:
mpq_set_d(n, f);
}
void ssx_eval_rho(SSX *ssx)
{ int m = ssx->m;
int p = ssx->p;
mpq_t *rho = ssx->rho;
int i;
xassert(1 <= p && p <= m);
/* rho := 0 */
for (i = 1; i <= m; i++) mpq_set_si(rho[i], 0, 1);
/* rho := e[p] */
mpq_set_si(rho[p], 1, 1);
/* rho := inv(B') * rho */
bfx_btran(ssx->binv, rho);
return;
}
static void
check_nan_inf_mpq (void)
{
mpfr_t mpfr_value, mpfr_cmp;
mpq_t mpq_value;
int status;
mpfr_init2 (mpfr_value, MPFR_PREC_MIN);
mpq_init (mpq_value);
mpq_set_si (mpq_value, 0, 0);
mpz_set_si (mpq_denref (mpq_value), 0);
status = mpfr_set_q (mpfr_value, mpq_value, MPFR_RNDN);
if ((status != 0) || (!MPFR_IS_NAN (mpfr_value)))
{
mpfr_init2 (mpfr_cmp, MPFR_PREC_MIN);
mpfr_set_nan (mpfr_cmp);
printf ("mpfr_set_q with a NAN mpq value returned a wrong value :\n"
" waiting for ");
mpfr_print_binary (mpfr_cmp);
printf (" got ");
mpfr_print_binary (mpfr_value);
printf ("\n trinary value is %d\n", status);
exit (1);
}
mpq_set_si (mpq_value, -1, 0);
mpz_set_si (mpq_denref (mpq_value), 0);
status = mpfr_set_q (mpfr_value, mpq_value, MPFR_RNDN);
if ((status != 0) || (!MPFR_IS_INF (mpfr_value)) ||
(MPFR_SIGN(mpfr_value) != mpq_sgn(mpq_value)))
{
mpfr_init2 (mpfr_cmp, MPFR_PREC_MIN);
mpfr_set_inf (mpfr_cmp, -1);
printf ("mpfr_set_q with a -INF mpq value returned a wrong value :\n"
" waiting for ");
mpfr_print_binary (mpfr_cmp);
printf (" got ");
mpfr_print_binary (mpfr_value);
printf ("\n trinary value is %d\n", status);
exit (1);
}
mpq_clear (mpq_value);
mpfr_clear (mpfr_value);
}
END_TEST
START_TEST (rational_matrix_creation)
{
int degree = 6;
int size = 14;
int i, j, k;
mps_context * ctx = mps_context_new ();
mps_monomial_matrix_poly *mp = mps_monomial_matrix_poly_new (ctx, 6, 14, false);
/* Set the coefficients in the matrices */
for (k = 0; k <= degree; k++)
{
mpq_t *mr, *mi;
mr = mps_newv (mpq_t, size * size);
mi = mps_newv (mpq_t, size * size);
mpq_vinit (mr, size * size);
mpq_vinit (mi, size * size);
for (i = 0; i < size; i++)
{
for (j = 0; j < size; j++)
{
mpq_set_si (MPS_MATRIX_ELEM (mr, i, j, size),
i - j, i + j + 1);
mpq_canonicalize (MPS_MATRIX_ELEM (mr, i, j, size));
mpq_set_si (MPS_MATRIX_ELEM (mi, i, j, size),
2 * i + 3 * j + 5, i + 2 * j + 1);
mpq_canonicalize (MPS_MATRIX_ELEM (mi, i, j, size));
}
}
mps_monomial_matrix_poly_set_coefficient_q (ctx, mp, k, mr, mi);
mpq_vclear (mr, size * size);
mpq_vclear (mi, size * size);
free (mr);
free (mi);
}
mps_monomial_matrix_poly_free (ctx, MPS_POLYNOMIAL (mp));
mps_context_free (ctx);
}
static void
coverage_mpfr_mul_q_20110218 (void)
{
mpfr_t cmp, res, op1;
mpq_t op2;
int status;
mpfr_init2 (cmp, MPFR_PREC_MIN);
mpfr_init2 (res, MPFR_PREC_MIN);
mpfr_init_set_si (op1, 1, MPFR_RNDN);
mpq_init (op2);
mpq_set_si (op2, 0, 0);
mpz_set_si (mpq_denref (op2), 0);
status = mpfr_mul_q (res, op1, op2, MPFR_RNDN);
if ((status != 0) || (mpfr_cmp (cmp, res) != 0))
{
printf ("Results differ %d.\nres=", status);
mpfr_print_binary (res);
printf ("\ncmp=");
mpfr_print_binary (cmp);
putchar ('\n');
exit (1);
}
mpfr_set_si (op1, 1, MPFR_RNDN);
mpq_set_si (op2, -1, 0);
status = mpfr_mul_q (res, op1, op2, MPFR_RNDN);
mpfr_set_inf (cmp, -1);
if ((status != 0) || (mpfr_cmp(res, cmp) != 0))
{
printf ("mpfr_mul_q 1 * (-1/0) returned a wrong value :\n waiting for ");
mpfr_print_binary (cmp);
printf (" got ");
mpfr_print_binary (res);
printf ("\n trinary value is %d\n", status);
exit (1);
}
mpq_clear (op2);
mpfr_clear (op1);
mpfr_clear (res);
mpfr_clear (cmp);
}
ring_elem QQ::from_int(int n) const
{
gmp_QQ result = QQ::new_elem();
mpq_set_si(result, n, 1);
return MPQ_RINGELEM(result);
}
void ssx_eval_row(SSX *ssx)
{ int m = ssx->m;
int n = ssx->n;
int *A_ptr = ssx->A_ptr;
int *A_ind = ssx->A_ind;
mpq_t *A_val = ssx->A_val;
int *Q_col = ssx->Q_col;
mpq_t *rho = ssx->rho;
mpq_t *ap = ssx->ap;
int j, k, ptr;
mpq_t temp;
mpq_init(temp);
for (j = 1; j <= n; j++)
{ /* ap[j] := - N'[j] * rho (inner product) */
k = Q_col[m+j]; /* x[k] = xN[j] */
if (k <= m)
mpq_neg(ap[j], rho[k]);
else
{ mpq_set_si(ap[j], 0, 1);
for (ptr = A_ptr[k-m]; ptr < A_ptr[k-m+1]; ptr++)
{ mpq_mul(temp, A_val[ptr], rho[A_ind[ptr]]);
mpq_add(ap[j], ap[j], temp);
}
}
}
mpq_clear(temp);
return;
}
void ssx_get_xNj(SSX *ssx, int j, mpq_t x)
{ int m = ssx->m;
int n = ssx->n;
mpq_t *lb = ssx->lb;
mpq_t *ub = ssx->ub;
int *stat = ssx->stat;
int *Q_col = ssx->Q_col;
int k;
xassert(1 <= j && j <= n);
k = Q_col[m+j]; /* x[k] = xN[j] */
xassert(1 <= k && k <= m+n);
switch (stat[k])
{ case SSX_NL:
/* xN[j] is on its lower bound */
mpq_set(x, lb[k]); break;
case SSX_NU:
/* xN[j] is on its upper bound */
mpq_set(x, ub[k]); break;
case SSX_NF:
/* xN[j] is free variable */
mpq_set_si(x, 0, 1); break;
case SSX_NS:
/* xN[j] is fixed variable */
mpq_set(x, lb[k]); break;
default:
xassert(stat != stat);
}
return;
}
ring_elem QQ::power(const ring_elem f, int n) const
{
gmp_QQ result = QQ::new_elem();
if (n > 0)
{
mpz_pow_ui(mpq_numref(result), mpq_numref(MPQ_VAL(f)), n);
mpz_pow_ui(mpq_denref(result), mpq_denref(MPQ_VAL(f)), n);
}
else if (n < 0)
{
mpz_pow_ui(mpq_numref(result), mpq_denref(MPQ_VAL(f)), -n);
mpz_pow_ui(mpq_denref(result), mpq_numref(MPQ_VAL(f)), -n);
if (mpz_sgn(mpq_denref(result)) < 0)
{
mpz_neg(mpq_numref(result), mpq_numref(result));
mpz_neg(mpq_denref(result), mpq_denref(result));
}
else if (mpz_sgn(mpq_denref(result)) == 0)
{
ERROR("attempted to divide by zero");
mpz_set_si(mpq_denref(result), 1);
}
}
else
mpq_set_si(result, 1, 1);
return MPQ_RINGELEM(result);
}
void
ovm_q_le(oregister_t *l, oregister_t *r)
{
l->t = t_word;
switch (r->t) {
case t_void:
l->v.w = mpq_sgn(oqr(l)) <= 0;
break;
case t_word:
l->v.w = mpq_cmp_si(oqr(l), r->v.w, 1) <= 0;
break;
case t_float:
l->v.w = mpq_get_d(oqr(l)) <= r->v.d;
break;
case t_mpz:
mpq_set_z(oqr(r), ozr(r));
l->v.w = mpq_cmp(oqr(l), oqr(r)) <= 0;
break;
case t_rat:
mpq_set_si(oqr(r), rat_num(r->v.r), rat_den(r->v.r));
l->v.w = mpq_cmp(oqr(l), oqr(r)) <= 0;
break;
case t_mpq:
l->v.w = mpq_cmp(oqr(l), oqr(r)) <= 0;
break;
case t_mpr:
mpfr_set_z(orr(l), ozr(l), thr_rnd);
l->v.w = mpfr_lessequal_p(orr(l), orr(r));
break;
default:
ovm_raise(except_not_a_real_number);
}
}
static int basis_col(void *info, int j, int ind[], mpq_t val[])
{ /* this auxiliary routine provides row indices and numeric values
of non-zero elements in j-th column of the matrix B */
SSX *ssx = info;
int m = ssx->m;
int n = ssx->n;
int *A_ptr = ssx->A_ptr;
int *A_ind = ssx->A_ind;
mpq_t *A_val = ssx->A_val;
int *Q_col = ssx->Q_col;
int k, len, ptr;
xassert(1 <= j && j <= m);
k = Q_col[j]; /* x[k] = xB[j] */
xassert(1 <= k && k <= m+n);
/* j-th column of the matrix B is k-th column of the augmented
constraint matrix (I | -A) */
if (k <= m)
{ /* it is a column of the unity matrix I */
len = 1, ind[1] = k, mpq_set_si(val[1], 1, 1);
}
else
{ /* it is a column of the original constraint matrix -A */
len = 0;
for (ptr = A_ptr[k-m]; ptr < A_ptr[k-m+1]; ptr++)
{ len++;
ind[len] = A_ind[ptr];
mpq_neg(val[len], A_val[ptr]);
}
}
return len;
}
LUX *lux_create(int n)
{ LUX *lux;
int k;
if (n < 1)
xfault("lux_create: n = %d; invalid parameter\n", n);
lux = xmalloc(sizeof(LUX));
lux->n = n;
lux->pool = dmp_create_poolx(sizeof(LUXELM));
lux->F_row = xcalloc(1+n, sizeof(LUXELM *));
lux->F_col = xcalloc(1+n, sizeof(LUXELM *));
lux->V_piv = xcalloc(1+n, sizeof(mpq_t));
lux->V_row = xcalloc(1+n, sizeof(LUXELM *));
lux->V_col = xcalloc(1+n, sizeof(LUXELM *));
lux->P_row = xcalloc(1+n, sizeof(int));
lux->P_col = xcalloc(1+n, sizeof(int));
lux->Q_row = xcalloc(1+n, sizeof(int));
lux->Q_col = xcalloc(1+n, sizeof(int));
for (k = 1; k <= n; k++)
{ lux->F_row[k] = lux->F_col[k] = NULL;
mpq_init(lux->V_piv[k]);
mpq_set_si(lux->V_piv[k], 1, 1);
lux->V_row[k] = lux->V_col[k] = NULL;
lux->P_row[k] = lux->P_col[k] = k;
lux->Q_row[k] = lux->Q_col[k] = k;
}
lux->rank = n;
return lux;
}
std::istream &Rationals::read (std::istream &is, Element &x) const
{
char buffer[65535], endc;
bool found_space = false;
int i = 0;
do {
is.get (endc);
} while (is && !isdigit (endc) && endc != '-' && endc != '.' && endc !='e' && endc != 'E');
buffer[i]=endc;
while ((buffer[i] == '-' || isdigit (buffer[i])) && i < 65535) {
i++;
is.get (buffer[i]);
}
endc = buffer[i];
buffer[i] = '\0';
if (i > 0)
mpz_set_str (mpq_numref (x.rep), buffer, 10);
else
mpq_set_si (x.rep, 0L, 1L);
if (endc == ' ') {
found_space = true;
while (endc == ' ') is >> endc;
}
static void
check0 (void)
{
mpq_t y;
mpfr_t x;
int inexact;
int r;
/* Check for +0 */
mpfr_init (x);
mpq_init (y);
mpq_set_si (y, 0, 1);
for (r = 0; r < MPFR_RND_MAX; r++)
{
mpfr_clear_flags ();
inexact = mpfr_set_q (x, y, (mpfr_rnd_t) r);
if (!MPFR_IS_ZERO(x) || !MPFR_IS_POS(x) || inexact ||
__gmpfr_flags != 0)
{
printf("mpfr_set_q(x,0) failed for %s\n",
mpfr_print_rnd_mode ((mpfr_rnd_t) r));
exit(1);
}
}
mpfr_clear (x);
mpq_clear (y);
}
int
main (int argc, char **argv)
{
mpfr_t x, y;
mpq_t a, b;
mpfi_t i;
mpq_init (a);
mpq_init (b);
mpfi_init2 (i, 53);
mpfr_init2 (x, 53);
mpfr_init2 (y, 53);
mpq_set_si (a, -1, 3);
mpq_set_ui (b, +1, 1024);
mpfr_set_q (x, a, MPFI_RNDD);
mpfr_set_q (y, b, MPFI_RNDU);
check (i, a, b, x, y, MPFI_FLAGS_LEFT_ENDPOINT_INEXACT);
check (i, b, a, x, y, MPFI_FLAGS_LEFT_ENDPOINT_INEXACT);
check (i, b, b, y, y, MPFI_FLAGS_BOTH_ENDPOINTS_EXACT);
mpfr_set_q (y, a, MPFI_RNDU);
check (i, a, a, x, y, MPFI_FLAGS_BOTH_ENDPOINTS_INEXACT);
mpq_clear (a);
mpq_clear (b);
mpfi_clear (i);
mpfr_clear (x);
mpfr_clear (y);
return 0;
}
void ssx_eval_bbar(SSX *ssx)
{ int m = ssx->m;
int n = ssx->n;
mpq_t *coef = ssx->coef;
int *A_ptr = ssx->A_ptr;
int *A_ind = ssx->A_ind;
mpq_t *A_val = ssx->A_val;
int *Q_col = ssx->Q_col;
mpq_t *bbar = ssx->bbar;
int i, j, k, ptr;
mpq_t x, temp;
mpq_init(x);
mpq_init(temp);
/* bbar := 0 */
for (i = 1; i <= m; i++)
mpq_set_si(bbar[i], 0, 1);
/* bbar := - N * xN = - N[1] * xN[1] - ... - N[n] * xN[n] */
for (j = 1; j <= n; j++)
{ ssx_get_xNj(ssx, j, x);
if (mpq_sgn(x) == 0) continue;
k = Q_col[m+j]; /* x[k] = xN[j] */
if (k <= m)
{ /* N[j] is a column of the unity matrix I */
mpq_sub(bbar[k], bbar[k], x);
}
else
{ /* N[j] is a column of the original constraint matrix -A */
for (ptr = A_ptr[k-m]; ptr < A_ptr[k-m+1]; ptr++)
{ mpq_mul(temp, A_val[ptr], x);
mpq_add(bbar[A_ind[ptr]], bbar[A_ind[ptr]], temp);
}
}
}
/* bbar := inv(B) * bbar */
bfx_ftran(ssx->binv, bbar, 0);
#if 1
/* compute value of the objective function */
/* bbar[0] := c[0] */
mpq_set(bbar[0], coef[0]);
/* bbar[0] := bbar[0] + sum{i in B} cB[i] * xB[i] */
for (i = 1; i <= m; i++)
{ k = Q_col[i]; /* x[k] = xB[i] */
if (mpq_sgn(coef[k]) == 0) continue;
mpq_mul(temp, coef[k], bbar[i]);
mpq_add(bbar[0], bbar[0], temp);
}
/* bbar[0] := bbar[0] + sum{j in N} cN[j] * xN[j] */
for (j = 1; j <= n; j++)
{ k = Q_col[m+j]; /* x[k] = xN[j] */
if (mpq_sgn(coef[k]) == 0) continue;
ssx_get_xNj(ssx, j, x);
mpq_mul(temp, coef[k], x);
mpq_add(bbar[0], bbar[0], temp);
}
#endif
mpq_clear(x);
mpq_clear(temp);
return;
}
AB_VALUE *AB_Value_fromInt(long int num, long int denom) {
AB_VALUE *v;
v=AB_Value_new();
mpq_set_si(v->value, num, denom);
return v;
}
static void
check (long int n, long int d, mpfr_rnd_t rnd, const char *ys)
{
mpq_t q;
mpfr_t x, t;
int inexact, compare;
unsigned int flags, ex_flags;
mpfr_init2 (x, 53);
mpfr_init2 (t, mpfr_get_prec (x) + mp_bits_per_limb);
mpq_init (q);
mpq_set_si (q, n, d);
mpfr_clear_flags ();
inexact = mpfr_set_q (x, q, rnd);
flags = __gmpfr_flags;
/* check values */
if (mpfr_cmp_str1 (x, ys))
{
printf ("Error for q = %ld/%ld and rnd = %s\n", n, d,
mpfr_print_rnd_mode (rnd));
printf ("correct result is %s, mpfr_set_q gives ", ys);
mpfr_out_str (stdout, 10, 0, x, MPFR_RNDN);
putchar ('\n');
exit (1);
}
/* check inexact flag */
if (mpfr_mul_ui (t, x, (d < 0) ? (-d) : d, rnd))
{
printf ("t <- x * d should be exact\n");
exit (1);
}
compare = mpfr_cmp_si (t, n);
if (! SAME_SIGN (inexact, compare))
{
printf ("Wrong ternary value for q = %ld/%ld and rnd = %s:\n"
"expected %d or equivalent, got %d\n",
n, d, mpfr_print_rnd_mode (rnd), compare, inexact);
exit (1);
}
ex_flags = compare == 0 ? 0 : MPFR_FLAGS_INEXACT;
if (flags != ex_flags)
{
printf ("Wrong flags for q = %ld/%ld and rnd = %s:\n",
n, d, mpfr_print_rnd_mode (rnd));
printf ("Expected flags:");
flags_out (ex_flags);
printf ("Got flags: ");
flags_out (flags);
exit (1);
}
mpfr_clear (x);
mpfr_clear (t);
mpq_clear (q);
}
Rational::Rational(const int precision, const int num)
{
mpq_init(number);
mpq_set_si(number, num, 1);
#ifdef TRACE_OUTPUT
UpdateNumberStr();
#endif
}
gint random_integer_with_probability(mpq_t *p, gint n)
{
mpz_t *den;
den = (mpz_t *)g_malloc(sizeof(mpz_t) * n);
int i;
for(i = 0; i < n; ++i)
{
mpz_init(den[i]);
mpq_get_den(den[i], p[i]);
}
mpz_t l;
mpz_init(l);
lcm(l, den, n);
mpq_t nlcm;
mpq_init(nlcm);
mpq_set_z(nlcm, l);
int lc = mpz_get_ui(l);
gint x = g_random_int_range(0, lc);
mpq_t y;
mpq_init(y);
mpq_set_si(y, x, 1);
mpq_t p_i;
mpq_init(p_i);
int j = n - 1;
for(i = 0; i < n - 1; i++)
{
mpq_mul(p_i, nlcm, p[i]);
if(mpq_cmp(y, p_i) < 0)
{
j = i;
break;
}
mpq_sub(y, y, p_i);
}
for(i = 0; i < n; ++i)
{
mpz_clear(den[i]);
}
g_free(den);
mpz_clear(l);
mpq_clear(nlcm);
mpq_clear(y);
mpq_clear(p_i);
return j;
}
void game_compute_p_i(game_t *game, int i, int j, mpq_t p_i)
{
mpq_t payoff_i;
mpq_t payoff_j;
mpq_t alpha;
mpq_t tmp;
mpq_t tmp2;
mpq_init(payoff_i);
mpq_init(payoff_j);
mpq_init(alpha);
mpq_init(tmp);
mpq_init(tmp2);
game_get_payoff_of_player(game, i, payoff_i);
game_get_payoff_of_player(game, j, payoff_j);
game_get_alpha(game, alpha);
int n_i = graph_number_of_neighbours_of(game->graph, i);
int n_j = graph_number_of_neighbours_of(game->graph, j);
int m = MAX(n_i, n_j);
mpq_sub(tmp, payoff_j, payoff_i);
//gmp_printf(" %Qd - %Qd = %Qd", payoff_j, payoff_i,tmp);
//max(P_j - P_i, 0)
if(mpq_cmp_si(tmp, 0, 1) < 0)
{
mpq_set_si(tmp, 0, 1);
}
mpq_set_si(tmp2, m, 1);
mpq_mul(tmp2, tmp2, alpha);
mpq_div(p_i, tmp, tmp2);
mpq_clear(payoff_i);
mpq_clear(payoff_j);
mpq_clear(alpha);
mpq_clear(tmp);
mpq_clear(tmp2);
}
void w3j(mpf_t w, long j1, long j2, long j3, long m1, long m2, long m3)
{
mpq_t delta_sq,r;
mpz_t i;
mpf_t h;
mpq_init(delta_sq);
mpq_init(r);
mpz_init(i);
mpf_init(h);
mpq_set_si(r,0,1);
if(m1+m2+m3!=0) return;
if((iabs(m1)>j1) || (iabs(m2)>j2) || (iabs(m3)>j3)) return;
if((j3<iabs(j1-j2)) || ((j1+j2)<j3)) return;
w3j_Delta_sq(delta_sq, j1, j2, j3);
w3j_intterm(i, j1, j2, j3, m1, m2, m3);
if(iabs(j1-j2-m3)%2 == 1) mpz_neg(i,i);
w3j_sqrt_sq(r, j1, j2, j3, m1, m2, m3);
mpq_mul(r,r,delta_sq);
mpf_set_q(w,r);
mpf_sqrt(w,w);
mpf_set_z(h,i);
mpf_mul(w,w,h);
mpf_clear(h);
mpz_clear(i);
mpq_clear(r);
mpq_clear(delta_sq);
}
