Solidity Math – How to Floor or Ceil a Fixed Point Number

fixed-pointmathsolidity

Say I have a signed 64.64 fixed point number 18444899399302180000 or 0.9999 in floating point notation. How can I define a floor and ceil function that floors or ceils an int128 signed 64.64 fixed point number?

function floor(int128) returns(int128);
function ceil(int128) returns(int128);

floor(18444899399302180000) == 0 // floor(0.9999) == 0
floor(-18444899399302180000) == 0 // floor(-0.9999) == -1

ceil(18444899399302180000) == 18446744073709551616 // ceil(0.9999) == 1
ceil(-18444899399302180000) == 0 // ceil(-0.9999) == 0

Btw I'm using ABDKMath64x64 for working with signed 64.64 fixed point numbers.

Best Answer

I managed to implement both floor and ceil as follows. The ABDKMath64x64.toInt function essentially floors the signed fixed point number to a signed integer, hence the following would hold true:

toInt(-18444899399302180000) == -1 i.e. floor(-0.9999) == -1
toInt(0) == 0 i.e. floor(0) == 0
toInt(18444899399302180000) == 0 i.e. floor(0.9999) == 0
toInt(18446744073709551616) == 1 i.e. floor(1) == 1
toInt(-18446744073709551616) == -1 i.e. floor(-1) == -1

so all that is required is to then just cast the resulting integer result back to a signed fixed point number.

For ceil I first check if the signed fixed point number is a whole number integer by %(mod) by 1(unity), if it is then I simply return the number since the ceil of a whole number is that number. Else I take the fixed point number into the real number range above it's current real number range and then floor it, so for example if the number is 0.9999 I take it into the range of it's ceil i.e. [1, 2) by adding unity which makes it 1.9999, then flooring it gives us the ceil i.e. 1 in this case. hence the following holds true:

ceil(-18444899399302180000) == 0 i.e. ceil(-0.9999) == 0
ceil(0) == 0 i.e. ceil(0) == 0
ceil(18444899399302180000) == 0 i.e. ceil(0.9999) == 1
ceil(18446744073709551616) == 1 i.e. ceil(1) == 1
ceil(-18446744073709551616) == -1 i.e. ceil(-1) == -1

pragma solidity ^0.8.0;

import { ABDKMath64x64 } from "./ABDKMath64x64.sol";

contract FloorCeil {

    int128 constant unity = 18446744073709551616;

    function floor(int128 fp) public pure returns(int128) {
        return ABDKMath64x64.fromInt(int256(ABDKMath64x64.toInt(fp)));
    }

    function ceil(int128 fp) public pure returns(int128) {
        if (fp == 0 || fp%unity == 0) {
            return fp;
        }
        return floor(ABDKMath64x64.fromInt(int256(ABDKMath64x64.toInt(ABDKMath64x64.add(fp, unity)))));
    }
}

Related Solutions

Solidity Integer Division – Cannot Perform Integer Division in Solidity

Problem is 4 & 5 fit in less that 256 bits (each). You end up with tiny uints in the constant expression, and then those aren't easily converted to the uint256, so ... cast the type explicitly.

uint x = uint(4)/uint(5);

Takeaway is caution with constants because they may be cast in unexpected types.

A sketchy idea:

contract Divide {
    
    function getDivided(uint numerator, uint denominator) public constant returns(uint quotient, uint remainder) {
        quotient  = numerator / denominator;
        remainder = numerator - denominator * quotient;
    }
}

Also check out "SafeMath" with "safeDiv()" at Zeppelin: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/math/SafeMath.sol

Also, since 4/5 obviously works out to 0 remainder 4, possibly you're really aiming for something more like 80%?

You can bump up the accuracy by working with "decimal" as is common in financial markets. You pass pairs around, the digits and the decimal offset.

So, 1.234 would be written as [1234, 3] with the 3 indicating that there is a decimal in the third spot.

In this case, you would calculate 80, with 2 decimal places (meaning .80).

4 * 10 ** 2 = 400, 400/5 = 80, we raised 4 by 10 ^ 2, so return ... 80,2 and optionally, a remainder.

Hope it helps.

Solidity – How to Write a Contract that Only Accepts Fixed Amount Payments

The functions seem weird... If this is a function that takes money from a user (they are calling payable function and sending your contract money), then why are you subtracting money from their internal balance?

They are depositing money, their balance should increment.

As for accepting a fixed amount of eth, what do you mean? You want the function to be executed only if the amount sent to it is = to certain value? If so:

// This function will fail if the buyer doesn't send the exact amount of money.

function buySomething() payable{
  uint exactAmount = 3000;
  require (msg.value == exactAmount);
  boughtSomething = true;
}

If you want to accept any amount and return the difference:

function buySomethingAndReturnChange() payable{
  uint minAmount = 3000;
  require (msg.value >= minAmount);
  uint moneyToReturn = msg.value - minAmount; 

  boughtSomething = true;
  if(moneyToReturn > 0)
    msg.sender.transfer(moneyToReturn);
}

Best Answer

Related Solutions

Solidity Integer Division – Cannot Perform Integer Division in Solidity

Solidity – How to Write a Contract that Only Accepts Fixed Amount Payments

Related Topic