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); }