static PyObject *
GMPy_Rational_Sub(PyObject *x, PyObject *y, CTXT_Object *context)
{
MPQ_Object *result;
if (!(result = GMPy_MPQ_New(context)))
return NULL;
if (MPQ_Check(x) && MPQ_Check(y)) {
mpq_sub(result->q, MPQ(x), MPQ(y));
return (PyObject*)result;
}
if (IS_RATIONAL(x) && IS_RATIONAL(y)) {
MPQ_Object *tempx, *tempy;
tempx = GMPy_MPQ_From_Rational(x, context);
tempy = GMPy_MPQ_From_Rational(y, context);
if (!tempx || !tempy) {
Py_XDECREF((PyObject*)tempx);
Py_XDECREF((PyObject*)tempy);
Py_DECREF((PyObject*)result);
return NULL;
}
mpq_sub(result->q, tempx->q, tempy->q);
Py_DECREF((PyObject*)tempx);
Py_DECREF((PyObject*)tempy);
return (PyObject*)result;
}
Py_DECREF((PyObject*)result);
Py_RETURN_NOTIMPLEMENTED;
}
void
ovm_q_sub(oregister_t *l, oregister_t *r)
{
switch (r->t) {
case t_void:
break;
case t_word:
mpq_set_si(oqr(r), r->v.w, 1);
mpq_sub(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_sub(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_sub(oqr(l), oqr(l), oqr(r));
check_mpq(l);
break;
case t_mpq:
mpq_sub(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_sub(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;
break;
case t_cqq:
l->t = t_cqq;
mpq_set_ui(oqi(l), 0, 1);
cqq_sub(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_sub(occ(l), occ(l), occ(r), thr_rndc);
break;
default:
ovm_raise(except_not_a_number);
}
}
/*lint -e{818} supress "Pointer parameter 'var' could be declared as pointing to const" */
static void remove_fixed_var(
Lps* lp,
Var* var,
int verbose_level)
{
Nzo* nzo;
mpq_t x;
mpq_t temp;
Bool is_zero;
assert(lp != NULL);
assert(var != NULL);
assert(var->type == VAR_FIXED && mpq_equal(var->lower, var->upper));
if (verbose_level > 0)
printf("Removing variable %s fixed to %g\n", var->name, mpq_get_d(var->lower));
mpq_init(x);
mpq_init(temp);
is_zero = mpq_equal(var->lower, x /* zero */);
while(var->first != NULL)
{
nzo = var->first;
/* Do we have to ajust the lhs/rhs ?
*/
if (!is_zero)
{
mpq_mul(x, var->lower, nzo->value);
/* do we have a valid rhs ?
*/
if (HAS_RHS(nzo->con))
{
mpq_sub(temp, nzo->con->rhs, x);
lps_setrhs(nzo->con, temp);
}
/* do we have a valid lhs ?
*/
if (HAS_LHS(nzo->con))
{
mpq_sub(temp, nzo->con->lhs, x);
lps_setlhs(nzo->con, temp);
}
}
lps_delnzo(lp, nzo);
}
mpq_clear(temp);
mpq_clear(x);
}
Eval prim_minus(Expr args) {
Expr init = take_typed(&args, NUMBER), diff = typed(NUMBER);
mpq_init(diff.num);
Expr s = sum(args);
mpq_sub(diff.num, init.num, s.num);
return final_eval(diff);
}
AlkValue AlkValue::operator-(const AlkValue &right) const
{
AlkValue result;
mpq_sub(result.d->m_val.get_mpq_t(), d->m_val.get_mpq_t(), right.d->m_val.get_mpq_t());
result.d->m_val.canonicalize();
return result;
}
void subtract_multiple(ElementType& result, const ElementType& a, const ElementType& b) const {
mpq_t tmp;
mpq_init(tmp);
mpq_mul(tmp, &a, &b);
mpq_sub(&result, &result, tmp);
mpq_clear(tmp);
}
void
check_all (mpq_ptr x, mpq_ptr y, mpq_ptr want_add, mpq_ptr want_sub)
{
mpq_t got;
int neg_x, neg_y, swap;
mpq_init (got);
MPQ_CHECK_FORMAT (want_add);
MPQ_CHECK_FORMAT (want_sub);
MPQ_CHECK_FORMAT (x);
MPQ_CHECK_FORMAT (y);
for (swap = 0; swap <= 1; swap++)
{
for (neg_x = 0; neg_x <= 1; neg_x++)
{
for (neg_y = 0; neg_y <= 1; neg_y++)
{
mpq_add (got, x, y);
MPQ_CHECK_FORMAT (got);
if (! mpq_equal (got, want_add))
{
printf ("mpq_add wrong\n");
mpq_trace (" x ", x);
mpq_trace (" y ", y);
mpq_trace (" got ", got);
mpq_trace (" want", want_add);
abort ();
}
mpq_sub (got, x, y);
MPQ_CHECK_FORMAT (got);
if (! mpq_equal (got, want_sub))
{
printf ("mpq_sub wrong\n");
mpq_trace (" x ", x);
mpq_trace (" y ", y);
mpq_trace (" got ", got);
mpq_trace (" want", want_sub);
abort ();
}
mpq_neg (y, y);
mpq_swap (want_add, want_sub);
}
mpq_neg (x, x);
mpq_swap (want_add, want_sub);
mpq_neg (want_add, want_add);
mpq_neg (want_sub, want_sub);
}
mpq_swap (x, y);
mpq_neg (want_sub, want_sub);
}
mpq_clear (got);
}
void ssx_update_cbar(SSX *ssx)
{ int m = ssx->m;
int n = ssx->n;
mpq_t *cbar = ssx->cbar;
int p = ssx->p;
int q = ssx->q;
mpq_t *ap = ssx->ap;
int j;
mpq_t temp;
mpq_init(temp);
xassert(1 <= p && p <= m);
xassert(1 <= q && q <= n);
/* compute d[q] in the adjacent basis */
/* d.new[q] = d[q] / alfa[p,q] */
mpq_div(cbar[q], cbar[q], ap[q]);
/* update reduced costs of other non-basic variables */
for (j = 1; j <= n; j++)
{ if (j == q) continue;
/* d.new[j] = d[j] - (alfa[p,j] / alfa[p,q]) * d[q] */
if (mpq_sgn(ap[j]) == 0) continue;
mpq_mul(temp, ap[j], cbar[q]);
mpq_sub(cbar[j], cbar[j], temp);
}
mpq_clear(temp);
return;
}
void ssx_update_pi(SSX *ssx)
{ int m = ssx->m;
int n = ssx->n;
mpq_t *pi = ssx->pi;
mpq_t *cbar = ssx->cbar;
int p = ssx->p;
int q = ssx->q;
mpq_t *aq = ssx->aq;
mpq_t *rho = ssx->rho;
int i;
mpq_t new_dq, temp;
mpq_init(new_dq);
mpq_init(temp);
xassert(1 <= p && p <= m);
xassert(1 <= q && q <= n);
/* compute d[q] in the adjacent basis */
mpq_div(new_dq, cbar[q], aq[p]);
/* update the vector of simplex multipliers */
for (i = 1; i <= m; i++)
{ if (mpq_sgn(rho[i]) == 0) continue;
mpq_mul(temp, new_dq, rho[i]);
mpq_sub(pi[i], pi[i], temp);
}
mpq_clear(new_dq);
mpq_clear(temp);
return;
}
void ssx_eval_dj(SSX *ssx, int j, mpq_t dj)
{ 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 *pi = ssx->pi;
int k, ptr, end;
mpq_t temp;
mpq_init(temp);
xassert(1 <= j && j <= n);
k = Q_col[m+j]; /* x[k] = xN[j] */
xassert(1 <= k && k <= m+n);
/* j-th column of the matrix N is k-th column of the augmented
constraint matrix (I | -A) */
if (k <= m)
{ /* it is a column of the unity matrix I */
mpq_sub(dj, coef[k], pi[k]);
}
else
{ /* it is a column of the original constraint matrix -A */
mpq_set(dj, coef[k]);
for (ptr = A_ptr[k-m], end = A_ptr[k-m+1]; ptr < end; ptr++)
{ mpq_mul(temp, A_val[ptr], pi[A_ind[ptr]]);
mpq_add(dj, dj, temp);
}
}
mpq_clear(temp);
return;
}
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 lux_v_solve(LUX *lux, int tr, mpq_t x[])
{ int n = lux->n;
mpq_t *V_piv = lux->V_piv;
LUXELM **V_row = lux->V_row;
LUXELM **V_col = lux->V_col;
int *P_row = lux->P_row;
int *Q_col = lux->Q_col;
LUXELM *vij;
int i, j, k;
mpq_t *b, temp;
b = xcalloc(1+n, sizeof(mpq_t));
for (k = 1; k <= n; k++)
mpq_init(b[k]), mpq_set(b[k], x[k]), mpq_set_si(x[k], 0, 1);
mpq_init(temp);
if (!tr)
{ /* solve the system V*x = b */
for (k = n; k >= 1; k--)
{ i = P_row[k], j = Q_col[k];
if (mpq_sgn(b[i]) != 0)
{ mpq_set(x[j], b[i]);
mpq_div(x[j], x[j], V_piv[i]);
for (vij = V_col[j]; vij != NULL; vij = vij->c_next)
{ mpq_mul(temp, vij->val, x[j]);
mpq_sub(b[vij->i], b[vij->i], temp);
}
}
}
}
else
{ /* solve the system V'*x = b */
for (k = 1; k <= n; k++)
{ i = P_row[k], j = Q_col[k];
if (mpq_sgn(b[j]) != 0)
{ mpq_set(x[i], b[j]);
mpq_div(x[i], x[i], V_piv[i]);
for (vij = V_row[i]; vij != NULL; vij = vij->r_next)
{ mpq_mul(temp, vij->val, x[i]);
mpq_sub(b[vij->j], b[vij->j], temp);
}
}
}
}
for (k = 1; k <= n; k++) mpq_clear(b[k]);
mpq_clear(temp);
xfree(b);
return;
}
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;
}
static void
dumpSkip(mpq_t *t, const symbol_t *scan)
{
static int initialized = 0;
static mpq_t dt;
static int de;
static int nu;
static mpz_t zde;
static mpz_t znu;
int rnd;
if (! initialized) {
mpq_init(dt);
mpz_init(zde);
mpz_init(znu);
initialized = 1;
}
if (mpq_equal(*t, scan->start)) {
return;
}
while (dump_tuplet_current != NO_ID) {
/* stop */
fprintf(lily_out, " }");
tuplet_pop(&dump_tuplet_current);
}
if (mpq_cmp(*t, scan->start) > 0) {
fprintf(stderr, "Uh oh -- start time ");
mpq_out_str(stderr, 10, scan->start);
fprintf(stderr, " is too low, should be ");
mpq_out_str(stderr, 10, *t);
fprintf(stderr, " -- is my voice analysis correct?\n");
return;
}
mpq_sub(dt, scan->start, *t);
mpq_get_num(znu, dt);
mpq_get_den(zde, dt);
nu = mpz_get_ui(znu);
de = mpz_get_ui(zde);
rnd = nu / de;
if (rnd != 0) {
fprintf(lily_out, " s1*%d", rnd);
nu -= rnd * de;
}
if (! is_two_pow(de)) {
fprintf(stderr, "Uh oh -- skip now already a tuplet %d/%d??\n", nu, de);
fprintf(lily_out, " s1*%d/%d", nu, de);
} else {
if (nu != 0) {
fprintf(lily_out, " s%d*%d", de, nu);
}
}
last_dumped_symbol = &sym_any_skip;
mpq_set(*t, scan->start);
VPRINTF(" skip to t = ");
VPRINT_MPQ(*t);
}
Rational operator-(const Rational& num1, const Rational& num2)
{
Rational res;
mpq_sub(res.number, num1.number, num2.number);
return res;
}
void mpq_submul(mpq_t x, mpq_t y, mpq_t z)
{
mpq_t t;
mpq_init(t);
mpq_mul(t, y, z);
mpq_sub(x, x, t);
mpq_clear(t);
}
void refine_sqrt_upper(mpq_t sqrt_x, mpq_t x, int digits)
/***************************************************************\
* USAGE: refine a rational upper bound on the sqrt(x) to the *
* requested tolerance: 10^-digits *
\***************************************************************/
{ // assume (sqrt_x)^2 >= x > 0 && sqrt_x > 0 && digits >= 0
mpq_t new_sqrt_x, beta, tol;
// initialize
mpq_init(new_sqrt_x);
mpq_init(beta);
mpq_init(tol);
// setup tol = (1/10)^digits
mpq_set_ui(tol, 1, 10);
exponentiate_mpq(tol, tol, digits);
// loop until we have refined to the tol
do
{ // compute new_sqrt_x & beta
mpq_mul(beta, sqrt_x, sqrt_x); // (sqrt_x)^2
mpq_sub(beta, beta, x); // (sqrt_x)^2 - x
mpq_add(new_sqrt_x, sqrt_x, sqrt_x); // 2*sqrt_x
mpq_div(beta, beta, new_sqrt_x); // ((sqrt_x)^2 - x)/(2*sqrt_x)
mpq_sub(new_sqrt_x, sqrt_x, beta); // sqrt_x - ((sqrt_x)^2 - x)/(2*sqrt_x)
// determine if 2*beta <= tol
mpq_add(beta, beta, beta);
if (mpq_cmp(beta, tol) <= 0)
{ // success!!
break;
}
else
{ // update sqrt_x & try again
mpq_set(sqrt_x, new_sqrt_x);
}
} while (1);
// clear
mpq_clear(new_sqrt_x);
mpq_clear(beta);
mpq_clear(tol);
return;
}
Rational operator-(const int num1, const Rational& num2)
{
Rational res;
Rational _num1(num1);
mpq_sub(res.number, _num1.number, num2.number);
return res;
}
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;
}
static PyObject *
GMPy_Rational_DivMod(PyObject *x, PyObject *y, CTXT_Object *context)
{
MPQ_Object *tempx, *tempy, *rem;
MPZ_Object *quo;
PyObject *result;
CHECK_CONTEXT(context);
result = PyTuple_New(2);
rem = GMPy_MPQ_New(context);
quo = GMPy_MPZ_New(context);
if (!result || !rem || !quo) {
Py_XDECREF(result);
Py_XDECREF((PyObject*)rem);
Py_XDECREF((PyObject*)quo);
return NULL;
}
if (IS_RATIONAL(x) && IS_RATIONAL(y)) {
tempx = GMPy_MPQ_From_Number(x, context);
tempy = GMPy_MPQ_From_Number(y, context);
if (!tempx || !tempy) {
SYSTEM_ERROR("could not convert Rational to mpq");
goto error;
}
if (mpq_sgn(tempy->q) == 0) {
ZERO_ERROR("division or modulo by zero");
goto error;
}
mpq_div(rem->q, tempx->q, tempy->q);
mpz_fdiv_q(quo->z, mpq_numref(rem->q), mpq_denref(rem->q));
/* Need to calculate x - quo * y. */
mpq_set_z(rem->q, quo->z);
mpq_mul(rem->q, rem->q, tempy->q);
mpq_sub(rem->q, tempx->q, rem->q);
Py_DECREF((PyObject*)tempx);
Py_DECREF((PyObject*)tempy);
PyTuple_SET_ITEM(result, 0, (PyObject*)quo);
PyTuple_SET_ITEM(result, 1, (PyObject*)rem);
return result;
}
Py_DECREF((PyObject*)result);
Py_RETURN_NOTIMPLEMENTED;
error:
Py_XDECREF((PyObject*)tempx);
Py_XDECREF((PyObject*)tempy);
Py_DECREF((PyObject*)rem);
Py_DECREF((PyObject*)quo);
Py_DECREF(result);
return NULL;
}
obj rational_minus( obj a, obj b )
{
mpq_t r, a1, b1;
OBJ_TO_MPQ(a1, a);
OBJ_TO_MPQ(b1, b);
mpq_init(r);
mpq_sub(r, a1, b1);
return rational_compact(r);
}
static PyObject *
GMPy_Rational_DivMod(PyObject *x, PyObject *y, CTXT_Object *context)
{
MPQ_Object *tempx = NULL, *tempy = NULL, *rem = NULL;
MPZ_Object *quo = NULL;
PyObject *result = NULL;
if (!(result = PyTuple_New(2)) ||
!(rem = GMPy_MPQ_New(context)) ||
!(quo = GMPy_MPZ_New(context))) {
/* LCOV_EXCL_START */
goto error;
/* LCOV_EXCL_STOP */
}
if (IS_RATIONAL(x) && IS_RATIONAL(y)) {
if (!(tempx = GMPy_MPQ_From_Number(x, context)) ||
!(tempy = GMPy_MPQ_From_Number(y, context))) {
/* LCOV_EXCL_START */
goto error;
/* LCOV_EXCL_STOP */
}
if (mpq_sgn(tempy->q) == 0) {
ZERO_ERROR("division or modulo by zero");
goto error;
}
mpq_div(rem->q, tempx->q, tempy->q);
mpz_fdiv_q(quo->z, mpq_numref(rem->q), mpq_denref(rem->q));
/* Need to calculate x - quo * y. */
mpq_set_z(rem->q, quo->z);
mpq_mul(rem->q, rem->q, tempy->q);
mpq_sub(rem->q, tempx->q, rem->q);
Py_DECREF((PyObject*)tempx);
Py_DECREF((PyObject*)tempy);
PyTuple_SET_ITEM(result, 0, (PyObject*)quo);
PyTuple_SET_ITEM(result, 1, (PyObject*)rem);
return result;
}
/* LCOV_EXCL_START */
SYSTEM_ERROR("Internal error in GMPy_Rational_DivMod().");
error:
Py_XDECREF((PyObject*)tempx);
Py_XDECREF((PyObject*)tempy);
Py_XDECREF((PyObject*)rem);
Py_XDECREF((PyObject*)quo);
Py_XDECREF(result);
return NULL;
/* LCOV_EXCL_STOP */
}
static PyObject *
Pympq_sub(PyObject *self, PyObject *args)
{
PympqObject *result;
PyObject *other;
PARSE_TWO_MPQ(other, "sub() requires 'mpq','mpq' arguments");
if ((result = (PympqObject*)Pympq_new()))
mpq_sub(result->q, Pympq_AS_MPQ(self), Pympq_AS_MPQ(other));
Py_DECREF(self);
Py_DECREF(other);
return (PyObject*)result;
}
void lux_f_solve(LUX *lux, int tr, mpq_t x[])
{ int n = lux->n;
LUXELM **F_row = lux->F_row;
LUXELM **F_col = lux->F_col;
int *P_row = lux->P_row;
LUXELM *fik, *fkj;
int i, j, k;
mpq_t temp;
mpq_init(temp);
if (!tr)
{ /* solve the system F*x = b */
for (j = 1; j <= n; j++)
{ k = P_row[j];
if (mpq_sgn(x[k]) != 0)
{ for (fik = F_col[k]; fik != NULL; fik = fik->c_next)
{ mpq_mul(temp, fik->val, x[k]);
mpq_sub(x[fik->i], x[fik->i], temp);
}
}
}
}
else
{ /* solve the system F'*x = b */
for (i = n; i >= 1; i--)
{ k = P_row[i];
if (mpq_sgn(x[k]) != 0)
{ for (fkj = F_row[k]; fkj != NULL; fkj = fkj->r_next)
{ mpq_mul(temp, fkj->val, x[k]);
mpq_sub(x[fkj->j], x[fkj->j], temp);
}
}
}
}
mpq_clear(temp);
return;
}
static PyObject *
GMPy_Rational_Mod(PyObject *x, PyObject *y, CTXT_Object *context)
{
mpz_t tempz;
MPQ_Object *tempx, *tempy, *result;
CHECK_CONTEXT(context);
if (!(result = GMPy_MPQ_New(context)))
return NULL;
if (IS_RATIONAL(x) && IS_RATIONAL(y)) {
tempx = GMPy_MPQ_From_Number(x, context);
tempy = GMPy_MPQ_From_Number(y, context);
if (!tempx || !tempy) {
SYSTEM_ERROR("could not convert Rational to mpq");
goto error;
}
if (mpq_sgn(tempy->q) == 0) {
ZERO_ERROR("division or modulo by zero");
goto error;
}
mpz_inoc(tempz);
mpq_div(result->q, tempx->q, tempy->q);
mpz_fdiv_q(tempz, mpq_numref(result->q), mpq_denref(result->q));
/* Need to calculate x - tempz * y. */
mpq_set_z(result->q, tempz);
mpq_mul(result->q, result->q, tempy->q);
mpq_sub(result->q, tempx->q, result->q);
mpz_cloc(tempz);
Py_DECREF((PyObject*)tempx);
Py_DECREF((PyObject*)tempy);
return (PyObject*)result;
}
Py_DECREF((PyObject*)result);
Py_RETURN_NOTIMPLEMENTED;
error:
Py_XDECREF((PyObject*)tempx);
Py_XDECREF((PyObject*)tempy);
Py_DECREF((PyObject*)result);
return NULL;
}
void generate_random_rational(rational_complex_number x)
/***************************************************************\
* USAGE: generate a random rational number of unit modulus *
\***************************************************************/
{
int base = 10;
char *str = NULL;
mpq_t t, t_sqr;
mpq_init(t);
mpq_init(t_sqr);
// generate a random number
create_random_number_str(&str);
mpq_set_str(t, str, base);
mpq_canonicalize(t);
// compute t_sqr = t^2
mpq_mul(t_sqr, t, t);
// compute denominator
mpq_set_ui(x->im, 1, 1);
mpq_add(x->im, x->im, t_sqr); // 1 + t^2
// compute numerator
mpq_set_ui(x->re, 1, 1);
mpq_sub(x->re, x->re, t_sqr); // 1 - t^2
// divide to compute real part
mpq_div(x->re, x->re, x->im);
// compute imaginary part
mpq_set_ui(x->im, 1, 1);
mpq_add(x->im, x->re, x->im); // 1 + x->re
mpq_mul(x->im, x->im, t); // t*(1+x->re)
// clear memory
mpq_clear(t);
mpq_clear(t_sqr);
free(str);
return;
}
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);
}
static void eliminate(LUX *lux, LUXWKA *wka, LUXELM *piv, int flag[],
mpq_t work[])
{ DMP *pool = lux->pool;
LUXELM **F_row = lux->F_row;
LUXELM **F_col = lux->F_col;
mpq_t *V_piv = lux->V_piv;
LUXELM **V_row = lux->V_row;
LUXELM **V_col = lux->V_col;
int *R_len = wka->R_len;
int *R_head = wka->R_head;
int *R_prev = wka->R_prev;
int *R_next = wka->R_next;
int *C_len = wka->C_len;
int *C_head = wka->C_head;
int *C_prev = wka->C_prev;
int *C_next = wka->C_next;
LUXELM *fip, *vij, *vpj, *viq, *next;
mpq_t temp;
int i, j, p, q;
mpq_init(temp);
/* determine row and column indices of the pivot v[p,q] */
xassert(piv != NULL);
p = piv->i, q = piv->j;
/* remove p-th (pivot) row from the active set; it will never
return there */
if (R_prev[p] == 0)
R_head[R_len[p]] = R_next[p];
else
R_next[R_prev[p]] = R_next[p];
if (R_next[p] == 0)
;
else
R_prev[R_next[p]] = R_prev[p];
/* remove q-th (pivot) column from the active set; it will never
return there */
if (C_prev[q] == 0)
C_head[C_len[q]] = C_next[q];
else
C_next[C_prev[q]] = C_next[q];
if (C_next[q] == 0)
;
else
C_prev[C_next[q]] = C_prev[q];
/* store the pivot value in a separate array */
mpq_set(V_piv[p], piv->val);
/* remove the pivot from p-th row */
if (piv->r_prev == NULL)
V_row[p] = piv->r_next;
else
piv->r_prev->r_next = piv->r_next;
if (piv->r_next == NULL)
;
else
piv->r_next->r_prev = piv->r_prev;
R_len[p]--;
/* remove the pivot from q-th column */
if (piv->c_prev == NULL)
V_col[q] = piv->c_next;
else
piv->c_prev->c_next = piv->c_next;
if (piv->c_next == NULL)
;
else
piv->c_next->c_prev = piv->c_prev;
C_len[q]--;
/* free the space occupied by the pivot */
mpq_clear(piv->val);
dmp_free_atom(pool, piv, sizeof(LUXELM));
/* walk through p-th (pivot) row, which already does not contain
the pivot v[p,q], and do the following... */
for (vpj = V_row[p]; vpj != NULL; vpj = vpj->r_next)
{ /* get column index of v[p,j] */
j = vpj->j;
/* store v[p,j] in the working array */
flag[j] = 1;
mpq_set(work[j], vpj->val);
/* remove j-th column from the active set; it will return there
later with a new length */
if (C_prev[j] == 0)
C_head[C_len[j]] = C_next[j];
else
C_next[C_prev[j]] = C_next[j];
if (C_next[j] == 0)
;
else
C_prev[C_next[j]] = C_prev[j];
/* v[p,j] leaves the active submatrix, so remove it from j-th
column; however, v[p,j] is kept in p-th row */
if (vpj->c_prev == NULL)
V_col[j] = vpj->c_next;
else
vpj->c_prev->c_next = vpj->c_next;
if (vpj->c_next == NULL)
;
else
vpj->c_next->c_prev = vpj->c_prev;
C_len[j]--;
}
/* now walk through q-th (pivot) column, which already does not
contain the pivot v[p,q], and perform gaussian elimination */
while (V_col[q] != NULL)
{ /* element v[i,q] has to be eliminated */
viq = V_col[q];
/* get row index of v[i,q] */
i = viq->i;
/* remove i-th row from the active set; later it will return
there with a new length */
if (R_prev[i] == 0)
R_head[R_len[i]] = R_next[i];
else
R_next[R_prev[i]] = R_next[i];
if (R_next[i] == 0)
;
else
R_prev[R_next[i]] = R_prev[i];
/* compute gaussian multiplier f[i,p] = v[i,q] / v[p,q] and
store it in the matrix F */
fip = dmp_get_atom(pool, sizeof(LUXELM));
fip->i = i, fip->j = p;
mpq_init(fip->val);
mpq_div(fip->val, viq->val, V_piv[p]);
fip->r_prev = NULL;
fip->r_next = F_row[i];
fip->c_prev = NULL;
fip->c_next = F_col[p];
if (fip->r_next != NULL) fip->r_next->r_prev = fip;
if (fip->c_next != NULL) fip->c_next->c_prev = fip;
F_row[i] = F_col[p] = fip;
/* v[i,q] has to be eliminated, so remove it from i-th row */
if (viq->r_prev == NULL)
V_row[i] = viq->r_next;
else
viq->r_prev->r_next = viq->r_next;
if (viq->r_next == NULL)
;
else
viq->r_next->r_prev = viq->r_prev;
R_len[i]--;
/* and also from q-th column */
V_col[q] = viq->c_next;
C_len[q]--;
/* free the space occupied by v[i,q] */
mpq_clear(viq->val);
dmp_free_atom(pool, viq, sizeof(LUXELM));
/* perform gaussian transformation:
(i-th row) := (i-th row) - f[i,p] * (p-th row)
note that now p-th row, which is in the working array,
does not contain the pivot v[p,q], and i-th row does not
contain the element v[i,q] to be eliminated */
/* walk through i-th row and transform existing non-zero
elements */
for (vij = V_row[i]; vij != NULL; vij = next)
{ next = vij->r_next;
/* get column index of v[i,j] */
j = vij->j;
/* v[i,j] := v[i,j] - f[i,p] * v[p,j] */
if (flag[j])
{ /* v[p,j] != 0 */
flag[j] = 0;
mpq_mul(temp, fip->val, work[j]);
mpq_sub(vij->val, vij->val, temp);
if (mpq_sgn(vij->val) == 0)
{ /* new v[i,j] is zero, so remove it from the active
submatrix */
/* remove v[i,j] from i-th row */
if (vij->r_prev == NULL)
V_row[i] = vij->r_next;
else
vij->r_prev->r_next = vij->r_next;
if (vij->r_next == NULL)
;
else
vij->r_next->r_prev = vij->r_prev;
R_len[i]--;
/* remove v[i,j] from j-th column */
if (vij->c_prev == NULL)
V_col[j] = vij->c_next;
else
vij->c_prev->c_next = vij->c_next;
if (vij->c_next == NULL)
;
else
vij->c_next->c_prev = vij->c_prev;
C_len[j]--;
/* free the space occupied by v[i,j] */
mpq_clear(vij->val);
dmp_free_atom(pool, vij, sizeof(LUXELM));
}
}
}
/* now flag is the pattern of the set v[p,*] \ v[i,*] */
/* walk through p-th (pivot) row and create new elements in
i-th row, which appear due to fill-in */
for (vpj = V_row[p]; vpj != NULL; vpj = vpj->r_next)
{ j = vpj->j;
if (flag[j])
{ /* create new non-zero v[i,j] = 0 - f[i,p] * v[p,j] and
add it to i-th row and j-th column */
vij = dmp_get_atom(pool, sizeof(LUXELM));
vij->i = i, vij->j = j;
mpq_init(vij->val);
mpq_mul(vij->val, fip->val, work[j]);
mpq_neg(vij->val, vij->val);
vij->r_prev = NULL;
vij->r_next = V_row[i];
vij->c_prev = NULL;
vij->c_next = V_col[j];
if (vij->r_next != NULL) vij->r_next->r_prev = vij;
if (vij->c_next != NULL) vij->c_next->c_prev = vij;
V_row[i] = V_col[j] = vij;
R_len[i]++, C_len[j]++;
}
else
{ /* there is no fill-in, because v[i,j] already exists in
i-th row; restore the flag, which was reset before */
flag[j] = 1;
}
}
/* now i-th row has been completely transformed and can return
to the active set with a new length */
R_prev[i] = 0;
R_next[i] = R_head[R_len[i]];
if (R_next[i] != 0) R_prev[R_next[i]] = i;
R_head[R_len[i]] = i;
}
/* at this point q-th (pivot) column must be empty */
xassert(C_len[q] == 0);
/* walk through p-th (pivot) row again and do the following... */
for (vpj = V_row[p]; vpj != NULL; vpj = vpj->r_next)
{ /* get column index of v[p,j] */
j = vpj->j;
/* erase v[p,j] from the working array */
flag[j] = 0;
mpq_set_si(work[j], 0, 1);
/* now j-th column has been completely transformed, so it can
return to the active list with a new length */
C_prev[j] = 0;
C_next[j] = C_head[C_len[j]];
if (C_next[j] != 0) C_prev[C_next[j]] = j;
C_head[C_len[j]] = j;
}
mpq_clear(temp);
/* return to the factorizing routine */
return;
}
int main (int argc, char **argv){
mp_int num1,den1,num2,den2;
mp_rat q1,q2,q3,q4;
//mp_rat *bernoulli;
int i;
clock_t start,stop;
if (argc < 5) {
fprintf(stderr, "usage: %s integer integer integer integer \n", argv[0]);
exit(EXIT_FAILURE);
}
mp_init_multi(&num1,&den1,&num2,&den2,NULL);
mp_get_str(argv[1], &num1, 10);
mp_get_str(argv[2], &den1, 10);
mp_get_str(argv[3], &num2, 10);
mp_get_str(argv[4], &den2, 10);
printf("Numerator 1: ");mp_print(&num1);puts("");
printf("Denominator 1: ");mp_print(&den1);puts("");
printf("Numerator 2: ");mp_print(&num2);puts("");
printf("Denominator 2: ");mp_print(&den2);puts("");
mpq_init_multi(&q1,&q2,&q3,&q4,NULL);puts("000");
mpq_set(&q1,&num1,&den1);puts("111");
printf("Rational1: ");mpq_print(&q1);puts("");
mpq_set(&q2,&num2,&den2);puts("222");
printf("Rational2: ");mpq_print(&q2);puts("");
mpq_add(&q1,&q2,&q3);;
printf("R1 + R2 = ");mpq_print(&q3);puts("");
mpq_sub(&q1,&q2,&q3);
printf("R1 - R2 = ");mpq_print(&q3);puts("");
mpq_mul(&q1,&q2,&q3);
printf("R1 * R2 = ");mpq_print(&q3);puts("");
mpq_div(&q1,&q2,&q3);
printf("R1 / R2 = ");mpq_print(&q3);puts("");
//mpq_pow_d(&q1,123,&q3);
printf("R1 ^ 123 = ");mpq_print(&q3);puts("");
printf("cmp(R1, R2) = %d\n",mpq_cmp(&q1,&q2));
printf("cmp(R2, R1) = %d\n",mpq_cmp(&q2,&q1));
printf("cmp(R1, R1) = %d\n",mpq_cmp(&q1,&q1));
mp_set_int(&num2,123);
//mp_expt(&num1,&num2,&num1);
printf("num1 ^123 = ");mp_fwrite(&num1,10,stdout);puts("");
mpq_set_epsilon(50);
//mpq_set_int(&q1,128,2);
//mpq_set_int(&q1,529,1849);
//mpq_set_int(&q1,3481,11664);
//mpq_set_int(&q1,1764,1849);
mpq_set_int(&q1,44521,46656);
mpq_sqrt(&q1,&q1);
printf("sqrt(R1) = ");mpq_print(&q1);puts("");
//SeidelBernoulli(20);
//bernoulli = malloc(sizeof(mp_rat) * 102);
start = clock();
//bern_rat_init(10);
//bhbern(50);
stop = clock();
puts("bernoulli");
for(i=0;i<=(50);i++){
//mpq_print(&bern_array[i]);printf(" %d\n",i);
}
mpq_bernoulli(10,&q1);
printf("B_10 = ");mpq_print(&q1);puts("");
mpq_bernoulli(4,&q1);
printf("B_4 = ");mpq_print(&q1);puts("");
mpq_bernoulli(0,&q1);
printf("B_0 = ");mpq_print(&q1);puts("");
mpq_bernoulli(1,&q1);
printf("B_1 = ");mpq_print(&q1);puts("");
mpq_bernoulli(2,&q1);
printf("B_3 = ");mpq_print(&q1);puts("");
mpq_bernoulli(100,&q1);
printf("B_100 = ");mpq_print(&q1);puts("");
mpq_bernoulli(98,&q1);
printf("B_98 = ");mpq_print(&q1);puts("");
printf("Time: %6.6f\n",( (double)stop - (double)start )/((double)CLOCKS_PER_SEC) );
mpq_bernoulli_free();
exit(EXIT_SUCCESS);
}
void subtract(ElementType& result, const ElementType& a, const ElementType& b) const {
mpq_sub(&result,&a,&b);
}
