int main(int argc, char* argv[]) { llu coeffs[25]; for (int i = 0; i <= 24; i++) coeffs[i] = i ? ((i+1) * (i+2) * (i+3)) / 6: 1; int nb_primes; int* primes = get_primes(100, &nb_primes); llu res = 0; llu up = 10000000000000000ULL; int nb_prod = 1 << nb_primes; // 2 ** 25 for (int i = 1; i < nb_prod; i++) { llu prod = 1; int nb_bits = 0; int ok = 1; for (int j = 0; j < nb_primes; j++) if (i & (1 << j)) { nb_bits++; prod *= primes[j]; if (prod > up) { ok = 0; break; } } if (!ok) continue; if (nb_bits < 4) continue; if (nb_bits % 2 == 0) res += coeffs[nb_bits-4] * (up / prod); else res -= coeffs[nb_bits-4] * (up / prod); } printf("Nb: %llu before %llu\n", res, up); return 0; }
int main(int argc, char **argv) { s_prime *p = get_primes(10000); int n = 1; int f = 0; int f_div_num = 0; int a_div_num = 0; int b_div_num = 0; while (1) { int a = n; int b = n + 1; if ((n % 2) == 0) { a = a / 2; } else { b = b / 2; } if (a == f) { a_div_num = f_div_num; } else { a_div_num = div_number(a, p); } b_div_num = div_number(b, p); f = b; f_div_num = b_div_num; int div_num = a_div_num * b_div_num; if (div_num > 500) { printf("number = %d\n", a * b); break; } n++; } }
inline std::vector<std::size_t> create_dim(std::size_t nlocals, std::size_t dim) { if(dim == 1) { return std::vector<std::size_t>(1, nlocals); } std::vector<std::size_t> primes = get_primes(nlocals); std::vector<std::size_t> factors = get_factors(nlocals, primes); return assign_locals(dim, primes, factors); }
RVB::RVB() { in = NULL; _branch = 0; for (int i = 0; i < 2; i++) { int j; for (j = 0; j < 6; j++) m_rvbData[i][j].Rvb_del = NULL; } get_primes(NPRIMES, primes); /* load array with prime numbers */ }
} TEST(prime_basic, prime_test) { // TODO: test if all the returned numbers are prime std::vector<int> primes; get_primes(primes, 120); //print_vector(primes); std::sort(primes.begin(), primes.end()); EXPECT_EQ(primes.size(), 30); EXPECT_EQ(primes[29], 113);
void factorial_prime_factorization(int x, umap<int,int>& counts) { static vector<int> primes = get_primes(MAXN); for (int p : primes) { if (p > x) break; int count = 0; int n = x; while ((n /= p) > 0) count += n; if (count) counts[p] = count; } }
int main(void) { #ifdef pause printf("Hit enter to sieve up to %lld\n", LIMIT); char nada[2]; fgets(nada, 2, stdin); #endif prime_array pa = get_primes(LIMIT); printf("%ld primes exist up to %lld\n", pa.len, LIMIT); #ifdef pause printf("Hit enter to quit\n"); fgets(nada, 2, stdin); #endif return 0; }
BASE::BASE() : m_tapsize(0) { in = NULL; m_tapDelay = NULL; m_buffersize = BUFLEN; for (int i = 0; i < 2; i++) { int j; for (j = 0; j < 6; j++) m_rvbData[i][j].Rvb_del = NULL; for (j = 0; j < 13; j++) { m_vectors[i][j].Firtaps = NULL; m_vectors[i][j].Fircoeffs = NULL; } } get_primes(NPRIMES, primes); /* load array with prime numbers */ }
int main(int argc, char* argv[]) { int nb_primes; int* primes = get_primes(5000, &nb_primes); lli total = 0; for (int i1 = 0; i1 < nb_primes; i1++) { lli p = primes[i1]; for (int i2 = i1+1; i2 < nb_primes; i2++) { lli q = primes[i2]; for (int i3 = i2+1; i3 < nb_primes; i3++) { lli r = primes[i3]; total += p * q * r * 2LL - p * q - q * r - p * r; } } } printf("%lli\n", total); return 0; }
int main(int argc, char* argv[]) { int nb_primes; int* primes = get_primes(MAXL, &nb_primes); cache = malloc(MAXL * sizeof(char**)); for (int i = 0; i < MAXL; i++) { cache[i] = malloc(MAXALPHA * sizeof(char*)); for (int j = 0; j < MAXALPHA; j++) { cache[i][j] = malloc(MAXBETA * sizeof(char)); for (int k = 0; k < MAXBETA; k++) cache[i][j][k] = -1; } } printf("%d\n", cache[5][0][15]); printf("%d\n", p(17)); long long int sum = 0; for (int i = 0; i < nb_primes; i++) if (p(primes[i]) == 1) sum += primes[i]; printf("%lli\n", sum); return 0; }
int main(int argc, char** argv) { char sieve[N]; get_primes(sieve, N); int count = 0; int i; for (i = 0; i < N; i++) { if (sieve[i] == IS_A_PRIME) { //printf("%d\n", i + i + 3); count++; } } /* plus 2, which is not indicated with the array. */ printf("num of primes: %d\n", count + 1); printf("is 2333 a prime number? %d\n", IS_PRIME(2333)); return 0; }
static FAR void *get_primes_thread(FAR void *parameter) { int id = (int)parameter; int count; int last; int i; printf("get_primes_thread id=%d started, looking for primes < %d, doing %d run(s)\n", id, CONFIG_EXAMPLES_KERNEL_SAMPLE_RR_RANGE, CONFIG_EXAMPLES_KERNEL_SAMPLE_RR_RUNS); for (i = 0; i < CONFIG_EXAMPLES_KERNEL_SAMPLE_RR_RUNS; i++) { get_primes(&count, &last); } printf("get_primes_thread id=%d finished, found %d primes, last one was %d\n", id, count, last); pthread_exit(NULL); return NULL; /* To keep some compilers happy */ }
/** * @brief Fill in the best MPI dimensions we can find. The truly optimal * solution should involve the tensor's sparsity pattern, but in general * this works as good (but usually better) than the hand-tuned dimensions * that we tried. * * @param rinfo MPI rank information. */ static void p_get_best_mpi_dim( rank_info * const rinfo) { int nprimes = 0; int * primes = get_primes(rinfo->npes, &nprimes); idx_t total_size = 0; for(idx_t m=0; m < rinfo->nmodes; ++m) { total_size += rinfo->global_dims[m]; /* reset mpi dims */ rinfo->dims_3d[m] = 1; } idx_t target = total_size / (idx_t)rinfo->npes; long diffs[MAX_NMODES]; /* start from the largest prime */ for(int p = nprimes-1; p >= 0; --p) { int furthest = 0; /* find dim furthest from target */ for(idx_t m=0; m < rinfo->nmodes; ++m) { /* distance is current - target */ idx_t const curr = rinfo->global_dims[m] / rinfo->dims_3d[m]; /* avoid underflow */ diffs[m] = (curr > target) ? (curr - target) : 0; if(diffs[m] > diffs[furthest]) { furthest = m; } } /* assign p processes to furthest mode */ rinfo->dims_3d[furthest] *= primes[p]; } free(primes); }
} TEST(prime_non_empty, prime_test) { std::vector<int> primes(4, 0); EXPECT_NO_THROW(get_primes(primes, 10));
} TEST(prime_zero_input, prime_test) { std::vector<int> primes; EXPECT_NO_THROW(get_primes(primes, 0));
int main(int argc, char* argv[]) { int nb_primes; int* primes = get_primes(LIM_P, &nb_primes); printf("%llu\n", count_rec(primes, nb_primes, 1, 1, 1)); return 0; }