TL;DR: A calculator is a small computer with three jobs: turn key presses into numbers, do arithmetic on them, and display the result. The arithmetic happens in binary logic circuits, the keys are scanned as a grid, and the display is driven by a dedicated controller. Modern calculators do the arithmetic in decimal-coded form rather than raw binary floating point, which is why 0.1 + 0.2 shows 0.3 on a calculator but not in many programming languages.
The three blocks
Every calculator, from a four-function model to a graphing device, decomposes into the same three functional blocks. Understanding them separately is the clearest way to understand the whole.
Input. The keypad is a matrix of switches. The processor cannot dedicate a wire to each key, so keys are arranged in rows and columns and scanned continuously — energise a row, read which columns respond, infer the key. That is why a damaged row trace kills a whole line of buttons at once.
Processing. A microcontroller runs a small program that maintains a running state: the current entry, a pending operation, and a stored operand. It calls the arithmetic unit for each operation.
Output. A display driver converts the internal value into segments or pixels. On a basic calculator that is a seven-segment LCD; on a graphing model it is a dot-matrix panel with a framebuffer.
How the arithmetic actually happens
At the circuit level, addition is done by logic gates. A half-adder combines two bits and produces a sum and a carry; chaining half-adders with carry handling produces a full adder, and chaining full adders produces a multi-bit adder.
Everything else is built from addition. Subtraction adds a negated value. Multiplication is repeated addition, usually accelerated by shifting and adding partial products. Division is repeated subtraction with remainder tracking.
That description applies to the hardware layer. The visible behaviour depends on what number format the calculator uses on top of it.
Why 0.1 + 0.2 works on a calculator
This is the most interesting part of the answer, because it explains a discrepancy people notice and cannot account for.
Most programming languages use binary floating point, where 0.1 has no exact representation — the same way one-third has no exact decimal representation. Adding two approximations produces a result that displays as 0.30000000000000004.
Calculator chips avoid this by working in binary-coded decimal, or BCD. Each decimal digit is stored in four bits, so 0.1 is stored as the digit 1 in the tenths position, exactly. Arithmetic proceeds digit by digit the way a person would do it on paper, with carries between decimal positions rather than binary ones.
The trade-off is that BCD uses more bits per digit and is slower for large computations. For a device whose entire purpose is displaying decimal results to a human, that trade is obviously correct — which is why the design has survived unchanged for decades.
Degrees, radians, and hidden modes
Scientific calculators hold state beyond the current number. The most consequential is the angle mode.
Trigonometric functions take an angle, and the same input means different things in degrees and radians. A calculator in the wrong mode returns a plausibly-sized but completely wrong answer — which is far more dangerous than an error message, because it looks correct.
The same applies to the number display mode: fixed, scientific, or engineering notation changes how a result is presented without changing its value. A student reading 1.5E3 as one and a half, rather than fifteen hundred, has misread a correct calculation.
Precision and rounding
A calculator displays far fewer digits than it computes internally. Most chips carry 10 to 15 significant digits and round the display to whatever the screen fits.
That is usually what you want, and occasionally it is not. Subtracting two nearly equal large numbers can leave a result with fewer meaningful digits than the display suggests, a problem called catastrophic cancellation. Chained calculations that round at every step accumulate error, which is why keeping intermediate values on the display, rather than copying rounded numbers, gives better answers.
The practical rule: treat everything past the tenth significant digit on a consumer calculator as unreliable, and expect statistical work at the edge of that range to be done in software with explicit precision control.
What is not a calculator
A phone calculator app is not a dedicated chip. It is software running on a general-purpose processor, using the platform’s floating-point hardware. That is why a phone calculator can show the 0.30000000000000004 artefact if it is implemented naively — and why good calculator apps deliberately mask it.
Spreadsheets are a third category: they use decimal arithmetic in some implementations and binary floating point in others, and the difference shows up in exactly the same place, at the boundary of representable values.
The short version
Three blocks: scanned keypad, programmed processor, display driver. Arithmetic is addition all the way down, but the decimal behaviour comes from BCD rather than binary floating point. Mode settings — angle, notation, rounding — cause more wrong answers than any arithmetic fault, because they fail silently.
If you want to check a specific calculation or explore how a function behaves across a range, an online calculator applies the same decimal arithmetic without the hidden-mode problem, since the settings are visible.
