a subnormal number
Imagine a ruler whose smallest marked tick is at, say, 0.001, with nothing at all between 0 and 0.001. If a measurement came out at 0.0003 you would be forced to round it brutally to either 0 or 0.001 — a big relative jolt. Floating-point faces the same cliff just above zero, and subnormal numbers are the extra fine ticks added inside that last gap so the fall to zero is gentle instead of abrupt.
Normalized numbers all have the form 1.f * 2^e, but the exponent e cannot go below a minimum, e_min. Subnormal (also called denormal) numbers use that minimum exponent while DROPPING the implicit leading 1, taking the form 0.f * 2^e_min. As the fraction's leading bits become zero, the value can shrink smoothly all the way down to the tiniest possible nonzero number, but at the cost of fewer and fewer significant bits — a subnormal trades precision for reach. This mechanism is called 'gradual underflow': instead of any value below the smallest normal collapsing straight to 0 (which would be 'flush to zero'), it degrades step by step.
Gradual underflow makes one property hold that programs quietly rely on: if x and y are different floating-point numbers, then x - y is never exactly 0, so the test 'if (x != y) compute 1/(x-y)' cannot blow up. Without subnormals, two distinct numbers could subtract to a true result smaller than the smallest normal and be flushed to 0. The practical caveat: on some hardware, computing with subnormals is dramatically SLOWER (the chip may trap to microcode), so performance-critical code sometimes enables 'flush-to-zero' mode — knowingly giving up the gentle landing for speed.
The smallest normalized double is about 2.225e-308. Below it the subnormals continue down to about 4.9e-324 (the smallest positive double), but a number like 1e-320 now carries only a handful of significant bits, not the usual ~16 digits. Multiplying two moderately small normals can land in this subnormal zone and silently lose precision.
Subnormals fill the last gap to zero — at the cost of precision.
Subnormals are not 'broken' tiny numbers — they are a deliberate feature giving gradual underflow. But they have reduced precision, and 'flush-to-zero' mode (common on GPUs) silently turns them all into 0.