int main (int argc, char ** argv) { if (argc != 2) { fprintf (stderr, "usage: %s <N>\n", argv[0]); return 1; } int N = atoi (argv[1]); if (N < 3) return 1; bool * primes = eratosthenes_sieve (N); int max_sum = 0; int max_count = 0; for (int i = 2; i < N; i++) { if (!primes[i]) continue; int count = 0; int sum = sum_primes (primes, &count, i, N); if (count > max_count) { max_sum = sum; max_count = count; } } printf ("%d\n", max_sum); free (primes); return 0; }
int main (int argc, char ** argv) { if (argc != 2) { fprintf (stderr, "usage: %s <N>\n", argv[0]); return 1; } int N = atoi (argv[1]); if (N < 1 || N >= DIGITS_COUNT) return 1; int primes_limit = sqrt (power (10, N)) + 1; bool * primes = eratosthenes_sieve (primes_limit); char digits[DIGITS_COUNT]; int digit = 0; for (int i = N; i > 0; i--) digits[digit++] = i + '0'; digits[digit] = '\0'; while (prev_permutation (digits)) { if (is_prime (atoi (digits), primes, primes_limit)) { printf ("%s\n", digits); break; } } free (primes); return 0; }
int main (int argc, char ** argv) { if (argc != 2) { fprintf (stderr, "usage: %s <N>\n", argv[0]); return 1; } int N = atoi (argv[1]); if (N < 1) return 1; int lower_limit = power (10, N - 1); int upper_limit = lower_limit * 10 - 1; long multiplier = lower_limit * 10; bool * primes = eratosthenes_sieve (upper_limit + 1); char next_perm[N + 1]; long max = 0; for (int start = lower_limit; start <= upper_limit; start++) { if (!primes[start]) continue; sprintf (next_perm, "%d", start); while (next_permutation (next_perm)) { int next_val = atoi (next_perm); if (!primes[next_val]) continue; int final_val = next_val + next_val - start; if (final_val > upper_limit) continue; if (!primes[final_val]) continue; if (!is_permutation (next_val, final_val)) continue; long seq_val = (((start * multiplier) + next_val) * multiplier) + final_val; if (seq_val > max) max = seq_val; } } printf ("%ld\n", max); free (primes); return 0; }
int main (int argc, char ** argv) { if (argc != 2) { fprintf (stderr, "usage: %s <N>\n", argv[0]); return 1; } int N = atoi (argv[1]); if (N < 2) return 1; bignum_t * powers[(N - 1) * (N - 1)]; size_t powers_count = 0; bool * primes = eratosthenes_sieve (N + 1); for (int a = 2; a <= N; a++) { bignum_t * power = NULL; for (int b = 2; b <= N; b++) { bignum_t * new_power = NULL; if (!power) new_power = bignum_get (a * a); else new_power = bignum_mult (power, a); if (b == 2) bignum_delete (power); int duplicate_at = -1; // Powers of a prime base cannot be duplicates if (!primes[a]) for (size_t i = 0; i < powers_count; i++) if (bignum_cmp (powers[i], new_power) == 0) { duplicate_at = i; break; } if (duplicate_at == -1) { powers[powers_count++] = new_power; power = new_power; } else { bignum_delete (new_power); power = powers[duplicate_at]; } } } printf ("%d\n", (int) powers_count); bignum_free_array (powers, powers_count); free (primes); return 0; }
int main() { unsigned count; #ifdef TEST_ATKIN count = atkin_sieve(); #elif TEST_SUNDARAM count = sundaram_sieve(); #elif TEST_ERATOSTHENES count = eratosthenes_sieve(); #elif TEST_FAST_ERATOSTHENES count = fast_eratosthenes_sieve(); #endif printf("Found %d primes under %d\n", count, SIZE); return 0; }
int main (int argc, char ** argv) { if (argc != 2) { fprintf (stderr, "usage: %s <N>\n", argv[0]); return 1; } int N = atoi (argv[1]); bool * sieve = eratosthenes_sieve (PRIMES_PRODUCT_LIMIT); size_t primes_count = count_primes (sieve, N); if (primes_count == 0) { printf ("0\n"); return 0; } int primes[primes_count]; int powers[primes_count]; fill_factor_arrays (primes, powers, sieve, primes_count); free (sieve); linked_list_t * pseudo_fortunates = linked_list_create (); int prime = 0; while ((prime = next_prime (primes, powers, primes_count, N)) > 0) { int val = find_pseudo_fortunate (prime); linked_list_add_sorted (pseudo_fortunates, copy_int (val), int_cmp, true); } int sum = linked_list_sum_int (pseudo_fortunates); printf ("%d\n", sum); linked_list_free (pseudo_fortunates); return 0; }
int main(void) { struct eratosthenes s; unsigned long n; /* This is how many tests you plan to run */ plan_tests(2 * LIMIT); eratosthenes_init(&s); eratosthenes_sieve(&s, LIMIT); for (n = 0; n < LIMIT; n++) { ok_eq(eratosthenes_isprime(&s, n), test_isprime(n)); ok_eq(eratosthenes_nextprime(&s, n), test_nextprime(&s, n)); } eratosthenes_reset(&s); /* This exits depending on whether all tests passed */ return exit_status(); }
unsigned long quadratic_sieve(mpz_t N, unsigned int n, unsigned interval, unsigned int max_fact, unsigned int block_size, mpz_t m, unsigned int print_fact) { double t1, t2; int rank; int comm_size; MPI_Comm_rank(MPI_COMM_WORLD, &rank); MPI_Comm_size(MPI_COMM_WORLD, & comm_size); /* Controllo con test di pseudoprimalità di rabin */ if(mpz_probab_prime_p(N, 25)) { return NUM_PRIMO; } /* Radice intera di N */ mpz_t s; mpz_init(s); mpz_sqrt(s, N); t1 = MPI_Wtime(); /* Individuazione primi in [2, n] */ unsigned int * primes = malloc(sizeof(unsigned int) * n); eratosthenes_sieve(primes, n); /* Compattiamo i numeri primi in primes */ unsigned j = 0; for(int i = 2; i < n; ++i) if(primes[i] == 1) { primes[j++] = i; } unsigned int n_all_primes = j; /* Fattorizzazione eseguita da tutti, gli slave ritornano IM_A_SLAVE mentre il main il fattore */ unsigned int simple_factor = trivial_fact(N, primes, n_all_primes); if(simple_factor != 0) { mpz_set_ui(m, simple_factor); return rank == 0 ? OK : IM_A_SLAVE; } /* Calcolo base di fattori e soluzioni dell'eq x^2 = N mod p */ pair * solutions = malloc(sizeof(pair) * n_all_primes); unsigned int * factor_base = primes; unsigned n_primes = base_fattori(N, s, factor_base, solutions, primes, n_all_primes); t2 = MPI_Wtime(); double t_base = t2 - t1; if(rank == 0) printf("#Dimensione base di fattori: %d\n", n_primes); /* Vettore degli esponenti in Z */ unsigned int ** exponents; /* Vettore degli (Ai + s) */ mpz_t * As; /* Parte di crivello: troviamo le k+n fattorizzazioni complete */ unsigned int n_fatt; t1 = MPI_Wtime(); if(rank == 0){ /* Inizializzazioni vettori */ init_matrix(& exponents, n_primes + max_fact, n_primes); init_vector_mpz(& As, n_primes + max_fact); /* Procedura master che riceve le fatt. complete */ n_fatt = master(n_primes, max_fact, exponents, As, comm_size, print_fact); } else { mpz_t begin; mpz_init(begin); mpz_t counter; mpz_init(counter); mpz_set_ui(begin, interval * (rank - 1)); //gmp_printf("%d) begin=%Zd interval=%d\n", rank, begin, interval); int stop_flag = 0; do { //gmp_printf("\t%d) [%Zd, %Zd+%d] - (flag=%d)\n", rank, begin, begin, interval, flag); stop_flag = smart_sieve(N, factor_base, n_primes, solutions, begin, interval, block_size, max_fact); mpz_add_ui(begin, begin, interval * (comm_size-1)); } while(!stop_flag); //printf("#%d) Termina\n", rank); return IM_A_SLAVE; } t2 = MPI_Wtime(); double t_sieve = t2 - t1; printf("#Numero fattorizzazioni complete trovate: %d\n", n_fatt); t1 = MPI_Wtime(); /* Matrice di esponenti in Z_2 organizzata a blocchi di bit */ word ** M; /* Numero di blocchi di bit da utilizzare */ unsigned long n_blocchi = n_primes / N_BITS + 1; /* Inizializzazione egli esponenti mod 2 */ init_matrix_l(& M, n_fatt, n_blocchi); for(int i = 0; i < n_fatt; ++i) for(int j = 0; j < n_primes; ++j) { unsigned int a = get_matrix(exponents, i, j); set_k_i(M, i, j, a); } /* Vettore con le info (bit piu' a dx e num bit a 1) su M */ struct row_stats * wt = malloc(sizeof(struct row_stats) * n_fatt); for(int i = 0; i < n_fatt; ++i) get_wt_k(M, i, n_primes, & wt[i]); /* In gauss gli esponenti sommati possono andare in overflow, li converto dunque in mpz */ mpz_t ** exponents_mpz; mpz_t temp; mpz_init_set_ui(temp, 2); unsigned int a; init_matrix_mpz(& exponents_mpz, n_fatt, n_primes); for(unsigned i = 0; i < n_fatt; ++i) for(unsigned j = 0; j < n_primes; ++j) { a = get_matrix(exponents, i, j); mpz_set_ui(temp, a); set_matrix_mpz(exponents_mpz, i, j, temp); } /* Eliminazione gaussiana */ gaussian_elimination(exponents_mpz, M, As, N, n_fatt, n_primes, n_blocchi, wt); t2 = MPI_Wtime(); double t_gauss = t2 - t1; /* In m ritorno un fattore non banale di N */ unsigned int n_fact_non_banali = factorization(N, factor_base, M, exponents_mpz, As, wt, n_fatt, n_primes, m); printf("#time_base time_sieve time_gauss time_totale\n"); printf("%.6f ", t_base); printf("%.6f ", t_sieve); printf("%.6f ", t_gauss); printf("%.6f\n", t_base + t_gauss + t_sieve); if(n_fact_non_banali > 0) { return OK; } else { return SOLO_FATTORIZZAZIONI_BANALI; } }