isprime | A faster than average C/C function to detect if a number | Computer Vision library

The documentation you've cited is correct.

certainty - a measure of the uncertainty that the caller is willing to tolerate: if the call returns true the probability that this BigInteger is prime exceeds (1 - 1/2^certainty)

99.9% indeed exceeds 1 - 1/(2²) = 3/4, so there's nothing wrong with what you've shown us.

The implementation makes no guarantees that that's exactly the probability, it just provides an implementation whose error is definitely bounded by that certainty.

Most quality primality testers will have lots of optimizations for small primes, or rather, numbers whose divisors are small composite numbers. These likely kick in before the random aspects of the algorithm, resulting in higher-than-usual accuracy for small primes.

First of all read on primality tests. The simplest method described is trial division, what you are using, but almost. The max number to check is square root of n, not n - 1. Implement it like this, and you will see dramatic increase in performance.

If speed is still not enough, you can make further optimizations:

1. Keeping a cache of primes, because you currently you are checking a number more than once for primality
2. Also in this line - for (int i = 2; i < n; i++), you need to check only other primes, not every number
3. You could add even/odd check before loop, even numbers are never prime, only odd might be.

All those optimizations a mentioned will lead to increase in performance, especially the first one. Using recursion certanly will not, as answered here.

OP's algorithm always exits on the first iteration.

Instead, loop less often and only exit loop when a divisor is found. Also account for values less than 2.

You were timing compilation. If you run the untyped function again, you'll see that it runs without extra allocation.

Short-circuit evaluation deals with evaluation of expressions. The expression is still there in the text of the C++ file, and it therefore must be compiled. If that expression contains a template instantiation, then that template must be instantiated. That's how compilation works (unless you use if constexpr, which you can't within that context).

If you want to prevent further instantiation, you have to do so via the rules of templates, not the rules of expression evaluation. So you need to use a partial specialization of the template, one which probably uses SFINAE techniques that is active when the condition is true. C++20 makes this easier with a requires clause.

Better still, turn IsPrime_Descend into a constexpr function.

See https://en.wikipedia.org/wiki/ANSI_escape_code, specifically:

In 2016, Microsoft released the Windows 10 version 1511 update which unexpectedly implemented support for ANSI escape sequences, over two decades after the debut of Windows NT.[13] This was done alongside Windows Subsystem for Linux, allowing Unix-like terminal-based software to use the sequences in Windows Console. Unfortunately this defaults to off, but Windows PowerShell 5.1 enabled it. PowerShell 6 made it possible to embed the necessary ESC character into a string with `e.[14] Windows Terminal, introduced in 2019, supports the sequences by default, and Microsoft intends to replace the Windows Console with Windows Terminal.[15]

Color codes work in Visual Studio Code (Terminal).

ADDITIONAL INFO:

https://devblogs.microsoft.com/commandline/new-experimental-console-features/

Your program is probably hanging due too long timeout.

As suggested in comments by @NathanPierson it is enough to check primality until i * i <= number which will speedup code greatly.

As commented by @Quimby if you use GCC or CLang compiler then it is worth adding -O3 command line compile option, which does all possible optimizations to make code as fast as possible. For MSVC compiler you may use /GL /O2 options.

Full corrected working code:

Try it online!

The issue with your sequence-based version is that deconstructing a sequence using Seq.head and Seq.tail recursively is very inefficient. The sequence returned by Seq.tail iterates the original sequence, but skips the first element. This means that by applying Seq.tail recursively, you are creating more and more sequences (I guess this is O(N^2)) that you need to iterate over.

This gets much more efficient if you use a list, where pattern matching against x::xs simply takes a reference to the next cons cell:

Here is what you need (probably):