Add -group and -groups-file flags

Author: ncw

find_arctan_formulae.go

@@ -4,6 +4,7 @@
 package main
 
 import (
+	"bufio"
 	"encoding/binary"
 	"flag"
 	"fmt"
@@ -15,6 +16,7 @@ import (
 	"runtime"
 	"runtime/debug"
 	"runtime/pprof"
+	"strconv"
 	"strings"
 	"sync"
 	"time"
@@ -25,29 +27,32 @@ import (
 
 var (
 	// Flags
-	cpuprofile          string  // write CPU profile to this file
-	pslqVerbose         bool    // verbose flag for PSLQ
-	pslqIterations      int     // iterations for PSLQ
-	pslqPrecision       uint    // precision to do PSLQ in
-	pslqLogMaxCoeff     uint    // log(max coefficient size) for PSLQ
-	pslqTargetPrecision float64 // PSLQ target precision of the result as a fraction of prec
-	workers             int     // Number of workers for PSLQ and search
-	pslqAlgorithm       int     // PSLQ algorithm
-	pslqMaxItems        int     // output no more than this many entries per PSLQ file
-	alpha               uint32  // Don't output arctan terms bigger than 1/alpha
-	maxPrime            uint32  // maximum prime factor to consider for groups
-	pslqMinItems        int     // minimum number of items required for a PSLQ file
-	minGroupLength      int     // only find groups with this many members, min
-	maxGroupLength      int     // only find groups with this many members, max
-	maxX                uint32  // max value of x when in arctan 1/x term
-	arctanCacheSize     int     // cache this many arctan values
-	groupCacheSize      int     // cache this many group values
-	pslqMaxFails        int     // stop PSLQ with this many failures in a row
-	pslqMaxNoNew        int     // stop PSLQ if no new formulae for this long
-	pslqTrimStart       bool    // if set, trim PSLQ norms from the start (larger fractions)
-	maxLehmerMeasure    float64 // don't print if worse than this
-	searchX             uint32  // if set, linear search formulae from 1/searchX up
-	pslqSkipZeros       bool    // if set skip PSLQ on any relations which contain zero relations
+	cpuprofile          string     // write CPU profile to this file
+	pslqVerbose         bool       // verbose flag for PSLQ
+	pslqIterations      int        // iterations for PSLQ
+	pslqPrecision       uint       // precision to do PSLQ in
+	pslqLogMaxCoeff     uint       // log(max coefficient size) for PSLQ
+	pslqTargetPrecision float64    // PSLQ target precision of the result as a fraction of prec
+	workers             int        // Number of workers for PSLQ and search
+	pslqAlgorithm       int        // PSLQ algorithm
+	pslqMaxItems        int        // output no more than this many entries per PSLQ file
+	alpha               uint32     // Don't output arctan terms bigger than 1/alpha
+	maxPrime            uint32     // maximum prime factor to consider for groups
+	pslqMinItems        int        // minimum number of items required for a PSLQ file
+	minGroupLength      int        // only find groups with this many members, min
+	maxGroupLength      int        // only find groups with this many members, max
+	maxX                uint32     // max value of x when in arctan 1/x term
+	arctanCacheSize     int        // cache this many arctan values
+	groupCacheSize      int        // cache this many group values
+	pslqMaxFails        int        // stop PSLQ with this many failures in a row
+	pslqMaxNoNew        int        // stop PSLQ if no new formulae for this long
+	pslqTrimStart       bool       // if set, trim PSLQ norms from the start (larger fractions)
+	maxLehmerMeasure    float64    // don't print if worse than this
+	searchX             uint32     // if set, linear search formulae from 1/searchX up
+	pslqSkipZeros       bool       // if set skip PSLQ on any relations which contain zero relations
+	fixedGroupString    string     // a comma or space separated string for a prime group to use
+	groupsFile          string     // a file of comma or spare seperated groups, one per line
+	fixedGroups         [][]uint32 // parsed version of the above
 
 	// Globals
 	arctanCache      *lru.Cache[uint32, *big.Float]
@@ -94,6 +99,8 @@ func init() {
 	flag.BoolVar(&pslqSkipZeros, "skip-zeros", false, "if set skip PSLQ on any relations which contain previously found zero relations")
 	flag.Float64Var(&maxLehmerMeasure, "max-lehmer-measure", 0.0, "Don't print formulae with a Lehmer measure greater than this")
 	Uint32Var(&searchX, "search-x", 0, "If set do a linear search of terms from this value up")
+	flag.StringVar(&fixedGroupString, "group", "", "A comma or space separated list of primes to use as the prime group")
+	flag.StringVar(&groupsFile, "groups-file", "", "a file of comma or spare seperated groups, one per line")
 }
 
 func showParameters() {
@@ -575,7 +582,15 @@ func processPrimeGroups(norms []*Norm, primeMap map[uint32][]*Norm, primesToProc
 		go processPrimeGroupsWorker(primeMap, ch, &wg)
 	}
 
-	if searchX == 0 {
+	if len(fixedGroups) != 0 {
+		for _, group := range fixedGroups {
+			statsMu.Lock()
+			currentGroup = group
+			groupsChecked++
+			statsMu.Unlock()
+			ch <- group
+		}
+	} else if searchX == 0 {
 		for length := minGroupLength; length <= maxGroupLength; length++ {
 			Printf("\n--- Processing groups of length %d ---\n", length)
 			for group := range Combinations(primesToProcess, length) {
@@ -638,13 +653,99 @@ func run() error {
 	return processPrimeGroups(norms, primeMap, primesToProcess)
 }
 
+// parseUint32List parses a string containing space or comma or both
+// separated integers into a slice of uint32.
+// It returns the slice of parsed integers and any error encountered during parsing.
+func parseUint32List(input string) ([]uint32, error) {
+	// Replace commas with spaces to handle both delimiters consistently.
+	replaced := strings.ReplaceAll(input, ",", " ")
+
+	// Split the string by spaces.
+	parts := strings.Fields(replaced)
+
+	result := make([]uint32, 0, len(parts))
+
+	for _, part := range parts {
+		if part == "" {
+			continue // Skip empty strings resulting from multiple spaces or commas.
+		}
+		val, err := strconv.ParseUint(part, 10, 32)
+		if err != nil {
+			return nil, err
+		}
+		result = append(result, uint32(val))
+	}
+
+	return result, nil
+}
+
+// loadGroups reads a file of prime groups, parses each line as a space or comma
+// separated list of integers, and returns a slice of slices of uint32.
+func loadGroups(fileName string) ([][]uint32, error) {
+	file, err := os.Open(fileName)
+	if err != nil {
+		return nil, fmt.Errorf("failed to open file %q: %w", fileName, err)
+	}
+	defer file.Close()
+
+	var groups [][]uint32
+	scanner := bufio.NewScanner(file)
+	for scanner.Scan() {
+		line := scanner.Text()
+		if line == "" {
+			continue // Skip empty lines
+		}
+		group, err := parseUint32List(line)
+		if err != nil {
+			return nil, fmt.Errorf("failed to parse line %q: %w", line, err)
+		}
+		groups = append(groups, group)
+	}
+
+	if err := scanner.Err(); err != nil {
+		return nil, fmt.Errorf("failed to read file %q: %w", fileName, err)
+	}
+
+	return groups, nil
+}
+
 func main() {
 	var err error
 	flag.Parse()
 
 	Printf("Starting %s with parameters %v\n\n", os.Args[0], os.Args[1:])
 	showParameters()
 
+	if fixedGroupString != "" {
+		fixedGroup, err := parseUint32List(fixedGroupString)
+		if err != nil {
+			log.Fatalf("Failed to parse -group %q: %v", fixedGroupString, err)
+		}
+		fixedGroups = [][]uint32{fixedGroup}
+		Printf("Using fixed prime group %v\n", fixedGroup)
+	} else if groupsFile != "" {
+		fixedGroups, err = loadGroups(groupsFile)
+		if err != nil {
+			log.Fatalf("Failed to parse -groups-file %q: %v", groupsFile, err)
+		}
+		Printf("Using %d fixed prime groups from file %q\n", len(fixedGroups), groupsFile)
+	}
+	// Filter out lines bigger than maxPrime
+	if len(fixedGroups) != 0 {
+		newFixedGroups := fixedGroups[:0]
+	GROUPS:
+		for _, group := range fixedGroups {
+			for _, p := range group {
+				if p > maxPrime {
+					Printf("Warning: dropping %v from fixed group as %d > %d (-max-prime)\n", group, p, maxPrime)
+					continue GROUPS
+				}
+			}
+			newFixedGroups = append(newFixedGroups, group)
+		}
+		fixedGroups = newFixedGroups
+	}
+
 	// Do CPU profiling if requested
 	if cpuprofile != "" {
 		f, err := os.Create(cpuprofile)