Optimization Models and Objective Functions: How Mathematical Models Support Better Decisions

Last Updated June 12, 2026

Optimization models and objective functions help mathematical models identify preferred choices under constraints. Instead of only describing how a system behaves, an optimization model asks what should be selected, allocated, scheduled, designed, minimized, maximized, or balanced.

An optimization model is not simply a calculation of the “best” answer. It is a formal representation of a decision problem. It defines decision variables, objective functions, constraints, feasible choices, parameters, tradeoffs, and assumptions. The result is only meaningful if those components represent the problem responsibly.

Objective functions are central because they translate goals into mathematical form. A model may minimize cost, maximize profit, reduce risk, improve reliability, balance equity, allocate resources, shorten travel time, minimize emissions, or optimize a weighted combination of competing priorities. What the objective function rewards or penalizes becomes part of the model’s values.

Optimization is powerful because it makes tradeoffs explicit. It can show what is feasible, what is efficient, what is costly, what must be sacrificed, and which assumptions drive a recommended choice. It can also mislead when the objective function is too narrow, constraints are incomplete, data are weak, or the model presents mathematical optimality as if it were social, ethical, or institutional legitimacy.

Why Optimization Models Matter

Optimization models matter because many modeling problems are not only descriptive. They are decision problems. A planner may need to allocate limited resources. An engineer may need to design a system under safety constraints. A logistics team may need to route vehicles. A policy analyst may need to compare interventions. A data scientist may need to fit a model by minimizing error. A sustainability team may need to reduce emissions without violating cost, reliability, or equity requirements.

Optimization helps formalize these problems. It asks what choices are available, what goal should be pursued, what constraints cannot be violated, and how competing priorities should be evaluated.

Optimization models are especially useful when choices are numerous, tradeoffs are difficult to compare informally, or constraints interact in ways that make intuition unreliable.

Back to top ↑

What an Optimization Model Is

An optimization model is a mathematical representation of a choice problem. It defines what can be chosen, what goal is being pursued, and what restrictions must be respected.

The word “optimize” may mean minimize or maximize. The feasible set contains the choices that satisfy the model’s constraints.

Optimization models should be interpreted conditionally. They do not identify the best choice in an absolute sense. They identify the best choice according to a stated model structure.

Back to top ↑

What an Objective Function Is

An objective function converts a goal into a mathematical expression. It defines what the model is trying to minimize, maximize, or balance.

The objective function is not neutral. It encodes what counts as success. If the model minimizes cost, it may neglect reliability or equity unless those are included through additional objective terms or constraints. If it maximizes output, it may ignore environmental stress unless environmental limits are included. If it minimizes average error, it may perform poorly for vulnerable subgroups unless subgroup performance is represented.

Objective functions should be documented in plain language. A reader should understand what the model is optimizing and what it is not optimizing.

Back to top ↑

Decision Variables, Parameters, and Constraints

Decision variables represent quantities the model is allowed to choose. Parameters shape the problem but are treated as fixed or externally supplied within a given run. Constraints define what choices are allowable.

A constraint may be an equality, inequality, logical rule, integer requirement, capacity limit, budget restriction, physical law, policy requirement, or operational boundary.

Optimization begins with a disciplined distinction between what the model chooses, what it assumes, what it must satisfy, and what it reports.

Back to top ↑

Feasible Regions and Constraint Sets

The feasible region is the set of all choices that satisfy the constraints. It determines what the model is allowed to consider.

A model can fail because the objective is wrong, but it can also fail because the feasible region is wrong. Missing constraints can make irresponsible solutions appear optimal. Overly restrictive constraints can hide better solutions. Poorly defined domains can produce results that cannot be implemented.

Feasibility is not merely mathematical. It is operational, institutional, legal, ethical, and physical. A feasible solution should be feasible in the world the model is intended to support.

Back to top ↑

Linear Optimization Models

Linear optimization models use linear objective functions and linear constraints. They are widely used because they are interpretable, computationally efficient, and applicable to many allocation and planning problems.

Linear models can represent transportation, production planning, diet problems, scheduling approximations, resource allocation, and many operational decisions. Their simplicity is a strength when the underlying assumptions are reasonable.

The danger is linearity by convenience. If returns diminish, thresholds matter, interactions dominate, or discrete choices are essential, a linear model may be a useful approximation but not a faithful representation.

Back to top ↑

Nonlinear and Convex Optimization

Nonlinear optimization models include objectives or constraints that are not linear. They can represent diminishing returns, nonlinear costs, physical laws, risk functions, learning curves, saturation, penalties, and complex system relationships.

Convex optimization is a special and important class. In a convex minimization problem, local optima are global optima under appropriate conditions. This gives convex optimization strong theoretical and computational advantages.

Nonlinear optimization can model reality more closely, but it can also be harder to solve and validate. Solver settings, starting points, scaling, and local minima may matter.

Back to top ↑

Integer and Combinatorial Optimization

Many decisions are discrete. A facility is open or closed. A project is selected or not. A worker is assigned to a shift. A vehicle visits a location. These problems require integer, binary, or combinatorial optimization.

Integer constraints can make optimization problems much harder. But they may be necessary for realistic implementation. A solution that opens 2.7 facilities or assigns 0.4 workers may be mathematically convenient but operationally invalid.

Discrete decision structure should be represented when implementation requires it. Relaxing integer constraints can be useful for analysis, but it should not be confused with an implementable decision.

Back to top ↑

Multiobjective Optimization and Tradeoffs

Many real decisions have more than one objective. A city may want to minimize cost, maximize service coverage, reduce emissions, and improve equity. A model that optimizes only one of these may produce a technically optimal but institutionally unacceptable solution.

One common approach is a weighted sum:

But weights are not merely technical. They express priorities. A small change in weights may change the recommended solution.

Multiobjective optimization is often more honest than pretending that a single objective represents the whole decision. It can show the structure of tradeoffs rather than hiding them inside one number.

Back to top ↑

Stochastic and Robust Optimization

Optimization under uncertainty requires special care. If demand, cost, supply, risk, or future conditions are uncertain, the optimal solution under average assumptions may fail under stress.

Stochastic optimization represents uncertainty explicitly, often through scenarios or probability distributions. Robust optimization seeks solutions that perform acceptably across a range of uncertain conditions.

Uncertainty-aware optimization is often more responsible than optimizing against a single forecast. It also requires careful communication because robust solutions may sacrifice average performance to reduce vulnerability.

Back to top ↑

Algorithms, Solvers, and Numerical Interpretation

Optimization models are usually solved with algorithms. The solver matters because algorithmic success depends on problem structure, numerical scaling, tolerances, convexity, integrality, starting points, and stopping criteria.

A solver result should not be treated as automatically meaningful. Modelers should review solver status, feasibility, sensitivity, numerical stability, and implementation realism before presenting a solution as a recommendation.

Back to top ↑

Mathematical Lens: Optimization as Constrained Choice

Optimization can be understood as constrained choice over a feasible set. The model searches for a decision vector \(x^\ast\) that performs at least as well as every other feasible choice under the objective.

For constrained problems, optimality often involves tradeoffs between objective improvement and constraint pressure. In differentiable constrained optimization, Lagrange multipliers express how constraints influence the optimum.

For inequality constraints, the Karush-Kuhn-Tucker framework is often used under appropriate regularity conditions:

This lens shows that optimization is not just “finding a maximum or minimum.” It is the formal study of goals, feasible choices, constraints, tradeoffs, and marginal consequences.

Back to top ↑

Example: Resource Allocation Optimization Model

Consider a resource allocation problem. A decision-maker has a limited budget and wants to allocate resources across programs. Each program has a cost, expected benefit, minimum service requirement, and maximum capacity.

Let \(x_i\) represent the amount allocated to program \(i\). A simple benefit-maximization model is:

Subject to budget and capacity constraints:

If each program must receive a minimum allocation, the model adds:

This model may be mathematically clear, but it still requires review. Are benefits measured fairly? Are costs complete? Are minimum levels ethically justified? Does maximizing total benefit hide unequal distribution? Should uncertainty in \(b_i\) be represented? Should equity be an objective, constraint, or separate review criterion?

Back to top ↑

Calibration, Validation, Sensitivity, and Uncertainty

Optimization models require validation because the optimal solution may be highly sensitive to assumptions. Small changes in costs, benefits, constraints, weights, forecasts, or solver settings can change recommendations.

A solution should be reported with its assumptions, sensitivity, feasible alternatives, and limitations. In many applied contexts, a portfolio of good feasible choices is more useful than a single point solution presented without context.

Back to top ↑

Ethical Stakes of Optimization Modeling

Optimization models can shape decisions about resources, access, safety, labor, environment, finance, infrastructure, and public services. Their ethical stakes arise because the model’s objective and constraints determine what counts as success.

Optimization does not remove judgment. It formalizes judgment. Responsible use requires asking whether the objective function, constraints, data, weights, and implementation pathway reflect the decision’s full stakes.

Back to top ↑

Python Workflow: Optimization Register and Feasible-Choice Audit

The Python workflow below uses a dependency-light enumeration approach for a small resource allocation model. It records feasible choices, objective scores, constraint results, and an optimization audit card.

# optimization_models_objective_functions_workflow.py
# Dependency-light workflow for optimization registers and feasible-choice audits.

from __future__ import annotations

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


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


@dataclass(frozen=True)
class Program:
    name: str
    benefit_per_unit: float
    cost_per_unit: float
    lower_bound: int
    upper_bound: int


@dataclass(frozen=True)
class OptimizationScenario:
    name: str
    budget: float
    equity_floor: int
    description: str


@dataclass(frozen=True)
class OptimizationRecord:
    key: str
    component_type: str
    expression: str
    interpretation: str
    review_question: str
    status: str


def optimization_register() -> list[OptimizationRecord]:
    return [
        OptimizationRecord(
            key="decision_variables",
            component_type="decision_variable",
            expression="x_i",
            interpretation="Allocation to program i.",
            review_question="Are these quantities actually controllable?",
            status="active",
        ),
        OptimizationRecord(
            key="objective_function",
            component_type="objective_function",
            expression="maximize sum_i benefit_i * x_i",
            interpretation="The model maximizes estimated total benefit.",
            review_question="Does total benefit hide distributional concerns?",
            status="review",
        ),
        OptimizationRecord(
            key="budget_constraint",
            component_type="constraint",
            expression="sum_i cost_i * x_i <= B",
            interpretation="Total cost cannot exceed budget.",
            review_question="Are all costs included?",
            status="review",
        ),
        OptimizationRecord(
            key="equity_floor",
            component_type="constraint",
            expression="x_i >= equity_floor",
            interpretation="Each program receives at least a minimum allocation.",
            review_question="Is the floor ethically and operationally justified?",
            status="review",
        ),
    ]


def programs() -> list[Program]:
    return [
        Program("housing", 11.0, 7.0, 0, 8),
        Program("health", 13.0, 8.0, 0, 8),
        Program("transport", 8.0, 5.0, 0, 8),
        Program("resilience", 10.0, 6.0, 0, 8),
    ]


def scenarios() -> list[OptimizationScenario]:
    return [
        OptimizationScenario("baseline", 75.0, 1, "Baseline budget with low equity floor."),
        OptimizationScenario("tight_budget", 55.0, 1, "Reduced budget scenario."),
        OptimizationScenario("higher_floor", 75.0, 3, "Higher minimum allocation scenario."),
    ]


def evaluate_choice(
    allocation: tuple[int, ...],
    program_list: list[Program],
    scenario: OptimizationScenario,
) -> dict[str, object]:
    total_cost = sum(x * p.cost_per_unit for x, p in zip(allocation, program_list))
    total_benefit = sum(x * p.benefit_per_unit for x, p in zip(allocation, program_list))
    equity_ok = all(x >= scenario.equity_floor for x in allocation)
    bounds_ok = all(p.lower_bound <= x <= p.upper_bound for x, p in zip(allocation, program_list))
    budget_ok = total_cost <= scenario.budget
    feasible = equity_ok and bounds_ok and budget_ok

    row = {
        "scenario": scenario.name,
        "total_cost": round(total_cost, 4),
        "total_benefit": round(total_benefit, 4),
        "budget": scenario.budget,
        "equity_floor": scenario.equity_floor,
        "budget_ok": budget_ok,
        "bounds_ok": bounds_ok,
        "equity_ok": equity_ok,
        "feasible": feasible,
    }

    for x, program in zip(allocation, program_list):
        row[f"allocation_{program.name}"] = x

    return row


def enumerate_choices(program_list: list[Program], scenario: OptimizationScenario) -> list[dict[str, object]]:
    ranges = [range(program.lower_bound, program.upper_bound + 1) for program in program_list]
    return [evaluate_choice(choice, program_list, scenario) for choice in product(*ranges)]


def best_feasible(rows: list[dict[str, object]]) -> dict[str, object]:
    feasible_rows = [row for row in rows if bool(row["feasible"])]
    if not feasible_rows:
        return {"status": "infeasible"}
    return max(feasible_rows, key=lambda row: float(row["total_benefit"]))


def optimization_risk_score(record: OptimizationRecord) -> float:
    score = {"active": 1.0, "review": 5.0, "revise": 8.0, "archive": 2.0}.get(
        record.status.lower(),
        4.0,
    )
    text = f"{record.component_type} {record.expression} {record.review_question}".lower()
    for term in ["objective", "constraint", "equity", "cost", "distributional", "controllable"]:
        if term in text:
            score += 1.0
    return round(score, 3)


def write_csv(path: Path, rows: list[dict[str, object]]) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    if not rows:
        raise ValueError(f"No rows supplied for {path}")
    with path.open("w", newline="", encoding="utf-8") as handle:
        writer = csv.DictWriter(handle, fieldnames=list(rows[0].keys()))
        writer.writeheader()
        writer.writerows(rows)


def write_json(path: Path, payload: object) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    with path.open("w", encoding="utf-8") as handle:
        json.dump(payload, handle, indent=2, sort_keys=True)


def main() -> None:
    program_list = programs()
    all_rows: list[dict[str, object]] = []
    summary_rows: list[dict[str, object]] = []

    for scenario in scenarios():
        rows = enumerate_choices(program_list, scenario)
        all_rows.extend(rows)
        best = best_feasible(rows)
        summary = {
            "scenario": scenario.name,
            "description": scenario.description,
            "candidate_choices": len(rows),
            "feasible_choices": sum(1 for row in rows if bool(row["feasible"])),
            **best,
        }
        summary_rows.append(summary)

    register_rows = [
        {**asdict(record), "optimization_risk_score": optimization_risk_score(record)}
        for record in optimization_register()
    ]

    write_csv(TABLES / "optimization_feasible_choice_audit.csv", all_rows)
    write_csv(TABLES / "optimization_solution_summary.csv", summary_rows)
    write_csv(TABLES / "optimization_model_register.csv", register_rows)

    write_json(JSON_DIR / "optimization_model_audit_card.json", {
        "article": "Optimization Models and Objective Functions",
        "optimization_register": register_rows,
        "solution_summaries": summary_rows,
        "audit_checks": [
            "decision variables are controllable",
            "objective function is documented",
            "constraints are explicit",
            "feasible alternatives are preserved",
            "optimal solution is framed as conditional decision support",
        ],
    })

    print("Optimization models and objective functions workflow complete.")
    print(f"Wrote outputs to {OUTPUTS}")


if __name__ == "__main__":
    main()

This workflow deliberately preserves feasible alternatives rather than only reporting the best solution. That makes sensitivity, tradeoffs, and near-optimal choices easier to review.

Back to top ↑

R Workflow: Objective Review and Scenario Diagnostics

The R workflow below reviews optimization outputs, classifies solution stability, and summarizes feasible alternatives by scenario.

# optimization_models_objective_functions_review.R
# Base R workflow for objective review and scenario diagnostics.

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()
}

tables_dir <- file.path(article_root, "outputs", "tables")
figures_dir <- file.path(article_root, "outputs", "figures")
dir.create(tables_dir, recursive = TRUE, showWarnings = FALSE)
dir.create(figures_dir, recursive = TRUE, showWarnings = FALSE)

choice_path <- file.path(tables_dir, "optimization_feasible_choice_audit.csv")
summary_path <- file.path(tables_dir, "optimization_solution_summary.csv")
register_path <- file.path(tables_dir, "optimization_model_register.csv")

if (!file.exists(choice_path) || !file.exists(summary_path)) {
  stop("Missing optimization outputs. Run the Python workflow first.")
}

choices <- read.csv(choice_path, stringsAsFactors = FALSE)
summary_data <- read.csv(summary_path, stringsAsFactors = FALSE)

summary_data$feasibility_review <- ifelse(
  summary_data$feasible_choices == 0,
  "infeasible scenario",
  ifelse(
    summary_data$feasible_choices < 10,
    "narrow feasible region",
    "feasible alternatives available"
  )
)

write.csv(
  summary_data,
  file.path(tables_dir, "r_optimization_solution_review_summary.csv"),
  row.names = FALSE
)

if (file.exists(register_path)) {
  register <- read.csv(register_path, stringsAsFactors = FALSE)

  register$priority <- ifelse(
    register$optimization_risk_score >= 8,
    "high",
    ifelse(register$optimization_risk_score >= 6, "medium", "low")
  )

  write.csv(
    register,
    file.path(tables_dir, "r_optimization_model_review_queue.csv"),
    row.names = FALSE
  )
}

png(file.path(figures_dir, "r_optimization_feasible_benefit_by_cost.png"), width = 1100, height = 720)

feasible <- choices[choices$feasible == TRUE, ]

plot(
  feasible$total_cost,
  feasible$total_benefit,
  xlab = "Total Cost",
  ylab = "Total Benefit",
  main = "Feasible Optimization Choices: Benefit by Cost"
)

grid()
dev.off()

print(summary_data)

The R layer focuses on review rather than automatic authority. It helps show whether the recommended solution sits inside a broad feasible region or depends on narrow feasibility.

Back to top ↑

Haskell Workflow: Typed Optimization Records

Haskell is useful for this article because optimization model components should not collapse into one informal category. Decision variables, objectives, constraints, parameters, solver settings, and validation diagnostics have different meanings.

{-# OPTIONS_GHC -Wall #-}

module Main where

data OptimizationComponent
  = DecisionVariable
  | ObjectiveFunction
  | Constraint
  | Parameter
  | FeasibleRegion
  | SolverSetting
  | ValidationDiagnostic
  deriving (Eq, Show)

data ReviewStatus
  = Active
  | RequiresReview
  | RequiresValidation
  | RequiresSensitivityTest
  | Revise
  deriving (Eq, Show)

data OptimizationRecord = OptimizationRecord
  { key :: String
  , component :: OptimizationComponent
  , expression :: String
  , interpretation :: String
  , reviewFocus :: String
  , status :: ReviewStatus
  } deriving (Eq, Show)

optimizationRegister :: [OptimizationRecord]
optimizationRegister =
  [ OptimizationRecord
      "decision_variables"
      DecisionVariable
      "x_i"
      "Allocation to program i."
      "Controllability."
      Active
  , OptimizationRecord
      "objective_function"
      ObjectiveFunction
      "maximize sum_i benefit_i * x_i"
      "Maximize estimated total benefit."
      "Goal validity and distributional effects."
      RequiresReview
  , OptimizationRecord
      "budget_constraint"
      Constraint
      "sum_i cost_i * x_i <= B" "Total cost cannot exceed budget." "Cost completeness." RequiresReview , OptimizationRecord "equity_floor" Constraint "x_i >= floor"
      "Each program receives a minimum allocation."
      "Equity and feasibility."
      RequiresSensitivityTest
  ]

needsReview :: OptimizationRecord -> Bool
needsReview item =
  case status item of
    Active -> False
    _ -> True

main :: IO ()
main = do
  putStrLn "Typed optimization model records:"
  mapM_ print optimizationRegister

  putStrLn "\nOptimization records requiring review:"
  mapM_ print (filter needsReview optimizationRegister)

This typed layer supports model governance by making objective functions, constraints, and decision variables explicit before optimization results are treated as recommendations.

Back to top ↑

GitHub Repository

The companion repository for this article is designed as a reproducible mathematical-modeling workspace. It contains article-specific code, data, documentation, notebooks, schemas, and generated outputs for optimization model registers, feasible-choice enumeration, objective-function review, constraint audits, typed Haskell optimization records, validation planning, and reproducible engineering/statistical workflows.

Back to top ↑

A Practical Method for Optimization Model Design

Optimization model design should begin with the decision, not the solver. Before a model can identify an optimal solution, it must define the decision context, controllable variables, objective, constraints, values, uncertainty, and use limits.

This method helps prevent optimization from becoming a black box. It connects mathematical optimality to model purpose, decision context, values, constraints, feasibility, uncertainty, and accountability.

Back to top ↑

Common Pitfalls

Optimization models can fail even when the solver succeeds. Many failures arise because the wrong objective is optimized, constraints are incomplete, uncertainty is ignored, or model output is treated as authority.

• Objective-function tunnel vision: optimizing what is easy to measure rather than what matters.
• Hidden value judgments: presenting weights, penalties, or priorities as purely technical.
• Missing constraints: leaving out operational, ethical, legal, or physical limits.
• Infeasible recommendations: producing solutions that cannot be implemented in practice.
• Ignoring uncertainty: optimizing against a single forecast when inputs are unstable.
• Mean-only optimization: choosing high average performance while ignoring tail risk.
• Overtrusting solver output: failing to check status, tolerance, optimality gap, or feasibility.
• Relaxed variables misread as real choices: treating fractional or continuous relaxations as implementable decisions.
• Equity afterthought: reviewing fairness only after the optimized allocation has already been produced.
• No sensitivity analysis: reporting one solution without showing how fragile it is.

These pitfalls can be reduced through objective review, constraint audits, scenario testing, sensitivity analysis, solver diagnostics, stakeholder review, and careful communication of what the optimum actually means.

Back to top ↑

Conclusion: Optimization Requires Judgment

Optimization models and objective functions help mathematical models move from description to decision support. They define choices, goals, constraints, feasible regions, tradeoffs, and preferred solutions.

Their strength is formal clarity. Optimization can show which choices are feasible, which constraints matter, which tradeoffs are unavoidable, and which assumptions drive a recommendation. It can also help compare alternatives when intuition is overwhelmed by interacting constraints.

But optimization does not remove judgment. It concentrates judgment inside objective functions, constraints, weights, parameters, scenarios, and solver choices. An optimal solution is only optimal relative to what the model has chosen to value and represent.

Responsible optimization requires transparency. Modelers should explain what is optimized, what is constrained, what is omitted, how uncertainty affects conclusions, and how sensitive the solution is. Optimization should support decisions, not replace accountability for them.

Back to top ↑

Related Articles

• What Is Mathematical Modeling?
• Variables, Parameters, and Constraints
• Equations, Inequalities, and Model Logic
• Algebraic Models and Static Relationships
• Discrete Models and Recurrence Relations
• Probabilistic and Stochastic Models
• Simulation and Computational Modeling
• Sensitivity Analysis and Robustness
• Model Interpretation and Decision-Making
• Decision Science and Systems Modeling

Back to top ↑

Further Reading

• Boyd, S. and Vandenberghe, L. (2004) Convex Optimization. Cambridge: Cambridge University Press. Available at: https://web.stanford.edu/~boyd/cvxbook/
• Bertsimas, D. and Tsitsiklis, J.N. (1997) Introduction to Linear Optimization. Belmont, MA: Athena Scientific.
• Hillier, F.S. and Lieberman, G.J. (2021) Introduction to Operations Research. 11th edn. New York: McGraw Hill.
• Winston, W.L. and Goldberg, J.B. (2004) Operations Research: Applications and Algorithms. 4th edn. Belmont, CA: Thomson Brooks/Cole.
• Nocedal, J. and Wright, S.J. (2006) Numerical Optimization. 2nd edn. New York: Springer.
• Nemhauser, G.L. and Wolsey, L.A. (1988) Integer and Combinatorial Optimization. New York: Wiley.
• Ben-Tal, A., El Ghaoui, L. and Nemirovski, A. (2009) Robust Optimization. Princeton: Princeton University Press.
• Birge, J.R. and Louveaux, F. (2011) Introduction to Stochastic Programming. 2nd edn. New York: Springer.
• Saltelli, A., Ratto, M., Andres, T., Campolongo, F., Cariboni, J., Gatelli, D., Saisana, M. and Tarantola, S. (2008) Global Sensitivity Analysis: The Primer. Chichester: Wiley.
• Oberkampf, W.L. and Roy, C.J. (2010) Verification and Validation in Scientific Computing. Cambridge: Cambridge University Press. Available at: https://www.cambridge.org/core/books/verification-and-validation-in-scientific-computing/05CA1F8F3CCB5AE5445FDF55239A0183

Back to top ↑

References

• Ben-Tal, A., El Ghaoui, L. and Nemirovski, A. (2009) Robust Optimization. Princeton: Princeton University Press.
• Bertsimas, D. and Tsitsiklis, J.N. (1997) Introduction to Linear Optimization. Belmont, MA: Athena Scientific.
• Birge, J.R. and Louveaux, F. (2011) Introduction to Stochastic Programming. 2nd edn. New York: Springer.
• Boyd, S. and Vandenberghe, L. (2004) Convex Optimization. Cambridge: Cambridge University Press. Available at: https://web.stanford.edu/~boyd/cvxbook/
• Garfunkel, S. and Montgomery, M. (eds.) (2019) GAIMME: Guidelines for Assessment and Instruction in Mathematical Modeling Education. 2nd edn. Philadelphia: Society for Industrial and Applied Mathematics. Available at: https://epubs.siam.org/doi/book/10.1137/1.9781611975741
• Hillier, F.S. and Lieberman, G.J. (2021) Introduction to Operations Research. 11th edn. New York: McGraw Hill.
• Nemhauser, G.L. and Wolsey, L.A. (1988) Integer and Combinatorial Optimization. New York: Wiley.
• Nocedal, J. and Wright, S.J. (2006) Numerical Optimization. 2nd edn. New York: Springer.
• Oberkampf, W.L. and Roy, C.J. (2010) Verification and Validation in Scientific Computing. Cambridge: Cambridge University Press. Available at: https://www.cambridge.org/core/books/verification-and-validation-in-scientific-computing/05CA1F8F3CCB5AE5445FDF55239A0183
• Saltelli, A., Ratto, M., Andres, T., Campolongo, F., Cariboni, J., Gatelli, D., Saisana, M. and Tarantola, S. (2008) Global Sensitivity Analysis: The Primer. Chichester: Wiley.
• Winston, W.L. and Goldberg, J.B. (2004) Operations Research: Applications and Algorithms. 4th edn. Belmont, CA: Thomson Brooks/Cole.

Back to top ↑