Solidity EVM – How to Convert Default Two’s Complement to Sign Magnitude

bit-manipulationevmintegerssolidity

According to this answer the EVM by default uses two's complement notation for handling signed integers. However for my application I would like to work with the sign-magnitude representation
where the sign can either be 0 or 1 corresponding to + or – respectively and the remaining bits comprise the magnitude. For example, if a int8 variable has a value of +1 it would be represented in binary as 0000_0001 and if it has a value of -1 it would 1000_0001 in sign-magnitude notation.

However since the EVM uses two's complement I first have to convert it into sign-magnitude representation before I can work with it. How exactly would I do this in a gas-efficient manner?

function twos_comp_to_sign_mag(int8) returns(int8);

// 255 in binary is 1111_1111 or -1 in two's complement notation
// 129 in binary is 1000_0001 or -1 in sign-magnitude notation
twos_comp_to_sign_mag(255) == 129

Best Answer

I asked basically the same question on StackOverflow but for python, below is my solidity adaptation using this answer:

// SPDX-License-Identifier: GPL-3.0
contract TwosComplement {

    function twos_comp_to_sign_mag(int8 value) external pure returns(int8) {
        
        int8 mask = 2**7 - 1; // 0111_1111

        if (value < 0) {
            value = -(value & mask);
        }
        return (-1 & value) | (value & mask);        
    }
}

where the following holds true:

twos_comp_to_sign_mag(positiveInt) == positiveInt;
// e.g.: twos_comp(0) == 0

twos_comp_to_sign_mag(negativeInt) == -128 - negativeInt;
// ex1: twos_comp(-1) == -128 - (-1) = -128 + 1 = -127
// ex2: twos_comp(-127) == -128 - (-127) = -128 + 127 = -1
// ex3: twos_comp(-128) == -128 - (-128) = -128 + 128 = 0

To adjust this for larger integer types is really simple; change the variable types accordingly and update the mask, so for int16 the mask will be 2**15 - 1.

Related Solutions

[Ethereum] how to use multiple modofier to form combinations of boolean conditions

There is no direct way in solidity. I'll explain you why. Modifier is like a macro function while compiling it will replace your modifier with its actuval implementation. Here _; replace with your function implementation.

contract ModiferTesting {
   uint public a;
   uint public b;
   uint public c;

   modifier modA() {
    a = a + 1;
    _;
   }

   modifier modB() {
    b = b + 1;
    _;
    b = b + 1;
    _;
    b = b + 1;
    _;
  }

  function test() public modA modB {
    c = c + 1;
  }
}

If you debug, above code you can find a=1, b=3, c=3

Try to write an other modifier that check's or condition.

Solidity Structs – How to Give Struct Members Default Values

No, this can't be done in Solidity. The reason is that there's no explicit allocation, and all slots in storage are implicitly zero until set to something else.

A pattern to use here would be to use a boolean value indicating whether a struct had been initialized (false by default because that's the zero value of a boolean), and everywhere you read a struct, check that flag and initialize if needed first. Something like this:

struct AttributeStats {
    bool initialized;
    Status status;
    bytes32 validationDuration;
    bytes32 value;
}
mapping (uint256 => AttributeStats) attributeStats;

function initializeIfNeeded(uint256 id) internal {
    AttributeStats stats = attributeStats[id];

    if (!stats.initialized) {
        stats.initialized = true;
        stats.validationDate = now;
        stats.status = 1;
        stats.validationDuration = 356;
    }        
}

function doSomething(uint256 id) public {
    initializeIfNeeded(id);

    AttributeStats storage stats = attributeStats[id];

    // ...
}

(It's unclear what now you meant to use in your pseudocode. I assumed you want to use the time when you initialize the struct, but if you wanted to use something like the time of contract creation, just store that in a variable in the constructor and use that instead.)

Best Answer

Related Solutions

[Ethereum] how to use multiple modofier to form combinations of boolean conditions

Solidity Structs – How to Give Struct Members Default Values

Related Topic