int main(int argc, const char *argv[])
{
mpz_t largenum;
int weight;
clock_t ticks1, ticks2;
if (argc < 3) {
printf("Usage: %s <number> <weight>\n", argv[0]);
return EXIT_FAILURE;
}
if (mpz_init_set_str(largenum, argv[1], 10) < 0) {
perror("Invalid number");
return EXIT_FAILURE;
}
struct sched_param params;
params.sched_priority = 2;
fprintf(stderr, "setting scheduler %li\n", syscall(156, getpid(), 6, ¶ms));
weight = atoi(argv[2]);
sleep(1);
fprintf(stderr, "getting scheduler %li %ld\n", syscall(157, getpid()), syscall(378, getpid()));
setweight(0, weight);
ticks1 = clock();
find_factors(largenum);
ticks2 = clock();
fprintf(stderr, "Time %ld\n", ticks2-ticks1);
return EXIT_SUCCESS;
}
// This algorithm factors each element a ∈ S over P if P is a base for S; otherwise it proclaims failure.
//
// Algorithm 21.2 [PDF page 27](http://cr.yp.to/lineartime/dcba-20040404.pdf)
//
// See [findfactors test](test-findfactors.html) for basic usage.
void find_factors(mpz_array *out, mpz_t *s, size_t from, size_t to, mpz_array *p) {
mpz_t x, y, z;
mpz_array d, q;
size_t i, n = to - from;
mpz_init(x);
array_prod(p, x);
mpz_init(y);
prod(y, s, from, to);
mpz_init(z);
ppi(z, x, y);
array_init(&d, p->size);
array_split(&d, z, p);
array_init(&q, p->size);
for (i = 0; i < p->used; i++) {
if (mpz_cmp(d.array[i], p->array[i]) == 0)
array_add(&q, p->array[i]);
}
if (n == 0) {
array_find_factor(out, y, &q);
} else {
find_factors(out, s, from, to - n/2 - 1, &q);
find_factors(out, s, to - n/2, to, &q);
}
mpz_clear(x);
mpz_clear(y);
mpz_clear(z);
array_clear(&d);
array_clear(&q);
}
void deal_complex_number(char *line)
{
t_big_num *big_num;
const int bignum_len = get_bignum_len(line);
int i;
const int len = ft_strlen(line);
if (!(big_num = malloc(sizeof(t_big_num))))
return ;
if (!(big_num->num = malloc(sizeof(unsigned long) * bignum_len)))
return ;
big_num->length = bignum_len;
i = -1;
while (len > (++i + 1) * 9)
{
big_num->num[i] = n_a_to_ll((line + len - (i + 1) * 9), 10);
}
big_num->num[i] = n_a_to_ll(line, (len - i * 9) + 1);
find_factors(line, big_num);
}
/*--------------------------------------------------------------------*/
uint32 factor_mpqs(msieve_obj *obj, mp_t *n,
factor_list_t *factor_list) {
uint32 bits, fb_size;
prime_list_t prime_list;
fb_t *factor_base;
uint32 *modsqrt_array;
sieve_param_t params;
relation_t *relation_list = NULL;
uint32 num_relations = 0;
la_col_t *cycle_list = NULL;
uint32 num_cycles = 0;
poly_t *poly_list = NULL;
mp_t *poly_a_list = NULL;
uint64 *bitfield = NULL;
uint32 multiplier;
uint32 factor_found = 0;
/* Calculate the factor base bound */
bits = mp_bits(n);
get_sieve_params(bits, ¶ms);
if (params.fb_size < 100)
params.fb_size = 100;
logprintf(obj, "commencing quadratic sieve (%u-digit input)\n",
strlen(mp_sprintf(n, 10, obj->mp_sprintf_buf)));
/* Make a prime list, use it to build a factor base */
fill_prime_list(&prime_list, 2 * params.fb_size + 100, MAX_FB_PRIME);
build_factor_base(n, &prime_list, &factor_base,
&modsqrt_array, ¶ms.fb_size,
&multiplier);
fb_size = params.fb_size;
logprintf(obj, "using multiplier of %u\n", multiplier);
free(prime_list.list);
/* Proceed with the algorithm */
do_sieving(obj, n, &poly_a_list, &poly_list,
factor_base, modsqrt_array, ¶ms, multiplier,
&relation_list, &num_relations,
&cycle_list, &num_cycles);
free(modsqrt_array);
if (relation_list == NULL || cycle_list == NULL ||
cycle_list == NULL || poly_a_list == NULL || poly_list == NULL) {
free(factor_base);
return 0;
}
solve_linear_system(obj, fb_size, &bitfield,
relation_list, cycle_list, &num_cycles);
if (bitfield != NULL && num_cycles > 0) {
factor_found = find_factors(obj, n, factor_base, fb_size,
cycle_list, num_cycles,
relation_list, bitfield,
multiplier, poly_a_list, poly_list,
factor_list);
}
free(factor_base);
free(bitfield);
free_cycle_list(cycle_list, num_cycles);
qs_free_relation_list(relation_list, num_relations);
free(poly_list);
free(poly_a_list);
return factor_found;
}
// #### array verison
void array_find_factors(mpz_array *out, mpz_array *s, mpz_array *p) {
if (s->used > 0)
find_factors(out, s->array, 0, s->used-1, p);
else
fprintf(stderr, "array_printfactors_set on empty array\n");
}
