Add digit map calculation

This is not in the output yet, but it will be soon - printing it is
another task since I want colours in my output.

1 files changed, 92 insertions, 3 deletions

diff --git a/factors/factors_test.go b/factors/factors_test.go
index b7f48b9..8373ede 100644
--- a/factors/factors_test.go
+++ b/factors/factors_test.go
@@ -3,6 +3,7 @@ package factors
 import (
 	"fmt"
 	"maps"
+	"slices"
 	"testing"
 )
 
@@ -19,6 +20,8 @@ func tableTest[IN comparable, OUT any](t *testing.T, toTest func(IN) OUT,
 	}
 }
 
+type uintPair struct{ a, b uint }
+
 var primeFactorCases = map[uint]PrimeFactorization{
 	0:     PrimeFactorization{map[uint]uint{0: 1}},
 	1:     PrimeFactorization{map[uint]uint{}},
@@ -58,8 +61,8 @@ func TestFactors(t *testing.T) {
 }
 
 var totativeRatioCases = map[uint]float64{
-	1:  1.0, 2:  0.5, 3:  2.0 / 3.0, 4:  0.5,
-	6:  1.0 / 3.0, 7:  6.0 / 7.0, 8:  0.5,
+	1: 1.0, 2: 0.5, 3: 2.0 / 3.0, 4: 0.5,
+	6: 1.0 / 3.0, 7: 6.0 / 7.0, 8: 0.5,
 	12: 1.0 / 3.0, 14: 3.0 / 7.0, 15: 8.0 / 15.0,
 	30: 4.0 / 15.0, 60: 4.0 / 15.0, 120: 4.0 / 15.0,
 }
@@ -163,7 +166,7 @@ func TestPractical(t *testing.T) {
 	tableTest(t, practical, practicalCases, stdEquals, "practical")
 }
 
-var typeCases = map[uint32]NumberType {
+var typeCases = map[uint32]NumberType{
 	2: ColossallyAbundant, 3: NotPractical, 4: Superabundant,
 	6: ColossallyAbundant, 8: OrderedExponent, 10: NotPractical,
 	12: ColossallyAbundant, 18: Practical, 20: Practical, 24: Superabundant,
@@ -178,6 +181,92 @@ func TestType(t *testing.T) {
 	tableTest(t, Type, typeCases, stdEquals, "Type")
 }
 
+// ====== DIGIT MAP TESTS ======
+var (
+	zt = zeroType                // 00 - zero
+	ot = oneType                 // 0R - one
+	ft = DigitType{1, Regular}   // 1R - factors
+	rt = DigitType{2, Regular}   // 2R - regulars (index 2)
+	nt = DigitType{0, Neighbour} // 0N - neighbours
+	pt = DigitType{0, Opaque}    // 0P - opaque totatives
+)
+var digitMapCases = map[uint][]DigitType{
+	2: []DigitType{zt, ot},
+	3: []DigitType{zt, ot, nt},
+	4: []DigitType{zt, ot, ft, nt},
+	5: []DigitType{zt, ot, nt, nt, nt},
+	6: []DigitType{zt, ot, ft, ft, rt, nt},
+	8: []DigitType{zt, ot, ft, nt, ft, pt, DigitType{1, Neighbour}, nt},
+	10: []DigitType{zt, ot, ft, nt, rt, ft, DigitType{1, Neighbour}, pt,
+		DigitType{3, Regular}, nt},
+	12: []DigitType{zt, ot, ft, ft, ft, pt, ft, pt, rt, rt,
+		DigitType{1, Opaque}, nt},
+	16: []DigitType{zt, ot, ft, nt, ft, nt, DigitType{1, Neighbour}, pt,
+		ft, pt, DigitType{1, Neighbour}, pt, DigitType{1, Neighbour},
+		pt, DigitType{1, Opaque}, nt},
+}
+
+func TestDigitMap(t *testing.T) {
+	tableTest(t, DigitMap, digitMapCases, slices.Equal, "DigitMap")
+}
+
+// ensures GetDigitType(d, r) == DigitMap(r)[d];
+// does not ensure it has the correct value (that's TestDigitMap's job)
+func TestGetDigitType(t *testing.T) {
+	for radix := range digitMapCases {
+		digitMap := DigitMap(radix)
+		for digit := range digitMap {
+			actual := GetDigitType(uint(digit), radix)
+			if actual != digitMap[digit] {
+				t.Logf("GetDigitType(%d, %d) = %d", digit, radix, actual)
+				t.Errorf("GetDigitType(%d, %d) != DigitMap(%d)[%d]",
+					digit, radix, radix, digit)
+			}
+		}
+	}
+}
+
+var splitCases = map[uintPair]uintPair{
+	// digit, radix, regular part, totative part
+	uintPair{0, 0}:    uintPair{0, 1},
+	uintPair{0, 2}:    uintPair{1, 0},
+	uintPair{0, 12}:   uintPair{1, 0},
+	uintPair{1, 0}:    uintPair{1, 1},
+	uintPair{20, 0}:   uintPair{1, 20},
+	uintPair{360, 0}:  uintPair{1, 360},
+	uintPair{1, 2}:    uintPair{1, 1},
+	uintPair{1, 3}:    uintPair{1, 1},
+	uintPair{1, 7}:    uintPair{1, 1},
+	uintPair{1, 12}:   uintPair{1, 1},
+	uintPair{1, 39}:   uintPair{1, 1},
+	uintPair{1, 2948}: uintPair{1, 1},
+	uintPair{5, 6}:    uintPair{1, 5},
+	uintPair{10, 6}:   uintPair{2, 5},
+	uintPair{12, 6}:   uintPair{12, 1},
+	uintPair{15, 6}:   uintPair{3, 5},
+	uintPair{35, 6}:   uintPair{1, 35},
+	uintPair{56, 6}:   uintPair{8, 7},
+	uintPair{5, 12}:   uintPair{1, 5},
+	uintPair{10, 12}:  uintPair{2, 5},
+	uintPair{12, 12}:  uintPair{12, 1},
+	uintPair{15, 12}:  uintPair{3, 5},
+	uintPair{35, 12}:  uintPair{1, 35},
+	uintPair{56, 12}:  uintPair{8, 7},
+	uintPair{12, 7}:   uintPair{1, 12},
+	uintPair{56, 7}:   uintPair{7, 8},
+	uintPair{70, 10}:  uintPair{10, 7},
+}
+
+// testing version of Split
+func splitTest(a uintPair) uintPair {
+	regular, totative := Split(a.a, a.b)
+	return uintPair{regular, totative}
+}
+
+func TestSplit(t *testing.T) {
+	tableTest(t, splitTest, splitCases, stdEquals, "Split")
+}
+
 // to be used as the equal paramater for tableTest
 func stdEquals[T comparable](a, b T) bool { return a == b }