Sensitivity, Robustness, and Parameter Dependence

Last Updated June 16, 2026

Sensitivity, robustness, and parameter dependence determine whether a mathematical model is stable under reasonable changes or fragile because of hidden assumptions. In calculus-based systems modeling, a result is rarely meaningful by itself. It must be interpreted alongside the parameters, ranges, perturbations, assumptions, and uncertainty conditions that produced it.

A model may produce a clean curve, equilibrium, forecast, optimum, or simulation output, but that result may change sharply if a growth rate, delay, capacity, exposure coefficient, initial value, boundary condition, or solver tolerance shifts. Sensitivity analysis asks how outputs respond to changes in inputs. Robustness analysis asks whether conclusions remain credible across plausible variations. Parameter dependence asks which assumptions matter most.

This article introduces sensitivity, robustness, and parameter dependence for calculus-based systems modeling, including local sensitivity, normalized sensitivity, elasticity, finite-difference approximations, parameter sweeps, robustness envelopes, threshold behavior, scenario ranges, interaction effects, uncertainty-aware interpretation, reproducible workflows, and model governance.

Sensitivity analysis is not only a technical diagnostic. It is a discipline of interpretation. A model result should not be treated as a fixed answer until the analyst understands how that result changes when assumptions change. Robust models do not require every output to remain unchanged. They require conclusions to remain appropriately qualified across the range of assumptions the model is meant to support.

The central question is not only “What does the model predict?” It is “Which parameters control that prediction, how much do conclusions depend on them, and where does the model become fragile?”

Why Sensitivity and Robustness Matter

Sensitivity and robustness matter because mathematical models are built from assumptions. Parameters may be measured, estimated, calibrated, inferred, chosen for illustration, or set from judgment. If model conclusions change dramatically when plausible parameter values change, the model should be interpreted with caution.

A model can be sensitive without being useless. Sensitivity can identify leverage points, reveal uncertainty, diagnose fragility, guide data collection, and clarify which assumptions deserve the most attention. The problem is not sensitivity itself. The problem is pretending sensitivity does not exist.

Sensitivity and robustness are therefore part of responsible model interpretation.

Back to top ↑

Parameter Dependence

Parameter dependence describes how model outputs change as parameters change. In many systems models, parameters represent rates, capacities, delays, elasticities, thresholds, interaction strengths, diffusion coefficients, forcing terms, recovery rates, failure probabilities, or policy settings.

Some parameters affect output magnitude. Others affect timing, stability, equilibrium, oscillation, threshold crossing, or qualitative regime. Parameter records should therefore document values, units, ranges, sources, assumptions, and intended interpretation.

Parameter dependence becomes dangerous when influential parameters are undocumented, untested, or treated as fixed truths.

Back to top ↑

Local Sensitivity

Local sensitivity measures how a model output changes near a baseline parameter value. In calculus terms, it is often represented by a derivative of the output with respect to a parameter.

Local sensitivity is useful when the model is smooth and the question concerns small changes near a baseline. It is less reliable when the model has thresholds, discontinuities, nonlinear regime changes, or large parameter uncertainty.

Local sensitivity is a powerful first check, but it should not be mistaken for complete uncertainty analysis.

Back to top ↑

Normalized Sensitivity and Elasticity

Raw sensitivities can be hard to compare when parameters have different units or magnitudes. Normalized sensitivity and elasticity express response in relative terms.

Elasticity is especially useful when comparing parameters measured in different units. For example, a carrying capacity, growth rate, recovery rate, and delay time cannot always be compared using raw derivatives. Elasticity places them on a relative scale.

Normalized measures help comparison, but they still depend on the chosen baseline and output definition.

Back to top ↑

Finite-Difference Sensitivity

When analytic derivatives are unavailable, sensitivity can be estimated using finite differences. This is common in simulation models, black-box workflows, numerical solvers, and multi-language repositories.

The choice of step size \(h\) matters. If \(h\) is too large, the estimate may no longer be local. If \(h\) is too small, roundoff error or solver noise may dominate. Finite-difference sensitivity should therefore record step sizes, solver settings, baseline values, and diagnostics.

Finite differences are practical, but they require careful documentation.

Back to top ↑

Parameter Sweeps and Scenario Ranges

Parameter sweeps evaluate a model across a set of parameter values. One-at-a-time sweeps vary one parameter while holding others fixed. Grid sweeps vary multiple parameters across defined ranges. Scenario ranges test plausible combinations of assumptions.

Sweeps are useful because they make model dependence visible. Instead of presenting one output as the answer, a sweep shows how output changes across assumptions.

Parameter sweeps should always report tested ranges. A conclusion that is robust over a narrow range may not be robust over a broader one.

Back to top ↑

Robustness

Robustness asks whether a conclusion remains stable across plausible parameter values, assumptions, model variants, or numerical settings. Robustness does not mean outputs never change. It means the interpretation remains appropriately reliable under documented variation.

Robustness is always conditional. It depends on the tested range, parameter combinations, output metric, model structure, and definition of the conclusion.

A robustness claim without a tested domain is incomplete.

Back to top ↑

Thresholds and Fragility

Some models appear stable until a parameter crosses a threshold. Near thresholds, small changes can produce large shifts in behavior. This is common in nonlinear systems, bifurcation models, epidemiological systems, infrastructure capacity models, climate feedback models, and resource depletion models.

Fragility is not always a defect. Sometimes it reveals a real structural risk. But when fragility is present, the model must not be communicated as if its outputs are stable across assumptions.

Fragility analysis is especially important when model outputs are used to support decisions.

Back to top ↑

Interactions Among Parameters

Parameter effects may interact. A delay may matter only when feedback is strong. A recovery rate may matter most when transmission is near a threshold. A capacity limit may matter only under high demand. One-at-a-time sensitivity can miss these interactions.

Interactions are common in systems models because feedback loops, nonlinearities, constraints, and thresholds couple assumptions together.

Interaction effects are one reason robust modeling cannot rely only on single baseline outputs.

Back to top ↑

Sensitivity and Model Governance

Sensitivity and robustness analysis belong in model governance because they help determine which claims are justified. A model that is highly sensitive to an uncertain parameter should not support a strong claim unless that parameter is well constrained or the claim is revised.

A sensitivity workflow should produce not only numbers but reviewable evidence.

Back to top ↑

Systems Modeling Interpretation

In systems modeling, sensitivity and robustness analysis help distinguish durable insight from parameter-specific behavior. A model may clarify a mechanism even when exact forecasts are sensitive. A model may support qualitative reasoning even when quantitative predictions are uncertain. A model may reveal a fragile threshold that deserves attention rather than dismissal.

This is especially important for public policy, sustainability, health, infrastructure, economics, climate, and organizational systems. A single output can look persuasive, but systems interpretation requires asking whether the same conclusion holds under plausible changes in parameters, assumptions, and model scope.

The stronger interpretive standard is not “the model produced a result.” It is: “the result has been tested against documented parameter ranges, sensitivity measures, robustness checks, interaction effects, numerical diagnostics, and claim boundaries.”

Back to top ↑

Mathematical Deepening

This section adds a more formal layer for mathematically advanced readers. Sensitivity, robustness, and parameter dependence connect derivatives with respect to parameters, finite differences, elasticity, gradients, Jacobians, Hessians, perturbation analysis, uncertainty propagation, local and global sensitivity methods, response surfaces, structural robustness, and model governance.

Back to top ↑

Back to top ↑

Computation and Reproducible Workflows

Computational workflows for sensitivity and robustness should preserve baseline parameter records, tested ranges, perturbation methods, output metrics, sensitivity scores, robustness classifications, threshold warnings, solver diagnostics, and interpretation notes. These records should be exported into durable formats so conclusions can be traced back to the parameter ranges that support them.

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

Back to top ↑

Python Workflow: Sensitivity and Robustness Audit

The Python workflow below builds baseline parameter records, finite-difference sensitivity estimates, robustness classifications, and governance warnings for a simple logistic model.

from __future__ import annotations

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


@dataclass(frozen=True)
class ParameterRecord:
    parameter_name: str
    baseline_value: float
    lower_bound: float
    upper_bound: float
    unit: str
    source_note: str


@dataclass(frozen=True)
class SensitivityRecord:
    parameter_name: str
    baseline_output: float
    low_output: float
    high_output: float
    finite_difference_sensitivity: float
    elasticity_estimate: float
    robustness_note: str
    warning: str


def logistic_final(
    initial_stock: float,
    growth_rate: float,
    carrying_capacity: float,
    horizon: float
) -> float:
    return carrying_capacity / (
        1 + ((carrying_capacity - initial_stock) / initial_stock) * math.exp(-growth_rate * horizon)
    )


def build_parameter_records() -> list[ParameterRecord]:
    return [
        ParameterRecord(
            parameter_name="growth_rate",
            baseline_value=0.35,
            lower_bound=0.20,
            upper_bound=0.50,
            unit="per time unit",
            source_note="synthetic teaching range"
        ),
        ParameterRecord(
            parameter_name="carrying_capacity",
            baseline_value=100.0,
            lower_bound=75.0,
            upper_bound=125.0,
            unit="state units",
            source_note="synthetic teaching range"
        ),
        ParameterRecord(
            parameter_name="initial_stock",
            baseline_value=10.0,
            lower_bound=5.0,
            upper_bound=20.0,
            unit="state units",
            source_note="synthetic teaching range"
        )
    ]


def evaluate_with(parameter_name: str, value: float) -> float:
    params = {
        "growth_rate": 0.35,
        "carrying_capacity": 100.0,
        "initial_stock": 10.0,
        "horizon": 20.0
    }
    params[parameter_name] = value

    return logistic_final(
        initial_stock=params["initial_stock"],
        growth_rate=params["growth_rate"],
        carrying_capacity=params["carrying_capacity"],
        horizon=params["horizon"]
    )


def build_sensitivity_records() -> list[SensitivityRecord]:
    records = []
    baseline_output = evaluate_with("growth_rate", 0.35)

    for parameter in build_parameter_records():
        low_output = evaluate_with(parameter.parameter_name, parameter.lower_bound)
        high_output = evaluate_with(parameter.parameter_name, parameter.upper_bound)
        denominator = parameter.upper_bound - parameter.lower_bound
        sensitivity = (high_output - low_output) / denominator

        elasticity = (
            sensitivity * parameter.baseline_value / baseline_output
            if baseline_output != 0
            else float("nan")
        )

        output_range = abs(high_output - low_output)
        robustness_note = "stable" if output_range < 10 else "sensitive"

        warning = (
            "Conclusion may depend strongly on this parameter."
            if robustness_note == "sensitive"
            else "Output variation is limited across this synthetic range."
        )

        records.append(
            SensitivityRecord(
                parameter_name=parameter.parameter_name,
                baseline_output=baseline_output,
                low_output=low_output,
                high_output=high_output,
                finite_difference_sensitivity=sensitivity,
                elasticity_estimate=elasticity,
                robustness_note=robustness_note,
                warning=warning
            )
        )

    return records


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)

parameters = build_parameter_records()
sensitivities = build_sensitivity_records()

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

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

audit = {
    "parameters": [asdict(record) for record in parameters],
    "sensitivities": [asdict(record) for record in sensitivities],
    "interpretation_warning": "Sensitivity analysis supports model review but does not prove model validity."
}

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

report_lines = [
    "# Sensitivity and Robustness Audit",
    "",
    "## Parameter Records"
]

for record in parameters:
    report_lines.append(
        f"- **{record.parameter_name}** = {record.baseline_value} {record.unit}; range: {record.lower_bound} to {record.upper_bound}; source: {record.source_note}"
    )

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

for record in sensitivities:
    report_lines.append(
        f"- **{record.parameter_name}**: sensitivity {record.finite_difference_sensitivity:.6f}; elasticity {record.elasticity_estimate:.6f}; status: {record.robustness_note}. {record.warning}"
    )

report_lines.append("")
report_lines.append("Sensitivity analysis supports model review but does not prove model validity.")

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

print("Wrote sensitivity and robustness audit outputs.")

This workflow keeps parameter ranges, sensitivity measures, robustness notes, and warnings attached to the model record.

Back to top ↑

R Workflow: Parameter Dependence Table

The R workflow below compares final logistic model outputs across simple parameter scenarios and records a robustness classification.

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

scenarios <- data.frame(
  parameter_name = c(
    "growth_rate",
    "growth_rate",
    "growth_rate",
    "carrying_capacity",
    "carrying_capacity",
    "carrying_capacity"
  ),
  scenario = c("low", "baseline", "high", "low", "baseline", "high"),
  growth_rate = c(0.20, 0.35, 0.50, 0.35, 0.35, 0.35),
  carrying_capacity = c(100, 100, 100, 75, 100, 125),
  initial_stock = c(10, 10, 10, 10, 10, 10),
  horizon = c(20, 20, 20, 20, 20, 20)
)

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

summary_table <- aggregate(
  final_stock ~ parameter_name,
  scenarios,
  function(x) max(x) - min(x)
)

names(summary_table)[2] <- "output_range"
summary_table$robustness_note <- ifelse(
  summary_table$output_range < 10,
  "stable across tested synthetic range",
  "sensitive across tested synthetic range"
)

summary_table$warning <- ifelse(
  summary_table$output_range < 10,
  "Output variation is limited across this range.",
  "Conclusion may depend strongly on this parameter."
)

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

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

write.csv(
  summary_table,
  "outputs/tables/r_parameter_dependence_summary.csv",
  row.names = FALSE
)

print(scenarios)
print(summary_table)

This workflow makes parameter dependence visible as a scenario table rather than hiding it behind a single baseline output.

Back to top ↑

Haskell Workflow: Typed Sensitivity Records

Haskell can represent parameter ranges, sensitivity outputs, and robustness classifications as typed records.

module Main where

data RobustnessStatus
  = Stable
  | Sensitive
  | Fragile
  | Untested
  deriving (Show, Eq)

data ParameterRecord = ParameterRecord
  { parameterName :: String
  , baselineValue :: Double
  , lowerBound :: Double
  , upperBound :: Double
  , unitLabel :: String
  , sourceNote :: String
  } deriving (Show, Eq)

data SensitivityRecord = SensitivityRecord
  { sensitivityParameter :: String
  , baselineOutput :: Double
  , lowOutput :: Double
  , highOutput :: Double
  , sensitivityScore :: Double
  , elasticityEstimate :: Double
  , robustnessStatus :: RobustnessStatus
  , warningNote :: String
  } deriving (Show, Eq)

parameterRecords :: [ParameterRecord]
parameterRecords =
  [ ParameterRecord
      "growth_rate"
      0.35
      0.20
      0.50
      "per time unit"
      "synthetic teaching range"
  , ParameterRecord
      "carrying_capacity"
      100.0
      75.0
      125.0
      "state units"
      "synthetic teaching range"
  , ParameterRecord
      "initial_stock"
      10.0
      5.0
      20.0
      "state units"
      "synthetic teaching range"
  ]

sensitivityRecords :: [SensitivityRecord]
sensitivityRecords =
  [ SensitivityRecord
      "growth_rate"
      99.2
      85.8
      99.7
      46.3
      0.163
      Sensitive
      "Conclusion may depend on growth-rate assumptions."
  , SensitivityRecord
      "carrying_capacity"
      99.2
      74.5
      124.0
      0.99
      0.998
      Sensitive
      "Capacity scale strongly affects final stock interpretation."
  , SensitivityRecord
      "initial_stock"
      99.2
      98.3
      99.6
      0.087
      0.009
      Stable
      "Output variation is limited across this synthetic range."
  ]

main :: IO ()
main = do
  putStrLn "Parameter records:"
  mapM_ print parameterRecords
  putStrLn ""
  putStrLn "Sensitivity records:"
  mapM_ print sensitivityRecords

The typed workflow helps keep sensitivity interpretation attached to parameter ranges and robustness status.

Back to top ↑

SQL Workflow: Sensitivity Governance Registry

SQL can preserve sensitivity, robustness, parameter range, and warning records for repository-level review.

CREATE TABLE sensitivity_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 sensitivity_governance_registry VALUES
(
  'parameter_record',
  'Parameter record',
  'Documents baseline value, unit, source, and tested range.',
  'Keeps model outputs tied to the assumptions that produced them.',
  'Parameter values should not be treated as fixed truths without evidence.'
);

INSERT INTO sensitivity_governance_registry VALUES
(
  'local_sensitivity',
  'Local sensitivity',
  'Measures output response near a baseline parameter value.',
  'Identifies influential assumptions around a reference scenario.',
  'Local sensitivity may miss nonlinear or threshold behavior.'
);

INSERT INTO sensitivity_governance_registry VALUES
(
  'elasticity',
  'Elasticity',
  'Normalizes sensitivity as relative output response to relative parameter change.',
  'Supports comparison across parameters with different units or magnitudes.',
  'Elasticity depends on the chosen baseline and output metric.'
);

INSERT INTO sensitivity_governance_registry VALUES
(
  'parameter_sweep',
  'Parameter sweep',
  'Evaluates outputs across defined parameter values or ranges.',
  'Shows how conclusions change across plausible assumptions.',
  'Sweep conclusions apply only over the tested range.'
);

INSERT INTO sensitivity_governance_registry VALUES
(
  'robustness_classification',
  'Robustness classification',
  'Labels whether a conclusion is stable, conditional, sensitive, or fragile.',
  'Supports claim boundaries and model governance.',
  'Robustness depends on the tested parameter domain.'
);

INSERT INTO sensitivity_governance_registry VALUES
(
  'fragility_warning',
  'Fragility warning',
  'Flags threshold crossings, reversals, or unstable regions.',
  'Prevents overconfident interpretation near critical regimes.',
  'Fragile conclusions require careful communication and review.'
);

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

This registry connects parameter records, local sensitivity, elasticity, sweeps, robustness classification, and fragility warnings to governance review.

Back to top ↑

GitHub Repository

The companion repository for this article is designed as a reproducible mathematical-modeling workspace. It supports baseline parameter records, sensitivity measures, finite-difference checks, parameter sweeps, robustness classifications, threshold warnings, SQL governance tables, Haskell typed records, generated reports, advanced audit logic, and reusable calculator scripts.

Back to top ↑

Interpretive Limits and Responsible Use

Sensitivity and robustness analysis improve model interpretation, but they do not prove that a model is true. A model can be robust across the wrong parameter ranges. A sensitivity ranking can depend on the chosen baseline. A parameter sweep can miss interactions. A robustness claim can fail if the tested domain is too narrow. A stable output can still be based on weak assumptions.

Responsible use requires documentation. Preserve baseline parameter values, units, sources, tested ranges, perturbation methods, solver settings, output metrics, sensitivity scores, robustness classifications, threshold warnings, and claim boundaries. Treat sensitivity analysis as evidence for review, not as a substitute for judgment.

The central question is not only “Which parameter matters?” It is “Which parameter matters for which output, over which range, under which assumptions, and with what consequences for interpretation?”

Back to top ↑

Related Articles

• Calculus for Systems Modeling
• Scaling, Units, and Nondimensionalization
• Mechanistic Explanation and the Limits of Formalism
• Parameter Sweeps and Sensitivity Analysis
• Model Calibration Using Calculus-Based Methods
• Uncertainty and Model Interpretation
• Sensitivity Analysis in Systems Models
• Stress Testing and Robustness Analysis
• Interpretation, Assumptions, and Responsible Mathematical Modeling
• Model Governance and Accountability

Back to top ↑

Further Reading

• 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. Link
• Saltelli, A., Chan, K. and Scott, E.M. (eds.) (2000) Sensitivity Analysis. Chichester: Wiley. Link
• Saltelli, A., Bammer, G., Bruno, I., Charters, E., Di Fiore, M., Didier, E., Espeland, W.N., Kay, J., Lo Piano, S., Mayo, D., Pielke Jr, R., Portaluri, T., Porter, T.M., Puy, A., Rafols, I., Ravetz, J.R., Reinert, E., Sarewitz, D., Stark, P.B., Stirling, A., van der Sluijs, J. and Vineis, P. (2020) ‘Five ways to ensure that models serve society: a manifesto’, Nature, 582, pp. 482–484. Link
• Pianosi, F., Beven, K., Freer, J., Hall, J.W., Rougier, J., Stephenson, D.B. and Wagener, T. (2016) ‘Sensitivity analysis of environmental models: A systematic review with practical workflow’, Environmental Modelling & Software, 79, pp. 214–232. Link
• Iooss, B. and Lemaître, P. (2015) ‘A review on global sensitivity analysis methods’, in Dellino, G. and Meloni, C. (eds.) Uncertainty Management in Simulation-Optimization of Complex Systems. New York: Springer, pp. 101–122. Link
• Hamby, D.M. (1994) ‘A review of techniques for parameter sensitivity analysis of environmental models’, Environmental Monitoring and Assessment, 32, pp. 135–154. Link
• Morris, M.D. (1991) ‘Factorial sampling plans for preliminary computational experiments’, Technometrics, 33(2), pp. 161–174. Link
• Sobol, I.M. (1993) ‘Sensitivity estimates for nonlinear mathematical models’, Mathematical Modeling and Computational Experiment, 1, pp. 407–414. Link
• Helton, J.C., Johnson, J.D., Sallaberry, C.J. and Storlie, C.B. (2006) ‘Survey of sampling-based methods for uncertainty and sensitivity analysis’, Reliability Engineering & System Safety, 91(10–11), pp. 1175–1209. Link
• Oakley, J.E. and O’Hagan, A. (2004) ‘Probabilistic sensitivity analysis of complex models: a Bayesian approach’, Journal of the Royal Statistical Society: Series B, 66(3), pp. 751–769. Link
• National Research Council (2007) Models in Environmental Regulatory Decision Making. Washington, DC: The National Academies Press. Link
• National Research Council (2012) Assessing the Reliability of Complex Models: Mathematical and Statistical Foundations of Verification, Validation, and Uncertainty Quantification. Washington, DC: The National Academies Press. Link
• Beven, K. (2012) Rainfall-Runoff Modelling: The Primer. 2nd edn. Chichester: Wiley-Blackwell. Link
• Oreskes, N., Shrader-Frechette, K. and Belitz, K. (1994) ‘Verification, validation, and confirmation of numerical models in the earth sciences’, Science, 263(5147), pp. 641–646. 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

• Beven, K. (2012) Rainfall-Runoff Modelling: The Primer. 2nd edn. Chichester: Wiley-Blackwell. Link
• Hamby, D.M. (1994) ‘A review of techniques for parameter sensitivity analysis of environmental models’, Environmental Monitoring and Assessment, 32, pp. 135–154. Link
• Helton, J.C., Johnson, J.D., Sallaberry, C.J. and Storlie, C.B. (2006) ‘Survey of sampling-based methods for uncertainty and sensitivity analysis’, Reliability Engineering & System Safety, 91(10–11), pp. 1175–1209. Link
• Iooss, B. and Lemaître, P. (2015) ‘A review on global sensitivity analysis methods’, in Dellino, G. and Meloni, C. (eds.) Uncertainty Management in Simulation-Optimization of Complex Systems. New York: Springer, pp. 101–122. Link
• Morris, M.D. (1991) ‘Factorial sampling plans for preliminary computational experiments’, Technometrics, 33(2), pp. 161–174. Link
• National Research Council (2007) Models in Environmental Regulatory Decision Making. Washington, DC: The National Academies Press. Link
• National Research Council (2012) Assessing the Reliability of Complex Models: Mathematical and Statistical Foundations of Verification, Validation, and Uncertainty Quantification. Washington, DC: The National Academies Press. Link
• Oakley, J.E. and O’Hagan, A. (2004) ‘Probabilistic sensitivity analysis of complex models: a Bayesian approach’, Journal of the Royal Statistical Society: Series B, 66(3), pp. 751–769. Link
• Oreskes, N., Shrader-Frechette, K. and Belitz, K. (1994) ‘Verification, validation, and confirmation of numerical models in the earth sciences’, Science, 263(5147), pp. 641–646. Link
• Pianosi, F., Beven, K., Freer, J., Hall, J.W., Rougier, J., Stephenson, D.B. and Wagener, T. (2016) ‘Sensitivity analysis of environmental models: A systematic review with practical workflow’, Environmental Modelling & Software, 79, pp. 214–232. Link
• Saltelli, A., Bammer, G., Bruno, I., Charters, E., Di Fiore, M., Didier, E., Espeland, W.N., Kay, J., Lo Piano, S., Mayo, D., Pielke Jr, R., Portaluri, T., Porter, T.M., Puy, A., Rafols, I., Ravetz, J.R., Reinert, E., Sarewitz, D., Stark, P.B., Stirling, A., van der Sluijs, J. and Vineis, P. (2020) ‘Five ways to ensure that models serve society: a manifesto’, Nature, 582, pp. 482–484. Link
• Saltelli, A., Chan, K. and Scott, E.M. (eds.) (2000) Sensitivity Analysis. Chichester: Wiley. Link
• 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. Link
• Sobol, I.M. (1993) ‘Sensitivity estimates for nonlinear mathematical models’, Mathematical Modeling and Computational Experiment, 1, pp. 407–414. 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 ↑