I'm working on modernizing Rosetta Code's infrastructure. Starting with communications. Please accept this time-limited open invite to RC's Slack.. --Michael Mol (talk) 20:59, 30 May 2020 (UTC)

# Two's complement

Two's complement
You are encouraged to solve this task according to the task description, using any language you may know.
Two's complement is an important concept in representing negative numbers. To turn a positive integer negative, flip the bits and add one.

Show how to calculate the two's complement of an integer. (It doesn't necessarily need to be a 32 bit integer.)

## 6502 Assembly

### 8-Bit

`LDA #%01010101EOR #255CLCADC #1 ;result: #%10101011`

### 16-bit

`myVar equ \$20 LDA #3STA myVarLDA #0STA myVar+1  ;equivalent C: uint16_t myVar = 3; negate:LDA myVar+1EOR #255STA myVar+1 LDA myVarEOR #255STA myVarCLCADC #1STA myVar;this handles the case if we started with something where the low byte was zero.LDA myVar+1ADC #0STA myVar+1`

## 8086 Assembly

`mov al,17neg al ;8-bitmov bx,4C00hneg bx ;16-bit`

## ALGOL 68

Algol 68 uses whatever representation the hardware the program is running on uses, which is almost certainly two's complement. So, as in C and most other languages, `-a` two's complements `a`. Using Algol 68's bit manipulation facilities, we can explicitely two's complement a positive integer, as shown in this example.
Note: BIN a converts a to a BITS (bit-string) value, the NOT operator will flip the bits and the ABS operator will convert back to an integer, so `1 + ABS NOT BIN a` is a long-winded alternative to `-a`. Note in Algol 68, the BIN operator cannot be applied to negative integers, so `1 + ABS NOT BIN -3` won't work.

`BEGIN    INT a := 3;    print( ( -a, " ", 1 + ABS NOT BIN a, newline ) )END`
Output:
```-3 -3
```

## ALGOL W

Translation of: ALGOL 68
`begin    integer a;    a := 3;    write( i_w := 1, s_w := 1, -a, 1 + number( not bitstring( a ) ) )end.`
Output:
```-3 -3
```

## C

`int a = 3;a = -a;`

## FreeBASIC

In FreeBASIC as in C, if a number n is any integer type, then -n is the two's complement of n, with type preserved.

`Dim As Integer d1 = 2147483648, d2 = 2147483646Dim As Integer b(1 To ...) = {-d1, -d1+1, -2, -1, 0, 1, 2, d1-2, d1-1}For i As Integer = 1 To Ubound(b)    Print b(i); " -> "; -b(i)Next iSleep`
Output:
`0000000000000011 -> 1111111111111101`

### inline assembly

`Dim As Integer a = &b000011Dim As Integer a2c, l#ifdef __FB_64BIT__    l = 16    Asm        mov rax, [a]        neg rax        mov [a2c], rax    End Asm#else    l = 8    Asm        mov eax, [a]        neg eax        mov [a2c], eax    End Asm#endif Print Bin(a, l); " -> "; Bin(a2c, l)Sleep`
Output:
```-2147483648 ->  2147483648
-2147483647 ->  2147483647
-2 ->  2
-1 ->  1
0 ->  0
1 -> -1
2 -> -2
2147483646 -> -2147483646
2147483647 -> -2147483647```

## J

J uses twos complement natively:

`   -3_3`

We can see this by extracting bits representing the number. In this example, we limit ourselves to 8 bits:

`   (8#2)#:30 0 0 0 0 0 1 1   (8#2)#:-31 1 1 1 1 1 0 1`

## Julia

In Julia as in C, if a number n is any integer type, then -n is the two's complement of n, with type preserved. This is true even if n is unsigned.

## Phix

### inline assembly

```without js
integer a = 0b000011,
a2c
#ilASM{

mov eax,[a]
neg eax
mov [a2c],eax

mov rax,[a]
neg rax
mov [a2c],rax
}
printf(1,"%032b -> %032b\n",{a,a2c})
```
Output:
```00000000000000000000000000000011 -> 11111111111111111111111111111101
```

### normal hll

```with javascript_semantics
integer a = 0b000011
printf(1,"%032b -> %032b\n",{a,-a})
```

Same output (naturally the rhs is twice as long under 64 bit, in both cases)

## PL/M

Works with: 8080 PL/M Compiler
... under CP/M (or an emulator)

Even though the original PL/M 8080 compiler only handles unsigned integers, `-A` two's complements `A`.

`100H: /* TWO'S COMPLEMENT                                                   *?    /* CP/M BDOS SYSTEM CALL */   BDOS: PROCEDURE( FN, ARG ); DECLARE FN BYTE, ARG ADDRESS; GOTO 5;END;   /* CONSOLE OUTPUT ROUTINES */   PR\$CHAR:   PROCEDURE( C ); DECLARE C BYTE;    CALL BDOS( 2, C ); END;   PR\$NL:     PROCEDURE; CALL PR\$CHAR( 0DH ); CALL PR\$CHAR( 0AH );  END;   PR\$HEX: PROCEDURE( B ); /* PRINTS B AS A 2 DIGIT HEX NUMBER */      DECLARE B BYTE;      DECLARE D BYTE;      IF ( D := SHR( B, 4 ) ) > 9 THEN CALL PR\$CHAR( ( D - 10 ) + 'A' );                                  ELSE CALL PR\$CHAR(     D      + '0' );      IF ( D := B AND 0FH   ) > 9 THEN CALL PR\$CHAR( ( D - 10 ) + 'A' );                                  ELSE CALL PR\$CHAR(     D      + '0' );   END PR\$HEX ;    DECLARE A  BYTE;    A = 1;   CALL PR\$HEX( A );   CALL PR\$CHAR( ' ' );   A = -A;   CALL PR\$HEX( A );   CALL PR\$NL; EOF`
Output:
```01 FF
```

## Raku

By default Rakus integers are arbitrary sized, theoretically of infinite length. You can't really take the twos complement of an infinitely long number; so, we need to specifically use fixed size integers.

There is a module available from the Raku ecosystem that provides fixed size integer support, named (appropriately enough.) FixedInt.

FixedInt supports fixed bit size integers, not only 8 bit, 16 bit, 32 bit or 64 bit, but ANY integer size. 22 bit, 35 bit, 191 bit, whatever.

Here we'll demonstrate twos complement on a 57 bit integer.

`use FixedInt; # Instantiate a new 57(!) bit fixed size integermy \fixedint = FixedInt.new: :57bits; fixedint = (2³⁷ / 72 - 5¹⁷); # Set it to a large value say fixedint;     # Echo the value to the console in decimal formatsay fixedint.bin; # Echo the value to the console in binary format fixedint.=C2;     # Take the twos complement say fixedint;     # Echo the value to the console in decimal formatsay fixedint.bin; # Echo the value to the console in binary format`
Output:
```144114427045277101
0b111111111111111110100111011001111000010101110110110101101
761030578771
0b000000000000000001011000100110000111101010001001001010011```

## Wren

Strictly speaking, Wren doesn't have integers. Instead all numbers are 'IEEE 754' 64 bit floating point values (their underlying C type being double) and negative numbers are therefore represented using the offset binary method rather than two's complement.

This is illustrated by running the following code:

`var a = 0a = -aSystem.print(a) // -0`

which produces 'negative zero' rather than just 'zero'.

However, when using the bitwise operators, Wren's VM emulates the corresponding operation in C by first converting the operands to unsigned 32 bit values, performing the operation and then converting the result back to a double.

We can therefore emulate how two's complement works on signed 32 bit integers by using the bitwise complement operator ~ to flip the bits as follows:

`var pow32 = 2.pow(32)var pow31 = 2.pow(31)var bs = [-pow31, -pow31+1, -2, -1, 0, 1, 2, pow31-2, pow31-1]for (b in bs) {    var b2 = ~b + 1    if (b2 > pow31) b2 = b2 - pow32    System.print("%(b) -> %(b2)")}`
Output:
```-2147483648 -> 2147483648
-2147483647 -> 2147483647
-2 -> 2
-1 -> 1
0 -> 0
1 -> -1
2 -> -2
2147483646 -> -2147483646
2147483647 -> -2147483647
```

## XPL0

`int I;  char C;[I:= 123;I:= (~I) + 1;IntOut(0, I);  CrLf(0);C:= -123;C:= ~(C-1);IntOut(0, C);  CrLf(0);]`
Output:
```-123
123
```

## Z80 Assembly

### 8-Bit

Zilog Z80

`ld a,%00001111neg ;returns %11110001 in a`

Game Boy

`ld a,%00001111cpl   ;game boy doesn't have NEG but it has CPL which flips all the bits.inc a ;returns %11110001 in a`

### 16 Bit

`NEG` and `CPL` only work on the accumulator `A`. The following can be written to work with `BC`, `DE`, `HL`, `IX`, or `IY`.

`xor a ;ld a,0sub cld c,asbc a ;loads &FF into A if "sub c" set the carry (borrow) flag. Otherwise, a remains zero.sub b ld b,a`