3.1.4. Examples of Arithmetic Operations

Similarly ah the number of plus if you see; the number of ones in the answer is 0, the parity flag is set to 1, but again since both the numbers are negative, but the sign is 0 which indicates the answer is positive. So, overflow flag is 1; so, in this case you see what is an overflow. For example, if both the numbers are negative. So, if you consider a; so, again this one is very important is you are considering signed arithmetic. So, if you are taking a signed arithmetic then 1 and 1; they are two negative numbers. Since both the numbers are negative sign bit is 1, if we are considering a signed 2’s complement arithmetic, but the sign bit of the answer is 0 that is this is a 0. So, had these been the two negative numbers; so, what are the 100 and 100. So, if you are taking a 2’s complement arithmetic it will be 00 ah it will be 0 sorry ah this is actually nothing, but 0111, you add a 1 nothing, but -8.

In signed arithmetic, we often have to consider how we represent negative numbers. For instance, if we add two negative integers, like -8 and -8, we expect to get -16. However, when using a signed 2's complement representation, the sign bit may indicate a positive number (seen when the most significant bit is 0). This situation introduces an concept called overflow, where we receive an invalid result due to the limitations of our representation system. It is important to understand how different number representations can change the interpretation of arithmetic results.

Think of it like trying to store a large box (the result of the addition) in a small locker (the limited size of the bit representation). If the box is too big (like how -16 cannot fit in a space meant for only 4 bits of numbers), it doesn't fit and we get confused about what we see and assume—similar to how the computer might think it obtained a positive number instead.

But this is nothing but equal to -8 and -8. So, in this case your answer should be -16, but somehow you are getting the MSB as 0. So, in this case we chose the both the numbers are negative, but the answer is 0 which indicates that the answer is positive. So, the overflow flag is 0; so, the overflow flag is set to 1 because had this is a signed arithmetic. So, this -8 -8; the answer should have been -16. But some of the answer is showing MSB as 0 which is basically wrong due to an overflow; so, the overflow flag is set to 1. But in this context as we are using an unsigned arithmetic, you have to totally neglect the overflow flag.

When performing arithmetic with unsigned numbers, the overflow flag becomes less relevant. This is because unsigned arithmetic does not account for negative values and focuses purely on positive results. If we were to add two positive numbers and the result exceeds the maximum value representable by our chosen number of bits, we might see unexpected results, such as an asserted overflow flag. However, since we are only interested in positive outcomes in unsigned arithmetic, this overflow doesn't indicate an error.

Imagine you're measuring the total weight of products in a box with a scale capable of measuring up to 10 kg. If you add multiple items and suddenly the display shows ‘0kg’ due to exceeding the limit, it doesn’t mean there’s no weight; it means you must use a larger scale to handle the weight you're trying to measure.

Like 5 + 4 if you are going to do again this is a unsigned arithmetic. So, you add this you are going to get the answer as this; obviously, the zero flag is reset because the answer is not 0; the MSB is 1 indicating it’s a negative number, but again it’s an unsigned arithmetic. So, you have to neglect the negative flag there is no carry generated over here. So, the carry flag is reset we have to consider this because 4 + 5 is 9; you are doing the operation in a 4 bit arithmetic.

Adding two positive numbers using unsigned arithmetic is straightforward. When we add 5 and 4, we obtain 9, which fits comfortably within the limits of 4-bit binary notation. In this scenario, we can check relevant flags such as the zero flag to see if the arithmetic resulted in zero (which it did not) and the carry flag to check for any overflow into the next bit (which there wasn’t). Since the result was valid, all flags indicate a normal operation.

This can be compared to adding 5 apples to 4 apples. You count and see you’ve got 9 apples in total, and everything is right in your basket — no extraneous apples spilling out, and no missing apples, just a clear count. This clear result means everything is functioning perfectly.

Like 7 + 1 = 8; same thing is going to be the answer. Answer is not all 0 zeroth flag is reset we have to take it negative flag MSB the final answer is negative. So, negative flag is set to 1; again ok just a minute.

Continuing with our arithmetic examples, adding 7 and 1 yields 8. However, we might run into issues when interpreting the result if we switch contexts from unsigned to signed arithmetic. When the most significant bit (MSB) indicates a negative number even though the actual result is positive, it clearly suggests a misunderstanding or miscalculation—indicating an overflow in a signed format. This situation stresses the importance of being mindful of how we are interpreting our outputs.

Think about a situation where you're glancing at a thermometer to note the temperature. If the thermometer has limited display space and it suddenly shows a reading that seems off—for instance, a negative number when the weather is positive—it could mean the display is malfunctioning, similar to how our result might misrepresent reality in arithmetic due to overflow.

Because positive 8 will be 0100 this is actually positive 8 because 1000 is negative 8 in 2’s complement arithmetic. So, this in fact, that is why I told you that it’s going out of range; so, this is going to be incorrect answer. So, if you do this we are going to get the answer this one; 1000 as a hardware it does not understand much, it will just develop the value of flags based on certain hardware computation.

A crucial lesson in arithmetic operations is understanding how exceeding the bit limitations leads to incorrect results. For example, in a 4-bit system, when attempting to perform operations that yield answers like positive 8, it simply cannot be represented (the binary representation exceeds its display capability, influencing how flags are set). This directly ties to how reliable the computer faces these outputs under limiting conditions, emphasizing the need for validation.

This reminds one of trying to capture an extended image in a camera with a smaller lens; if the scene is larger than the lens can handle, parts of it will be lost or misrepresented. Ensuring we work within the appropriate measures is critical for achieving accurate results.

--