• In a language with explicit type conversions, 2's Complement is handled automatically when casting into the correct data type.

/* C Type Casting */
unsigned char x = 0xFF;
signed char y = x;
signed int z = (signed char) x;
/* x is 255 but both y and z are -1 */

/* C99 fixed width integer types */
uint8_t x = 0xFF;
int8_t y = x;
int8_t z = (int8_t) x;
/* x is 255 but both y and z are -1 */

• Without type conversion, an IF statement is needed to detect and correct numbers that are supposed to be negative.
  • For a 2's complement number with n bits, values greater than or equal to 2^(n-1) are actually negative numbers. Restated, if the 2^(n-1) bit is present, then the number is negative. This bit is also known as the sign bit. For an 8-bit number, the sign bit is equal to 0x80 or 0b10000000.

  • To decode negative values, subtract 2ⁿ. This is needed to reverse the order of 2's complement negative values. See also Table 1-1.

    • The opposite is also true: when encoding a negative number to a signed binary data type, 2ⁿ can be added to obtain the correct hex/binary value.
    • Note that adding or subtracting 2ⁿ this way assumes that the underlying data type does not overflow. This is a safe assumption most of the time, because that is not necessary to correct the sign of the data this way if we can type cast to the correct number of bits instead. The underlying data type is likely a C float or similar with at least 32 bits.
  • In Excel, use the IF function and 2ⁿ statements for readability. Excel does not have good support for bitwise operations. Subtract 2ⁿ to convert a number to the correct negative value. These examples are for 16-bit numbers.
• In the following Excel example, row 1 illustrates decoding of data received from the sensor while row 2 illustrates encoding data to be sent to the device.

• In JavaScript and Python, both hex and bitwise operators are available.

  • 0x8000 and 0x10000 are equivalent to 2¹⁵ and 2¹⁶ without the use of additional operators.

  • Bitwise AND comparison can be used to check for the presence of a sign bit instead of greater-than-equal-to comparison.

/* JavaScript */
/* decode from 8-bit 2's complement */
function decode(x) {return (x & 0x8000) ? x-0x10000 : x}
let n = decode(0xFFFF)
/* n is -1 */

/* encode to 8-bit 2's complement */
function encode(x) {return (x < 0) ? x+0x10000 : x}
let n = encode(-1).toString(16)
/* n is 'ffff' */

# Python
# decode from 8-bit 2's complement
def decode(x): return x-0x10000 if (x & 0x8000) else x
n = decode(0xFFFF)
# n is -1

# encode to 8-bit 2's complement
def encode(x): return x+0x10000 if (x & 0x8000) else x
n = hex(encode(-1))
# n is '0xffff'