¿Cuál es la forma más económica de redondear () o ceil () a un múltiplo de 1000?

¿Cuál es la forma más económica de redondear () o ceil () a un múltiplo de 1000?

Por ejemplo, si se implementa la forma más económica de redondear en la función ceil:

function ceil(uint a, uint m) returns (uint) {
    //some cheap roundup to muliple function
}

entonces se espera que:

  • techo (123456,1000) == 124000
  • techo(1,1000) == 1000
  • techo (0,1000) == 0
  • techo (123000,1000) == 123000

Respuestas (2)

Aquí hay una solución:

contract Ceil {
    function ceil(uint a, uint m) constant returns (uint ) {
        return ((a + m - 1) / m) * m;
    }

    // To measure gas
    function ceil1(uint a, uint m) returns (uint ) {
        return ((a + m - 1) / m) * m;
    }
}

Y probando los resultados correctos:

> ceil.ceil(123456, 1000)
124000
> ceil.ceil(1,1000)
1000
> ceil.ceil(0,1000)
0
> ceil.ceil(123000,1000)
123000

Para medir el gas, he creado ceil1(...)y enviado una transacción:

> ceil.ceil1(123456, 1000, eth.accounts[0], {
   from:web3.eth.accounts[0], 
   data: ceilCompiled.Ceil.code,
   gas: 1000000
});
"0xeac6bb84ba5a1703ee3a762cb392f1793adf550906b6112e441928c0ea288f53"
...
> debug.traceTransaction("0xeac6bb84ba5a1703ee3a762cb392f1793adf550906b6112e441928c0ea288f53")
{
  gas: 21990,
  returnValue: "000000000000000000000000000000000000000000000000000000000001e460",
  structLogs: [{

El costo del gas de este cálculo es de 21.990. Esta cifra incluiría el valor predeterminado de 21 000 gas por enviar una transacción regular que da un costo incremental de gas de 990.

Al conectar el código en Online Solidity Compiler en https://chriseth.github.io/browser-solidity/#version=soljson-latest.js , se estiman los siguientes costos de gasolina:

Creation: 69 + 43000
External:
  ceil(uint256,uint256): 275
  ceil1(uint256,uint256): 253
Internal:

Entonces, una estimación del costo del gas ceil1(...)es entre 253 y 990.

No sé si esta es la más barata, pero una de las soluciones que he logrado inventar es esta:

function ceil(uint a, uint m) returns (uint r) {
    return (a + m - 1) / m * m;
}