Hello !

Differences

This shows you the differences between two versions of the page.

--- en:multiasm:cs:chapter_3_11 [2026/02/08 17:33] – [Integers] ktokarz
+++ en:multiasm:cs:chapter_3_11 [2026/02/19 20:54] (current) – jtokarz
@@ Line 1: / Line 1: @@
+====== Fundamentals of Data Encoding, Big Endian, Little Endian ======
+The processor can work with different types of data. These include integers of different sizes, floating-point numbers, text, structures, and even single bits. All this data is stored in the memory as a single byte or multiple bytes.
+===== Integers =====
+Integer data types can be 8, 16, 32 or 64 bits long. If the encoded number is unsigned, it is stored in binary representation, while if the value is signed, the representation is two's complement. A natural binary number range starts with zero. In such a case, it contains all bits equal to zero. While it contains all bits equal to one, the value can be calculated with the expression\\
+{{:en:multiasm:cs:equation_binary.png?100 |}},\\ \\
+where n is the number of bits in a number.
+In two's complement representation, the most significant bit (MSB) represents the sign of the number. Zero means a non-negative number; one represents a negative value. The table {{ref>binarynumbers}} shows the integer data types with their ranges.
+<table binarynumbers>
+<caption> Integer binary numbers</caption>
+^ Number of bits  ^ Minimum value (hexadecimal)  ^ Maximum value (hexadecimal)  ^ Minimum value (decimal)     ^ Maximum value (decimal)     ^
+| 8               | 0x00                         | 0xFF                         | 0                           | 255                         |
+| 8 signed        | 0x80                         | 0x7F                         | -128                        | 127                         |
+| 16              | 0x0000                       | 0xFFFF                       | 0                           | 65 535                      |
+| 16 signed       | 0x8000                       | 0x7FFF                       | -32 768                     | 32 767                      |
+| 32              | 0x0000 0000                  | 0xFFFF FFFF                  | 0                           | 4 294 967 295               |
+| 32 signed       | 0x8000 0000                  | 0x7FFF FFFF                  | -2 147 483 648              | 2 147 483 647               |
+| 64              | 0x0000 0000 0000 0000        | 0xFFFF FFFF FFFF FFFF        | 0                           | 18 446 744 073 709 551 615  |
+| 64 signed       | 0x8000 0000 0000 0000        | 0x7FFF FFFF FFFF FFFF        | -9 223 372 036 854 775 808  | 9 223 372 036 854 775 807   |
+</table>
+===== Floating point =====
+Integer calculations do not always cover all mathematical requirements of the algorithm. To represent real numbers, the floating-point encoding is used. A floating point is the representation of the value //A//, which is composed of three fields:
+  * Sign bit
+  * Exponent (E)
+  * Mantissa (M)
+fulfilling the equation\\
+{{:en:multiasm:cs:equation_floating.png?100 |}}.\\
+There are two main types of real numbers, called floating-point values. Single precision is a number which is encoded in 32 bits. A double-precision floating-point number is encoded with 64 bits. They are presented in Fig{{ref>realtypes}}.
+<figure realtypes>
+{{:en:multiasm:cs:floating_numbers.png?600 |Illustration of a single and double precision real numbers}}
+<caption>Illustration of a single and double precision real numbers </caption>
+</figure>
+The Table{{ref>realnumbers}} shows a number of bits for exponent and mantissa for single and double precision floating point numbers. It also presents the minimal and maximal values which can be stored using these formats (they are absolute values, and can be positive or negative depending on the sign bit).
+<table realnumbers>
+<caption> Floating point numbers</caption>
+^ Precision        ^ Exponent  ^ Mantissa  ^ The smallest                             ^ The largest                              ^
+| Single (32 bit)  | 8 bits    | 23 bits   | {{ :en:multiasm:cs:min_fp_32.png?105 }}  | {{ :en:multiasm:cs:max_fp_32.png?100 }}  |
+| Double (64 bit)  | 11 bits   | 52 bits   | {{ :en:multiasm:cs:min_fp_64.png?120 }}  | {{ :en:multiasm:cs:max_fp_64.png?100 }}  |
+</table>
+The most common representation for real numbers on computers is standardised in the document IEEE Standard 754. Two features have been implemented to make the calculations easier for computers:
+  * the Biased exponent,
+  * the Normalised Mantissa.
+A biased exponent means that the bias value is added to the real exponent value. This results in all positive exponents, which makes it easier to compare numbers.
+The normalised mantissa is adjusted to have only one bit of the value "1" to the left of the decimal. It requires an appropriate exponent adjustment.
+===== Texts =====
+Texts are represented as a series of characters. In modern operating systems, texts are encoded using two-byte Unicode, which is capable of encoding not only 26 basic letters but also language-specific characters of many different languages. In simpler computers, like in embedded systems, 8-bit ASCII codes are often used. Every byte of the text representation in the memory contains a single ASCII code of the character. It is quite common in assembler programs to use the zero value (NULL) as the end character of the string, similar to the C/C++ null-terminated string convention.
+===== Endianness =====
+Data encoded in memory must be compatible with the processor. Memory chips are usually organised as a sequence of bytes, which means that every byte can be individually addressed. For processors of the class higher than 8-bit, there appears to be an issue with the byte order in bigger data types. There are two possibilities:
+  - Little Endian - low-order byte is stored at a lower address in the memory.
+  - Big Endian - the high-order byte is stored at a lower address in the memory.
+These two methods for a 32-bit class processor are shown in Fig{{ref>littlebigendian}}
+<figure littlebigendian>
+{{ :en:multiasm:cs:little_big_endian.png?600 |Illustration of Little and Big Endian data placement in the memory}}
+<caption>Illustration of Little and Big Endian data placement in the memory</caption>
+</figure>

en/multiasm/cs/chapter_3_11.txt · Last modified: 2026/02/19 20:54 by jtokarz