void save_smooth_number(smooth_number_t n) {
if (nb_global_smooth_numbers_found > nb_qr_primes + NB_VECTORS_OFFSET - 1) /* if we have sufficient smooth numbers, skip saving */
return;
mpz_clear(tmp_matrix_row); /* tmp_matrix_row must be initialized already */
mpz_init2(tmp_matrix_row, nb_qr_primes); /* init a vector of *exactly* nb_qr_primes bits */
smooth_number_t tmp;
mpz_init(tmp.value_x);
mpz_init(tmp.value_x_squared);
mpz_init(tmp.factors_vect);
mpz_set(tmp.value_x, n.value_x);
mpz_pow_ui(tmp.value_x_squared, n.value_x, 2);
mpz_sub(tmp.value_x_squared, tmp.value_x_squared, N);
mpz_set(tmp.factors_vect, n.factors_vect);
if (my_rank == 0) /* master appends directly to the matrix */
{
smooth_numbers[nb_global_smooth_numbers_found++] = tmp;
push_row(&matrix, n.factors_vect);
} else /* append smooth number to the temporary list, later they will be sent to master */
{
temp_slaves_smooth_numbers[nb_temp_smooth_numbers++] = tmp;
}
}
int main(int argc, char *argv[]) {
mpz_t base, result;
int i;
int sum = 0;
mpz_init(base);
mpz_init(result);
mpz_set_ui(result, 0);
mpz_set_ui(base, 2);
mpz_pow_ui(result, base, 1000);
size_t sz = mpz_sizeinbase(result, 10);
FILE *file = fopen("tmp.txt", "ab+");
mpz_out_str(file, 10, result);
fclose(file);
file = fopen("tmp.txt", "r");
for (i = 0 ; i < sz ; i++) {
sum += fgetc(file) - '0';
}
fclose(file);
remove("tmp.txt");
printf("%i\n", sum);
return 0;
}
ecc_point* existPoint(mpz_t p){
mpz_t l;
mpz_init(l);
mpz_pow_ui(l,p,3);
mpz_addmul(l,a,p);
mpz_add(l,l,b);
mpz_mod(l,l,prime);
mpz_t i;
mpz_init_set_ui(i,0);
mpz_t y;
mpz_init(y);
if (quadratic_residue(y,l,prime)==1){
gmp_printf("entrei");
ecc_point* r= malloc(sizeof(ecc_point));
mpz_init_set((*r).x,p);
mpz_init_set((*r).y,y);
return r;
} else
return NULL;
/* while(mpz_cmp(i,prime)!=0){
mpz_set(y,i);
mpz_pow_ui(y,y,2);
mpz_mod(y,y,prime);
gmp_printf(" x %Zd Y %Zd \n",l,y);
if (mpz_cmp(y,l)==0){
ecc_point* r= malloc(sizeof(ecc_point));
mpz_init_set((*r).x,p);
mpz_init_set((*r).y,i);
return r;
}else
mpz_add_ui(i,i,1);
}*/
return NULL;
}
int existPoint1(mpz_t x, mpz_t y){
mpz_t exp,eq_result;
mpz_init(eq_result); //Equation Result
mpz_init(exp); //Exponentiation Result
mpz_pow_ui(exp,x,3);
mpz_addmul(exp,x,a);
mpz_add(exp,exp,b);
gmp_printf("%Zd x \n",exp);
mpz_mod(exp,exp,prime);
mpz_pow_ui(eq_result,y,2);
mpz_mod(eq_result,eq_result,prime);
if (mpz_cmp(eq_result,exp)==0)
return 1;
else
return 0;
}
ecc_point* sum(ecc_point p1,ecc_point p2){
ecc_point* result;
result = malloc(sizeof(ecc_point));
mpz_init((*result).x);
mpz_init((*result).y);
if (mpz_cmp(p1.x,p2.x)==0 && mpz_cmp(p1.y,p2.y)==0)
result=double_p(p1);
else
if( mpz_cmp(p1.x,p2.x)==0 && mpz_cmpabs(p2.y,p1.y)==0)
result=INFINITY_POINT;
else{
mpz_t delta_x,x,y,delta_y,s,s_2;
mpz_init(delta_x);
mpz_init(x); mpz_init(y);
mpz_init(s); mpz_init(s_2);
mpz_init(delta_y);
mpz_sub(delta_x,p1.x,p2.x);
mpz_sub(delta_y,p1.y,p2.y);
mpz_mod(delta_x,delta_x,prime);
mpz_invert(delta_x,delta_x,prime);
mpz_mul(s,delta_x,delta_y);
mpz_mod(s,s,prime);
mpz_pow_ui(s_2,s,2);
mpz_sub(x,s_2,p1.x);
mpz_sub(x,x,p2.x);
mpz_mod(x,x,prime);
mpz_set((*result).x,x);
mpz_sub(delta_x,p2.x,x);
mpz_neg(y,p2.y);
mpz_addmul(y,s,delta_x);
mpz_mod(y,y,prime);
mpz_set((*result).y,y);
};
return result;
}
void make_headers(void)
{
mpz_t newk, oldk, thing, div;
mpz_init(newk);
mpz_init(thing);
mpz_ui_pow_ui(thing, 2, M);
mpz_init_set(div, thing);
mpz_init_set_ui(oldk, 3);
int size = SIZE;
for(int i = 0; i <= LEVELS; i++)
{
mpz_set_ui(newk, 0);
int r = 1;
int n;
while(mpz_get_ui(newk) < 3)
{
r++;
double bottom = mpz_get_d(oldk);
n = floor(((M+1)*log(2.0) + log((double) r))/log(bottom));
mpz_pow_ui(thing, oldk, n);
mpz_cdiv_q(newk, thing, div);
}
headers[i].chunksize = n;
headers[i].K = mpz_get_ui(oldk);
mpz_set(oldk,newk);
headers[i].size = size;
size = ceil((double)size/n);
}
fwrite(headers, sizeof(header), LEVELS + 1, output);
mpz_clear(oldk);
mpz_clear(div);
mpz_clear(thing);
mpz_clear(newk);
}
/**
* Returns an array p^(floor(log_p B)) for all primes p <= B.
* @return An array p^(floor(log_p B)) for all primes p <= B.
* Caller must free the returned array.
* @param w is the number of prime powers.
*/
uint32_t* mpz_prime_powers(int* w, const uint32_t B) {
mpz_t p; // prime
mpz_t pp; // prime power
int ppsi; // prime powers index
unsigned long e; // exponent
unsigned long exps[32]; // exponents
int b;
int i;
double dB;
uint32_t* prime_powers;
mpz_init(p);
mpz_init(pp);
*w = count_primes(B);
prime_powers = (uint32_t*)malloc(*w * sizeof(uint32_t));
// check the base cases
if (B == 0 || B == 1) {
return prime_powers;
}
// size of B
b = msb_u32(B) + 1;
// compute the i^th root of B, from 2 to log2(B)-1
dB = (double)B;
exps[0] = 0;
exps[1] = 0;
for (i = 2; i < b; i ++) {
exps[i] = (unsigned long)floor(pow(dB, 1.0/((double)i)));
}
// start with p=2
prime_powers[0] = 1U << (b-1);
ppsi = 1;
// let p=3 be the first odd prime
mpz_set_ui(p, 3);
e = b-1;
while (ppsi < *w) {
// reduce the exponent as appropriate
while (e >= 2 && mpz_cmp_ui(p, exps[e]) > 0) {
e --;
}
// compute the prime power
mpz_pow_ui(pp, p, e);
prime_powers[ppsi] = mpz_get_ui(pp);
ppsi ++;
// move to the next prime
mpz_nextprime(p, p);
}
mpz_clear(pp);
mpz_clear(p);
return prime_powers;
}
void fmpz_pow_ui(fmpz_t output, const fmpz_t input, const unsigned long exp)
{
mpz_t power;
mpz_init(power);
fmpz_to_mpz(power, input);
mpz_pow_ui(power, power, exp);
mpz_to_fmpz(output, power);
mpz_clear(power);
}
void bg_decrypt_block(bg_prikey key, FILE *in, FILE *out, mp_size_t len) {
mpz_t y, xqmp, xpmq, pp, qq, negone;
unsigned long int l;
bbs_state *bbs;
mpz_init(y);
mpz_init(xqmp);
mpz_init(xpmq);
mpz_init(pp);
mpz_init(qq);
mpz_init_set_si(negone, -1);
bbs = init_bbs(negone, key.n);
bbs_gen(bbs, NULL, 8*len, 0);
bbs_iter(bbs);
bbs_close(bbs);
l = bbs->len;
mpz_inp_raw(y, in);
mpz_add_ui(pp, key.p, 1);
mpz_tdiv_q_ui(pp, pp, 4);
mpz_pow_ui(pp, pp, l);
mpz_powm_sec(pp, y, pp, key.p);
mpz_add_ui(qq, key.q, 1);
mpz_tdiv_q_ui(qq, qq, 4);
mpz_pow_ui(qq, qq, l);
mpz_powm_sec(qq, y, qq, key.q);
mpz_mul(xqmp, key.q, pp);
mpz_powm(pp, key.q, negone, key.p);
mpz_mul(xqmp, xqmp, pp);
mpz_mul(xpmq, key.p, qq);
mpz_powm(qq, key.p, negone, key.q);
mpz_mul(xpmq, xpmq, qq);
mpz_add(y, xqmp, xpmq);
mpz_mod(y, y, key.n);
bbs = init_bbs(y, key.n);
while(len && !feof(in)) len -= bg_xor(bbs, in, out, len);
bbs_close(bbs);
}
static CRATIONAL *_powf(CRATIONAL *a, double f, bool invert)
{
ulong p;
mpz_t num, den;
mpq_t n;
if (invert || (double)(int)f != f)
return NULL;
if (f < 0)
{
f = (-f);
invert = TRUE;
}
p = (ulong)f;
mpz_init(num);
mpz_pow_ui(num, mpq_numref(a->n), p);
mpz_init(den);
mpz_pow_ui(den, mpq_denref(a->n), p);
mpq_init(n);
if (invert)
mpz_swap(num, den);
if (mpz_cmp_si(den, 0) == 0)
{
GB.Error(GB_ERR_ZERO);
return NULL;
}
mpq_set_num(n, num);
mpq_set_den(n, den);
mpz_clear(num);
mpz_clear(den);
mpq_canonicalize(n);
return RATIONAL_create(n);
}
void power_mpz(ElementType& result,
const ElementType& a,
const mpz_ptr n) const
{
std::pair<bool, int> n1 = RingZZ::get_si(n);
if (n1.first)
mpz_pow_ui(&result, &a, n1.second);
else
throw exc::engine_error("exponent too large");
}
mpz_class UnivariatePolynomial::eval(const mpz_class &x) const {
//TODO: Use Horner's Scheme
mpz_class ans = 0;
for (const auto &p : dict_) {
mpz_class temp;
mpz_pow_ui(temp.get_mpz_t(), x.get_mpz_t(), p.first);
ans += p.second * temp;
}
return ans;
}
ring_elem RingZZ::power(const ring_elem f, mpz_t n) const
{
mpz_ptr result = new_elem();
int n1;
if (!get_si(n1, n))
{ ERROR("exponent too large"); }
else
mpz_pow_ui(result, f.get_mpz(), n1);
return ring_elem(result);
}
/*------------------------------------------------------------------------*/
static void
stage1_bounds_update(poly_search_t *poly, poly_coeff_t *c)
{
/* determine the parametrs for the collision search,
given one leading algebraic coefficient a_d */
uint32 degree = poly->degree;
double N = mpz_get_d(poly->N);
double high_coeff = mpz_get_d(c->high_coeff);
double m0 = pow(N / high_coeff, 1./degree);
double skewness_min, coeff_max;
/* we don't know the optimal skewness for this polynomial
but at least can bound the skewness. The value of the
third-highest coefficient is from Kleinjung's 2006
poly selection algorithm as published in Math. Comp. */
switch (degree) {
case 4:
skewness_min = sqrt(m0 / poly->norm_max);
coeff_max = poly->norm_max;
break;
case 5:
skewness_min = pow(m0 / poly->norm_max, 2./3.);
coeff_max = poly->norm_max / sqrt(skewness_min);
break;
case 6:
skewness_min = sqrt(m0 / poly->norm_max);
coeff_max = poly->norm_max / skewness_min;
break;
default:
printf("error: unexpected poly degree %d\n", degree);
exit(-1);
}
c->degree = degree;
c->m0 = m0;
c->coeff_max = coeff_max;
c->p_size_max = coeff_max / skewness_min;
/* we perform the collision search on a transformed version
of N and the low-order rational coefficient m. In the
transformed coordinates, a_d is 1 and a_{d-1} is 0. When
a hit is found, we undo the transformation to recover
the correction to m that makes the new polynomial 'work' */
mpz_mul_ui(c->trans_N, c->high_coeff, degree);
mpz_pow_ui(c->trans_N, c->trans_N, degree - 1);
mpz_mul_ui(c->trans_N, c->trans_N, degree);
mpz_mul(c->trans_N, c->trans_N, poly->N);
mpz_root(c->trans_m0, c->trans_N, degree);
}
int
main (int argc, char **argv)
{
mpz_t x2;
mpz_t root1;
mp_size_t x2_size;
int i;
int reps = 5000;
unsigned long nth;
gmp_randstate_ptr rands;
mpz_t bs;
unsigned long bsi, size_range;
tests_start ();
rands = RANDS;
mpz_init (bs);
if (argc == 2)
reps = atoi (argv[1]);
mpz_init (x2);
mpz_init (root1);
/* This triggers a gcc 4.3.2 bug */
mpz_set_str (x2, "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff80000000000000000000000000000000000000000000000000000000000000002", 16);
mpz_root (root1, x2, 2);
check_one (root1, x2, 2, -1);
for (i = 0; i < reps; i++)
{
mpz_urandomb (bs, rands, 32);
size_range = mpz_get_ui (bs) % 12 + 2;
mpz_urandomb (bs, rands, size_range);
x2_size = mpz_get_ui (bs) + 10;
mpz_rrandomb (x2, rands, x2_size);
mpz_urandomb (bs, rands, 15);
nth = mpz_getlimbn (bs, 0) % mpz_sizeinbase (x2, 2) + 2;
mpz_root (root1, x2, nth);
mpz_urandomb (bs, rands, 4);
bsi = mpz_get_ui (bs);
if ((bsi & 1) != 0)
{
/* With 50% probability, set x2 near a perfect power. */
mpz_pow_ui (x2, root1, nth);
if ((bsi & 2) != 0)
{
mpz_sub_ui (x2, x2, bsi >> 2);
mpz_abs (x2, x2);
}
else
int
main (int argc, char **argv)
{
mpz_t x2;
mpz_t x;
mpz_t temp, temp2;
mp_size_t x2_size;
int i;
int reps = 1000;
unsigned long nth;
gmp_randstate_ptr rands;
mpz_t bs;
unsigned long bsi, size_range;
tests_start ();
rands = RANDS;
mpz_init (bs);
if (argc == 2)
reps = atoi (argv[1]);
mpz_init (x2);
mpz_init (x);
mpz_init (temp);
mpz_init (temp2);
for (i = 0; i < reps; i++)
{
mpz_urandomb (bs, rands, 32);
size_range = mpz_get_ui (bs) % 12 + 2;
mpz_urandomb (bs, rands, size_range);
x2_size = mpz_get_ui (bs) + 10;
mpz_rrandomb (x2, rands, x2_size);
mpz_urandomb (bs, rands, 15);
nth = mpz_getlimbn (bs, 0) % mpz_sizeinbase (x2, 2) + 2;
mpz_root (x, x2, nth);
mpz_urandomb (bs, rands, 4);
bsi = mpz_get_ui (bs);
if ((bsi & 1) != 0)
{
/* With 50% probability, set x2 near a perfect power. */
mpz_pow_ui (x2, x, nth);
if ((bsi & 2) != 0)
{
mpz_sub_ui (x2, x2, bsi >> 2);
mpz_abs (x2, x2);
}
else
static void generator_pi(Generator *gen, mpz_t seed, mpz_t pi1, mpz_t pi2) {
int res;
/*
* Pairing function that takes @pi1 and @pi2 and returns the pair as
* @seed. We use @gen as temporary variables, to avoid dynamic
* allocation on each call.
*/
/* CAREFUL: pi1/pi2/seed may *overlap*! */
res = mpz_cmp(pi1, pi2);
if (res < 0) {
mpz_pow_ui(gen->index, pi2, 2);
mpz_add(seed, gen->index, pi1);
} else {
mpz_pow_ui(gen->index, pi1, 2);
mpz_add(gen->index, gen->index, pi1);
mpz_add(seed, gen->index, pi2);
}
}
// Given q, t such that #E(F_q) = q - t + 1, compute #E(F_q^k).
void pbc_mpz_curve_order_extn(mpz_t res, mpz_t q, mpz_t t, int k) {
mpz_t z;
mpz_t tk;
mpz_init(z);
mpz_init(tk);
mpz_pow_ui(z, q, k);
mpz_add_ui(z, z, 1);
pbc_mpz_trace_n(tk, q, t, k);
mpz_sub(z, z, tk);
mpz_set(res, z);
mpz_clear(z);
mpz_clear(tk);
}
uint64_t lpow(mpz_t n, uint64_t k, uint64_t l)
{
//Returns floor(n^(k/l))
assert(n>0); assert(l>0);
mpz_t x;
mpz_init(x);
mpz_set(x,n);
mpz_pow_ui(x, x, k);
mpz_root(x, x, l);
uint64_t y = mpz_get_ui(x);
mpz_clear(x);
return y;
}
int mpow(char* strOut){
mpz_t x, y;
mpz_init_set_str(y, "2", 10);
mpz_pow_ui (y,y,1000);
strncpy(strOut, mpz_get_str(NULL, 10, y), mpz_sizeinbase(y, 10) + 2);
return mpz_sizeinbase(y, 10);
}
// base64 will be a pointer to the converted string
long hex_to_base64(char *hex, char **base64) {
mpz_t decimal;
mpz_init_set_str (decimal, hex, 16);
mpz_t base;
mpz_init_set_ui(base, 64);
mpz_t place_value;
mpz_init(place_value);
long power = 0;
mpz_pow_ui(place_value, base, power);
while(mpz_cmp(decimal, place_value) > 0) {
power++;
mpz_pow_ui(place_value, base, power);
}
long length = power;
*base64 = (char *) malloc(length);
if(power > 0) {
power--;
}
while(power >= 0) {
mpz_pow_ui(place_value, base, power);
mpz_t quotient;
mpz_init(quotient);
mpz_fdiv_q(quotient, decimal, place_value);
unsigned long quotient_ui = mpz_get_ui(quotient);
char place_char = base64_table[quotient_ui];
(*base64)[(length - 1) - power] = place_char;
mpz_t decrement;
mpz_init(decrement);
mpz_mul_ui(decrement, place_value, quotient_ui);
mpz_sub(decimal, decimal, decrement);
power--;
}
return length;
}
void QtGMP::powAB()
{
QString s("");
mpz_t aa,bb,cc;
char *str=0;
mpz_init(cc);
mpz_init_set_str(aa,qPrintable(this->lineEdit1->text()),10);
mpz_init_set_str(bb,qPrintable(this->lineEdit2->text()),10);
mpz_pow_ui(cc,aa,mpz_get_ui(bb));
// gmp_printf("A:\t%Zd\n\B:\t%ZdnA^B:\t%Zd\n\n\n",aa,bb,cc);
s.sprintf("A:\t%s\nB:\t%s\nA^B:\t%s\n",mpz_get_str(str,10,aa),mpz_get_str(str,10,bb),mpz_get_str(str,10,cc));
this->textEdit->setText(s);
mpz_clears(aa,bb,cc,'\0');
}
void init(){
mpz_init(big_temp);
mpz_init(n);
mpz_init(n_plus_1);
mpz_init(n_square);
mpz_init(r);
mpz_init(r_pow_n);
mpz_init(d);
mpz_init(d_inverse);
gmp_randinit_default(state);
gmp_randseed_ui(state, time(NULL));
#if 0
//if (mpz_set_str(n, "179681631915977638526315179067310074434153390395025087607016290555239821629901731559598243352941859391381209211619271844002852733873844383750232911574662592776713675341534697696513241904324622555691981004726000585832862539270063589746625628692671893634789450932536008307903467370375372903436564465076676639793", 10) == -1) {
if (mpz_set_str(n, "32317006071311007300714876688666765257611171752763855809160912665177570453236751584543954797165007338356871062761077928870875400023524429983317970103631801129940018920824479704435252236861111449159643484346382578371909996991024782612350354546687409434034812409194215016861565205286780300229046771688880430612167916071628041661162278649907703501859979953765149466990620201855101883306321620552981581118638956530490592258880907404676403950212619825592177687668726740525457667131084835164607889060249698382116887240122647424904709577375839097384133219410477128893432015573232511359202702215050502392962065602621373646633", 10) == -1) {
printf("\n n = %s is invalid \n", n);
exit(0);
}
#endif
// Get the values of n and d from already generated file
get_n_and_d_from_file();
gmp_printf("n read = %Zd\n", n);
gmp_printf("d read = %Zd\n", d);
mpz_add_ui(n_plus_1, n, 1);
mpz_pow_ui(n_square, n, 2);
//d=lcm(p-1, q-1)
#if 0
//if (mpz_set_str(d, "11230101994748602407894698691706879652134586899689067975438518159702488851868858222474890209558866211961325575726204490250178295867115273984389556973416410372977387708241492548657648934473794873887265114170151559636690542947614482279486573108720489183236783924737117351777821606184702946528449106783160617728", 10) == -1) {
if (mpz_set_str(d, "16158503035655503650357438344333382628805585876381927904580456332588785226618375792271977398582503669178435531380538964435437700011762214991658985051815900564970009460412239852217626118430555724579821742173191289185954998495512391306175177273343704717017406204597107508430782602643390150114523385844440215305904188722327789239808208805874958140879652760769485822638556957710893419557319777578361302813366793271881989825323106333296234499565420424474500540721018071974424406358805685133447529623729447991492181271325655526833481571159446598626059774013428343748622306000136795074246791265885436988193283384961017822594", 10) == -1) {
printf("\n d = %s is invalid \n", d);
exit(0);
}
#endif
if (mpz_invert (d_inverse, d, n_square) == 0) {
printf("\n%s\n", "d^-1 does not exist!");
exit(0);
}
}
//mocked key
void paillier_pubkey::init_key(unsigned int key_bit_size)
{
init_s = 1;
gmp_randstate_t rand;
gmp_randinit_default(rand);
mpz_urandomb(nj[1], rand, key_bit_size);
mpz_add_ui(g, nj[1], 1);
for (int i = 2; i <= init_s+1; i++)
{
mpz_pow_ui(nj[i], nj[1], i);
}
gmp_randclear(rand);
}
static PyObject *
GMPy_XMPZ_IPow_Slot(PyObject *self, PyObject *other, PyObject *mod)
{
mp_bitcnt_t exp;
exp = mp_bitcnt_t_From_Integer(other);
if (exp == (mp_bitcnt_t)(-1) && PyErr_Occurred()) {
PyErr_Clear();
Py_RETURN_NOTIMPLEMENTED;
}
mpz_pow_ui(MPZ(self), MPZ(self), exp);
Py_INCREF((PyObject*)self);
return (PyObject*)self;
}
// given an array of exponents of factors on the base [primes], reconstructs the number
void reconstruct_mpz(mpz_t rop, uint64_t *factors_exp) {
uint64_t i;
mpz_t t;
mpz_init(t);
mpz_t p_exp;
mpz_init(p_exp);
mpz_set_ui(t, 1);
for (i = 0; i < nb_qr_primes; i++) {
mpz_set_ui(p_exp, primes[i]);
mpz_pow_ui(p_exp, p_exp, factors_exp[i]);
mpz_mul(t, t, p_exp);
}
mpz_set(rop, t);
}
static CBIGINT *_powf(CBIGINT *a, double f, bool invert)
{
if (invert)
{
mpz_t b;
if (!mpz_fits_slong_p(a->n))
return NULL;
mpz_init_set_si(b, (long)f);
mpz_pow_ui(b, b, mpz_get_si(a->n));
return BIGINT_create(b);
}
else
return BIGINT_make_int(a, f, mpz_pow_ui);
}
int main()
{
mpz_t a;
mpz_init_set_ui(a, 5);
mpz_pow_ui(a, a, 1 << 18); /* 2**18 == 4**9 */
int len = mpz_sizeinbase(a, 10);
printf("GMP says size is: %d\n", len);
/* because GMP may report size 1 too big; see doc */
char *s = mpz_get_str(0, 10, a);
printf("size really is %d\n", len = strlen(s));
printf("Digits: %.20s...%s\n", s, s + len - 20);
// free(s); /* we could, but we won't. we are exiting anyway */
return 0;
}
int main()
{
mpz_t nm,rez;
mpz_init(nm);
mpz_init(rez);
mpz_set_ui(rez,0);
for (auto i = 1; i <= 10000; i++)
{
mpz_set_ui(nm, i);
mpz_pow_ui(nm,nm, i);
mpz_add(rez,rez,nm);
}
return gmp_printf("%Zd\n" , rez);
}
static PyObject *
GMPy_MPZ_IPow_Slot(PyObject *self, PyObject *other, PyObject *mod)
{
MPZ_Object *r;
mp_bitcnt_t exp;
exp = mp_bitcnt_t_From_Integer(other);
if (exp == (mp_bitcnt_t)(-1) && PyErr_Occurred()) {
PyErr_Clear();
Py_RETURN_NOTIMPLEMENTED;
}
if (!(r = GMPy_MPZ_New(NULL)))
return NULL;
mpz_pow_ui(r->z, MPZ(self), exp);
return (PyObject*)r;
}
