Algorithm and Data Structure Interview Guide - Digital Coding

digital encoding

Original code, inverse code and complement code

In the table in the previous section, we found that all integer types can represent one more negative number than positive numbers. For example, the bytevalue range of is $[-128,127]$ . This phenomenon is relatively counter-intuitive, and its intrinsic reason involves the knowledge of original code, inverse code, and complement code.

First of all, it needs to be pointed out that numbers are stored in computers in "complement" form . Before analyzing the reasons for this, we first give the definitions of the three.

• Original code : We consider the highest bit of the binary representation of a number as the sign bit, where $0$ represents a positive number,$1$ represents a negative number and the remaining bits represent the value of the number.
• One 's complement code : The one's complement of a positive number is the same as its original code. The one's complement of a negative number is the inversion of all bits of its original code except the sign bit.
• Two's complement : The complement of a positive number is the same as its original code, and the complement of a negative number is the complement of its complement plus $1$ 。

The figure below shows the conversion method between original code, one's complement code and one's complement code.

Although the "original true form" is the most intuitive, it has some limitations. On the one hand, the original code of negative numbers cannot be directly used in operations . For example, calculate 1 + ( − 2 ) 1 + (-2) under the original code$1+(-2)$ , the result is$-3$ , which is obviously wrong.

$$\begin{array}{rl}& 1+(-2)\\ & \to 00000001+10000010\\ & =10000011\\ & \to -3\end{array}$$

In order to solve this problem, computers introduced "1's complement code". If we first convert the original code into one's complement, and calculate 1 + ( − 2 ) 1 + (-2) under its complement$1+(-2)$ , and finally convert the result from the complement code back to the original code, then the correct result can be obtained$-1$ 。

$$\begin{array}{rl}& 1+(-2)\\ & \to 00000001\text{( original code )}+10000010\text{( original code )}\\ & =00000001\text{( reverse code )}+11111101\text{( reverse code )}\\ & =11111110\text{( reverse code )}\\ & =10000001\text{( original code )}\\ & \to -1\end{array}$$

On the other hand, the original code for the number zero is $+0$ and$-0$ can be expressed in two ways. This means that the number zero corresponds to two different binary codes, which may cause ambiguity. For example, in conditional judgment, if positive zero and negative zero are not distinguished, the judgment result may be incorrect. And if we want to handle the ambiguity between positive zero and negative zero, we need to introduce additional judgment operations, which may reduce the computing efficiency of the computer.

$$\begin{array}{rl}+0& \to 00000000\\ -0& \to 10000000\end{array}$$

Like the original code, the complement code also has the problem of positive and negative zero ambiguity, so the computer further introduced "2's complement code". Let’s first observe the conversion process of the original code, inverse code, and complement code of negative zero:

$$\begin{array}{rl}-0\to & 10000000\text{( original code )}\\ =& 11111111\text{( reverse code )}\\ =1& 00000000\text{( complement code}\end{array}$$

Add 1 1 to the complement of negative zero$1$ would produce a carry, butbytethe type is only 8 bits long, so it overflows to$1$ will be discarded. That is,the complement of negative zero is$00000000$ , which is the same as positive zero's complement. This means that there is only one zero in the two's complement representation and the positive and negative zero ambiguity is thus resolved.

There is one last doubt left: bytethe value range of the type is $[-128,127]$ , an extra negative number$-\; How\; is128$ obtained? We note that the interval$[-127,+127]$ All integers within have corresponding original codes, complement codes and complement codes, and the original codes and complement codes can be converted to each other.

However, the complement $10000000$ is an exception, it has no corresponding original code. According to the conversion method, we get the original code of the complement code as$00000000$ . This is obviously a contradiction because the original code represents the number$0$ , its complement should be itself. The computer specifies this special complement$10000000$ represents$-128$ . In fact,$(-1)+The\; calculation\; result\; of\; (-127)$ in two’s complement is$-128$ 。

$$\begin{array}{rl}& (-127)+(-1)\\ & \to 11111111\text{( original code )}+10000001\text{( original code )}\\ & =10000000\text{( reverse code )}+11111110\text{( reverse code )}\\ & =10000001\text{( complement code )}+11111111\text{( complement code )}\\ & =10000000\text{( complement code )}\\ & \to -128\end{array}$$

You may have noticed that all the above calculations are addition operations. This implies an important fact: the hardware circuits inside the computer are mainly designed based on addition operations . This is because compared to other operations (such as multiplication, division, and subtraction), addition operations are simpler to implement in hardware, easier to parallelize, and faster.

Note that this does not mean that computers can only do addition. By combining addition with some basic logical operations, computers are able to perform a variety of other mathematical operations . For example, calculate the subtraction $a-b$ can be transformed into the calculation addition$a+(-b)$ ; Calculating multiplication and division can be converted into calculating multiple additions or subtractions.

Now we can summarize the reasons why computers use complement codes: Based on complement representation, computers can use the same circuits and operations to process the addition of positive and negative numbers. There is no need to design special hardware circuits to handle subtraction, and there is no need to specially handle positive numbers. The ambiguity problem with negative zero. This greatly simplifies hardware design and improves computing efficiency.

The design of the complement code is very exquisite. Due to space constraints, we will introduce it here first. It is recommended that interested readers learn more about it in depth.

floating point encoding

If you are careful, you may find that: the length intof floatis the same as 4 bytes, but why floatthe value range of is much larger than int? This is very counter-intuitive, because it stands to reason that floatto represent decimals, the value range should be smaller.

In fact, this is because floating point numbers floatare represented differently . Remember a 32-bit length binary number as:

$$b_{31}{b}_{30}{b}_{29}\dots b_2{b}_1{b}_0$$

According to the IEEE 754 standard, the 32-bit length floatconsists of the following three parts.

• Sign bit $S$ : occupies 1 bit, corresponding to$b_{31}$ 。
• Exponent bit $E$ : occupies 8 bits, corresponding to$b_{30}{b}_{29}\dots b_{23}$。
• Fractional digit $N$ : 23 bits, corresponding to$b_{22}{b}_{21}\dots b_0$。

floatHow to calculate the corresponding value of a binary number :

$$\text{val}=(-1{)}^{b_{31}}\times 2^{{\left(b_{30}{b}_{29}\dots b_{23}\right)}_2-127}\times {\left(1.b_{22}{b}_{21}\dots b_0\right)}_2$$

The calculation formula converted to decimal:

$$\text{val}=(-1{)}^{\mathrm{S}}\times 2^{\mathrm{E}-127}\times (1+\mathrm{N})$$

The value range of each item is:

S ∈ { 0 , 1 } , E ∈ { 1 , 2 , … , 254 } ( 1 + N ) = ( 1 + ∑ i = 1 23 b 23 − i 2 − i ) ⊂ [ 1 , 2 − 2 − 23 ] \begin{aligned} \mathrm{S} \in & \{ 0, 1\}, \quad \mathrm{E} \in \{ 1, 2, \dots, 254 \} \newline (1 + \mathrm{N}) = & (1 + \sum_{i=1}^{23} b_{23-i} 2^{-i}) \subset [1, 2 - 2^{-23}] \end{aligned} S∈(1+N)=​{ 0,1},E∈{ 1,2,…,254}(1+i=1∑23​b23−i​2−i)⊂[1,2−2−23]​

Observe the figure above, given an example data $\mathrm{S}=0$，$\mathrm{E}=124$ ,$\mathrm{N}=2^{-2}+2^{-3}=0.375$ , then there is:

$$\text{ val }=(-1{)}^0\times 2^{124-127}\times (1+0.375)=0.171875$$

Now we can answer the original question: floatthe representation of contains an exponent bit, causing its range of values ​​to be much larger thanint . According to the above calculation, floatthe maximum positive number that can be represented is $2^{254-127}\times (2-2^{-23})\approx 3.4\times 10^{38}$ , the smallest negative number can be obtained by switching the sign bit.

Although floating point numbers floatextend the range of values, a side effect is that precision is sacrificed . The integer type intuses all 32 bits to represent numbers, and the numbers are evenly distributed; and due to the existence of the exponent bit, floatthe larger the value of the floating point number, the greater the difference between two adjacent numbers will tend to be.

As shown in the table below, the exponent bit $E=0$ sum$E=255$ has a special meaning andis used to represent zero, infinity,$NaN$ et al.

Table meaning of exponent bits

Exponent bit E	Fractional bit $\mathrm{N}=0$	Fractional digit $N\ne 0$	Calculation formula
$0$	$\pm 0$	subnormal number	$(-1{)}^{\mathrm{S}}\times 2^{-126}\times (0.\mathrm{N})$
$1,2,\dots ,254$	normal number	normal number	$(-1{)}^{\mathrm{S}}\times 2^{(\mathrm{E}-127)}\times (1.\mathrm{N})$
$255$	$\pm \infty$	$NaN$

It is worth mentioning that subnormal numbers significantly improve the accuracy of floating point numbers. The smallest positive normal number is $2^{-126}$ , the smallest positive subnormal number is$2^{-126}\times 2^{-23}$ 。

Double precision doublealso uses a similar floatrepresentation method, which will not be described in detail here.