Files
DSP_Mods/UXAssist/Production/TwoPhaseSimplex.cs
T
soarqin d4ba72abf4 fix(production): correct full-load capture and solver scaling
Stop capturing the transient miner output damper, apply the sandbox boost state to artificial stars as for launchers, and keep lens-free photon flows when no ray receiver is selected.

Scale the planner conservation check by each ledger row and normalize the simplex right-hand side so large rates no longer fail. Skip non-production objects before copying native settings, decode blueprints through the native paste path, and simplify analyzer mode resolution.

Update stale ProductionCheck expectations, add regression checks, and document the rules.
2026-10-11 03:13:07 +08:00

220 lines
8.4 KiB
C#

using System;
using System.Collections.Generic;
using System.Threading;
namespace UXAssist.Production;
internal enum LinearSolveStatus
{
Optimal,
Infeasible,
Unbounded,
IterationLimit,
Cancelled
}
internal sealed class LinearSolveResult
{
internal LinearSolveStatus Status { get; }
internal double[] Values { get; }
internal LinearSolveResult(LinearSolveStatus status, double[] values = null)
{
Status = status;
Values = values;
}
}
internal static class TwoPhaseSimplex
{
private const double PivotTolerance = 1e-10;
private const double ReducedTolerance = 1e-8;
internal static LinearSolveResult Solve(double[,] coefficients, double[] rightHandSide,
IReadOnlyList<double[]> objectives, int iterationBudget, CancellationToken cancellation)
{
var rowCount = rightHandSide.Length;
var columnCount = coefficients.GetLength(1);
if (coefficients.GetLength(0) != rowCount || iterationBudget <= 0)
throw new ArgumentException("The linear system or iteration budget is invalid.");
foreach (var objective in objectives)
{
if (objective.Length != columnCount)
throw new ArgumentException("An objective has an incorrect number of columns.");
}
if (rowCount == 0)
return new LinearSolveResult(LinearSolveStatus.Optimal, new double[columnCount]);
// Optimal values scale linearly with the right-hand side; normalize it so tolerances do not depend on rates.
var rightHandScale = 0.0;
foreach (var value in rightHandSide)
{
if (double.IsNaN(value) || double.IsInfinity(value))
throw new ArgumentException("The right-hand side contains a non-finite number.");
rightHandScale = Math.Max(rightHandScale, Math.Abs(value));
}
if (rightHandScale == 0) rightHandScale = 1;
var width = columnCount + rowCount;
var tableau = new double[rowCount, width + 1];
var basis = new int[rowCount];
var isBasic = new bool[width];
for (var row = 0; row < rowCount; row++)
{
var scale = 0.0;
for (var column = 0; column < columnCount; column++)
{
if (double.IsNaN(coefficients[row, column]) || double.IsInfinity(coefficients[row, column]))
throw new ArgumentException("The constraint matrix contains a non-finite number.");
scale = Math.Max(scale, Math.Abs(coefficients[row, column]));
}
var rightHand = rightHandSide[row] / rightHandScale;
if (scale == 0)
{
if (Math.Abs(rightHand) > PivotTolerance)
return new LinearSolveResult(LinearSolveStatus.Infeasible);
scale = 1;
}
var sign = rightHand < 0 ? -1 : 1;
for (var column = 0; column < columnCount; column++)
tableau[row, column] = sign * coefficients[row, column] / scale;
tableau[row, columnCount + row] = 1;
tableau[row, width] = sign * rightHand / scale;
basis[row] = columnCount + row;
isBasic[columnCount + row] = true;
}
var artificialObjective = new double[width];
for (var row = 0; row < rowCount; row++) artificialObjective[columnCount + row] = 1;
var iterations = 0;
var firstStatus = Optimize(tableau, basis, isBasic, artificialObjective, Array.Empty<double[]>(),
columnCount, ref iterations, iterationBudget, cancellation);
if (firstStatus != LinearSolveStatus.Optimal)
return new LinearSolveResult(firstStatus == LinearSolveStatus.Unbounded
? LinearSolveStatus.Infeasible : firstStatus);
for (var row = 0; row < rowCount; row++)
{
if (basis[row] < columnCount) continue;
if (Math.Abs(tableau[row, width]) > ReducedTolerance)
return new LinearSolveResult(LinearSolveStatus.Infeasible);
for (var column = 0; column < columnCount; column++)
{
if (isBasic[column] || Math.Abs(tableau[row, column]) <= PivotTolerance) continue;
Pivot(tableau, basis, isBasic, row, column);
break;
}
}
var optimizedObjectives = new List<double[]>();
foreach (var objective in objectives)
{
var costs = new double[width];
Array.Copy(objective, costs, columnCount);
var status = Optimize(tableau, basis, isBasic, costs, optimizedObjectives, columnCount,
ref iterations, iterationBudget, cancellation);
if (status != LinearSolveStatus.Optimal) return new LinearSolveResult(status);
optimizedObjectives.Add(costs);
}
var values = new double[columnCount];
for (var row = 0; row < rowCount; row++)
{
if (basis[row] < columnCount)
values[basis[row]] = Math.Max(0, tableau[row, width]) * rightHandScale;
}
return new LinearSolveResult(LinearSolveStatus.Optimal, values);
}
private static LinearSolveStatus Optimize(double[,] tableau, int[] basis, bool[] isBasic, double[] costs,
IReadOnlyList<double[]> previousCosts, int enteringLimit, ref int iterations, int budget,
CancellationToken cancellation)
{
var rowCount = basis.Length;
var rightColumn = tableau.GetLength(1) - 1;
while (true)
{
if (cancellation.IsCancellationRequested) return LinearSolveStatus.Cancelled;
var entering = -1;
for (var column = 0; column < enteringLimit; column++)
{
if (isBasic[column] || ReducedCost(tableau, basis, costs, column) >= -ReducedTolerance)
continue;
var preservesPrevious = true;
foreach (var previous in previousCosts)
{
if (Math.Abs(ReducedCost(tableau, basis, previous, column)) <= ReducedTolerance) continue;
preservesPrevious = false;
break;
}
if (preservesPrevious)
{
entering = column;
break;
}
}
if (entering < 0) return LinearSolveStatus.Optimal;
if (iterations >= budget) return LinearSolveStatus.IterationLimit;
var leaving = -1;
var minRatio = double.PositiveInfinity;
for (var row = 0; row < rowCount; row++)
{
var coefficient = tableau[row, entering];
if (coefficient <= PivotTolerance) continue;
var ratio = Math.Max(0, tableau[row, rightColumn]) / coefficient;
if (ratio < minRatio - ReducedTolerance ||
Math.Abs(ratio - minRatio) <= ReducedTolerance &&
(leaving < 0 || basis[row] < basis[leaving]))
{
minRatio = ratio;
leaving = row;
}
}
if (leaving < 0) return LinearSolveStatus.Unbounded;
Pivot(tableau, basis, isBasic, leaving, entering);
iterations++;
}
}
private static double ReducedCost(double[,] tableau, int[] basis, double[] costs, int column)
{
var reduced = costs[column];
for (var row = 0; row < basis.Length; row++)
reduced -= costs[basis[row]] * tableau[row, column];
return reduced;
}
private static void Pivot(double[,] tableau, int[] basis, bool[] isBasic, int pivotRow, int pivotColumn)
{
var rowCount = basis.Length;
var width = tableau.GetLength(1);
var divisor = tableau[pivotRow, pivotColumn];
for (var column = 0; column < width; column++)
tableau[pivotRow, column] /= divisor;
for (var row = 0; row < rowCount; row++)
{
if (row == pivotRow) continue;
var factor = tableau[row, pivotColumn];
if (factor == 0) continue;
for (var column = 0; column < width; column++)
tableau[row, column] -= factor * tableau[pivotRow, column];
tableau[row, pivotColumn] = 0;
}
tableau[pivotRow, pivotColumn] = 1;
isBasic[basis[pivotRow]] = false;
isBasic[pivotColumn] = true;
basis[pivotRow] = pivotColumn;
}
}