Encontrar y usar bibliotecas de solidez (es decir, funciones matemáticas)

Actualmente, la biblioteca estándar aún no está completamente configurada, pero en este caso, lo que haría sería vincular sus contratos a la dirección de su biblioteca (y, con suerte, asignarlo a un registro con nombre en ese caso). Eso se implementará en el futuro y será mucho más fácil cuando llegue ese momento.

Sin embargo, hasta entonces, tendrá que hacerlo manualmente, es decir, de la manera difícil.

Una cosa que haría sería extraer la función de raíz cuadrada de este contenedor dapp (aunque, francamente, no vale la pena usarla en este momento, ya que la variable de punto fijo aún no se ha configurado, pero la usaremos para este ejemplo)

https://github.com/ethereum/dapp-bin/blob/master/library/math.sol

harías algo en la línea de

import "math.sol"

contract myContract {
    function f() {
        int a = Math.sqrt(9);
    }
}

desde allí, el indicador --libraries le permitió vincularse a ciertas direcciones donde el argumento es el nombre de la biblioteca seguido de la dirección, por lo que si tiene la biblioteca matemática en la dirección 0x123456, la nombraría:

solc yourContract.sol --libraries Math: 0x123456

Mi biblioteca matemática avanzada PRBMath ofrece sqrt, entre muchas otras funciones. Voy a pegar mi implementación aquí, para la posteridad, pero consulte el repositorio vinculado para obtener el código más actualizado.

/// @notice Calculates the square root of x, rounding down.
/// @dev Uses the Babylonian method https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method.
/// @param x The uint256 number for which to calculate the square root.
/// @return result The result as an uint256.
function sqrt(uint256 x) internal pure returns (uint256 result) {
    if (x == 0) {
        return 0;
    }

    // Calculate the square root of the perfect square of a power of two that is the closest to x.
    uint256 xAux = uint256(x);
    result = 1;
    if (xAux >= 0x100000000000000000000000000000000) {
        xAux >>= 128;
        result <<= 64;
    }
    if (xAux >= 0x10000000000000000) {
        xAux >>= 64;
        result <<= 32;
    }
    if (xAux >= 0x100000000) {
        xAux >>= 32;
        result <<= 16;
    }
    if (xAux >= 0x10000) {
        xAux >>= 16;
        result <<= 8;
    }
    if (xAux >= 0x100) {
        xAux >>= 8;
        result <<= 4;
    }
    if (xAux >= 0x10) {
        xAux >>= 4;
        result <<= 2;
    }
    if (xAux >= 0x8) {
        result <<= 1;
    }

    // The operations can never overflow because the result is max 2^127 when it enters this block.
    unchecked {
        result = (result + x / result) >> 1;
        result = (result + x / result) >> 1;
        result = (result + x / result) >> 1;
        result = (result + x / result) >> 1;
        result = (result + x / result) >> 1;
        result = (result + x / result) >> 1;
        result = (result + x / result) >> 1; // Seven iterations should be enough
        uint256 roundedDownResult = x / result;
        return result >= roundedDownResult ? roundedDownResult : result;
    }
}