How to solve a linear programming problem with SciPy

Many allocation decisions trade a linear cost against linear capacity, demand, or quality limits. SciPy turns those coefficients into an optimum plus a termination status through scipy.optimize.linprog(), making it suitable for continuous planning models without nonlinear terms.

The solver minimizes c @ x under <= inequalities, exact equalities, and variable bounds. A minimum requirement therefore needs both sides multiplied by -1 before it becomes an A_ub row; the supplier model expresses its quality floor that way.

The sample chooses regular and premium quantities that total ten units while reaching a quality score of at least fourteen. Both quantities remain continuous and nonnegative; integer lots need a mixed-integer model instead.

Steps to solve a linear programming problem with SciPy:

Create solve_linear_program.py with the initial model inputs.

import numpy as np
from scipy.optimize import linprog
 
 
cost = np.array([4.0, 7.0])

Append the demand equation beneath the cost vector in solve_linear_program.py.
```
demand_coefficients = np.array([[1.0, 1.0]])
demand_total = np.array([10.0])
```
The equality row requires the regular and premium quantities to total exactly ten units.
Append the minimum-quality inequality beneath the demand equation.
```
quality_coefficients = np.array([[-1.0, -2.0]])
minimum_quality = np.array([-14.0])
```
linprog() accepts inequalities as A_ub @ x <= b_ub, so the quality requirement is multiplied by -1.
Append nonnegative bounds for both supplier quantities.
```
bounds = [(0.0, None), (0.0, None)]
```

Add the linprog() call beneath the bounds.

result = linprog(
    c=cost,
    A_ub=quality_coefficients,
    b_ub=minimum_quality,
    A_eq=demand_coefficients,
    b_eq=demand_total,
    bounds=bounds,
    method="highs",
)

method=“highs” selects SciPy's HiGHS linear optimization interface.

Add a solver-failure check beneath the linprog() call.
```
if not result.success:
    raise RuntimeError(result.message)
```
The returned quantities and objective value are valid only after success is True.

Add independent constraint validation beneath the solver-failure check.

regular, premium = result.x
total_units = regular + premium
quality_score = regular + 2.0 * premium
demand_residual = total_units - demand_total[0]
quality_margin = quality_score + minimum_quality[0]
 
if not np.isclose(demand_residual, 0.0) or quality_margin < -1e-9:
    raise RuntimeError("The returned quantities violate the model constraints.")

Add the result output beneath the constraint validation.

print(f"solver_success: {result.success}")
print(f"solver_status: {result.status}")
print(f"minimum_cost: {result.fun:.2f}")
print(f"regular_units: {regular:.1f}")
print(f"premium_units: {premium:.1f}")
print(f"demand_residual: {demand_residual:.2e}")
print(f"quality_margin: {quality_margin:.2e}")

Run the completed linear programming script.
```
$ python3 solve_linear_program.py
solver_success: True
solver_status: 0
minimum_cost: 52.00
regular_units: 6.0
premium_units: 4.0
demand_residual: 0.00e+00
quality_margin: 0.00e+00
```
Status 0 confirms an optimal solution, while zero demand residual and nonnegative quality margin confirm that both model constraints hold.