Network Flow Modeling: How Linear Algebra Models Movement, Capacity, and Bottlenecks

Last Updated July 2, 2026

Network flow modeling explains how quantities move through connected systems under constraints. A network may describe roads, pipes, power lines, supply chains, communication links, ecological corridors, financial exposures, logistics routes, or service systems. Flow models ask how much can move, where it moves, what limits it, what it costs, and where bottlenecks appear.

This article continues Part V of the Linear Algebra for Systems Modeling series by connecting directed graphs, sources, sinks, capacities, edge flows, node balance, incidence matrices, conservation laws, maximum flow, minimum cut, residual networks, augmenting paths, costed flow, shortest paths, linear programming, sparse computation, sensitivity analysis, and responsible interpretation.

The central modeling question is not only “What is connected?” It is “What can move through the network, what constraints govern movement, what assumptions define conservation, and how do local edge limits shape system-wide capacity, vulnerability, and behavior?”

Network flow modeling begins with a graph. Nodes represent locations, assets, firms, stations, reservoirs, routers, sectors, or decision points. Edges represent channels through which something can move. Each edge may have a capacity, cost, direction, reliability, travel time, loss rate, or exposure. Flow models combine graph theory with linear algebra and optimization to study feasible movement through the system.

The power of network flow modeling is that it connects local constraints to global behavior. A single low-capacity edge may limit the entire system. A cut may separate supply from demand. A source may have surplus, a sink may have demand, and intermediate nodes may obey conservation. Linear algebra helps express these balance relationships; optimization helps find feasible, maximum, minimum-cost, or robust flows.

Why Network Flow Modeling Matters

Network flow modeling matters because many systems are constrained by movement. Water must move through pipes. Electricity must move through transmission lines. Vehicles must move through roads. Goods must move through supply chains. Data must move through communication networks. Patients, resources, services, risks, and information all move through structured pathways.

A flow model does not merely describe a network. It asks whether the network can support a required movement under constraints. It can identify bottlenecks, estimate capacity, test disruption scenarios, compare routing strategies, locate critical cuts, and support investment or policy decisions.

Network flow modeling is therefore a structural approach to capacity, movement, and constraint.

Back to top ↑

Flow Networks

A flow network is a directed graph with capacities on edges. It usually includes at least one source node and one sink node. Flow moves along directed edges subject to capacity limits and balance conditions.

In systems modeling, the capacity function may represent maximum traffic, shipment volume, electrical transfer, water flow, bandwidth, service capacity, staffing throughput, or institutional processing ability.

The graph abstraction becomes a flow model only when capacities, sources, sinks, and balance assumptions are defined.

Back to top ↑

Sources, Sinks, and Transshipment Nodes

Flow models distinguish between sources, sinks, and intermediate nodes. A source supplies flow. A sink demands or receives flow. A transshipment node passes flow through while satisfying balance constraints.

The classic maximum-flow problem usually treats intermediate nodes as conservative. More realistic systems may include storage, loss, delay, transformation, or nonlinear behavior.

Back to top ↑

Edge Flows, Capacities, and Costs

Each edge \(e\) has a flow \(f_e\) and often a capacity \(c_e\). Feasible edge flow must satisfy:

Some models also assign a cost \(a_e\) to each unit of flow on edge \(e\). Cost may represent distance, time, money, energy, risk, emissions, loss, congestion, or degradation.

Capacities and costs should be treated as assumptions requiring provenance, units, and sensitivity analysis.

Back to top ↑

Flow Conservation

Flow conservation states that, at an ordinary intermediate node, total inflow equals total outflow. For node \(v\):

Here \(\delta^-(v)\) denotes incoming edges and \(\delta^+(v)\) denotes outgoing edges. Sources and sinks are exceptions because they supply or demand flow.

Conservation is a modeling assumption. It should not be applied automatically to systems with storage, loss, transformation, queues, or time delay.

Back to top ↑

Incidence Matrices and Balance Equations

Incidence matrices express flow balance compactly. Let \(B\) be an oriented node-edge incidence matrix and \(\mathbf{f}\) be a vector of edge flows. Then:

Depending on the sign convention, \(\mathbf{b}\) may represent net inflow or net outflow. The convention must be documented.

This matrix view connects graph theory, linear algebra, and optimization. It is especially useful for reproducible computational workflows.

Back to top ↑

Maximum Flow

The maximum-flow problem asks how much flow can be sent from a source \(s\) to a sink \(t\) without exceeding edge capacities and while respecting flow conservation at intermediate nodes.

The value of the flow is the net amount leaving the source or entering the sink. The maximum feasible value is constrained by capacities and network topology.

Maximum flow is useful when the primary question is throughput: how much the system can carry from origin to destination.

Back to top ↑

Minimum Cuts and Bottlenecks

A cut separates the source from the sink by partitioning nodes into two sets. The capacity of a cut is the total capacity of edges crossing from the source side to the sink side.

The max-flow min-cut theorem states that the maximum value of an \(s\)-to-\(t\) flow equals the capacity of a minimum \(s\)-\(t\) cut.

The minimum cut is often as important as the maximum flow because it explains where the system is constrained.

Back to top ↑

Residual Networks and Augmenting Paths

Many maximum-flow algorithms use residual networks. A residual network describes how much additional flow can still be pushed along edges, including the possibility of undoing previous flow through reverse edges.

An augmenting path is a source-to-sink path in the residual network with positive residual capacity. Sending additional flow along that path increases total flow.

Residual networks reveal that network flow algorithms are not simply greedy path selection; they maintain a structured space of reversible choices.

Back to top ↑

Minimum-Cost Flow

Maximum flow asks how much can move. Minimum-cost flow asks how to move required flow at minimum cost while satisfying capacity and balance constraints.

Minimum-cost flow is useful when multiple feasible routings exist and the modeler must choose among them based on cost, distance, time, loss, emissions, congestion, or risk.

Minimum-cost flow models require careful cost semantics. A cost coefficient should not be mixed across incompatible meanings without normalization or justification.

Back to top ↑

Shortest Paths as Flow Problems

A shortest-path problem can be expressed as a special flow problem: send one unit of flow from a source to a sink at minimum cost. The selected route minimizes total edge cost.

This formulation links graph algorithms to linear programming. It also clarifies that “shortest” depends on what edge cost means.

Shortest-path modeling is not only a graph problem; it is a cost-definition problem.

Back to top ↑

Multi-Commodity Flow

Many systems carry multiple kinds of flow at once. Roads carry different vehicle classes. Networks carry different data streams. Supply chains carry many products. Power grids carry constrained electrical flows. Hospitals move patients, staff, beds, and equipment. Multi-commodity flow models represent multiple flow types sharing network capacity.

Multi-commodity models are more realistic but more complex. Shared constraints can create tradeoffs that single-commodity models cannot see.

Back to top ↑

Linear Programming Formulation

Network flow problems can be expressed as linear programs. A generic minimum-cost flow formulation is:

This formulation connects network flow to optimization, matrix computation, duality, sensitivity analysis, and reproducible scientific workflows.

Linear programming makes network flow assumptions explicit, auditable, and computable.

Back to top ↑

Sparse Computation and Scaling

Real flow networks are often large and sparse. Most nodes connect to only a small fraction of all possible nodes. Incidence matrices, adjacency matrices, and constraint matrices should therefore be stored and computed using sparse formats when networks become large.

Sparse representation is not only about speed. It helps preserve the edge-based structure of the model.

Back to top ↑

Sensitivity, Uncertainty, and Robustness

Network flow conclusions can change when capacities, costs, demand, supply, or graph structure changes. A serious flow model should test sensitivity to uncertain capacities, edge failures, demand shifts, cost changes, and alternative graph boundaries.

Robust flow modeling asks not only for the optimal solution, but for how fragile that solution is.

Back to top ↑

Network Flow in Systems Modeling

Network flow models appear wherever movement, capacity, routing, and balance matter. They can support operational planning, infrastructure investment, resilience analysis, emergency logistics, energy systems, water systems, transportation design, supply-chain risk, communication routing, health-system capacity, and environmental planning.

Network flow modeling is most useful when its constraints reflect the actual system, not merely the easiest graph abstraction.

Back to top ↑

Mathematical Deepening

This section adds a more formal layer. Network flow modeling connects graph theory, incidence matrices, conservation equations, capacity constraints, linear programming, duality, max-flow min-cut theory, residual networks, shortest paths, minimum-cost flow, sparse computation, and systems governance.

Back to top ↑

Back to top ↑

Computation and Reproducible Workflows

Computational workflows for network flow modeling should document node lists, edge lists, source and sink nodes, capacities, costs, edge-flow variables, incidence matrices, conservation conventions, supply-demand vectors, feasibility checks, saturated edges, cut structures, solver settings, sensitivity tests, data provenance, and interpretation warnings.

The companion repository treats network flow as an auditable optimization layer. Python, R, Julia, SQL, Haskell, C, C++, Fortran, Rust, Go, notebooks, schemas, generated outputs, Canvas artifacts, advanced reports, and calculators each support a different layer of reproducible flow analysis.

For this article, the computational examples focus on constructing a directed capacitated network, computing feasible flow summaries, auditing node balances, identifying saturated edges, estimating a simple source-sink bottleneck, and preserving governance records for capacity and conservation assumptions.

Back to top ↑

Python Workflow: Network Flow Audit

The Python workflow below builds a small directed capacitated network, evaluates a candidate flow, checks capacity constraints, computes node balances, identifies saturated edges, and writes auditable outputs.

from __future__ import annotations

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


@dataclass(frozen=True)
class EdgeFlowRecord:
    source: str
    target: str
    capacity: float
    cost: float
    flow: float


@dataclass(frozen=True)
class NetworkFlowAudit:
    graph_name: str
    node_count: int
    edge_count: int
    source_node: str
    sink_node: str
    total_source_outflow: float
    total_sink_inflow: float
    capacity_violations: int
    saturated_edge_count: int
    max_absolute_transshipment_imbalance: float
    total_flow_cost: float
    interpretation_warning: str


def build_network() -> tuple[list[str], list[EdgeFlowRecord]]:
    nodes = ["source", "north_hub", "south_hub", "transfer", "sink"]
    edges = [
        EdgeFlowRecord("source", "north_hub", 12.0, 2.0, 10.0),
        EdgeFlowRecord("source", "south_hub", 8.0, 3.0, 6.0),
        EdgeFlowRecord("north_hub", "transfer", 7.0, 1.0, 6.0),
        EdgeFlowRecord("north_hub", "sink", 5.0, 4.0, 4.0),
        EdgeFlowRecord("south_hub", "transfer", 6.0, 2.0, 6.0),
        EdgeFlowRecord("transfer", "sink", 12.0, 1.0, 12.0),
    ]
    return nodes, edges


def node_balances(nodes: list[str], edges: list[EdgeFlowRecord]) -> dict[str, float]:
    balances = {node: 0.0 for node in nodes}
    for edge in edges:
        balances[edge.source] -= edge.flow
        balances[edge.target] += edge.flow
    return balances


def build_audit() -> tuple[NetworkFlowAudit, list[str], list[EdgeFlowRecord], dict[str, float]]:
    nodes, edges = build_network()
    balances = node_balances(nodes, edges)

    source = "source"
    sink = "sink"
    transshipment_nodes = [node for node in nodes if node not in {source, sink}]
    capacity_violations = sum(1 for edge in edges if edge.flow < -1e-12 or edge.flow - edge.capacity > 1e-12)
    saturated_edge_count = sum(1 for edge in edges if abs(edge.flow - edge.capacity) < 1e-12)
    max_transshipment_imbalance = max(abs(balances[node]) for node in transshipment_nodes)
    total_flow_cost = sum(edge.cost * edge.flow for edge in edges)

    audit = NetworkFlowAudit(
        graph_name="synthetic_capacitated_flow_network",
        node_count=len(nodes),
        edge_count=len(edges),
        source_node=source,
        sink_node=sink,
        total_source_outflow=round(-balances[source], 12),
        total_sink_inflow=round(balances[sink], 12),
        capacity_violations=capacity_violations,
        saturated_edge_count=saturated_edge_count,
        max_absolute_transshipment_imbalance=round(max_transshipment_imbalance, 12),
        total_flow_cost=round(total_flow_cost, 12),
        interpretation_warning=(
            "Network flow results depend on node definitions, edge definitions, capacity units, "
            "flow units, cost semantics, source-sink choices, conservation assumptions, time scale, "
            "solver settings, uncertainty, and data provenance."
        ),
    )

    return audit, nodes, edges, balances


def write_outputs(output_dir: Path) -> None:
    (output_dir / "tables").mkdir(parents=True, exist_ok=True)
    (output_dir / "json").mkdir(parents=True, exist_ok=True)

    audit, nodes, edges, balances = build_audit()
    row = asdict(audit)

    with (output_dir / "tables" / "network_flow_audit.csv").open(
        "w", newline="", encoding="utf-8"
    ) as handle:
        writer = csv.DictWriter(handle, fieldnames=list(row.keys()))
        writer.writeheader()
        writer.writerow(row)

    with (output_dir / "tables" / "edge_flow_table.csv").open(
        "w", newline="", encoding="utf-8"
    ) as handle:
        writer = csv.DictWriter(handle, fieldnames=["source", "target", "capacity", "cost", "flow", "slack", "saturated"])
        writer.writeheader()
        for edge in edges:
            writer.writerow({
                "source": edge.source,
                "target": edge.target,
                "capacity": edge.capacity,
                "cost": edge.cost,
                "flow": edge.flow,
                "slack": round(edge.capacity - edge.flow, 12),
                "saturated": abs(edge.capacity - edge.flow) < 1e-12,
            })

    with (output_dir / "tables" / "node_balance_table.csv").open(
        "w", newline="", encoding="utf-8"
    ) as handle:
        writer = csv.DictWriter(handle, fieldnames=["node", "balance"])
        writer.writeheader()
        for node in nodes:
            writer.writerow({"node": node, "balance": round(balances[node], 12)})

    (output_dir / "json" / "network_flow_audit.json").write_text(
        json.dumps(row, indent=2, sort_keys=True),
        encoding="utf-8",
    )


if __name__ == "__main__":
    write_outputs(Path("outputs"))
    print("Network flow audit complete.")

This workflow keeps capacity checks, node balances, saturated edges, total flow cost, and interpretation warnings together.

Back to top ↑

R Workflow: Flow Balance Diagnostics

R can support network-flow diagnostics by auditing edge capacities, computing node balances, identifying saturated edges, and exporting flow summaries.

nodes <- c("source", "north_hub", "south_hub", "transfer", "sink")

edges <- data.frame(
  source = c("source", "source", "north_hub", "north_hub", "south_hub", "transfer"),
  target = c("north_hub", "south_hub", "transfer", "sink", "transfer", "sink"),
  capacity = c(12, 8, 7, 5, 6, 12),
  cost = c(2, 3, 1, 4, 2, 1),
  flow = c(10, 6, 6, 4, 6, 12)
)

edges$slack <- edges$capacity - edges$flow
edges$saturated <- abs(edges$slack) < 1e-12
edges$capacity_violation <- edges$flow < -1e-12 | edges$flow - edges$capacity > 1e-12
edges$flow_cost <- edges$cost * edges$flow

balances <- setNames(rep(0, length(nodes)), nodes)

for (i in seq_len(nrow(edges))) {
  balances[edges$source[i]] <- balances[edges$source[i]] - edges$flow[i]
  balances[edges$target[i]] <- balances[edges$target[i]] + edges$flow[i]
}

source_node <- "source"
sink_node <- "sink"
transshipment_nodes <- setdiff(nodes, c(source_node, sink_node))

audit_record <- data.frame(
  graph_name = "synthetic_capacitated_flow_network",
  node_count = length(nodes),
  edge_count = nrow(edges),
  source_node = source_node,
  sink_node = sink_node,
  total_source_outflow = -balances[source_node],
  total_sink_inflow = balances[sink_node],
  capacity_violations = sum(edges$capacity_violation),
  saturated_edge_count = sum(edges$saturated),
  max_absolute_transshipment_imbalance = max(abs(balances[transshipment_nodes])),
  total_flow_cost = sum(edges$flow_cost),
  interpretation_warning = paste(
    "Network flow results depend on node definitions, edge definitions, capacity units,",
    "flow units, cost semantics, source-sink choices, conservation assumptions,",
    "time scale, solver settings, uncertainty, and data provenance."
  )
)

balance_table <- data.frame(node = nodes, balance = as.numeric(balances[nodes]))

dir.create("outputs/tables", recursive = TRUE, showWarnings = FALSE)

write.csv(audit_record, "outputs/tables/r_network_flow_audit.csv", row.names = FALSE)
write.csv(edges, "outputs/tables/r_edge_flow_table.csv", row.names = FALSE)
write.csv(balance_table, "outputs/tables/r_node_balance_table.csv", row.names = FALSE)

print(audit_record)

This R workflow preserves edge-level flow assumptions and node-level balance diagnostics in auditable tables.

Back to top ↑

Haskell Workflow: Typed Flow Records

Haskell can represent network-flow audit output as typed records, keeping capacity, source-sink, balance, and interpretation warnings attached to the summary.

module Main where

data NetworkFlowAudit = NetworkFlowAudit
  { graphName :: String
  , nodeCount :: Int
  , edgeCount :: Int
  , sourceNode :: String
  , sinkNode :: String
  , totalSourceOutflow :: Double
  , totalSinkInflow :: Double
  , capacityViolations :: Int
  , saturatedEdgeCount :: Int
  , maxAbsoluteTransshipmentImbalance :: Double
  , totalFlowCost :: Double
  , interpretationWarning :: String
  } deriving (Show)

buildAudit :: NetworkFlowAudit
buildAudit =
  NetworkFlowAudit
    "synthetic_capacitated_flow_network"
    5
    6
    "source"
    "sink"
    16.0
    16.0
    0
    2
    0.0
    82.0
    "Network flow results depend on node definitions, edge definitions, capacity units, flow units, cost semantics, source-sink choices, conservation assumptions, time scale, solver settings, uncertainty, and data provenance."

main :: IO ()
main =
  print buildAudit

The typed record helps prevent flow values from being separated from the assumptions that make them meaningful.

Back to top ↑

SQL Workflow: Network Flow Registry

SQL can document network-flow assumptions when flow models support infrastructure planning, logistics, emergency management, supply-chain analysis, water systems, service operations, or institutional dashboards.

CREATE TABLE network_flow_registry (
    assumption_key TEXT PRIMARY KEY,
    assumption_name TEXT NOT NULL,
    mathematical_role TEXT NOT NULL,
    systems_modeling_role TEXT NOT NULL,
    review_warning TEXT NOT NULL
);

INSERT INTO network_flow_registry VALUES
(
  'flow_quantity',
  'Flow quantity',
  'Defines what the edge-flow variables measure.',
  'Determines whether flow represents vehicles, goods, water, power, data, patients, money, or services.',
  'Flow units and time scale must be documented.'
);

INSERT INTO network_flow_registry VALUES
(
  'source_sink_definition',
  'Source and sink definition',
  'Defines where flow enters and leaves the network.',
  'Determines the meaning of throughput, demand, and supply.',
  'Changing sources or sinks changes the problem.'
);

INSERT INTO network_flow_registry VALUES
(
  'capacity_definition',
  'Capacity definition',
  'Defines upper bounds on edge flow.',
  'Represents physical, operational, regulatory, or institutional limits.',
  'Capacities may vary over time and may be uncertain.'
);

INSERT INTO network_flow_registry VALUES
(
  'conservation_assumption',
  'Conservation assumption',
  'Defines node-balance constraints.',
  'Determines whether intermediate nodes preserve, store, lose, or transform flow.',
  'Simple conservation can be wrong for systems with storage, loss, queues, or delay.'
);

INSERT INTO network_flow_registry VALUES
(
  'cost_semantics',
  'Cost semantics',
  'Defines objective coefficients for costed flow.',
  'Determines whether optimization minimizes distance, time, money, risk, emissions, or loss.',
  'Mixed or unclear costs can produce misleading optimal routes.'
);

INSERT INTO network_flow_registry VALUES
(
  'cut_interpretation',
  'Cut interpretation',
  'Defines what source-sink partitions mean.',
  'Supports bottleneck and vulnerability analysis.',
  'A minimum cut is a model-based bottleneck, not automatically a policy priority.'
);

INSERT INTO network_flow_registry VALUES
(
  'sensitivity_review',
  'Sensitivity review',
  'Tests how flows change under capacity, cost, demand, and edge perturbations.',
  'Assesses robustness of capacity and bottleneck conclusions.',
  'Optimal flows can be fragile under uncertainty.'
);

SELECT
    assumption_name,
    mathematical_role,
    systems_modeling_role,
    review_warning
FROM network_flow_registry
ORDER BY assumption_key;

This registry keeps network-flow analysis tied to flow units, source-sink definitions, capacities, conservation, costs, cuts, and sensitivity testing.

Back to top ↑

GitHub Repository

The companion repository for this article is designed as a reproducible mathematical-modeling workspace. It supports network-flow audits, directed edge lists, capacity checks, node-balance diagnostics, saturated-edge summaries, source-sink throughput reports, costed-flow calculations, SQL governance tables, generated outputs, advanced mathematical audit reports, and reusable calculator scripts.

Back to top ↑

Interpretive Limits and Responsible Use

Network flow modeling is powerful because it makes movement, capacity, conservation, cost, and bottlenecks explicit. It can estimate system throughput, identify limiting cuts, compare routing strategies, test disruption scenarios, and support infrastructure, logistics, supply-chain, communication, service, and public-sector planning. Its limits arise because flow models depend on assumptions that may be uncertain, incomplete, contested, or simplified.

A feasible flow is feasible only under the modeled graph, capacities, demands, time scale, conservation rules, and cost definitions. A maximum flow is not automatically desirable. A minimum-cost flow may ignore equity, reliability, emissions, resilience, or institutional constraints. A minimum cut may identify a mathematical bottleneck but not the only practical vulnerability. A capacity value may represent ideal throughput, not real operating conditions. A route may be optimal in a static model but fragile under disruption.

Responsible use requires documenting what flows, where it flows, what limits it, what is conserved, what costs mean, what time period applies, what uncertainty exists, what alternatives were tested, and who is affected by the resulting optimization. Network flow models should clarify capacity and constraint, not hide value choices behind mathematical feasibility.

Back to top ↑

Related Articles

• What Is Linear Algebra for Systems Modeling?
• Network Adjacency Matrices
• Incidence Structure and Graph Representation
• Graph Theory Foundations for Systems Modeling
• PageRank and Network Influence Models
• Infrastructure Network Models
• Flow, Connectivity, and System Vulnerability
• Matrix Differential Equations
• Control Systems Modeling
• Markov Chains and Transition Matrices
• Linear Dynamical Systems
• Eigenvalues, Eigenvectors, and System Modes
• Stability Analysis with Eigenvalues
• Linear Algebra for Systems Modeling
• Mathematical Modeling
• Systems Modeling
• Algorithms & Computational Reasoning
• Scientific Computing for Systems Modeling

Back to top ↑

Further Reading

• Ahuja, R.K., Magnanti, T.L. and Orlin, J.B. (1993) Network Flows: Theory, Algorithms, and Applications. Upper Saddle River, NJ: Prentice Hall. Available at: https://mitmgmtfaculty.mit.edu/jorlin/network-flows/.
• Bertsekas, D.P. (1998) Network Optimization: Continuous and Discrete Models. Belmont, MA: Athena Scientific. Available at: https://www.athenasc.com/netbook.html.
• Boyd, S. and Vandenberghe, L. (2004) Convex Optimization. Cambridge: Cambridge University Press. Available at: https://web.stanford.edu/~boyd/cvxbook/.
• Cormen, T.H., Leiserson, C.E., Rivest, R.L. and Stein, C. (2022) Introduction to Algorithms. 4th edn. Cambridge, MA: MIT Press. Available at: https://mitpress.mit.edu/9780262046305/introduction-to-algorithms/.
• Ford, L.R. and Fulkerson, D.R. (1962) Flows in Networks. Princeton, NJ: Princeton University Press. Available at: https://press.princeton.edu/books/hardcover/9780691625393/flows-in-networks.
• Lawler, E.L. (1976) Combinatorial Optimization: Networks and Matroids. New York: Holt, Rinehart and Winston.
• NetworkX Developers (n.d.) Flow Algorithms. NetworkX Documentation. Available at: https://networkx.org/documentation/stable/reference/algorithms/flow.html.
• Schrijver, A. (2003) Combinatorial Optimization: Polyhedra and Efficiency. Berlin: Springer. Available at: https://link.springer.com/book/10.1007/978-3-540-44389-6.
• SciPy Developers (n.d.) linprog. SciPy Documentation. Available at: https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.linprog.html.
• Vanderbei, R.J. (2020) Linear Programming: Foundations and Extensions. 5th edn. Cham: Springer. Available at: https://link.springer.com/book/10.1007/978-3-030-39415-8.

Back to top ↑

References

• Ahuja, R.K., Magnanti, T.L. and Orlin, J.B. (1993) Network Flows: Theory, Algorithms, and Applications. Upper Saddle River, NJ: Prentice Hall. Available at: https://mitmgmtfaculty.mit.edu/jorlin/network-flows/.
• Bertsekas, D.P. (1998) Network Optimization: Continuous and Discrete Models. Belmont, MA: Athena Scientific. Available at: https://www.athenasc.com/netbook.html.
• Boyd, S. and Vandenberghe, L. (2004) Convex Optimization. Cambridge: Cambridge University Press. Available at: https://web.stanford.edu/~boyd/cvxbook/.
• Cormen, T.H., Leiserson, C.E., Rivest, R.L. and Stein, C. (2022) Introduction to Algorithms. 4th edn. Cambridge, MA: MIT Press. Available at: https://mitpress.mit.edu/9780262046305/introduction-to-algorithms/.
• Ford, L.R. and Fulkerson, D.R. (1962) Flows in Networks. Princeton, NJ: Princeton University Press. Available at: https://press.princeton.edu/books/hardcover/9780691625393/flows-in-networks.
• Lawler, E.L. (1976) Combinatorial Optimization: Networks and Matroids. New York: Holt, Rinehart and Winston.
• NetworkX Developers (n.d.) Flow Algorithms. NetworkX Documentation. Available at: https://networkx.org/documentation/stable/reference/algorithms/flow.html.
• Schrijver, A. (2003) Combinatorial Optimization: Polyhedra and Efficiency. Berlin: Springer. Available at: https://link.springer.com/book/10.1007/978-3-540-44389-6.
• SciPy Developers (n.d.) linprog. SciPy Documentation. Available at: https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.linprog.html.
• Vanderbei, R.J. (2020) Linear Programming: Foundations and Extensions. 5th edn. Cham: Springer. Available at: https://link.springer.com/book/10.1007/978-3-030-39415-8.

Back to top ↑