prime

func All ¶

func All() iter.Seq[uint]

All returns an iterator yielding all the prime numbers up to math.MaxUint in ascending order.

// Find first 5 pairs of twin primes
var prev uint
count := 0
for p := range All() {
	if prev != 0 && p-prev == 2 {
		fmt.Printf("(%d, %d) ", prev, p)
		count++
		if count == 5 {
			break
		}
	}
	prev = p
}

Output:

(3, 5) (5, 7) (11, 13) (17, 19) (29, 31)

func Factorize ¶

func Factorize(n uint) iter.Seq2[uint, int]

Factorize returns an iterator that yields the prime factors of n and their exponents.

for prime, exponent := range Factorize(360) {
	fmt.Printf("%d^%d ", prime, exponent)
}

Output:

2^3 3^2 5^1

func FirstN ¶

func FirstN(n int) []uint

FirstN returns a slice containing the first n prime numbers in ascending order.

The returned slice should be considered read-only and must not be modified.

The returned slice might contain less than n elements if those numbers wouldn't fit in a uint.

fmt.Println(FirstN(10))

Output:

[2 3 5 7 11 13 17 19 23 29]

func GCD ¶

func GCD(numbers ...uint) uint

GCD computes the greatest common divisor. This really doesn't have much to do with prime numbers other than the algorithm heavily relying on them.

Returns 0 if the list is empty or all of the numbers are 0.

fmt.Println(GCD(6, 0, 12, 9))

Output:

3

func LCM ¶

func LCM(numbers ...uint) uint

LCM computes the least common multiple. This really doesn't have much to do with prime numbers other than the algorithm heavily relying on them.

Returns 0 if the LCM would overflow, or one of the numbers is 0.

fmt.Println(LCM(6, 8, 12))

Output:

24

func Next ¶

func Next(n uint, offset int) uint

Next returns the prime number at some relative offset to n, or 0 if there is no applicable number.

Next(n, 0) will return n if n is prime, otherwise 0. Next(n, -1) will return the next prime number before n, if one exists (i.e., n >= 3) Next(n, 1) will return the next prime number after n, if representable in a uint. Next(n, 100) will return the 100th prime number after n, if representable in a uint.

resetCache()
_ = upTo(100)

offsets := []int{-3, -2, -1, 0, 1, 2, 1000}
names := []string{"3rd prime before", "2nd prime before", "1st prime before", "prime at", "1st prime after", "2nd prime after", "thousandth prime after"}

for i, offset := range offsets {
	const n = 4

	if prime := Next(n, offset); prime != 0 {
		fmt.Printf("%s %d is: %d\n", names[i], n, Next(n, offset))
	} else {
		fmt.Printf("no %s %d\n", names[i], n)
	}
}

Output:

no 3rd prime before 4
2nd prime before 4 is: 2
1st prime before 4 is: 3
no prime at 4
1st prime after 4 is: 5
2nd prime after 4 is: 7
thousandth prime after 4 is: 7933

func Test ¶

func Test(n uint) bool

Test returns true if n is prime.

for i := range uint(6) {
	fmt.Printf("%d: %v\n", i, Test(i))
}

Output:

0: false
1: false
2: true
3: true
4: false
5: true

func UpTo ¶

func UpTo(n uint) []uint

UpTo returns a slice containing all the up to n inclusive in ascending order.

The returned slice should be considered read-only and must not be modified.

fmt.Println(UpTo(11))

Output:

[2 3 5 7 11]