Linear Programming and Convex Optimization: How Algorithms Optimize Under Constraints

Last Updated June 20, 2026

Linear programming and convex optimization explain how algorithms solve structured decision problems by combining objectives, variables, constraints, feasible regions, and efficient solution methods. Many computational problems ask how to allocate limited resources, choose quantities, schedule activity, balance trade-offs, minimize cost, maximize value, reduce risk, or find the best feasible decision under clearly defined mathematical conditions.

Linear programming is optimization with a linear objective and linear constraints. Convex optimization is a broader framework in which the feasible region and objective structure allow reliable movement toward globally optimal solutions. These methods appear in logistics, energy systems, finance, operations research, public planning, telecommunications, machine learning, supply chains, environmental modeling, infrastructure management, workforce scheduling, portfolio design, and institutional decision support.

This article introduces linear programming and convex optimization as core topics in algorithms and computational reasoning. It emphasizes that optimization is not only about mathematical efficiency. It is also about how goals, constraints, trade-offs, assumptions, data, uncertainty, and institutional priorities are represented before an algorithm declares something optimal.

This article explains decision variables, objective functions, linear constraints, feasible regions, binding constraints, slack, shadow prices, simplex reasoning, duality, convex sets, convex functions, global optima, local optima, constraint qualifications, sensitivity analysis, robust optimization, fairness constraints, uncertainty, traceability, governance, and representation risk. It emphasizes that an optimal solution is only meaningful relative to the model that defines the objective, constraints, data, and feasible set.

Why Linear Programming and Convex Optimization Matter

Linear programming and convex optimization matter because many real decisions involve limited resources and competing goals. A city may need to allocate emergency vehicles. A company may need to schedule production. A grid operator may need to dispatch power. A public agency may need to allocate services. A machine-learning system may need to minimize error while satisfying constraints.

These problems are difficult not because the goal is vague, but because the goal must be pursued within limits. Optimization gives a formal way to represent those limits and reason about the best feasible option.

Optimization turns goals and limits into a structured search for the best feasible decision.

Back to top ↑

Linear Programming Defined

Linear programming solves optimization problems in which the objective function and constraints are linear. The model chooses values for decision variables in order to maximize or minimize a linear expression while satisfying linear inequalities or equalities.

Linear programming is powerful because many allocation problems can be approximated or represented in linear form. It also has strong geometric and computational structure. The feasible region is a polyhedron, and optimal solutions occur at boundary points or vertices when a finite optimum exists.

Linear programming is a formal language for limited-resource choice.

Back to top ↑

Decision Variables, Objectives, and Constraints

The first modeling task is to define decision variables. These variables represent what the optimization model is allowed to choose. If the variables are poorly chosen, the model may optimize the wrong problem.

The objective function defines what counts as better. Constraints define what is allowed. Together, they determine the feasible set and the meaning of optimality.

Optimization begins as representation, not calculation.

Back to top ↑

Feasible Regions and Optimal Solutions

The feasible region is the set of all solutions that satisfy the constraints. In linear programming, the feasible region is shaped by linear inequalities and equalities. Each constraint cuts away part of the space. What remains is the set of allowable choices.

An optimal solution is the feasible solution with the best objective value. If the feasible region is empty, the problem is infeasible. If the objective can improve without bound, the problem is unbounded.

The feasible region is the modeled world within which the algorithm searches.

Back to top ↑

Binding Constraints, Slack, and Sensitivity

A binding constraint is exactly tight at the solution. A nonbinding constraint has slack. Slack measures unused capacity, margin, or room before a constraint becomes tight.

Sensitivity analysis asks how the solution changes when coefficients, constraints, resource limits, or objective weights change. This is crucial because optimization results often depend on uncertain or estimated inputs.

Sensitivity analysis helps distinguish robust decisions from fragile optimal points.

Back to top ↑

Simplex and Geometric Reasoning

The simplex method is a classic algorithm for linear programming. Geometrically, it moves along vertices of the feasible region, improving the objective until no adjacent move improves the solution.

This geometric view is useful because it shows why linear programming has structure. The optimum is not found by random search. It is found by using the shape of the feasible region and the direction of improvement defined by the objective.

Simplex reasoning links algebraic computation to the geometry of feasible choice.

Back to top ↑

Duality and Shadow Prices

Duality is one of the central ideas in linear programming. Every linear program has a related dual problem. The primal problem may represent choices about activities or allocations. The dual problem often represents prices, resource values, certificates, or bounds.

Shadow prices come from dual variables. They estimate how much the objective would improve if a constraint were relaxed slightly. This makes duality useful for interpretation, not only computation.

Duality turns constraints into interpretable values.

Back to top ↑

Convex Optimization Defined

Convex optimization generalizes linear programming. A convex optimization problem has a structure that prevents deceptive local optima from trapping the search. Under standard conditions, a local optimum is also a global optimum.

This makes convex optimization especially important in algorithms, statistics, machine learning, signal processing, control, finance, operations research, and scientific computing. It offers a framework for reliable optimization when objectives and constraints have favorable geometry.

Convexity is valuable because it makes optimization more reliable.

Back to top ↑

Convex Sets and Convex Functions

A set is convex if every line segment between two points in the set remains inside the set. A function is convex if the line segment between two points on its graph lies above the graph. These geometric ideas have major computational consequences.

Convex sets avoid disconnected feasible regions. Convex functions avoid misleading local valleys. Together, they create optimization problems where global structure supports reliable solution methods.

Convexity is a property of problem shape, not merely algorithm choice.

Back to top ↑

Local and Global Optima

A local optimum is best among nearby alternatives. A global optimum is best among all feasible alternatives. In nonconvex problems, local optima can be misleading. In convex minimization, every local optimum is global under appropriate conditions.

This distinction matters for trust. An algorithm may report a solution, but users need to know whether the method can guarantee global optimality or only improvement relative to a starting point.

Convex optimization is attractive because it narrows the gap between local improvement and global confidence.

Back to top ↑

Constraints, Regularization, and Penalties

Constraints define what is allowed. Penalties and regularization add costs to undesirable patterns. In machine learning, regularization may discourage overly complex models. In institutional optimization, penalties may represent risk, unfairness, delay, emissions, shortage, or violation of soft constraints.

A hard constraint forbids a solution. A penalty discourages it. This distinction matters. Treating a protected requirement as a penalty may allow violations. Treating a negotiable preference as a hard constraint may make a problem infeasible.

Constraints and penalties are not interchangeable. They encode different forms of judgment.

Back to top ↑

Robustness, Uncertainty, and Sensitivity

Optimization models often use uncertain data. Demand may change. Prices may shift. Travel times may vary. Capacity may fail. Measurements may be incomplete. Coefficients may be estimates.

Robust optimization asks whether a solution remains acceptable under plausible variation. Sensitivity analysis asks how the solution changes as inputs change. Scenario analysis tests specific alternative futures.

An optimal solution that collapses under small changes may be mathematically correct but practically fragile.

Back to top ↑

Fairness, Governance, and Institutional Objectives

Optimization models are often used inside institutions. They may allocate resources, prioritize cases, schedule staff, route services, assign budgets, or recommend interventions. In these settings, objectives and constraints carry ethical and political weight.

A model that minimizes cost may reduce service quality. A model that maximizes throughput may increase worker burden. A model that minimizes delay may shift burdens to less visible communities. A model that optimizes average performance may worsen outcomes for a minority of cases.

Optimization governance asks whether the model’s definition of “best” is legitimate in context.

Back to top ↑

Traceability and Accountability

Optimization systems should preserve records of objectives, variables, constraints, coefficients, data sources, solver settings, feasibility status, optimal values, sensitivity results, and human review.

Traceability matters because optimization outputs can appear authoritative. A solution labeled “optimal” may be accepted without asking what was optimized, what was constrained, what was omitted, and what trade-offs were made.

Optimization accountability requires a visible path from assumptions to model to solution to consequence.

Back to top ↑

Representation Risk

Representation risk appears when an optimization model treats its formal structure as if it fully captured the real decision. A model may omit costs, ignore harms, simplify constraints, assume linearity, mismeasure objectives, hide uncertainty, or treat contested priorities as neutral coefficients.

Optimization is especially vulnerable to false precision. A solver can return a highly precise answer even when the model’s assumptions are incomplete. The numerical answer may be exact relative to the model and misleading relative to the world.

An optimization model should be judged not only by whether it solves, but by whether it represents the decision responsibly.

Back to top ↑

Back to top ↑

Mathematics, Computation, and Modeling

A standard linear programming problem can be represented as:

A minimization version can be written as:

A convex optimization problem can be represented as:

A convexity condition for a function can be written as:

The Lagrangian can be written as:

A sensitivity-style shadow price can be interpreted as:

These formulas provide a compact vocabulary for objectives, constraints, feasible regions, convexity, Lagrangians, dual variables, and sensitivity.

Back to top ↑

Python Workflow: Linear Programming and Convex Optimization Audit

The Python workflow below creates a dependency-light audit for linear programming and convex optimization models. It scores synthetic optimization cases for variable clarity, objective documentation, constraint documentation, feasibility logic, sensitivity review, robustness, fairness review, traceability, and governance.

# linear_programming_convex_optimization_audit.py
# Dependency-light workflow for auditing linear programming and convex optimization models.

from __future__ import annotations

from dataclasses import asdict, dataclass
from itertools import product
from pathlib import Path
from statistics import mean
import csv
import json

ARTICLE_ROOT = Path(__file__).resolve().parents[1]
TABLES = ARTICLE_ROOT / "outputs" / "tables"
JSON_DIR = ARTICLE_ROOT / "outputs" / "json"


@dataclass(frozen=True)
class OptimizationCase:
    case_name: str
    decision_context: str
    optimization_goal: str
    variable_clarity: float
    objective_documentation: float
    constraint_documentation: float
    data_provenance: float
    feasibility_logic: float
    sensitivity_review: float
    robustness_review: float
    fairness_review: float
    traceability: float
    governance_review: float
    communication_clarity: float


def clamp(value: float, low: float = 0.0, high: float = 100.0) -> float:
    return max(low, min(high, value))


def optimization_governance_score(case: OptimizationCase) -> float:
    return clamp(
        100.0 * (
            0.10 * case.variable_clarity
            + 0.11 * case.objective_documentation
            + 0.11 * case.constraint_documentation
            + 0.09 * case.data_provenance
            + 0.10 * case.feasibility_logic
            + 0.10 * case.sensitivity_review
            + 0.09 * case.robustness_review
            + 0.09 * case.fairness_review
            + 0.09 * case.traceability
            + 0.08 * case.governance_review
            + 0.04 * case.communication_clarity
        )
    )


def optimization_governance_risk(case: OptimizationCase) -> float:
    weak_points = [
        1.0 - case.variable_clarity,
        1.0 - case.objective_documentation,
        1.0 - case.constraint_documentation,
        1.0 - case.data_provenance,
        1.0 - case.feasibility_logic,
        1.0 - case.sensitivity_review,
        1.0 - case.robustness_review,
        1.0 - case.fairness_review,
        1.0 - case.traceability,
        1.0 - case.governance_review,
    ]
    return clamp(100.0 * mean(weak_points))


def diagnose(score: float, risk: float) -> str:
    if score >= 84 and risk <= 20:
        return "strong optimization-governance discipline"
    if score >= 70 and risk <= 35:
        return "usable optimization model with review needs"
    if risk >= 55:
        return "high risk; objectives, constraints, data provenance, feasibility, robustness, fairness, or governance may be underdefined"
    return "partial discipline; strengthen objectives, constraints, sensitivity, robustness, traceability, fairness, and governance"


def feasible_plan(x: int, y: int) -> bool:
    labor = 2 * x + 1 * y
    material = 1 * x + 2 * y
    return labor <= 8 and material <= 8 and x >= 0 and y >= 0


def objective_value(x: int, y: int) -> float:
    return 3 * x + 4 * y


def brute_force_linear_program() -> dict[str, object]:
    candidates: list[dict[str, object]] = []

    for x, y in product(range(0, 9), range(0, 9)):
        if feasible_plan(x, y):
            candidates.append({
                "x": x,
                "y": y,
                "objective_value": objective_value(x, y),
                "labor_used": 2 * x + y,
                "material_used": x + 2 * y,
                "labor_slack": 8 - (2 * x + y),
                "material_slack": 8 - (x + 2 * y),
            })

    best = max(candidates, key=lambda row: float(row["objective_value"]))
    return {
        "candidate_count": len(candidates),
        "best_solution": best,
        "interpretation": "Small integer grid enumeration used only as a transparent teaching calculator for a two-variable linear program."
    }


def convex_quadratic_example() -> list[dict[str, object]]:
    rows: list[dict[str, object]] = []

    for x in [-3, -2, -1, 0, 1, 2, 3, 4, 5]:
        value = (x - 2) ** 2 + 1
        rows.append({
            "x": x,
            "convex_objective_value": value,
            "is_global_minimum": x == 2,
        })

    return rows


def build_cases() -> list[OptimizationCase]:
    return [
        OptimizationCase(
            case_name="Production planning model",
            decision_context="Choose production quantities under labor, material, machine, and demand constraints.",
            optimization_goal="maximize feasible profit while documenting constraints and sensitivity",
            variable_clarity=0.88,
            objective_documentation=0.86,
            constraint_documentation=0.84,
            data_provenance=0.78,
            feasibility_logic=0.86,
            sensitivity_review=0.80,
            robustness_review=0.74,
            fairness_review=0.62,
            traceability=0.82,
            governance_review=0.76,
            communication_clarity=0.80,
        ),
        OptimizationCase(
            case_name="Public resource allocation",
            decision_context="Allocate limited public-service resources across regions and needs.",
            optimization_goal="balance service coverage, cost, capacity, equity, and accountability",
            variable_clarity=0.82,
            objective_documentation=0.78,
            constraint_documentation=0.84,
            data_provenance=0.72,
            feasibility_logic=0.80,
            sensitivity_review=0.76,
            robustness_review=0.78,
            fairness_review=0.86,
            traceability=0.80,
            governance_review=0.84,
            communication_clarity=0.78,
        ),
        OptimizationCase(
            case_name="Portfolio optimization",
            decision_context="Choose asset weights under expected return, risk, liquidity, and exposure constraints.",
            optimization_goal="optimize risk-return trade-offs while testing sensitivity to uncertain estimates",
            variable_clarity=0.80,
            objective_documentation=0.76,
            constraint_documentation=0.78,
            data_provenance=0.68,
            feasibility_logic=0.82,
            sensitivity_review=0.84,
            robustness_review=0.82,
            fairness_review=0.50,
            traceability=0.76,
            governance_review=0.72,
            communication_clarity=0.74,
        ),
        OptimizationCase(
            case_name="Opaque cost minimization",
            decision_context="Minimize operational cost using undocumented constraints and incomplete impact measures.",
            optimization_goal="reduce total reported cost",
            variable_clarity=0.42,
            objective_documentation=0.30,
            constraint_documentation=0.28,
            data_provenance=0.24,
            feasibility_logic=0.36,
            sensitivity_review=0.20,
            robustness_review=0.18,
            fairness_review=0.16,
            traceability=0.24,
            governance_review=0.22,
            communication_clarity=0.34,
        ),
    ]


def run_audit() -> list[dict[str, object]]:
    rows: list[dict[str, object]] = []

    for case in build_cases():
        score = optimization_governance_score(case)
        risk = optimization_governance_risk(case)
        rows.append({
            **asdict(case),
            "optimization_governance_score": round(score, 3),
            "optimization_governance_risk": round(risk, 3),
            "diagnostic": diagnose(score, risk),
        })

    return rows


def write_csv(path: Path, rows: list[dict[str, object]]) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    fieldnames = sorted({key for row in rows for key in row.keys()})

    with path.open("w", newline="", encoding="utf-8") as handle:
        writer = csv.DictWriter(handle, fieldnames=fieldnames, extrasaction="ignore")
        writer.writeheader()
        writer.writerows(rows)


def write_json(path: Path, payload: object) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    path.write_text(json.dumps(payload, indent=2, sort_keys=True), encoding="utf-8")


def summarize(rows: list[dict[str, object]]) -> dict[str, object]:
    return {
        "case_count": len(rows),
        "average_optimization_governance_score": round(mean(float(row["optimization_governance_score"]) for row in rows), 3),
        "average_optimization_governance_risk": round(mean(float(row["optimization_governance_risk"]) for row in rows), 3),
        "highest_score_case": max(rows, key=lambda row: float(row["optimization_governance_score"]))["case_name"],
        "highest_risk_case": max(rows, key=lambda row: float(row["optimization_governance_risk"]))["case_name"],
        "interpretation": "Optimization governance depends on variable clarity, objective documentation, constraint documentation, data provenance, feasibility logic, sensitivity review, robustness review, fairness review, traceability, governance review, and communication clarity."
    }


def main() -> None:
    audit_rows = run_audit()
    summary = summarize(audit_rows)
    lp_example = brute_force_linear_program()
    convex_rows = convex_quadratic_example()

    write_csv(TABLES / "linear_programming_convex_optimization_audit.csv", audit_rows)
    write_csv(TABLES / "linear_programming_convex_optimization_audit_summary.csv", [summary])
    write_csv(TABLES / "linear_programming_example_best_solution.csv", [lp_example["best_solution"]])
    write_csv(TABLES / "convex_quadratic_example.csv", convex_rows)

    write_json(JSON_DIR / "linear_programming_convex_optimization_audit.json", audit_rows)
    write_json(JSON_DIR / "linear_programming_convex_optimization_audit_summary.json", summary)
    write_json(JSON_DIR / "linear_programming_example.json", lp_example)
    write_json(JSON_DIR / "convex_quadratic_example.json", convex_rows)

    print("Linear programming and convex optimization audit complete.")
    print(TABLES / "linear_programming_convex_optimization_audit.csv")


if __name__ == "__main__":
    main()

This workflow treats optimization as a model-governance problem as well as a mathematical search problem.

Back to top ↑

R Workflow: Optimization Summary

The R workflow reads the Python-generated audit table and optimization examples, then creates summary outputs and visualizations using base R.

# linear_programming_convex_optimization_summary.R
# Base R workflow for summarizing linear programming and convex optimization audits.

args <- commandArgs(trailingOnly = FALSE)
file_arg <- grep("^--file=", args, value = TRUE)

if (length(file_arg) > 0) {
  script_path <- normalizePath(sub("^--file=", "", file_arg[1]), mustWork = TRUE)
  article_root <- normalizePath(file.path(dirname(script_path), ".."), mustWork = TRUE)
} else {
  article_root <- getwd()
}

setwd(article_root)

tables_dir <- file.path(article_root, "outputs", "tables")
figures_dir <- file.path(article_root, "outputs", "figures")

if (!dir.exists(tables_dir)) {
  dir.create(tables_dir, recursive = TRUE)
}

if (!dir.exists(figures_dir)) {
  dir.create(figures_dir, recursive = TRUE)
}

audit_path <- file.path(tables_dir, "linear_programming_convex_optimization_audit.csv")

if (!file.exists(audit_path)) {
  stop(paste("Missing", audit_path, "Run the Python workflow first."))
}

data <- read.csv(audit_path, stringsAsFactors = FALSE)

summary_table <- data.frame(
  case_count = nrow(data),
  average_optimization_governance_score = mean(data$optimization_governance_score),
  average_optimization_governance_risk = mean(data$optimization_governance_risk),
  highest_score_case = data$case_name[which.max(data$optimization_governance_score)],
  highest_risk_case = data$case_name[which.max(data$optimization_governance_risk)]
)

write.csv(
  summary_table,
  file.path(tables_dir, "r_linear_programming_convex_optimization_summary.csv"),
  row.names = FALSE
)

comparison_matrix <- rbind(
  data$optimization_governance_score,
  data$optimization_governance_risk
)

colnames(comparison_matrix) <- data$case_name
rownames(comparison_matrix) <- c(
  "Optimization governance score",
  "Optimization governance risk"
)

png(
  file.path(figures_dir, "optimization_governance_score_vs_risk.png"),
  width = 1500,
  height = 850
)

barplot(
  comparison_matrix,
  beside = TRUE,
  las = 2,
  ylim = c(0, 100),
  ylab = "Score",
  main = "Optimization Governance Score vs. Risk"
)

legend(
  "topleft",
  legend = rownames(comparison_matrix),
  pch = 15,
  bty = "n"
)

grid()
dev.off()

convex_path <- file.path(tables_dir, "convex_quadratic_example.csv")

if (file.exists(convex_path)) {
  convex_data <- read.csv(convex_path, stringsAsFactors = FALSE)

  png(
    file.path(figures_dir, "convex_quadratic_example.png"),
    width = 1400,
    height = 850
  )

  plot(
    convex_data$x,
    convex_data$convex_objective_value,
    type = "b",
    xlab = "x",
    ylab = "Objective value",
    main = "Convex Quadratic Objective"
  )

  grid()
  dev.off()
}

print(summary_table)

This workflow helps compare variable clarity, objective documentation, constraint documentation, data provenance, feasibility logic, sensitivity review, robustness, fairness, traceability, governance, and communication readiness.

Back to top ↑

GitHub Repository

The companion repository for this article provides reproducible code, synthetic datasets, workflow documentation, generated outputs, linear programming calculators, convexity examples, optimization audit tables, governance checklists, and Canvas-ready artifacts that extend the article into executable examples.

Back to top ↑

A Practical Method for Building an Optimization Model

A practical method for building a linear programming or convex optimization model begins by defining the real decision. What choices are available? What objective is legitimate? What constraints are binding? What data is trustworthy? What uncertainty matters? What happens if the result shifts burdens or excludes important consequences?

A responsible optimization model makes its definition of “best” explicit and reviewable.

Back to top ↑

Common Pitfalls

A common pitfall is treating optimization as objective because it uses mathematics. Optimization is formal, but the model still depends on human choices about variables, objectives, constraints, coefficients, data, scenarios, and consequences.

Common pitfalls include:

• wrong objective: the model optimizes what is measurable instead of what matters;
• missing constraints: legal, ethical, safety, fairness, or operational limits are absent;
• false linearity: nonlinear relationships are forced into linear form without review;
• unbounded models: missing limits allow unrealistic improvement;
• infeasible models: constraints conflict but the conflict is not explained;
• fragile optima: small input changes produce different decisions;
• hidden externalities: costs are shifted outside the objective;
• unclear coefficients: data sources and transformations are not documented;
• solver authority bias: outputs are trusted because they appear precise;
• weak governance: no one reviews whether the modeled optimum is institutionally appropriate.

The remedy is optimization literacy: explicit variables, documented objectives, constraint inventories, data provenance, feasibility checks, sensitivity analysis, robust scenarios, fairness review, traceability, and governance.

Back to top ↑

Why Structured Optimization Shapes Computational Judgment

Linear programming and convex optimization shape computational judgment because they define what a system is allowed to choose, what it tries to improve, which limits it must respect, and what it means for one feasible solution to be better than another.

These methods can make decision-making more transparent, efficient, and disciplined. They can reveal binding constraints, scarce resources, infeasible requirements, trade-offs, and sensitivity to changing conditions. They can also create false authority when objectives are incomplete, constraints are missing, coefficients are uncertain, or external consequences are ignored.

Responsible optimization asks more than whether a solver returned an optimal value. It asks whether the variables represent real choices, whether the objective reflects legitimate purpose, whether constraints include the right boundaries, whether data is trustworthy, whether the solution is robust, whether distributional effects are reviewed, whether assumptions are documented, and whether the result remains accountable to the people and systems affected by it.

The next article turns to gradient descent and optimization in machine learning, where iterative improvement, loss functions, gradients, learning rates, convergence, and model training connect optimization to modern statistical and AI systems.

Back to top ↑

Related Articles

• Decision Rules, Thresholds, and Classification
• Gradient Descent and Optimization in Machine Learning
• Optimization, Objectives, and Constraints
• Constraint Satisfaction and Feasible Solutions
• Multi-Objective Optimization and Trade-Off Reasoning
• Algorithm Design Principles
• Computational Complexity and Scalability
• Data Quality, Missingness, and Computational Judgment

Further Reading

• Bazaraa, M.S., Jarvis, J.J. and Sherali, H.D. (2010) Linear Programming and Network Flows. 4th edn. Hoboken, NJ: Wiley.
• Bertsimas, D. and Tsitsiklis, J.N. (1997) Introduction to Linear Optimization. Belmont, MA: Athena Scientific.
• Boyd, S. and Vandenberghe, L. (2004) Convex Optimization. Cambridge: Cambridge University Press.
• Dantzig, G.B. (1963) Linear Programming and Extensions. Princeton, NJ: Princeton University Press.
• Luenberger, D.G. and Ye, Y. (2016) Linear and Nonlinear Programming. 4th edn. Cham: Springer.
• Nocedal, J. and Wright, S.J. (2006) Numerical Optimization. 2nd edn. New York: Springer.
• Rockafellar, R.T. (1970) Convex Analysis. Princeton, NJ: Princeton University Press.
• Vanderbei, R.J. (2020) Linear Programming: Foundations and Extensions. 5th edn. Cham: Springer.
• Winston, W.L. and Goldberg, J.B. (2004) Operations Research: Applications and Algorithms. 4th edn. Belmont, CA: Thomson Brooks/Cole.
• Wright, S.J. (1997) Primal-Dual Interior-Point Methods. Philadelphia, PA: SIAM.

References

• Bazaraa, M.S., Jarvis, J.J. and Sherali, H.D. (2010) Linear Programming and Network Flows. 4th edn. Hoboken, NJ: Wiley.
• Bertsimas, D. and Tsitsiklis, J.N. (1997) Introduction to Linear Optimization. Belmont, MA: Athena Scientific.
• Boyd, S. and Vandenberghe, L. (2004) Convex Optimization. Cambridge: Cambridge University Press.
• Dantzig, G.B. (1963) Linear Programming and Extensions. Princeton, NJ: Princeton University Press.
• Karmarkar, N. (1984) ‘A new polynomial-time algorithm for linear programming’, Proceedings of the Sixteenth Annual ACM Symposium on Theory of Computing, pp. 302–311.
• Luenberger, D.G. and Ye, Y. (2016) Linear and Nonlinear Programming. 4th edn. Cham: Springer.
• Nocedal, J. and Wright, S.J. (2006) Numerical Optimization. 2nd edn. New York: Springer.
• Rockafellar, R.T. (1970) Convex Analysis. Princeton, NJ: Princeton University Press.
• Vanderbei, R.J. (2020) Linear Programming: Foundations and Extensions. 5th edn. Cham: Springer.
• Winston, W.L. and Goldberg, J.B. (2004) Operations Research: Applications and Algorithms. 4th edn. Belmont, CA: Thomson Brooks/Cole.
• Wright, S.J. (1997) Primal-Dual Interior-Point Methods. Philadelphia, PA: SIAM.

Back to top ↑