Treat radices >2^16 as large unless -l set

These radices are large enough that:
- there is no reason to use them as actual radices
- calculating them takes a lot of time!

Therefore, the exact MTC and radix type shouldn't be calculated by
default.  If you want to take the time, you still can with -l.  I am
keeping the original 2^32 limit even with -l, because the problem with
that is not performance, it is that the resulting MTC could overflow a
uint64 (also the CAN list only goes up to this range).

3 files changed, 23 insertions, 11 deletions

diff --git a/args.go b/args.go
index f2ede5d..99f4874 100644
--- a/args.go
+++ b/args.go
@@ -11,9 +11,10 @@ const ProgramVersion = "1.0.0-alpha+dev"
 
 // The arguments to this program
 type args struct {
-	Radix   uint
-	Compact bool
-	FullMap bool
+	Radix     uint
+	Compact   bool
+	FullMap   bool
+	LargeCalc bool
 	// If true, exit the program immediately after parsing args.
 	Exit bool
 }
@@ -24,6 +25,8 @@ func parseArgs() (args, error) {
 	flag.BoolVar(&a.FullMap, "f", false,
 		fmt.Sprintf("Show full digit map (up to %d) for every radix",
 			maxSmallRadix))
+	flag.BoolVar(&a.LargeCalc, "l", false,
+		"Calculate exact MTC and radix class for very large radices, which may take a while.")
 	help := flag.Bool("?", false,
 		"Get information about program usage then exit")
 	version := flag.Bool("V", false,
diff --git a/factor_info.go b/factor_info.go
index 0d0bd40..62c3524 100644
--- a/factor_info.go
+++ b/factor_info.go
@@ -49,13 +49,22 @@ type FactorInfo struct {
 	DigitMap []factors.DigitType
 }
 
-func GetFactorInfo(radix uint, fullMap bool) *FactorInfo {
+const (
+	// The maximum radix that will always be treated as normal
+	// (i.e. radix type and exact MTC will be calculated)
+	maxNormal = 1 << 16
+	// The max radix that will be treated as normal with -l
+	// above this, MTC can exceed the size of a uint64
+	maxExtended = 1 << 32
+)
+
+func GetFactorInfo(radix uint, fullMap bool, largeCalc bool) *FactorInfo {
 	r_factors := factors.Factors(radix)
 	slices.Sort(r_factors)
 
 	var r_type_ptr *factors.NumberType
 	var mtc_ptr *uint64
-	if radix < 1<<32 {
+	if radix < maxNormal || (largeCalc && radix < maxExtended) {
 		r_type := factors.Type(uint32(radix))
 		r_type_ptr = &r_type
 		mtc := factors.MTC(uint64(radix))
@@ -91,15 +100,15 @@ func (fi *FactorInfo) WriteTo(w io.Writer) {
 	fmt.Fprintf(w, "Factors: %v (Score: %.4f)\n", fi.Factors, fi.Score)
 	fmt.Fprintln(w, "2345 Rank:", fi.BasicRank)
 	fmt.Fprintf(w, "Totative Digit Count: %d (%.3f%%)\n",
-		fi.Totient, fi.TotativeRatio * 100.0)
+		fi.Totient, fi.TotativeRatio*100.0)
 	if fi.Type != nil {
 		writeTypeMessage(w, *fi.Type)
 	}
 	if fi.MTC != nil {
 		fmt.Fprintln(w, "Multiplication Table Complexity:", *fi.MTC)
 	} else {
-		low_mtc_est := float64(fi.Radix)*float64(fi.Totient-2)
-		high_mtc_est := float64(fi.Radix)*float64(fi.Radix-2)
+		low_mtc_est := float64(fi.Radix) * float64(fi.Totient-2)
+		high_mtc_est := float64(fi.Radix) * float64(fi.Radix-2)
 		fmt.Fprintf(w,
 			"Multiplication Table Complexity is between %.6g and %.6g.\n",
 			low_mtc_est, high_mtc_est)
@@ -119,8 +128,8 @@ func (fi *FactorInfo) WriteToCompact(w io.Writer) {
 	if fi.MTC != nil {
 		fmt.Fprintf(w, "MTC: %d | ", *fi.MTC)
 	} else {
-		low_mtc_est := float32(fi.Radix)*float32(fi.Totient-2)
-		high_mtc_est := float32(fi.Radix)*float32(fi.Radix-2)
+		low_mtc_est := float32(fi.Radix) * float32(fi.Totient-2)
+		high_mtc_est := float32(fi.Radix) * float32(fi.Radix-2)
 		fmt.Fprintf(w, "%.4g ≤ MTC ≤ %.4g | ", low_mtc_est, high_mtc_est)
 	}
 	fmt.Fprintf(w, "Ln: %.2f", fi.Ln)
diff --git a/radix_info.go b/radix_info.go
index 0500a33..79b68e0 100644
--- a/radix_info.go
+++ b/radix_info.go
@@ -12,7 +12,7 @@ func main() {
 	}
 
 	if err == nil {
-		factorInfo := GetFactorInfo(args.Radix, args.FullMap)
+		factorInfo := GetFactorInfo(args.Radix, args.FullMap, args.LargeCalc)
 		if args.Compact {
 			factorInfo.WriteToCompact(os.Stdout)
 		} else {