Measurement Application Bug

As far as I know the documentation is correct.

Signed 2's complement numbers work like this:

(This is a logical build up to the final explanation)

To represent signed numbers, the most significant bit could be used as a sign bit; if set then the number is negative.

A number of early days computers worked like this.

However, doing this would mean we could have both positive and negative zero, for example in binary:

%0000 = positive zero
%1000 = negative zero

%0001 = positive one
%1001 = negative one

So thats actually not very useful, as differentiating positive and negative zero is a pain.

The other thing we'd really like from signed number is that addition actually works (and in the above examples, it does not).

This means we'd like things like 2 + (-1) to result in 1.

And this gives a hint as to what to do:

Flipping the bits for negative numbers seems a good bet:

So:
%0010 = 2

How about:
%1101 = -2 ??

What happens when we add those - we'd like a result of 0.

But %0010 + %1101 restults in %1111, which is clearly not zero.

But adding 1 results in zero...

So a negative number is formed by:

- take the positive number, write it out in binary
- invert all the bits
- add one

This results in the most significant bit always being 1 for a negative number (an easy test for negative); but after that things are not quite so obvious:

%0010 = 2

%1110 = -2

Also:

%0001 = 1
%1111 = -1

You see the pattern of the negative numbers - the more one bits are present, the LESS negative, this is the opposite of the positive numbers.

So when the documentation refers to signed 2's complement it just means - the plain ole natural signed integer format that numbers are in.

That can appear as hex.

For example, $0001 is a 2 byte quantity, signed 2's complement, positive 1.

And $1111 is a 2 byte quantity, signed 2's complement, negative 1.

 

What you have described is use of a simple sign bit.

There are 3 conventions that have historically been used for representing signed (especially) negative numbers:

2's complement - which works for addition as I described, therefore the most common, and you'd struggle these days to ever find anything else.

1's complement - which is just a bitwise inverse, so the most significant bit is the sign bit and all the other bits are upside down. Addition only works by a fudge (the adding of 1).

Use of a plain sign bit only - which as as you described. This has the disadvantage that addition just does not work at all, you need to treat arithmetic as a series of special cases, for example, turning additions into subtractions after flipping the sign bit.

Plain sign bits were used in the very early days on some machines some of the time (1950's), but the disadvantages meant that this approach has gone the way of the dinosaurs.