Home

Choosing the right generator

This library contains 3 generators to choose from, based on your use case. Also check the benchmark performance figures.

• Default primeGenenerator() - produces primes from 2 until maxPrime = 9_007_199_254_740_881, which is hypothetically reachable, after running for 10+ years, so it can be considered infinite. This is the most efficient method in terms of memory and CPU usage, and can produce the first million primes in under half-second.
• Fast primeGenerator({boost: N}) - produces up to N primes. It boosts performance 10x times over the default method, by pre-allocating a memory buffer for the calculation. However, this brings memory penalty, and so N is capped at 100mln primes, which at peak will use about 127MB of RAM.
• Offset primeGenerator({start: S}) - produces all primes between S (inclusive) and maxPrime. It has the same memory + CPU efficiency as the default method, and is the best at finding primes above a certain range.

Note that you cannot combine start and boost options, because the fast method can only produce primes from the beginning, while the offset method cannot buffer its calculation.

Primes Cache

If you need to store a large number of primes in memory, for quick access, and concerned about memory usage, this library has a function cachePrimes to help with that. It caches up primes as compressed gaps, up to 100mln primes (100MB), and gives quick access to all of them as iterable or array. You end up using 8 times less memory than by keeping actual primes.

import {cachePrimes} from 'prime-lib';

const cache = cachePrimes(10); // returns a read-only array-iterator

const list = [...cache]; //=> [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]

for(const prime of cache) {
    // optimum use, as for-of iteration is very fast
}

for(let i = 0;i < cache.length;i ++) {
    // sub-optimum use (much slower than for-of),
    // because each value needs to be recalculated

    const prime = cache[i];
}

// Much faster local access to primes (at memory expense):
const primes = Array.from(cache);

The returned cache object is RXJS-friendly:

import {from} from 'rxjs';
import {cachePrimes} from 'prime-lib';

const cache = cachePrimes(10);

from(cache).subscribe(prime => {
    // 2, 3, 5, 7, 11, 13, 17, 19, 23, 29
});

Stop-Iterators

This library includes 3 stop-iterators - stopOnValue, stopOnCount, and generic stopWhen, to help limit generators. These are mainly for regular JavaScript and TypeScript clients, as RXJS provides its own operators for this.

However, you can combine them with RXJS, if you like - see the example below.

Let's produce all prime numbers between 100 and 200:

import {from} from 'rxjs';
import {generatePrimes, stopOnValue} from 'prime-lib';

const iterator = stopOnValue(generatePrimes({start: 100}), 200);

from(iterator)
    .subscribe(prime => {
        // 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151,
        // 157, 163, 167, 173, 179, 181, 191, 193, 197, 199
    });

The above result is the same as the following:

import {from, takeWhile} from 'rxjs';
import {generatePrimes} from 'prime-lib';

const iterator = generatePrimes({start: 100});

from(iterator).pipe(takeWhile(p => p < 200))
    .subscribe(prime => {
        // 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151,
        // 157, 163, 167, 173, 179, 181, 191, 193, 197, 199
    });