From e9f911682caa7e3f7e40ce2c98aa29d376fd2e33 Mon Sep 17 00:00:00 2001 From: thedavidmeister Date: Fri, 15 Aug 2025 17:24:42 +0400 Subject: [PATCH 1/2] update div precision --- .../LibDecimalFloatImplementation.sol | 10 ++++----- test/lib/LibCommonResults.sol | 4 ++-- test/src/lib/LibDecimalFloat.mixed.t.sol | 6 ++--- test/src/lib/LibDecimalFloat.pow.t.sol | 4 ++-- .../LibDecimalFloatImplementation.div.t.sol | 22 +++++++++---------- .../LibDecimalFloatImplementation.pow10.t.sol | 2 +- 6 files changed, 24 insertions(+), 24 deletions(-) diff --git a/src/lib/implementation/LibDecimalFloatImplementation.sol b/src/lib/implementation/LibDecimalFloatImplementation.sol index f2457621..2b1ed275 100644 --- a/src/lib/implementation/LibDecimalFloatImplementation.sol +++ b/src/lib/implementation/LibDecimalFloatImplementation.sol @@ -189,11 +189,11 @@ library LibDecimalFloatImplementation { returns (int256, int256) { unchecked { - (signedCoefficientA, exponentA) = normalize(signedCoefficientA, exponentA); + (signedCoefficientA, exponentA) = maximize(signedCoefficientA, exponentA); (signedCoefficientB, exponentB) = normalize(signedCoefficientB, exponentB); - int256 signedCoefficient = (signedCoefficientA * 1e38) / signedCoefficientB; - int256 exponent = exponentA - exponentB - 38; + int256 signedCoefficient = signedCoefficientA / signedCoefficientB; + int256 exponent = exponentA - exponentB; return (signedCoefficient, exponent); } } @@ -371,8 +371,8 @@ library LibDecimalFloatImplementation { function inv(int256 signedCoefficient, int256 exponent) internal pure returns (int256, int256) { (signedCoefficient, exponent) = normalize(signedCoefficient, exponent); - signedCoefficient = 1e75 / signedCoefficient; - exponent = -exponent - 75; + signedCoefficient = 1e76 / signedCoefficient; + exponent = -exponent - 76; return (signedCoefficient, exponent); } diff --git a/test/lib/LibCommonResults.sol b/test/lib/LibCommonResults.sol index f63553c8..753bb4dc 100644 --- a/test/lib/LibCommonResults.sol +++ b/test/lib/LibCommonResults.sol @@ -1,5 +1,5 @@ // SPDX-License-Identifier: CAL pragma solidity ^0.8.25; -int256 constant ONES = 11111111111111111111111111111111111111; -int256 constant THREES = 33333333333333333333333333333333333333; +int256 constant ONES = 111111111111111111111111111111111111111; +int256 constant THREES = 333333333333333333333333333333333333333; diff --git a/test/src/lib/LibDecimalFloat.mixed.t.sol b/test/src/lib/LibDecimalFloat.mixed.t.sol index 51637e0f..4df03423 100644 --- a/test/src/lib/LibDecimalFloat.mixed.t.sol +++ b/test/src/lib/LibDecimalFloat.mixed.t.sol @@ -16,12 +16,12 @@ contract LibDecimalFloatMixedTest is Test { Float c = a.div(b); (int256 signedCoefficientDiv, int256 exponentDiv) = LibDecimalFloat.unpack(c); assertEq(signedCoefficientDiv, THREES, "coefficient"); - assertEq(exponentDiv, -38, "exponent"); + assertEq(exponentDiv, -39, "exponent"); Float d = c.mul(LibDecimalFloat.packLossless(555, 18)); (int256 signedCoefficientMul, int256 exponentMul) = LibDecimalFloat.unpack(d); - assertEq(signedCoefficientMul, 18499999999999999999999999999999999999815); - assertEq(exponentMul, -20); + assertEq(signedCoefficientMul, 184999999999999999999999999999999999999815); + assertEq(exponentMul, -21); } } diff --git a/test/src/lib/LibDecimalFloat.pow.t.sol b/test/src/lib/LibDecimalFloat.pow.t.sol index 6829f7bb..f4a6dcd7 100644 --- a/test/src/lib/LibDecimalFloat.pow.t.sol +++ b/test/src/lib/LibDecimalFloat.pow.t.sol @@ -38,8 +38,8 @@ contract LibDecimalFloatPowTest is LogTest { } function testPows() external { - checkPow(5e37, -38, 3e37, -36, 9.3283582089552238805970149253731343283e37, -47); - checkPow(5e37, -38, 6e37, -36, 8.7108013937282229965156794425087108013e37, -56); + checkPow(5e37, -38, 3e37, -36, 9.32835820895522388059701492537313432835e38, -48); + checkPow(5e37, -38, 6e37, -36, 8.71080139372822299651567944250871080139e38, -57); // // Issues found in fuzzing from here. checkPow(99999, 0, 12182, 0, 1000, 60907); checkPow(1785215562, 0, 18, 0, 3388, 163); diff --git a/test/src/lib/implementation/LibDecimalFloatImplementation.div.t.sol b/test/src/lib/implementation/LibDecimalFloatImplementation.div.t.sol index ebb4f65f..2f3f3357 100644 --- a/test/src/lib/implementation/LibDecimalFloatImplementation.div.t.sol +++ b/test/src/lib/implementation/LibDecimalFloatImplementation.div.t.sol @@ -40,12 +40,12 @@ contract LibDecimalFloatImplementationDivTest is Test { /// 1 / 3 function testDiv1Over3() external pure { - checkDiv(1, 0, 3, 0, THREES, -38); + checkDiv(1, 0, 3, 0, THREES, -39); } /// - 1 / 3 function testDivNegative1Over3() external pure { - checkDiv(-1, 0, 3, 0, -THREES, -38); + checkDiv(-1, 0, 3, 0, -THREES, -39); } /// 1 / 3 gas @@ -56,22 +56,22 @@ contract LibDecimalFloatImplementationDivTest is Test { /// 1e18 / 3 function testDiv1e18Over3() external pure { - checkDiv(1e18, 0, 3, 0, THREES, -20); + checkDiv(1e18, 0, 3, 0, THREES, -21); } /// 10,0 / 1e38,-37 == 1 function testDivTenOverOOMs() external pure { - checkDiv(10, 0, 1e38, -37, 1e38, -38); + checkDiv(10, 0, 1e38, -37, 1e39, -39); } /// 1e38,-37 / 2,0 == 5 function testDivOOMsOverTen() external pure { - checkDiv(1e38, -37, 2, 0, 5e37, -37); + checkDiv(1e38, -37, 2, 0, 5e38, -38); } /// 5e37,-37 / 2e37,-37 == 2.5 function testDivOOMs5and2() external pure { - checkDiv(5e37, -37, 2e37, -37, 25e37, -38); + checkDiv(5e37, -37, 2e37, -37, 25e38, -39); } /// (1 / 9) / (1 / 3) == 0.333.. @@ -79,18 +79,18 @@ contract LibDecimalFloatImplementationDivTest is Test { // 1 / 9 (int256 signedCoefficientA, int256 exponentA) = LibDecimalFloatImplementation.div(1, 0, 9, 0); assertEq(signedCoefficientA, ONES); - assertEq(exponentA, -38); + assertEq(exponentA, -39); // 1 / 3 (int256 signedCoefficientB, int256 exponentB) = LibDecimalFloatImplementation.div(1, 0, 3, 0); assertEq(signedCoefficientB, THREES); - assertEq(exponentB, -38); + assertEq(exponentB, -39); // (1 / 9) / (1 / 3) (int256 signedCoefficient, int256 exponent) = LibDecimalFloatImplementation.div(signedCoefficientA, exponentA, signedCoefficientB, exponentB); - assertEq(signedCoefficient, THREES); - assertEq(exponent, -38); + assertEq(signedCoefficient, 333333333333333333333333333333333333336); + assertEq(exponent, -39); } /// forge-config: default.fuzz.runs = 100 @@ -102,7 +102,7 @@ contract LibDecimalFloatImplementationDivTest is Test { int256 di = 0; while (true) { int256 i = 1; - int256 j = -38 - di; + int256 j = -39 - di; while (true) { // want to see full precision on the THREES regardless of the // scale of the numerator and denominator. diff --git a/test/src/lib/implementation/LibDecimalFloatImplementation.pow10.t.sol b/test/src/lib/implementation/LibDecimalFloatImplementation.pow10.t.sol index 91cab239..de9c7ca3 100644 --- a/test/src/lib/implementation/LibDecimalFloatImplementation.pow10.t.sol +++ b/test/src/lib/implementation/LibDecimalFloatImplementation.pow10.t.sol @@ -56,7 +56,7 @@ contract LibDecimalFloatImplementationPow10Test is LogTest { checkPow10(0.5e37, -37, 3162, -3); checkPow10(0.3e37, -37, 1995, -3); - checkPow10(-0.3e37, -37, 5.012531328320802005012531328320802005e37, -38); + checkPow10(-0.3e37, -37, 0.501253132832080200501253132832080200501e39, -39); } function testInterpolatedLookupsPower() external { From e168a124f91000e38e457e12475ce99b99b9b321 Mon Sep 17 00:00:00 2001 From: thedavidmeister Date: Fri, 15 Aug 2025 17:27:27 +0400 Subject: [PATCH 2/2] snapshot --- .gas-snapshot | 159 ++++++++++++++++++++++++-------------------------- 1 file changed, 75 insertions(+), 84 deletions(-) diff --git a/.gas-snapshot b/.gas-snapshot index e3270c2a..67f4143e 100644 --- a/.gas-snapshot +++ b/.gas-snapshot @@ -1,35 +1,35 @@ -DecimalFloatAbsTest:testAbsDeployed(bytes32) (runs: 5118, μ: 2585908, ~: 2585851) -DecimalFloatAddTest:testAddDeployed(bytes32,bytes32) (runs: 5118, μ: 2589963, ~: 2590047) -DecimalFloatCeilTest:testCeilDeployed(bytes32) (runs: 5118, μ: 2585935, ~: 2585564) -DecimalFloatConstantsTest:testEDeployed() (gas: 2585094) -DecimalFloatConstantsTest:testMaxNegativeValueDeployed() (gas: 2585126) -DecimalFloatConstantsTest:testMaxPositiveValueDeployed() (gas: 2585084) -DecimalFloatConstantsTest:testMinNegativeValueDeployed() (gas: 2585059) -DecimalFloatConstantsTest:testMinPositiveValueDeployed() (gas: 2585038) -DecimalFloatDivTest:testDivDeployed(bytes32,bytes32) (runs: 5118, μ: 2588385, ~: 2588242) -DecimalFloatEqTest:testEqDeployed(bytes32,bytes32) (runs: 5118, μ: 2586294, ~: 2586219) -DecimalFloatFloorTest:testFloorDeployed(bytes32) (runs: 5118, μ: 2585748, ~: 2585562) -DecimalFloatFormatTest:testFormatDeployed(bytes32) (runs: 5118, μ: 2589916, ~: 2589727) -DecimalFloatFracTest:testFracDeployed(bytes32) (runs: 5118, μ: 2586139, ~: 2586122) -DecimalFloatFromFixedDecimalLosslessTest:testFromFixedDecimalLosslessDeployed(uint256,uint8) (runs: 5118, μ: 2586692, ~: 2586626) -DecimalFloatFromFixedDecimalLossyTest:testFromFixedDecimalLossyDeployed(uint256,uint8) (runs: 5118, μ: 2587178, ~: 2587096) -DecimalFloatGtTest:testGtDeployed(bytes32,bytes32) (runs: 5118, μ: 2586236, ~: 2586161) -DecimalFloatGteTest:testGteDeployed(bytes32,bytes32) (runs: 5118, μ: 2586222, ~: 2586147) -DecimalFloatInvTest:testInvDeployed(bytes32) (runs: 5118, μ: 2587476, ~: 2587402) -DecimalFloatIsZeroTest:testIsZeroDeployed(bytes32) (runs: 5118, μ: 2585404, ~: 2585404) -DecimalFloatLtTest:testLtDeployed(bytes32,bytes32) (runs: 5118, μ: 2586213, ~: 2586138) -DecimalFloatLteTest:testLteDeployed(bytes32,bytes32) (runs: 5118, μ: 2586266, ~: 2586191) -DecimalFloatMaxTest:testMaxDeployed(bytes32,bytes32) (runs: 5118, μ: 2586274, ~: 2586213) -DecimalFloatMinTest:testMinDeployed(bytes32,bytes32) (runs: 5118, μ: 2586295, ~: 2586233) -DecimalFloatMinusTest:testMinusDeployed(bytes32) (runs: 5118, μ: 2586009, ~: 2586009) -DecimalFloatMulTest:testMulDeployed(bytes32,bytes32) (runs: 5118, μ: 2588107, ~: 2589169) +DecimalFloatAbsTest:testAbsDeployed(bytes32) (runs: 5118, μ: 2575478, ~: 2575421) +DecimalFloatAddTest:testAddDeployed(bytes32,bytes32) (runs: 5118, μ: 2579527, ~: 2579617) +DecimalFloatCeilTest:testCeilDeployed(bytes32) (runs: 5118, μ: 2575504, ~: 2575134) +DecimalFloatConstantsTest:testEDeployed() (gas: 2574664) +DecimalFloatConstantsTest:testMaxNegativeValueDeployed() (gas: 2574696) +DecimalFloatConstantsTest:testMaxPositiveValueDeployed() (gas: 2574654) +DecimalFloatConstantsTest:testMinNegativeValueDeployed() (gas: 2574629) +DecimalFloatConstantsTest:testMinPositiveValueDeployed() (gas: 2574608) +DecimalFloatDivTest:testDivDeployed(bytes32,bytes32) (runs: 5118, μ: 2578204, ~: 2578195) +DecimalFloatEqTest:testEqDeployed(bytes32,bytes32) (runs: 5118, μ: 2575864, ~: 2575789) +DecimalFloatFloorTest:testFloorDeployed(bytes32) (runs: 5118, μ: 2575316, ~: 2575132) +DecimalFloatFormatTest:testFormatDeployed(bytes32) (runs: 5118, μ: 2579467, ~: 2579297) +DecimalFloatFracTest:testFracDeployed(bytes32) (runs: 5118, μ: 2575708, ~: 2575692) +DecimalFloatFromFixedDecimalLosslessTest:testFromFixedDecimalLosslessDeployed(uint256,uint8) (runs: 5118, μ: 2576261, ~: 2576196) +DecimalFloatFromFixedDecimalLossyTest:testFromFixedDecimalLossyDeployed(uint256,uint8) (runs: 5118, μ: 2576747, ~: 2576666) +DecimalFloatGtTest:testGtDeployed(bytes32,bytes32) (runs: 5118, μ: 2575806, ~: 2575731) +DecimalFloatGteTest:testGteDeployed(bytes32,bytes32) (runs: 5118, μ: 2575791, ~: 2575717) +DecimalFloatInvTest:testInvDeployed(bytes32) (runs: 5118, μ: 2577047, ~: 2576972) +DecimalFloatIsZeroTest:testIsZeroDeployed(bytes32) (runs: 5118, μ: 2574974, ~: 2574974) +DecimalFloatLtTest:testLtDeployed(bytes32,bytes32) (runs: 5118, μ: 2575783, ~: 2575708) +DecimalFloatLteTest:testLteDeployed(bytes32,bytes32) (runs: 5118, μ: 2575837, ~: 2575761) +DecimalFloatMaxTest:testMaxDeployed(bytes32,bytes32) (runs: 5118, μ: 2575845, ~: 2575783) +DecimalFloatMinTest:testMinDeployed(bytes32,bytes32) (runs: 5118, μ: 2575865, ~: 2575803) +DecimalFloatMinusTest:testMinusDeployed(bytes32) (runs: 5118, μ: 2575579, ~: 2575579) +DecimalFloatMulTest:testMulDeployed(bytes32,bytes32) (runs: 5118, μ: 2577678, ~: 2578739) DecimalFloatPackLosslessTest:testPackDeployed(int224,int32) (runs: 5118, μ: 158769, ~: 158769) -DecimalFloatParseTest:testParseDeployed(string) (runs: 5118, μ: 2588641, ~: 2588510) -DecimalFloatPowTest:testPowDeployed(bytes32,bytes32) (runs: 5118, μ: 2597234, ~: 2594242) -DecimalFloatSqrtTest:testSqrtDeployed(bytes32) (runs: 5118, μ: 2596502, ~: 2594956) -DecimalFloatSubTest:testSubDeployed(bytes32,bytes32) (runs: 5118, μ: 2590308, ~: 2590347) -DecimalFloatToFixedDecimalLosslessTest:testToFixedDecimalLosslessDeployed(bytes32,uint8) (runs: 5118, μ: 2587325, ~: 2587209) -DecimalFloatToFixedDecimalLossyTest:testToFixedDecimalLossyDeployed(bytes32,uint8) (runs: 5118, μ: 2587473, ~: 2587738) +DecimalFloatParseTest:testParseDeployed(string) (runs: 5118, μ: 2578211, ~: 2578080) +DecimalFloatPowTest:testPowDeployed(bytes32,bytes32) (runs: 5118, μ: 2586874, ~: 2583812) +DecimalFloatSqrtTest:testSqrtDeployed(bytes32) (runs: 5118, μ: 2586169, ~: 2584526) +DecimalFloatSubTest:testSubDeployed(bytes32,bytes32) (runs: 5118, μ: 2579886, ~: 2579917) +DecimalFloatToFixedDecimalLosslessTest:testToFixedDecimalLosslessDeployed(bytes32,uint8) (runs: 5118, μ: 2576909, ~: 2576779) +DecimalFloatToFixedDecimalLossyTest:testToFixedDecimalLossyDeployed(bytes32,uint8) (runs: 5118, μ: 2577046, ~: 2577308) LibDecimalFloatAbsTest:testAbsMinValue(int32) (runs: 5117, μ: 5121, ~: 5121) LibDecimalFloatAbsTest:testAbsNegative(int256,int32) (runs: 5118, μ: 10475, ~: 10702) LibDecimalFloatAbsTest:testAbsNonNegative(int256,int32) (runs: 5118, μ: 9640, ~: 9392) @@ -79,7 +79,7 @@ LibDecimalFloatDecimalTest:testToFixedDecimalLossyTruncate(int256,int256,uint8) LibDecimalFloatDecimalTest:testToFixedDecimalLossyTruncateLossless() (gas: 14523) LibDecimalFloatDecimalTest:testToFixedDecimalLossyUnderflow(int256,int256,uint8) (runs: 5118, μ: 13739, ~: 13602) LibDecimalFloatDecimalTest:testToFixedDecimalLossyZero(int256,uint8) (runs: 5118, μ: 4598, ~: 4598) -LibDecimalFloatDivTest:testDivPacked(bytes32,bytes32) (runs: 5118, μ: 8053, ~: 7855) +LibDecimalFloatDivTest:testDivPacked(bytes32,bytes32) (runs: 5118, μ: 8293, ~: 8263) LibDecimalFloatEqTest:testEqPacked(bytes32,bytes32) (runs: 5118, μ: 5524, ~: 5450) LibDecimalFloatEqTest:testEqXNotYExponents(bytes32,bytes32) (runs: 5118, μ: 4341, ~: 4234) LibDecimalFloatEqTest:testEqZero(int32) (runs: 5118, μ: 5133, ~: 5133) @@ -128,41 +128,32 @@ LibDecimalFloatGteTest:testGteXPositiveYNegative(int256,int32,int256,int32) (run LibDecimalFloatGteTest:testGteXPositiveYZero(int256,int32,int32) (runs: 5118, μ: 9550, ~: 9170) LibDecimalFloatGteTest:testGteZero(int32,int32) (runs: 5118, μ: 4838, ~: 4838) LibDecimalFloatImplementationAddTest:testAdd123456789987654321() (gas: 4811) -LibDecimalFloatImplementationAddTest:testAdd123456789e9987654321() (gas: 4795) -LibDecimalFloatImplementationAddTest:testAddNeverRevert(int256,int256,int256,int256) (runs: 5118, μ: 13126, ~: 13053) +LibDecimalFloatImplementationAddTest:testAdd123456789e9987654321() (gas: 4861) +LibDecimalFloatImplementationAddTest:testAddNeverRevert(int256,int256,int256,int256) (runs: 5118, μ: 13100, ~: 13033) LibDecimalFloatImplementationAddTest:testAddOneOneNotMaximized() (gas: 6148) -LibDecimalFloatImplementationAddTest:testAddOneOnePreMaximized() (gas: 4235) -LibDecimalFloatImplementationAddTest:testAddOneZero() (gas: 3688) -LibDecimalFloatImplementationAddTest:testAddSameExponent(int256,int256) (runs: 5112, μ: 6890, ~: 6957) -LibDecimalFloatImplementationAddTest:testAddZero() (gas: 3687) -LibDecimalFloatImplementationAddTest:testAddZeroAnyExponent(int128) (runs: 5118, μ: 9292, ~: 9271) -LibDecimalFloatImplementationAddTest:testAddZeroOne() (gas: 3686) -LibDecimalFloatImplementationAddTest:testAddZeroToAnyNonZero(int256,int256,int256) (runs: 5117, μ: 13996, ~: 13970) -LibDecimalFloatImplementationAddTest:testAddingSmallToLargeReturnsLargeExamples() (gas: 92108) -LibDecimalFloatImplementationAddTest:testAddingSmallToLargeReturnsLargeFuzz(int256,int256,int256,int256) (runs: 5101, μ: 17007, ~: 16985) -LibDecimalFloatImplementationAddTest:testGasAddOne() (gas: 1364) -LibDecimalFloatImplementationAddTest:testGasAddZero() (gas: 382) ---- a/test/src/lib/implementation/LibDecimalFloatImplementation.add.t.sol -@@ -31,10 +31,10 @@ - } - -- function testOverflowCheks(int256 a, int256 b) external pure { -+ function testOverflowChecks(int256 a, int256 b) external pure { - bool expected = willOverflow(a, b); - bool actual = willOverflow2(a, b); - assertEq(expected, actual); - } -LibDecimalFloatImplementationCharacteristicMantissaTest:testCharacteristicMantissaExamples() (gas: 7754) -LibDecimalFloatImplementationDivTest:testDiv1Over3() (gas: 6014) -LibDecimalFloatImplementationDivTest:testDiv1Over3Gas0() (gas: 716) -LibDecimalFloatImplementationDivTest:testDiv1Over3Gas10() (gas: 6907) -LibDecimalFloatImplementationDivTest:testDiv1Over9Over1Over3() (gas: 8914) -LibDecimalFloatImplementationDivTest:testDiv1e18Over3() (gas: 6003) -LibDecimalFloatImplementationDivTest:testDivNegative1Over3() (gas: 6074) -LibDecimalFloatImplementationDivTest:testDivOOMs5and2() (gas: 4848) -LibDecimalFloatImplementationDivTest:testDivOOMsOverTen() (gas: 5665) -LibDecimalFloatImplementationDivTest:testDivTenOverOOMs() (gas: 5590) -LibDecimalFloatImplementationDivTest:testUnnormalizedThreesDiv0(int256,int256) (runs: 122, μ: 21050720, ~: 21050370) +LibDecimalFloatImplementationAddTest:testAddOneOnePreMaximized() (gas: 4300) +LibDecimalFloatImplementationAddTest:testAddOneZero() (gas: 3666) +LibDecimalFloatImplementationAddTest:testAddSameExponent(int256,int256) (runs: 5111, μ: 6864, ~: 6935) +LibDecimalFloatImplementationAddTest:testAddZero() (gas: 3665) +LibDecimalFloatImplementationAddTest:testAddZeroAnyExponent(int128) (runs: 5118, μ: 9293, ~: 9271) +LibDecimalFloatImplementationAddTest:testAddZeroOne() (gas: 3664) +LibDecimalFloatImplementationAddTest:testAddZeroToAnyNonZero(int256,int256,int256) (runs: 5117, μ: 13974, ~: 13948) +LibDecimalFloatImplementationAddTest:testAddingSmallToLargeReturnsLargeExamples() (gas: 92086) +LibDecimalFloatImplementationAddTest:testAddingSmallToLargeReturnsLargeFuzz(int256,int256,int256,int256) (runs: 5104, μ: 16980, ~: 16963) +LibDecimalFloatImplementationAddTest:testGasAddOne() (gas: 1342) +LibDecimalFloatImplementationAddTest:testGasAddZero() (gas: 360) +LibDecimalFloatImplementationAddTest:testOverflowChecks(int256,int256) (runs: 5118, μ: 3857, ~: 3843) +LibDecimalFloatImplementationCharacteristicMantissaTest:testCharacteristicMantissaExamples() (gas: 30611) +LibDecimalFloatImplementationDivTest:testDiv1Over3() (gas: 5987) +LibDecimalFloatImplementationDivTest:testDiv1Over3Gas0() (gas: 923) +LibDecimalFloatImplementationDivTest:testDiv1Over3Gas10() (gas: 10560) +LibDecimalFloatImplementationDivTest:testDiv1Over9Over1Over3() (gas: 9596) +LibDecimalFloatImplementationDivTest:testDiv1e18Over3() (gas: 5646) +LibDecimalFloatImplementationDivTest:testDivNegative1Over3() (gas: 6047) +LibDecimalFloatImplementationDivTest:testDivOOMs5and2() (gas: 5055) +LibDecimalFloatImplementationDivTest:testDivOOMsOverTen() (gas: 5957) +LibDecimalFloatImplementationDivTest:testDivTenOverOOMs() (gas: 5551) +LibDecimalFloatImplementationDivTest:testUnnormalizedThreesDiv0(int256,int256) (runs: 122, μ: 20842375, ~: 20842008) LibDecimalFloatImplementationEqTest:testEqGasAZero() (gas: 430) LibDecimalFloatImplementationEqTest:testEqGasBZero() (gas: 473) LibDecimalFloatImplementationEqTest:testEqGasBothZero() (gas: 450) @@ -177,12 +168,12 @@ LibDecimalFloatImplementationEqTest:testEqXEqY(int256,int256,int256,int256) (run LibDecimalFloatImplementationEqTest:testEqXNotY(int256,int256,int256,int256) (runs: 5118, μ: 3928, ~: 3953) LibDecimalFloatImplementationEqTest:testEqZero(int256,int256) (runs: 5118, μ: 3440, ~: 3440) LibDecimalFloatImplementationInvTest:testInvGas0() (gas: 734) -LibDecimalFloatImplementationInvTest:testInvReference(int256,int256) (runs: 5116, μ: 12225, ~: 12163) -LibDecimalFloatImplementationInvTest:testInvSlowGas0() (gas: 755) +LibDecimalFloatImplementationInvTest:testInvReference(int256,int256) (runs: 5116, μ: 12416, ~: 12356) +LibDecimalFloatImplementationInvTest:testInvSlowGas0() (gas: 948) LibDecimalFloatImplementationLog10Test:testExactLogs() (gas: 1263178) LibDecimalFloatImplementationLog10Test:testExactLookupsLog10() (gas: 1280250) -LibDecimalFloatImplementationLog10Test:testInterpolatedLookups() (gas: 1260903) -LibDecimalFloatImplementationLog10Test:testSub1() (gas: 1256480) +LibDecimalFloatImplementationLog10Test:testInterpolatedLookups() (gas: 1260273) +LibDecimalFloatImplementationLog10Test:testSub1() (gas: 1256794) LibDecimalFloatImplementationMaximizeTest:testMaximizedEverything(int256,int256) (runs: 5118, μ: 9478, ~: 9455) LibDecimalFloatImplementationMaximizeTest:testMaximizedExamples() (gas: 165819) LibDecimalFloatImplementationMaximizeTest:testMaximizedIdempotent(int256,int256) (runs: 5118, μ: 9903, ~: 9868) @@ -204,8 +195,8 @@ LibDecimalFloatImplementationNormalizeTest:testIsNormalizedReference(int256,int2 LibDecimalFloatImplementationNormalizeTest:testNormalized(int256,int256) (runs: 5118, μ: 9415, ~: 9348) LibDecimalFloatImplementationPow10Test:testExactLookups() (gas: 1281984) LibDecimalFloatImplementationPow10Test:testExactPows() (gas: 1260129) -LibDecimalFloatImplementationPow10Test:testInterpolatedLookupsPower() (gas: 1285018) -LibDecimalFloatImplementationPow10Test:testNoRevert(int224,int32) (runs: 5108, μ: 1259163, ~: 1259241) +LibDecimalFloatImplementationPow10Test:testInterpolatedLookupsPower() (gas: 1283750) +LibDecimalFloatImplementationPow10Test:testNoRevert(int224,int32) (runs: 5110, μ: 1258970, ~: 1259175) LibDecimalFloatImplementationSubTest:testSubIsAdd(int256,int256,int256,int256) (runs: 5118, μ: 15800, ~: 15832) LibDecimalFloatImplementationSubTest:testSubMinSignedValue(int256,int256,int256) (runs: 5118, μ: 14990, ~: 14932) LibDecimalFloatImplementationSubTest:testSubOneFromMax() (gas: 6517) @@ -221,7 +212,7 @@ LibDecimalFloatIsZeroTest:testIsZeroDeployed(bytes32) (runs: 5118, μ: 3899, ~: LibDecimalFloatIsZeroTest:testIsZeroEqZero(bytes32) (runs: 5118, μ: 3527, ~: 3527) LibDecimalFloatIsZeroTest:testIsZeroExamples(int32) (runs: 5118, μ: 4477, ~: 4477) LibDecimalFloatIsZeroTest:testNotIsZero(int224,int32) (runs: 5116, μ: 3896, ~: 3896) -LibDecimalFloatLog10Test:testLog10Packed(bytes32) (runs: 5118, μ: 1651432, ~: 1271847) +LibDecimalFloatLog10Test:testLog10Packed(bytes32) (runs: 5118, μ: 1651243, ~: 1270937) LibDecimalFloatLtTest:testLtExamples() (gas: 3994) LibDecimalFloatLtTest:testLtGasAZero() (gas: 946) LibDecimalFloatLtTest:testLtGasBZero() (gas: 1012) @@ -262,21 +253,21 @@ LibDecimalFloatMinTest:testMinXYEqual(bytes32) (runs: 5118, μ: 5292, ~: 5292) LibDecimalFloatMinTest:testMinXYGreater(bytes32,bytes32) (runs: 5110, μ: 6074, ~: 5961) LibDecimalFloatMinTest:testMinXYLess(bytes32,bytes32) (runs: 5104, μ: 6087, ~: 5972) LibDecimalFloatMinusTest:testMinusPacked(bytes32) (runs: 5118, μ: 5550, ~: 5550) -LibDecimalFloatMixedTest:testDiv1Over3() (gas: 8161) +LibDecimalFloatMixedTest:testDiv1Over3() (gas: 8175) LibDecimalFloatMulTest:testMulPacked(bytes32,bytes32) (runs: 5118, μ: 7889, ~: 8837) LibDecimalFloatPackTest:testPartsRoundTrip(int224,int32) (runs: 5118, μ: 5352, ~: 5352) -LibDecimalFloatPow10Test:testPow10Packed(bytes32) (runs: 5118, μ: 1643075, ~: 1257968) -LibDecimalFloatPowTest:testNegativePowError(bytes32,bytes32) (runs: 5118, μ: 1248478, ~: 1248447) -LibDecimalFloatPowTest:testPowAZero(int32,bytes32) (runs: 5110, μ: 1246471, ~: 1246471) +LibDecimalFloatPow10Test:testPow10Packed(bytes32) (runs: 5118, μ: 1644250, ~: 1257848) +LibDecimalFloatPowTest:testNegativePowError(bytes32,bytes32) (runs: 5117, μ: 1248480, ~: 1248447) +LibDecimalFloatPowTest:testPowAZero(int32,bytes32) (runs: 5111, μ: 1246471, ~: 1246471) LibDecimalFloatPowTest:testPowAZeroNegative(bytes32) (runs: 5098, μ: 1246870, ~: 1246870) LibDecimalFloatPowTest:testPowBZero(bytes32,int32) (runs: 5118, μ: 1246058, ~: 1246058) -LibDecimalFloatPowTest:testPows() (gas: 1307542) -LibDecimalFloatPowTest:testRoundTripFuzzPow(bytes32,bytes32) (runs: 5118, μ: 1260914, ~: 1257677) -LibDecimalFloatPowTest:testRoundTripSimple() (gas: 1462197) -LibDecimalFloatSqrtTest:testRoundTripFuzzSqrt(int224,int32) (runs: 5118, μ: 1292077, ~: 1289038) -LibDecimalFloatSqrtTest:testSqrt() (gas: 1293543) -LibDecimalFloatSqrtTest:testSqrtNegative(bytes32) (runs: 5117, μ: 1248101, ~: 1248059) -LibDecimalFloatSqrtTest:testSqrtRoundTrip() (gas: 1393964) +LibDecimalFloatPowTest:testPows() (gas: 1307988) +LibDecimalFloatPowTest:testRoundTripFuzzPow(bytes32,bytes32) (runs: 5118, μ: 1260704, ~: 1257620) +LibDecimalFloatPowTest:testRoundTripSimple() (gas: 1466189) +LibDecimalFloatSqrtTest:testRoundTripFuzzSqrt(int224,int32) (runs: 5118, μ: 1291727, ~: 1289446) +LibDecimalFloatSqrtTest:testSqrt() (gas: 1293117) +LibDecimalFloatSqrtTest:testSqrtNegative(bytes32) (runs: 5118, μ: 1248101, ~: 1248059) +LibDecimalFloatSqrtTest:testSqrtRoundTrip() (gas: 1392528) LibDecimalFloatSubTest:testSubPacked(bytes32,bytes32) (runs: 5118, μ: 9973, ~: 9995) LibFormatDecimalFloatTest:testFormatDecimalExamples() (gas: 133439) LibFormatDecimalFloatTest:testFormatDecimalRoundTrip(uint256) (runs: 5118, μ: 25209, ~: 20105)