HomeCalculatorsMathNumerical CalculusTwo-Sided Limit Calculator
Math calculator

Two-Sided Limit Calculator

Numeric two-sided limit of a polynomial, sin, or exp at a finite x. Same engine as Numerical Derivative. Not one-sided. Not L’Hôpital. Not a second engine. Runs locally.

Instant result
Result
—

Enter values to calculate.

Inputs—
Mode—
Formula—
Trust summary CVP VERIFIED · CVP protocol 1.0.0-proposed · Core assurance · all published methods
Input interpretation
Enter values to calculate.
Result
—
Verified scope
all published methods
Assurance
Core
Declared partition coverage
PASS · 7/7 declared partitions (tiny-step, subnormal-exp, central, forward, backward, limit, invalid-domain) · Matrix
Known limitations
  • Core CVP does not include live graph, viewport, or pointer interaction.
Model
Numeric two-sided limit of poly, sin, or exp at a finite x, with an engine-linked figure of f around x.
Scope
The Result Card includes an engine-linked figure of f around x (horizontal at the two-sided probe). Same engine as /numerical-derivative. Not symbolic CAS lim. Not one-sided. Not L’Hôpital.
Verification
Engine tested · Source checked · v1.1.4 · CVP VERIFIED · CVP protocol 1.0.0-proposed · Core assurance · all published methods· View Manifest · CVP overview · Specification
Versions
Calculation 1.1.4 · CVP protocol 1.0.0-proposed · Evidence 2026-10-28.metric-scope-v3
Verification revision
2026-10-28.metric-scope-v3 · 1/1 property · digest 2f8a7989f6c9
Legacy regression
14/14 tests · Production surface contract 6/6
Trust layers
Verification VERIFIED · Production CURRENT · Overall CVP state: VERIFIED under CVP 1.0.0-proposed
Reference
O1 model · O2 expected_values · O2 numerical_behavior
Interfaces
PASS · UI (SSR) / REST / MCP — ui-ssr is query-result HTML, not a live browser session. Error-path engine·REST·MCP 3/3 (status, code, calculation_version). SSR compared on URL-canonical requested calculations; empty query is idle (not an error) and JSON-typed object/array inputs are REST/MCP-only. Raw HTTP REST/JSON-RPC transport rejection 5/5; raw-number source and conflicting pins are transport-only checks, not engine/SSR input-source parity.
Supplemental domain review
Not performed
Named expert review
Not performed
CVP suite
255/255 golden · 2/2 CVP boundary · 16/16 invalid · 1/1 property · 2/2 metamorphic · 16/16 cross-interface · 1/1 cross-calculator · 6/6 CVP contract · Manifest
Sources
Sources
Evidence
4 legacy golden · 3 legacy boundary · legacy regression suite · 255/255 oracle-backed golden · 16/16 invalid · Artifact integrity PASS
This calculator CURRENT · Public schema 1.1.4 matches · Semantic contract ✓ · Production attested · Public/cache ✓ · Origin ✓
Semantic contract
PASS
Full verification

Manifest identity, reference classes, interfaces, suite, and production records.

Formulas

Core equations used by this calculator.

Two-sided probe[f(x+h) + f(x−h)] / 2
Exact (continuous f)lim_{t→x} f(t) = f(x)
iSame engine as /numerical-derivative. Not one-sided left/right. Not x→∞. Not L’Hôpital. Not symbolic CAS. Default h = 10⁻⁶. Degree ≤ 8.

How to use

1

Choose f and x

Poly needs coeffs (constant first). sin and exp are f(t)=sin t and eᵗ. Finite x only.

2

Read the two-sided value

Left and right probes are shown. Finite-difference derivatives stay on /numerical-derivative.

Example calculations

Common configurations with formula and result.

ϟ

x² at 3

coeffs 0,0,1

lim = 9
9
ϟ

sin at 0

two-sided

sin 0
0

Two-Sided Limit calculator specification

Version 1.1.4 · Engine tested

Calculation status

Review policy · Evidence

Definition
lim_{t→x} f(t) is estimated by [f(x+h)+f(x−h)]/2. This page is method=limit on math.numerical.derivative. Polynomial, sin, and exp are continuous, so the exact check is f(x). Not a second engine. Not one-sided. Not L’Hôpital. Not a CAS.
What it calculates
Numeric two-sided limit of poly, sin, or exp at a finite x, with an engine-linked figure of f around x.
Inputs
  • integrand
  • x
  • h?
  • coeffs?
Outputs
  • value
  • exact
  • abs_err
  • left
  • right
  • gap
Formula
[f(x+h) + f(x−h)] / 2
Assumptions
  • The Result Card includes an engine-linked figure of f around x (horizontal at the two-sided probe). Same engine as /numerical-derivative. Not symbolic CAS lim. Not one-sided. Not L’Hôpital.
  • Not one-sided left/right
  • Not L’Hôpital
  • Not x→∞
  • Polynomial degree ≤ 8
Units
  • dimensionless
Boundary conditions
  • exp(x) underflow to zero → NUMERICAL_RANGE_ERROR
  • Non-finite function probes, derivative or error → NUMERICAL_RANGE_ERROR
  • h ≤ 0 → VALUE_MUST_BE_POSITIVE
  • h > 1 → VALUE_OUT_OF_RANGE
  • unknown method (including left, right, lhopital, autodiff, cas) → INVALID_MODE
Example
method=limit integrand=poly coeffs=0,0,1 x=3 → 9
Validation cases

2 published on this page · 14/14 tests · Production surface contract 6/6 · View evidence

  • method=limit integrand=poly coeffs=0,0,1 x=3 → exact=9
  • method=left integrand=sin x=0 → INVALID_MODE
Sources
Calculation version
1.1.4

Background

Interpretation and common distinctions.

What does this two-sided limit calculator compute?

lim_{t→x} f(t) is estimated by [f(x+h)+f(x−h)]/2.

The published formula or method is [f(x+h) + f(x−h)] / 2. The following references support the stated mathematics or method:

  • Gilbert Strang, Calculus — Chapter 2: Derivatives (MIT OpenCourseWare): Two-sided and one-sided limits, continuity, and functions whose limits do not exist. Finite numerical samples alone are not proof of a mathematical limit; CalculatorX’s sampling limitations are stated separately. Mathematical reference only; not implementation validation or an endorsement of CalculatorX.

Which inputs and limits should you check?

A finite step gives a numerical estimate. Very small steps can amplify roundoff, while large steps introduce truncation error; finite samples alone do not prove an arbitrary limit.

The worked example uses coeffs 0,0,1 with lim = 9. Compare it with the Example calculations and the complete result for the same inputs.

How can you verify and cite this result?

CalculatorX is responsible for this page. The mathematical references above explain the model; implementation checks and their scope are documented separately in the math.numerical.derivative v1.1.4 Evidence and capability contract. Read the displayed verification and production state together with the specification's numerical limits.

Use the clean calculator URL to cite the tool. A shared input link identifies a particular calculation. Content updates, numerical verification, and domain reviews have separate dates and scopes.

Input precision, finite-step meaning and privacy

Use finite decimal numbers or decimal text for x and h. Nonzero decimal underflow is rejected, never changed to zero. Missing h uses 0.000001; an explicitly empty h remains an error. h must satisfy 0<h≤1. Polynomial input is 2–9 constant-first coefficients, degree at most8; constants use c0,0. Method/function/coefficient aliases must agree. Two-Sided Limit locks method=limit.

The primary value is the requested finite-step approximation, not the analytic derivative. Polynomial x±h uses mathematical sums of the supplied binary64 values with exact dyadic intermediates; stable sin/exp identities also retain h when a binary64 node would round to x. A finite sample does not prove an arbitrary limit. Nonzero primary value/baseline underflow and nonfinite probes/results are rejected. Probe, gap and signed error diagnostics are rounded binary64 and may quantize to zero; subnormal outputs have coarse relative precision.

The historical exact field is a binary64 analytic baseline. abs_err is the signed difference of the published approximation and baseline, not an absolute error or certified bound. Values publish12 significant digits; this does not guarantee12 digits of accuracy for arbitrary h. The complete result includes method/function, x/h, polynomial coefficients, value/baseline/error/formula, and left/right/gap for limit. At unsupported graphic scales a figure may be omitted while the numeric result is retained.

Ordinary form calculations run locally without an account. JSON and CSV retain full inputs, results and calculation version. A shared query URL sends its parameters to the server when opened and may appear in server or third-party logs. Workspace fragments are recomputed from inputs; stored result claims are ignored.

Other calculators in this family: Brent Method Calculator, Definite Integral Calculator, Euler Method Calculator, Gauss Quadrature Calculator, Golden Section Search Calculator, Nonlinear Equation Calculator, Numerical Derivative Calculator, Numerical Interpolation Calculator . Explore all Numerical Calculus.

→ Brent Method Calculator Brent’s method (golden section plus inverse parabolic interpolation) for a minimum of a polynomial, sin, or exp on [a, b]. Same engine as One-Dimensional Optimization. Not root-finding Brent. Runs locally. › → Definite Integral Calculator Composite trapezoid, Simpson 1/3, or Gauss–Legendre of a polynomial, sin, or exp on [a, b]. Not indefinite symbolic integrate. Runs locally. › → Euler Method Calculator Forward Euler for a scalar first-order IVP y′=f(t,y). Same engine as Ordinary Differential Equation. Not RK4, not rk45, not a system. Runs locally. › → Gauss Quadrature Calculator n-point Gauss–Legendre quadrature of a polynomial, sin, or exp on [a, b]. Same engine as Definite Integral. Not indefinite CAS. Runs locally. › → Golden Section Search Calculator Golden-section search for a minimum of a polynomial, sin, or exp on [a, b]. Same engine as One-Dimensional Optimization. Not Brent, not multivariate. Runs locally. › → Nonlinear Equation Calculator Solve a polynomial or sin x for one approximate real zero using Newton, bisection, or secant. Inspect the residual and stopping reason. Calculate locally. › → Numerical Derivative Calculator Finite-difference derivative of a polynomial, sin, or exp, plus a numeric two-sided limit. Central, forward, backward, or limit. Discovery /two-sided-limit. Not symbolic d/dx. Runs locally. › → Numerical Interpolation Calculator Piecewise-linear, Lagrange, or natural cubic spline of tabulated (x, y). Not regression, not CAS. Runs locally. ›

Frequently asked questions

Key distinctions behind the calculation.

Is this a second derivative engine?

No. It is method=limit on math.numerical.derivative, the same engine as /calc/math/numerical-derivative. Forward / backward / central differences stay on that page.

Do you ship one-sided limits or L’Hôpital?

No. method=left, method=right, and method=lhopital are INVALID_MODE. This page is the two-sided numeric probe only. Not a CAS.

Where does this run?

Locally in the browser by default. REST and MCP call the same derivative engine.