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;
}
