simplex: slices.SortFunc for the dual ratio test (zero-alloc, generic)

Follow-up to e9d9386. Microbenchmark (200-elem tie-heavy sort, the ratio
test's shape): sort.Slice 6743ns/3allocs, sort.Sort-Interface 3269ns/1alloc,
slices.SortFunc 3080ns/0allocs. slices.SortFunc is 2.2x over the original
sort.Slice and 6%-faster + zero-alloc over the concrete sort.Interface (whose
1 alloc was interface boxing, x82k+ sorts). Order is byte-identical to
sort.Sort — verified across 200 tie-heavy seeds (a throwaway test) and by 020
staying at 774 nodes / 182619 pivots. Drops the concrete sort types. All
tests + PuLP green.

Author: andig

simplex/dual2.go

@@ -3,7 +3,7 @@ package simplex
 import (
 	"math"
 	"os"
-	"sort"
+	"slices"
 	"time"
 )
 
@@ -39,14 +39,6 @@ type dual2Cand struct {
 	ratio float64
 }
 
-// dual2CandByRatio: concrete sort.Interface for the DSE ratio test (skips
-// sort.Slice reflection; identical pdqsort order).
-type dual2CandByRatio []dual2Cand
-
-func (s dual2CandByRatio) Len() int           { return len(s) }
-func (s dual2CandByRatio) Less(i, j int) bool { return s[i].ratio < s[j].ratio }
-func (s dual2CandByRatio) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
-
 // dual2Run is a complete bounded dual simplex modeled on ClpSimplexDual:
 // DSE pricing, Harris ratio test with bound flips, run to optimality.
 func (lp *LP) dual2Run(st *State) dual2Result {
@@ -246,7 +238,15 @@ func (lp *LP) dual2Run(st *State) dual2Result {
 				cands = append(cands, dual2Cand{j, dir, at, rd, rd / at})
 			}
 		}
-		sort.Sort(dual2CandByRatio(cands))
+		slices.SortFunc(cands, func(a, b dual2Cand) int {
+			switch {
+			case a.ratio < b.ratio:
+				return -1
+			case a.ratio > b.ratio:
+				return 1
+			}
+			return 0
+		})
 
 		// bound-flipping walk, then a Harris window: the largest pivot
 		// entry inside the first blocker's relaxed ratio wins

simplex/simplex.go

@@ -7,7 +7,7 @@ package simplex
 import (
 	"math"
 	"os"
-	"sort"
+	"slices"
 	"time"
 
 	"cbcgo/problem"
@@ -689,7 +689,15 @@ func (lp *LP) dualRun(st *State) {
 			}
 		}
 		ws.cands = cands
-		sort.Sort(dualCandByRatio(cands))
+		slices.SortFunc(cands, func(a, b dualCand) int {
+			switch {
+			case a.ratio < b.ratio:
+				return -1
+			case a.ratio > b.ratio:
+				return 1
+			}
+			return 0
+		})
 
 		// dual long step (Clp "dual with flips"): boxed candidates that
 		// can't absorb the violation get flipped; the overshooter pivots
@@ -804,15 +812,6 @@ type dualCand struct {
 	ratio float64
 }
 
-// dualCandByRatio sorts entering candidates by ascending ratio. Concrete
-// sort.Interface (not sort.Slice) so the per-pivot ratio-test sort skips
-// reflection — same pdqsort, same comparator, byte-identical order.
-type dualCandByRatio []dualCand
-
-func (s dualCandByRatio) Len() int           { return len(s) }
-func (s dualCandByRatio) Less(i, j int) bool { return s[i].ratio < s[j].ratio }
-func (s dualCandByRatio) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
-
 // enterDirs lists the directions a nonbasic variable may enter the basis in.
 func enterDirs(s varStat) []float64 {
 	switch s {