Fixed-Point (Q Format) Converter

Standard formats

Format reference

Every bound is exact: the value of a Q-format word is raw ÷ 2ⁿ, and because the divisor is a power of two the decimal expansion always terminates. Nothing on this page is a rounded preview.

How Q format works

A fixed-point number is an ordinary integer with an agreed binary point. In Q15 the stored word raw represents raw ÷ 2^15, so the hardware only ever does integer arithmetic and the scaling lives entirely in your head - or, better, in a typedef. Addition and subtraction need no adjustment at all: two Q15 values add as plain int16s.

Multiplication does. Multiplying two Q15 values produces a Q30 result, so you widen into a double-width accumulator and shift back down by 15. Omitting that shift is the single most common fixed-point bug, and it shows up as a result that is off by a factor of 2^15 rather than as anything that looks like a rounding problem.

Because the point is fixed, precision does not vary across the range the way it does in floating point: every representable value is an exact multiple of 0.000030517578125, at the top of the range and the bottom alike. That predictability is why control loops and audio filters prefer it - the error budget is a constant you can reason about, not a function of the signal.

The Qm.n notation trap

There are two live conventions and they disagree by one bit. Texas Instruments writes Qm.n with m counting integer bits excluding the sign, so a signed Q15.16 is a 32-bit word. ARM and the CMSIS-DSP documentation count the sign bit inside m. Both are in current use, which is why a coefficient table copied from one vendor's app note into another's toolchain is off by a factor of two.

This tool avoids the argument by making you state the total word width and the fraction count directly, then showing the resulting name. When you hand a format to someone else, give them the same two numbers rather than the label - “16-bit signed, 15 fraction bits” cannot be misread.

Fixed point versus IEEE 754

Floating point moves the binary point per value, spending some bits on an exponent to buy enormous dynamic range at constant relative precision. Fixed point spends every bit on the value itself, giving constant absolute precision over a narrow range. For an audio sample that is always between -1 and +1, the exponent field of a float is pure waste - which is exactly why Q15 and Q31 exist.

The practical trigger is hardware. A Cortex-M0 or M3 has no FPU, so a float multiply is a software routine costing tens of cycles while a Q15 multiply is one MUL and one shift. If you are on a part with an FPU, use floats and stop thinking about it. If you are not, or you are writing a filter whose error budget has to be provable, fixed point is the right answer. The IEEE 754 converter shows the other side of the same trade.

Code Examples

#include <stdint.h>

#define Q15_FRAC 15
#define Q15_ONE  (1 << Q15_FRAC)

/* float -> Q15 with rounding and saturation */
int16_t to_q15(float x) {
    int32_t raw = (int32_t)(x * Q15_ONE + (x >= 0 ? 0.5f : -0.5f));
    if (raw >  32767) raw =  32767;
    if (raw < -32768) raw = -32768;
    return (int16_t)raw;
}

float from_q15(int16_t q) { return (float)q / Q15_ONE; }

/* Q15 * Q15 -> Q15: the >> 15 re-normalises the Q30 product */
int16_t mul_q15(int16_t a, int16_t b) {
    return (int16_t)(((int32_t)a * (int32_t)b) >> Q15_FRAC);
}

Frequently Asked Questions

Related Tools