Saúde
Fixed-point arithmetic
Texto da Wikipédia (en), licença CC BY-SA. O BETARUBI mostra o verbete inteiro nesta página — a leitura não continua fora do site.
In computing, fixed-point is a method of representing fractional (non-integer) numbers using an integer together with an implicit or explicit fixed scaling factor.[1] Dollar amounts, for example, may be represented with exactly two fractional decimal digits, corresponding to cents (1/100 of a dollar). More generally, fixed-point values can represent integer multiples of a fixed unit, such as a fraction of an hour represented as an integer number of seconds. Fixed-point representation is commonly contrasted with floating-point representation, in which the scale varies with an exponent.[2]
In fixed-point representation, the fractional part is often expressed in the same number base as the integer part, using negative powers of the base b. Common variants are decimal (base 10) and binary (base 2); power-of-two scaling is also called binary-point scaling.[1] Thus, if n fractional digits are stored, representable values are integer multiples of b−n. A scaling factor greater than one can likewise omit low-order integer digits, for example when values are represented in thousands.
When decimal fixed-point numbers are displayed for human reading, the fractional digits are usually separated from the integer part by a radix character. Internally, the radix point may be implicit: the stored integer and the associated scale together determine the represented value.[1]
Fixed-point arithmetic remains useful when a fixed range and resolution are appropriate, when exact decimal scaling is required, or when integer-based arithmetic is advantageous on a target platform.[2][3] It is widely encountered in digital signal processing, embedded systems, and hardware-oriented numerical implementations. Some microcontrollers provide dedicated fixed-point accelerators; for example, the STM32G4 CORDIC coprocessor operates on q1.15 and q1.31 fixed-point values.[4]
History
The underlying ideas of fixed-point representation long predate electronic computing. Positional number systems make the value of a digit depend on its position relative to a radix point. Donald Knuth, in his history of positional notation, distinguishes the highly developed Babylonian sexagesimal system of the second millennium BCE from fixed-point notation: because the scale of a Babylonian numeral was often inferred from context, he describes it as effectively a form of floating-point representation with the exponent omitted. Knuth identifies the Maya vigesimal system, used especially for calendars and astronomical records, as an early fixed-point positional notation.[5]
Fixed-radix notation subsequently developed through several mathematical traditions. Knuth traces the development of decimal positional notation in India to around the first millennium CE and notes early forms of positional decimal fractions in the work of the 10th-century mathematician al-Uqlīdisī. Decimal fractions were later developed by Jamshīd al-Kāshī in the 15th century and popularized in Europe by Simon Stevin's De Thiende in 1585.[5] The older sexagesimal tradition survives in the division of angles and time into minutes and seconds.[5]
The fixed placement of the radix point also became an explicit feature of mechanical calculation. Instructions for the Burroughs Calculator dating from 1918 describe a "fixed decimal point" that an operator could establish at a chosen position; one example places dollars to its left and cents and fractions of a cent to its right.[6] Fixed-point calculation was therefore already a practical technique in mechanical business machines before the development of electronic computers.
Early electronic digital computers commonly relied on fixed-point arithmetic. ENIAC, completed in the 1940s, used decimal fixed-point arithmetic, requiring programmers to manage the scale of quantities explicitly.[7] The EDSAC, developed at the University of Cambridge under Maurice Wilkes and first operated in 1949, represented values as either integers or fixed-point binary fractions; its multiplier treated fixed-point values as fractions between −1 and 1.[8] Work around EDSAC also contributed to early programming techniques and subroutine libraries, including routines for floating-point arithmetic.[8]
As computers developed, floating-point hardware provided an alternative in which the scale of a number could vary automatically over a much wider range. The IBM 704, introduced in the 1950s, was the first mass-produced computer with hardware floating-point arithmetic.[9] Fixed-point arithmetic nevertheless remained important in machines where hardware resources, execution time, or predictable numerical scaling favored integer-based computation.
A prominent example was the Apollo Guidance Computer (AGC), developed for the Apollo program. NASA described the Lunar Module guidance computer as a parallel, one's-complement, fixed-point general-purpose digital computer.[10] Its fixed word length and the wide range of values required for spacecraft navigation placed significant demands on numerical scaling and precision; Apollo guidance documentation discusses these constraints explicitly when describing the implementation of orbital calculations.[11]
Fixed-point arithmetic became particularly important in digital signal processors (DSPs), whose workloads repeatedly perform operations such as multiplication and accumulation on sampled signals. Early single-chip DSP development included the Bell Labs DSP-1 and the fixed-point NEC μPD7720 around 1979–1980.[12] In 1982, Texas Instruments introduced the TMS32010, the first fixed-point DSP in its TMS320 family; later generations included both fixed- and floating-point processors.[13] Fixed-point arithmetic continues to be used in embedded processors, signal-processing systems, graphics interfaces, and specialized hardware where its range, precision, and implementation characteristics suit the application.
Representation
| Value represented | Internal representation |
|---|---|
| 0.00 | 0 |
| 0.5 | 50 |
| 0.99 | 99 |
| 2 | 200 |
| −14.1 | −1410 |
| 314.160 | 31416 |
A fixed-point representation can be described as a stored integer interpreted through a fixed scaling factor.[1] For example, the value 1.23 can be stored as the integer 123 with a scaling factor of 1/100. This permits fixed-point operations to be implemented using integer arithmetic together with appropriate scaling.
Negative values are commonly represented in binary fixed-point formats using a signed integer in two's complement representation with an implicit scaling factor.[1][14] The sign of the value will always be indicated by the most significant bit (1 = negative, 0 = non-negative), even if the number of fraction bits is greater than or equal to the total number of bits. For example, the 8-bit signed binary integer (11110101)2 = −11, taken with −3, +5, and +12 implied fraction bits, would represent the values −11/2−3 = −88, −11/25 = −0.34375, and −11/212 = −0.002685546875, respectively.
A program will usually assume that all fixed-point values that will be stored into a given variable, or will be produced by a given instruction, will have the same scaling factor. This parameter can usually be chosen by the programmer depending on the precision needed and the range of values to be stored.
The scaling factor of a variable or expression may be implicit in the program's type information, interface, or implementation rather than encoded in the stored integer itself.
Choice of scaling factors
Power-of-two scaling is common in binary fixed-point systems because changing a binary-point position can be implemented efficiently with shifts or equivalent scaling operations.[1] Other scaling factors can be selected according to the quantities represented by an application; for example, a decimal scale of 1/100 can represent values in hundredths, while a scale of 1/3600 can represent fractions of an hour as integer numbers of seconds.
For a fixed-point type whose representable values are spaced by a scale or precision S, rounding to the nearest representable value introduces an error of at most S/2. A smaller spacing therefore provides finer absolute precision, provided the required range is still representable.[15]
For a fixed word length, increasing fractional precision reduces the available numerical range; scaling therefore determines a tradeoff between range and precision.[15] The maximum fixed-point value that can be stored into a variable is the largest integer value that can be stored into it, multiplied by the scaling factor, and similarly for the minimum value. For example, the table below gives the implied scaling factor S, the minimum and maximum representable values Vmin and Vmax, and the accuracy δ = S/2 of values that could be represented in 16-bit signed binary fixed point format, depending on the number f of implied fraction bits.
| f | S | δ | Vmin | Vmax |
|---|---|---|---|---|
| −3 | 1/2−3 = 8 | 4 | −262144 | 262136 |
| 0 | 1/20 = 1 | 0.5 | −32768 | +32767 |
| 5 | 1/25 = 1/32 | < 0.016 | −1024.00000 | +1023.96875 |
| 14 | 1/214 = 1/16384 | < 0.000031 | −2.00000000000000 | +1.99993896484375 |
| 15 | 1/215 = 1/32768 | < 0.000016 | −1.000000000000000 | +0.999969482421875 |
| 16 | 1/216 = 1/65536 | < 0.000008 | −0.5000000000000000 | +0.4999847412109375 |
| 20 | 1/220 = 1/1048576 | < 0.0000005 | −0.03125000000000000000 | +0.03124904632568359375 |
Exact values
Any binary fraction a/2m, such as 1/16 or 17/32, can be exactly represented in fixed-point, with a power-of-two scaling factor 1/2n with any n ≥ m.[16] However, most decimal fractions like 0.1 or 0.123 are infinite repeating fractions in base 2, and hence cannot be represented that way.
Similarly, any decimal fraction a/10m, such as 1/100 or 37/1000, can be exactly represented in fixed point with a power-of-ten scaling factor 1/10n with any n ≥ m. This decimal format can also represent any binary fraction a/2m, such as 1/8 (0.125) or 17/32 (0.53125).
More generally, fixed-point representations in base b finitely represent rational numbers whose reduced denominator divides a power of b.[16] Thus, in base 2 the denominator must be a power of 2, while in base 10 it can contain no prime factors other than 2 or 5.
Comparison with floating-point
For a fixed word length and scale, fixed-point values have constant absolute spacing between adjacent representable values. Increasing the number of fractional bits improves that absolute precision while reducing the representable range.[15] Floating-point formats instead use an exponent to provide a much wider dynamic range, with spacing that varies with magnitude.
Fixed-point arithmetic can be preferable on systems without efficient floating-point hardware, or where predictable scaling, low implementation cost, or deterministic integer-based arithmetic is important.[2][3] These advantages are application- and implementation-dependent rather than universal.
Fixed-point implementations must explicitly account for finite range, quantization, rounding, and overflow. Overflow behavior may wrap or saturate depending on the arithmetic system, while rounding occurs whenever an exact result cannot be represented at the selected scale.[15][17] Choosing word lengths and scaling factors is therefore an important part of fixed-point design.
Applications
Fixed-point arithmetic is used when a predetermined numerical scale is useful for the problem or implementation. Common examples include exact decimal quantities, digital signal processing, embedded and real-time systems, graphics, and specialized numerical hardware.[2]
Financial and decimal arithmetic
Decimal fixed-point arithmetic is commonly used for monetary values and other quantities expressed in fixed decimal units. It avoids representing decimal subdivisions such as cents through binary floating-point approximations. For example, the open-source money-management application GnuCash switched from floating-point to fixed-point arithmetic in version 1.6 to improve control over monetary rounding.[18]
Exact decimal arithmetic remains common in database and business software. SQL defines exact numeric types such as NUMERIC and DECIMAL, and database systems including PostgreSQL implement them for exact decimal storage and arithmetic.[19]
Digital signal processing and embedded systems
Binary fixed-point arithmetic has long been associated with digital signal processing, where algorithms operate on sampled audio, communications, image, radar, and other signal data.[2][12] DSP architectures have often provided multiplication, accumulation, scaling, rounding, and saturation operations suited to fixed-point computation.
Fixed-point processing remains present in modern microcontrollers and accelerators. The STM32G4 series, for example, includes a CORDIC coprocessor whose inputs and outputs can use q1.15 or q1.31 fixed-point formats.[4]
Graphics and multimedia
Fixed-point interfaces have been used in computer graphics where floating-point hardware could not be assumed. The OpenGL ES 1.1 specification includes the OES_fixed_point extension, which defines a signed S15.16 fixed-point representation for platforms without efficient floating-point support.[20]
Fixed-point arithmetic has also been used in audio codecs, image-processing software, fonts, and game engines. These uses commonly exploit predictable integer arithmetic or target hardware on which floating-point computation is limited or comparatively expensive.
Operations
Addition and subtraction
To add or subtract two values with the same implicit scaling factor, it is sufficient to add or subtract the underlying integers;[21] the result has the same scaling factor. The mathematical result is represented exactly provided that it lies within the destination format's range; otherwise overflow handling depends on the arithmetic environment.
If the operands have different scaling factors, then they must be converted to a common scaling factor before the operation.
Multiplication
To multiply two fixed-point numbers, the underlying integers can be multiplied while the result scale is derived from the operand scales.[21]
- (p/q) * (r/s) = pr/qs
The result will be exact, with no rounding, provided that it does not overflow the receiving variable. (Specifically, with integer multiplication, the product is up to twice the width of the two factors.)
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. As another example, multiplying the first number by 155 implicitly scaled by 1/32 (155/32 = 4.84375) yields the integer 123×155 = 19065 with implicit scaling factor (1/1000)×(1/32) = 1/32000, that is 19065/32000 = 0.59578125.
In binary, it is common to use a scaling factor that is a power of two. After the multiplication, the scaling factor can be divided away by shifting right. Shifting is simple and fast in most computers.
When rescaling requires discarding low-order bits or digits, the result may require rounding. The rounding rule depends on the arithmetic environment; for example, signed integer division in modern C truncates toward zero.[22] Fixed-point systems may instead use rounding modes such as rounding toward zero, rounding toward positive or negative infinity, rounding to the nearest representable value, or convergent (round-to-even) rounding.[17] The choice of rounding rule affects the quantization error introduced by the operation.
Division
Division requires accounting for both the stored integers and their scaling factors. If the represented values are pR and qS, where p and q are stored integers and R and S are their scales, then
A fixed-point implementation therefore chooses a scale for the result and rescales the integer quotient accordingly. Additional precision is often retained in an intermediate value before division so that integer truncation does not discard all fractional information.[21]
For example, if a = 1.23 is represented as 123 with scale 1/100 and b = 6.25 is represented as 6250 with scale 1/1000, directly dividing the stored integers gives 123÷6250 = 0 and loses the useful fractional result. Rescaling the dividend to 1,230,000 with scale 1/1,000,000 before the integer division gives 1,230,000÷6250 ≈ 197, which at scale 1/1000 represents approximately 0.197. The exact quotient is 0.1968.
Scaling conversion
Fixed-point values sometimes need to be converted between scaling factors, for example before arithmetic on operands with different scales or when storing a result in a destination format with a prescribed scale.[21]
If a value is represented by the stored integer x with scaling factor R, then representing the same value with scaling factor S requires a stored value corresponding to xR/S. When R/S is not an integer, the converted value must be rounded to a representable integer. The conversion can also overflow if the destination format does not have sufficient range.[21][17]
For binary fixed-point formats whose scaling factors are powers of two, some scale conversions can be implemented using shifts. Right shifts that discard bits can require rounding, while left shifts can overflow if the destination does not provide sufficient range.[21]
Conversion to and from floating-point
Conversion between fixed-point and floating-point representations requires applying or removing the fixed-point scaling factor. Conversion to a fixed-point format may require rounding and can overflow if the value lies outside the destination range. Conversion to floating point may likewise be inexact when the floating-point format cannot represent the scaled integer exactly.[1][17]
Hardware support
Fixed-point arithmetic can be implemented with ordinary integer instructions, with scaling handled through multiplication, division, or shifts. Power-of-two scaling is particularly convenient in binary arithmetic because a change in binary-point position corresponds to multiplication or division by a power of two.[1]
Some processor and accelerator architectures provide operations useful for fixed-point workloads, such as widening multiplication, arithmetic shifts, rounding, and saturation. Dedicated hardware may also define specific fixed-point formats. For example, the STM32G4 CORDIC coprocessor supports q1.15 and q1.31 inputs and outputs.[4]
Overflow
Overflow occurs when a result lies outside the representable range of the destination format. Fixed-point systems may handle overflow by wrapping modulo the storage width or by saturation, which clamps a result to the largest or smallest representable value.[15] The appropriate behavior depends on the arithmetic environment and application.
Computer language support
Some programming languages provide explicit fixed-point data types. PL/I, for example, defines both FIXED BINARY and FIXED DECIMAL data, with precision and scale specified as part of the type.[23] Ada also provides fixed-point types whose representation and range are controlled by type declarations.[24]
ISO/IEC TR 18037, Extensions to support embedded processors, specifies fixed-point type families for C including _Fract and _Accum, together with saturating variants.[14] GCC implements these fixed-point types as an extension on supported targets; its documentation notes that not all targets support them.[25]
SQL defines exact numeric types such as NUMERIC and DECIMAL. Database systems including PostgreSQL implement these types for exact decimal storage and arithmetic.[19]
Notations
Various notations have been used to concisely specify the parameters of a fixed-point format. 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 (0/1 or some other alternative representation), and b the total number of bits.
- The Q notation was defined by Texas Instruments.[26] One writes
Qfto specify a signed binary fixed-point value with f fraction bits; for example,Q15specifies a signed integer in two's complement notation with a scaling factor 1/215. The codeQm.fspecifies additionally that the number has m bits in the integer part of the value, not counting the sign bit. ThusQ1.30would describe a binary fixed-point format with 1 integer bit and 30 fractional bits, which could be stored as a 32-bit 2's complement integer with scaling factor 1/230.[26][27]- A similar notation has been used by ARM, except that they count the sign bit in the value of m; so the same format above would be specified as
Q2.30.[28][29] - The Embedded C proposal uses .f for unsigned fraction. s.f for signed fraction, m.f for unsigned accumulator, and sm.f for signed accumulator. This would translate the above to
s1.30, though this is not a valid type for either fraction or accumulator: in valid versions, m is at least 4 and depending on the underlying type f is at least 7, 15, or 23. Note the non-italicized s: it is simply prepended as a letter.[14]
- A similar notation has been used by ARM, except that they count the sign bit in the value of m; so the same format above would be specified as
- The COBOL programming language originally supported decimal fixed-precision with arbitrary size and decimal scaling, whose format was specified "graphically" with the PIC directive. For example,
PIC S9999V99specified a sign-magnitude 6-digit decimal integer with two decimal fraction digits.[30] - The construct
REAL FIXED BINARY (p,f)is used in the PL/I programming language, to specify a fixed-point signed binary data type with p total bits (not including sign) with f bits in the fraction part; that is a p+1 bit signed integer with a scaling factor of 1/2f. The latter could be positive or negative. One could specify COMPLEX instead of REAL, and DECIMAL instead of BINARY for base 10.[23] - In the Ada programming language, a numeric data type can be specified by, for example,
type F is delta 0.005 range -50.0 .. 50.0. The decimal bounds are translated to the next power of two, hence it means a fixed-point representation consisting of a signed binary integer in two's complement format with at least 8 fraction bits (providing a scaling factor 1/256) and 7 sign-and-magnitude bits (ensuring an actual range from −64.00 to almost +64.00): a minimum total of 15 bits. On a 16-bit computer, the spare bit is assigned to the fractional part. Asymmetrical range constraints are also allowed,[24] though the underlying implementation remains symmetric about 0.[31] Newer versions of Ada allow specifying an exact (including non-power-of-two) scaling factor using'Small => 0.005(aspect specification), or, if the factor is a power of 10, through a decimal fixed point. - LabVIEW represents fixed-point types using an encoding (signed or unsigned), a total word length, and an integer word length; these parameters determine the range and fractional precision of the value.[32]
Examples in software and hardware
- TrueType uses fixed-point numeric formats in parts of its instruction and font-data representation.[33]
- The Apollo Guidance Computer used fixed-point arithmetic for real-time guidance and navigation during the Apollo missions.[10][11]
- Early fixed-point digital signal processors included the NEC μPD7720 and Texas Instruments TMS32010.[12][13]
- The STM32G4 CORDIC coprocessor supports q1.15 and q1.31 fixed-point formats.[4]
- OpenGL ES 1.1 includes an
OES_fixed_pointextension using an S15.16 representation.[20] - The WavPack lossless audio compressor uses fixed-point arithmetic; its technical documentation cites deterministic behavior across platforms as one motivation.[34]
- Fractint uses fixed-point arithmetic in performance-sensitive code for older processors.[35]
- GCC supports the Embedded C fixed-point types on some targets.[25]
See also
- A-law algorithm
- Block floating-point scaling
- Libfixmath - a library written in C for fixed-point math
- Logarithmic number system
- Minifloat
- Modulo operation
- Q (number format)
- Rational data type
- μ-law algorithm
References
- 1 2 3 4 5 6 7 8 "Scaling, Range, and Precision of Fixed-Point Data Types". MathWorks. Retrieved 2026-08-21.
- 1 2 3 4 5 Padgett, Wayne T.; Anderson, David V. (2009). Fixed-Point Signal Processing. Synthesis Lectures on Signal Processing. Morgan & Claypool Publishers. doi:10.2200/S00220ED1V01Y200909SPR009. ISBN 978-1-59829-258-9.
- 1 2 "Fixed-Point Real Numbers". ISO/IEC JTC1/SC22/WG21. 2019. Retrieved 2026-08-21.
- 1 2 3 4 "STM32G4 series advanced Arm-based 32-bit MCUs: Reference manual" (PDF). STMicroelectronics. CORDIC coprocessor. Retrieved 2026-08-21.
- 1 2 3 Knuth, Donald E. (1997). "Positional Number Systems". The Art of Computer Programming. Vol. 2: Seminumerical Algorithms (3rd ed.). Addison-Wesley. ISBN 978-0-201-89684-8.
- ↑ The Burroughs Calculator: Instructions for Operating (PDF). Burroughs Adding Machine Company. 1918. Fixed Decimal Point. Retrieved 2026-08-21.
- ↑ "ENIAC". A Third Survey of Domestic Electronic Digital Computing Systems. Ballistic Research Laboratories. Numerical system. Retrieved 2026-08-21.
- 1 2 "EDSAC Architecture". University of Cambridge Computer Laboratory. Retrieved 2026-08-21.
- ↑ "The IBM 704". Columbia University. Retrieved 2026-08-21.
- 1 2 "Apollo News Reference: Lunar Module Guidance, Navigation, and Control" (PDF). NASA. LM Guidance Computer. Retrieved 2026-08-21.
- 1 2 Apollo Guidance, Navigation and Control (PDF) (Report). June 1968. section 5.5. Retrieved 2026-08-21.
- 1 2 3 "1979: Single Chip Digital Signal Processor Introduced". Computer History Museum. Retrieved 2026-08-21.
- 1 2 "TMS320 Family Overview". TMS320F/C24x DSP Controllers CPU and Instruction Set Reference Guide (PDF). Texas Instruments. Retrieved 2026-08-21.
- 1 2 3 "Extensions to support embedded processors" (PDF). ISO/IEC JTC1/SC22/WG14. 2006. N1169. Retrieved 2026-08-21.
- 1 2 3 4 5 "Scaling, Range, and Precision". MathWorks. Retrieved 2026-08-21.
- 1 2 Hehner, Eric C. R.; Horspool, R. Nigel (May 1979). "A New Representation of the Rational Numbers for Fast Easy Arithmetic". SIAM Journal on Computing. 8 (2): 124–134. doi:10.1137/0208011.
- 1 2 3 4 "Quantization". MathWorks. Retrieved 2026-08-21.
- ↑ "What's New?". GnuCash. Retrieved 2025-09-10.
- 1 2 "Numeric Types". PostgreSQL Documentation. PostgreSQL Global Development Group. Retrieved 2026-08-21.
- 1 2 "OpenGL ES Common Profile Specification, Version 1.1" (PDF). Khronos Group. OES_fixed_point extension. Retrieved 2026-08-21.
- 1 2 3 4 5 6 "Recommendations for Arithmetic and Scaling". MathWorks. Retrieved 2026-08-21.
- ↑ "Proposal to require signed integer division to truncate toward zero". ISO/IEC JTC1/SC22/WG14. 1996. N617. Retrieved 2026-08-21.
- 1 2 "Enterprise PL/I for z/OS Language Reference" (PDF). IBM. Binary fixed-point data. Retrieved 2026-08-21.
- 1 2 Ada 83 documentation: "Rationale, 5.3.2: Fixed Point Types". Accessed on 2021-07-05.
- 1 2 "Fixed-Point Types". Using the GNU Compiler Collection. Free Software Foundation. Retrieved 2026-08-21.
- 1 2 "Appendix A.2". TMS320C64x DSP Library Programmer's Reference (PDF). Dallas, Texas, USA: Texas Instruments Incorporated. October 2003. SPRU565. Archived (PDF) from the original on 2022-12-22. Retrieved 2022-12-22.
- ↑ "MathWorks Fixed-Point Toolbox Documentation Glossary". mathworks.com. Archived from the original on 2011-03-16. Retrieved 2011-01-28.
- ↑ "ARM Developer Suite AXD and armsd Debuggers Guide". 1.2. ARM Limited. 2001 [1999]. Chapter 4.7.9. AXD > AXD Facilities > Data formatting > Q-format. ARM DUI 0066D.
{{cite web}}: CS1 maint: deprecated archival service (link) - ↑ "Chapter 4.7.9. AXD > AXD Facilities > Data formatting > Q-format". RealView Development Suite AXD and armsd Debuggers Guide (PDF). 3.0. ARM Limited. 2006 [1999]. pp. 4–24. ARM DUI 0066G. Archived (PDF) from the original on 2017-11-04.
- ↑ IBM Corporation, "Numeric items". Online documentation site, accessed on 2021-07-05.
- ↑ "Fixed Point Types".
- ↑ "Configuring Input and Output Terminals of the High Throughput Math Functions". National Instruments. Retrieved 2026-08-21.
- ↑ "The TrueType Instruction Set: Data types". 2020-09-22.
- ↑ "WavPack Technical Description". www.wavpack.com. Retrieved 2015-07-13.
- ↑ "Fractint, A Little Code". Archived from the original on 2010-10-27. Retrieved 2005-10-24.
Further reading
- Warren, Jr., Henry S. (2013). Hacker's Delight (2 ed.). Addison Wesley / Pearson Education, Inc. ISBN 978-0-321-84268-8.
External links
