simplex: concrete sort.Interface for the dual ratio test (drop sort.Slice reflection)

The Clp long-step / DSE ratio test sorts entering candidates by ascending
ratio every dual pivot. sort.Slice does this via reflection (a per-element
reflect-based swap); on 020 it was 740ms / 6.8% of the solve. Replaced with
a concrete sort.Interface (dualCandByRatio / dual2CandByRatio) — the same
pdqsort, same comparator, so the order is byte-identical and results are
unchanged: 020 774 nodes / 182619 pivots / same objective, 018/021 identical.
Interleaved timing (controls for thermal drift): ~11.55s vs ~11.79s, a
consistent ~2% on 020 (new faster in all 5 paired runs). Numerics-neutral —
no tree re-roll. All tests + PuLP green.

Author: andig

simplex/dual2.go

@@ -39,6 +39,14 @@ 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 {
@@ -238,7 +246,7 @@ func (lp *LP) dual2Run(st *State) dual2Result {
 				cands = append(cands, dual2Cand{j, dir, at, rd, rd / at})
 			}
 		}
-		sort.Slice(cands, func(x, y int) bool { return cands[x].ratio < cands[y].ratio })
+		sort.Sort(dual2CandByRatio(cands))
 
 		// bound-flipping walk, then a Harris window: the largest pivot
 		// entry inside the first blocker's relaxed ratio wins

simplex/simplex.go

@@ -689,7 +689,7 @@ func (lp *LP) dualRun(st *State) {
 			}
 		}
 		ws.cands = cands
-		sort.Slice(cands, func(a, b int) bool { return cands[a].ratio < cands[b].ratio })
+		sort.Sort(dualCandByRatio(cands))
 
 		// dual long step (Clp "dual with flips"): boxed candidates that
 		// can't absorb the violation get flipped; the overshooter pivots
@@ -804,6 +804,15 @@ 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 {