static PyObject *
Pygmpy_c_divmod(PyObject *self, PyObject *args)
{
PyObject *x, *y, *result;
PympzObject *q, *r, *tempx, *tempy;
if (PyTuple_GET_SIZE(args) != 2) {
TYPE_ERROR("c_divmod() requires 'mpz','mpz' arguments");
return NULL;
}
x = PyTuple_GET_ITEM(args, 0);
y = PyTuple_GET_ITEM(args, 1);
CREATE_TWO_MPZ_TUPLE(q, r, result);
if (CHECK_MPZANY(x) && CHECK_MPZANY(y)) {
if(mpz_sgn(Pympz_AS_MPZ(y)) == 0) {
ZERO_ERROR("c_divmod() division by 0");
Py_DECREF((PyObject*)q);
Py_DECREF((PyObject*)r);
Py_DECREF(result);
return NULL;
}
mpz_cdiv_qr(q->z, r->z, Pympz_AS_MPZ(x), Pympz_AS_MPZ(y));
}
else {
tempx = Pympz_From_Integer(x);
tempy = Pympz_From_Integer(y);
if (!tempx || !tempy) {
TYPE_ERROR("c_divmod() requires 'mpz','mpz' arguments");
Py_XDECREF((PyObject*)tempx);
Py_XDECREF((PyObject*)tempy);
Py_DECREF((PyObject*)q);
Py_DECREF((PyObject*)r);
Py_DECREF(result);
return NULL;
}
if (mpz_sgn(Pympz_AS_MPZ(tempy)) == 0) {
ZERO_ERROR("c_divmod() division by 0");
Py_DECREF((PyObject*)tempx);
Py_DECREF((PyObject*)tempy);
Py_DECREF((PyObject*)q);
Py_DECREF((PyObject*)r);
Py_DECREF(result);
return NULL;
}
mpz_cdiv_qr(q->z, r->z, tempx->z, tempy->z);
Py_DECREF((PyObject*)tempx);
Py_DECREF((PyObject*)tempy);
}
PyTuple_SET_ITEM(result, 0, (PyObject*)q);
PyTuple_SET_ITEM(result, 1, (PyObject*)r);
return result;
}
void C_BigInt::ceilDivideInPlace (const C_BigInt inDivisor, C_BigInt & outRemainder) {
mpz_t quotient ;
mpz_init (quotient) ;
mpz_cdiv_qr (quotient, outRemainder.mGMPint, mGMPint, inDivisor.mGMPint) ;
mpz_swap (quotient, mGMPint) ;
mpz_clear (quotient) ;
}
static Variant HHVM_FUNCTION(gmp_div_qr,
const Variant& dataA,
const Variant& dataB,
int64_t round = GMP_ROUND_ZERO) {
mpz_t gmpDataA, gmpDataB, gmpReturnQ, gmpReturnR;
if (!variantToGMPData(cs_GMP_FUNC_NAME_GMP_DIV_QR, gmpDataA, dataA)) {
return false;
}
if (!variantToGMPData(cs_GMP_FUNC_NAME_GMP_DIV_QR, gmpDataB, dataB)) {
mpz_clear(gmpDataA);
return false;
}
if (mpz_sgn(gmpDataB) == 0) {
mpz_clear(gmpDataA);
mpz_clear(gmpDataB);
raise_warning(cs_GMP_INVALID_VALUE_MUST_NOT_BE_ZERO,
cs_GMP_FUNC_NAME_GMP_DIV_QR);
return false;
}
mpz_init(gmpReturnQ);
mpz_init(gmpReturnR);
switch (round)
{
case GMP_ROUND_ZERO:
mpz_tdiv_qr(gmpReturnQ, gmpReturnR, gmpDataA, gmpDataB);
break;
case GMP_ROUND_PLUSINF:
mpz_cdiv_qr(gmpReturnQ, gmpReturnR, gmpDataA, gmpDataB);
break;
case GMP_ROUND_MINUSINF:
mpz_fdiv_qr(gmpReturnQ, gmpReturnR, gmpDataA, gmpDataB);
break;
default:
mpz_clear(gmpDataA);
mpz_clear(gmpDataB);
mpz_clear(gmpReturnQ);
mpz_clear(gmpReturnR);
return null_variant;
}
ArrayInit returnArray(2, ArrayInit::Map{});
returnArray.set(0, NEWOBJ(GMPResource)(gmpReturnQ));
returnArray.set(1, NEWOBJ(GMPResource)(gmpReturnR));
mpz_clear(gmpDataA);
mpz_clear(gmpDataB);
mpz_clear(gmpReturnQ);
mpz_clear(gmpReturnR);
return returnArray.toVariant();
}
int cifra_caracter_afin(int cha, mpz_t a, mpz_t b , mpz_t m){
if(cha==10){
cha=32;
}
int cint,mAux;
mAux = mpz_get_ui(m);
if(cha>64 && cha<91){
cha+=32;
}
if(cha<97 || cha>122){
if(cha == 32){
cha = mAux-1;
}else{
printf("ERROR, esto no es una letra\n");
return(-1);
}
}
if(cha!=(mAux-1)){
cha-=97;
}
mpz_t p,c,aux, x, mod;
mpz_init(p);
mpz_init(c);
mpz_init(aux);
mpz_init(x);
mpz_init(mod);
mpz_set_ui(p,cha);
mpz_mul(aux,a,p);
mpz_add(c,aux,b);
mpz_cdiv_qr(x,mod,c,m);
//gmp_printf("modulo \n");
if(mpz_cmp_ui(mod,0)<0){
mpz_add(mod,mod,m);
}
cint = mpz_get_ui(mod);
if(cint==mAux-1){
cint = 32;
}else{
cint+=97;
}
mpz_clear(c);
mpz_clear(aux);
mpz_clear(x);
mpz_clear(mod);
mpz_clear(p);
return cint;
}
cl_object
_ecl_big_ceiling(cl_object a, cl_object b, cl_object *pr)
{
cl_object q = _ecl_big_register0();
cl_object r = _ecl_big_register1();
mpz_cdiv_qr(q->big.big_num, r->big.big_num, a->big.big_num, b->big.big_num);
*pr = _ecl_big_register_normalize(r);
return _ecl_big_register_normalize(q);
}
void
hex_random_op4 (enum hex_random_op op, unsigned long maxbits,
char **ap, char **bp, char **cp, char **dp)
{
mpz_t a, b, c, d;
unsigned long abits, bbits;
unsigned signs;
mpz_init (a);
mpz_init (b);
mpz_init (c);
mpz_init (d);
if (op == OP_POWM)
{
unsigned long cbits;
abits = gmp_urandomb_ui (state, 32) % maxbits;
bbits = 1 + gmp_urandomb_ui (state, 32) % maxbits;
cbits = 2 + gmp_urandomb_ui (state, 32) % maxbits;
mpz_rrandomb (a, state, abits);
mpz_rrandomb (b, state, bbits);
mpz_rrandomb (c, state, cbits);
signs = gmp_urandomb_ui (state, 3);
if (signs & 1)
mpz_neg (a, a);
if (signs & 2)
{
mpz_t g;
/* If we negate the exponent, must make sure that gcd(a, c) = 1 */
if (mpz_sgn (a) == 0)
mpz_set_ui (a, 1);
else
{
mpz_init (g);
for (;;)
{
mpz_gcd (g, a, c);
if (mpz_cmp_ui (g, 1) == 0)
break;
mpz_divexact (a, a, g);
}
mpz_clear (g);
}
mpz_neg (b, b);
}
if (signs & 4)
mpz_neg (c, c);
mpz_powm (d, a, b, c);
}
else
{
unsigned long qbits;
bbits = 1 + gmp_urandomb_ui (state, 32) % maxbits;
qbits = gmp_urandomb_ui (state, 32) % maxbits;
abits = bbits + qbits;
if (abits > 30)
abits -= 30;
else
abits = 0;
mpz_rrandomb (a, state, abits);
mpz_rrandomb (b, state, bbits);
signs = gmp_urandomb_ui (state, 2);
if (signs & 1)
mpz_neg (a, a);
if (signs & 2)
mpz_neg (b, b);
switch (op)
{
default:
abort ();
case OP_CDIV:
mpz_cdiv_qr (c, d, a, b);
break;
case OP_FDIV:
mpz_fdiv_qr (c, d, a, b);
break;
case OP_TDIV:
mpz_tdiv_qr (c, d, a, b);
break;
}
}
gmp_asprintf (ap, "%Zx", a);
gmp_asprintf (bp, "%Zx", b);
gmp_asprintf (cp, "%Zx", c);
gmp_asprintf (dp, "%Zx", d);
mpz_clear (a);
mpz_clear (b);
mpz_clear (c);
mpz_clear (d);
}
