Error propagation calculator
Multiply 2 ± 0.1 by 3 ± 0.2 and you get 6 with a combined standard uncertainty of 0.5, plus the share each input adds. Sums, products, powers, square roots and logarithms all follow the same first-order rule. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
When a derived quantity is computed from measured inputs, each input's standard error contributes to the uncertainty of the result. First-order error propagation — the Gaussian or GUM linear approximation — combines those contributions through the partial derivatives of the formula. This error propagation calculator accepts an algebraic formula together with named values and their standard errors, evaluates the expression, and returns the result with the combined standard uncertainty under the usual assumption that the inputs are independent. Addition, products, quotients, powers, and common laboratory functions such as square root and logarithm sit in one contract, so you do not have to remember a different special-case identity for every experiment.
What first-order error propagation actually computes
Error propagation answers a laboratory question that a bare calculator never does: if each input is known only to a stated standard error, how large is the standard uncertainty on the number you just computed? The first-order Gaussian rule, which is also the linear term in the Guide to the Expression of Uncertainty in Measurement, linearizes the formula around the measured point and adds the independent contributions in quadrature.
Written out, the combined standard uncertainty is the square root of the sum of each partial derivative times the matching standard error, all squared. For a sum or difference the partials are plus or minus one, so the combined uncertainty is simply the root-sum-square of the input errors. For a product or quotient the same identity becomes the familiar relative-error combination.
For a power, a square root, or a logarithm the partial is no longer trivial, which is why a general formula engine is more honest than a pair of hardcoded product and sum buttons. This calculator evaluates the formula with forward-mode automatic differentiation so every supported operator and function contributes an exact first derivative rather than a finite-difference guess that depends on a hidden step size. Inputs are treated as uncorrelated: there is no covariance matrix, no Monte Carlo draw, and no second-order Hessian term.
That is the textbook first-order independent model used in undergraduate labs and in most LIMS uncertainty columns. Zero is allowed and means that input is treated as exact. The response reports the evaluated result, the combined uncertainty, optional relative and percent uncertainties when the result is not zero, and a per-variable breakdown of partials and variance contributions so you can see which measurement dominates the budget.
Input contract, supported formulas, and how errors are reported
At least one variable is required and the list is capped so a pasted notebook dump cannot run away. Supported syntax includes plus, minus, multiply, divide, caret or double-star power, parentheses, and implicit multiply such as two pi r or two a. Built-in constants are pi and e.
Built-in functions are sqrt, exp, ln, log (natural), log10, sin, cos, tan, abs, asin, acos, atan, and pow, with trigonometric arguments in radians. A classic product check is formula a times b with a equal to two plus or minus one tenth and b equal to three plus or minus two tenths: the result is six and the combined uncertainty is exactly one half, because the partials are three and two.
A density check m over v with mass ten plus or minus one tenth and volume two plus or minus five hundredths yields five with a combined uncertainty near one hundred thirty-five thousandths.
Where uncertainty propagation is most useful
Undergraduate physics, chemistry, and engineering labs ask students to quote a derived result with a combined uncertainty instead of copying only the central value from a calculator. Teaching platforms and exam generators need a deterministic oracle that marks a negative standard error as invalid rather than taking an absolute value and silently scoring a sloppy spreadsheet as correct. Analytical and calibration laboratories attach a first-order uncertainty to density, resistance, flow, and yield formulas inside LIMS or notebook jobs without standing up a computer-algebra system.
Quality and metrology teams compare which input dominates the variance contribution when they decide whether to buy a better balance or a better thermometer. Failed validation does not consume balance.
What you can do with it
Lab reports and homework keys
Students enter a formula plus each measured value and standard error to check the combined uncertainty against the first-order rule used in undergraduate physics and chemistry labs.
LIMS and notebook uncertainty columns
Attach a deterministic combined uncertainty to density, resistance, or yield formulas in laboratory information systems and analysis notebooks without a computer-algebra dependency.
Uncertainty-budget reviews
Inspect per-variable variance contributions to see which measurement dominates the combined uncertainty before buying a better instrument or repeating a run.
FAQ
How is the combined uncertainty computed?
Partials come from forward-mode automatic differentiation of the formula.
Are the input variables assumed to be independent?
Yes. Combined uncertainty is a root-sum-square of the individual (partial × standard error) terms. Correlated inputs and Monte Carlo propagation are out of scope for this landing.
Which formulas and functions are supported?
You can use + − * / ^, parentheses, implicit multiply, constants pi and e, and the functions sqrt, exp, ln, log, log10, sin, cos, tan, abs, asin, acos, atan, and pow. Trigonometric arguments are in radians.
How do I see which measurement dominates the uncertainty?
Look at the breakdown for each input, which lists its partial derivative and its contribution. In the example the second input adds 0.4 and the first 0.3, so a better measurement of the second helps most.
Can a standard error be zero?
Yes. Zero means that input is treated as exact, so it adds nothing to the combined uncertainty. Only negative standard errors are rejected, because a standard error is a width and cannot carry a sign.
Related tools
For developers — API access
Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.
API endpoint
Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, by email and from Telegram — and soon from our app too.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/stat/error-propagation \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"formula":"a*b","variables":[{"name":"a","value":2,"std_error":0.1},{"name":"b","value":3,"std_error":0.2}]}'const res = await fetch("https://api.kit.forhosting.com/stat/error-propagation", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"formula": "a*b",
"variables": [
{
"name": "a",
"value": 2,
"std_error": 0.1
},
{
"name": "b",
"value": 3,
"std_error": 0.2
}
]
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/stat/error-propagation",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"formula": "a*b",
"variables": [
{
"name": "a",
"value": 2,
"std_error": 0.1
},
{
"name": "b",
"value": 3,
"std_error": 0.2
}
]
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/stat/error-propagation", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"formula":"a*b","variables":[{"name":"a","value":2,"std_error":0.1},{"name":"b","value":3,"std_error":0.2}]}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"formula":"a*b","variables":[{"name":"a","value":2,"std_error":0.1},{"name":"b","value":3,"std_error":0.2}]}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/stat/error-propagation", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"formula": "a*b",
"variables": [
{
"name": "a",
"value": 2,
"std_error": 0.1
},
{
"name": "b",
"value": 3,
"std_error": 0.2
}
]
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "stat.error_propagation",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.
Pricing
Published price — no tokens, no invented credits. A failed task is never charged.
Limits
max_formula_len | 400 |
max_variables | 24 |
max_abs | 1000000000000000 |
Errors
| HTTP | Code | Meaning |
|---|---|---|
401 | unauthorized | Missing or invalid API key. |
402 | insufficient_balance | Your balance doesn't cover the task price. |
404 | unknown_type | That task type doesn't exist. |
429 | rate_limited | Too many requests. Use the webhook instead of polling. |
Technical notes
A negative standard error is rejected with invalid_input rather than being silently absolute-valued.
What first-order error propagation actually computes
If any standard error is negative the request is rejected, because a standard error is a non-negative width, not a signed residual.
Input contract, supported formulas, and how errors are reported
POST a JSON body with two required fields. formula is an algebraic expression whose identifiers match the names you will supply; aliases expression, expr, and f are accepted. variables is a list of records, each with name, value, and std_error, with aliases vars, inputs, and measurements for the list and error, se, sigma, or uncertainty for the standard-error cell. Missing fields, empty formulas, unknown identifiers, reserved function names used as variables, non-finite numbers, and any negative std_error fail with invalid_input naming the problem, and those failures are not billed. On success the body echoes the formula, returns result and combined_uncertainty as the primary pair, sets method to first_order_gaussian and independent to true, restates the quadrature identity, and lists every input with its partial derivative, absolute contribution, and variance contribution. Pair the JSON with your own significant-figure rounding if a report template demands a particular display; this endpoint keeps twelve decimal places so goldens and pipelines stay stable across JavaScript engines.
Where an error-propagation API earns its keep
Keep formulas short, name every identifier, and pin the rounded result and combined_uncertainty in tests, and you get reproducible uncertainty for homework, edge workers, and laboratory scripts without re-implementing the GUM linear rule in every language you ship.
Technical questions
What does the error propagation calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input, including a negative standard error, is not billed.
Why are negative standard errors rejected?
A standard error is a non-negative width. A negative value is almost always a sign error or a swapped residual, so the task fails with invalid_input instead of taking an absolute value.