diff options
Diffstat (limited to 'factors/factors_test.go')
| -rw-r--r-- | factors/factors_test.go | 95 |
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 } |