/* not canonicalized */
void _lsrt_mpq_set_decimal(mpq_t q, const char *ptr, int radix)
{
mpz_t num, dec, exp;
mpq_t addend;
int ex, expdigits;
int s, e;
char ch = '+';
if (radix != 10)
lsrt_error("unsupported radix for exact decimal number: %d", radix);
mpz_init_set_ui(num, 0);
mpz_init_set_ui(dec, 0);
mpz_init(exp);
mpq_init(addend);
e = 0;
sscanf(ptr, "%[+-]%n", &ch, &e);
ptr += e;
e = 0;
gmp_sscanf(ptr, "%Zd%n", num, &e);
ptr += e;
s = 0;
e = 0;
expdigits = 0;
gmp_sscanf(ptr, ".%n%Zd%n", &s, dec, &e);
ptr += e;
if (e >= s)
expdigits = e - s;
s = 0;
e = 0;
ex = 0;
sscanf(ptr, "@%n%d%n", &s, &ex, &e);
if (e - s >= 5 || ex >= 256)
lsrt_error("decimal number out of range");
mpz_set(mpq_numref(q), dec);
mpz_ui_pow_ui(mpq_denref(q), radix, expdigits);
mpq_set_z(addend, num);
mpq_add(q, q, addend);
if (ex > 0) {
mpz_ui_pow_ui(exp, 10, ex); /* exponent is always in radix 10 */
mpz_mul(mpq_numref(q), mpq_numref(q), exp);
} else if (ex < 0) {
mpz_ui_pow_ui(exp, 10, -ex);
mpz_mul(mpq_denref(q), mpq_denref(q), exp);
}
if (ch == '-')
mpz_neg(mpq_numref(q), mpq_numref(q));
mpq_clear(addend);
mpz_clear(exp);
mpz_clear(num);
mpz_clear(dec);
}
void BigFixedPoint::scale(int decimals)
{
int adjustment = decimals - decimalPlaces;
if (adjustment > 0)
{
mpz_class factor;
mpz_ui_pow_ui(factor.get_mpz_t(), 10, adjustment);
mpz_class adjusted = number * factor;
number = adjusted;
decimalPlaces = decimals;
} else if (adjustment < 0) {
mpz_class factor;
mpz_ui_pow_ui(factor.get_mpz_t(), 10, abs(adjustment));
if (roundingEnabled)
{
//qDebug() << "Rounding " << QString::fromStdString(number.get_str())
// << "from " << decimalPlaces << " to " << decimals;
mpz_class adjNum;
mpz_ui_pow_ui(adjNum.get_mpz_t(), 10, abs(adjustment)-1);
adjNum = 5*adjNum;
//qDebug() << "Adjnum = " << QString::fromStdString(adjNum.get_str());
number += adjNum;
//qDebug() << "number adjusted = " << QString::fromStdString(number.get_str());
}
mpz_class adjusted = number / factor;
number = adjusted;
decimalPlaces = decimals;
} else {
// Scaled correctly, do nothing
}
}
int main() {
unsigned long long a,b;
mpz_t a2, b3, v, sum;
mpz_init(a2);
mpz_init(b3);
mpz_init(v);
mpz_init_set_ui(sum, 0);
for (b = 1; b < sqrt(MAX); b++) {
mpz_ui_pow_ui(b3, b, 3);
for (a = 1; a < b ; a++) {
mpz_ui_pow_ui(a2, a, 2);
mpz_add(v, a2, b3);
if (!mpz_divisible_ui_p(v, a)) {
continue;
}
mpz_div_ui(v, v, a);
if (mpz_perfect_square_p(v)) {
mpz_add(sum, sum, v);
printf("%s %llu %llu\n", mpz_get_str(NULL, 10, v), a, b);
}
}
}
return(0);
}
int
main (int argc, char **argv)
{
char str[1000];
gmp_randstate_t rnd;
mpz_t x, y, z;
int i, j, k, s;
tests_start ();
gmp_randinit_default (rnd);
mpz_init(x);
mpz_init(y);
mpz_init(z);
for( i = 0 ; i < sizeof(tests1) / sizeof(tests1[0]) ; ++i )
{
mpz_ui_pow_ui(x, 10, tests1[i].pow10);
mpz_next_prime_candidate(y, x, rnd);
mpz_sub(y, y, x);
j = mpz_get_ui(y);
if(j != tests1[i].np_off)
{
printf("\nnext_likely_prime(10^%d) - 10^%d: expected %d but got %d",
tests1[i].pow10, tests1[i].pow10, tests1[i].np_off, j);
abort();
}
}
for( i = 0 ; i < sizeof(tests2) / sizeof(tests2[0]) ; ++i )
{
mpz_ui_pow_ui(x, 10, tests2[i].pow10);
mpz_set(y, x);
s = j = 0;
for( ; ; )
{
mpz_next_prime_candidate(y, y, rnd);
mpz_sub(z, y, x);
k = mpz_get_si(z);
if(k >= 1000)
break;
j++;
s += k * k;
}
if(j != tests2[i].count || s != tests2[i].sumsq)
{
printf("\nnext_likely_prime failed test2[%d], expected %d and %d but got %d and %d",
i, tests2[i].count, tests2[i].sumsq, j, s);
abort();
}
}
gmp_randclear (rnd);
mpz_clear(z);
mpz_clear(y);
mpz_clear(x);
tests_end ();
exit (0);
}
void nBinEqvCod::calc_eVec_byStr(nBinEqvVec* v)
{
v->n = n;
v->w = w;
v->ab = new int[n];
v->a = new int[w];
v->CaInt = new int[n];
QStringList list = v->Ca.split(' ', QString::SkipEmptyParts);
if (list.count() != n)
qDebug() << "Split err!";
for (int i = 0, j = 0; i < n; ++i)
{
v->CaInt[i] = list[i].toInt();
if (v->CaInt[i] != 0)
{
v->ab[i] = 1;
v->a[j] = v->CaInt[i];
++j;
}
else
v->ab[i] = 0;
}
v->Ab = 0;
for (int i = 0, l = 0; i < n; ++i)
{
if (v->ab[n - i - 1] == 1)
{
mpz_class j = (comb((n - i - 1), (w - l)));
if (j >= 0)
{
v->Ab += j;
++l;
}
}
}
v->Ap = 0;
for (int i = 0; i < w; ++i)
{
mpz_class res;
mpz_ui_pow_ui(res.get_mpz_t(), (q - 1), i);
v->Ap += res * (v->a[i] - 1);
}
mpz_class temp;
mpz_ui_pow_ui(temp.get_mpz_t(), (q - 1), w);
v->A = v->Ab * temp + v->Ap;
}
int main()
{
mpz_int f, g;
mpz_ui_pow_ui(f.backend().data(), 3, 150000); // 3^150000, 71569 digits
mpz_ui_pow_ui(g.backend().data(), 5, 100000); // 5^100000, 69898 digits
mpz_int result = toom_3(f, g);
std::cout << result % 100000000 << std::endl;
return 0;
}
unsigned long my_div_estimate_threshold()
{
const double log10 = 3.321928;
clock_t begin, end, diff1, diff2;
mpz_t y, x;
unsigned long digits = 100, min_digits, max_digits, prec, stage = 1;
div_threshold = 0;
for (;;) {
if (stage == 1)
digits *= 2;
else
digits = (min_digits + max_digits)/2;
prec = (unsigned long) (digits * log10) + 32;
my_init(prec);
mpz_init(y);
mpz_init(x);
mpz_ui_pow_ui(y, 10, digits);
mpz_ui_pow_ui(x, 10, digits/10);
begin = clock();
my_divexact(y, y, x);
end = clock();
diff1 = end - begin;
mpz_ui_pow_ui(y, 10, digits);
begin = clock();
mpz_divexact(y, y, x);
end = clock();
diff2 = end - begin;
my_clear();
mpz_clear(y);
mpz_clear(x);
printf("digits %ld, my %ld, mpz %ld\n", digits, diff1, diff2);
if (stage == 1) {
if (diff1 >= 10 && diff1 < diff2) {
stage = 2;
min_digits = digits/2;
max_digits = digits;
}
} else {
if (diff1 < diff2)
max_digits = digits;
else
min_digits = digits;
if (max_digits - min_digits < 100)
break;
}
}
return (unsigned long) (digits * log10);
}
int main() {
mpz_class base, sum(0);
mpz_ui_pow_ui(base.get_mpz_t(), 10, 10);
for (int i = 1; i <= 1000; ++i) {
mpz_class m;
mpz_ui_pow_ui(m.get_mpz_t(), i, i);
m %= base;
sum += m;
}
sum %= base;
std::cout << sum << "\n";
return 0;
}
void
generate (int limb_bits, int nail_bits, int base)
{
int numb_bits = limb_bits - nail_bits;
mpz_set_ui (t, 1L);
mpz_mul_2exp (t, t, numb_bits);
mpz_set_ui (big_base, 1L);
chars_per_limb = 0;
for (;;)
{
mpz_mul_ui (big_base, big_base, (long) base);
if (mpz_cmp (big_base, t) > 0)
break;
chars_per_limb++;
}
chars_per_bit_exactly = 0.69314718055994530942 / log ((double) base);
mpz_ui_pow_ui (big_base, (long) base, (long) chars_per_limb);
normalization_steps = limb_bits - mpz_sizeinbase (big_base, 2);
mpz_set_ui (t, 1L);
mpz_mul_2exp (t, t, 2*limb_bits - normalization_steps);
mpz_tdiv_q (big_base_inverted, t, big_base);
mpz_set_ui (t, 1L);
mpz_mul_2exp (t, t, limb_bits);
mpz_sub (big_base_inverted, big_base_inverted, t);
}
void decode_all(int* array, header h, int level)
{
if(!level)
{
return finish(array);
}
int* new_array = malloc(sizeof(int)*headers[level-1].size);
int index = 0;
mpz_t number, spill;
mpz_init(number);
mpz_init(spill);
for(int i = 0; i < h.size; i++)
{
mpz_ui_pow_ui(spill, 2, M);
mpz_set(number, remainders[level-1][i]);
mpz_addmul_ui(number, spill, array[i]);
int min = headers[level-1].chunksize > (headers[level-1].size - index)?(headers[level-1].size - index):headers[level-1].chunksize;
for(int j = 0; j < min; j++)
{
new_array[index + min - j - 1] = mpz_fdiv_q_ui(number, number, headers[level-1].K);
}
index += min;
}
return decode_all(new_array, headers[level - 1], level - 1);
}
MP_INT Encode (int p, int length, int *list)
{
MP_INT powers, code;
int i;
mpz_init_set_ui (&code, 0);
for (i = 1; i <= length; ++i) {
mpz_init_set_si (&powers, 0);
if (list[i] != 0)
mpz_ui_pow_ui (&powers, p, i-1);
mpz_add (&code, &code, &powers);
}
/*
if (list[i] != 0) {
MP_INT factor;
mpz_init_set_si (&factor, list[i]);
mpz_ui_pow_ui (&powers, p, i);
mpz_mul (&powers, &powers, &factor);
mpz_add (&code, &code, &powers);
}
}
*/
return code;
}
int main(int argc, char *argv[]) {
int i = 0, num_arg = 0;
mpz_t max, unit, num, token;
if (argc < 2) {
fprintf(stderr, "Usage: %s <num_tokens>\n", argv[0]);
exit(EXIT_FAILURE);
}
if (1 != sscanf(argv[1], "%d", &num_arg)) {
fprintf(stderr, "Cannot parse %s as number of tokens.\n", argv[1]);
exit(EXIT_FAILURE);
}
mpz_init(max);
mpz_init(unit);
mpz_init(num);
mpz_init(token);
mpz_set_ui(num, num_arg);
mpz_set_ui(token, 0); // start at token 0
mpz_ui_pow_ui(max, 2, (128-1));
mpz_tdiv_q(unit, max, num);
for (; i < num_arg; i++) {
gmp_printf("%Zd\n", token);
mpz_add(token, token, unit);
}
return 0;
}
int main()
{
FILE* file;
file = fopen("result.txt", "w+");
char digit;
int sum = 0;
mpz_t result;
if (file != NULL)
{
mpz_init(result);
mpz_ui_pow_ui(result, 2, 1000);
mpz_out_str(file, 10, result);
fseek(file, 0, SEEK_SET);
while ((digit=fgetc(file)) != EOF)
{
sum += (int)(digit-'0');
}
}
std::cout << sum << std::endl;
mpz_clear(result);
fclose(file);
return 0;
}
/* Called when s is supposed to be floor(root(u,z)), and r = u - s^z */
static int
rootrem_valid_p (const mpz_t u, const mpz_t s, const mpz_t r, unsigned long z)
{
mpz_t t;
mpz_init (t);
if (mpz_fits_ulong_p (s))
mpz_ui_pow_ui (t, mpz_get_ui (s), z);
else
mpz_pow_ui (t, s, z);
mpz_sub (t, u, t);
if (mpz_sgn (t) != mpz_sgn(u) || mpz_cmp (t, r) != 0)
{
mpz_clear (t);
return 0;
}
if (mpz_sgn (s) > 0)
mpz_add_ui (t, s, 1);
else
mpz_sub_ui (t, s, 1);
mpz_pow_ui (t, t, z);
if (mpz_cmpabs (t, u) <= 0)
{
mpz_clear (t);
return 0;
}
mpz_clear (t);
return 1;
}
mpz_class* gen_number(const str* h, const str* seed, unsigned int v, unsigned int w) {
str* h_0 = extract_right_bits(h, w);
mpz_class* z = expand(seed);
str* hi = new str[v + 1];
hi[0] = *h_0;
for (int i = 1; i < v + 1; i++) {
mpz_class z_plus_i((*z) + i), p, r;
mpz_ui_pow_ui(p.get_mpz_t(), 2, 160);
mpz_mod(r.get_mpz_t(), z_plus_i.get_mpz_t(), p.get_mpz_t()); // r = (z+i) % 2^160
str* si = expand(&r);
str* tmp = sha1(si);
hi[i] = *tmp;
}
delete z;
h = str_concat(hi, v + 1);
delete[] hi;
mpz_class* c = expand(h);
delete h;
return c;
}
mpz_class chudnovsky(int digits)
{
digits += EXTRA_DIGITS;
const double digits_per_term = log10(151931373056000ll); // log(C_cubed_over_24 / 72);
int N = int(digits / digits_per_term) + 1;
std::cout << "Binary splitting max: " << N << std::endl;
mpz_class P, Q, T;
bs(0, N, P, Q, T);
mpz_class one;
mpz_ui_pow_ui(one.get_mpz_t(), 10, digits);
mpz_class sqrt_10005 = one * 10005;
mpz_sqrt(sqrt_10005.get_mpz_t(), sqrt_10005.get_mpz_t());
mpz_class pi = (Q * 426880 * sqrt_10005) / T;
//int bin_digits = int(digits * log2(10));
//int precision = bin_digits + EXTRA_DIGITS;
//std::cout << "Precision: " << precision << std::endl;
//mpf_set_default_prec(precision);
//mpf_class Q_float(Q);
//mpf_class T_float(T);
//mpf_class sqrt_10005;
//mpf_sqrt_ui(sqrt_10005.get_mpf_t(), 10005);
//std::cout << sqrt_10005 << std::endl; // Correct precision
//mpf_class pi = (Q_float * 426880 * sqrt_10005) / T_float;
return pi;
}
void int_to_chargg(mpz_t we, int poz){
int l,ll;
mpz_set(wep,we);
mpz_ui_pow_ui(we_p,ch,m-1);
mpz_tdiv_q(we_p2,wep,we_p);
tab[(poz*m+0)]=mpz_get_ui(we_p2);
l=0;
for (ll=m-1;ll>1;ll--) {l++;
mpz_ui_pow_ui(we_p,ch,ll);
mpz_mod(we_p,wep,we_p);
mpz_ui_pow_ui(we_p2,ch,ll-1);
mpz_tdiv_q(we_p,we_p,we_p2);
tab[(poz*m+l)]=mpz_get_ui(we_p);
}
mpz_mod_ui(we_p,wep,ch);
tab[(poz*m+l+1)]=mpz_get_ui(we_p); }
// NOTE: I got stuck for two days while bruteforcing my way out.
//
// Courtesy of http://mukeshiiitm.wordpress.com/2011/02/11/project-euler-problem-100/
int main() {
mpz_class N;
mpz_ui_pow_ui(N.get_mpz_t(), 10, 12);
ContinuedFraction fraction = ContinuedFraction::squareRoot(8);
mpq_class beforeLast, last, current = fraction.getConvergent(0);
for (int n = 1; ; ++n) {
beforeLast = last;
last = current;
current = (n == 1)? fraction.getConvergent(1):
fraction.getNextConvergent(n, beforeLast, last);
mpz_class x2, r2;
mpz_pow_ui(x2.get_mpz_t(), current.get_num().get_mpz_t(), 2);
mpz_pow_ui(r2.get_mpz_t(), current.get_den().get_mpz_t(), 2);
if (x2 - 8 * r2 == 1) {
mpz_class result = 2 * current.get_den() + (current.get_num() + 1) / 2;
if (result > N) {
std::cout << result - current.get_den() << "\n";
break;
}
}
}
return 0;
}
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);
}
/*
* === FUNCTION ======================================================================
* Name: convertToInt
* Description:
* =====================================================================================
*/
mpz_t *convertToInt(char *str, int str_size, int block_size, int *ret_size) {
mpz_t *result, tmp;
int res_size = str_size / block_size + 1, pts = 0, pta = -1, i;
unsigned long int pow = block_size;
result = (mpz_t *) malloc (res_size * sizeof(mpz_t));
for (i=0; i<res_size; i++)
mpz_init(result[i]);
mpz_init(tmp);
while (str[pts] != '\0') {
if (!(pts % block_size)) {
pow = block_size - 1;
pta ++;
}
mpz_ui_pow_ui(tmp, NB_CHAR, pow);
mpz_mul_ui(tmp, tmp, (unsigned int)str[pts]);
mpz_add(result[pta], result[pta], tmp);
pts++;
pow --;
}
*ret_size = res_size;
return result;
} /* ----- end of function convertToInt ----- */
nBinEqvCod::nBinEqvCod(int n, int w, int q) : n(n), w(w), q(q)
{
omp_set_dynamic(1);
omp_set_num_threads(8);
mpz_ui_pow_ui(qw.get_mpz_t(), (q - 1), w);
//qw = qPow((q - 1), w);
//qw = Bigint(q-1).pow(w);
M = mpz_class(qw) * comb(n, w); // factorial(n) / (factorial(w) * factorial(n - w));
//code = new nBinEqvVec[M];
code = nullptr;
qDebug() << "Creating non_binary equivalent codes";
qDebug() << "n:" << n << "\tw: " << w << "\tq:" << q << "\tM: " << M.get_str().c_str();
//#pragma omp parallel for
//for (int i = 0; i < M; ++i)
//{
// calc_eVec(i, &code[i]);
// mapNBEV.insert(code[i].Ca, &code[i]);
//}
//--------------------------------------------------
//QTime midnight(0, 0, 0);
//qsrand(midnight.secsTo(QTime::currentTime()));
//code = new nBinEqvVec[3];
//calc_eVec(qrand() % M, code[0]);
//calc_eVec(qrand() % M, code[1]);
//calc_eVec(qrand() % M, code[2]);
}
int main(void) {
unsigned int maxsum = 0;
mpz_t num;
mpz_init(num);
char numstr[200] = "";
for (unsigned int base = 51; base < 100; ++base) {
if (base % 10 == 0) {
continue;
}
for (unsigned int exp = 70; exp <= 100; ++exp) {
mpz_ui_pow_ui(num, base, exp);
mpz_get_str(numstr, 10, num);
unsigned int sum = 0;
for (char* digit = numstr; *digit; ++digit) {
sum += *digit - '0';
}
if (sum > maxsum) {
maxsum = sum;
}
}
}
printf("%u\n", maxsum);
return 0;
}
int generate_key(ptr_curve_t E, ptr_point_t G, ptr_point_t Q, bases_t d_bases)
{
mpz_t n;
mpz_init(n);
mpz_ui_pow_ui(n,2,M);
if(DEBUG)gmp_printf("%Zd\n",n);
gmp_randstate_t rand_stat;
gmp_randinit_mt(rand_stat);
gmp_randseed_ui(rand_stat,time(NULL));
mpz_t d;
mpz_init(d);
mpz_urandomb(d,rand_stat,M);
if(DEBUG)gmp_printf("%Zd\n",d);
bases_init(d_bases);
int_to_bases(d,d_bases);
point_init(Q);
multiple_point_CE(E,G,d_bases,Q);
if(DEBUG)
{
bases_print(d_bases);
printf("\n");
point_print(Q,"Q");
}
char buffer [1024];
FILE *pub, *priv;
pub = fopen("./pub.key","w+");
if(pub != NULL){
memset(buffer, '\0', sizeof(buffer));
bases_to_string(Q->_x,buffer);
fputs(buffer,pub);
fputs(";",pub);
memset(buffer, '\0', sizeof(buffer));
bases_to_string(Q->_y,buffer);
fputs(buffer,pub);
fclose(pub);
}
else
return ERROR;
priv = fopen("./priv.key","w+");
if(priv != NULL){
memset(buffer, '\0', sizeof(buffer));
bases_to_string(d_bases,buffer);
fputs(buffer,priv);
fclose(priv);
}
else
return ERROR;
return NERROR;
}//generate_key()
// This algorithm finds cb(P ∪ Q) if P is coprime and Q is coprime
//
// Algorithm 17.3 [PDF page 23](http://cr.yp.to/lineartime/dcba-20040404.pdf)
//
// See [cbmerge test](test-cbmerge.html) for basic usage.
void cbmerge(mpz_array *s, mpz_array *p, mpz_array *q) {
mpz_array t; // T
mpz_array r; // buffer for q_k : bit_i k = 0 and q_k : bit_i k = 1
size_t n = q->used;
size_t b = 0;
size_t i = 0;
size_t k = 0;
mpz_t x; // buffer
mpz_init(x);
// Find the smallest b ≥ 1 with 2^b.
do {
b++;
mpz_ui_pow_ui(x, 2, b);
} while(mpz_cmp_ui(x, n) < 0);
// Set S ← P.
array_copy(s, p);
while(1) {
// If i = b: Print S. Stop.
if (i == b) {
mpz_clear(x);
return;
}
// Find R ← {qk : bit(k) = 1}
array_init(&r, n);
for(k=0; k<n; k++) {
if (!bit(i,k)) array_add(&r, q->array[k]);
}
// Compute x ← prod{R}
array_prod(&r, x);
// Compute T ← cbextend(S ∪ {x})
array_init(&t, s->size);
cbextend(&t, s, x);
// Find R ← {qk : bit(k) = 1}
array_clear(&r);
array_init(&r, n);
for(k=0; k<n; k++) {
if (bit(i,k)) array_add(&r, q->array[k]);
}
// Compute x ← prod{R}
array_prod(&r, x);
// Compute S ← cbextend(T ∪ {x})
array_clear(s);
array_init(s, s->size);
cbextend(s, &t, x);
// Free the memory.
array_clear(&r);
array_clear(&t);
i++;
}
}
char * get_digits(int n, size_t* len)
{
mpz_ui_pow_ui(pows, 10, n + 20);
actan(t5, 5, pows);
mpz_mul_ui(t5, t5, 16);
actan(t239, 239, pows);
mpz_mul_ui(t239, t239, 4);
mpz_sub(t5, t5, t239);
mpz_ui_pow_ui(pows, 10, 20);
mpz_tdiv_q(t5, t5, pows);
*len = mpz_sizeinbase(t5, 10);
return mpz_get_str(0, 0, t5);
}
void calc(int d,int n,mpz_t r) {
mpz_t t;
mpz_init(t);
mpz_ui_pow_ui(t,2,n/d);
mpz_mul_si(t,t,phi(2*d));
mpz_add(r,r,t);
mpz_clear(t);
}
void sum_of_self_powers_upto(mpz_t sum, unsigned limit){
mpz_set_ui(sum, 0);
mpz_t term;
mpz_init(term);
for (unsigned i = 1; i <= limit; i++){
mpz_ui_pow_ui(term, i, i);
mpz_add(sum, sum, term);
}
}
int main() {
mpz_t num;
mpz_init2(num, 1000); /* initialize with 1000 bits */
mpz_ui_pow_ui(num, 2, 1000);
printf("Answer: %lu\n", gmp_digital_sum(num));
mpz_clear(num);
return 0;
}
/**
* \fn void gpa(mpz_t nombreRandom, unsigned int n, gmp_randstate_t state)
* \brief Génère un entier GMP (mpz_t) aléatoire > 2^n
* \param nombreRandom le nombre aléatoire
* \param n taille (en bits) minimale de nombreRandom
* */
void gpa(mpz_t nombreRandom, unsigned int n, gmp_randstate_t state)
{
mpz_t nombreTemp;
mpz_init(nombreTemp);
mpz_ui_pow_ui (nombreTemp, 2, n-1); // 2^(n-1) minimum
mpz_urandomb(nombreRandom, state, n);// aléatoire entre 0 et 2^n -1
mpz_add(nombreRandom, nombreRandom, nombreTemp);
mpz_clear(nombreTemp);
}
void seventh_fermat_number( void )
{
mpz_t n;
mpz_init( n );
mpz_ui_pow_ui( n, 2, 128 );
mpz_add_ui( n, n, 1);
printf(" 2 ** 7 = 128\n");
gmp_printf("2 ** (2 ** 7) + 1: %Zd\n", n);
}
