/usr/include/primesieve.hpp is in libprimesieve6-dev-common 5.6.0+ds-1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 | ///
/// @file primesieve.hpp
/// @brief primesieve C++ API. primesieve is a library for fast prime
/// number generation, in case an error occurs a
/// primesieve::primesieve_error exception (derived form
/// std::runtime_error) will be thrown.
///
/// Copyright (C) 2015 Kim Walisch, <kim.walisch@gmail.com>
///
/// This file is distributed under the BSD License.
///
#ifndef PRIMESIEVE_HPP
#define PRIMESIEVE_HPP
#define PRIMESIEVE_VERSION "5.6.0"
#define PRIMESIEVE_VERSION_MAJOR 5
#define PRIMESIEVE_VERSION_MINOR 6
#define PRIMESIEVE_VERSION_PATCH 0
#include <primesieve/PrimeSieve.hpp>
#include <primesieve/ParallelPrimeSieve.hpp>
#include <primesieve/Callback.hpp>
#include <primesieve/cancel_callback.hpp>
#include <primesieve/iterator.hpp>
#include <primesieve/PushBackPrimes.hpp>
#include <primesieve/primesieve_error.hpp>
#include <stdint.h>
#include <vector>
#include <string>
/// All of primesieve's C++ functions and classes are declared
/// inside this namespace.
///
namespace primesieve
{
enum {
/// Use all CPU cores for prime sieving.
MAX_THREADS = -1
};
/// Store the primes <= stop in the primes vector.
/// @pre stop <= 2^64 - 2^32 * 10.
///
template <typename T>
inline void generate_primes(uint64_t stop, std::vector<T>* primes)
{
if (primes)
{
PushBackPrimes<std::vector<T> > pb(*primes);
pb.pushBackPrimes(0, stop);
}
}
/// Store the primes within the interval [start, stop]
/// in the primes vector.
/// @pre stop <= 2^64 - 2^32 * 10.
///
template <typename T>
inline void generate_primes(uint64_t start, uint64_t stop, std::vector<T>* primes)
{
if (primes)
{
PushBackPrimes<std::vector<T> > pb(*primes);
pb.pushBackPrimes(start, stop);
}
}
/// Store the first n primes in the primes vector.
template <typename T>
inline void generate_n_primes(uint64_t n, std::vector<T>* primes)
{
if (primes)
{
PushBack_N_Primes<std::vector<T> > pb(*primes);
pb.pushBack_N_Primes(n, 0);
}
}
/// Store the first n primes >= start in the primes vector.
/// @pre start <= 2^64 - 2^32 * 10.
///
template <typename T>
inline void generate_n_primes(uint64_t n, uint64_t start, std::vector<T>* primes)
{
if (primes)
{
PushBack_N_Primes<std::vector<T> > pb(*primes);
pb.pushBack_N_Primes(n, start);
}
}
/// Find the nth prime.
/// @param n if n = 0 finds the 1st prime >= start, <br/>
/// if n > 0 finds the nth prime > start, <br/>
/// if n < 0 finds the nth prime < start (backwards).
/// @pre start <= 2^64 - 2^32 * 11.
///
uint64_t nth_prime(int64_t n, uint64_t start = 0);
/// Find the nth prime in parallel.
/// By default all CPU cores are used, use
/// primesieve::set_num_threads(int) to change the number of
/// threads.
/// @param n if n = 0 finds the 1st prime >= start, <br/>
/// if n > 0 finds the nth prime > start, <br/>
/// if n < 0 finds the nth prime < start (backwards).
/// @pre start <= 2^64 - 2^32 * 11.
///
uint64_t parallel_nth_prime(int64_t n, uint64_t start = 0);
/// Count the primes within the interval [start, stop].
/// @pre stop <= 2^64 - 2^32 * 10.
///
uint64_t count_primes(uint64_t start, uint64_t stop);
/// Count the twin primes within the interval [start, stop].
/// @pre stop <= 2^64 - 2^32 * 10.
///
uint64_t count_twins(uint64_t start, uint64_t stop);
/// Count the prime triplets within the interval [start, stop].
/// @pre stop <= 2^64 - 2^32 * 10.
///
uint64_t count_triplets(uint64_t start, uint64_t stop);
/// Count the prime quadruplets within the interval [start, stop].
/// @pre stop <= 2^64 - 2^32 * 10.
///
uint64_t count_quadruplets(uint64_t start, uint64_t stop);
/// Count the prime quintuplets within the interval [start, stop].
/// @pre stop <= 2^64 - 2^32 * 10.
///
uint64_t count_quintuplets(uint64_t start, uint64_t stop);
/// Count the prime sextuplets within the interval [start, stop].
/// @pre stop <= 2^64 - 2^32 * 10.
///
uint64_t count_sextuplets(uint64_t start, uint64_t stop);
/// Count the primes within the interval [start, stop] in
/// parallel. By default all CPU cores are used, use
/// primesieve::set_num_threads(int) to change the number of
/// threads.
/// @pre stop <= 2^64 - 2^32 * 10.
///
uint64_t parallel_count_primes(uint64_t start, uint64_t stop);
/// Count the twin primes within the interval [start, stop] in
/// parallel. By default all CPU cores are used, use
/// primesieve::set_num_threads(int) to change the number of
/// threads.
/// @pre stop <= 2^64 - 2^32 * 10.
///
uint64_t parallel_count_twins(uint64_t start, uint64_t stop);
/// Count the prime triplets within the interval [start, stop] in
/// parallel. By default all CPU cores are used, use
/// primesieve::set_num_threads(int) to change the number of
/// threads.
/// @pre stop <= 2^64 - 2^32 * 10.
///
uint64_t parallel_count_triplets(uint64_t start, uint64_t stop);
/// Count the prime quadruplets within the interval [start, stop] in
/// parallel. By default all CPU cores are used, use
/// primesieve::set_num_threads(int) to change the number of
/// threads.
/// @pre stop <= 2^64 - 2^32 * 10.
///
uint64_t parallel_count_quadruplets(uint64_t start, uint64_t stop);
/// Count the prime quintuplets within the interval [start, stop] in
/// parallel. By default all CPU cores are used, use
/// primesieve::set_num_threads(int) to change the number of
/// threads.
/// @pre stop <= 2^64 - 2^32 * 10.
///
uint64_t parallel_count_quintuplets(uint64_t start, uint64_t stop);
/// Count the prime sextuplets within the interval [start, stop] in
/// parallel. By default all CPU cores are used, use
/// primesieve::set_num_threads(int) to change the number of
/// threads.
/// @pre stop <= 2^64 - 2^32 * 10.
///
uint64_t parallel_count_sextuplets(uint64_t start, uint64_t stop);
/// Print the primes within the interval [start, stop]
/// to the standard output.
/// @pre stop <= 2^64 - 2^32 * 10.
///
void print_primes(uint64_t start, uint64_t stop);
/// Print the twin primes within the interval [start, stop]
/// to the standard output.
/// @pre stop <= 2^64 - 2^32 * 10.
///
void print_twins(uint64_t start, uint64_t stop);
/// Print the prime triplets within the interval [start, stop]
/// to the standard output.
/// @pre stop <= 2^64 - 2^32 * 10.
///
void print_triplets(uint64_t start, uint64_t stop);
/// Print the prime quadruplets within the interval [start, stop]
/// to the standard output.
/// @pre stop <= 2^64 - 2^32 * 10.
///
void print_quadruplets(uint64_t start, uint64_t stop);
/// Print the prime quintuplets within the interval [start, stop]
/// to the standard output.
/// @pre stop <= 2^64 - 2^32 * 10.
///
void print_quintuplets(uint64_t start, uint64_t stop);
/// Print the prime sextuplets within the interval [start, stop]
/// to the standard output.
/// @pre stop <= 2^64 - 2^32 * 10.
///
void print_sextuplets(uint64_t start, uint64_t stop);
/// Call back the primes within the interval [start, stop].
/// @param callback A callback function.
/// @pre stop <= 2^64 - 2^32 * 10.
///
void callback_primes(uint64_t start, uint64_t stop, void (*callback)(uint64_t prime));
/// Call back the primes within the interval [start, stop].
/// @param callback An object derived from primesieve::Callback<uint64_t>.
/// @pre stop <= 2^64 - 2^32 * 10.
///
void callback_primes(uint64_t start, uint64_t stop, primesieve::Callback<uint64_t>* callback);
/// Get the current set sieve size in kilobytes.
int get_sieve_size();
/// Get the current set number of threads.
/// @note By default MAX_THREADS (-1) is returned.
///
int get_num_threads();
/// Returns the largest valid stop number for primesieve.
/// @return (2^64-1) - (2^32-1) * 10.
///
uint64_t get_max_stop();
/// Set the sieve size in kilobytes.
/// The best sieving performance is achieved with a sieve size of
/// your CPU's L1 data cache size (per core). For sieving >= 10^17 a
/// sieve size of your CPU's L2 cache size sometimes performs
/// better.
/// @param sieve_size Sieve size in kilobytes.
/// @pre sieve_size >= 1 && sieve_size <= 2048.
///
void set_sieve_size(int sieve_size);
/// Set the number of threads for use in subsequent
/// primesieve::parallel_* function calls. Note that this only
/// changes the number of threads for the current process.
/// @param num_threads Number of threads for sieving
/// or MAX_THREADS to use all CPU cores.
///
void set_num_threads(int num_threads);
/// Run extensive correctness tests.
/// The tests last about one minute on a quad core CPU from
/// 2013 and use up to 1 gigabyte of memory.
/// @return true if success else false.
///
bool primesieve_test();
/// Get the primesieve version number, in the form “i.j.k”.
std::string primesieve_version();
}
#endif
|