Last reviewed: 2026-05-19

How Charterly checks calculator correctness

A calculator is only as useful as the trust the candidate places in its answer. Charterly is a free, independent companion for the TI BA II Plus and the HP 12C. Both calculator simulations and the device-specific mistake detectors are checked against a reference framework so the answers the candidate sees on screen match what the physical device would have shown.

This page gives the product-level version of that framework. It is specific enough to explain what Charterly checks without turning internal test files or release notes into public documentation.

The engine is deterministic and pure

The Charterly calculator engine is a set of pure functions: each function takes the current engine state plus user inputs and returns a new state. No network calls, no time-dependent logic, no random number generation, no side effects. Two runs with the same inputs return the same outputs to the bit.

This is enforced as a hard rule in the engineering brief. Telemetry and analytics live in the integration layer above the engine; the engine itself never observes them.

Decimal.js, not native floating-point

Every financial computation runs through Decimal.js full precision. Native JavaScript Number arithmetic is forbidden inside the engine. This matters for two reasons:

  1. Compounding chains do not drift. A 360-period mortgage amortization compounded through native floating-point can drift several cents from the device-faithful answer by the end. Decimal.js preserves arbitrary precision until the final display rounding.
  2. The displayed answer is reproducible. When the user's decimal-places setting is 4, the displayed value is exactly the Decimal.js value rounded to 4 places. The same problem on the physical BA II Plus returns the same displayed value because the physical device also rounds to the displayed setting from a higher-precision internal representation.

The user-facing decimal precision is a display setting. The engine's underlying precision is full and unchanged across decimal preferences.

The reference-case set

The engine is verified against a fixed set of reference cases that exercise every supported module: TVM, cash flows, bonds, amortization, depreciation, statistics, interest conversion, dates, and the advanced equity, options, and performance models. Each case records:

  • The inputs, such as TVM registers, cash-flow entries, and option parameters.
  • The setting state, such as decimal places, P/Y, payment mode, and arithmetic mode.
  • The expected outputs to the displayed precision.

Every change to the engine runs the full reference-case suite before release. A change that breaks a reference case is rejected unless the case itself is wrong, in which case the expected value is corrected and the rationale is recorded internally.

Parity with the physical device

The engine's parity target is 0.0001 of displayed value across the reference-case set, measured against the physical TI BA II Plus. The HP 12C engine shares the canonical TVM and cash-flow solvers with the TI engine, so on any problem that both calculators can solve, the two engines return identical answers to four decimals. This is what lets the device comparison page say candidly that the two calculators answer the same on any CFA question.

The mistake detector and the false-positive bar

Charterly's twelve named device-state rules (M1-M6 on the BA II Plus, H1-H6 on the HP 12C) are pure functions over a snapshot of engine state. Each detector either returns no warning or returns a structured warning with the rule, severity, and explanation.

The detectors are tuned to keep false positives under 2 percent per device. The current seeded checks have not produced unexpected detector fires, but the durable rule matters more than a one-time headline number: warnings should help candidates catch calculator-state mistakes without getting in the way of normal work.

When a detector fires, the warning is non-blocking. The calculator always computes and displays the result. The warning surfaces alongside the result so the candidate can correct the state before committing the answer. The candidate can dismiss the warning for the session, and warnings can be turned off globally from Settings, though we recommend leaving them on.

What is intentionally not promised

  • Not "more accurate" than the physical device. Charterly matches the physical device. The exam is graded against the physical device, so matching is the right target.
  • Not "AI-driven." The engine is pure deterministic code. AI is used for the explanation layer on practice questions, behind clear guardrails, and never to compute the answer itself.
  • Not a pass-rate claim. Charterly does not claim that using it improves CFA pass rates. The product reduces calculator-driven mistakes; the candidate's exam outcome depends on many things outside this tool.

Release checks

Before public engine or mistake-detector changes ship, Charterly reruns the checks that matter for candidate trust:

  • Reference cases must hold parity.
  • Mistake warnings must stay inside the false-positive bar.
  • Type checks, lint, unit tests, and calculator-page browser checks must pass.

These checks are part of the release workflow. When a result changes a user-facing claim, the page is updated with the new status.

Open verification

If you find a case where the displayed answer disagrees with the physical device, send the reproduction steps through Charterly support. Confirmed mismatches are added to the regression suite so the same case cannot silently return later.

Related pages