Scaling, Units, and Nondimensionalization

Last Updated June 16, 2026

Scaling, units, and nondimensionalization help mathematical models remain interpretable, comparable, and computationally reliable. In calculus-based systems modeling, a model is not only a collection of equations. It is also a statement about measurement, scale, units, dimensions, parameters, assumptions, and the level of abstraction appropriate to the problem.

Units tell us what quantities mean. Scaling tells us how large or small those quantities are relative to meaningful reference values. Nondimensionalization rewrites models in dimensionless form so that dominant relationships, small parameters, similarity patterns, numerical conditioning, and system regimes become easier to see.

This article introduces scaling, units, and nondimensionalization for systems modeling, including dimensional consistency, unit conversion, reference scales, dimensionless variables, dimensionless groups, the Buckingham Pi theorem, scaling laws, numerical conditioning, parameter reduction, model comparison, reproducible workflows, and responsible interpretation.

Scaling and units are not bookkeeping details. They shape model meaning. A time step measured in days is not the same as a time step measured in years. A growth rate per hour cannot be used as a growth rate per decade without conversion. A length scale, population scale, exposure scale, or concentration scale can change how equations are interpreted and how numerical methods behave.

The central question is not only “What is the equation?” It is “What are the units, what scales define the problem, and what dimensionless structure remains after measurement choices are removed?”

Why Scaling and Units Matter

Scaling and units matter because mathematical models can become misleading when quantities are compared without reference to measurement. A value of 0.5 may be small, large, or meaningless depending on whether it refers to meters, years, probability, concentration, elasticity, normalized response, or a dimensionless ratio.

In systems modeling, scaling affects interpretation, computation, and communication. It clarifies whether a parameter is large or small, whether a time horizon is short or long, whether a process is fast or slow, whether a numerical method is stable, and whether different systems can be compared.

Scaling and units are therefore part of model design, not only presentation.

Back to top ↑

Dimensional Consistency

Dimensional consistency means that terms being added, subtracted, or compared have compatible dimensions. A model that adds a population count to a growth rate, or a length to a time, is structurally confused unless those quantities have been transformed into compatible form.

Multiplication and division combine dimensions. Derivatives and integrals also carry dimensions. For example, if \(x\) has units of population and \(t\) has units of time, then \(dx/dt\) has units of population per time.

Dimensional consistency is one of the simplest and most powerful checks on model structure.

Back to top ↑

Units and Model Meaning

Units connect a mathematical symbol to measurement. They also protect against hidden conversion errors. A model parameter may look harmless as a number, but if the rate is expressed per day and the time variable is measured in years, the model may run at the wrong speed.

Units should be documented for variables, parameters, initial conditions, boundary conditions, data columns, solver settings, axes, outputs, and interpretation statements.

Unit records are especially important in multi-language repositories, where data may pass through Python, R, SQL, Haskell, Julia, and compiled examples.

Back to top ↑

Scaling and Reference Values

Scaling rewrites quantities relative to reference values. A reference value may be a maximum, baseline, characteristic length, characteristic time, carrying capacity, mean value, threshold, or policy-relevant target.

Scaling can make variables easier to compare. A population stock of 80 is more interpretable when we know whether the relevant capacity is 100, 1,000, or 1,000,000. A time horizon of 20 is more meaningful when compared to the system’s characteristic response time.

Good scaling choices reveal model structure. Poor scaling choices can obscure it.

Back to top ↑

Nondimensionalization

Nondimensionalization rewrites a model in terms of variables with no units. The goal is not to erase measurement, but to make the essential structure clearer by expressing variables relative to their characteristic scales.

Consider the logistic growth equation:

Using scaled variables \(u=x/K\) and \(\tau=rt\), the equation becomes:

The nondimensional form is simpler. It removes arbitrary unit choices and shows the core structure of the model. It also helps compare systems with different growth rates and carrying capacities.

Nondimensionalization often reduces the number of parameters and clarifies which combinations of parameters actually control behavior.

Back to top ↑

Dimensionless Groups

A dimensionless group is a combination of variables and parameters whose units cancel. Dimensionless groups are useful because they often identify regimes, thresholds, similarity classes, and dominant processes.

Many important dimensionless groups compare competing effects. A ratio may compare advection to diffusion, inertia to viscosity, forcing to damping, growth to removal, exposure to threshold, or delay to response time.

Dimensionless groups often matter more than raw parameter values because they express relationships between processes.

Back to top ↑

The Buckingham Pi Theorem

The Buckingham Pi theorem gives a systematic way to reduce a dimensional relationship to a relationship among dimensionless groups. If a problem involves \(n\) dimensional variables and \(k\) independent base dimensions, then the relationship can often be expressed using \(n-k\) independent dimensionless groups.

This theorem is useful when the exact functional form is unknown but the relevant variables and dimensions are known. It can support experiment design, model comparison, scale modeling, data collapse, and similarity analysis.

The theorem does not choose the correct variables automatically. It gives a disciplined method once the modeling judgment about relevant variables has been made.

Back to top ↑

Scaling Laws and Similarity

Scaling laws describe how one quantity changes with another across size, time, intensity, or regime. Similarity occurs when different systems share the same dimensionless structure even if their raw units and magnitudes differ.

Similarity analysis is especially useful when comparing models across different sizes or settings. A laboratory model, field system, urban system, ecological system, or infrastructure network may be comparable only when expressed through relevant dimensionless groups.

Scaling laws can clarify structure, but they can also be overused. A fitted power law is not automatically a mechanism.

Back to top ↑

Numerical Conditioning

Scaling also affects numerical computation. When variables or parameters differ by many orders of magnitude, numerical methods may become unstable, inefficient, or difficult to interpret. Poor scaling can make optimization, calibration, integration, and differential equation solving harder than necessary.

Good scaling is not merely aesthetic. It can determine whether a computational workflow is stable, efficient, and reviewable.

Back to top ↑

Scope and Interpretation

Scaling choices carry interpretive consequences. A nondimensional model may be elegant, but interpretation still depends on the scales used to create it. If the reference scale changes, the meaning of normalized quantities can change. If a dimensionless group is interpreted outside the tested range, the model can be overextended.

Scaling supports interpretation only when the reference values, assumptions, and validity domains are documented.

Back to top ↑

Systems Modeling Interpretation

In systems modeling, scaling, units, and nondimensionalization help distinguish model structure from measurement convention. They make it easier to see whether a result is large or small, whether a process is fast or slow, whether a capacity is nearly reached, whether a delay matters, and whether systems can be compared.

This matters because systems models often connect mathematical formalism to public explanation, planning, infrastructure, ecology, health, climate, finance, and institutional strategy. Without unit records and scaling logic, model outputs can look precise while being difficult to interpret responsibly.

The stronger interpretive standard is not “the model produced a number.” It is: “the model result is tied to documented units, reference scales, dimensionless groups, numerical conditioning checks, tested parameter ranges, and claim boundaries.”

Back to top ↑

Mathematical Deepening

This section adds a more formal layer for mathematically advanced readers. Scaling, units, and nondimensionalization connect dimensional analysis, unit systems, reference scales, nondimensional variables, dimensionless parameters, similarity solutions, asymptotic reasoning, numerical conditioning, perturbation methods, and model governance.

Back to top ↑

Back to top ↑

Computation and Reproducible Workflows

Computational workflows for scaling and nondimensionalization should preserve unit records, conversion rules, reference scales, scaled variables, dimensionless groups, numerical conditioning checks, output tables, and interpretation warnings. These records should be exported into durable formats so model results can be traced back to measurement choices.

The companion repository for this article uses a multi-language scaffold to show how scaling, units, and nondimensionalization can be documented, validated, and audited across Python, R, Haskell, SQL, and other workflow layers.

Back to top ↑

Python Workflow: Scaling and Unit Audit

The Python workflow below builds unit records, scale records, and nondimensional outputs for a simple logistic model. It exports CSV, JSON, and Markdown review artifacts.

from __future__ import annotations

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


@dataclass(frozen=True)
class UnitRecord:
    quantity_name: str
    value: float
    unit: str
    dimension: str
    source_note: str
    warning: str


@dataclass(frozen=True)
class ScaleRecord:
    scale_name: str
    scale_value: float
    unit: str
    interpretation: str
    warning: str


@dataclass(frozen=True)
class NondimensionalRecord:
    quantity_name: str
    dimensional_value: float
    scale_value: float
    dimensionless_value: float
    interpretation: str


def build_unit_records() -> list[UnitRecord]:
    return [
        UnitRecord(
            quantity_name="population_stock",
            value=40.0,
            unit="state units",
            dimension="stock",
            source_note="synthetic teaching value",
            warning="Synthetic value; do not treat as empirical measurement."
        ),
        UnitRecord(
            quantity_name="carrying_capacity",
            value=100.0,
            unit="state units",
            dimension="stock",
            source_note="synthetic teaching capacity",
            warning="Capacity scale controls normalized interpretation."
        ),
        UnitRecord(
            quantity_name="growth_rate",
            value=0.35,
            unit="per time unit",
            dimension="inverse time",
            source_note="synthetic teaching rate",
            warning="Rate units must match the time variable."
        )
    ]


def build_scale_records() -> list[ScaleRecord]:
    return [
        ScaleRecord(
            scale_name="stock_scale",
            scale_value=100.0,
            unit="state units",
            interpretation="carrying capacity used to normalize population stock",
            warning="Changing the capacity scale changes dimensionless stock."
        ),
        ScaleRecord(
            scale_name="time_scale",
            scale_value=1 / 0.35,
            unit="time units",
            interpretation="inverse growth rate used as characteristic response time",
            warning="Changing the growth-rate scale changes dimensionless time."
        )
    ]


def build_nondimensional_records() -> list[NondimensionalRecord]:
    stock = 40.0
    capacity = 100.0
    time = 20.0
    growth_rate = 0.35

    return [
        NondimensionalRecord(
            quantity_name="scaled_stock",
            dimensional_value=stock,
            scale_value=capacity,
            dimensionless_value=stock / capacity,
            interpretation="population stock as fraction of carrying capacity"
        ),
        NondimensionalRecord(
            quantity_name="scaled_time",
            dimensional_value=time,
            scale_value=1 / growth_rate,
            dimensionless_value=growth_rate * time,
            interpretation="time measured in characteristic growth-time units"
        )
    ]


output_dir = Path("outputs")
(output_dir / "tables").mkdir(parents=True, exist_ok=True)
(output_dir / "json").mkdir(parents=True, exist_ok=True)
(output_dir / "reports").mkdir(parents=True, exist_ok=True)

unit_records = build_unit_records()
scale_records = build_scale_records()
nondimensional_records = build_nondimensional_records()

with (output_dir / "tables" / "unit_records.csv").open("w", newline="", encoding="utf-8") as handle:
    writer = csv.DictWriter(handle, fieldnames=asdict(unit_records[0]).keys())
    writer.writeheader()
    for record in unit_records:
        writer.writerow(asdict(record))

with (output_dir / "tables" / "scale_records.csv").open("w", newline="", encoding="utf-8") as handle:
    writer = csv.DictWriter(handle, fieldnames=asdict(scale_records[0]).keys())
    writer.writeheader()
    for record in scale_records:
        writer.writerow(asdict(record))

with (output_dir / "tables" / "nondimensional_records.csv").open("w", newline="", encoding="utf-8") as handle:
    writer = csv.DictWriter(handle, fieldnames=asdict(nondimensional_records[0]).keys())
    writer.writeheader()
    for record in nondimensional_records:
        writer.writerow(asdict(record))

audit = {
    "unit_records": [asdict(record) for record in unit_records],
    "scale_records": [asdict(record) for record in scale_records],
    "nondimensional_records": [asdict(record) for record in nondimensional_records],
    "interpretation_warning": "Scaling improves comparability but does not prove empirical validity."
}

(output_dir / "json" / "scaling_unit_audit.json").write_text(
    json.dumps(audit, indent=2),
    encoding="utf-8"
)

report_lines = [
    "# Scaling and Unit Audit",
    "",
    "## Unit Records"
]

for record in unit_records:
    report_lines.append(
        f"- **{record.quantity_name}** = {record.value} {record.unit}; dimension: {record.dimension}. {record.warning}"
    )

report_lines.append("")
report_lines.append("## Scale Records")

for record in scale_records:
    report_lines.append(
        f"- **{record.scale_name}** = {record.scale_value:.6f} {record.unit}; {record.interpretation}. {record.warning}"
    )

report_lines.append("")
report_lines.append("## Nondimensional Records")

for record in nondimensional_records:
    report_lines.append(
        f"- **{record.quantity_name}** = {record.dimensionless_value:.6f}; {record.interpretation}"
    )

report_lines.append("")
report_lines.append("Scaling improves comparability but does not prove empirical validity.")

(output_dir / "reports" / "scaling_unit_audit.md").write_text(
    "\n".join(report_lines) + "\n",
    encoding="utf-8"
)

print("Wrote scaling and unit audit outputs.")

This workflow keeps units, reference scales, dimensionless values, and interpretation warnings attached to the model record.

Back to top ↑

R Workflow: Nondimensional Scenario Table

The R workflow below compares dimensional and nondimensional logistic trajectories across different initial stocks.

logistic_solution <- function(t, x0, growth_rate, carrying_capacity) {
  carrying_capacity / (1 + ((carrying_capacity - x0) / x0) * exp(-growth_rate * t))
}

scenarios <- data.frame(
  scenario = c("low_stock", "baseline_stock", "high_stock"),
  initial_stock = c(5, 10, 20),
  carrying_capacity = c(100, 100, 100),
  growth_rate = c(0.35, 0.35, 0.35),
  time = c(20, 20, 20),
  unit_warning = c(
    "Synthetic teaching scenario; stock measured in state units.",
    "Synthetic teaching scenario; stock measured in state units.",
    "Synthetic teaching scenario; stock measured in state units."
  )
)

scenarios$final_stock <- mapply(
  logistic_solution,
  scenarios$time,
  scenarios$initial_stock,
  scenarios$growth_rate,
  scenarios$carrying_capacity
)

scenarios$scaled_initial_stock <- scenarios$initial_stock / scenarios$carrying_capacity
scenarios$scaled_final_stock <- scenarios$final_stock / scenarios$carrying_capacity
scenarios$scaled_time <- scenarios$growth_rate * scenarios$time

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

write.csv(
  scenarios,
  "outputs/tables/r_nondimensional_scenarios.csv",
  row.names = FALSE
)

print(scenarios)

This workflow makes it easier to compare trajectories as fractions of carrying capacity and scaled time.

Back to top ↑

Haskell Workflow: Typed Unit Records

Haskell can represent units, scales, and nondimensional records as typed structures that preserve modeling interpretation.

module Main where

data Dimension
  = Stock
  | Time
  | InverseTime
  | Length
  | Dimensionless
  deriving (Show, Eq)

data UnitRecord = UnitRecord
  { quantityName :: String
  , quantityValue :: Double
  , unitLabel :: String
  , dimension :: Dimension
  , sourceNote :: String
  , unitWarning :: String
  } deriving (Show, Eq)

data ScaleRecord = ScaleRecord
  { scaleName :: String
  , scaleValue :: Double
  , scaleUnit :: String
  , scaleInterpretation :: String
  , scaleWarning :: String
  } deriving (Show, Eq)

data NondimensionalRecord = NondimensionalRecord
  { dimensionlessName :: String
  , dimensionalValue :: Double
  , referenceScale :: Double
  , dimensionlessValue :: Double
  , dimensionlessInterpretation :: String
  } deriving (Show, Eq)

unitRecords :: [UnitRecord]
unitRecords =
  [ UnitRecord
      "population_stock"
      40.0
      "state units"
      Stock
      "synthetic teaching value"
      "Synthetic value; do not treat as empirical measurement."
  , UnitRecord
      "carrying_capacity"
      100.0
      "state units"
      Stock
      "synthetic teaching capacity"
      "Capacity scale controls normalized interpretation."
  , UnitRecord
      "growth_rate"
      0.35
      "per time unit"
      InverseTime
      "synthetic teaching rate"
      "Rate units must match the time variable."
  ]

scaleRecords :: [ScaleRecord]
scaleRecords =
  [ ScaleRecord
      "stock_scale"
      100.0
      "state units"
      "carrying capacity used to normalize population stock"
      "Changing the capacity scale changes dimensionless stock."
  , ScaleRecord
      "time_scale"
      (1 / 0.35)
      "time units"
      "inverse growth rate used as characteristic response time"
      "Changing the growth-rate scale changes dimensionless time."
  ]

nondimensionalRecords :: [NondimensionalRecord]
nondimensionalRecords =
  [ NondimensionalRecord
      "scaled_stock"
      40.0
      100.0
      (40.0 / 100.0)
      "population stock as fraction of carrying capacity"
  , NondimensionalRecord
      "scaled_time"
      20.0
      (1 / 0.35)
      (0.35 * 20.0)
      "time measured in characteristic growth-time units"
  ]

main :: IO ()
main = do
  putStrLn "Unit records:"
  mapM_ print unitRecords
  putStrLn ""
  putStrLn "Scale records:"
  mapM_ print scaleRecords
  putStrLn ""
  putStrLn "Nondimensional records:"
  mapM_ print nondimensionalRecords

The typed workflow helps keep measurement choices explicit rather than burying them in raw numbers.

Back to top ↑

SQL Workflow: Scaling Governance Registry

SQL can preserve unit, scale, nondimensionalization, and governance records for repository-level review.

CREATE TABLE scaling_governance_registry (
    registry_key TEXT PRIMARY KEY,
    registry_name TEXT NOT NULL,
    analytical_role TEXT NOT NULL,
    systems_modeling_role TEXT NOT NULL,
    review_warning TEXT NOT NULL
);

INSERT INTO scaling_governance_registry VALUES
(
  'unit_record',
  'Unit record',
  'Documents units, dimensions, conversion rules, and source notes.',
  'Keeps model quantities interpretable and comparable.',
  'A numerical value without a unit may be ambiguous or misleading.'
);

INSERT INTO scaling_governance_registry VALUES
(
  'reference_scale',
  'Reference scale',
  'Defines the characteristic value used to normalize a quantity.',
  'Turns raw magnitudes into comparable ratios.',
  'Changing the reference scale changes dimensionless interpretation.'
);

INSERT INTO scaling_governance_registry VALUES
(
  'dimensionless_variable',
  'Dimensionless variable',
  'Expresses a quantity as a ratio to a reference scale.',
  'Supports comparison across systems with different units or sizes.',
  'Dimensionless form still depends on documented scale choices.'
);

INSERT INTO scaling_governance_registry VALUES
(
  'dimensionless_group',
  'Dimensionless group',
  'Combines variables and parameters so units cancel.',
  'Reveals process ratios, regimes, and similarity classes.',
  'Dimensionless groups require correct variable selection and interpretation.'
);

INSERT INTO scaling_governance_registry VALUES
(
  'unit_conversion',
  'Unit conversion',
  'Transforms values across compatible unit systems.',
  'Prevents hidden mismatches in time, length, mass, stock, or rate units.',
  'Conversion rules should be explicit and reproducible.'
);

INSERT INTO scaling_governance_registry VALUES
(
  'claim_boundary',
  'Claim boundary',
  'Defines how scaled or dimensionless results may be interpreted.',
  'Prevents overclaiming from elegant mathematical form.',
  'Scaling improves comparability but does not prove empirical validity.'
);

SELECT
    registry_name,
    analytical_role,
    systems_modeling_role,
    review_warning
FROM scaling_governance_registry
ORDER BY registry_key;

This registry connects units, reference scales, dimensionless variables, dimensionless groups, conversion rules, and claim boundaries to governance review.

Back to top ↑

GitHub Repository

The companion repository for this article is designed as a reproducible mathematical-modeling workspace. It supports unit records, reference-scale records, nondimensional variables, dimensionless groups, conversion checks, numerical conditioning notes, SQL governance tables, Haskell typed records, generated reports, advanced audit logic, and reusable calculator scripts.

Back to top ↑

Interpretive Limits and Responsible Use

Scaling, units, and nondimensionalization improve model clarity, but they do not prove that a model is true. A dimensionally consistent equation can still represent the wrong mechanism. A clean nondimensional form can still be calibrated poorly. A scaling law can fit a pattern without explaining it. A numerical normalization can improve computation while hiding interpretive choices.

Responsible use requires documentation. Preserve units, dimensions, conversion rules, reference scales, scale choices, dimensionless groups, parameter ranges, solver settings, data domains, validation checks, and claim boundaries. Treat nondimensionalization as a tool for clarity and comparison, not as a substitute for evidence, validation, or judgment.

The central question is not only “Can the model be rescaled?” It is “Do the scaling choices clarify the model’s structure while preserving the evidence, assumptions, and limits needed for responsible interpretation?”

Back to top ↑

Related Articles

• Calculus for Systems Modeling
• Initial Conditions, Boundary Conditions, and Model Scope
• Sensitivity, Robustness, and Parameter Dependence
• Domains, Ranges, and System Boundaries
• Dimensional Analysis
• Differential Equations and Dynamic Systems
• Stability, Error, and Convergence in Numerical Modeling
• Stiff Systems and Computational Difficulty
• Interpretation, Assumptions, and Responsible Mathematical Modeling
• Model Governance and Accountability

Back to top ↑

Further Reading

• Bureau International des Poids et Mesures (2026) Le Système international d’unités / The International System of Units. 9th edn. Paris: BIPM. Link
• National Institute of Standards and Technology (2019) The International System of Units (SI). NIST Special Publication 330. Gaithersburg, MD: NIST. Link
• Thompson, A. and Taylor, B.N. (2008) Guide for the Use of the International System of Units (SI). NIST Special Publication 811. Gaithersburg, MD: National Institute of Standards and Technology. Link
• Bridgman, P.W. (1931) Dimensional Analysis. Revised edn. New Haven, CT: Yale University Press. Link
• Britannica (2024) ‘Pi theorem’, Encyclopaedia Britannica. Link
• Sonin, A.A. (2004) ‘A generalization of the Π-theorem and dimensional analysis’, Proceedings of the National Academy of Sciences, 101(23), pp. 8525–8526. Link
• Barenblatt, G.I. (1996) Scaling, Self-similarity, and Intermediate Asymptotics. Cambridge: Cambridge University Press. Link
• Lin, C.C. and Segel, L.A. (1988) Mathematics Applied to Deterministic Problems in the Natural Sciences. Philadelphia, PA: SIAM. Link
• Feynman, R.P., Leighton, R.B. and Sands, M. (2013) The Feynman Lectures on Physics. New Millennium edn. Pasadena, CA: California Institute of Technology. Link
• Taylor, J.R. (2022) An Introduction to Error Analysis: The Study of Uncertainties in Physical Measurements. 3rd edn. Cambridge, MA: MIT Press. Link
• LeVeque, R.J. (2007) Finite Difference Methods for Ordinary and Partial Differential Equations: Steady-State and Time-Dependent Problems. Philadelphia, PA: SIAM. Link
• Kevorkian, J. and Cole, J.D. (1981) Perturbation Methods in Applied Mathematics. New York: Springer. Link
• Holmes, M.H. (2013) Introduction to Perturbation Methods. 2nd edn. New York: Springer. Link
• Murray, J.D. (1993) Mathematical Biology. Berlin: Springer. Link
• Strogatz, S.H. (2018) Nonlinear Dynamics and Chaos: With Applications to Physics, Biology, Chemistry, and Engineering. 2nd edn. Boca Raton, FL: CRC Press. Link

Back to top ↑

References

• Barenblatt, G.I. (1996) Scaling, Self-similarity, and Intermediate Asymptotics. Cambridge: Cambridge University Press. Link
• Bridgman, P.W. (1931) Dimensional Analysis. Revised edn. New Haven, CT: Yale University Press. Link
• Britannica (2024) ‘Pi theorem’, Encyclopaedia Britannica. Link
• Bureau International des Poids et Mesures (2026) Le Système international d’unités / The International System of Units. 9th edn. Paris: BIPM. Link
• Feynman, R.P., Leighton, R.B. and Sands, M. (2013) The Feynman Lectures on Physics. New Millennium edn. Pasadena, CA: California Institute of Technology. Link
• Holmes, M.H. (2013) Introduction to Perturbation Methods. 2nd edn. New York: Springer. Link
• Kevorkian, J. and Cole, J.D. (1981) Perturbation Methods in Applied Mathematics. New York: Springer. Link
• LeVeque, R.J. (2007) Finite Difference Methods for Ordinary and Partial Differential Equations: Steady-State and Time-Dependent Problems. Philadelphia, PA: SIAM. Link
• Lin, C.C. and Segel, L.A. (1988) Mathematics Applied to Deterministic Problems in the Natural Sciences. Philadelphia, PA: SIAM. Link
• Murray, J.D. (1993) Mathematical Biology. Berlin: Springer. Link
• National Institute of Standards and Technology (2019) The International System of Units (SI). NIST Special Publication 330. Gaithersburg, MD: NIST. Link
• Sonin, A.A. (2004) ‘A generalization of the Π-theorem and dimensional analysis’, Proceedings of the National Academy of Sciences, 101(23), pp. 8525–8526. Link
• Strogatz, S.H. (2018) Nonlinear Dynamics and Chaos: With Applications to Physics, Biology, Chemistry, and Engineering. 2nd edn. Boca Raton, FL: CRC Press. Link
• Taylor, J.R. (2022) An Introduction to Error Analysis: The Study of Uncertainties in Physical Measurements. 3rd edn. Cambridge, MA: MIT Press. Link
• Thompson, A. and Taylor, B.N. (2008) Guide for the Use of the International System of Units (SI). NIST Special Publication 811. Gaithersburg, MD: National Institute of Standards and Technology. Link

Back to top ↑