void pushBack_N_Primes(uint64_t n, uint64_t start)
{
n_ = n;
PrimeSieve ps;
std::size_t newSize = primes_.size() + static_cast<std::size_t>(n_);
primes_.reserve(newSize);
try
{
while (n_ > 0)
{
// choose stop > nth prime
uint64_t logx = 50;
uint64_t dist = n_ * logx + 10000;
uint64_t stop = start + dist;
// fix integer overflow
if (stop < start)
stop = get_max_stop();
ps.callbackPrimes(start, stop, this);
start = stop + 1;
if (stop >= get_max_stop())
throw primesieve_error("cannot generate primes > 2^64");
}
}
catch (cancel_callback&) { }
}
static PyObject* primes(PyObject* self, PyObject* args){
Py_ssize_t start = 0, n = 0; size_t pi;
if (!PyArg_ParseTuple(args, "n|n:primes", &start, &n)) return NULL;
if (PyTuple_Size(args) == 1){
n = start;
start = 0;
}
if (start > n) return PyList_New(0);
if (start < 2) start = 2;
if (n < 3) return PyErr_Occurred() ? NULL : PyList_New(0);
else if (n == 3){
PyObject* just_two = PyList_New(1);
PyList_SET_ITEM(just_two, 0, PyInt_FromLong(2));
return just_two;
}
else if (n < 6) pi = 2;
else if (n < 8) pi = 3;
else if (n < 12) pi = 4;
else if (n < 14) pi = 5;
else if (n < 18) pi = 6;
else pi = n/(log(n)-1);
size_t i = 0;
PrimePyList primes(pi, &i);
PrimeSieve ps;
ps.generatePrimes(start, n-1, &primes);
i--;
while (i < --pi) PyObject_CallMethod(primes.list, (char*)"__delitem__", (char*)"(n)", pi);
return primes.list;
}
void pushBackPrimes(uint64_t start, uint64_t stop)
{
if (start <= stop)
{
std::size_t prime_count = approximate_prime_count(start, stop);
primes_.reserve(primes_.size() + prime_count);
PrimeSieve ps;
ps.callbackPrimes(start, stop, this);
}
}
int main(){
//Initialize Seed
srand(time (NULL) );
//Create Random Start from range 0 to 99
int start = rand () % 99 + 1 ;
//Create Random Stop from range 999 to 99999 (Nighty - Nine Thousand )
int stop = rand () % 99999 + 999 ;
cout<<"Random start "<<start <<endl;
cout<<"Random end " <<stop <<endl;
PrimeSieve ps;
try
{
ps.generatePrimes(start ,stop ,callback);
// ps.printPrimes(start ,stop );
}catch (stop_primesieve & e ){
//cerr << " Error " << e.what() <<endl;
}
//Random Number
int num1 = rand() % 99 + 1 ;
int num2 = rand() % 500 + 100;
//P and Q are 2 large random number
long long unsigned int p = primes[num1];
long long unsigned int q = primes[num2];
//Calculate n
long long unsigned int n = p * q;
//Calculate phi
long long unsigned int phi = (p -1 ) * (q -1);
//Calculate e s.t.
cout << " num1 = " << num1 <<endl;
cout << " num2 = " << num2 <<endl;
cout << " p = " << p <<endl;
cout << " q = " << q <<endl;
cout << " n = " << n <<endl;
cout << " phi = "<< phi <<endl;
euclid(a,b);
return 0;
}
void pushBack_N_Primes(uint64_t n, uint64_t start)
{
n_ = n;
std::size_t newSize = primes_.size() + static_cast<std::size_t>(n_);
primes_.reserve(newSize);
PrimeSieve ps;
try
{
while (n_ > 0)
{
uint64_t logn = 50;
// choose stop > nth prime
uint64_t stop = start + n_ * logn + 10000;
ps.callbackPrimes(start, stop, this);
start = stop + 1;
}
}
catch (cancel_callback&) { }
}
IntVec PrimeSwing::GetMultiplies( int _number, PrimeSieve& _sieve )
{
IntVec multiplies;
int sqrtN = static_cast<int>( sqrt( static_cast<double>(_number) ) );
int maxIdx = _sieve.GetPrimeIndex( sqrtN, 2, _sieve.GetNumberOfPrimes() );
for ( int i = 1; i < maxIdx; ++i )
{
int prime = _sieve.GetPrime(i);
int q = _number, p = 1;
while ((q /= prime) > 0)
if ((q & 1) == 1)
p *= prime;
if (p > 1)
multiplies.push_back(p);
}
int minIdx = maxIdx;
maxIdx = _sieve.GetPrimeIndex( _number / 3, minIdx, _sieve.GetNumberOfPrimes() );
for (int i = minIdx; i < maxIdx; ++i)
{
int prime = _sieve.GetPrime(i);
if (((_number / prime) & 1) == 1)
multiplies.push_back(prime);
}
return multiplies;
}
mpz_class PrimeSwing::Swing( int _number, PrimeSieve& _sieve )
{
// Small precalculated values
if (_number < 33)
return smallOddSwing[_number];
// Fetch multiplies
IntVec multiplies = GetMultiplies(_number, _sieve);
// Return multiplies of primorials
return _sieve.Primorial(_number / 2, _number) *
UtilityFunctions::SequenceProduct( multiplies.begin(), multiplies.end() );
}
static PyObject* primes_nth(PyObject* self, PyObject* args){
Py_ssize_t n = 0;
if (!PyArg_ParseTuple(args, "n:primes_nth", &n)) return NULL;
if (n < 1){
PyErr_SetString(PyExc_ValueError, "a positive integer is required");
return NULL;
}
switch (n){
case 1: return PyInt_FromLong(2);
case 2: return PyInt_FromLong(3);
case 3: return PyInt_FromLong(5);
case 4: return PyInt_FromLong(7);
case 5: return PyInt_FromLong(11);
}
NthPrime nthprime(n);
PrimeSieve ps;
try {
ps.generatePrimes(0, n*log(n*log(n)), &nthprime);
}
catch (StopPrimeGeneration&) {}
return nthprime.prime;
}
uint64_t count_sextuplets(uint64_t start, uint64_t stop)
{
PrimeSieve ps;
ps.setSieveSize(get_sieve_size());
return ps.countSextuplets(start, stop);
}
uint64_t count_twins(uint64_t start, uint64_t stop)
{
PrimeSieve ps;
ps.setSieveSize(get_sieve_size());
return ps.countTwins(start, stop);
}
uint64_t nth_prime(int64_t n, uint64_t start)
{
PrimeSieve ps;
ps.setSieveSize(get_sieve_size());
return ps.nthPrime(n, start);
}
void callback_primes(uint64_t start, uint64_t stop, Callback<uint64_t>* callback)
{
PrimeSieve ps;
ps.setSieveSize(get_sieve_size());
ps.callbackPrimes(start, stop, callback);
}
void print_sextuplets(uint64_t start, uint64_t stop)
{
PrimeSieve ps;
ps.setSieveSize(get_sieve_size());
ps.printSextuplets(start, stop);
}
void print_twins(uint64_t start, uint64_t stop)
{
PrimeSieve ps;
ps.setSieveSize(get_sieve_size());
ps.printTwins(start, stop);
}
