Arithmetic and Logical Operation

Computer Organization & Embedded System — Computer Arithmetic and Memory System, NEC licence examination syllabus (Nepal Engineering Council).

Computer Arithmetic: how a CPU actually does math

Addition looks easy. Multiplication and division are where exams get you.

Every time a game engine calculates where a bullet lands, or your calculator app multiplies two numbers, it all comes down to circuits that only really know how to do one thing well: add. At the hardware level, every arithmetic operation eventually reduces to addition and subtraction of binary numbers, done using two's complement so the same adder circuit handles both positive and negative numbers.

Addition, subtraction, and overflow

To subtract A − B in two's complement, hardware doesn't build a separate subtractor — it just complements B and adds 1, then feeds it into the same adder used for addition. This is why two's complement is used almost everywhere in CPU design — one circuit, two jobs.

Overflow rule (signed addition): Overflow happens ONLY when both operands have the SAME sign and the result has the OPPOSITE sign. Example: 01111111 (+127) + 00000001 (+1) = 10000000 (−128) ❌ overflow!

Carry-out and Overflow are different things. Carry cares about unsigned wraparound; Overflow cares about signed results going out of range. A question can set a trap by giving you signed inputs and asking only about carry, or vice versa.

Booth's Algorithm — multiplication, the exam favourite

Booth's algorithm multiplies signed numbers efficiently by scanning pairs of bits and deciding to add, subtract, or do nothing, then shifting.

Registers used: A (accumulator, starts at 0), Q (multiplier), M (multiplicand), plus an extra bit Qn+1 initialized to 0 to compare with Q's last bit. After n cycles, A:Q holds the signed product.

💡 Booth's algorithm numerical is one of the most repeated questions in this subject — practice a full multiplication of two 4-bit signed numbers step-by-step, showing A, Q, Qn+1 after every shift.

➗ Division: Restoring vs Non-Restoring

RestoringShift-subtract, and if the result goes negative, add the divisor back ("restore") before continuing.

Non-restoringSkips the restore step entirely — instead of always subtracting, it subtracts or adds depending on the sign of the previous remainder. Faster, since no wasted restore cycle.

Floating-point representation — IEEE 754

Every time a game physics engine handles a fraction of a second, or a spreadsheet stores 3.14159, it's using this exact format. Real (fractional) numbers are stored as sign, exponent, and mantissa — similar to scientific notation, but in binary.

🎯 Single vs Double Precision

Single (32-bit)1 sign + 8 exponent (bias 127) + 23 mantissa bits.

Double (64-bit)1 sign + 11 exponent (bias 1023) + 52 mantissa bits — this is what most programming languages use by default for decimals (e.g. Python's float, Java's double).

💡 Practice converting a decimal number (like 25.75) into IEEE-754 single precision step by step: binary conversion → normalize to 1.xxxx × 2ⁿ → find biased exponent → fill 23-bit mantissa.

Syllabus points

Addition/subtraction (2's complement) + overflow detection
Multiplication — Booth's algorithm + array multiplier
Division — restoring & non-restoring
Floating-point representation (IEEE 754)
Floating-point arithmetic operations

Create a free account to tick topics off, take notes as you read, watch the video lessons and get a day-by-day study plan built around your exam date.