/* 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); }