Fixed-point number - Revision history

Aoineko: /* Langage C */

2025-10-17T22:47:20Z

‎Langage C

Aoineko: /* Full list */

2025-10-17T22:43:14Z

‎Full list

Aoineko at 22:42, 17 October 2025

2025-10-17T22:42:52Z

Aoineko: /* Qm.n format */

2025-10-17T22:42:35Z

‎Qm.n format

Aoineko: /* Qm.n format */

2025-10-17T22:40:53Z

‎Qm.n format

Aoineko at 22:37, 17 October 2025

2025-10-17T22:37:32Z

Aoineko: /* Langage C */

2025-10-17T22:30:14Z

‎Langage C

Aoineko at 11:39, 11 April 2024

2024-04-11T11:39:52Z

Aoineko: /* Format Qm.n */

2024-04-11T10:11:31Z

‎Format Qm.n

Aoineko at 10:04, 11 April 2024

2024-04-11T10:04:42Z

@@ Line 177: / Line 177: @@
 * Q1:7 : 26 ts
-== Langage C ==
+== C Language ==
-Et pour les utilisateurs de C, il est conseillé de passer par des macros de conversion.
+For C users, it is recommended to use conversion macros.
-Par ex. :
+For example:
 <syntaxhighlight lang="c">
 // Unit conversion (Pixel <> Q10.6)
@@ Line 188: / Line 188: @@
 </syntaxhighlight>
-On laisse les multiplications/divisions par 64 pour permettre au compilateur de pouvoir adapter ses opérations en fonction du type de data qu'on lui donne.
+We leave the multiplications/divisions by 64 to allow the compiler to optimize operations based on the data type provided.
-Si on prend une variable int16 x qui contient un nombre au format Q10.6, on peux faire ce genre d'opérations :
+If we have an int16 x variable containing a number in Q10.6 format, we can perform operations like this:
 <syntaxhighlight lang="c">
 #define PI PX_TO_UNIT(3.14159265f) // Le compilateur va faire la conversion en float, puis convertir en int (précision optimale)
@@ Line 198: / Line 198: @@
 </syntaxhighlight>
-L'autre gros avantage, c'est qu'on peux ainsi changer la précision de son unité sans devoir retoucher tout son code.
+The other major advantage is that you can change the precision of your unit without having to rewrite all your code.

@@ Line 49: / Line 49: @@
 === Full list ===
-Here is the set of possible Qm.n formats for 8 and 16-bit integers, with their precision values and bounds:
+Here is the complete set of possible Qm.n formats for 8- and 16-bit integers, with their precision values and bounds:
 <img src="https://msxvillage.fr/upload/qm_n.png" style="width:800px;"/>

@@ Line 28: / Line 28: @@
 Thus, Q7.8 ⇒ 1-bit sign, 7-bit integer, 8-bit fractional.
-===== Examples ===
+=== Examples ===
 There are as many Q formats as there are bit combinations.

@@ Line 28: / Line 28: @@
 Thus, Q7.8 ⇒ 1-bit sign, 7-bit integer, 8-bit fractional.
-=== Examples ===
+===== Examples ===
-There are as many Qs as there are bit combinations.
+There are as many Q formats as there are bit combinations.
 Here are a few examples I use:
-* Q2.6 : 8-bit integer for encoding digits between -1.0 and 1.0 with a precision of 0.015625. Very useful for storing direction vectors, for example.
+* Q2.6: 8-bit integer for encoding values between -1.0 and 1.0 with a precision of 0.015625. Very useful for storing direction vectors, for example.
-* Q8.8 : 16-bit integer with 8-bit integer and fractional parts. Very efficient when used with an unsigned number. Otherwise, a few precautions should be taken.
+* Q8.8: 16-bit integer with 8 bits each for the integer and fractional parts. Very efficient when used with unsigned numbers. Otherwise, some precautions are needed.
-* Q6.10 : 16-bit integer with 6-bit integer part and 10-bit fractional part. Allows data to be manipulated in KB (with a factor of 1024). Useful for small numbers requiring very high precision (~0.001).
+* Q6.10: 16-bit integer with a 6-bit integer part and a 10-bit fractional part. Allows data to be manipulated in KB (with a factor of 1024). Useful for small numbers requiring very high precision (~0.001).
 === Conversion ===
-Of course, you can switch from one Q format to another by simply shifting bits.
+You can switch between Q formats by simply shifting bits.
 For example:
@@ Line 45: / Line 45: @@
 * Q8.8 >> 4 ⇒ Q12.4
-Note: In the case of a negative signed value, it's a little more complicated as the sign must be preserved.
+Note: For negative signed values, it’s a bit more complicated because the sign must be preserved.
 === Full list ===

@@ Line 15: / Line 15: @@
 == Qm.n format ==
-Since division/multiplication by 100 is costly, we'll instead use factors to the power of 2 (1, 2, 4, 8, 16, etc.) as the basis for the fractional part.
+Since division/multiplication by 100 is computationally expensive, we instead use powers of 2 (1, 2, 4, 8, 16, etc.) as the basis for the fractional part.
-As a result, divisions/multiplications can be replaced by bit shifts, which are incomparably less costly.
+As a result, divisions/multiplications can be replaced with bit shifts, which are far less costly.
-On an 8 or 16-bit integer (32-bits are often too expensive for our Z80s), we'll decide how many bits will be used to code the integer part and which bits (the remainder) will be used to code the fractional part.
+For an 8- or 16-bit integer (32-bit is often too expensive for our Z80s), we decide how many bits will encode the integer part and how many bits (the remainder) will encode the fractional part.
-This is the Q format! Or rather the "Qm.n" format: "m" is the number of bits for the integer part and "n" the number of bits for the fractional part (cf. [https://en.wikipedia.org/wiki/Q_(number_format) "Q" article on Wikipedia]).
+This is the Q format! Or more precisely, the "Qm.n" format: "m" is the number of bits for the integer part, and "n" is the number of bits for the fractional part (see the [https://en.wikipedia.org/wiki/Q_(number_format) "Q" article on Wikipedia]).
-For example, an 8-bit number coded in Q4.4 format uses 4-bits for the integer and 4-bits for the fraction.
+For example, an 8-bit number in Q4.4 format uses 4 bits for the integer part and 4 bits for the fractional part.
-To convert a final unit value to Q4.4, simply shift the number 4 times to the left (<tt>x << 4</tt>), To convert a Q4.4 to a final unit value, simply shift the number 4 times to the right (<tt>x >> 4</tt>).
+To convert a final unit value to Q4.4, simply shift the number 4 places to the left (x << 4). To convert a Q4.4 value back to the final unit, shift the number 4 places to the right (x >> 4).
-If used to store an unsigned number, a Q4.4 can encode numbers from 0 to 15.9375 (255/16) with a precision of 0.0625 (1/16).
+If used to store an unsigned number, Q4.4 can encode values from 0 to 15.9375 (255/16) with a precision of 0.0625 (1/16).
 Q4.4 can be used for any basic mathematical operation, as long as all terms are in the same format.
-Note that for signed integers, some exclude the sign bit in the notation.
+Note that for signed integers, some notations exclude the sign bit.
-As a result, Q7.8 ⇒ 1-bit sign, 7-bit integer, 8-bit fractional.
+Thus, Q7.8 ⇒ 1-bit sign, 7-bit integer, 8-bit fractional.
 === Examples ===

@@ Line 1: / Line 1: @@
-A fixed-point number is simply a real number (e.g. 3.14) that is encoded onto an integer by applying a factor (a multiplier).
+A fixed-point number is simply a real number (e.g., 3.14) that is encoded as an integer by applying a factor (a multiplier).
-The aim is to be able to manipulate numbers with a precision of less than 1, while keeping good performance of integer processing.
+The aim is to manipulate numbers with a precision of less than 1, while maintaining the performance benefits of integer processing.
 == Principe ==
-To understand the principle, just imagine a program that needs the meter as its final unit, but at some point needs to be able to move an object of less than one unit, say 0.2 m (20 cm).
+To understand the principle, imagine a program that uses meters as its final unit but needs to move an object by less than one unit, say 0.2 m (20 cm).
-Since it would be far too heavy for our venerable MSX to work with real floating-point numbers (like C's <tt>float</tt>), the trick might simply be to store the numbers and do the calculations in centimeter (cm = meters * 100), then convert to meters when necessary (meters = cm / 100).
+Since working with real floating-point numbers (like C's float) would be too resource-intensive for our venerable MSX, the trick is to store numbers and perform calculations in centimeters (cm = meters × 100), then convert back to meters when necessary (meters = cm / 100).
-So, to add 0.2 m, we'd add the integer value 0.2 * 100 (= 20).
+So, to add 0.2 m, you would add the integer value 0.2 × 100 (= 20).
-Conversely, the integer 4213 would actually represent 42.13 m.
+Conversely, the integer 4213 would represent 42.13 m.
-Such a format would be a fixed-point number with 2 decimal places (100).
+This format is a fixed-point number with 2 decimal places (100).
 == Qm.n format ==

@@ Line 15: / Line 15: @@
 == Format Qm.n ==
-Since division/multiplication by 100 is costly, we'll instead use factors to the power of 2 (1, 2, 4, 8, 16, etc.) as the basis for the fractional part. As a result, divisions/multiplications can be replaced by bit shifts, which are incomparably less costly.
+Since division/multiplication by 100 is costly, we'll instead use factors to the power of 2 (1, 2, 4, 8, 16, etc.) as the basis for the fractional part.
 On an 8 or 16-bit integer (32-bits are often too expensive for our Z80s), we'll decide how many bits will be used to code the integer part and which bits (the remainder) will be used to code the fractional part.
-This is the Q format! Or rather "Qm.n" (cf. [https://en.wikipedia.org/wiki/Q_(number_format) "Q" article on Wikipedia]).
+This is the Q format! Or rather the "Qm.n" format: "m" is the number of bits for the integer part and "n" the number of bits for the fractional part (cf. [https://en.wikipedia.org/wiki/Q_(number_format) "Q" article on Wikipedia]).
-Par ex., un nombre 8-bits codé au format Q4.4, utilise 4-bits pour l’entier et 4-bits pour la fraction. Pour convertir une valeur en Q4.4, il suffit de décaler le nombre 4 fois vers la gauche (x << 4), Pour convertir un Q4.4 en valeur, il suffit de décaler le nombre 4 fois vers la droite (x >> 4). Si on l’utilise pour stocker un nombre non signé, on pourra coder dans un Q4.4 des nombres allant de 0 à 15,9375 (255/16) avec une précision de 0,0625 (1/16).
+For example, an 8-bit number coded in Q4.4 format uses 4-bits for the integer and 4-bits for the fraction. To convert a final unit value to Q4.4, simply shift the number 4 times to the left (<tt>x << 4</tt>), To convert a Q4.4 to a final unit value, simply shift the number 4 times to the right (<tt>x >> 4</tt>). If used to store an unsigned number, a Q4.4 can encode numbers from 0 to 15.9375 (255/16) with a precision of 0.0625 (1/16).
-On peut utiliser avec le Q4.4 n’importe quelles opérations mathématiques de base tant que tous les termes sont au même format.
+Q4.4 can be used for any basic mathematical operation, as long as all terms are in the same format.
 A noter que pour les entiers signés, certains excluent le bit de signe dans la notation.