diff --git a/.gas-snapshot b/.gas-snapshot index 38b6737b..03124789 100644 --- a/.gas-snapshot +++ b/.gas-snapshot @@ -1,134 +1,138 @@ -DecimalFloatAbsTest:testAbsDeployed(bytes32) (runs: 5115, μ: 2425911, ~: 2425853) -DecimalFloatAddTest:testAddDeployed(bytes32,bytes32) (runs: 5115, μ: 2428668, ~: 2428357) -DecimalFloatConstantsTest:testEDeployed() (gas: 2425118) -DecimalFloatConstantsTest:testMaxNegativeValueDeployed() (gas: 2425150) -DecimalFloatConstantsTest:testMaxPositiveValueDeployed() (gas: 2425086) -DecimalFloatConstantsTest:testMinNegativeValueDeployed() (gas: 2425061) -DecimalFloatConstantsTest:testMinPositiveValueDeployed() (gas: 2425040) -DecimalFloatDivTest:testDivDeployed(bytes32,bytes32) (runs: 5115, μ: 2428414, ~: 2428266) -DecimalFloatEqTest:testEqDeployed(bytes32,bytes32) (runs: 5115, μ: 2426317, ~: 2426243) -DecimalFloatFloorTest:testFloorDeployed(bytes32) (runs: 5115, μ: 2426115, ~: 2426098) -DecimalFloatFormatTest:testFormatDeployed(bytes32) (runs: 5115, μ: 2429928, ~: 2429757) -DecimalFloatFracTest:testFracDeployed(bytes32) (runs: 5115, μ: 2426162, ~: 2426146) -DecimalFloatFromFixedDecimalLosslessTest:testFromFixedDecimalLosslessDeployed(uint256,uint8) (runs: 5115, μ: 2426713, ~: 2426650) -DecimalFloatFromFixedDecimalLossyTest:testFromFixedDecimalLossyDeployed(uint256,uint8) (runs: 5115, μ: 2427202, ~: 2427120) -DecimalFloatGtTest:testGtDeployed(bytes32,bytes32) (runs: 5115, μ: 2426238, ~: 2426163) -DecimalFloatGteTest:testGteDeployed(bytes32,bytes32) (runs: 5115, μ: 2426310, ~: 2426236) -DecimalFloatInvTest:testInvDeployed(bytes32) (runs: 5115, μ: 2427501, ~: 2427426) -DecimalFloatIsZeroTest:testIsZeroDeployed(bytes32) (runs: 5115, μ: 2425428, ~: 2425428) -DecimalFloatLtTest:testLtDeployed(bytes32,bytes32) (runs: 5115, μ: 2426215, ~: 2426140) -DecimalFloatLteTest:testLteDeployed(bytes32,bytes32) (runs: 5115, μ: 2426267, ~: 2426193) -DecimalFloatMaxTest:testMaxDeployed(bytes32,bytes32) (runs: 5115, μ: 2426297, ~: 2426237) -DecimalFloatMinTest:testMinDeployed(bytes32,bytes32) (runs: 5115, μ: 2426296, ~: 2426235) -DecimalFloatMinusTest:testMinusDeployed(bytes32) (runs: 5115, μ: 2425988, ~: 2425988) -DecimalFloatMulTest:testMulDeployed(bytes32,bytes32) (runs: 5115, μ: 2428195, ~: 2429260) -DecimalFloatPackLosslessTest:testPackDeployed(int224,int32) (runs: 5115, μ: 158769, ~: 158769) -DecimalFloatParseTest:testParseDeployed(string) (runs: 5115, μ: 2428730, ~: 2428600) -DecimalFloatSubTest:testSubDeployed(bytes32,bytes32) (runs: 5115, μ: 2429004, ~: 2428695) -DecimalFloatToFixedDecimalLosslessTest:testToFixedDecimalLosslessDeployed(bytes32,uint8) (runs: 5115, μ: 2427346, ~: 2427233) -DecimalFloatToFixedDecimalLossyTest:testToFixedDecimalLossyDeployed(bytes32,uint8) (runs: 5115, μ: 2427491, ~: 2427762) -LibDecimalFloatAbsTest:testAbsMinValue(int32) (runs: 5115, μ: 5121, ~: 5121) -LibDecimalFloatAbsTest:testAbsNegative(int256,int32) (runs: 5115, μ: 10476, ~: 10702) -LibDecimalFloatAbsTest:testAbsNonNegative(int256,int32) (runs: 5115, μ: 9640, ~: 9392) -LibDecimalFloatConstantsTest:testFloatE() (gas: 3335) -LibDecimalFloatConstantsTest:testFloatMaxNegativeValue() (gas: 3357) -LibDecimalFloatConstantsTest:testFloatMaxNegativeValueIsMax(bytes32) (runs: 5115, μ: 4465, ~: 4572) -LibDecimalFloatConstantsTest:testFloatMaxPositiveValue() (gas: 3379) -LibDecimalFloatConstantsTest:testFloatMaxPositiveValueIsMax(bytes32) (runs: 5115, μ: 3544, ~: 3586) -LibDecimalFloatConstantsTest:testFloatMinNegativeValue() (gas: 3380) -LibDecimalFloatConstantsTest:testFloatMinNegativeValueIsMin(bytes32) (runs: 5115, μ: 3474, ~: 3435) -LibDecimalFloatConstantsTest:testFloatMinPositiveValue() (gas: 3335) -LibDecimalFloatConstantsTest:testFloatMinPositiveValueIsMin(bytes32) (runs: 5115, μ: 4917, ~: 4848) +DecimalFloatAbsTest:testAbsDeployed(bytes32) (runs: 5100, μ: 2447356, ~: 2447298) +DecimalFloatAddTest:testAddDeployed(bytes32,bytes32) (runs: 5100, μ: 2450111, ~: 2449802) +DecimalFloatConstantsTest:testEDeployed() (gas: 2446563) +DecimalFloatConstantsTest:testMaxNegativeValueDeployed() (gas: 2446595) +DecimalFloatConstantsTest:testMaxPositiveValueDeployed() (gas: 2446531) +DecimalFloatConstantsTest:testMinNegativeValueDeployed() (gas: 2446506) +DecimalFloatConstantsTest:testMinPositiveValueDeployed() (gas: 2446485) +DecimalFloatDivTest:testDivDeployed(bytes32,bytes32) (runs: 5100, μ: 2449855, ~: 2449711) +DecimalFloatEqTest:testEqDeployed(bytes32,bytes32) (runs: 5100, μ: 2447762, ~: 2447688) +DecimalFloatFloorTest:testFloorDeployed(bytes32) (runs: 5100, μ: 2447560, ~: 2447543) +DecimalFloatFormatTest:testFormatDeployed(bytes32) (runs: 5100, μ: 2451379, ~: 2451202) +DecimalFloatFracTest:testFracDeployed(bytes32) (runs: 5100, μ: 2447608, ~: 2447591) +DecimalFloatFromFixedDecimalLosslessTest:testFromFixedDecimalLosslessDeployed(uint256,uint8) (runs: 5100, μ: 2448162, ~: 2448095) +DecimalFloatFromFixedDecimalLossyTest:testFromFixedDecimalLossyDeployed(uint256,uint8) (runs: 5100, μ: 2448648, ~: 2448565) +DecimalFloatGtTest:testGtDeployed(bytes32,bytes32) (runs: 5100, μ: 2447683, ~: 2447608) +DecimalFloatGteTest:testGteDeployed(bytes32,bytes32) (runs: 5100, μ: 2447755, ~: 2447681) +DecimalFloatInvTest:testInvDeployed(bytes32) (runs: 5100, μ: 2448946, ~: 2448871) +DecimalFloatIsZeroTest:testIsZeroDeployed(bytes32) (runs: 5100, μ: 2446873, ~: 2446873) +DecimalFloatLtTest:testLtDeployed(bytes32,bytes32) (runs: 5100, μ: 2447660, ~: 2447585) +DecimalFloatLteTest:testLteDeployed(bytes32,bytes32) (runs: 5100, μ: 2447713, ~: 2447638) +DecimalFloatMaxTest:testMaxDeployed(bytes32,bytes32) (runs: 5100, μ: 2447743, ~: 2447682) +DecimalFloatMinTest:testMinDeployed(bytes32,bytes32) (runs: 5100, μ: 2447742, ~: 2447680) +DecimalFloatMinusTest:testMinusDeployed(bytes32) (runs: 5100, μ: 2447433, ~: 2447433) +DecimalFloatMulTest:testMulDeployed(bytes32,bytes32) (runs: 5100, μ: 2449642, ~: 2450705) +DecimalFloatPackLosslessTest:testPackDeployed(int224,int32) (runs: 5100, μ: 158769, ~: 158769) +DecimalFloatParseTest:testParseDeployed(string) (runs: 5100, μ: 2450176, ~: 2450045) +DecimalFloatPowTest:testPowDeployed(bytes32,bytes32) (runs: 5100, μ: 2457813, ~: 2455719) +DecimalFloatPowTest:testSqrtDeployed(bytes32) (runs: 5100, μ: 2457126, ~: 2456425) +DecimalFloatSubTest:testSubDeployed(bytes32,bytes32) (runs: 5100, μ: 2450443, ~: 2450140) +DecimalFloatToFixedDecimalLosslessTest:testToFixedDecimalLosslessDeployed(bytes32,uint8) (runs: 5100, μ: 2448786, ~: 2448678) +DecimalFloatToFixedDecimalLossyTest:testToFixedDecimalLossyDeployed(bytes32,uint8) (runs: 5100, μ: 2448935, ~: 2449207) +LibDecimalFloatAbsTest:testAbsMinValue(int32) (runs: 5100, μ: 5121, ~: 5121) +LibDecimalFloatAbsTest:testAbsNegative(int256,int32) (runs: 5100, μ: 10475, ~: 10702) +LibDecimalFloatAbsTest:testAbsNonNegative(int256,int32) (runs: 5100, μ: 9641, ~: 9392) +LibDecimalFloatConstantsTest:testFloatE() (gas: 3357) +LibDecimalFloatConstantsTest:testFloatHalf() (gas: 3336) +LibDecimalFloatConstantsTest:testFloatMaxNegativeValue() (gas: 3379) +LibDecimalFloatConstantsTest:testFloatMaxNegativeValueIsMax(bytes32) (runs: 5100, μ: 4488, ~: 4594) +LibDecimalFloatConstantsTest:testFloatMaxPositiveValue() (gas: 3335) +LibDecimalFloatConstantsTest:testFloatMaxPositiveValueIsMax(bytes32) (runs: 5100, μ: 3545, ~: 3586) +LibDecimalFloatConstantsTest:testFloatMinNegativeValue() (gas: 3335) +LibDecimalFloatConstantsTest:testFloatMinNegativeValueIsMin(bytes32) (runs: 5100, μ: 3496, ~: 3457) +LibDecimalFloatConstantsTest:testFloatMinPositiveValue() (gas: 3357) +LibDecimalFloatConstantsTest:testFloatMinPositiveValueIsMin(bytes32) (runs: 5100, μ: 4938, ~: 4870) LibDecimalFloatConstantsTest:testFloatOne() (gas: 3358) +LibDecimalFloatConstantsTest:testFloatTwo() (gas: 3380) LibDecimalFloatConstantsTest:testFloatZero() (gas: 3337) -LibDecimalFloatDecimalAddTest:testAddPacked(bytes32,bytes32) (runs: 5115, μ: 8363, ~: 8036) -LibDecimalFloatDecimalLosslessTest:testFromFixedDecimalLosslessFail(uint256,uint8) (runs: 5114, μ: 9615, ~: 9663) -LibDecimalFloatDecimalLosslessTest:testFromFixedDecimalLosslessMem(uint256,uint8) (runs: 5115, μ: 8130, ~: 8048) -LibDecimalFloatDecimalLosslessTest:testFromFixedDecimalLosslessPass(uint256,uint8) (runs: 5115, μ: 7452, ~: 7424) +LibDecimalFloatDecimalAddTest:testAddPacked(bytes32,bytes32) (runs: 5100, μ: 8361, ~: 8036) +LibDecimalFloatDecimalLosslessTest:testFromFixedDecimalLosslessFail(uint256,uint8) (runs: 5100, μ: 9615, ~: 9663) +LibDecimalFloatDecimalLosslessTest:testFromFixedDecimalLosslessMem(uint256,uint8) (runs: 5100, μ: 8130, ~: 8048) +LibDecimalFloatDecimalLosslessTest:testFromFixedDecimalLosslessPass(uint256,uint8) (runs: 5100, μ: 7452, ~: 7424) LibDecimalFloatDecimalLosslessTest:testToFixedDecimalLosslessFail() (gas: 4894) -LibDecimalFloatDecimalLosslessTest:testToFixedDecimalLosslessPacked(bytes32,uint8) (runs: 5115, μ: 6719, ~: 6161) -LibDecimalFloatDecimalLosslessTest:testToFixedDecimalLosslessPass(int256,int256,uint8) (runs: 5115, μ: 15806, ~: 15768) -LibDecimalFloatDecimalTest:testFixedDecimalRoundTripLossless(uint256,uint8) (runs: 5115, μ: 9274, ~: 9053) +LibDecimalFloatDecimalLosslessTest:testToFixedDecimalLosslessPacked(bytes32,uint8) (runs: 5100, μ: 6717, ~: 6161) +LibDecimalFloatDecimalLosslessTest:testToFixedDecimalLosslessPass(int256,int256,uint8) (runs: 5100, μ: 15805, ~: 15768) +LibDecimalFloatDecimalTest:testFixedDecimalRoundTripLossless(uint256,uint8) (runs: 5100, μ: 9274, ~: 9053) LibDecimalFloatDecimalTest:testFromFixedDecimalLossyComplicated() (gas: 685958) LibDecimalFloatDecimalTest:testFromFixedDecimalLossyNormalizedMax() (gas: 673506) LibDecimalFloatDecimalTest:testFromFixedDecimalLossyNormalizedMaxPlusOne() (gas: 704362) LibDecimalFloatDecimalTest:testFromFixedDecimalLossyOne() (gas: 685936) LibDecimalFloatDecimalTest:testFromFixedDecimalLossyOneMillion() (gas: 685937) LibDecimalFloatDecimalTest:testFromFixedDecimalLossyOverflow() (gas: 715261) -LibDecimalFloatDecimalTest:testFromFixedDecimalLossyPacked(uint256,uint8) (runs: 5115, μ: 9460, ~: 9374) -LibDecimalFloatDecimalTest:testFromFixedDecimalLossyTruncateOne(uint256,uint8) (runs: 5115, μ: 5978, ~: 5937) -LibDecimalFloatDecimalTest:testFromFixedDecimalLossyTruncateZero(uint256,uint8) (runs: 5115, μ: 7302, ~: 5860) -LibDecimalFloatDecimalTest:testToFixedDecimalLosslessScaleUp(int256,int256,uint8) (runs: 5111, μ: 16005, ~: 15996) -LibDecimalFloatDecimalTest:testToFixedDecimalLossyExponentOverflow(int256,int256,uint8) (runs: 5115, μ: 14962, ~: 14729) -LibDecimalFloatDecimalTest:testToFixedDecimalLossyIdentity(int256,uint8) (runs: 5115, μ: 10150, ~: 9811) -LibDecimalFloatDecimalTest:testToFixedDecimalLossyNegative(int256,int256,uint8) (runs: 5115, μ: 10826, ~: 11076) -LibDecimalFloatDecimalTest:testToFixedDecimalLossyPacked(bytes32,uint8) (runs: 5115, μ: 6805, ~: 6905) -LibDecimalFloatDecimalTest:testToFixedDecimalLossyScaleUpOverflow(int256,int256,uint8) (runs: 5101, μ: 15347, ~: 15612) -LibDecimalFloatDecimalTest:testToFixedDecimalLossyTruncate(int256,int256,uint8) (runs: 5115, μ: 14492, ~: 14212) +LibDecimalFloatDecimalTest:testFromFixedDecimalLossyPacked(uint256,uint8) (runs: 5100, μ: 9460, ~: 9374) +LibDecimalFloatDecimalTest:testFromFixedDecimalLossyTruncateOne(uint256,uint8) (runs: 5100, μ: 5978, ~: 5937) +LibDecimalFloatDecimalTest:testFromFixedDecimalLossyTruncateZero(uint256,uint8) (runs: 5100, μ: 7305, ~: 5860) +LibDecimalFloatDecimalTest:testToFixedDecimalLosslessScaleUp(int256,int256,uint8) (runs: 5099, μ: 16005, ~: 15996) +LibDecimalFloatDecimalTest:testToFixedDecimalLossyExponentOverflow(int256,int256,uint8) (runs: 5100, μ: 14963, ~: 14729) +LibDecimalFloatDecimalTest:testToFixedDecimalLossyIdentity(int256,uint8) (runs: 5100, μ: 10152, ~: 9811) +LibDecimalFloatDecimalTest:testToFixedDecimalLossyNegative(int256,int256,uint8) (runs: 5100, μ: 10825, ~: 11076) +LibDecimalFloatDecimalTest:testToFixedDecimalLossyPacked(bytes32,uint8) (runs: 5100, μ: 6804, ~: 6905) +LibDecimalFloatDecimalTest:testToFixedDecimalLossyScaleUpOverflow(int256,int256,uint8) (runs: 5097, μ: 15348, ~: 15612) +LibDecimalFloatDecimalTest:testToFixedDecimalLossyTruncate(int256,int256,uint8) (runs: 5100, μ: 14493, ~: 14212) LibDecimalFloatDecimalTest:testToFixedDecimalLossyTruncateLossless() (gas: 14523) -LibDecimalFloatDecimalTest:testToFixedDecimalLossyUnderflow(int256,int256,uint8) (runs: 5115, μ: 13738, ~: 13602) -LibDecimalFloatDecimalTest:testToFixedDecimalLossyZero(int256,uint8) (runs: 5115, μ: 4598, ~: 4598) -LibDecimalFloatDivTest:testDivPacked(bytes32,bytes32) (runs: 5115, μ: 8053, ~: 7855) -LibDecimalFloatEqTest:testEqPacked(bytes32,bytes32) (runs: 5115, μ: 5524, ~: 5450) -LibDecimalFloatEqTest:testEqXNotYExponents(bytes32,bytes32) (runs: 5115, μ: 4341, ~: 4234) -LibDecimalFloatEqTest:testEqZero(int32) (runs: 5115, μ: 5133, ~: 5133) +LibDecimalFloatDecimalTest:testToFixedDecimalLossyUnderflow(int256,int256,uint8) (runs: 5100, μ: 13738, ~: 13602) +LibDecimalFloatDecimalTest:testToFixedDecimalLossyZero(int256,uint8) (runs: 5100, μ: 4598, ~: 4598) +LibDecimalFloatDivTest:testDivPacked(bytes32,bytes32) (runs: 5100, μ: 8052, ~: 7855) +LibDecimalFloatEqTest:testEqPacked(bytes32,bytes32) (runs: 5100, μ: 5524, ~: 5450) +LibDecimalFloatEqTest:testEqXNotYExponents(bytes32,bytes32) (runs: 5100, μ: 4341, ~: 4234) +LibDecimalFloatEqTest:testEqZero(int32) (runs: 5100, μ: 5133, ~: 5133) LibDecimalFloatFloorTest:testFloorExamples() (gas: 38974) LibDecimalFloatFloorTest:testFloorGas0() (gas: 937) LibDecimalFloatFloorTest:testFloorGasTiny() (gas: 858) LibDecimalFloatFloorTest:testFloorGasZero() (gas: 809) -LibDecimalFloatFloorTest:testFloorInRange(int224,int256) (runs: 5115, μ: 11009, ~: 11021) -LibDecimalFloatFloorTest:testFloorLessThanMin(int224,int256) (runs: 5115, μ: 10261, ~: 10270) -LibDecimalFloatFloorTest:testFloorNonNegative(int224,int256) (runs: 5115, μ: 9802, ~: 10062) -LibDecimalFloatFloorTest:testFloorNotReverts(bytes32) (runs: 5115, μ: 630, ~: 621) +LibDecimalFloatFloorTest:testFloorInRange(int224,int256) (runs: 5100, μ: 11009, ~: 11021) +LibDecimalFloatFloorTest:testFloorLessThanMin(int224,int256) (runs: 5100, μ: 10261, ~: 10270) +LibDecimalFloatFloorTest:testFloorNonNegative(int224,int256) (runs: 5100, μ: 9803, ~: 10062) +LibDecimalFloatFloorTest:testFloorNotReverts(bytes32) (runs: 5100, μ: 630, ~: 621) LibDecimalFloatFracTest:testFracExamples() (gas: 39135) LibDecimalFloatFracTest:testFracGas0() (gas: 960) LibDecimalFloatFracTest:testFracGasTiny() (gas: 836) LibDecimalFloatFracTest:testFracGasZero() (gas: 820) -LibDecimalFloatFracTest:testFracInRange(int224,int256) (runs: 5115, μ: 10847, ~: 10859) -LibDecimalFloatFracTest:testFracLessThanMin(int224,int256) (runs: 5115, μ: 10273, ~: 10280) -LibDecimalFloatFracTest:testFracNonNegative(int224,int256) (runs: 5115, μ: 9804, ~: 10066) -LibDecimalFloatFracTest:testFracNotReverts(bytes32) (runs: 5115, μ: 630, ~: 621) +LibDecimalFloatFracTest:testFracInRange(int224,int256) (runs: 5100, μ: 10847, ~: 10859) +LibDecimalFloatFracTest:testFracLessThanMin(int224,int256) (runs: 5100, μ: 10273, ~: 10280) +LibDecimalFloatFracTest:testFracNonNegative(int224,int256) (runs: 5100, μ: 9805, ~: 10066) +LibDecimalFloatFracTest:testFracNotReverts(bytes32) (runs: 5100, μ: 630, ~: 621) LibDecimalFloatGtTest:testGtGasAZero() (gas: 973) LibDecimalFloatGtTest:testGtGasBZero() (gas: 973) LibDecimalFloatGtTest:testGtGasBothZero() (gas: 751) LibDecimalFloatGtTest:testGtGasDifferentSigns() (gas: 974) LibDecimalFloatGtTest:testGtGasExponentDiffOverflow() (gas: 1143) -LibDecimalFloatGtTest:testGtOneEAny(bytes32) (runs: 5115, μ: 3494, ~: 3494) -LibDecimalFloatGtTest:testGtReference(int224,int32,int224,int32) (runs: 5115, μ: 8062, ~: 6272) -LibDecimalFloatGtTest:testGtX(int224,int32) (runs: 5115, μ: 3882, ~: 3882) -LibDecimalFloatGtTest:testGtXEAnyVsXEAny(int256,int32,int32) (runs: 5115, μ: 10591, ~: 10332) -LibDecimalFloatGtTest:testGtXEAnyVsXEAnyNegative(int256,int32,int32) (runs: 5115, μ: 11145, ~: 11349) -LibDecimalFloatGtTest:testGtXNotY(bytes32,bytes32) (runs: 5115, μ: 4340, ~: 4232) -LibDecimalFloatGtTest:testGtXPositiveYNegative(int256,int32,int256,int32) (runs: 5115, μ: 13763, ~: 13595) -LibDecimalFloatGtTest:testGtXPositiveYZero(int256,int32,int32) (runs: 5115, μ: 10272, ~: 9879) -LibDecimalFloatGtTest:testGtZero(int32,int32) (runs: 5115, μ: 4793, ~: 4793) +LibDecimalFloatGtTest:testGtOneEAny(bytes32) (runs: 5100, μ: 3494, ~: 3494) +LibDecimalFloatGtTest:testGtReference(int224,int32,int224,int32) (runs: 5100, μ: 8065, ~: 6272) +LibDecimalFloatGtTest:testGtX(int224,int32) (runs: 5100, μ: 3882, ~: 3882) +LibDecimalFloatGtTest:testGtXEAnyVsXEAny(int256,int32,int32) (runs: 5100, μ: 10592, ~: 10332) +LibDecimalFloatGtTest:testGtXEAnyVsXEAnyNegative(int256,int32,int32) (runs: 5100, μ: 11144, ~: 11349) +LibDecimalFloatGtTest:testGtXNotY(bytes32,bytes32) (runs: 5100, μ: 4341, ~: 4232) +LibDecimalFloatGtTest:testGtXPositiveYNegative(int256,int32,int256,int32) (runs: 5100, μ: 13764, ~: 13595) +LibDecimalFloatGtTest:testGtXPositiveYZero(int256,int32,int32) (runs: 5100, μ: 10273, ~: 10026) +LibDecimalFloatGtTest:testGtZero(int32,int32) (runs: 5100, μ: 4793, ~: 4793) LibDecimalFloatGteTest:testGteGasAZero() (gas: 976) LibDecimalFloatGteTest:testGteGasBZero() (gas: 1020) LibDecimalFloatGteTest:testGteGasBothZero() (gas: 753) LibDecimalFloatGteTest:testGteGasDifferentSigns() (gas: 996) LibDecimalFloatGteTest:testGteGasExponentDiffOverflow() (gas: 1102) -LibDecimalFloatGteTest:testGteOneEAny(bytes32) (runs: 5115, μ: 3494, ~: 3494) -LibDecimalFloatGteTest:testGteReference(int224,int32,int224,int32) (runs: 5115, μ: 8112, ~: 6318) -LibDecimalFloatGteTest:testGteX(int224,int32) (runs: 5115, μ: 3925, ~: 3925) -LibDecimalFloatGteTest:testGteXEAnyVsXEAny(int256,int32,int32) (runs: 5115, μ: 10621, ~: 10364) -LibDecimalFloatGteTest:testGteXEAnyVsXEAnyNegative(int256,int32,int32) (runs: 5115, μ: 11157, ~: 11361) -LibDecimalFloatGteTest:testGteXNotLtY(bytes32,bytes32) (runs: 5115, μ: 3947, ~: 3873) -LibDecimalFloatGteTest:testGteXPositiveYNegative(int256,int32,int256,int32) (runs: 5115, μ: 13793, ~: 13623) -LibDecimalFloatGteTest:testGteXPositiveYZero(int256,int32,int32) (runs: 5115, μ: 9550, ~: 9170) -LibDecimalFloatGteTest:testGteZero(int32,int32) (runs: 5115, μ: 4838, ~: 4838) +LibDecimalFloatGteTest:testGteOneEAny(bytes32) (runs: 5100, μ: 3494, ~: 3494) +LibDecimalFloatGteTest:testGteReference(int224,int32,int224,int32) (runs: 5100, μ: 8115, ~: 6344) +LibDecimalFloatGteTest:testGteX(int224,int32) (runs: 5100, μ: 3925, ~: 3925) +LibDecimalFloatGteTest:testGteXEAnyVsXEAny(int256,int32,int32) (runs: 5100, μ: 10622, ~: 10364) +LibDecimalFloatGteTest:testGteXEAnyVsXEAnyNegative(int256,int32,int32) (runs: 5100, μ: 11156, ~: 11361) +LibDecimalFloatGteTest:testGteXNotLtY(bytes32,bytes32) (runs: 5100, μ: 3947, ~: 3873) +LibDecimalFloatGteTest:testGteXPositiveYNegative(int256,int32,int256,int32) (runs: 5100, μ: 13794, ~: 13623) +LibDecimalFloatGteTest:testGteXPositiveYZero(int256,int32,int32) (runs: 5100, μ: 9551, ~: 9170) +LibDecimalFloatGteTest:testGteZero(int32,int32) (runs: 5100, μ: 4838, ~: 4838) LibDecimalFloatImplementationAddTest:testAdd123456789987654321() (gas: 4813) LibDecimalFloatImplementationAddTest:testAdd123456789e9987654321() (gas: 4865) -LibDecimalFloatImplementationAddTest:testAddNeverRevert(int256,int256,int256,int256) (runs: 5115, μ: 13213, ~: 13133) +LibDecimalFloatImplementationAddTest:testAddNeverRevert(int256,int256,int256,int256) (runs: 5100, μ: 13213, ~: 13134) LibDecimalFloatImplementationAddTest:testAddOneOneNotNormalized() (gas: 5368) LibDecimalFloatImplementationAddTest:testAddOneOnePreNormalized() (gas: 4250) LibDecimalFloatImplementationAddTest:testAddOneZero() (gas: 3688) -LibDecimalFloatImplementationAddTest:testAddSameExponentSameCoefficient(int256,int256) (runs: 5115, μ: 5764, ~: 5813) +LibDecimalFloatImplementationAddTest:testAddSameExponentSameCoefficient(int256,int256) (runs: 5100, μ: 5764, ~: 5813) LibDecimalFloatImplementationAddTest:testAddZero() (gas: 3664) -LibDecimalFloatImplementationAddTest:testAddZeroAnyExponent(int128) (runs: 5115, μ: 9294, ~: 9271) +LibDecimalFloatImplementationAddTest:testAddZeroAnyExponent(int128) (runs: 5100, μ: 9294, ~: 9271) LibDecimalFloatImplementationAddTest:testAddZeroOne() (gas: 3686) -LibDecimalFloatImplementationAddTest:testAddZeroToAnyNonZero(int256,int256,int256) (runs: 5115, μ: 14015, ~: 13877) +LibDecimalFloatImplementationAddTest:testAddZeroToAnyNonZero(int256,int256,int256) (runs: 5100, μ: 14015, ~: 14005) LibDecimalFloatImplementationAddTest:testAddingSmallToLargeReturnsLargeExamples() (gas: 19289) -LibDecimalFloatImplementationAddTest:testAddingSmallToLargeReturnsLargeFuzz(int256,int256,int256,int256) (runs: 5104, μ: 17092, ~: 17016) +LibDecimalFloatImplementationAddTest:testAddingSmallToLargeReturnsLargeFuzz(int256,int256,int256,int256) (runs: 5098, μ: 17092, ~: 17016) LibDecimalFloatImplementationAddTest:testGasAddOne() (gas: 944) LibDecimalFloatImplementationAddTest:testGasAddZero() (gas: 382) LibDecimalFloatImplementationDivTest:testDiv1Over3() (gas: 6014) @@ -140,116 +144,120 @@ LibDecimalFloatImplementationDivTest:testDivNegative1Over3() (gas: 6074) LibDecimalFloatImplementationDivTest:testDivOOMs5and2() (gas: 4848) LibDecimalFloatImplementationDivTest:testDivOOMsOverTen() (gas: 5665) LibDecimalFloatImplementationDivTest:testDivTenOverOOMs() (gas: 5590) -LibDecimalFloatImplementationDivTest:testUnnormalizedThreesDiv0(int256,int256) (runs: 119, μ: 21050704, ~: 21050370) +LibDecimalFloatImplementationDivTest:testUnnormalizedThreesDiv0(int256,int256) (runs: 104, μ: 21050734, ~: 21050370) LibDecimalFloatImplementationEqTest:testEqGasAZero() (gas: 430) LibDecimalFloatImplementationEqTest:testEqGasBZero() (gas: 473) LibDecimalFloatImplementationEqTest:testEqGasBothZero() (gas: 450) LibDecimalFloatImplementationEqTest:testEqGasDifferentSigns() (gas: 482) LibDecimalFloatImplementationEqTest:testEqGasExponentDiffOverflow() (gas: 533) -LibDecimalFloatImplementationEqTest:testEqNotReverts(int256,int256,int256,int256) (runs: 5115, μ: 654, ~: 679) -LibDecimalFloatImplementationEqTest:testEqOneEAny(int256,int256) (runs: 5115, μ: 3416, ~: 3416) -LibDecimalFloatImplementationEqTest:testEqReference(int256,int256,int256,int256) (runs: 5115, μ: 9906, ~: 11456) -LibDecimalFloatImplementationEqTest:testEqX(int256) (runs: 5115, μ: 3392, ~: 3392) -LibDecimalFloatImplementationEqTest:testEqXEAnyVsXEAny(int256,int256,int256) (runs: 5115, μ: 4718, ~: 4714) -LibDecimalFloatImplementationEqTest:testEqXEqY(int256,int256,int256,int256) (runs: 5115, μ: 732, ~: 753) -LibDecimalFloatImplementationEqTest:testEqXNotY(int256,int256,int256,int256) (runs: 5115, μ: 3928, ~: 3953) -LibDecimalFloatImplementationEqTest:testEqZero(int256,int256) (runs: 5115, μ: 3440, ~: 3440) +LibDecimalFloatImplementationEqTest:testEqNotReverts(int256,int256,int256,int256) (runs: 5100, μ: 654, ~: 679) +LibDecimalFloatImplementationEqTest:testEqOneEAny(int256,int256) (runs: 5100, μ: 3416, ~: 3416) +LibDecimalFloatImplementationEqTest:testEqReference(int256,int256,int256,int256) (runs: 5100, μ: 9905, ~: 11456) +LibDecimalFloatImplementationEqTest:testEqX(int256) (runs: 5100, μ: 3392, ~: 3392) +LibDecimalFloatImplementationEqTest:testEqXEAnyVsXEAny(int256,int256,int256) (runs: 5100, μ: 4718, ~: 4714) +LibDecimalFloatImplementationEqTest:testEqXEqY(int256,int256,int256,int256) (runs: 5100, μ: 732, ~: 753) +LibDecimalFloatImplementationEqTest:testEqXNotY(int256,int256,int256,int256) (runs: 5100, μ: 3928, ~: 3953) +LibDecimalFloatImplementationEqTest:testEqZero(int256,int256) (runs: 5100, μ: 3440, ~: 3440) LibDecimalFloatImplementationInvTest:testInvGas0() (gas: 734) -LibDecimalFloatImplementationInvTest:testInvReference(int256,int256) (runs: 5115, μ: 12224, ~: 12163) +LibDecimalFloatImplementationInvTest:testInvReference(int256,int256) (runs: 5100, μ: 12224, ~: 12163) LibDecimalFloatImplementationInvTest:testInvSlowGas0() (gas: 755) LibDecimalFloatImplementationLog10Test:testExactLogs() (gas: 1263200) LibDecimalFloatImplementationLog10Test:testExactLookups() (gas: 1280292) LibDecimalFloatImplementationLog10Test:testInterpolatedLookups() (gas: 1257728) LibDecimalFloatImplementationLog10Test:testSub1() (gas: 1255242) -LibDecimalFloatImplementationMinusTest:testMinusIsSubZero(int256,int256,int256) (runs: 5115, μ: 12950, ~: 12929) +LibDecimalFloatImplementationMinusTest:testMinusIsSubZero(int256,int256,int256) (runs: 5100, μ: 12951, ~: 12929) LibDecimalFloatImplementationMulTest:testMul123456789987654321() (gas: 3676) -LibDecimalFloatImplementationMulTest:testMul123456789987654321WithExponents(int128,int128) (runs: 5115, μ: 13186, ~: 13270) +LibDecimalFloatImplementationMulTest:testMul123456789987654321WithExponents(int128,int128) (runs: 5100, μ: 13186, ~: 13270) LibDecimalFloatImplementationMulTest:testMul1e181e19() (gas: 3720) LibDecimalFloatImplementationMulTest:testMulGasOne() (gas: 382) LibDecimalFloatImplementationMulTest:testMulGasZero() (gas: 324) -LibDecimalFloatImplementationMulTest:testMulNotRevertAnyExpectation(int256,int256,int256,int256) (runs: 5115, μ: 13392, ~: 12563) +LibDecimalFloatImplementationMulTest:testMulNotRevertAnyExpectation(int256,int256,int256,int256) (runs: 5100, μ: 13394, ~: 12563) LibDecimalFloatImplementationMulTest:testMulOneOne() (gas: 3721) LibDecimalFloatImplementationMulTest:testMulOneZero() (gas: 3663) LibDecimalFloatImplementationMulTest:testMulZero0Exponent() (gas: 3620) -LibDecimalFloatImplementationMulTest:testMulZeroAnyExponent(int64,int64) (runs: 5115, μ: 3908, ~: 3908) +LibDecimalFloatImplementationMulTest:testMulZeroAnyExponent(int64,int64) (runs: 5100, μ: 3908, ~: 3908) LibDecimalFloatImplementationMulTest:testMulZeroOne() (gas: 3642) LibDecimalFloatImplementationNormalizeTest:testExamples() (gas: 160899) -LibDecimalFloatImplementationNormalizeTest:testIdempotent(int256,int256) (runs: 5115, μ: 9875, ~: 9808) -LibDecimalFloatImplementationNormalizeTest:testIsNormalizedReference(int256,int256) (runs: 5115, μ: 3533, ~: 3539) -LibDecimalFloatImplementationNormalizeTest:testNormalized(int256,int256) (runs: 5115, μ: 9415, ~: 9348) +LibDecimalFloatImplementationNormalizeTest:testIdempotent(int256,int256) (runs: 5100, μ: 9875, ~: 9808) +LibDecimalFloatImplementationNormalizeTest:testIsNormalizedReference(int256,int256) (runs: 5100, μ: 3533, ~: 3539) +LibDecimalFloatImplementationNormalizeTest:testNormalized(int256,int256) (runs: 5100, μ: 9415, ~: 9348) LibDecimalFloatImplementationPow10Test:testExactLookups() (gas: 1281984) LibDecimalFloatImplementationPow10Test:testExactPows() (gas: 1260129) LibDecimalFloatImplementationPow10Test:testInterpolatedLookupsPower() (gas: 1277254) -LibDecimalFloatImplementationPow10Test:testNoRevert(int224,int32) (runs: 5104, μ: 1258255, ~: 1259171) -LibDecimalFloatImplementationSubTest:testSubIsAdd(int256,int256,int256,int256) (runs: 5115, μ: 16004, ~: 15966) -LibDecimalFloatImplementationSubTest:testSubMinSignedValue(int256,int256,int256) (runs: 5115, μ: 16216, ~: 16148) +LibDecimalFloatImplementationPow10Test:testNoRevert(int224,int32) (runs: 5100, μ: 1258254, ~: 1259171) +LibDecimalFloatImplementationSubTest:testSubIsAdd(int256,int256,int256,int256) (runs: 5100, μ: 16004, ~: 15967) +LibDecimalFloatImplementationSubTest:testSubMinSignedValue(int256,int256,int256) (runs: 5100, μ: 16216, ~: 16148) LibDecimalFloatImplementationWithTargetExponentTest:testWithTargetExponentExamples() (gas: 13429) -LibDecimalFloatImplementationWithTargetExponentTest:testWithTargetExponentLargerExponentOverflowRescaleRevert(int256,int256,int256) (runs: 5100, μ: 14426, ~: 14395) -LibDecimalFloatImplementationWithTargetExponentTest:testWithTargetExponentLargerExponentVeryLargeDiffRevert(int256,int256,int256) (runs: 5115, μ: 13307, ~: 13527) -LibDecimalFloatImplementationWithTargetExponentTest:testWithTargetExponentLargerTargetExponentNoRevert(int256,int256,int256) (runs: 5115, μ: 11668, ~: 11718) -LibDecimalFloatImplementationWithTargetExponentTest:testWithTargetExponentSameExponentNoop(int256,int256) (runs: 5115, μ: 3676, ~: 3676) -LibDecimalFloatImplementationWithTargetExponentTest:testWithTargetExponentSmallerExponentNoRevert(int256,int256,int256) (runs: 5111, μ: 13874, ~: 13665) -LibDecimalFloatInvTest:testInvMem(bytes32) (runs: 5115, μ: 7321, ~: 7246) -LibDecimalFloatIsZeroTest:testIsZeroDeployed(bytes32) (runs: 5115, μ: 3899, ~: 3899) -LibDecimalFloatIsZeroTest:testIsZeroEqZero(bytes32) (runs: 5115, μ: 3527, ~: 3527) -LibDecimalFloatIsZeroTest:testIsZeroExamples(int32) (runs: 5115, μ: 4477, ~: 4477) -LibDecimalFloatIsZeroTest:testNotIsZero(int224,int32) (runs: 5115, μ: 3896, ~: 3896) -LibDecimalFloatLog10Test:testLog10Packed(bytes32) (runs: 5115, μ: 1645104, ~: 1263823) +LibDecimalFloatImplementationWithTargetExponentTest:testWithTargetExponentLargerExponentOverflowRescaleRevert(int256,int256,int256) (runs: 5097, μ: 14426, ~: 14395) +LibDecimalFloatImplementationWithTargetExponentTest:testWithTargetExponentLargerExponentVeryLargeDiffRevert(int256,int256,int256) (runs: 5100, μ: 13307, ~: 13527) +LibDecimalFloatImplementationWithTargetExponentTest:testWithTargetExponentLargerTargetExponentNoRevert(int256,int256,int256) (runs: 5100, μ: 11668, ~: 11718) +LibDecimalFloatImplementationWithTargetExponentTest:testWithTargetExponentSameExponentNoop(int256,int256) (runs: 5100, μ: 3676, ~: 3676) +LibDecimalFloatImplementationWithTargetExponentTest:testWithTargetExponentSmallerExponentNoRevert(int256,int256,int256) (runs: 5099, μ: 13874, ~: 13665) +LibDecimalFloatInvTest:testInvMem(bytes32) (runs: 5100, μ: 7321, ~: 7246) +LibDecimalFloatIsZeroTest:testIsZeroDeployed(bytes32) (runs: 5100, μ: 3899, ~: 3899) +LibDecimalFloatIsZeroTest:testIsZeroEqZero(bytes32) (runs: 5100, μ: 3527, ~: 3527) +LibDecimalFloatIsZeroTest:testIsZeroExamples(int32) (runs: 5100, μ: 4477, ~: 4477) +LibDecimalFloatIsZeroTest:testNotIsZero(int224,int32) (runs: 5100, μ: 3896, ~: 3896) +LibDecimalFloatLog10Test:testLog10Packed(bytes32) (runs: 5100, μ: 1646008, ~: 1263823) LibDecimalFloatLtTest:testLtExamples() (gas: 3994) LibDecimalFloatLtTest:testLtGasAZero() (gas: 946) LibDecimalFloatLtTest:testLtGasBZero() (gas: 1012) LibDecimalFloatLtTest:testLtGasBothZero() (gas: 969) LibDecimalFloatLtTest:testLtGasDifferentSigns() (gas: 969) LibDecimalFloatLtTest:testLtGasExponentDiffOverflow() (gas: 1053) -LibDecimalFloatLtTest:testLtNegativeVsPositive(int256,int32,int256,int32) (runs: 5115, μ: 13750, ~: 13593) -LibDecimalFloatLtTest:testLtNegativeVsZero(int256,int32,int32) (runs: 5115, μ: 10790, ~: 11008) -LibDecimalFloatLtTest:testLtOneEAny(int224,int32) (runs: 5115, μ: 3905, ~: 3905) -LibDecimalFloatLtTest:testLtReference(bytes32,bytes32) (runs: 5115, μ: 4696, ~: 4998) -LibDecimalFloatLtTest:testLtVsEqualVsGt(bytes32,bytes32) (runs: 5115, μ: 4323, ~: 4210) -LibDecimalFloatLtTest:testLtX(int224) (runs: 5115, μ: 3798, ~: 3798) -LibDecimalFloatLtTest:testLtXEAnyVsXEAny(int256,int32,int32) (runs: 5115, μ: 10556, ~: 10297) -LibDecimalFloatLtTest:testLtXEAnyVsXEAnyNegative(int256,int32,int32) (runs: 5115, μ: 11154, ~: 11359) -LibDecimalFloatLtTest:testLtZero(int32,int32) (runs: 5115, μ: 4171, ~: 4171) +LibDecimalFloatLtTest:testLtNegativeVsPositive(int256,int32,int256,int32) (runs: 5100, μ: 13750, ~: 13593) +LibDecimalFloatLtTest:testLtNegativeVsZero(int256,int32,int32) (runs: 5100, μ: 10790, ~: 11008) +LibDecimalFloatLtTest:testLtOneEAny(int224,int32) (runs: 5100, μ: 3905, ~: 3905) +LibDecimalFloatLtTest:testLtReference(bytes32,bytes32) (runs: 5100, μ: 4696, ~: 4998) +LibDecimalFloatLtTest:testLtVsEqualVsGt(bytes32,bytes32) (runs: 5100, μ: 4323, ~: 4210) +LibDecimalFloatLtTest:testLtX(int224) (runs: 5100, μ: 3798, ~: 3798) +LibDecimalFloatLtTest:testLtXEAnyVsXEAny(int256,int32,int32) (runs: 5100, μ: 10557, ~: 10297) +LibDecimalFloatLtTest:testLtXEAnyVsXEAnyNegative(int256,int32,int32) (runs: 5100, μ: 11153, ~: 11359) +LibDecimalFloatLtTest:testLtZero(int32,int32) (runs: 5100, μ: 4171, ~: 4171) LibDecimalFloatLteTest:testLteGasAZero() (gas: 997) LibDecimalFloatLteTest:testLteGasBZero() (gas: 999) LibDecimalFloatLteTest:testLteGasBothZero() (gas: 753) LibDecimalFloatLteTest:testLteGasDifferentSigns() (gas: 976) LibDecimalFloatLteTest:testLteGasExponentDiffOverflow() (gas: 1082) -LibDecimalFloatLteTest:testLteOneEAny(bytes32) (runs: 5115, μ: 3493, ~: 3493) -LibDecimalFloatLteTest:testLteReference(int224,int32,int224,int32) (runs: 5115, μ: 8107, ~: 6315) -LibDecimalFloatLteTest:testLteX(int224,int32) (runs: 5115, μ: 3904, ~: 3904) -LibDecimalFloatLteTest:testLteXEAnyVsXEAny(int256,int32,int32) (runs: 5115, μ: 10581, ~: 10321) -LibDecimalFloatLteTest:testLteXEAnyVsXEAnyNegative(int256,int32,int32) (runs: 5115, μ: 11177, ~: 11383) -LibDecimalFloatLteTest:testLteXNotLtY(bytes32,bytes32) (runs: 5115, μ: 3882, ~: 3807) -LibDecimalFloatLteTest:testLteXPositiveYNegative(int256,int32,int256,int32) (runs: 5115, μ: 13102, ~: 12931) -LibDecimalFloatLteTest:testLteXPositiveYZero(int256,int32,int32) (runs: 5115, μ: 9574, ~: 9191) -LibDecimalFloatLteTest:testLteZero(int32,int32) (runs: 5115, μ: 4816, ~: 4816) -LibDecimalFloatMaxTest:testMaxX(bytes32) (runs: 5115, μ: 4246, ~: 4246) -LibDecimalFloatMaxTest:testMaxXY(bytes32,bytes32) (runs: 5115, μ: 4689, ~: 4613) -LibDecimalFloatMaxTest:testMaxXYEqual(bytes32) (runs: 5115, μ: 5272, ~: 5272) -LibDecimalFloatMaxTest:testMaxXYGreater(bytes32,bytes32) (runs: 5105, μ: 6129, ~: 6016) -LibDecimalFloatMaxTest:testMaxXYLess(bytes32,bytes32) (runs: 5106, μ: 6141, ~: 6027) -LibDecimalFloatMinTest:testMinX(bytes32) (runs: 5115, μ: 4268, ~: 4268) -LibDecimalFloatMinTest:testMinXY(bytes32,bytes32) (runs: 5115, μ: 4689, ~: 4613) -LibDecimalFloatMinTest:testMinXYEqual(bytes32) (runs: 5115, μ: 5292, ~: 5292) -LibDecimalFloatMinTest:testMinXYGreater(bytes32,bytes32) (runs: 5105, μ: 6074, ~: 5961) -LibDecimalFloatMinTest:testMinXYLess(bytes32,bytes32) (runs: 5106, μ: 6087, ~: 5972) -LibDecimalFloatMinusTest:testMinusPacked(bytes32) (runs: 5115, μ: 5550, ~: 5550) +LibDecimalFloatLteTest:testLteOneEAny(bytes32) (runs: 5100, μ: 3493, ~: 3493) +LibDecimalFloatLteTest:testLteReference(int224,int32,int224,int32) (runs: 5100, μ: 8110, ~: 6315) +LibDecimalFloatLteTest:testLteX(int224,int32) (runs: 5100, μ: 3904, ~: 3904) +LibDecimalFloatLteTest:testLteXEAnyVsXEAny(int256,int32,int32) (runs: 5100, μ: 10582, ~: 10321) +LibDecimalFloatLteTest:testLteXEAnyVsXEAnyNegative(int256,int32,int32) (runs: 5100, μ: 11177, ~: 11383) +LibDecimalFloatLteTest:testLteXNotLtY(bytes32,bytes32) (runs: 5100, μ: 3882, ~: 3807) +LibDecimalFloatLteTest:testLteXPositiveYNegative(int256,int32,int256,int32) (runs: 5100, μ: 13102, ~: 12931) +LibDecimalFloatLteTest:testLteXPositiveYZero(int256,int32,int32) (runs: 5100, μ: 9575, ~: 9191) +LibDecimalFloatLteTest:testLteZero(int32,int32) (runs: 5100, μ: 4816, ~: 4816) +LibDecimalFloatMaxTest:testMaxX(bytes32) (runs: 5100, μ: 4246, ~: 4246) +LibDecimalFloatMaxTest:testMaxXY(bytes32,bytes32) (runs: 5100, μ: 4689, ~: 4613) +LibDecimalFloatMaxTest:testMaxXYEqual(bytes32) (runs: 5100, μ: 5272, ~: 5272) +LibDecimalFloatMaxTest:testMaxXYGreater(bytes32,bytes32) (runs: 5098, μ: 6129, ~: 6016) +LibDecimalFloatMaxTest:testMaxXYLess(bytes32,bytes32) (runs: 5098, μ: 6141, ~: 6027) +LibDecimalFloatMinTest:testMinX(bytes32) (runs: 5100, μ: 4268, ~: 4268) +LibDecimalFloatMinTest:testMinXY(bytes32,bytes32) (runs: 5100, μ: 4689, ~: 4613) +LibDecimalFloatMinTest:testMinXYEqual(bytes32) (runs: 5100, μ: 5292, ~: 5292) +LibDecimalFloatMinTest:testMinXYGreater(bytes32,bytes32) (runs: 5098, μ: 6074, ~: 5961) +LibDecimalFloatMinTest:testMinXYLess(bytes32,bytes32) (runs: 5098, μ: 6087, ~: 5972) +LibDecimalFloatMinusTest:testMinusPacked(bytes32) (runs: 5100, μ: 5550, ~: 5550) LibDecimalFloatMixedTest:testDiv1Over3() (gas: 8161) -LibDecimalFloatMulTest:testMulPacked(bytes32,bytes32) (runs: 5115, μ: 7886, ~: 8837) -LibDecimalFloatPackTest:testPartsRoundTrip(int224,int32) (runs: 5115, μ: 5352, ~: 5352) -LibDecimalFloatPow10Test:testPow10Packed(bytes32) (runs: 5115, μ: 1643772, ~: 1257918) -LibDecimalFloatPowTest:testNegativePowError(bytes32,bytes32) (runs: 5115, μ: 1248394, ~: 1248360) -LibDecimalFloatPowTest:testPowAZero(int32,bytes32) (runs: 5114, μ: 1246472, ~: 1246472) -LibDecimalFloatPowTest:testPowAZeroNegative(bytes32) (runs: 5098, μ: 1246804, ~: 1246804) -LibDecimalFloatPowTest:testPowBZero(bytes32,int32) (runs: 5115, μ: 1246036, ~: 1246036) +LibDecimalFloatMulTest:testMulPacked(bytes32,bytes32) (runs: 5100, μ: 7890, ~: 8837) +LibDecimalFloatPackTest:testPartsRoundTrip(int224,int32) (runs: 5100, μ: 5352, ~: 5352) +LibDecimalFloatPow10Test:testPow10Packed(bytes32) (runs: 5100, μ: 1644444, ~: 1257918) +LibDecimalFloatPowTest:testNegativePowError(bytes32,bytes32) (runs: 5100, μ: 1248393, ~: 1248360) +LibDecimalFloatPowTest:testPowAZero(int32,bytes32) (runs: 5100, μ: 1246472, ~: 1246472) +LibDecimalFloatPowTest:testPowAZeroNegative(bytes32) (runs: 5097, μ: 1246804, ~: 1246804) +LibDecimalFloatPowTest:testPowBZero(bytes32,int32) (runs: 5100, μ: 1246036, ~: 1246036) LibDecimalFloatPowTest:testPows() (gas: 1296960) -LibDecimalFloatPowTest:testRoundTripFuzz(bytes32,bytes32) (runs: 5115, μ: 1257280, ~: 1253651) -LibDecimalFloatPowTest:testRoundTripSimple() (gas: 1452863) -LibDecimalFloatSubTest:testSubPacked(bytes32,bytes32) (runs: 5115, μ: 8616, ~: 8297) +LibDecimalFloatPowTest:testRoundTripFuzz(bytes32,bytes32) (runs: 5100, μ: 1257241, ~: 1253651) +LibDecimalFloatPowTest:testRoundTripSimple() (gas: 1450811) +LibDecimalFloatSqrtTest:testRoundTripFuzz(int224,int32) (runs: 5100, μ: 1282810, ~: 1281348) +LibDecimalFloatSqrtTest:testSqrt() (gas: 1287510) +LibDecimalFloatSqrtTest:testSqrtNegative(bytes32) (runs: 5100, μ: 1248099, ~: 1248059) +LibDecimalFloatSqrtTest:testSqrtRoundTrip() (gas: 1372610) +LibDecimalFloatSubTest:testSubPacked(bytes32,bytes32) (runs: 5100, μ: 8614, ~: 8297) LibFormatDecimalFloatTest:testFormatDecimalExamples() (gas: 133439) -LibFormatDecimalFloatTest:testFormatDecimalRoundTrip(uint256) (runs: 5115, μ: 25204, ~: 20105) -LibFormatDecimalFloatTest:testFormatDecimalRoundTripNegative(int256) (runs: 5115, μ: 19670, ~: 21006) +LibFormatDecimalFloatTest:testFormatDecimalRoundTrip(uint256) (runs: 5100, μ: 25221, ~: 20105) +LibFormatDecimalFloatTest:testFormatDecimalRoundTripNegative(int256) (runs: 5100, μ: 19679, ~: 21006) LibLogTableBytesTest:testToBytesAntiLogTableDec() (gas: 159794) LibLogTableBytesTest:testToBytesAntiLogTableDecSmall() (gas: 162322) LibLogTableBytesTest:testToBytesLogTableDec() (gas: 143165) @@ -271,7 +279,7 @@ LibParseDecimalFloatTest:testParseLiteralDecimalFloatEDot() (gas: 4190) LibParseDecimalFloatTest:testParseLiteralDecimalFloatExponentRevert5() (gas: 4176) LibParseDecimalFloatTest:testParseLiteralDecimalFloatExponentRevert6() (gas: 4188) LibParseDecimalFloatTest:testParseLiteralDecimalFloatExponents() (gas: 402635) -LibParseDecimalFloatTest:testParseLiteralDecimalFloatFuzz(uint256,uint8,bool) (runs: 5115, μ: 45929, ~: 37394) +LibParseDecimalFloatTest:testParseLiteralDecimalFloatFuzz(uint256,uint8,bool) (runs: 5100, μ: 45906, ~: 37364) LibParseDecimalFloatTest:testParseLiteralDecimalFloatLeadingZeros() (gas: 59779) LibParseDecimalFloatTest:testParseLiteralDecimalFloatNegativeE() (gas: 6100) LibParseDecimalFloatTest:testParseLiteralDecimalFloatNegativeFrac() (gas: 5137) @@ -279,5 +287,5 @@ LibParseDecimalFloatTest:testParseLiteralDecimalFloatPrecisionRevert0() (gas: 27 LibParseDecimalFloatTest:testParseLiteralDecimalFloatPrecisionRevert1() (gas: 24801) LibParseDecimalFloatTest:testParseLiteralDecimalFloatSpecific() (gas: 22959) LibParseDecimalFloatTest:testParseLiteralDecimalFloatUnrelated() (gas: 50856) -LibParseDecimalFloatTest:testParsePacked(string) (runs: 5115, μ: 9786, ~: 9668) -TestDecimalFloatUnpackTest:testUnpackDeployed(bytes32) (runs: 5115, μ: 158422, ~: 158422) \ No newline at end of file +LibParseDecimalFloatTest:testParsePacked(string) (runs: 5100, μ: 9787, ~: 9668) +TestDecimalFloatUnpackTest:testUnpackDeployed(bytes32) (runs: 5100, μ: 158422, ~: 158422) \ No newline at end of file diff --git a/src/concrete/DecimalFloat.sol b/src/concrete/DecimalFloat.sol index 48390300..f3dd675b 100644 --- a/src/concrete/DecimalFloat.sol +++ b/src/concrete/DecimalFloat.sol @@ -188,6 +188,13 @@ contract DecimalFloat { return a.pow(b, LibDecimalFloat.LOG_TABLES_ADDRESS); } + /// Exposes `LibDecimalFloat.sqrt` for offchain use. + /// @param a The float to take the square root of. + /// @return The square root of the float. + function sqrt(Float a) external view returns (Float) { + return a.sqrt(LibDecimalFloat.LOG_TABLES_ADDRESS); + } + /// Exposes `LibDecimalFloat.min` for offchain use. /// @param a The first float to compare. /// @param b The second float to compare. diff --git a/src/lib/LibDecimalFloat.sol b/src/lib/LibDecimalFloat.sol index f9b9d8be..75d5255c 100644 --- a/src/lib/LibDecimalFloat.sol +++ b/src/lib/LibDecimalFloat.sol @@ -96,6 +96,14 @@ library LibDecimalFloat { /// A one valued float. Float constant FLOAT_ONE = Float.wrap(bytes32(uint256(1))); + /// A half valued float. + // slither-disable-next-line too-many-digits + Float constant FLOAT_HALF = + Float.wrap(bytes32(uint256(0xffffffff00000000000000000000000000000000000000000000000000000005))); + + /// A two valued float. + Float constant FLOAT_TWO = Float.wrap(bytes32(uint256(0x02))); + /// Largest possible positive value. /// type(int224).max, type(int32).max Float constant FLOAT_MAX_POSITIVE_VALUE = @@ -691,6 +699,22 @@ library LibDecimalFloat { return c; } + /// sqrt a = a ^ 0.5 + /// + /// Due to the inaccuracies of log10 and power10, this is not perfectly + /// accurate, a round trip like sqrt(x)^2 will typically be within half a + /// percent or less of the original value, but this can vary depending on + /// the input values. + /// + /// Doesn't lose precision due to the exponent, for a wide range of + /// exponents. + /// @param a The float to take the square root of. + /// @param tablesDataContract The address of the contract containing the + /// logarithm tables. + function sqrt(Float a, address tablesDataContract) internal view returns (Float) { + return pow(a, FLOAT_HALF, tablesDataContract); + } + /// Returns the minimum of two values. /// Convenience for `a < b ? a : b`. /// @param a The first float to compare. diff --git a/test/src/concrete/DecimalFloat.pow.t.sol b/test/src/concrete/DecimalFloat.pow.t.sol index edfc9ac4..c83bce34 100644 --- a/test/src/concrete/DecimalFloat.pow.t.sol +++ b/test/src/concrete/DecimalFloat.pow.t.sol @@ -8,20 +8,20 @@ import {DecimalFloat} from "src/concrete/DecimalFloat.sol"; contract DecimalFloatPowTest is LogTest { using LibDecimalFloat for Float; - function powExternal(Float a, Float b) external returns (Float) { - return a.pow(b, logTables()); + function powExternal(Float a, Float b) external view returns (Float) { + return a.pow(b, LibDecimalFloat.LOG_TABLES_ADDRESS); } - // function testPowDeployed(Float a, Float b) external { - // DecimalFloat deployed = new DecimalFloat(); + function testPowDeployed(Float a, Float b) external { + DecimalFloat deployed = new DecimalFloat(); - // try this.powExternal(a, b) returns (Float c) { - // Float deployedC = deployed.pow(a, b); + try this.powExternal(a, b) returns (Float c) { + Float deployedC = deployed.pow(a, b); - // assertEq(Float.unwrap(c), Float.unwrap(deployedC)); - // } catch (bytes memory err) { - // vm.expectRevert(err); - // deployed.pow(a, b); - // } - // } + assertEq(Float.unwrap(c), Float.unwrap(deployedC)); + } catch (bytes memory err) { + vm.expectRevert(err); + deployed.pow(a, b); + } + } } diff --git a/test/src/concrete/DecimalFloat.sqrt.t.sol b/test/src/concrete/DecimalFloat.sqrt.t.sol new file mode 100644 index 00000000..2553f046 --- /dev/null +++ b/test/src/concrete/DecimalFloat.sqrt.t.sol @@ -0,0 +1,27 @@ +// SPDX-License-Identifier: CAL +pragma solidity =0.8.25; + +import {LibDecimalFloat, Float} from "src/lib/LibDecimalFloat.sol"; +import {LogTest} from "test/abstract/LogTest.sol"; +import {DecimalFloat} from "src/concrete/DecimalFloat.sol"; + +contract DecimalFloatSqrtTest is LogTest { + using LibDecimalFloat for Float; + + function sqrtExternal(Float a) external view returns (Float) { + return a.sqrt(LibDecimalFloat.LOG_TABLES_ADDRESS); + } + + function testSqrtDeployed(Float a) external { + DecimalFloat deployed = new DecimalFloat(); + + try this.sqrtExternal(a) returns (Float c) { + Float deployedC = deployed.sqrt(a); + + assertEq(Float.unwrap(c), Float.unwrap(deployedC)); + } catch (bytes memory err) { + vm.expectRevert(err); + deployed.sqrt(a); + } + } +} diff --git a/test/src/lib/LibDecimalFloat.constants.t.sol b/test/src/lib/LibDecimalFloat.constants.t.sol index f7768ff7..b229e6b6 100644 --- a/test/src/lib/LibDecimalFloat.constants.t.sol +++ b/test/src/lib/LibDecimalFloat.constants.t.sol @@ -76,4 +76,16 @@ contract LibDecimalFloatConstantsTest is Test { Float expected = LibDecimalFloat.packLossless(1, 0); assertEq(Float.unwrap(one), Float.unwrap(expected)); } + + function testFloatHalf() external pure { + Float half = LibDecimalFloat.FLOAT_HALF; + Float expected = LibDecimalFloat.packLossless(5, -1); + assertEq(Float.unwrap(half), Float.unwrap(expected)); + } + + function testFloatTwo() external pure { + Float two = LibDecimalFloat.FLOAT_TWO; + Float expected = LibDecimalFloat.packLossless(2, 0); + assertEq(Float.unwrap(two), Float.unwrap(expected)); + } } diff --git a/test/src/lib/LibDecimalFloat.pow.t.sol b/test/src/lib/LibDecimalFloat.pow.t.sol index 518c8609..909b717c 100644 --- a/test/src/lib/LibDecimalFloat.pow.t.sol +++ b/test/src/lib/LibDecimalFloat.pow.t.sol @@ -102,7 +102,7 @@ contract LibDecimalFloatPowTest is LogTest { Float roundTrip = c.pow(b.inv(), tables); - Float diff = a.div(roundTrip).sub(LibDecimalFloat.packLossless(1, 0)).abs(); + Float diff = a.div(roundTrip).sub(LibDecimalFloat.FLOAT_ONE).abs(); assertTrue(!diff.gt(diffLimit()), "diff"); } diff --git a/test/src/lib/LibDecimalFloat.sqrt.t.sol b/test/src/lib/LibDecimalFloat.sqrt.t.sol new file mode 100644 index 00000000..de91a4cf --- /dev/null +++ b/test/src/lib/LibDecimalFloat.sqrt.t.sol @@ -0,0 +1,92 @@ +// SPDX-License-Identifier: CAL +pragma solidity =0.8.25; + +import {LogTest} from "../../abstract/LogTest.sol"; + +import {LibDecimalFloat, Float} from "src/lib/LibDecimalFloat.sol"; +import {ZeroNegativePower, Log10Negative} from "src/error/ErrDecimalFloat.sol"; +import {LibDecimalFloatImplementation} from "src/lib/implementation/LibDecimalFloatImplementation.sol"; +import {console2} from "forge-std/Test.sol"; + +contract LibDecimalFloatSqrtTest is LogTest { + using LibDecimalFloat for Float; + + function diffLimit() internal pure returns (Float) { + return LibDecimalFloat.packLossless(94, -3); + } + + function sqrtExternal(Float a, address tables) external view returns (Float) { + return a.sqrt(tables); + } + + function checkSqrt( + int256 signedCoefficient, + int256 exponent, + int256 expectedSignedCoefficient, + int256 expectedExponent + ) internal { + Float a = LibDecimalFloat.packLossless(signedCoefficient, exponent); + address tables = logTables(); + uint256 beforeGas = gasleft(); + Float c = a.sqrt(tables); + uint256 afterGas = gasleft(); + console2.log("Gas used:", beforeGas - afterGas); + console2.logInt(signedCoefficient); + console2.logInt(exponent); + (int256 actualSignedCoefficient, int256 actualExponent) = c.unpack(); + assertEq(actualSignedCoefficient, expectedSignedCoefficient, "signedCoefficient"); + assertEq(actualExponent, expectedExponent, "exponent"); + } + + function checkRoundTrip(int256 signedCoefficient, int256 exponent) internal { + Float a = LibDecimalFloat.packLossless(signedCoefficient, exponent); + address tables = logTables(); + Float c = a.sqrt(tables); + Float roundTrip = c.pow(LibDecimalFloat.FLOAT_TWO, tables); + + Float diff = a.div(roundTrip).sub(LibDecimalFloat.FLOAT_ONE).abs(); + + assertTrue(diff.lte(diffLimit()), "Round trip sqrt diff too high"); + } + + function testSqrt() external { + checkSqrt(0, 0, 0, 0); + checkSqrt(2, 0, 1415, -3); + checkSqrt(4, 0, 2e3, -3); + checkSqrt(16, 0, 399950000000000000000000000000000000000000, -41); + } + + function testSqrtNegative(Float a) external { + // We can't simply minus 0 to get a negative base. + vm.assume(!a.isZero()); + + if (a.gt(LibDecimalFloat.FLOAT_ZERO)) { + a = a.minus(); + } + + address tables = logTables(); + + (int256 signedCoefficient, int256 exponent) = a.unpack(); + (int256 signedCoefficientNormalized, int256 exponentNormalized) = + LibDecimalFloatImplementation.normalize(signedCoefficient, exponent); + vm.expectRevert(abi.encodeWithSelector(Log10Negative.selector, signedCoefficientNormalized, exponentNormalized)); + this.sqrtExternal(a, tables); + } + + function testSqrtRoundTrip() external { + checkRoundTrip(2, 0); + checkRoundTrip(4, 0); + checkRoundTrip(16, 0); + checkRoundTrip(25, 0); + checkRoundTrip(100, 0); + checkRoundTrip(10000, 0); + checkRoundTrip(1000000, 0); + checkRoundTrip(100000000, 0); + } + + function testRoundTripFuzz(int224 signedCoefficient, int32 exponent) external { + signedCoefficient = int224(bound(signedCoefficient, 1, type(int224).max)); + exponent = int32(bound(exponent, type(int16).min, type(int16).max)); + checkRoundTrip(signedCoefficient, exponent); + } +}