Two's complement: Difference between revisions
m
→{{header|Wren}}: Changed to Wren S/H
m (Another correction of code formatting.) |
m (→{{header|Wren}}: Changed to Wren S/H) |
||
| (18 intermediate revisions by 6 users not shown) | |||
Line 85:
<syntaxhighlight lang="c">int a = 3;
a = -a;</syntaxhighlight>
=={{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}}==
Line 200 ⟶ 284:
String.format("%6s%12s%24s%32s", "-----------", "--------", "----------", "----------------"));
for (
System.out.println(String.format("%5d%18s%36s%13d",
}
}
Line 248 ⟶ 332:
=={{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}}==
Line 348 ⟶ 460:
01 FF
</pre>
=={{header|Python}}==
<syntaxhighlight lang="python">-n</syntaxhighlight>
or
<syntaxhighlight lang="python">~n+1</syntaxhighlight>
=={{header|Quackery}}==
Line 400 ⟶ 517:
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/
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 435 ⟶ 552:
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}}==
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:
<syntaxhighlight lang="
a = -a
System.print(a) // -0</syntaxhighlight>
Line 448 ⟶ 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:
<syntaxhighlight lang="
var pow31 = 2.pow(31)
var bs = [-pow31, -pow31+1, -2, -1, 0, 1, 2, pow31-2, pow31-1]
| |||