Hacker News Board Hacker News, browsed like a classic message board
Live data from Hacker News

Signed Integers Are Two’s Complement

open-std.org

Post reply on HN
Print view View original

31–40 of 126 posts

Re: Signed Integers Are Two’s Complement

#31

Post by DoofusOfDeath »

caf wrote: post #25
userbinator wrote: post #17

Earlier quoted context omitted.

It prevents risky optimisations; this now requires the compiler to prove that such optimisations won't change the semantics of the code, e.g. in your case by essentially proving that the high 2 bits of x (only 1 in the unsigned case, due to sign-extension) will never be set. ...and it could be argued that if the compiler couldn't prove that was true, then it just helped you find a possible overflow bug in the code. I…

However it also prevents "abort on overflow" implementations from being conforming, which look like a much better way of finding actual overflow bugs in the code.

That's a question of static vs. dynamic analysis for bug detection.

Which one(s) is/are most useful depends on the user's needs.

Re: Signed Integers Are Two’s Complement

#32

Post by unwind »

wyldfire wrote: post #14
paulddraper wrote: post #12

Earlier quoted context omitted.

The comment suggested the standard make it implementation defined rather than undefined. There's not a meaningful difference here. Even today, an implementation may define unsigned overflow.

Oh, I see, I wonder if greenhouse_gas is suggesting a feature similar to sizeof() that can be used to portably adapt your program's design to the target's overflow capability.

C language lawyer in training: sizeof is not a function.

The parentheses are part of the operand and only needed for type names, to make them into cast expressions.

Re: Signed Integers Are Two’s Complement

#33

Post by beyondCritics »

Getting rid of this useless (crap #!§$§$§$) legacy stuff was overdue, so i am very happy to see it done. I personally think it is _the_ most important proposal for C++20, since it will remove a lot of pointless pressure from secure coding attempts and in turn make the world a little bit more secure.

Re: Signed Integers Are Two’s Complement

#34

Post by Phrodo_00 »

userbinator wrote: post #19
lopmotr wrote: post #16

Earlier quoted context omitted.

Was that ever really a reason for signed magnitude, or did people just make use of the 2nd representation of zero because because it was available and they couldn't be bothered putting that information in another variable or using floating point or fixed point, or anything else that would have achieved the same result?

I have a feeling signed-magnitude predates binary and complement arithmetic --- it is, after all, the "natural" way humans work with numbers. A lot of the early non-binary computers used some form of sign-magnitude, all the way back to punch card formats: https://en.wikipedia.org/wiki/Signed_overpunch On the other hand (no pun intended), early mechanical (decimal) manual adding machines made use of complement arithme…

TIL about signed overpunch

Except the "natural" way also recognizes a single zero with no sign, so it's still not accurately modeling that.

If you wanted to model natural arithmetic accurately you'd need 2 bits for the sign (positive, negative, unsigned). At that point, all of single bit signed magnitude, and complements are compromises.

Re: Signed Integers Are Two’s Complement

#35

Post by ridiculous_fish »

greenhouse_gas wrote: post #7

The real issue isn't that C doesn't have a standard int overflow, but that it's undefined. What they could have done is made it implementation defined , like sizeof(int), which depends on the implementation (hardware) but on the other hand isn't undefined behavior (so on x86/amd4 sizeof(int) will always be equal to 4).

The modern case for keeping signed overflow as UB is that it unlocks compiler optimizations. For example, it allows compilers to assume that `x+1>x`.

If implementations are forced to define signed overflow, then these optimizations are necessarily lost. So implementation-defined is effectively the same as fully-defined.

Re: Signed Integers Are Two’s Complement

#36

Post by int0x80 »

greenhouse_gas wrote: post #7

The real issue isn't that C doesn't have a standard int overflow, but that it's undefined. What they could have done is made it implementation defined , like sizeof(int), which depends on the implementation (hardware) but on the other hand isn't undefined behavior (so on x86/amd4 sizeof(int) will always be equal to 4).

Just a nitpick. Implementation is about the particular compiler and runtime (stdlib) implementation, not the hardware. Hardware is the platform hosting the implementation (this are ISO C-standard defined terms).

A compiler targeting x86 platform can implement sizeof int == 8, or whatever it pleases, as far as C std is concerned.

In practice compilers dont get creative about this. But there are real world cases where stuff is different, for example: http://www.unix.org/version2/whatsnew/lp64_wp.html

Re: Signed Integers Are Two’s Complement

#38

Post by sasaf5 »

fred256 wrote: post #3

I'm curious why some old architectures didn't use two's complement for signed numbers. What advantage did one's complement or signed magnitude have over two's complement?

With one's complement it is easier to multiply by minus one: just invert all bits. It is also symmetrical around the zero, so sequences of random numbers will truly tend to average to zero.

Re: Signed Integers Are Two’s Complement

#39

Post by Animats »

userbinator wrote: post #19
lopmotr wrote: post #16

Earlier quoted context omitted.

Was that ever really a reason for signed magnitude, or did people just make use of the 2nd representation of zero because because it was available and they couldn't be bothered putting that information in another variable or using floating point or fixed point, or anything else that would have achieved the same result?

I have a feeling signed-magnitude predates binary and complement arithmetic --- it is, after all, the "natural" way humans work with numbers. A lot of the early non-binary computers used some form of sign-magnitude, all the way back to punch card formats: https://en.wikipedia.org/wiki/Signed_overpunch On the other hand (no pun intended), early mechanical (decimal) manual adding machines made use of complement arithme…

Burroughs 5xxx and 6xxx machines used signed-magnitude.

Burroughs had a unique numeric representation. Numbers were 48 bits. Sign, sign of exponent, exponent, mantissa, with the binary point at the low end. Integers were thus valid floating point numbers. The math operations would maintain a value as an integer, with a zero exponent, if possible.

IEEE floating point also maintains integer values as integers until they don't fit, but the representation is not integer-like.

Re: Signed Integers Are Two’s Complement

#40

Post by daveFNbuck »

0xcde4c3db wrote: post #6
fred256 wrote: post #3

I'm curious why some old architectures didn't use two's complement for signed numbers. What advantage did one's complement or signed magnitude have over two's complement?

It can be useful to distinguish between positive and negative zero in some cases, for example when dealing with values that have been rounded to zero or limits approaching zero.

That's true for limits approaching any number, so if that's important you'll need more than negative zero.
Post reply on HN