Change functions and vars from snake_case to camelCase (Closes #16)
This commit is contained in:
parent
fc555fa581
commit
56ebe616ab
@ -13,7 +13,7 @@ import (
|
||||
//go:embed blocks.csv
|
||||
var f embed.FS
|
||||
|
||||
func (solver *Solver) load_blocks() {
|
||||
func (solver *Solver) loadBlocks() {
|
||||
|
||||
defer solver.timeTrack(time.Now(), "Loaded blocks")
|
||||
log.Println("Loading blocks")
|
||||
|
@ -8,7 +8,7 @@ import (
|
||||
"runtime"
|
||||
)
|
||||
|
||||
func (solver *Solver) parse_flags() {
|
||||
func (solver *Solver) parseFlags() {
|
||||
|
||||
// Define variables
|
||||
var row1 string
|
||||
@ -33,7 +33,7 @@ func (solver *Solver) parse_flags() {
|
||||
flag.StringVar(&row7, "row7", "000000000", "7th row of the sudoku puzzle.")
|
||||
flag.StringVar(&row8, "row8", "000000000", "8th row of the sudoku puzzle.")
|
||||
flag.StringVar(&row9, "row9", "000000000", "9th row of the sudoku puzzle.")
|
||||
flag.IntVar(&solver.numcpus, "numcpu", runtime.NumCPU(), "Number of CPU cores to assign to this task.")
|
||||
flag.IntVar(&solver.numCPUs, "numcpu", runtime.NumCPU(), "Number of CPU cores to assign to this task.")
|
||||
flag.IntVar(&split, "split", 1, "Split the tasks in n parts. This depends on the availability of the first row.")
|
||||
flag.IntVar(&part, "part", 1, "Process part x in n parts. Cannot be lower than 1, or higher than specified in split.")
|
||||
|
||||
@ -41,33 +41,33 @@ func (solver *Solver) parse_flags() {
|
||||
flag.Parse()
|
||||
|
||||
// Process any changes to the CPU usage.
|
||||
if solver.numcpus <= 0 {
|
||||
if solver.numCPUs <= 0 {
|
||||
log.Printf("ERROR: Number of CPU cores must be 1 or higher.\n\n")
|
||||
solver.print_Usage()
|
||||
solver.printUsage()
|
||||
os.Exit(1)
|
||||
}
|
||||
|
||||
if solver.numcpus != runtime.NumCPU() {
|
||||
runtime.GOMAXPROCS(solver.numcpus)
|
||||
if solver.numCPUs != runtime.NumCPU() {
|
||||
runtime.GOMAXPROCS(solver.numCPUs)
|
||||
}
|
||||
|
||||
// Process rows
|
||||
if row1 == "000000000" || row2 == "000000000" || row3 == "000000000" || row4 == "000000000" || row5 == "000000000" || row6 == "000000000" || row7 == "000000000" || row8 == "000000000" || row9 == "000000000" {
|
||||
log.Printf("ERROR: All parameters must be entered.\n\n")
|
||||
solver.print_Usage()
|
||||
solver.printUsage()
|
||||
os.Exit(1)
|
||||
}
|
||||
|
||||
// Validate the row (never trust user input)
|
||||
solver.validate_row("row1", row1)
|
||||
solver.validate_row("row2", row2)
|
||||
solver.validate_row("row3", row3)
|
||||
solver.validate_row("row4", row4)
|
||||
solver.validate_row("row5", row5)
|
||||
solver.validate_row("row6", row6)
|
||||
solver.validate_row("row7", row7)
|
||||
solver.validate_row("row8", row8)
|
||||
solver.validate_row("row9", row9)
|
||||
solver.validateRow("row1", row1)
|
||||
solver.validateRow("row2", row2)
|
||||
solver.validateRow("row3", row3)
|
||||
solver.validateRow("row4", row4)
|
||||
solver.validateRow("row5", row5)
|
||||
solver.validateRow("row6", row6)
|
||||
solver.validateRow("row7", row7)
|
||||
solver.validateRow("row8", row8)
|
||||
solver.validateRow("row9", row9)
|
||||
|
||||
// Put entries in into the struct
|
||||
solver.row1 = row1
|
||||
@ -84,14 +84,14 @@ func (solver *Solver) parse_flags() {
|
||||
// Ensure split and part are 1 or higher
|
||||
if split <= 0 || part <= 0 {
|
||||
log.Printf("ERROR: '-split' and '-part' need to be 1 or higher.\n")
|
||||
solver.print_Usage()
|
||||
solver.printUsage()
|
||||
os.Exit(1)
|
||||
}
|
||||
|
||||
// Ensure part is between 1 and split
|
||||
if part > split {
|
||||
log.Printf("ERROR: '-part' cannot be bigger than `-split`.\n")
|
||||
solver.print_Usage()
|
||||
solver.printUsage()
|
||||
os.Exit(1)
|
||||
}
|
||||
|
||||
@ -100,7 +100,7 @@ func (solver *Solver) parse_flags() {
|
||||
|
||||
}
|
||||
|
||||
func (solver *Solver) validate_row(name string, row string) {
|
||||
func (solver *Solver) validateRow(name string, row string) {
|
||||
|
||||
var found bool
|
||||
var double bool
|
||||
@ -109,18 +109,18 @@ func (solver *Solver) validate_row(name string, row string) {
|
||||
// 1. Make sure the row is 9 in length
|
||||
if len(row) != 9 {
|
||||
log.Printf("ERROR: Invalid length of %s (%s), must be 9 numbers\n\n", name, row)
|
||||
solver.print_Usage()
|
||||
solver.printUsage()
|
||||
os.Exit(1)
|
||||
}
|
||||
|
||||
// 2. Ensure all digits are numbers
|
||||
for _, value := range row {
|
||||
found = solver.valid_char(value)
|
||||
found = solver.validChar(value)
|
||||
}
|
||||
|
||||
if !found {
|
||||
log.Printf("ERROR: Invalid character of %s (%s), must be 9 numbers\n\n", name, row)
|
||||
solver.print_Usage()
|
||||
solver.printUsage()
|
||||
os.Exit(1)
|
||||
}
|
||||
|
||||
@ -137,13 +137,13 @@ func (solver *Solver) validate_row(name string, row string) {
|
||||
|
||||
if double {
|
||||
log.Printf("ERROR: Double character of %s (%s), numbers between 1 and 9 may only be entered once\n\n", name, row)
|
||||
solver.print_Usage()
|
||||
solver.printUsage()
|
||||
os.Exit(1)
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
func (solver *Solver) valid_char(char rune) (valid bool) {
|
||||
func (solver *Solver) validChar(char rune) (valid bool) {
|
||||
decvals := [10]int{48, 49, 50, 51, 52, 53, 54, 55, 56, 57}
|
||||
|
||||
for _, value := range decvals {
|
||||
@ -155,7 +155,7 @@ func (solver *Solver) valid_char(char rune) (valid bool) {
|
||||
return valid
|
||||
}
|
||||
|
||||
func (solver *Solver) print_Usage() {
|
||||
func (solver *Solver) printUsage() {
|
||||
fmt.Fprintf(flag.CommandLine.Output(), "Usage of %s:\n", os.Args[0])
|
||||
fmt.Fprintf(flag.CommandLine.Output(), "\nPut every row of a Sudoku puzzle as paramters.\nUse '0' for what is currently blank in the puzzle you wish to solve.\n\n")
|
||||
fmt.Fprintf(flag.CommandLine.Output(), "Example: %s -row1 ... -row2 ... -row3 ... (etc)\n\n", os.Args[0])
|
||||
|
@ -5,9 +5,9 @@ import (
|
||||
"log"
|
||||
)
|
||||
|
||||
func (solver *Solver) print_solutions() {
|
||||
for solution_index, solution := range solver.solutions {
|
||||
log.Printf("\nSolution #%d:", solution_index+1)
|
||||
func (solver *Solver) printSolutions() {
|
||||
for solutionIndex, solution := range solver.solutions {
|
||||
log.Printf("\nSolution #%d:", solutionIndex+1)
|
||||
fmt.Println(solution)
|
||||
}
|
||||
}
|
||||
|
@ -6,52 +6,52 @@ import (
|
||||
"time"
|
||||
)
|
||||
|
||||
func (solver *Solver) populate_blocks() {
|
||||
func (solver *Solver) populateBlocks() {
|
||||
|
||||
defer solver.timeTrack(time.Now(), "Populated blocks")
|
||||
log.Println("Populating blocks")
|
||||
|
||||
solver.find_blocks(&solver.row1, &solver.row1s)
|
||||
solver.find_blocks(&solver.row2, &solver.row2s)
|
||||
solver.find_blocks(&solver.row3, &solver.row3s)
|
||||
solver.find_blocks(&solver.row4, &solver.row4s)
|
||||
solver.find_blocks(&solver.row5, &solver.row5s)
|
||||
solver.find_blocks(&solver.row6, &solver.row6s)
|
||||
solver.find_blocks(&solver.row7, &solver.row7s)
|
||||
solver.find_blocks(&solver.row8, &solver.row8s)
|
||||
solver.find_blocks(&solver.row9, &solver.row9s)
|
||||
solver.findBlocks(&solver.row1, &solver.row1s)
|
||||
solver.findBlocks(&solver.row2, &solver.row2s)
|
||||
solver.findBlocks(&solver.row3, &solver.row3s)
|
||||
solver.findBlocks(&solver.row4, &solver.row4s)
|
||||
solver.findBlocks(&solver.row5, &solver.row5s)
|
||||
solver.findBlocks(&solver.row6, &solver.row6s)
|
||||
solver.findBlocks(&solver.row7, &solver.row7s)
|
||||
solver.findBlocks(&solver.row8, &solver.row8s)
|
||||
solver.findBlocks(&solver.row9, &solver.row9s)
|
||||
|
||||
// This calculates and stores the total number of solutions to validate.
|
||||
solver.iter = int64(len(solver.row1s)) * int64(len(solver.row2s)) * int64(len(solver.row3s)) * int64(len(solver.row4s)) * int64(len(solver.row5s)) * int64(len(solver.row6s)) * int64(len(solver.row7s)) * int64(len(solver.row8s)) * int64(len(solver.row9s))
|
||||
|
||||
}
|
||||
|
||||
func (solver *Solver) find_blocks(row *string, rows *[]int) {
|
||||
func (solver *Solver) findBlocks(row *string, rows *[]int) {
|
||||
// Declare selection
|
||||
var selection []int
|
||||
var curr_blocks []int
|
||||
func_row := *row
|
||||
var currBlocks []int
|
||||
funcRow := *row
|
||||
|
||||
for letter := range func_row {
|
||||
for letter := range funcRow {
|
||||
|
||||
if len(selection) == 0 {
|
||||
curr_blocks = solver.blocks
|
||||
currBlocks = solver.blocks
|
||||
} else {
|
||||
curr_blocks = selection
|
||||
currBlocks = selection
|
||||
selection = nil
|
||||
}
|
||||
|
||||
for _, block := range curr_blocks {
|
||||
for _, block := range currBlocks {
|
||||
|
||||
curr_row := strconv.Itoa(block)
|
||||
currRow := strconv.Itoa(block)
|
||||
|
||||
if func_row[letter] == curr_row[letter] {
|
||||
found_row, _ := strconv.Atoi(curr_row)
|
||||
selection = append(selection, found_row)
|
||||
if funcRow[letter] == currRow[letter] {
|
||||
foundRow, _ := strconv.Atoi(currRow)
|
||||
selection = append(selection, foundRow)
|
||||
}
|
||||
if func_row[letter] == '0' {
|
||||
found_row, _ := strconv.Atoi(curr_row)
|
||||
selection = append(selection, found_row)
|
||||
if funcRow[letter] == '0' {
|
||||
foundRow, _ := strconv.Atoi(currRow)
|
||||
selection = append(selection, foundRow)
|
||||
}
|
||||
|
||||
} // End for-loop
|
||||
@ -61,17 +61,17 @@ func (solver *Solver) find_blocks(row *string, rows *[]int) {
|
||||
*rows = selection
|
||||
}
|
||||
|
||||
func (solver *Solver) check_combinations() {
|
||||
for rows1_index := range solver.row1s {
|
||||
for rows2_index := range solver.row2s {
|
||||
for rows3_index := range solver.row3s {
|
||||
for rows4_index := range solver.row4s {
|
||||
for rows5_index := range solver.row5s {
|
||||
for rows6_index := range solver.row6s {
|
||||
for rows7_index := range solver.row7s {
|
||||
for rows8_index := range solver.row8s {
|
||||
for rows9_index := range solver.row9s {
|
||||
go solver.routine_validator(rows1_index, rows2_index, rows3_index, rows4_index, rows5_index, rows6_index, rows7_index, rows8_index, rows9_index)
|
||||
func (solver *Solver) checkCombinations() {
|
||||
for rows1Index := range solver.row1s {
|
||||
for rows2Index := range solver.row2s {
|
||||
for rows3Index := range solver.row3s {
|
||||
for rows4Index := range solver.row4s {
|
||||
for rows5Index := range solver.row5s {
|
||||
for rows6Index := range solver.row6s {
|
||||
for rows7Index := range solver.row7s {
|
||||
for rows8Index := range solver.row8s {
|
||||
for rows9Index := range solver.row9s {
|
||||
go solver.routineValidator(rows1Index, rows2Index, rows3Index, rows4Index, rows5Index, rows6Index, rows7Index, rows8Index, rows9Index)
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -83,13 +83,13 @@ func (solver *Solver) check_combinations() {
|
||||
}
|
||||
}
|
||||
|
||||
func (solver *Solver) routine_validator(rows1_index int, rows2_index int, rows3_index int, rows4_index int, rows5_index int, rows6_index int, rows7_index int, rows8_index int, rows9_index int) {
|
||||
func (solver *Solver) routineValidator(rows1Index int, rows2Index int, rows3Index int, rows4Index int, rows5Index int, rows6Index int, rows7Index int, rows8Index int, rows9Index int) {
|
||||
|
||||
// solver.counter = solver.counter + 1
|
||||
solver.counter.Add(1)
|
||||
|
||||
if solver.validate_combination(solver.row1s[rows1_index], solver.row2s[rows2_index], solver.row3s[rows3_index], solver.row4s[rows4_index], solver.row5s[rows5_index], solver.row6s[rows6_index], solver.row7s[rows7_index], solver.row8s[rows8_index], solver.row9s[rows9_index]) {
|
||||
solver.solutions = append(solver.solutions, solver.render_combination(solver.row1s[rows1_index], solver.row2s[rows2_index], solver.row3s[rows3_index], solver.row4s[rows4_index], solver.row5s[rows5_index], solver.row6s[rows6_index], solver.row7s[rows7_index], solver.row8s[rows8_index], solver.row9s[rows9_index]))
|
||||
if solver.validateCombination(solver.row1s[rows1Index], solver.row2s[rows2Index], solver.row3s[rows3Index], solver.row4s[rows4Index], solver.row5s[rows5Index], solver.row6s[rows6Index], solver.row7s[rows7Index], solver.row8s[rows8Index], solver.row9s[rows9Index]) {
|
||||
solver.solutions = append(solver.solutions, solver.renderCombination(solver.row1s[rows1Index], solver.row2s[rows2Index], solver.row3s[rows3Index], solver.row4s[rows4Index], solver.row5s[rows5Index], solver.row6s[rows6Index], solver.row7s[rows7Index], solver.row8s[rows8Index], solver.row9s[rows9Index]))
|
||||
}
|
||||
|
||||
}
|
||||
@ -108,13 +108,13 @@ func (solver *Solver) tracker() {
|
||||
var track int
|
||||
|
||||
// Tracking the rate, starting point
|
||||
var rate_start int64
|
||||
var rateStart int64
|
||||
// Tracking the rate, difference between previous iterations
|
||||
var rate_diff int64
|
||||
var rateDiff int64
|
||||
|
||||
// Tracking duration
|
||||
var timer_start = time.Now()
|
||||
// Prevent division-by-zero error when establishing `rate_diff`
|
||||
var timerStart = time.Now()
|
||||
// Prevent division-by-zero error when establishing `rateDiff`
|
||||
time.Sleep(time.Second)
|
||||
|
||||
// Estimation how long it will take
|
||||
@ -127,23 +127,23 @@ func (solver *Solver) tracker() {
|
||||
percentage = (float32(solver.counter.Load()) / (float32(solver.iter) / 100))
|
||||
|
||||
// Reset the loop
|
||||
rate_diff = solver.counter.Load() - rate_start
|
||||
rateDiff = solver.counter.Load() - rateStart
|
||||
|
||||
if track <= int(percentage) || rate_diff == 0 { // Start if-statement
|
||||
if track <= int(percentage) || rateDiff == 0 { // Start if-statement
|
||||
|
||||
// Make sure something happened, making rate_start the only reliable variable
|
||||
if rate_diff == 0 {
|
||||
// Make sure something happened, making rateStart the only reliable variable
|
||||
if rateDiff == 0 {
|
||||
percentage = 100
|
||||
solver.counter.Store(solver.iter)
|
||||
done = true
|
||||
}
|
||||
|
||||
timer_elapsed := time.Since(timer_start)
|
||||
solver.rates = append(solver.rates, rate_diff)
|
||||
rate_avg := solver.calc_avg()
|
||||
timer_elapsed := time.Since(timerStart)
|
||||
solver.rates = append(solver.rates, rateDiff)
|
||||
rate_avg := solver.calcAVG()
|
||||
|
||||
// Estimate when this is finished
|
||||
if rate_diff == 0 {
|
||||
if rateDiff == 0 {
|
||||
est_fin = "N/A"
|
||||
} else {
|
||||
duration_int := (solver.iter - solver.counter.Load()) / rate_avg
|
||||
@ -156,7 +156,7 @@ func (solver *Solver) tracker() {
|
||||
}
|
||||
|
||||
// Printing the progress
|
||||
log.Println("Processing: " + strconv.Itoa(int(percentage)) + "% (" + strconv.FormatInt(solver.counter.Load(), 10) + "/" + strconv.Itoa(int(solver.iter)) + "); Rate: " + strconv.FormatInt(rate_diff, 10) + "/sec for " + timer_elapsed.String() + "; Time left (est.): " + est_fin)
|
||||
log.Println("Processing: " + strconv.Itoa(int(percentage)) + "% (" + strconv.FormatInt(solver.counter.Load(), 10) + "/" + strconv.Itoa(int(solver.iter)) + "); Rate: " + strconv.FormatInt(rateDiff, 10) + "/sec for " + timer_elapsed.String() + "; Time left (est.): " + est_fin)
|
||||
|
||||
// After we are done printing, exit this for-loop
|
||||
if percentage == 100 {
|
||||
@ -170,12 +170,12 @@ func (solver *Solver) tracker() {
|
||||
track = track + 1
|
||||
}
|
||||
|
||||
timer_start = time.Now()
|
||||
timerStart = time.Now()
|
||||
|
||||
}
|
||||
|
||||
// Resert the rate counter
|
||||
rate_start = solver.counter.Load()
|
||||
rateStart = solver.counter.Load()
|
||||
|
||||
// Sleep for a second
|
||||
time.Sleep(1 * time.Second)
|
||||
@ -184,7 +184,7 @@ func (solver *Solver) tracker() {
|
||||
|
||||
}
|
||||
|
||||
func (solver *Solver) validate_combination(row1 int, row2 int, row3 int, row4 int, row5 int, row6 int, row7 int, row8 int, row9 int) (retval bool) {
|
||||
func (solver *Solver) validateCombination(row1 int, row2 int, row3 int, row4 int, row5 int, row6 int, row7 int, row8 int, row9 int) (retval bool) {
|
||||
retval = true
|
||||
|
||||
row1s := strconv.Itoa(row1)
|
||||
@ -239,14 +239,14 @@ func (solver *Solver) validate_combination(row1 int, row2 int, row3 int, row4 in
|
||||
return retval
|
||||
}
|
||||
|
||||
func (solver *Solver) calc_avg() (avg int64) {
|
||||
var avg_sum int64
|
||||
func (solver *Solver) calcAVG() (avg int64) {
|
||||
var avgSum int64
|
||||
|
||||
for _, value := range solver.rates {
|
||||
avg_sum += value
|
||||
avgSum += value
|
||||
}
|
||||
|
||||
avg = avg_sum / int64(len(solver.rates))
|
||||
avg = avgSum / int64(len(solver.rates))
|
||||
|
||||
return
|
||||
}
|
||||
|
@ -12,33 +12,33 @@ func Run() {
|
||||
solver := Solver{}
|
||||
|
||||
// Parse and handle flags
|
||||
solver.parse_flags()
|
||||
solver.parseFlags()
|
||||
|
||||
// Report number of CPUs being used, if set.
|
||||
if runtime.NumCPU() != solver.numcpus {
|
||||
log.Println("Using " + strconv.Itoa(solver.numcpus) + " CPUs, (was " + strconv.Itoa(runtime.NumCPU()) + ")")
|
||||
if runtime.NumCPU() != solver.numCPUs {
|
||||
log.Println("Using " + strconv.Itoa(solver.numCPUs) + " CPUs, (was " + strconv.Itoa(runtime.NumCPU()) + ")")
|
||||
}
|
||||
|
||||
// Load blocks from CSV file
|
||||
solver.load_blocks()
|
||||
solver.loadBlocks()
|
||||
|
||||
// Find rows that fit with the entered rows
|
||||
solver.populate_blocks()
|
||||
solver.populateBlocks()
|
||||
|
||||
// If needed, split the workload
|
||||
// May exit and throw an error if the work load isn't viable
|
||||
if solver.split != 1 {
|
||||
solver.select_workload()
|
||||
solver.selectWorkload()
|
||||
}
|
||||
|
||||
// Print the total number of solutions to validate
|
||||
log.Println("Number of (potential) solutions:", solver.iter)
|
||||
|
||||
// Check the number of solutions
|
||||
go solver.check_combinations()
|
||||
go solver.checkCombinations()
|
||||
solver.tracker()
|
||||
|
||||
// Print the valid solutions
|
||||
solver.print_solutions()
|
||||
solver.printSolutions()
|
||||
|
||||
}
|
||||
|
@ -10,7 +10,7 @@ import (
|
||||
// Perform some checks
|
||||
// and
|
||||
// Modify solver.row1s so it limits the workload to what is only desired.
|
||||
func (solver *Solver) select_workload() {
|
||||
func (solver *Solver) selectWorkload() {
|
||||
if solver.split > len(solver.row1s) {
|
||||
log.Println("ERROR: Unable to divide the workload in " + strconv.Itoa(solver.split) + " parts, when only " + strconv.Itoa(len(solver.row1s)) + " are available.\n\n")
|
||||
os.Exit(1)
|
||||
@ -18,12 +18,12 @@ func (solver *Solver) select_workload() {
|
||||
defer solver.timeTrack(time.Now(), "Workload set")
|
||||
log.Println("Setting workload")
|
||||
log.Println("We are agent " + strconv.Itoa(solver.part) + " of " + strconv.Itoa(solver.split))
|
||||
workloads := solver.split_workload()
|
||||
solver.set_workload(workloads)
|
||||
workloads := solver.splitWorkload()
|
||||
solver.setWorkload(workloads)
|
||||
}
|
||||
|
||||
// Determine how workload should be split among the agents
|
||||
func (solver *Solver) split_workload() []int {
|
||||
func (solver *Solver) splitWorkload() []int {
|
||||
agents := make([]int, solver.split)
|
||||
var tracker int
|
||||
var tasks int = len(solver.row1s)
|
||||
@ -41,7 +41,7 @@ func (solver *Solver) split_workload() []int {
|
||||
}
|
||||
|
||||
// Set the workload by setting solver.row1s
|
||||
func (solver *Solver) set_workload(agents []int) {
|
||||
func (solver *Solver) setWorkload(agents []int) {
|
||||
var start int = 0
|
||||
var finish int = 0
|
||||
for key, value := range agents {
|
||||
|
@ -4,7 +4,7 @@ import (
|
||||
"strconv"
|
||||
)
|
||||
|
||||
func (solver *Solver) render_combination(row1 int, row2 int, row3 int, row4 int, row5 int, row6 int, row7 int, row8 int, row9 int) string {
|
||||
func (solver *Solver) renderCombination(row1 int, row2 int, row3 int, row4 int, row5 int, row6 int, row7 int, row8 int, row9 int) string {
|
||||
|
||||
row1s := strconv.Itoa(row1)
|
||||
row2s := strconv.Itoa(row2)
|
||||
|
@ -29,7 +29,7 @@ type Solver struct {
|
||||
counter atomic.Int64
|
||||
solutions []string
|
||||
rates []int64
|
||||
numcpus int
|
||||
numCPUs int
|
||||
split int
|
||||
part int
|
||||
}
|
||||
|
@ -48,7 +48,7 @@ func (solver *Solver) routine_row8(index1 int, index2 int, index3 int, index4 in
|
||||
}
|
||||
|
||||
func (solver *Solver) routine_row9(index1 int, index2 int, index3 int, index4 int, index5 int, index6 int, index7 int, index8 int, index9 int) {
|
||||
go solver.routine_validator(index1, index2, index3, index4, index5, index6, index7, index8, index9)
|
||||
go solver.routineValidator(index1, index2, index3, index4, index5, index6, index7, index8, index9)
|
||||
}
|
||||
|
||||
// blocks.go
|
||||
|
Loading…
x
Reference in New Issue
Block a user