Scientific Calculator

Degrees divide a circle into 360 parts, a convention inherited from Babylonian astronomy and kept because 360 divides neatly by so many numbers. Radians define an angle by the arc it subtends on a unit circle, which makes a full turn 2π rather than a round number.

Radians look inconvenient and are the natural unit for anything analytical. The derivative of sin(x) is cos(x) only when x is in radians; in degrees a conversion factor appears and everything downstream gets uglier. Every programming language's trig functions take radians for this reason.

The practical rule: use degrees for geometry, surveying, navigation and construction, where angles are measured with instruments. Use radians for calculus, physics, signal processing and anything you will hand to code.

To convert, multiply degrees by π/180, or radians by 180/π. Useful anchors: 30° is π/6, 45° is π/4, 60° is π/3, 90° is π/2, 180° is π.

A logarithm answers the question: what power do I raise the base to, in order to get this number? log₁₀(1000) is 3, because 10³ is 1000.

The convention on calculators is that "log" means base 10 and "ln" means base e — the natural logarithm, where e is about 2.71828. Confusing them is a factor of 2.303 out, which is large enough to notice and small enough to miss.

Base 10 suits anything expressed in orders of magnitude: pH, decibels, the Richter scale, and any quantity spanning many powers of ten. The natural logarithm suits anything growing or decaying continuously — compound interest, radioactive decay, population models — because e is the base at which a quantity's rate of change equals its own size.

For any other base, use the change-of-base rule: log_b(x) = ln(x) / ln(b). So log₂(1000) is ln(1000)/ln(2) = 9.97.

Logarithms are only defined for positive numbers. There is no real power of 10 that produces zero or a negative, so log(0) and log(−5) are domain errors rather than very large negative numbers — a calculator that returns "-Infinity" for log(0) is reporting a limit, not a value.

Computers store numbers in binary, and one tenth in binary is a repeating fraction in exactly the way one third is in decimal. It has to be truncated, so 0.1 is stored as a value very slightly off, and errors of that size accumulate through a calculation.

The classic demonstration is 0.1 + 0.2, which in raw double-precision arithmetic gives 0.30000000000000004. Squaring 0.1 gives 0.010000000000000002.

This is not a defect in any particular calculator — it is inherent to binary floating point and affects every language and every spreadsheet. What calculators do is round the display to fewer digits than they store, which hides the dust.

Two practical consequences. First, never test two floating-point results for exact equality; compare the difference against a small tolerance instead. Second, when a result should be a clean number and shows a trailing 000000004, that is representation error, not a real quantity — and it is why sin(180°) shows 0 here rather than 1.2 × 10⁻¹⁶.

Doubles carry about 15 to 17 significant decimal digits. Beyond that the digits are noise, which is why results are rounded to twelve significant figures before display.

Factorial (!) —

defined only for non-negative integers. 0! is 1 by convention, not by accident — it is the number of ways to arrange nothing. 170! is the largest that fits in a double; 171! overflows to infinity.

Square root —

of a negative number has no real value. The answer is imaginary, which a real-number calculator cannot represent.

Tangent —

undefined at 90° and every 180° after it, where cosine is zero and the ratio blows up. Floating point returns an enormous finite number there rather than an error, which is misleading enough to be worth catching.

Percent (%) —

on this calculator divides by 100, so 50% becomes 0.5. Some calculators make it context-sensitive, computing 200 + 10% as 220. Neither is wrong, but they are different, so check which one you are using before relying on it.