Frequent Links
Fixedpoint arithmetic
In computing, a fixedpoint number representation is a real data type for a number that has a fixed number of digits after (and sometimes also before) the radix point (after the decimal point '.' in English decimal notation). Fixedpoint number representation can be compared to the more complicated (and more computationally demanding) floatingpoint number representation.
Fixedpoint numbers are useful for representing fractional values, usually in base 2 or base 10, when the executing processor has no floating point unit (FPU) or if fixedpoint provides improved performance or accuracy for the application at hand. Most lowcost embedded microprocessors and microcontrollers do not have an FPU.
Contents
Representation
A value of a fixedpoint data type is essentially an integer that is scaled by an implicit specific factor determined by the type. For example, the value 1.23 can be represented as 1230 in a fixedpoint data type with scaling factor of 1/1000, and the value 1,230,000 can be represented as 1230 with a scaling factor of 1000. Unlike floatingpoint data types, the scaling factor is the same for all values of the same type, and does not change during the entire computation.
The scaling factor is usually a power of 10 (for human convenience) or a power of 2 (for computational efficiency). However, other scaling factors may be used occasionally, e.g. a time value in hours may be represented as a fixedpoint type with a scale factor of 1/3600 to obtain values with onesecond accuracy.
The maximum value of a fixedpoint type is simply the largest value that can be represented in the underlying integer type multiplied by the scaling factor; and similarly for the minimum value. For example, consider a fixedpoint type represented as a binary integer with b bits in two's complement format, with a scaling factor of 1/2^{f} (that is, the last f bits are fraction bits): the minimum representable value is −2^{b−1}/2^{f} and the maximum value is (2^{b−1}−1)/2^{f}.
Operations
To convert a number from a fixed point type with scaling factor R to another type with scaling factor S, the underlying integer must be multiplied by R and divided by S; that is, multiplied by the ratio R/S. Thus, for example, to convert the value 1.23 = 123/100 from a type with scaling factor R=1/100 to one with scaling factor S=1/1000, the underlying integer 123 must be multiplied by (1/100)/(1/1000) = 10, yielding the representation 1230/1000. If S does not divide R (in particular, if the new scaling factor S is greater than the original R), the new integer will have to be rounded. The rounding rules and methods are usually part of the language's specification.
To add or subtract two values of the same fixedpoint type, it is sufficient to add or subtract the underlying integers, and keep their common scaling factor. The result can be exactly represented in the same type, as long as no overflow occurs (i.e. provided that the sum of the two integers fits in the underlying integer type). If the numbers have different fixedpoint types, with different scaling factors, then one of them must be converted to the other before the sum.
To multiply two fixedpoint numbers, it suffices to multiply the two underlying integers, and assume that the scaling factor of the result is the product of their scaling factors. This operation involves no rounding. For example, multiplying the numbers 123 scaled by 1/1000 (0.123) and 25 scaled by 1/10 (2.5) yields the integer 123×25 = 3075 scaled by (1/1000)×(1/10) = 1/10000, that is 3075/10000 = 0.3075. If the two operands belong to the same fixedpoint type, and the result is also to be represented in that type, then the product of the two integers must be explicitly multiplied by the common scaling factor; in this case the result may have to be rounded, and overflow may occur. For example, if the common scaling factor is 1/100, multiplying 1.23 by 0.25 entails multiplying 123 by 25 to yield 3075 with an intermediate scaling factor of 1/10000. This then must be multiplied by 1/100 to yield either 31 (0.31) or 30 (0.30), depending on the rounding method used, to result in a final scale factor of 1/100.
To divide two fixedpoint numbers, one takes the integer quotient of their underlying integers, and assumes that the scaling factor is the quotient of their scaling factors. The first division involves rounding in general. For example, division of 3456 scaled by 1/100 (34.56) and 1234 scaled by 1/1000 (1.234) yields the integer 3456÷1234 = 3 (rounded) with scale factor (1/100)/(1/1000) = 10, that is, 30. One can obtain a more accurate result by first converting the dividend to a more precise type: in the same example, converting 3456 scaled by 1/100 (34.56) to 3,456,000 scaled by 1/100000, before dividing by 1234 scaled by 1/1000 (1.234), would yield 3456000÷1234 = 2801 (rounded) with scaling factor (1/100000)/(1/1000) = 1/100, that is 28.01 (instead of 30). If both operands and the desired result are represented in the same fixedpoint type, then the quotient of the two integers must be explicitly divided by the common scaling factor.
Binary vs. decimal
The two most common classes of fixedpoint types are decimal and binary. Decimal fixedpoint types have a scaling factor that is a power of ten; for binary fixedpoint types it is a power of two.
Binary fixedpoint types are most commonly used, because the rescaling operations can be implemented as fast bit shifts. Binary fixedpoint numbers can represent fractional powers of two exactly, but, like binary floatingpoint numbers, cannot exactly represent fractional powers of ten. If exact fractional powers of ten are desired, then a decimal format should be used. For example, onetenth (0.1) and onehundredth (0.01) can be represented only approximately by binary fixedpoint or binary floatingpoint representations, while they can be represented exactly in decimal fixedpoint or decimal floatingpoint representations. These representations may be encoded in many ways, including BCD.
Notation
There are various notations used to represent word length and radix point in a binary fixedpoint number. In the following list, f represents the number of fractional bits, m the number of magnitude or integer bits, s the number of sign bits, and b the total number of bits.
 Qf: The "Q" prefix. For example, Q15 represents a number with 15 fractional bits. This notation is ambiguous since it does not specify the word length, however it is usually assumed that the word length is either 16 or 32 bits depending on the target processor in use.^{[1]}
 Qm.f: The unambiguous form of the "Q" notation. Since the entire word is a 2's complement integer, a sign bit is implied. For example, Q1.30 describes a number with 1 integer bit and 30 fractional bits stored as a 32bit 2's complement integer.^{[1]}^{[2]}
 fxm.b: The "fx" prefix is similar to the above, but uses the word length as the second item in the dotted pair. For example, fx1.16 describes a number with 1 magnitude bit and 15 fractional bits in a 16 bit word.^{[3]}
 s:m:f: Yet other notations include a sign bit, such as this one used in the PS2 GS User's Guide.^{[4]} It also differs from conventional usage by using a colon instead of a period as the separator. For example, in this notation, 0:8:0 represents an unsigned 8bit integer.
Precision loss and overflow
Because fixed point operations can produce results that have more bits than the operands, there is possibility for information loss. For instance, the result of fixed point multiplication could potentially have as many bits as the sum of the number of bits in the two operands. In order to fit the result into the same number of bits as the operands, the answer must be rounded or truncated. If this is the case, the choice of which bits to keep is very important. When multiplying two fixed point numbers with the same format, for instance with <math>I</math> integer bits, and <math>Q</math> fractional bits, the answer could have up to <math>2I</math> integer bits, and <math>2Q</math> fractional bits.
For simplicity, many fixedpoint multiply procedures use the same result format as the operands. This has the effect of keeping the middle bits; the Inumber of least significant integer bits, and the Qnumber of most significant fractional bits. Fractional bits lost below this value represent a precision loss which is common in fractional multiplication. If any integer bits are lost, however, the value will be radically inaccurate. Some modelbased fixedpoint packages^{[5]} allow you to specify a result format different from the input formats. This allows you to maximize precision and avoid overflow.
Some operations, like divide, often have builtin result limiting so that any positive overflow results in the largest possible number that can be represented by the current format. Likewise, negative overflow results in the largest negative number represented by the current format. This built in limiting is often referred to as saturation.
Some processors support a hardware overflow flag that can generate an exception on the occurrence of an overflow, but it is usually too late to salvage the proper result at this point.
Modern development cycles include a prototyping phase which examines the potential precision loss and overflow of designs using fixed point calculations before proceeding to physical prototyping.^{[6]}
Implementations
Very few computer languages include builtin support for fixed point values, because for most applications, binary or decimal floatingpoint representations are usually simpler to use and accurate enough. Floatingpoint representations are easier to use than fixedpoint representations, because they can handle a wider dynamic range and do not require programmers to specify the number of digits after the radix point. However, if they are needed, fixedpoint numbers can be implemented even in programming languages like C and C++, which do not commonly include such support.
A common use of fixedpoint BCD numbers is for storing monetary values, where the inexact values of binary floatingpoint numbers are often a liability. Historically, fixedpoint representations were the norm for decimal data types; for example, in PL/I or COBOL. The Ada programming language includes builtin support for both fixedpoint (binary and decimal) and floatingpoint. JOVIAL and Coral 66 also provide both floating and fixedpoint types.
ISO/IEC TR 18037^{[7]} specifies fixedpoint data types for the C programming language; vendors are expected to implement the language extensions for fixed point arithmetic in coming years. Fixedpoint support is implemented in GCC.^{[8]}^{[9]}
Almost all relational databases, and the SQL query language, support fixedpoint decimal arithmetic and storage of numbers. PostgreSQL has a special numeric type for exact storage of numbers with up to 1000 digits.^{[10]}
Other
 libfixmath is a recent opensource library for the manipulation of fixed point numbers,^{[11]} it currently supports Q16.16 and Q0.32 formats and provides an interface similar to math.h.
 GnuCash is an application for tracking money which is written in C. It switched from a floatingpoint representation of money to a fixedpoint implementation as of version 1.6. This change was made to trade the less predictable rounding errors of floatingpoint representations for more control over rounding (for example, to the nearest cent).
 Tremor, Toast and MAD are software libraries which decode the Ogg Vorbis, GSM Full Rate and MP3 audio formats respectively. These codecs use fixedpoint arithmetic because many audio decoding hardware devices do not have an FPU (partly to save money, but primarily to save power  integer units are much smaller in silicon area than an FPU) and audio decoding requires performance to the extent a software implementation of floatingpoint on lowspeed devices would not produce output in real time.
 All 3D graphics engines on Sony's original PlayStation, Sega's Saturn, Nintendo's Game Boy Advance (only 2D), Nintendo DS (2D and 3D), Nintendo Gamecube^{[12]} and GP2X Wiz video game systems use fixedpoint arithmetic for the same reason as Tremor and Toast: to gain throughput on an architecture without an FPU.
 The OpenGL ES 1.x specification includes a fixed point profile, as it is an API aimed for embedded systems, which do not always have an FPU.
 TeX font metric files use 32bit signed fixedpoint numbers, with 12 bits to the left of the decimal, extensively.
 The dc and bc programs are arbitrary precision calculators, but only keep track of a (userspecified) fixed number of fractional digits.
 VisSim A visually programmed block diagram language supporting a fixedpoint block set to allow simulation and automatic code generation of fixedpoint operations. Both word size and radix point can be specified on an operator basis.
 Fractint represents numbers as Q2.29 fixedpoint numbers,^{[13]} to speed up drawing on old PCs with 386 or 486SX processors, which lacked an FPU.
 Doom was the last firstperson shooter title by id Software to use a 16.16 fixed point representation for all of its noninteger computations, including map system, geometry, rendering, player movement etc. This was done in order for the game to be playable on 386 and 486SX CPUs without an FPU. For compatibility reasons, this representation is still used in modern Doom source ports.
 SystemC provides signed and unsigned fixed point data types.
See also
 Binary scaling
 Q (number format)
 Libfixmath  a library written in C for fixedpoint math
 Floatingpoint arithmetic
References
 ^ ^{a} ^{b} Texas Instruments, TMS320C64x DSP Library Programmer's Reference, Appendix A.2
 ^ MathWorks FixedPoint Toolbox Documentation Glossary
 ^ VisSim FixedPoint Toolbox
 ^ PS2 GS User's Guide, Chapter 7.1 "Explanatory Notes"
 ^ VisSim FixedPoint User Guidehttp://www.vissim.com/downloads/doc/EmbeddedControlsDeveloper_UGv80.pdf
 ^ Equalis Fixed Point Module documentation.
 ^ JTC1/SC22/WG14, status of TR 18037: Embedded C
 ^ GCC wiki, FixedPoint Arithmetic Support
 ^ Using GCC, section 5.13 FixedPoint Types
 ^ PostgreSQL manual, section 8.1.2. Arbitrary Precision Numbers
 ^ libfixmath, The project page
 ^ http://dolphinemu.org/blog/2014/03/15/pixelprocessingproblems/
 ^ Fractint, A Little Code
External links
40x40px  The Wikibook Floating Point has a page on the topic of: FixedPoint Numbers 
 FixedPoint Arithmetic  An Introduction Representing and implementing fixedpoint arithmetic in digital signal processing, by Randy Yates
 A Calculated Look at FixedPoint Arithmetic at the Wayback Machine (archived June 11, 2002)
 A Calculated Look at FixedPoint Arithmetic (PDF)
 Working with floating point parameters in an integer world How to represent floating point values in a fixed point processor, by Dinu Madau
 Fixed Point Representation And Fractional Math
40x40px  The Wikibook Embedded Systems has a page on the topic of: FixedPoint Arithmetic 
 Cladlab: FixedPoint Mathematics Using fixedpoint numbers on an embedded system
