How to convert from sign-magnitude to two's complement

Question

How would I convert from sign-magnitude to two's complement. I don't know where to start. Any help would be appreciated. I can only use the following operations:!,~,|,&,^,+,>>,<<.

/*
 * sm2tc - Convert from sign-magnitude to two's complement
 *   where the MSB is the sign bit
 *   Example: sm2tc(0x80000005) = -5.
 *   
 */
int sm2tc(int x) {

return 2;
}

Begin by familiarizing yourself with how the numbers are stored in sign-magnitude and two's complement. The operation can be simply implemented with only bitwise operations. — Daniel Kamil Kozar, Feb 17 '14 at 18:55
@Daniel Kamil Kozar do you consider `!` a bit-wise operator? — chux - Reinstate Monica, Feb 17 '14 at 21:36
Interesting that a solution with `-` operator (not in the set `!,~,|,&,^,+,>>,<<`) was selected as the answer. — chux - Reinstate Monica, Feb 19 '14 at 19:55

score 3 · Accepted Answer · answered Feb 18 '14 at 18:23

You can convert signed-magnitude to two's complement by subtracting the number from 0x80000000 if the number is negative. This will work for a 32-bit integer on a machine using two's complement to represent negative values, but if the value is positive this will result in a two's complement negation. A right shift of a two's complement negative number will shift in one's, we can utilize this to make a mask to select between the original value, or the conversion of a signed-magnitude negative value to a two's complement negative value.

int sm2tc(int x) {
  int m = x >> 31;
  return (~m & x) | (((x & 0x80000000) - x) & m);
}

score 1 · Answer 2 · answered Feb 17 '14 at 19:27

1

There you go.

uint32_t sm2tc(uint32_t x)
{
        return (x & 0x80000000)
                ? ((~(x & 0x7fffffff)) + (uint32_t)1)
                : x;
}

answered Feb 17 '14 at 19:27

Daniel Kamil Kozar

18,476
5
50
64

do you know how to do it wiithout using ? and: – user3316874 Feb 17 '14 at 21:24
2

what kind of person needs to know the answer to the original question and isn't comfortable converting from the ternary op to if/then – Andrey Mishchenko Feb 17 '14 at 21:32
@user3316874 : it's less than trivial. Consult your C reference book. – Daniel Kamil Kozar Feb 17 '14 at 22:37

cmaster - reinstate monica · Answer 3 · 2014-02-18T10:06:27.737

1

Interestingly, the conversion between the two formats is symmetrical, so you need only one conversion function to swap from one format to the other. Here is the complete conversion without relying on any conditionals:

uint32_t convertSignRepresentation(uint32_t in) {
    uint32_t mask = -(in >> 31);
    return mask&0x80000000-in | ~mask&in;
}

The technique I used here is essentially replacing the conditional operator in

uint32_t convertSignRepresentation(uint32_t in) {
    return (in >> 31) ? 0x80000000-in : in;
}

by a bitmask of only zeros or ones to select the correct resulting value.

Please note, that 0x80000000 (either smallest possible value, or negative zero) is projected to positive zero, and cannot be recovered. So convertSignRepresentation(converSignRepresentation(0x80000000)) yields zero instead of 0x80000000. This might give nasty surprises. It might be avoided in theory by mapping 0x80000000 onto itself, but that is not as easy to do and has even nastier surprises...

Edit:
A comment pointed out that subtraction was not on the list of allowed operators, even though addition is. I don't know whether this was deliberate or a mistake. Anyways, the operation -x can be written as ~x + 1. With this, the code becomes:

uint32_t convertSignRepresentation(uint32_t in) {
    uint32_t mask = ~(in >> 31) + 1;
    return mask&0x80000001+~in | ~mask&in;
}

edited Feb 18 '14 at 10:06

answered Feb 17 '14 at 22:06

cmaster - reinstate monica

38,891
9
62
106

Does this not use the `-` operator which is not in OP's list of `!,~,|,&,^,+,>>,<<`? – chux - Reinstate Monica Feb 18 '14 at 00:29
@chux Thanks, that little detail escaped my notice. (I saw the `+` and jumped to the conclusing that additive arithmetic is allowed. If you know a bit about the hardware, you know that the command for `a - b` will just negate b before feeding it into the adder, and supply a carry of 1 to the first bit, so it's really just an addition.) But I added instructions to avoid `-` to my answer now. – cmaster - reinstate monica Feb 18 '14 at 10:05
Note: there are hardware designs that use a [subtractive adder](http://www.fourmilab.ch/documents/univac/minuszero.html) such that all addition is done by first negating an addend and then subtracting. Certainly not common with 2's, but part of the various methods to implement arithmetic in hardware. – chux - Reinstate Monica Feb 18 '14 at 14:44
If I try 0x80000000 I get 0x80000000 in return, but I should be getting 0x00. Why is that. Also my compiler doesn't recognize uint32_t so I'm just using int. – user3316874 Feb 19 '14 at 01:30
`uint32_t` is defined in `stdint.h`, and is an **unsigned** 32-bit integer type. `int` is a **signed** type. All sane compilers implement the right shift operation on signed types to be sign preserving, copying the sign bit into the bits that are shifted in. Consequently `in >> 31` yields `0xffffffff` if `in` is signed, `0x00000001` if it's unsigned. So, if you use `int`, you work with a wrong mask of `0x00000001` instead of `0xffffffff`. The result is, that the first 31 bits come from `in` instead of `0x80000000-in`. – cmaster - reinstate monica Feb 19 '14 at 08:03

score 0 · Answer 4 · edited Feb 17 '14 at 19:30

Signed Numbers are 8 bit quantities with the least significant 7 bits representing the magnitude and the most significant bit indicating the sign. 0 in this bit indicates the number is positive, and 1 indicates it is negative. There is no magnitude information in this 8th bit-just the sign.

To convert a negative signed number to two's complement, first set the 8th bit to zero. Then invert all 8 bits. Finally add 1. An example follows:

Signed Number:

10001111

set the 8th bit to zero: (use & operator)

00001111

invert all 8 bits: (use bitwise-complement operator)

11110000

finally, add 1; resulting in the final two's complement number: (use + operator)

11110001

If the 8th bit is 0, indicating that the signed number is positive, the number requires no conversion. It's two's complement representation is the same as the signed magnitude representation.

chux - Reinstate Monica · Answer 5 · 2014-02-18T16:57:53.637

0

To convert from Sign Magnitude x to Two's Complement y:

1) On a two's complement machine.
2) Use only !,~,|,&,^,+,>>,<<
3) Does not use ?:, -, *, /
4) Does not assume 4-byte int
5) Work with all Sign Magnitude including +0 and -0

#include <limits.h>
int sm2tc(int x) {
  int sign = x & INT_MIN;
  int negmask = UINT_MAX + !sign;
  return (x & ~negmask) | (negmask & ((~x + 1)^INT_MIN));
}

edited Feb 18 '14 at 16:57

answered Feb 17 '14 at 21:11

chux - Reinstate Monica

143,097
13
135
256

How to convert from sign-magnitude to two's complement

5 Answers5

Linked