Why is int16 type limit 32,768 if 16 bits max is 65,535?

Question

Sum of 16 bits all "1" bits will result 65,535:

first byte: 1(128) 1(64) 1(32) 1(16) 1(8) 1(4) 1(2) 1(1)

second byte: 1(327,68) 1(16,384) 1(8,192) 1(4,096) 1(2,048) 1(1,024) 1(512) 1(256)

which the decimal would be:

32,768 + 16,384 + 8,192 + 4,096 + 2,048 + 1,024 + 512 + 256 + 128 + 64 + 32 + 16 + 8 + 4 + 2 + 1

total is: 65,535

the max of int16 should be 65,535 and 32,768(which is just 1000 0000 0000 0000)

I can't see how it would be otherwise.

Answer 1

Because it ranges from -32,768 to 32,767, which in sum is 65,536 (0 is included here) possible values.

If you use UInt16 (which stands for unsigned int16) you can give it a value of 65,535.

Answer 2

There is a difference between a signed and an unsigned integer. One has the ability to be negative and the other one doesn't.

It also is not just for int16, but for other types as well.

+--------+----------------------------+----------------------------+--------------------------+
|  Type  |            Min             |            Max             |           Size           |
+--------+----------------------------+----------------------------+--------------------------+
| sbyte  | -128                       | 127                        | Signed 8-bit integer     |
| byte   | 0                          | 255                        | Unsigned 8-bit integer   |
| char   | U+0000                     | U+ffff                     | Unicode 16-bit character |
| short  | -32,768                    | 32,767                     | Signed 16-bit integer    |
| ushort | 0                          | 65,535                     | Unsigned 16-bit integer  |
| int    | -2,147,483,648             | 2,147,483,647              | Signed 32-bit integer    |
| uint   | 0                          | 4,294,967,295              | Unsigned 32-bit integer  |
| long   | -9,223,372,036,854,775,808 | 9,223,372,036,854,775,807  | Signed 64-bit integer    |
| ulong  | 0                          | 18,446,744,073,709,551,615 | Unsigned 64-bit integer  |
+--------+----------------------------+----------------------------+--------------------------+

Answer 3

That's difference between signed int and unsigned int. 16-bit unsigned int ranges in [0, 65535]. While 16-bit signed int ranges [-32768, 32767]. The max of int16 should be 32767 instead of 32768.

Answer 4

Int16 is signed. The most significant bit denotes sign (0 for positive, 1 for negative). The highest number achievable with 0 as MSB is 0111 1111 1111 1111, which is 32767 in decimal.

It is designed this way, so that unsigned addition/subtraction would work on signed numbers as well. So, to get -1, you subtract 1 from 0, and get 1111 1111 1111 1111 (due to overflow). If you keep subtracting, you eventually reach 1000 0000 0000 0000 = -32768 (dec), which is the lowest negative number representable as int16.

So, 2^16 = 65536, which is the total number of representable values. This adds up from: (a) 1 value for zero, (b) 32767 positive numbers, (c) 32768 negative numbers.

Answer 5

You're forgetting the sign. int16 is a signed type, so it's actually:

first byte: ...
second byte: sign(+ or -) 1(16,384) ...

Which covers the range from -32768 to 32767 (0 is considered a positive).
Most of the time, 0 is used for positive and 1 for negative: Sign bit

It would be an entirely different matter if it was a uint16 (u for unsigned):

first byte: ...
second byte: 1(32768) ...

Which, in turn, ranges from 0 to 65535.