Rosetta Code

Two's complement: Difference between revisions

Page Discussion

Two's complement (view source)

Revision as of 16:03, 14 February 2024

9,204 bytes added ,  3 months ago
m
→‎{{header|Wren}}: Changed to Wren S/H
(Two's complement in FreeBASIC)
m (→‎{{header|Wren}}: Changed to Wren S/H)
 
(32 intermediate revisions by 15 users not shown)
Line 13:
=={{header|6502 Assembly}}==
===8-Bit===
<langsyntaxhighlight lang="6502asm">LDA #%01010101
EOR #255
CLC
ADC #1 ;result: #%10101011</langsyntaxhighlight>
===16-bit===
<langsyntaxhighlight lang="6502asm">myVar equ $20
 
LDA #3
Line 39:
LDA myVar+1
ADC #0
STA myVar+1</langsyntaxhighlight>
 
=={{header|68000 Assembly}}==
<syntaxhighlight lang="68000devpac">MOVE.L #3,D0
NEG.L D0 ;D0 = #$FFFFFFFD</syntaxhighlight>
 
=={{header|8086 Assembly}}==
<langsyntaxhighlight lang="asm">mov al,17
neg al ;8-bit
mov bx,4C00h
neg bx ;16-bit</langsyntaxhighlight>
 
 
=={{header|ALGOL 68}}==
Line 52 ⟶ 55:
<br>
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 <code>1 + ABS NOT BIN a</code> is a long-winded alternative to <code>-a</code>. Note in Algol 68, the BIN operator cannot be applied to negative integers, so <code>1 + ABS NOT BIN -3</code> won't work.
<langsyntaxhighlight lang="algol68">BEGIN
INT a := 3;
print( ( -a, " ", 1 + ABS NOT BIN a, newline ) )
END</langsyntaxhighlight>
{{out}}
<pre>
Line 63 ⟶ 66:
=={{header|ALGOL W}}==
{{Trans|ALGOL 68}}
<langsyntaxhighlight lang="algolw">begin
integer a;
a := 3;
write( i_w := 1, s_w := 1, -a, 1 + number( not bitstring( a ) ) )
end.</langsyntaxhighlight>
{{out}}
<pre>
-3 -3
</pre>
 
=={{header|ARM Assembly}}==
<syntaxhighlight lang="arm assembly">MOV R0,#0x0000000F
MOV R1,#1
MVN R0,R0 ;flips the bits of R0, R0 = 0xFFFFFFF0
ADD R0,R0,R1 ;R0 = 0xFFFFFFF1</syntaxhighlight>
 
=={{header|C}}==
<langsyntaxhighlight Clang="c">int a = 3;
a = -a;</langsyntaxhighlight>
 
=={{header|C++}}==
In C++ the two's complement of an integer 'n' is its arithmetic negation '-n'.
 
The two's complement of an integer 'n' can also be calculated by adding 1 to its bitwise complement '~n'.
<syntaxhighlight lang="c++">
#include <cstdint>
#include <iostream>
#include <iomanip>
#include <vector>
#include <bitset>
 
std::string to_hex(const int32_t number) {
std::stringstream stream;
stream << std::setfill('0') << std::setw(8) << std::hex << number;
return stream.str();
}
 
std::string to_binary(const int32_t number) {
std::stringstream stream;
stream << std::bitset<16>(number);
return stream.str();
}
 
int32_t twos_complement(const int32_t number) {
return ~number + 1;
}
 
std::string to_upper_case(std::string str) {
for ( char& ch : str ) {
ch = toupper(ch);
}
return str;
}
 
int main() {
std::vector<int32_t> examples = { 0, 1, -1, 42 };
 
std::cout << std::setw(9) << "decimal" << std::setw(12) << "hex"
<< std::setw(17) << "binary" << std::setw(25) << "two's complement" << std::endl;
std::cout << std::setw(6) << "-----------" << std::setw(12) << "--------"
<< std::setw(20) << "----------------" << std::setw(20) << "----------------" << std::endl;
 
for ( const int32_t& example : examples ) {
std::cout << std::setw(6) << example << std::setw(17) << to_upper_case(to_hex(example))
<< std::setw(20) << to_binary(example) << std::setw(13) << twos_complement(example) << std::endl;
}
}
</syntaxhighlight>
{{ out }}
<pre>
decimal hex binary two's complement
----------- -------- ---------------- ----------------
0 00000000 0000000000000000 0
1 00000001 0000000000000001 -1
-1 FFFFFFFF 1111111111111111 1
42 0000002A 0000000000101010 -42
</pre>
 
=={{header|Craft Basic}}==
<syntaxhighlight lang="basic">let d = 1234567
 
dim b[d * -1, d * -1 + 1, -2, -1, 0, 1, 2, d - 2, d - 1]
 
arraysize s, b
 
for i = 0 to s - 1
 
print b[i], " : ", b[i] * -1
 
next i
 
end</syntaxhighlight>
{{out| Output}}<pre>
-1234567 : 1234567
-1234566 : 1234566
-2 : 2
-1 : 1
0 : 0
1 : -1
2 : -2
1234565 : -1234565
1234566 : -1234566
</pre>
 
=={{header|Delphi}}==
{{works with|Delphi|6.0}}
{{libheader|SysUtils,StdCtrls}}
 
 
<syntaxhighlight lang="Delphi">
 
procedure TwosCompliment(Memo: TMemo);
var N: integer;
begin
N:=123456789;
Memo.Lines.Add(Format('N=%10d $%0.8x',[N,N]));
Memo.Lines.Add('');
Memo.Lines.Add('N:=(N xor $FFFFFFFF)+1');
N:=(N xor $FFFFFFFF)+1;
Memo.Lines.Add('');
Memo.Lines.Add(Format('N=%10d $%0.8x',[N,N]));
end;
 
 
</syntaxhighlight>
{{out}}
<pre>
N= 123456789 $075BCD15
 
N:=(N xor $FFFFFFFF)+1
 
N=-123456789 $F8A432EB
Elapsed Time: 5.206 ms.
</pre>
 
 
=={{header|Forth}}==
{{works with|gforth|0.7.3}}
Forth uses two's complement internally. One can use the 'base' variable to switch from one base to another.
<syntaxhighlight lang="forth">: 2s'complement base @ swap dup negate swap 2 base ! u. u. base ! ;
25 2s'complement</syntaxhighlight>
 
{{out}}
<pre>11001 1111111111111111111111111111111111111111111111111111111111100111 ok
</pre>
 
 
=={{header|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.
<langsyntaxhighlight lang="freebasic">Dim As Integer d1 = 2147483648, d2 = 2147483646
Dim 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 i
Sleep</langsyntaxhighlight>
{{out}}
<pre>0000000000000011 -> 1111111111111101</pre>
 
=== inline assembly ===
<langsyntaxhighlight lang="freebasic">Dim As Integer a = &b000011
Dim As Integer a2c, l
#ifdef __FB_64BIT__
Line 108 ⟶ 244:
 
Print Bin(a, l); " -> "; Bin(a2c, l)
Sleep</langsyntaxhighlight>
{{out}}
<pre>-2147483648 -> 2147483648
Line 122 ⟶ 258:
=={{header|J}}==
J uses twos complement natively:
<langsyntaxhighlight Jlang="j"> -3
_3</langsyntaxhighlight>
 
We can see this by extracting bits representing the number. In this example, we limit ourselves to 8 bits:
 
<langsyntaxhighlight Jlang="j"> (8#2)#:3
0 0 0 0 0 0 1 1
(8#2)#:-3
1 1 1 1 1 1 0 1</langsyntaxhighlight>
 
=={{header|Java}}==
In Java the two's complement of an integer 'n' is its arithmetic negation '-n'.
 
The two's complement of an integer 'n' can also be calculated by adding 1 to its bitwise complement '~n'.
<syntaxhighlight lang="java">
import java.util.List;
 
public final class TwosComplement {
 
public static void main(String[] args) {
List<Integer> examples = List.of( 0, 1, -1, 42 );
System.out.println(String.format("%9s%12s%24s%34s", "decimal", "hex", "binary", "two's complement"));
System.out.println(
String.format("%6s%12s%24s%32s", "-----------", "--------", "----------", "----------------"));
for ( int example : examples ) {
System.out.println(String.format("%5d%18s%36s%13d",
example, toHex(example), toBinary(example), twosComplement(example)));
}
}
private static String toHex(int number) {
return String.format("%8s", Integer.toHexString(number).toUpperCase()).replace(" ", "0");
}
private static String toBinary(int number) {
return String.format("%32s", Integer.toBinaryString(number)).replace(" ", "0");
}
private static int twosComplement(int number) {
return ~number + 1;
}
 
}
</syntaxhighlight>
{{ out }}
<pre>
decimal hex binary two's complement
----------- -------- ---------- ----------------
0 00000000 00000000000000000000000000000000 0
1 00000001 00000000000000000000000000000001 -1
-1 FFFFFFFF 11111111111111111111111111111111 1
42 0000002A 00000000000000000000000000101010 -42
</pre>
 
=={{header|Jakt}}==
<syntaxhighlight lang="jakt">
fn main() {
let n = 0xabcdeabcdeu64
println("{:064b}", n)
println("{:064b}", ~n + 1)
println("{:064b}", -n) // Same result
}
</syntaxhighlight>
{{out}}
<pre>
0000000000000000000000001010101111001101111010101011110011011110
1111111111111111111111110101010000110010000101010100001100100010
1111111111111111111111110101010000110010000101010100001100100010
</pre>
 
=={{header|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.
=={{header|M2000 Interpreter}}==
 
 
<syntaxhighlight lang="m2000 interpreter">
Module Complement2{
// we use binary.and to get a number in range of byte 0 to 255
byte k, v
v=random(1, 255) ' there is no two's complement for zero
z=binary.and(binary.not(v)+1, 0xFF)
print v
print z
print z=255-v+1 // z is type of byte always positive
print sint(z+0xFFFFFF00)=-v // using 4bytes, we add unsinged 0xFFFFFF00
}
Complement2
Complement2
</syntaxhighlight>
{{out}}
<pre>
2
254
True
True
208
48
True
True
</pre>
 
=={{header|Nim}}==
We define a function to compute the two’s complement by taking the logical complement and adding one. As Nim uses the native complement of the computer, which is two’s complement, the result should be equal to the arithmetic negation.
 
<syntaxhighlight lang="Nim">import std/[strformat, strutils]
 
func twosComplement[T: SomeSignedInt](n: T): T =
## Compute the two's complement of "n".
not n + 1
 
echo &"""{"n":^15}{"2's complement":^15}{"-n":^15}"""
for n in [0i32, 1i32, -1i32]:
echo &"{n.toHex:^15}{twosComplement(n).toHex:^15}{(-n).toHex:^15}"
for n in [-50i8, 50i8]:
echo &"{n.toHex:^15}{twosComplement(n).toHex:^15}{(-n).toHex:^15}"
</syntaxhighlight>
 
{{out}}
<pre> n 2's complement -n
──────── ────────────── ────────
00000000 00000000 00000000
00000001 FFFFFFFF FFFFFFFF
FFFFFFFF 00000001 00000001
CE 32 32
32 CE CE
</pre>
 
=={{header|Perl}}==
<syntaxhighlight lang="perl" line>use strict;
use warnings;
 
for ( -2**31, -2**31+1, -2, -1, 0, 1, 2, 2**31-2, 2**31-1 ) {
printf "$_ -> %d\n", $_ == 0 ? 0 : ~$_+1
}</syntaxhighlight>
Output is the same as the Wren entry.
 
=={{header|Phix}}==
=== inline assembly ===
<!--<langsyntaxhighlight Phixlang="phix">-->
<span style="color: #008080;">without</span> <span style="color: #008080;">js</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">a</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0b000011</span><span style="color: #0000FF;">,</span>
Line 152 ⟶ 413:
}
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%032b -&gt; %032b\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">a</span><span style="color: #0000FF;">,</span><span style="color: #000000;">a2c</span><span style="color: #0000FF;">})</span>
<!--</langsyntaxhighlight>-->
{{out}}
<pre>
Line 158 ⟶ 419:
</pre>
=== normal hll ===
<!--<langsyntaxhighlight Phixlang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">a</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0b000011</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%032b -&gt; %032b\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">a</span><span style="color: #0000FF;">,-</span><span style="color: #000000;">a</span><span style="color: #0000FF;">})</span>
<!--</langsyntaxhighlight>-->
Same output (naturally the rhs is twice as long under 64 bit, in both cases)
 
Line 169 ⟶ 430:
<br>
Even though the original PL/M 8080 compiler only handles unsigned integers, <code>-A</code> two's complements <code>A</code>.
<langsyntaxhighlight lang="pli">100H: /* TWO'S COMPLEMENT *?
 
/* CP/M BDOS SYSTEM CALL */
Line 194 ⟶ 455:
CALL PR$NL;
 
EOF</langsyntaxhighlight>
{{out}}
<pre>
01 FF
</pre>
 
=={{header|Python}}==
<syntaxhighlight lang="python">-n</syntaxhighlight>
or
<syntaxhighlight lang="python">~n+1</syntaxhighlight>
 
=={{header|Quackery}}==
 
Ways of calculating the two's complement of an integer in Quackery include <code>negate</code>, <code>~ 1+</code>, <code>-1 *</code>, and <code>0 swap -</code>.
 
These are demonstrated as a dialogue in the Quackery shell.
 
<pre>/O> 37 negate
...
 
Stack: -37
 
/O> negate
...
 
Stack: 37
 
/O> ~ 1+
...
 
Stack: -37
 
/O> ~ 1+
...
 
Stack: 37
 
/O> -1 *
...
 
Stack: -37
 
/O> -1 *
...
 
Stack: 37
 
/O> 0 swap -
...
 
Stack: -37
 
/O> 0 swap -
...
 
Stack: 37
 
/O> </pre>
 
=={{header|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.) [https://raku.land/githubzef:thundergnat/FixedInt 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.
Line 209 ⟶ 523:
Here we'll demonstrate twos complement on a 57 bit integer.
 
<syntaxhighlight lang="raku" perl6line>use FixedInt;
 
# Instantiate a new 57(!) bit fixed size integer
Line 222 ⟶ 536:
 
say fixedint; # Echo the value to the console in decimal format
say fixedint.bin; # Echo the value to the console in binary format</langsyntaxhighlight>
{{out}}
<pre>144114427045277101
Line 228 ⟶ 542:
761030578771
0b000000000000000001011000100110000111101010001001001010011</pre>
 
=={{header|RPL}}==
RPL can handle integers whose size can be set from 1 to 64 bits. For this task, a 8-bit size is selected with <code>STWS</code>.
RPL considers 'true' integers (i.e. declared by the prefix <code>#</code>) to be positive, so the two's complement can not be done by the <code>NEG</code> instruction.
8 STWS BIN
#3d NOT 1 +
{{out}}
<pre>
1: #11111101b
</pre>
=={{header|Ruby}}==
Ruby integers have a built-in 'one-complement'method: '''~''', which flips all bits. Adding 1 leads to a negative integer:
<syntaxhighlight lang="ruby">~42 + 1 # => -42
</syntaxhighlight>
 
=={{header|Wren}}==
Line 233 ⟶ 561:
 
This is illustrated by running the following code:
<langsyntaxhighlight ecmascriptlang="wren">var a = 0
a = -a
System.print(a) // -0</langsyntaxhighlight>
which produces 'negative zero' rather than just 'zero'.
 
Line 242 ⟶ 570:
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:
 
<langsyntaxhighlight ecmascriptlang="wren">var pow32 = 2.pow(32)
var pow31 = 2.pow(31)
var bs = [-pow31, -pow31+1, -2, -1, 0, 1, 2, pow31-2, pow31-1]
Line 249 ⟶ 577:
if (b2 > pow31) b2 = b2 - pow32
System.print("%(b) -> %(b2)")
}</langsyntaxhighlight>
 
{{out}}
Line 265 ⟶ 593:
 
=={{header|XPL0}}==
<langsyntaxhighlight XPL0lang="xpl0">int I; char C;
[I:= 123;
I:= (~I) + 1;
Line 272 ⟶ 600:
C:= ~(C-1);
IntOut(0, C); CrLf(0);
]</langsyntaxhighlight>
 
{{out}}
Line 285 ⟶ 613:
'''Zilog Z80'''
 
<langsyntaxhighlight lang="z80">ld a,%00001111
neg ;returns %11110001 in a</langsyntaxhighlight>
 
'''Game Boy'''
<langsyntaxhighlight lang="z80">ld a,%00001111
cpl ;game boy doesn't have NEG but it has CPL which flips all the bits.
inc a ;returns %11110001 in a</langsyntaxhighlight>
 
===16 Bit===
<code>NEG</code> and <code>CPL</code> only work on the accumulator <code>A</code>.
The following can be written to work with <code>BC</code>, <code>DE</code>, <code>HL</code>, <code>IX</code>, or <code>IY</code>.
<langsyntaxhighlight lang="z80">xor a ;ld a,0
sub c
ld c,a
sbc a ;loads &FF into A if "sub c" set the carry (borrow) flag. Otherwise, a remains zero.
sub b
ld b,a</langsyntaxhighlight>
PureFox
9,482

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/321906...355684"