Merge pull request #22 from evcc-io/perf/simplex-alloc-pooling

CBC/Clp engine features: reliability branching, DSE dual, warm cut re-solves

Author: andig

README.md

@@ -94,11 +94,17 @@ It fails on any failure not listed in `testdata/pulp_known_failures.txt`.
   re-run on every improving incumbent, SOS1/SOS2 via Beale–Tomlin
   splitting; a failed pass restarts once on the same model, inheriting
   cuts, fixings and probe facts.
-- **Branching**: strong branching at shallow depths (to depth 6 on large
-  instances, 16 otherwise) seeding pseudocosts, with CBC-style
-  strong-branch fixing — a probe side that is infeasible or cannot beat
-  the incumbent fixes the variable at the node without spending a
-  branch; pseudocost selection deeper (reliability-branching shape).
+- **Branching**: CBC reliability branching — a column whose pseudocost
+  isn't yet trusted (fewer than `numberBeforeTrust`=10 observed gains
+  either way) is strong-branched with cheap capped dual probes to seed
+  it; trusted columns are scored straight from their pseudocost. The
+  branch variable is the best CBC score (max-weighted blend before an
+  incumbent, product rule after). Untrusted columns float to the top so
+  the per-node strong-branch budget (`maxStrong`=5) is spent where the
+  pseudocosts are least reliable — so it runs at every depth yet
+  self-limits once columns are seeded. CBC-style strong-branch fixing: a
+  probe side that is infeasible or cannot beat the incumbent fixes the
+  variable at the node without spending a branch.
 - **Heuristics**: caller-provided MIP start (`mip.Model.MIPStart`,
   completed via a warm child solve before the cut loop so reduced-cost
   fixing bites; the trivial start is deliberately not polished — measured

mip/cuts.go

@@ -17,6 +17,10 @@ const (
 	cutDropTol  = 1e-11
 	maxCutsPer  = 32 // cuts per round
 	maxCutRound = 30 // hard cap; rounds stop early once the bound stalls
+
+	// cutMarginFrac stops cut rounds once a round's bound gain drops below this
+	// fraction of the cumulative gain (warm-invariant diminishing-returns test)
+	cutMarginFrac = 0.02
 )
 
 // probingCuts probes fractional binaries at x and adds violated implication
@@ -294,9 +298,11 @@ func (m *Model) gomoryCuts(st *simplex.State) int {
 	// fractional tableau rows; the aggregate LHS stays integer, so the
 	// same MIR derivation applies. Big instances only (cf. probing cuts).
 	if m.LP.NumRows() > 1500 {
+		// D3: aggregate many tableau pairs toward CBC's TwoMir cut count.
+		topCap, pairCap := 24, 64
 		topN := len(cands)
-		if topN > 8 {
-			topN = 8
+		if topN > topCap {
+			topN = topCap
 		}
 		tabs := make([][]float64, topN)
 		bval := make([]float64, topN)
@@ -307,8 +313,8 @@ func (m *Model) gomoryCuts(st *simplex.State) int {
 		}
 		agg := make([]float64, nt)
 		pairAdded := 0
-		for a := 0; a < topN && pairAdded < 8; a++ {
-			for b := a + 1; b < topN && pairAdded < 8; b++ {
+		for a := 0; a < topN && pairAdded < pairCap; a++ {
+			for b := a + 1; b < topN && pairAdded < pairCap; b++ {
 				for _, sgn := range [2]float64{1, -1} {
 					for j := range nt {
 						agg[j] = tabs[a][j] + sgn*tabs[b][j]

mip/eliminate.go

@@ -167,14 +167,9 @@ func eliminateSingletons(p *problem.Problem) (*problem.Problem, *reduction) {
 	return q, &reduction{orig: p, records: records, colMap: colMap}
 }
 
-// dropRedundantContinuousRows removes rows that (a) can never bind under the
-// current column bounds (min activity >= lb and max activity <= ub) and (b)
-// contain no integer column. Condition (a) makes removal exact for the LP;
-// condition (b) keeps it clear of the GMI/MIR cut suite, which only derives
-// from integer structure — so the relaxation, cuts and branch tree are all
-// unchanged, only inert continuous rows leave (CBC forcing-row removal).
-// Returns (nil,nil) when nothing qualifies; keep[origRow]=false when dropped.
-func dropRedundantContinuousRows(p *problem.Problem) (*problem.Problem, []bool) {
+// dropRedundantRows removes never-binding rows (exact; postsolve: a·x, 0 dual).
+// includeInt also drops integer rows — CBC CglPreProcess forcing removal (D1).
+func dropRedundantRows(p *problem.Problem, includeInt bool) (*problem.Problem, []bool) {
 	inf := problem.Inf
 	keep := make([]bool, len(p.Rows))
 	nkeep := 0
@@ -208,7 +203,7 @@ func dropRedundantContinuousRows(p *problem.Problem) (*problem.Problem, []bool)
 				mx += a * lb
 			}
 		}
-		redundant := !hasInt && mni == 0 && mxi == 0 && mn >= rlb-1e-7 && mx <= rub+1e-7
+		redundant := (includeInt || !hasInt) && mni == 0 && mxi == 0 && mn >= rlb-1e-7 && mx <= rub+1e-7
 		keep[ri] = !redundant
 		if keep[ri] {
 			nkeep++
@@ -231,7 +226,7 @@ func dropRedundantContinuousRows(p *problem.Problem) (*problem.Problem, []bool)
 		nri := q.AddRow(r.Name, r.Idx, r.Coef, r.Sense, r.RHS)
 		q.Rows[nri].HasRange, q.Rows[nri].Range = r.HasRange, r.Range
 	}
-	debugf("presolve: dropped %d/%d redundant continuous rows", len(p.Rows)-nkeep, len(p.Rows))
+	debugf("presolve: dropped %d/%d redundant rows (includeInt=%v)", len(p.Rows)-nkeep, len(p.Rows), includeInt)
 	return q, keep
 }