Topics:

1. Convert Decimal to Binary

A. Positive Decimal to Binary

Divide the number by 2 and write down the remainder.
Divide the quotient (result of division) by 2 again and write down the remainder.
Repeat the process until the quotient is 0.
The binary number is the remainders, read from bottom to top, write from left to right.

Example: convert 22 from Decimal to Binary: 10110

Step	Quotient	Remainder	Binary (from bottom to top)
1	22 ÷ 2 = 11	0
2	11 ÷ 2 = 5	1
3	5 ÷ 2 = 2	1
4	2 ÷ 2 = 1	0
5	1 ÷ 2 = `0` (stop here, quotient is 0)	1	`10110`

B. Negative Decimal to Binary

One’s complement:
- Inverts all the bits (0s become 1s and 1s become 0s).
- It is an older method of representing signed numbers. In this document, one’s complement is mainly used as an intermediate step when creating a two’s complement negative number.

Two's complement:
- Inverts all the bits and then adds 1 to the result.
- It is a fixed-width method for representing signed integers. The most significant bit helps indicate whether the value is non-negative or negative, and negative numbers are found by inverting the bits of the positive value and adding 1.

Example: convert -22 from Decimal to Binary: 11101010

To convert -22 to binary, we first need to find the binary representation of the positive number 22 and then apply 2's complement(8-bit Signed) to represent the negative number.

1. Convert 22 to Binary:

22 ÷ 2 = 11, remainder = 0

11 ÷ 2 = 5, remainder = 1

5 ÷ 2 = 2, remainder = 1

2 ÷ 2 = 1, remainder = 0

1 ÷ 2 = 0, remainder = 1 (stop, quotient is 0)

So, the binary representation of 22 is 10110. To make it 8-bit, we add leading zeros: 00010110.

2. Invert the bits (1's complement): invert each bit of 00010110 to get the 1's complement: (change 0 to 1 and 1 to 0)

00010110 → 11101001.

3. Add 1 to the inverted bits ( 1's complement 11101001) to get 2's complement:

11101001 + 1 = 11101010.

Table Summary:

Step	Operation	Result
1. Convert 22 to binary	Binary of `22`	`00010110`
2. Invert the bits	1's complement of `00010110`	`11101001`
3. Add 1	Add `1` to `11101001`	`11101010`

C. Adding `1` to the Binary number

binary number example: 11101001

  11101001
+ 00000001
-----------
  11101010

Start with 11101001.

Add 1 to the rightmost bit (least important), causing a carry.

Continue only while there is a carry. If the carry becomes 0, the remaining left-side bits stay the same

Step	Operation	Carry	Result
Initial Value	`11101001`		`11101001`
Add 1 to rightmost bit	1 + 1 = 10	`1`	`11101000`
Add carry to next bit	0 + `1` = 1	`0`	`11101010`
Continue to next bits	0 + `0` = 0	`0`	`11101010`
Continue to next bits	1 + `0` = 1	`0`	`11101010`
Continue to next bits	0 + `0` = 0	`0`	`11101010`
Continue to next bits	1 + `0` = 1	`0`	`11101010`
Continue to next bits	1 + `0` = 1	`0`	`11101010`
Continue to next bits	1 + `0` = 1	`0`	`11101010`
Final Result			`11101010`

2. Convert Binary to Decimal

A. Positive (unsigned) Binary to Decimal

Convert the 8-bit signed two’s complement binary number 11101010 into its decimal equivalent: -22

Note: Each position in a binary number corresponds to a power of $2$ , starting from $2^{0}$ on the right.

Step	Explanation	Calculation
1. Write the binary number	Binary number `10110`	`10110`: Binary digits(bits)
2. Assign powers of 2	Assign powers of 2 to each bit from right to left:	`43210` : Positions `2⁴` `2³` `2²` `2¹` `2⁰` → `16` `8` `4` `2` `1`
3. Multiply each bit by power of 2	Multiply each bit by its corresponding power of 2:	`1 × 16` = `16` `0 × 8` = `0` `1 × 4` = `4` `1 × 2` = `2` `0 × 1` = `0`
4. Add the results	Sum the results of the multiplications:	`16 + 0 + 4 + 2 + 0` = `22`

B. Negative (signed) Binary to Decimal

convert the signed binary number 11101010 into its decimal equivalent: -22

Step	Description	Result
1. Input binary	Original 8-bit binary number	`11101010`
2. Check sign bit	First bit is `1`, so the number is negative	Negative
3. Invert all bits	Flip `1` to `0` and `0` to `1`	`00010101`
4. Add 1	Add `1` to the inverted bits	`00010110`
5. Convert to decimal	`00010110` = `22` in decimal	`22`
6. Apply sign	Original number was negative	`-22`

C. Signed vs Unsigned binary interpretation

The Binary representation is the same for both signed and unsigned integers, but the decimal interpretation differs depending on whether the question context specifies signed or unsigned. so, Whether the first bit (leftmost) indicates a negative number depends on the context — signed vs unsigned representation.

If no signed format or bit width is specified, a binary number is usually interpreted as unsigned in basic binary conversion problems. In that case, the leftmost bit is part of the value, not a sign bit

Binary	Bit Length	Signed or Unsigned?	Interpreted As
`10110`	5 bits	unsigned 5-bit	+22
`10110`	5 bits	signed 5-bit two’s complement	-10

Case 1: Interpreting 10110 as Unsigned (default): 22

Just calculate: 1×2⁴ + 0×2³ + 1×2² + 1×2¹ + 0×2⁰ = 16 + 0 + 4 + 2 + 0 = 22

The first bit being 1 does not imply negativity in unsigned binary — it just adds to the total like any other bit.

Case 2: Interpreting 10110 as a Signed 5-bit 2's Complement Number: -10

First bit is 1, so it's negative.

Step 1: Invert bits: 10110 → 01001

Step 2: Add 1: 01001 + 1 = 01010 → that’s 10 in decimal
- Calculate: 0×2⁴ + 1×2³ + 0×2² + 1×2¹ + 0×2⁰ = 0 + 8 + 0 + 2 + 0 = 10

Step 3: Apply sign → Result is -10

D. Two's complement

Two's complement is a way to represent both positive and negative integers in binary form. It is widely used because addition and subtraction can be handled consistently using binary arithmetic.

How Two's Complement Works:

Positive numbers:
The binary representation is the same as the regular binary form. For example, 6 in binary is just 00000110 (if we use 8 bits).

Negative numbers:

To represent a negative number in two's complement:

First, take the binary representation of the absolute value of the number.

Then, invert all the bits (change 0 to 1 and 1 to 0).

Finally, add 1 to the result.

Example with 8-bit representation:

For 0:

Binary representation of 0 is 00000000 in two's complement, and no change is needed because it's already 0.

For 6:

The binary representation of 6 is 00000110 in an 8-bit system.

For -6:

First, take the binary representation of 6: 00000110.
Invert all the bits: 11111001.
Add 1: 11111001 + 1 = 11111010.
So, the two's complement representation of -6 is 11111010.

Here's a table that summarizes the steps to convert -3 into 2's complement for 4 bits, 8 bits, and 32 bits:

Step	4 bits	8 bits	32 bits
1. Start with binary of 3	`0011`	`00000011`	`00000000 00000000 00000000 00000011`
2. Invert the bits (1's complement)	`1100`	`11111100`	`11111111 11111111 11111111 11111100`
3. Add 1 to the inverted bits	`1100 + 1 = 1101`	`11111100 + 1 = 11111101`	`11111111 11111111 11111111 11111100 + 1 = 11111111 11111111 11111111 11111101`
Result (2's complement)	`1101`	`11111101`	`11111111 11111111 11111111 11111101`

Bitwise operations

Bitwise operations directly manipulate the individual bits of integers. These operations are often used in low-level programming, such as system programming, hardware control, or in scenarios where performance and memory efficiency are critical.

Most common bitwise operations:

1. AND (&)

Operation: It compares each corresponding bit of two integers and returns 1 if both bits are 1, otherwise, it returns 0.

Example: 5 & 3
In binary:

5 = 0101

3 = 0011

The result is 0001, which is 1 in decimal.

2. OR (|)

Operation: It compares each corresponding bit of two integers and returns 1 if at least one of the bits is 1, otherwise, it returns 0.

Example: 5 | 3
In binary:

5 = 0101

3 = 0011

The result is 0111, which is 7 in decimal.

3. XOR (^)

Operation: XOR, or exclusive OR, compares two bits and returns 1 if they are different and 0 if they are the same.:
- 0 ^ 0 = 0 (both bits are the same)
- 1 ^ 1 = 0 (both bits are the same)
- 0 ^ 1 = 1 (bits are different)
- 1 ^ 0 = 1 (bits are different)

Key properties of XOR:

1. Self-inverse: x ^ x = 0. XORing a number with itself results in 0.

2. Identity: x ^ 0 = x. XORing a number with 0 leaves the number unchanged.

3. Commutative and Associative: x ^ y = y ^ x and (x ^ y) ^ z = x ^ (y ^ z). The order of XOR operations doesn't matter.

Example: 5 ^ 3
In binary:

5 = 0101

3 = 0011

The result is 0110, which is 6 in decimal.

4. NOT (~)

Operation: It inverts the bits of the operand (also called a bitwise negation).

Example: ~5
In binary: 5 = 0101

If using 4 bits, ~0101 = 1010. Interpreted as unsigned, 1010 is 10. Interpreted as 4-bit two’s complement, 1010 is -6. In JavaScript, ~5 evaluates to -6 because JavaScript bitwise operators use 32-bit signed integers.

5. Left Shift (<< , <<<)

Operation: It shifts the bits of the number to the left by a specified number of positions. This is equivalent to multiplying the number by 2 for each position shifted.

<< is the signed left shift
<<< is the unsigned left shift

Example: 5 << 1
In binary: 5 = 0101

Shifting left by 1 gives 1010, which is 10 in decimal.

6. Right Shift (>>, >>>)

Operation: It shifts the bits of the number to the right by a specified number of positions. This is equivalent to dividing the number by 2 for each position shifted, and it discards the bits shifted out.

>> is the signed right shift
>>> is the unsigned right shift

Example: 5 >> 1
In binary: 5 = 0101

Shifting right by 1 gives 0010, which is 2 in decimal.

Summary of Bitwise Operations:

Operator	Description	Example	Binary Operation	Result Binary	Decimal Result
`&`	AND	`5 & 3`	`0101 & 0011`	`0001`	`1`
`\|`	OR	`5 \| 3`	`0101 \| 0011`	`0111`	`7`
`^`	XOR	`5 ^ 3`	`0101 ^ 0011`	`0110`	`6`
`~`	NOT	`~5`	`~0101`	`1010`	`-6` if signed two’s complement
`<<`	Left Shift	`5 << 1`	`0101 << 1`	`1010`	`10`
`>>`	Right Shift	`5 >> 1`	`0101 >> 1`	`0010`	`2`

Use Cases of Bitwise Operations

Setting, Clearing, or Toggling specific bits: Bitwise operations are often used to manipulate specific bits in control registers, memory locations, or flags.

Efficiency: Since bitwise operations are typically faster than arithmetic operations, they are commonly used in performance-critical applications.

Masking: Masking involves using bitwise AND to extract specific bits from a value or set bits in a value.

Optimizing Multiplication/Division: Shifting bits left or right can be a faster alternative to multiplying or dividing by powers of 2.

Bit Manipulation