int main(int argc, char** argv) { int plen, diff, k, i_l, j_l, k_l; int* i_s; int* j_s; int* k_s; int* primes = find_primes(10000, &plen); for (int i = 0; i < plen; ++i) { for (int j = i + 1; j < (plen-1); ++j) { if (primes[i] < 1000 || primes[j] < 1000 || primes[i] == 1487) continue; // primes[j] > primes[i] diff = primes[j] - primes[i]; k = primes[j] + diff; if (k < 10000 && is_prime(primes, plen, k)) { i_s = split_number(primes[i], &i_l); j_s = split_number(primes[j], &j_l); if (are_perms49(i_s, j_s)) { k_s = split_number(k, &k_l); if (are_perms49(j_s, k_s)) { printf("%d %d %d\n", primes[i], primes[j], k); free(k_s); free(j_s); free(i_s); return 0; } free(k_s); } free(j_s); free(i_s); } } } return 0; }
vector<long long> BigNum::kmul(vector<long long>& numbers, IPos begin, IPos end, vector<long long>& o_numbers, IPos o_begin, IPos o_end, long long base) { if ( (end - begin) <= 1 && (o_end - o_begin) <= 1 ) { vector<long long> res_numbers; long long m1 = (end - begin) == 1 ? (*begin) : 0; long long m2 = (o_end - o_begin) == 1 ? (*o_begin) : 0; res_numbers.push_back(m1 * m2); long long div = res_numbers[0] / base; long i = 0; while ( div != 0 ) { res_numbers[i] %= base; res_numbers.push_back(div); ++i; div = res_numbers[i] / base; } return res_numbers; } long size = max(end - begin, o_end - o_begin); long count = size / 2; if ( size % 2 == 1 ) count++; IPos middle, o_middle; split_number(begin, end, numbers, &middle, count); split_number(o_begin, o_end, o_numbers, &o_middle, count); vector<long long> u1mv1 = kmul(numbers, middle, end, o_numbers, o_middle, o_end, base); vector<long long> u0mv0 = kmul(numbers, begin, middle, o_numbers, o_begin, o_middle, base); vector<long long> u1au0 = add(numbers, middle, end, numbers, begin, middle, base); trim_num_zeroes(u1au0); vector<long long> v1av0 = add(o_numbers, o_middle, o_end, o_numbers, o_begin, o_middle, base); trim_num_zeroes(v1av0); vector<long long> umv = full_kmul(u1au0, v1av0, base); vector<long long> sum2 = full_sub(umv, u0mv0, base); sum2 = full_sub(sum2, u1mv1, base); lshift(&u1mv1, count * 2); lshift(&sum2, count); vector<long long> res = full_add(u1mv1, sum2, base); res = full_add(res, u0mv0, base); trim_num_zeroes(res); return res; }
void Test_join_shares(CuTest* tc) { int n = 200; int t = 100; int shares[n*2]; int count = 255; /* How many times should we test it? */ int j; for (j = 0; j < count; ++j) { int * test = split_number(j, n, t); int i; for (i = 0; i < n; ++i) { shares[i*2] = i + 1; shares[i*2 + 1] = test[i]; } /* Send all n shares */ int result = join_shares(shares, n); free(test); CuAssertIntEquals(tc, j, result); } }
void Test_split_number(CuTest* tc) { seed_random(); int * test = split_number(1234, 50, 20); free(test); CuAssertIntEquals(tc, 0, 0); }
static u_int count_digits(const struct number *n) { struct number *int_part, *fract_part; u_int i; if (BN_is_zero(n->number)) return n->scale ? n->scale : 1; int_part = new_number(); fract_part = new_number(); fract_part->scale = n->scale; split_number(n, int_part->number, fract_part->number); i = 0; while (!BN_is_zero(int_part->number)) { BN_div_word(int_part->number, 10); i++; } free_number(int_part); free_number(fract_part); return (i + n->scale); }
void printnumber(FILE *f, const struct number *b, u_int base) { struct number *int_part, *fract_part; int digits; char buf[11]; size_t sz; int i; struct stack stack; char *p; charcount = 0; lastchar = -1; if (BN_is_zero(b->number)) putcharwrap(f, '0'); int_part = new_number(); fract_part = new_number(); fract_part->scale = b->scale; if (base <= 16) digits = 1; else { digits = snprintf(buf, sizeof(buf), "%u", base-1); } split_number(b, int_part->number, fract_part->number); i = 0; stack_init(&stack); while (!BN_is_zero(int_part->number)) { BN_ULONG rem = BN_div_word(int_part->number, base); stack_pushstring(&stack, get_digit(rem, digits, base)); i++; } sz = i; if (BN_cmp(b->number, &zero) < 0) putcharwrap(f, '-'); for (i = 0; i < sz; i++) { p = stack_popstring(&stack); if (base > 16) putcharwrap(f, ' '); printwrap(f, p); free(p); } stack_clear(&stack); if (b->scale > 0) { struct number *num_base; BIGNUM mult, stop; putcharwrap(f, '.'); num_base = new_number(); BN_set_word(num_base->number, base); BN_init(&mult); BN_one(&mult); BN_init(&stop); BN_one(&stop); scale_number(&stop, b->scale); i = 0; while (BN_cmp(&mult, &stop) < 0) { u_long rem; if (i && base > 16) putcharwrap(f, ' '); i = 1; bmul_number(fract_part, fract_part, num_base); split_number(fract_part, int_part->number, NULL); rem = BN_get_word(int_part->number); p = get_digit(rem, digits, base); int_part->scale = 0; normalize(int_part, fract_part->scale); BN_sub(fract_part->number, fract_part->number, int_part->number); printwrap(f, p); free(p); BN_mul_word(&mult, base); } free_number(num_base); BN_free(&mult); BN_free(&stop); } flushwrap(f); free_number(int_part); free_number(fract_part); }
static void bexp(void) { struct number *a, *p; struct number *r; bool neg; u_int rscale; p = pop_number(); if (p == NULL) return; a = pop_number(); if (a == NULL) { push_number(p); return; } if (p->scale != 0) { BIGNUM *i, *f; i = BN_new(); bn_checkp(i); f = BN_new(); bn_checkp(f); split_number(p, i, f); if (!BN_is_zero(f)) warnx("Runtime warning: non-zero fractional part in exponent"); BN_free(i); BN_free(f); } normalize(p, 0); neg = false; if (BN_is_negative(p->number)) { neg = true; negate(p); rscale = bmachine.scale; } else { /* Posix bc says min(a.scale * b, max(a.scale, scale) */ u_long b; u_int m; b = BN_get_word(p->number); m = max(a->scale, bmachine.scale); rscale = a->scale * (u_int)b; if (rscale > m || (a->scale > 0 && (b == ULONG_MAX || b > UINT_MAX))) rscale = m; } if (BN_is_zero(p->number)) { r = new_number(); bn_check(BN_one(r->number)); normalize(r, rscale); } else { u_int ascale, mscale; ascale = a->scale; while (!BN_is_bit_set(p->number, 0)) { ascale *= 2; bmul_number(a, a, a, ascale); bn_check(BN_rshift1(p->number, p->number)); } r = dup_number(a); bn_check(BN_rshift1(p->number, p->number)); mscale = ascale; while (!BN_is_zero(p->number)) { ascale *= 2; bmul_number(a, a, a, ascale); if (BN_is_bit_set(p->number, 0)) { mscale += ascale; bmul_number(r, r, a, mscale); } bn_check(BN_rshift1(p->number, p->number)); } if (neg) { BN_CTX *ctx; BIGNUM *one; one = BN_new(); bn_checkp(one); bn_check(BN_one(one)); ctx = BN_CTX_new(); bn_checkp(ctx); scale_number(one, r->scale + rscale); if (BN_is_zero(r->number)) warnx("divide by zero"); else bn_check(BN_div(r->number, NULL, one, r->number, ctx)); BN_free(one); BN_CTX_free(ctx); r->scale = rscale; } else normalize(r, rscale); } push_number(r); free_number(a); free_number(p); }