Two's Complement: The Computer's Clever Little Lie

Ah, two's complement! Sounds like something you'd order at a fancy digital restaurant. But no, it's just how computers pull a fast one when dealing with those pesky negative numbers. Apparently, the old sign and magnitude wasn't quite sneaky enough for them.

Denary to Two's Complement: The Positive Pretenders

Now, if you've got a positive denary number (that's a normal number to you and me), converting it to two's complement is surprisingly… well, normal. You just bung it into binary as you usually would. But here's the little quirk: to really show it's a goody-two-shoes positive number, the very first bit on the left (the most important one, the big cheese) must be a 0. Think of it as a digital halo.

Take the example: 30 in binary is 11110. But hold your horses! That starts with a 1, which in the world of two's complement could mean trouble (i.e., a negative number). So, to make it clear it's a happy, positive 30, you slap a 0 at the front: 011110. See? All smiles now.

Denary to Two's Complement: The Negative Nasties

Right, this is where things get a bit more… interesting. If you've got a negative denary number and you want to turn it into two's complement, there's a little dance you have to do. We'll stick to one method here to save our sanity.

First, you take the denary number (ignore the minus sign for a moment) and convert it into plain old binary. Easy enough.

Then comes the fun bit: you have to "flip every bit". That means all the 1s become 0s, and all the 0s become 1s. It's like the binary numbers have suddenly decided to swap identities.

Finally, you add binary 1 to the result of that flipping frenzy. Yes, just a simple 1. It's this little addition that makes the whole two's complement system work its magic (or its dark arts, depending on how you look at it).

So, there you have it. Positive numbers are just themselves with a polite 0 at the front. Negative numbers go through a digital obstacle course of flipping and adding. Don't say computers don't have a sense of drama!

Two's Complement to Denary: Unmasking the Digital Deception

So, the sneaky computers have given you a number in their twisted two's complement form, and now they expect you to figure out what normal number it actually represents. It's like they're speaking in code and you've forgotten the secret handshake. Fear not, intrepid explorer of the digital wilderness! We can crack this.

Spotting the Good Eggs and the Rotten Ones

First things first, you need to play detective and figure out if the two's complement number is a good egg (positive) or a right rotten one (negative). The big clue is that very first bit on the left. It's like the digital equivalent of a sneer or a smile.

If that first bit is a big fat 1, then BAM! You've got a negative number on your hands. It's wearing a digital disguise. But if that first bit is a nice, innocent 0, then you're in positive territory. Phew!

Positive Numbers: As Easy as Digital Pie

If you've spotted a 0 at the beginning, congratulations! You've got a positive two's complement number. Converting it back to denary is as simple as converting any ordinary binary number. No sneaky tricks here. For example, if you see 0100110, you just treat it like regular binary, and it happily turns into the denary number 38. Easy peasy.

Negative Numbers: Reversing the Digital Shenanigans

Now, if that first bit was a 1, buckle up, buttercup! We need to undo the computer's little game. To get back to the real negative denary number, we have to reverse the "flipping" we talked about earlier. Here's the easiest way to do this digital U-turn:

Starting from the right-hand side of the two's complement number, you write down all the bits exactly as they are, up to and including the very first 1 you encounter. Stop there!

Then, for all the remaining bits to the left of that first 1, you do the opposite – you flip them! So, all the 1s become 0s, and all the 0s become 1s.

Finally, once you've done all that flipping, you treat the resulting binary number as a positive value and work out its denary equivalent. And don't forget! Since we started with a 1 at the beginning of the two's complement number, the denary number you've just calculated is actually negative. So, slap a minus sign on the front and Bob's your uncle!

For example, let's take the two's complement number 11010110. Starting from the right, we go 0, 1 (stop here!). Now, we flip the remaining bits to the left: 1101 becomes 0010. So we have 001010. Converting that to denary gives us 10. Since the original number started with a 1, the answer is -10. Clever, eh? In a slightly devious, computer-y way.

Range of Two's Complement Numbers: Not as Roomy as You Might Think!

So, you've got your unsigned binary numbers, all happy-go-lucky and starting from zero upwards. They're like a digital queue where everyone's in a positive mood. But then along comes two's complement, and things get a bit… partitioned. It turns out, the range of numbers you can squeeze into the same number of bits isn't quite the same. It's like having a party where some guests are only allowed in the 'positive zone' and others are stuck in the 'negative corner'.

Take, for instance, a humble 8-bit number. If it's unsigned, it can cheerfully count all the way from a big fat 0 up to a respectable 255. Plenty of room for digital shenanigans!

But if you're using two's complement with those same 8 bits, things get a bit… restricted. You can only represent numbers from a rather chilly -128 up to a slightly less chilly +127. Notice how the positive end isn't quite as high as the unsigned version? It's because that first bit is doing double duty as the sign, hogging some of the potential for bigger positive numbers. Sneaky, those computers!

The Secret Formula for Positive Territory (Mostly)

Now, if you want to work out the top end of the positive range in two's complement, there's a bit of a formula you can use: 2^n-1 - 1, where n is the number of bits you're dealing with.

Let's look at their example: 6 bits. Plug that into our formula: 2^6-1 - 1 = 2⁵ - 1 = 32 - 1 = 31. So, with 6 bits in two's complement, the biggest positive number you can represent is 31.

Notice that the formula only gives you the top of the positive range. Working out the bottom end (the most negative number) is slightly different – for n bits, it's usually -2^n-1. So, for our 6-bit example, the most negative number would be -2^6-1 = -2⁵ = -32.

So, the key takeaway here is that two's complement lets you represent negative numbers, which is jolly useful, but it comes at the cost of a slightly smaller positive range compared to its unsigned cousin. It's all a matter of digital give and take, isn't it?

Subtracting with Two's Complement: Adding is the New Subtracting!

Now, hold on to your hats, because this is where things get a tad… upside down. It turns out that computers, bless their simple digital hearts, aren't all that keen on subtraction. It's a bit too much bother for them. So, what do they do instead? They cheat! They use the wonderful weirdness of two's complement numbers to turn subtraction into… drum roll please… addition!

Think about it in the normal world for a moment. Saying you want to calculate 33 - 10 is exactly the same as saying you want to calculate 33 + (-10). See? Subtraction is just adding a negative number in disguise!

And that's precisely what two's complement lets us do in the binary world. If you want to subtract one binary number from another, the computer can take the number you want to subtract, turn it into its negative two's complement form (we talked about how to do that earlier, remember?), and then simply add the two numbers together.

So, instead of faffing about with borrowing and all that subtraction nonsense, the computer just does what it's good at: adding binary numbers. If you've forgotten how that works, you might want to go back and have a peek at the section on addition. It all ties together, you see! This clever little trick is why two's complement is so darn useful in the inner workings of your computer. It makes things much simpler (for the computer, at least!).