static PyObject *
GMPy_MPZ_Function_Remove(PyObject *self, PyObject *args)
{
MPZ_Object *result = NULL, *tempx = NULL, *tempf = NULL;
PyObject *x, *f;
size_t multiplicity;
if (PyTuple_GET_SIZE(args) != 2) {
TYPE_ERROR("remove() requires 'mpz','mpz' arguments");
return NULL;
}
if (!(result = GMPy_MPZ_New(NULL))) {
/* LCOV_EXCL_START */
return NULL;
/* LCOV_EXCL_STOP */
}
x = PyTuple_GET_ITEM(args, 0);
f = PyTuple_GET_ITEM(args, 1);
if (MPZ_Check(x) && MPZ_Check(f)) {
if (mpz_cmp_si(MPZ(f), 2) < 0) {
VALUE_ERROR("factor must be > 1");
Py_DECREF((PyObject*)result);
return NULL;
}
multiplicity = mpz_remove(result->z, MPZ(x), MPZ(f));
return Py_BuildValue("(Nk)", result, multiplicity);
}
else {
if (!(tempx = GMPy_MPZ_From_Integer(x, NULL)) ||
!(tempf = GMPy_MPZ_From_Integer(f, NULL))) {
TYPE_ERROR("remove() requires 'mpz','mpz' arguments");
Py_XDECREF((PyObject*)tempx);
Py_XDECREF((PyObject*)tempf);
Py_DECREF((PyObject*)result);
return NULL;
}
if (mpz_cmp_si(MPZ(tempf), 2) < 0) {
VALUE_ERROR("factor must be > 1");
Py_DECREF((PyObject*)tempx);
Py_DECREF((PyObject*)tempf);
Py_DECREF((PyObject*)result);
return NULL;
}
multiplicity = mpz_remove(result->z, tempx->z, tempf->z);
return Py_BuildValue("(Nk)", result, multiplicity);
}
}
// Liefert die Primfaktorzerlegung einer Zahl als String.
char *factorize(mpz_t number)
{
// Primtest (Miller-Rabin).
if (mpz_probab_prime_p(number, 10) > 0)
return mpz_get_str(NULL, 10, number);
mpz_t factor, cofactor;
mpz_init(factor);
mpz_init(cofactor);
char *str1, *str2, *result;
int B1 = INITB1, B2 = INITB2, curves = INITCURVES;
// Zunaechst eine einfache Probedivision.
trial(number, factor, 3e3);
if (mpz_cmp_si(factor, 1) == 0)
{
// Zweite Strategie: Pollard-Rho.
do
{
rho(number, factor, 4e4);
} while (mpz_cmp(factor, number) == 0);
// Falls immer noch kein Faktor gefunden wurde, mit ECM fortfahren.
while (mpz_cmp_si(factor, 1) == 0)
{
ecm(number, factor, B1, B2, curves);
if (mpz_cmp(factor, number) == 0)
{
mpz_set_si(factor, 1);
B1 = INITB1;
B2 = INITB2;
curves = INITCURVES;
continue;
}
// Anpassung der Parameter.
B1 *= 4;
B2 *= 5;
curves = (curves * 5) / 2;
}
}
mpz_divexact(cofactor, number, factor);
str1 = factorize(factor);
str2 = factorize(cofactor);
result = (char *) malloc(strlen(str1) + strlen(str2) + 4);
strcpy(result, str1);
strcat(result, " * ");
strcat(result, str2);
mpz_clear(factor);
mpz_clear(cofactor);
return result;
}
/* Evaluate the expression E modulo MOD and put the result in R. */
void
mpz_eval_mod_expr (mpz_ptr r, expr_t e, mpz_ptr mod)
{
mpz_t lhs, rhs;
switch (e->op)
{
case POW:
mpz_init (lhs); mpz_init (rhs);
mpz_eval_mod_expr (lhs, e->operands.ops.lhs, mod);
mpz_eval_expr (rhs, e->operands.ops.rhs);
mpz_powm (r, lhs, rhs, mod);
mpz_clear (lhs); mpz_clear (rhs);
return;
case PLUS:
mpz_init (lhs); mpz_init (rhs);
mpz_eval_mod_expr (lhs, e->operands.ops.lhs, mod);
mpz_eval_mod_expr (rhs, e->operands.ops.rhs, mod);
mpz_add (r, lhs, rhs);
if (mpz_cmp_si (r, 0L) < 0)
mpz_add (r, r, mod);
else if (mpz_cmp (r, mod) >= 0)
mpz_sub (r, r, mod);
mpz_clear (lhs); mpz_clear (rhs);
return;
case MINUS:
mpz_init (lhs); mpz_init (rhs);
mpz_eval_mod_expr (lhs, e->operands.ops.lhs, mod);
mpz_eval_mod_expr (rhs, e->operands.ops.rhs, mod);
mpz_sub (r, lhs, rhs);
if (mpz_cmp_si (r, 0L) < 0)
mpz_add (r, r, mod);
else if (mpz_cmp (r, mod) >= 0)
mpz_sub (r, r, mod);
mpz_clear (lhs); mpz_clear (rhs);
return;
case MULT:
mpz_init (lhs); mpz_init (rhs);
mpz_eval_mod_expr (lhs, e->operands.ops.lhs, mod);
mpz_eval_mod_expr (rhs, e->operands.ops.rhs, mod);
mpz_mul (r, lhs, rhs);
mpz_mod (r, r, mod);
mpz_clear (lhs); mpz_clear (rhs);
return;
default:
mpz_init (lhs);
mpz_eval_expr (lhs, e);
mpz_mod (r, lhs, mod);
mpz_clear (lhs);
return;
}
}
static ZSolveMatrix Matrix2zsolve(Matrix *M)
{
int i, j;
ZSolveMatrix zmatrix;
zmatrix = createMatrix(M->NbColumns-2, M->NbRows);
for (i = 0; i < M->NbRows; ++i)
for (j = 0; j < M->NbColumns-2; ++j) {
assert(mpz_cmp_si(M->p[i][1+j], -MAXINT) > 0);
assert(mpz_cmp_si(M->p[i][1+j], MAXINT) < 0);
zmatrix->Data[i*zmatrix->Width+j] = mpz_get_si(M->p[i][1+j]);
}
return zmatrix;
}
bool RingZZ::from_rational(mpq_ptr q, ring_elem &result) const
{
bool ok = mpz_cmp_si(mpq_denref(q), 1) == 0;
if (not ok) return false;
result = RingZZ::from_int(mpq_numref(q));
return true;
}
static void
lst_linearized_niter (lst_p lst, mpz_t res)
{
int i;
lst_p l;
mpz_t n;
mpz_init (n);
mpz_set_si (res, 0);
FOR_EACH_VEC_ELT (lst_p, LST_SEQ (lst), i, l)
if (LST_LOOP_P (l))
{
lst_linearized_niter (l, n);
mpz_add (res, res, n);
}
if (LST_LOOP_P (lst))
{
lst_niter_for_loop (lst, n);
if (mpz_cmp_si (res, 0) != 0)
mpz_mul (res, res, n);
else
mpz_set (res, n);
}
mpz_clear (n);
}
/**
* Recombine les racines modulo mod1 et mod2 pour trouver les racines finales.
* rac_modi[0]contient les valeurs en x des racines et rac_modi[1] celles en y.
* @param rac_mod1 tableau des couples (x, y) de racines modulo mod1
* @param rac_mod2 tableau des couples (x, y) de racines modulo mod2
* @param nb1 nombre de racines (x, y) dans rac_mod1
* @param nb2 nombre de racines (x, y) dans rac_mod2
*/
void find_roots(mpz_t *rac_mod1[2], mpz_t *rac_mod2[2], int nb1, int nb2, mpz_t mod1, mpz_t mod2, mpz_t **PY, mpz_t **QY, int *degres_PY, int *degresQY, int deg_P, int deg_Q, mpz_t mod){
int i, j, nb_racines=0;
mpz_t rx, ry, isroot;
mpz_inits(rx, ry, isroot, NULL);
for(i=0; i<nb1; i++){
for(j=0; j<nb2; j++){
/* crt sur la i eme racine mod1 et la j eme mod2 */
crt(rx, rac_mod1[0][i], rac_mod2[0][j], mod1, mod2);
crt(ry, rac_mod1[1][i], rac_mod2[1][j], mod1, mod2);
/* on evalue en le resultat (rx, ry) trouve */
eval_bivXY(isroot, rx, ry, PY, degres_PY, deg_P, mod);
/* on teste si le resultat est bien racine */
if (!mpz_cmp_si(isroot, 0)){
printf("(%ld, %ld) est racine\n", mpz_get_si(rx), mpz_get_si(ry));
nb_racines++;
}
}
}
printf("%d racines au total\n", nb_racines);
}
/* Called when g is supposed to be gcd(a,b), and g = s a + t b, for some t.
Uses temp1 and temp2 */
static int
gcdext_valid_p (const mpz_t a, const mpz_t b, const mpz_t g, const mpz_t s)
{
/* It's not clear that gcd(0,0) is well defined, but we allow it and require that
allow gcd(0,0) = 0. */
if (mpz_sgn (g) < 0)
return 0;
if (mpz_sgn (a) == 0)
{
/* Must have g == abs (b). Any value for s is in some sense "correct",
but it makes sense to require that s == 0. */
return mpz_cmpabs (g, b) == 0 && mpz_sgn (s) == 0;
}
else if (mpz_sgn (b) == 0)
{
/* Must have g == abs (a), s == sign (a) */
return mpz_cmpabs (g, a) == 0 && mpz_cmp_si (s, mpz_sgn (a)) == 0;
}
if (mpz_sgn (g) <= 0)
return 0;
if (! (mpz_divisible_p (a, g)
&& mpz_divisible_p (b, g)
&& mpz_cmpabs (s, b) <= 0))
return 0;
mpz_mul(temp1, s, a);
mpz_sub(temp1, g, temp1);
mpz_tdiv_qr(temp1, temp2, temp1, b);
return mpz_sgn (temp2) == 0 && mpz_cmpabs (temp1, a) <= 0;
}
/**
* Output the first n best rational approximations of rational q
*/
void cpt_rat_approx(mpq_t *res, mpq_srcptr q, unsigned int *n)
{
mpz_t pnm1,pnm2,qnm1,qnm2,pn,qn,a,num,den;
mpz_init_set_si(pnm1,1);
mpz_init_set_si(pnm2,0);
mpz_init_set_si(qnm1,0);
mpz_init_set_si(qnm2,1);
mpz_init(pn);
mpz_init(qn);
mpz_init(a);
mpz_init(num);
mpz_init(den);
mpq_get_num(num,q);
mpq_get_den(den,q);
for(unsigned int i = 0; i < *n; i++)
{
if(mpz_cmp_si(den,0) == 0)
{
*n = i;
break;
}
__rat_approx_step(res[i], num, den, a, pnm2, pnm1, qnm2, qnm1, pn, qn);
}
mpz_clear(pnm1);
mpz_clear(pnm2);
mpz_clear(qnm1);
mpz_clear(qnm2);
mpz_clear(pn);
mpz_clear(qn);
mpz_clear(a);
mpz_clear(num);
mpz_clear(den);
}
void ARingZZGMP::syzygy(const ElementType& a, const ElementType& b,
ElementType& x, ElementType& y) const
{
M2_ASSERT(!is_zero(b));
// First check the special cases a = 0, b = 1, -1. Other cases: use gcd.
if (is_zero(a))
{
set_from_long(x, 1);
set_zero(y);
return;
}
if (mpz_cmp_ui(&b,1) == 0)
{
set_from_long(x, 1);
negate(y, a);
return;
}
if (mpz_cmp_si(&b,-1) == 0)
{
set_from_long(x, 1);
set(y, a);
return;
}
elem g;
init(g);
mpz_gcd(&g,&a,&b);
divide(y,a,g);
divide(x,b,g);
if (mpz_sgn(&x) > 0)
negate(y,y);
else
negate(x,x);
clear(g);
}
// Das Hauptprogramm.
main(int argc, char *argv[])
{
if (argc == 1)
{
printf("Wo ist die Eingabezahl?\n");
return 1;
}
mpz_t number;
mpz_init(number);
if (mpz_set_str(number, argv[1], 10) == -1)
{
printf("Ungueltige Eingabe.\n");
mpz_clear(number);
return 1;
}
if (mpz_cmp_si(number, 2) < 0)
{
printf("Natuerliche Zahl > 1 erforderlich.\n");
mpz_clear(number);
return 1;
}
srand(time(0));
printf("%s\n", factorize(number));
mpz_clear(number);
return 0;
}
gfc_constructor *
gfc_constructor_lookup (gfc_constructor_base base, int offset)
{
gfc_constructor *c;
splay_tree_node node;
if (!base)
return NULL;
node = splay_tree_lookup (base, (splay_tree_key) offset);
if (node)
return (gfc_constructor *) node->value;
/* Check if the previous node has a repeat count big enough to
cover the offset looked for. */
node = splay_tree_predecessor (base, (splay_tree_key) offset);
if (!node)
return NULL;
c = (gfc_constructor *) node->value;
if (mpz_cmp_si (c->repeat, 1) > 0)
{
if (mpz_get_si (c->offset) + mpz_get_si (c->repeat) <= offset)
c = NULL;
}
else
c = NULL;
return c;
}
/**
*Affiche les racines de P
*/
void print_racines(mpz_t *P, int deg_P, mpz_t mod){
int i, nb_racines=0;
mpz_t rac[deg_P+1];
for(i=0; i<deg_P+1; i++){
mpz_init_set_str(rac[i], "-1", 10);
}
printf("\n\nEtude du Polynome : ");
print_P(P, deg_P);
racines(rac, P, deg_P,&nb_racines, mod);
for(i=0; i<deg_P+1; i++){
if (!mpz_cmp_si(rac[i],-1)){
printf("Polynome : ");
print_P(P, deg_P);
printf("%d racine(s)\n", nb_racines);
return;
}
printf("%ld est racine\n", mpz_get_si(rac[i]));
}
printf("Polynome : ");
print_P(P, deg_P);
printf("%d racines\n", nb_racines);
}
/**
* Retourne le nombre de coefficient a 0 au debut de P
*/
int nb_zeros(mpz_t *P, int deg_P ){
int i=0;
while(!mpz_cmp_si(P[i], 0)){
i++;
}
return i;
}
int32_t Integer::operator < (const int64_t l) const
{
#if GMP_LIMB_BITS != 64
return mpz_cmp_si((mpz_srcptr)&gmp_rep, l) < 0;
#else
return this->operator < (Integer(l));
#endif
}
bool lift_to_mpz(mpz_ptr result, const ElementType& a) const {
if (mpz_cmp_si(mpq_denref(&a), 1) == 0)
{
mpz_set(result, mpq_numref(&a));
return true;
}
return false;
}
void SecretShare::getShares(mpz_t* shares, mpz_t secret){
/*mpz_t coefficient, temp;
mpz_init(coefficient);
mpz_init(temp);
int peer;
for(peer = 0; peer < peers; peer++)
mpz_set_ui(shares[peer], 0);
for(int degree = 0; degree < threshold+1; degree++){
if(degree == 0)
mpz_set(coefficient,secret);
else{
mpz_urandomb(coefficient, rstate, bits);
if(degree == threshold && mpz_sgn(coefficient) == 0)
mpz_add_ui(coefficient, coefficient, 1);
}
for(int peer = 0; peer < peers; peer++){
modMul(temp, sharingMatrix[peer][degree], coefficient);
modAdd(shares[peer],shares[peer], temp);
}
}
mpz_clear(temp);
mpz_clear(coefficient); */
srand(time(NULL));
mpz_t coefficient;
mpz_init(coefficient);
mpz_t temp;
mpz_init(temp);
mpz_set_ui(temp, 0);
mpz_t random;
mpz_init(random);
for(int i = 0; i < peers; i++)
mpz_set_ui(shares[i], 0);
if(mpz_cmp_si(secret, 0) < 0){
mpz_mod(secret, secret, fieldSize);
}
for(int degree = 0; degree < threshold+1; degree++){
if(degree == 0)
mpz_set(coefficient,secret);
else{
mpz_urandomm(coefficient, rstate, fieldSize); //
if(degree == threshold && mpz_sgn(coefficient) == 0)
mpz_add_ui(coefficient, coefficient, 1);
/*mpz_set_ui(temp,rand());
mpz_set(temp, random);
mpz_mod(coefficient, temp, fieldSize);
mpz_add_ui(coefficient, coefficient, 1);*/
}
for(int peer = 0; peer < peers; peer++){
modMul(temp, sharingMatrix[peer][degree], coefficient);
modAdd(shares[peer],shares[peer], temp);
}
}
}
int
check_si (mpz_t sz, mpz_t oz, long si, long oi, int c)
{
mpz_t t;
int fail;
if (mpz_cmp_si (sz, oi) != c)
{
printf ("mpz_cmp_si (sz, %ld) != %i.\n", oi, c);
printf (" sz="); mpz_out_str (stdout, 10, sz); printf ("\n");
abort ();
}
if ((si < oi ? -1 : si > oi) != c)
return 1;
mpz_init_set_si (t, si);
if ((fail = mpz_cmp_si (sz, si)) != 0)
printf ("mpz_cmp_si (sz, %ld) != 0.\n", si);
if (mpz_cmp_si (oz, si) != -c)
printf ("mpz_cmp_si (oz, %ld) != %i.\n", si, -c), fail = 1;
if (! mpz_fits_slong_p (sz))
printf ("mpz_fits_slong_p (sz) != 1.\n"), fail = 1;
if (mpz_get_si (sz) != si)
printf ("mpz_get_si (sz) != %ld.\n", si), fail = 1;
if (mpz_cmp (t, sz) != 0)
{
printf ("mpz_init_set_si (%ld) failed.\n", si);
printf (" got="); mpz_out_str (stdout, 10, t); printf ("\n");
fail = 1;
}
mpz_clear (t);
if (fail)
{
printf (" sz="); mpz_out_str (stdout, 10, sz); printf ("\n");
printf (" oz="); mpz_out_str (stdout, 10, oz); printf ("\n");
printf (" si=%ld\n", si);
abort ();
}
return 0;
}
bool set_from_mpq(ElementType& result, const mpq_ptr a) const
{
if (mpz_cmp_si(mpq_denref(a), 1) == 0)
{
set_from_mpz(result, mpq_numref(a));
return true;
}
return false;
}
/* Called when g is supposed to be gcd(a,b), and g = s a + t b, for some t.
Uses temp1, temp2 and temp3. */
static int
gcdext_valid_p (const mpz_t a, const mpz_t b, const mpz_t g, const mpz_t s)
{
/* It's not clear that gcd(0,0) is well defined, but we allow it and require that
gcd(0,0) = 0. */
if (mpz_sgn (g) < 0)
return 0;
if (mpz_sgn (a) == 0)
{
/* Must have g == abs (b). Any value for s is in some sense "correct",
but it makes sense to require that s == 0. */
return mpz_cmpabs (g, b) == 0 && mpz_sgn (s) == 0;
}
else if (mpz_sgn (b) == 0)
{
/* Must have g == abs (a), s == sign (a) */
return mpz_cmpabs (g, a) == 0 && mpz_cmp_si (s, mpz_sgn (a)) == 0;
}
if (mpz_sgn (g) <= 0)
return 0;
mpz_tdiv_qr (temp1, temp3, a, g);
if (mpz_sgn (temp3) != 0)
return 0;
mpz_tdiv_qr (temp2, temp3, b, g);
if (mpz_sgn (temp3) != 0)
return 0;
/* Require that 2 |s| < |b/g|, or |s| == 1. */
if (mpz_cmpabs_ui (s, 1) > 0)
{
mpz_mul_2exp (temp3, s, 1);
if (mpz_cmpabs (temp3, temp2) >= 0)
return 0;
}
/* Compute the other cofactor. */
mpz_mul(temp2, s, a);
mpz_sub(temp2, g, temp2);
mpz_tdiv_qr(temp2, temp3, temp2, b);
if (mpz_sgn (temp3) != 0)
return 0;
/* Require that 2 |t| < |a/g| or |t| == 1*/
if (mpz_cmpabs_ui (temp2, 1) > 0)
{
mpz_mul_2exp (temp2, temp2, 1);
if (mpz_cmpabs (temp2, temp1) >= 0)
return 0;
}
return 1;
}
int
mpc_cmp_si (mpc_t op1, signed long int op2)
{
unsigned int count;
for (count = 0; count < op1.precision; count++)
op2 *= 10;
return mpz_cmp_si (op1.object, op2);
}
static CBIGINT *_div(CBIGINT *a, CBIGINT *b, bool invert)
{
if (mpz_cmp_si(b->n, 0) == 0)
{
GB.Error(GB_ERR_ZERO);
return NULL;
}
else
return BIGINT_make(a, b, mpz_tdiv_q);
}
int first_test(mpz_t n){
int test = 1;
int sortie = 0;
mpz_t nb, max,mod;
mpz_init (nb);
mpz_init (max);
mpz_init (mod);
mpz_root(max, n, 2); //need debug
//gmp_printf ("\nDebug racine carré : %Zd\n", max);
//mpz_out_str(stdout, 10, max);
mpz_set_str(nb,"2",10);
//gmp_printf ("\nDebug compteur : %Zd\n", nb);
if(mpz_cmp_si(n,0)== 0 || mpz_cmp_si(n,1)== 0){
test = 0;
sortie = 1;
}
for(sortie = 0;sortie!=1 && mpz_cmp(nb,max)<=0;mpz_add_ui(nb,nb,1)){
//printf("test : %i\n", test);
mpz_mod(mod,n,nb);
//gmp_printf("Debug tour num %Zd : n = %Zd, nb = %Zd, n mod nb = %Zd\n",nb,n,nb,mod);
if(mpz_cmp_si(mod,0)== 0){
//printf("Debug : Sortie\n");
test = 0;
sortie = 1;
}
}
mpz_clear(nb);
mpz_clear(max);
mpz_clear(mod);
//printf("test : %i\n", test);
return test;
}
value largeint_cmp_si(value li, value si)
{
long res = mpz_cmp_si(Large_val(li), Long_val(si));
if (res < 0)
return Val_long(-1);
else if (res > 0)
return Val_long(1);
else
return Val_long(0);
}
SLVAL
sl_integer_parse(sl_vm_t* vm, uint8_t* str, size_t len)
{
mpz_t mpz;
char* buff = sl_alloc(vm->arena, len + 1);
memcpy(buff, str, len);
buff[len] = 0;
char* dec = memchr(buff, '.', len);
if(dec) {
*dec = 0;
}
mpz_init_set_str(mpz, buff, 10);
if(mpz_cmp_si(mpz, INT_MIN / 2) > 0 && mpz_cmp_si(mpz, INT_MAX / 2) < 0) {
SLVAL retn = sl_make_int(vm, mpz_get_si(mpz));
mpz_clear(mpz);
return retn;
} else {
mpz_clear(mpz);
return sl_make_bignum_s(vm, buff);
}
}
double
qcn_estimate (mpz_t d)
{
#define P_LIMIT 132000
double h;
unsigned long p;
/* p=2 */
h = sqrt (-mpz_get_d (d)) / M_PI
* 2.0 / (2.0 - mpz_kronecker_ui (d, 2));
if (mpz_cmp_si (d, -3) == 0) h *= 3;
else if (mpz_cmp_si (d, -4) == 0) h *= 2;
for (p = 3; p < P_LIMIT; p += 2)
if (prime_p (p))
h *= (double) p / (double) (p - mpz_kronecker_ui (d, p));
return h;
}
int
gfc_expr_is_one (gfc_expr *expr, int def)
{
gcc_assert (expr != NULL);
if (expr->expr_type != EXPR_CONSTANT)
return def;
if (expr->ts.type != BT_INTEGER)
return def;
return mpz_cmp_si (expr->value.integer, 1) == 0;
}
/*-----------------------------------------------------------------------------*/
void tree_to_ops(tree_t tree, int var_res)
{
int i;
char* var[2];
var[0] = label_var(1);
var[1] = "tmp";
if(!mpz_cmp_ui(tree->M_red, 1))
{
add_operation_str(SET, var[var_res], NULL, label_var(0));
if(tree->shift)
add_operation_int(SHF, var[var_res], var[var_res], tree->shift);
}
else
{
for(i=3; i>0; i--)
if(tree->node[i] && mpz_cmp_si(tree->node[i]->max_add, -1) != 0) break;
switch(i)
{
case 0:
tree_to_ops(tree->node[i], var_res);
add_operation_str(ADD, var[var_res], var[var_res], label_var(0));
if(tree->shift)
add_operation_int(SHF, var[var_res], var[var_res], tree->shift);
break;
case 1:
tree_to_ops(tree->node[i], var_res);
add_operation_str(SUB, var[var_res], var[var_res], label_var(0));
if(tree->shift)
add_operation_int(SHF, var[var_res], var[var_res], tree->shift);
break;
case 2:
tree_to_ops(tree->node[i], 1-var_res);
add_operation_str(SET, var[var_res], NULL, var[1-var_res]);
add_operation_int(SHF, var[1-var_res], var[1-var_res], tree->k);
add_operation_str(ADD, var[var_res], var[var_res], var[1-var_res]);
if(tree->shift)
add_operation_int(SHF, var[var_res], var[var_res], tree->shift);
break;
case 3:
tree_to_ops(tree->node[i], 1-var_res);
add_operation_str(SET, var[var_res], NULL, var[1-var_res]);
add_operation_int(SHF, var[var_res], var[var_res], tree->k);
add_operation_str(SUB, var[var_res], var[var_res], var[1-var_res]);
if(tree->shift)
add_operation_int(SHF, var[var_res], var[var_res], tree->shift);
break;
}
}
}
/**
* Compute exponential of x to e mod n
*/
void cpt_exp_mod(mpz_t res, mpz_srcptr x, mpz_srcptr e, mpz_srcptr, n)
{
if(mpz_cmp_si(e,0) < 0)
{
mpz_t me;
mpz_init(me);
mpz_neg(me,e);
cpt_exp_mod(res,x,me,n);
cpt_inv_mod(res,res,n);
mpz_clear(me);
return;
}
if(mpz_cmp_si(e,0) == 0)
{
mpz_set_si(res,1);
return;
}
/* Get the binary expansion of e */
const char * bin = mpz_get_str(NULL,2,e);
unsigned int l = strlen(bin);
mpz_t y;
mpz_init_set_si(y,1);
for(int i = 0; i < l; i++)
{
mpz_mul(y,y,2);
mpz_mod(y,y,n);
if(bin[i])
{
mpz_mul(y,x,y);
mpz_mod(y,y,n);
}
}
mpz_set(res,y);
mpz_clear(y);
free(bin);
}
void ARingZZGMP::elem_text_out(buffer &o,
const ElementType& a,
bool p_one,
bool p_plus,
bool p_parens) const
{
char *str;
bool is_neg = (mpz_cmp_si(&a, 0) == -1);
bool is_one = (mpz_cmp_si(&a, 1) == 0 || mpz_cmp_si(&a, -1) == 0);
if (!is_neg && p_plus) o << '+';
if (is_one)
{
if (is_neg) o << '-';
if (p_one) o << '1';
}
else
{
str = mpz_get_str(static_cast<char*>(0), 10, &a);
o << str;
}
}