diff --git a/.gas-snapshot b/.gas-snapshot index cbd0b8c7..5afadff9 100644 --- a/.gas-snapshot +++ b/.gas-snapshot @@ -1,164 +1,165 @@ -DecimalFloatAbsTest:testAbsDeployed(bytes32) (runs: 5105, μ: 3069064, ~: 3069007) -DecimalFloatAddTest:testAddDeployed(bytes32,bytes32) (runs: 5105, μ: 3073115, ~: 3073203) -DecimalFloatCeilTest:testCeilDeployed(bytes32) (runs: 5105, μ: 3069092, ~: 3068720) -DecimalFloatConstantsTest:testEDeployed() (gas: 3068250) -DecimalFloatConstantsTest:testMaxNegativeValueDeployed() (gas: 3068239) -DecimalFloatConstantsTest:testMaxPositiveValueDeployed() (gas: 3068240) -DecimalFloatConstantsTest:testMinNegativeValueDeployed() (gas: 3068215) -DecimalFloatConstantsTest:testMinPositiveValueDeployed() (gas: 3068216) -DecimalFloatConstantsTest:testZeroDeployed() (gas: 3068283) -DecimalFloatDivTest:testDivDeployed(bytes32,bytes32) (runs: 5105, μ: 3075111, ~: 3075187) -DecimalFloatEqTest:testEqDeployed(bytes32,bytes32) (runs: 5105, μ: 3069448, ~: 3069375) -DecimalFloatFloorTest:testFloorDeployed(bytes32) (runs: 5105, μ: 3068902, ~: 3068718) -DecimalFloatFormatTest:testFormatDeployed(bytes32,uint256) (runs: 5105, μ: 3094453, ~: 3100980) -DecimalFloatFracTest:testFracDeployed(bytes32) (runs: 5105, μ: 3069294, ~: 3069278) -DecimalFloatFromFixedDecimalLosslessTest:testFromFixedDecimalLosslessDeployed(uint256,uint8) (runs: 5105, μ: 3069849, ~: 3069782) -DecimalFloatFromFixedDecimalLossyTest:testFromFixedDecimalLossyDeployed(uint256,uint8) (runs: 5105, μ: 3070335, ~: 3070252) -DecimalFloatGtTest:testGtDeployed(bytes32,bytes32) (runs: 5105, μ: 3069390, ~: 3069317) -DecimalFloatGteTest:testGteDeployed(bytes32,bytes32) (runs: 5105, μ: 3069377, ~: 3069303) -DecimalFloatInvTest:testInvDeployed(bytes32) (runs: 5105, μ: 3073960, ~: 3074002) -DecimalFloatIsZeroTest:testIsZeroDeployed(bytes32) (runs: 5105, μ: 3068560, ~: 3068560) -DecimalFloatLtTest:testLtDeployed(bytes32,bytes32) (runs: 5105, μ: 3069367, ~: 3069294) -DecimalFloatLteTest:testLteDeployed(bytes32,bytes32) (runs: 5105, μ: 3069421, ~: 3069347) -DecimalFloatMaxTest:testMaxDeployed(bytes32,bytes32) (runs: 5105, μ: 3069431, ~: 3069369) -DecimalFloatMinTest:testMinDeployed(bytes32,bytes32) (runs: 5105, μ: 3069428, ~: 3069367) -DecimalFloatMinusTest:testMinusDeployed(bytes32) (runs: 5105, μ: 3069165, ~: 3069165) -DecimalFloatMulTest:testMulDeployed(bytes32,bytes32) (runs: 5105, μ: 3073023, ~: 3073834) -DecimalFloatPackLosslessTest:testPackDeployed(int224,int32) (runs: 5105, μ: 158769, ~: 158769) -DecimalFloatParseTest:testParseDeployed(string) (runs: 5105, μ: 3071798, ~: 3071667) -DecimalFloatPowTest:testPowDeployed(bytes32,bytes32) (runs: 5105, μ: 3082112, ~: 3080775) -DecimalFloatSqrtTest:testSqrtDeployed(bytes32) (runs: 5105, μ: 3082208, ~: 3081993) -DecimalFloatSubTest:testSubDeployed(bytes32,bytes32) (runs: 5105, μ: 3073432, ~: 3073459) -DecimalFloatToFixedDecimalLosslessTest:testToFixedDecimalLosslessDeployed(bytes32,uint8) (runs: 5105, μ: 3070523, ~: 3070410) -DecimalFloatToFixedDecimalLossyTest:testToFixedDecimalLossyDeployed(bytes32,uint8) (runs: 5105, μ: 3070615, ~: 3070894) -LibDecimalFloatAbsTest:testAbsMinValue(int32) (runs: 5104, μ: 5121, ~: 5121) -LibDecimalFloatAbsTest:testAbsNegative(int256,int32) (runs: 5105, μ: 10475, ~: 10702) -LibDecimalFloatAbsTest:testAbsNonNegative(int256,int32) (runs: 5105, μ: 9641, ~: 9392) -LibDecimalFloatCeilTest:testCeilExamples() (gas: 30794) -LibDecimalFloatCeilTest:testCeilInRange(int224,int256) (runs: 5105, μ: 11040, ~: 10713) -LibDecimalFloatCeilTest:testCeilLessThanMin(int224,int256) (runs: 5105, μ: 10059, ~: 9820) -LibDecimalFloatCeilTest:testCeilNonNegative(int224,int256) (runs: 5105, μ: 8961, ~: 9212) -LibDecimalFloatCeilTest:testCeilNotReverts(bytes32) (runs: 5105, μ: 598, ~: 411) -LibDecimalFloatCeilTest:testCeilZero(int32) (runs: 5105, μ: 5438, ~: 5438) -LibDecimalFloatConstantsTest:testFloatE() (gas: 3357) -LibDecimalFloatConstantsTest:testFloatHalf() (gas: 3336) -LibDecimalFloatConstantsTest:testFloatMaxNegativeValue() (gas: 3379) -LibDecimalFloatConstantsTest:testFloatMaxNegativeValueIsMax(bytes32) (runs: 5105, μ: 4488, ~: 4594) -LibDecimalFloatConstantsTest:testFloatMaxPositiveValue() (gas: 3335) +DecimalFloatAbsTest:testAbsDeployed(bytes32) (runs: 5105, μ: 3264809, ~: 3264749) +DecimalFloatAddTest:testAddDeployed(bytes32,bytes32) (runs: 5105, μ: 3270277, ~: 3270334) +DecimalFloatCeilTest:testCeilDeployed(bytes32) (runs: 5105, μ: 3264787, ~: 3264412) +DecimalFloatConstantsTest:testEDeployed() (gas: 3263942) +DecimalFloatConstantsTest:testMaxNegativeValueDeployed() (gas: 3263931) +DecimalFloatConstantsTest:testMaxPositiveValueDeployed() (gas: 3263932) +DecimalFloatConstantsTest:testMinNegativeValueDeployed() (gas: 3263907) +DecimalFloatConstantsTest:testMinPositiveValueDeployed() (gas: 3263908) +DecimalFloatConstantsTest:testZeroDeployed() (gas: 3263975) +DecimalFloatDivTest:testDivDeployed(bytes32,bytes32) (runs: 5105, μ: 3271788, ~: 3271912) +DecimalFloatEqTest:testEqDeployed(bytes32,bytes32) (runs: 5105, μ: 3265142, ~: 3265067) +DecimalFloatFloorTest:testFloorDeployed(bytes32) (runs: 5105, μ: 3264590, ~: 3264410) +DecimalFloatFormatTest:testFormatDeployed(bytes32,uint256) (runs: 5105, μ: 3290302, ~: 3296672) +DecimalFloatFracTest:testFracDeployed(bytes32) (runs: 5105, μ: 3264994, ~: 3264960) +DecimalFloatFromFixedDecimalLosslessTest:testFromFixedDecimalLosslessDeployed(uint256,uint8) (runs: 5105, μ: 3265587, ~: 3265528) +DecimalFloatFromFixedDecimalLossyTest:testFromFixedDecimalLossyDeployed(uint256,uint8) (runs: 5105, μ: 3266077, ~: 3265995) +DecimalFloatGtTest:testGtDeployed(bytes32,bytes32) (runs: 5105, μ: 3265084, ~: 3265009) +DecimalFloatGteTest:testGteDeployed(bytes32,bytes32) (runs: 5105, μ: 3265070, ~: 3264995) +DecimalFloatInvTest:testInvDeployed(bytes32) (runs: 5105, μ: 3270243, ~: 3270304) +DecimalFloatIsZeroTest:testIsZeroDeployed(bytes32) (runs: 5105, μ: 3264252, ~: 3264252) +DecimalFloatLtTest:testLtDeployed(bytes32,bytes32) (runs: 5105, μ: 3265061, ~: 3264986) +DecimalFloatLteTest:testLteDeployed(bytes32,bytes32) (runs: 5105, μ: 3265114, ~: 3265039) +DecimalFloatMaxTest:testMaxDeployed(bytes32,bytes32) (runs: 5105, μ: 3265123, ~: 3265061) +DecimalFloatMinTest:testMinDeployed(bytes32,bytes32) (runs: 5105, μ: 3265121, ~: 3265059) +DecimalFloatMinusTest:testMinusDeployed(bytes32) (runs: 5105, μ: 3264917, ~: 3264918) +DecimalFloatMulTest:testMulDeployed(bytes32,bytes32) (runs: 5105, μ: 3268750, ~: 3269531) +DecimalFloatPackLosslessTest:testPackDeployed(int224,int32) (runs: 5105, μ: 170044, ~: 170045) +DecimalFloatParseTest:testParseDeployed(string) (runs: 5105, μ: 3267490, ~: 3267359) +DecimalFloatPowTest:testPowDeployed(bytes32,bytes32) (runs: 5105, μ: 3279535, ~: 3277829) +DecimalFloatSqrtTest:testSqrtDeployed(bytes32) (runs: 5105, μ: 3279512, ~: 3279047) +DecimalFloatSubTest:testSubDeployed(bytes32,bytes32) (runs: 5105, μ: 3270585, ~: 3270659) +DecimalFloatToFixedDecimalLosslessTest:testToFixedDecimalLosslessDeployed(bytes32,uint8) (runs: 5105, μ: 3266220, ~: 3266102) +DecimalFloatToFixedDecimalLossyTest:testToFixedDecimalLossyDeployed(bytes32,uint8) (runs: 5105, μ: 3266315, ~: 3266586) +LibDecimalFloatAbsTest:testAbsMinValue(int32) (runs: 5105, μ: 5162, ~: 5162) +LibDecimalFloatAbsTest:testAbsNegative(int256,int32) (runs: 5105, μ: 10527, ~: 10754) +LibDecimalFloatAbsTest:testAbsNonNegative(int256,int32) (runs: 5105, μ: 9714, ~: 9463) +LibDecimalFloatCeilTest:testCeilExamples() (gas: 35053) +LibDecimalFloatCeilTest:testCeilInRange(int224,int256) (runs: 5105, μ: 11143, ~: 10763) +LibDecimalFloatCeilTest:testCeilLessThanMin(int224,int256) (runs: 5105, μ: 10079, ~: 9840) +LibDecimalFloatCeilTest:testCeilNonNegative(int224,int256) (runs: 5105, μ: 8985, ~: 9237) +LibDecimalFloatCeilTest:testCeilNotReverts(bytes32) (runs: 5105, μ: 603, ~: 411) +LibDecimalFloatCeilTest:testCeilZero(int32) (runs: 5105, μ: 5428, ~: 5428) +LibDecimalFloatConstantsTest:testFloatE() (gas: 3383) +LibDecimalFloatConstantsTest:testFloatHalf() (gas: 3362) +LibDecimalFloatConstantsTest:testFloatMaxNegativeValue() (gas: 3405) +LibDecimalFloatConstantsTest:testFloatMaxNegativeValueIsMax(bytes32) (runs: 5105, μ: 4505, ~: 4620) +LibDecimalFloatConstantsTest:testFloatMaxPositiveValue() (gas: 3361) LibDecimalFloatConstantsTest:testFloatMaxPositiveValueIsMax(bytes32) (runs: 5105, μ: 3545, ~: 3586) -LibDecimalFloatConstantsTest:testFloatMinNegativeValue() (gas: 3335) +LibDecimalFloatConstantsTest:testFloatMinNegativeValue() (gas: 3361) LibDecimalFloatConstantsTest:testFloatMinNegativeValueIsMin(bytes32) (runs: 5105, μ: 3496, ~: 3457) -LibDecimalFloatConstantsTest:testFloatMinPositiveValue() (gas: 3357) -LibDecimalFloatConstantsTest:testFloatMinPositiveValueIsMin(bytes32) (runs: 5105, μ: 4938, ~: 4870) -LibDecimalFloatConstantsTest:testFloatOne() (gas: 3358) -LibDecimalFloatConstantsTest:testFloatTwo() (gas: 3380) -LibDecimalFloatConstantsTest:testFloatZero() (gas: 3337) -LibDecimalFloatDecimalAddTest:testAddPacked(bytes32,bytes32) (runs: 5105, μ: 9762, ~: 9832) -LibDecimalFloatDecimalLosslessTest:testFromFixedDecimalLosslessFail(uint256,uint8) (runs: 5104, μ: 9615, ~: 9663) -LibDecimalFloatDecimalLosslessTest:testFromFixedDecimalLosslessMem(uint256,uint8) (runs: 5105, μ: 8130, ~: 8048) +LibDecimalFloatConstantsTest:testFloatMinPositiveValue() (gas: 3383) +LibDecimalFloatConstantsTest:testFloatMinPositiveValueIsMin(bytes32) (runs: 5105, μ: 4965, ~: 4896) +LibDecimalFloatConstantsTest:testFloatOne() (gas: 3384) +LibDecimalFloatConstantsTest:testFloatTwo() (gas: 3406) +LibDecimalFloatConstantsTest:testFloatZero() (gas: 3332) +LibDecimalFloatDecimalAddTest:testAddPacked(bytes32,bytes32) (runs: 5105, μ: 11217, ~: 11318) +LibDecimalFloatDecimalLosslessTest:testFromFixedDecimalLosslessFail(uint256,uint8) (runs: 5105, μ: 9616, ~: 9663) +LibDecimalFloatDecimalLosslessTest:testFromFixedDecimalLosslessMem(uint256,uint8) (runs: 5105, μ: 8187, ~: 8104) LibDecimalFloatDecimalLosslessTest:testFromFixedDecimalLosslessPass(uint256,uint8) (runs: 5105, μ: 7452, ~: 7424) LibDecimalFloatDecimalLosslessTest:testToFixedDecimalLosslessFail() (gas: 4894) -LibDecimalFloatDecimalLosslessTest:testToFixedDecimalLosslessPacked(bytes32,uint8) (runs: 5105, μ: 6719, ~: 6161) -LibDecimalFloatDecimalLosslessTest:testToFixedDecimalLosslessPass(int256,int256,uint8) (runs: 5105, μ: 15805, ~: 15768) -LibDecimalFloatDecimalTest:testFixedDecimalRoundTripLossless(uint256,uint8) (runs: 5105, μ: 9110, ~: 9031) +LibDecimalFloatDecimalLosslessTest:testToFixedDecimalLosslessPacked(bytes32,uint8) (runs: 5105, μ: 6729, ~: 6161) +LibDecimalFloatDecimalLosslessTest:testToFixedDecimalLosslessPass(int256,int256,uint8) (runs: 5105, μ: 15813, ~: 15768) +LibDecimalFloatDecimalTest:testFixedDecimalRoundTripLossless(uint256,uint8) (runs: 5105, μ: 9111, ~: 9031) LibDecimalFloatDecimalTest:testFromFixedDecimalLossyComplicated() (gas: 685958) LibDecimalFloatDecimalTest:testFromFixedDecimalLossyMax() (gas: 673463) LibDecimalFloatDecimalTest:testFromFixedDecimalLossyOne() (gas: 686002) LibDecimalFloatDecimalTest:testFromFixedDecimalLossyOneMillion() (gas: 685937) LibDecimalFloatDecimalTest:testFromFixedDecimalLossyOverflow() (gas: 715261) -LibDecimalFloatDecimalTest:testFromFixedDecimalLossyPacked(uint256,uint8) (runs: 5105, μ: 9481, ~: 9396) -LibDecimalFloatDecimalTest:testFromFixedDecimalLossyTruncateOne(uint256,uint8) (runs: 5105, μ: 5978, ~: 5937) -LibDecimalFloatDecimalTest:testFromFixedDecimalLossyTruncateZero(uint256,uint8) (runs: 5105, μ: 6062, ~: 5860) -LibDecimalFloatDecimalTest:testToFixedDecimalLosslessScaleUp(int256,int256,uint8) (runs: 5101, μ: 15987, ~: 15862) +LibDecimalFloatDecimalTest:testFromFixedDecimalLossyPacked(uint256,uint8) (runs: 5105, μ: 9537, ~: 9452) +LibDecimalFloatDecimalTest:testFromFixedDecimalLossyTruncateOne(uint256,uint8) (runs: 5105, μ: 5977, ~: 5937) +LibDecimalFloatDecimalTest:testFromFixedDecimalLossyTruncateZero(uint256,uint8) (runs: 5105, μ: 6066, ~: 5860) +LibDecimalFloatDecimalTest:testToFixedDecimalLosslessScaleUp(int256,int256,uint8) (runs: 5103, μ: 15997, ~: 15929) LibDecimalFloatDecimalTest:testToFixedDecimalLossyExponentOverflow(int256,int256,uint8) (runs: 5105, μ: 14963, ~: 14729) -LibDecimalFloatDecimalTest:testToFixedDecimalLossyIdentity(int256,uint8) (runs: 5105, μ: 10153, ~: 9811) -LibDecimalFloatDecimalTest:testToFixedDecimalLossyNegative(int256,int256,uint8) (runs: 5105, μ: 10826, ~: 11076) -LibDecimalFloatDecimalTest:testToFixedDecimalLossyPacked(bytes32,uint8) (runs: 5105, μ: 6804, ~: 6905) -LibDecimalFloatDecimalTest:testToFixedDecimalLossyScaleUpOverflow(int256,int256,uint8) (runs: 5100, μ: 15348, ~: 15612) -LibDecimalFloatDecimalTest:testToFixedDecimalLossyTruncate(int256,int256,uint8) (runs: 5105, μ: 14492, ~: 14212) +LibDecimalFloatDecimalTest:testToFixedDecimalLossyIdentity(int256,uint8) (runs: 5105, μ: 10155, ~: 9957) +LibDecimalFloatDecimalTest:testToFixedDecimalLossyNegative(int256,int256,uint8) (runs: 5105, μ: 10825, ~: 11076) +LibDecimalFloatDecimalTest:testToFixedDecimalLossyPacked(bytes32,uint8) (runs: 5105, μ: 6813, ~: 6905) +LibDecimalFloatDecimalTest:testToFixedDecimalLossyScaleUpOverflow(int256,int256,uint8) (runs: 5098, μ: 15351, ~: 15612) +LibDecimalFloatDecimalTest:testToFixedDecimalLossyTruncate(int256,int256,uint8) (runs: 5105, μ: 14493, ~: 14212) LibDecimalFloatDecimalTest:testToFixedDecimalLossyTruncateLossless() (gas: 14500) LibDecimalFloatDecimalTest:testToFixedDecimalLossyUnderflow(int256,int256,uint8) (runs: 5105, μ: 13738, ~: 13602) LibDecimalFloatDecimalTest:testToFixedDecimalLossyZero(int256,uint8) (runs: 5105, μ: 4575, ~: 4575) -LibDecimalFloatDivTest:testDivByNegativeOneFloat(int224,int32) (runs: 5105, μ: 328862, ~: 328318) -LibDecimalFloatDivTest:testDivByOneFloat(int224,int32) (runs: 5105, μ: 304449, ~: 303480) -LibDecimalFloatDivTest:testDivPacked(bytes32,bytes32) (runs: 5105, μ: 11630, ~: 11706) +LibDecimalFloatDivTest:testDivByNegativeOneFloat(int224,int32) (runs: 5105, μ: 361808, ~: 358393) +LibDecimalFloatDivTest:testDivByOneFloat(int224,int32) (runs: 5105, μ: 336379, ~: 333291) +LibDecimalFloatDivTest:testDivPacked(bytes32,bytes32) (runs: 5105, μ: 12706, ~: 12844) LibDecimalFloatEqTest:testEqPacked(bytes32,bytes32) (runs: 5105, μ: 5524, ~: 5450) LibDecimalFloatEqTest:testEqXNotYExponents(bytes32,bytes32) (runs: 5105, μ: 4341, ~: 4234) -LibDecimalFloatEqTest:testEqZero(int32) (runs: 5105, μ: 5133, ~: 5133) -LibDecimalFloatFloorTest:testFloorExamples() (gas: 38387) -LibDecimalFloatFloorTest:testFloorGas0() (gas: 960) -LibDecimalFloatFloorTest:testFloorGasTiny() (gas: 881) -LibDecimalFloatFloorTest:testFloorGasZero() (gas: 553) -LibDecimalFloatFloorTest:testFloorInRange(int224,int256) (runs: 5105, μ: 11032, ~: 11044) -LibDecimalFloatFloorTest:testFloorLessThanMin(int224,int256) (runs: 5105, μ: 10284, ~: 10293) -LibDecimalFloatFloorTest:testFloorNonNegative(int224,int256) (runs: 5105, μ: 9546, ~: 9806) -LibDecimalFloatFloorTest:testFloorNotReverts(bytes32) (runs: 5105, μ: 461, ~: 365) -LibDecimalFloatFracTest:testFracExamples() (gas: 39135) -LibDecimalFloatFracTest:testFracGas0() (gas: 960) -LibDecimalFloatFracTest:testFracGasTiny() (gas: 836) -LibDecimalFloatFracTest:testFracGasZero() (gas: 820) -LibDecimalFloatFracTest:testFracInRange(int224,int256) (runs: 5105, μ: 10847, ~: 10859) -LibDecimalFloatFracTest:testFracLessThanMin(int224,int256) (runs: 5105, μ: 10273, ~: 10280) -LibDecimalFloatFracTest:testFracNonNegative(int224,int256) (runs: 5105, μ: 9805, ~: 10066) -LibDecimalFloatFracTest:testFracNotReverts(bytes32) (runs: 5105, μ: 630, ~: 621) -LibDecimalFloatGtTest:testGtGasAZero() (gas: 973) -LibDecimalFloatGtTest:testGtGasBZero() (gas: 973) -LibDecimalFloatGtTest:testGtGasBothZero() (gas: 751) -LibDecimalFloatGtTest:testGtGasDifferentSigns() (gas: 974) -LibDecimalFloatGtTest:testGtGasExponentDiffOverflow() (gas: 1143) +LibDecimalFloatEqTest:testEqZero(int32) (runs: 5105, μ: 5123, ~: 5123) +LibDecimalFloatFloorTest:testFloorExamples() (gas: 39140) +LibDecimalFloatFloorTest:testFloorGas0() (gas: 1003) +LibDecimalFloatFloorTest:testFloorGasTiny() (gas: 902) +LibDecimalFloatFloorTest:testFloorGasZero() (gas: 548) +LibDecimalFloatFloorTest:testFloorInRange(int224,int256) (runs: 5105, μ: 11101, ~: 11130) +LibDecimalFloatFloorTest:testFloorLessThanMin(int224,int256) (runs: 5105, μ: 10302, ~: 10314) +LibDecimalFloatFloorTest:testFloorNonNegative(int224,int256) (runs: 5105, μ: 9591, ~: 9851) +LibDecimalFloatFloorTest:testFloorNotReverts(bytes32) (runs: 5105, μ: 459, ~: 365) +LibDecimalFloatFracTest:testFracExamples() (gas: 40054) +LibDecimalFloatFracTest:testFracGas0() (gas: 1003) +LibDecimalFloatFracTest:testFracGasTiny() (gas: 888) +LibDecimalFloatFracTest:testFracGasZero() (gas: 810) +LibDecimalFloatFracTest:testFracInRange(int224,int256) (runs: 5105, μ: 10917, ~: 10934) +LibDecimalFloatFracTest:testFracLessThanMin(int224,int256) (runs: 5105, μ: 10343, ~: 10351) +LibDecimalFloatFracTest:testFracNonNegative(int224,int256) (runs: 5105, μ: 9825, ~: 10087) +LibDecimalFloatFracTest:testFracNotReverts(bytes32) (runs: 5105, μ: 634, ~: 616) +LibDecimalFloatGtTest:testGtGasAZero() (gas: 994) +LibDecimalFloatGtTest:testGtGasBZero() (gas: 994) +LibDecimalFloatGtTest:testGtGasBothZero() (gas: 746) +LibDecimalFloatGtTest:testGtGasDifferentSigns() (gas: 1026) +LibDecimalFloatGtTest:testGtGasExponentDiffOverflow() (gas: 1195) LibDecimalFloatGtTest:testGtOneEAny(bytes32) (runs: 5105, μ: 3494, ~: 3494) -LibDecimalFloatGtTest:testGtReference(int224,int32,int224,int32) (runs: 5105, μ: 8067, ~: 6272) -LibDecimalFloatGtTest:testGtX(int224,int32) (runs: 5105, μ: 3882, ~: 3882) -LibDecimalFloatGtTest:testGtXEAnyVsXEAny(int256,int32,int32) (runs: 5105, μ: 10592, ~: 10332) -LibDecimalFloatGtTest:testGtXEAnyVsXEAnyNegative(int256,int32,int32) (runs: 5105, μ: 11144, ~: 11349) +LibDecimalFloatGtTest:testGtReference(int224,int32,int224,int32) (runs: 5105, μ: 8121, ~: 6350) +LibDecimalFloatGtTest:testGtX(int224,int32) (runs: 5105, μ: 3907, ~: 3908) +LibDecimalFloatGtTest:testGtXEAnyVsXEAny(int256,int32,int32) (runs: 5105, μ: 10644, ~: 10384) +LibDecimalFloatGtTest:testGtXEAnyVsXEAnyNegative(int256,int32,int32) (runs: 5105, μ: 11196, ~: 11401) LibDecimalFloatGtTest:testGtXNotY(bytes32,bytes32) (runs: 5105, μ: 4341, ~: 4232) -LibDecimalFloatGtTest:testGtXPositiveYNegative(int256,int32,int256,int32) (runs: 5105, μ: 13764, ~: 13595) -LibDecimalFloatGtTest:testGtXPositiveYZero(int256,int32,int32) (runs: 5105, μ: 10273, ~: 10026) -LibDecimalFloatGtTest:testGtZero(int32,int32) (runs: 5105, μ: 4793, ~: 4793) -LibDecimalFloatGteTest:testGteGasAZero() (gas: 976) -LibDecimalFloatGteTest:testGteGasBZero() (gas: 1020) -LibDecimalFloatGteTest:testGteGasBothZero() (gas: 753) -LibDecimalFloatGteTest:testGteGasDifferentSigns() (gas: 996) -LibDecimalFloatGteTest:testGteGasExponentDiffOverflow() (gas: 1102) +LibDecimalFloatGtTest:testGtXPositiveYNegative(int256,int32,int256,int32) (runs: 5105, μ: 13816, ~: 13647) +LibDecimalFloatGtTest:testGtXPositiveYZero(int256,int32,int32) (runs: 5105, μ: 10294, ~: 10047) +LibDecimalFloatGtTest:testGtZero(int32,int32) (runs: 5105, μ: 4783, ~: 4783) +LibDecimalFloatGteTest:testGteGasAZero() (gas: 997) +LibDecimalFloatGteTest:testGteGasBZero() (gas: 1041) +LibDecimalFloatGteTest:testGteGasBothZero() (gas: 748) +LibDecimalFloatGteTest:testGteGasDifferentSigns() (gas: 1048) +LibDecimalFloatGteTest:testGteGasExponentDiffOverflow() (gas: 1154) LibDecimalFloatGteTest:testGteOneEAny(bytes32) (runs: 5105, μ: 3494, ~: 3494) -LibDecimalFloatGteTest:testGteReference(int224,int32,int224,int32) (runs: 5105, μ: 8115, ~: 6344) -LibDecimalFloatGteTest:testGteX(int224,int32) (runs: 5105, μ: 3925, ~: 3925) -LibDecimalFloatGteTest:testGteXEAnyVsXEAny(int256,int32,int32) (runs: 5105, μ: 10622, ~: 10364) -LibDecimalFloatGteTest:testGteXEAnyVsXEAnyNegative(int256,int32,int32) (runs: 5105, μ: 11156, ~: 11361) -LibDecimalFloatGteTest:testGteXNotLtY(bytes32,bytes32) (runs: 5105, μ: 3947, ~: 3873) -LibDecimalFloatGteTest:testGteXPositiveYNegative(int256,int32,int256,int32) (runs: 5105, μ: 13794, ~: 13623) -LibDecimalFloatGteTest:testGteXPositiveYZero(int256,int32,int32) (runs: 5105, μ: 9551, ~: 9170) -LibDecimalFloatGteTest:testGteZero(int32,int32) (runs: 5105, μ: 4838, ~: 4838) -LibDecimalFloatImplementationAddTest:testAdd123456789987654321() (gas: 4811) -LibDecimalFloatImplementationAddTest:testAdd123456789e9987654321() (gas: 4861) -LibDecimalFloatImplementationAddTest:testAddNeverRevert(int256,int256,int256,int256) (runs: 5105, μ: 13101, ~: 13034) -LibDecimalFloatImplementationAddTest:testAddOneOneNotMaximized() (gas: 6148) -LibDecimalFloatImplementationAddTest:testAddOneOnePreMaximized() (gas: 4300) +LibDecimalFloatGteTest:testGteReference(int224,int32,int224,int32) (runs: 5105, μ: 8170, ~: 6396) +LibDecimalFloatGteTest:testGteX(int224,int32) (runs: 5105, μ: 3950, ~: 3951) +LibDecimalFloatGteTest:testGteXEAnyVsXEAny(int256,int32,int32) (runs: 5105, μ: 10675, ~: 10416) +LibDecimalFloatGteTest:testGteXEAnyVsXEAnyNegative(int256,int32,int32) (runs: 5105, μ: 11207, ~: 11413) +LibDecimalFloatGteTest:testGteXNotLtY(bytes32,bytes32) (runs: 5105, μ: 3948, ~: 3873) +LibDecimalFloatGteTest:testGteXPositiveYNegative(int256,int32,int256,int32) (runs: 5105, μ: 13845, ~: 13675) +LibDecimalFloatGteTest:testGteXPositiveYZero(int256,int32,int32) (runs: 5105, μ: 9572, ~: 9191) +LibDecimalFloatGteTest:testGteZero(int32,int32) (runs: 5105, μ: 4828, ~: 4828) +LibDecimalFloatImplementationAddTest:testAdd123456789987654321() (gas: 5341) +LibDecimalFloatImplementationAddTest:testAdd123456789e9987654321() (gas: 5391) +LibDecimalFloatImplementationAddTest:testAddNeverRevert(int256,int256,int256,int256) (runs: 5105, μ: 13728, ~: 13703) +LibDecimalFloatImplementationAddTest:testAddOneOneNotMaximized() (gas: 6964) +LibDecimalFloatImplementationAddTest:testAddOneOnePreMaximized() (gas: 4532) LibDecimalFloatImplementationAddTest:testAddOneZero() (gas: 3666) -LibDecimalFloatImplementationAddTest:testAddSameExponent(int256,int256) (runs: 5104, μ: 6865, ~: 6935) +LibDecimalFloatImplementationAddTest:testAddSameExponent(int256,int256) (runs: 5105, μ: 7730, ~: 7847) LibDecimalFloatImplementationAddTest:testAddZero() (gas: 3665) LibDecimalFloatImplementationAddTest:testAddZeroAnyExponent(int128) (runs: 5105, μ: 9293, ~: 9271) LibDecimalFloatImplementationAddTest:testAddZeroOne() (gas: 3664) -LibDecimalFloatImplementationAddTest:testAddZeroToAnyNonZero(int256,int256,int256) (runs: 5105, μ: 13974, ~: 13948) -LibDecimalFloatImplementationAddTest:testAddingSmallToLargeReturnsLargeExamples() (gas: 92086) -LibDecimalFloatImplementationAddTest:testAddingSmallToLargeReturnsLargeFuzz(int256,int256,int256,int256) (runs: 5102, μ: 16980, ~: 16963) -LibDecimalFloatImplementationAddTest:testGasAddOne() (gas: 1342) +LibDecimalFloatImplementationAddTest:testAddZeroToAnyNonZero(int256,int256,int256) (runs: 5105, μ: 13978, ~: 13948) +LibDecimalFloatImplementationAddTest:testAddingSmallToLargeReturnsLargeExamples() (gas: 107795) +LibDecimalFloatImplementationAddTest:testAddingSmallToLargeReturnsLargeFuzz(int256,int256,int256,int256) (runs: 5098, μ: 18260, ~: 18314) +LibDecimalFloatImplementationAddTest:testGasAddOne() (gas: 1830) LibDecimalFloatImplementationAddTest:testGasAddZero() (gas: 360) -LibDecimalFloatImplementationAddTest:testOverflowChecks(int256,int256) (runs: 5105, μ: 3857, ~: 3843) +LibDecimalFloatImplementationAddTest:testOverflowChecks(int256,int256) (runs: 5105, μ: 3857, ~: 3853) LibDecimalFloatImplementationCharacteristicMantissaTest:testCharacteristicMantissaExamples() (gas: 30611) -LibDecimalFloatImplementationDivTest:testDiv1Over3() (gas: 7100) -LibDecimalFloatImplementationDivTest:testDiv1Over3Gas0() (gas: 2315) -LibDecimalFloatImplementationDivTest:testDiv1Over3Gas10() (gas: 19624) -LibDecimalFloatImplementationDivTest:testDiv1Over9Over1Over3() (gas: 14799) -LibDecimalFloatImplementationDivTest:testDiv1e18Over3() (gas: 6782) -LibDecimalFloatImplementationDivTest:testDivBy1(int256,int256) (runs: 5105, μ: 336608, ~: 340641) -LibDecimalFloatImplementationDivTest:testDivByNegativeOneFloat(int256,int256) (runs: 5105, μ: 339113, ~: 343299) -LibDecimalFloatImplementationDivTest:testDivNegative1Over3() (gas: 7173) -LibDecimalFloatImplementationDivTest:testDivOOMs5and2() (gas: 6425) -LibDecimalFloatImplementationDivTest:testDivOOMsOverTen() (gas: 7049) -LibDecimalFloatImplementationDivTest:testDivTenOverOOMs() (gas: 7006) -LibDecimalFloatImplementationDivTest:testDivZero(int256,int256) (runs: 5105, μ: 12126, ~: 12122) -LibDecimalFloatImplementationDivTest:testUnnormalizedThreesDiv0(int256,int256) (runs: 109, μ: 27566756, ~: 27586532) +LibDecimalFloatImplementationDivTest:testDiv1Over3() (gas: 7679) +LibDecimalFloatImplementationDivTest:testDiv1Over3Gas0() (gas: 2566) +LibDecimalFloatImplementationDivTest:testDiv1Over3Gas10() (gas: 21216) +LibDecimalFloatImplementationDivTest:testDiv1Over9Over1Over3() (gas: 16036) +LibDecimalFloatImplementationDivTest:testDiv1e18Over3() (gas: 7233) +LibDecimalFloatImplementationDivTest:testDivBy1(int256,int256) (runs: 5105, μ: 366456, ~: 371759) +LibDecimalFloatImplementationDivTest:testDivByNegativeOneFloat(int256,int256) (runs: 5105, μ: 368960, ~: 374524) +LibDecimalFloatImplementationDivTest:testDivMaxPositiveValueDenominatorNotRevert(int256,int256) (runs: 5105, μ: 2596, ~: 2645) +LibDecimalFloatImplementationDivTest:testDivNegative1Over3() (gas: 7774) +LibDecimalFloatImplementationDivTest:testDivOOMs5and2() (gas: 6676) +LibDecimalFloatImplementationDivTest:testDivOOMsOverTen() (gas: 7614) +LibDecimalFloatImplementationDivTest:testDivTenOverOOMs() (gas: 7573) +LibDecimalFloatImplementationDivTest:testDivZero(int256,int256) (runs: 5105, μ: 9942, ~: 9948) +LibDecimalFloatImplementationDivTest:testUnnormalizedThreesDiv0(int256,int256) (runs: 109, μ: 29907315, ~: 29824868) LibDecimalFloatImplementationEqTest:testEqGasAZero() (gas: 430) LibDecimalFloatImplementationEqTest:testEqGasBZero() (gas: 473) LibDecimalFloatImplementationEqTest:testEqGasBothZero() (gas: 450) @@ -172,20 +173,20 @@ LibDecimalFloatImplementationEqTest:testEqXEAnyVsXEAny(int256,int256,int256) (ru LibDecimalFloatImplementationEqTest:testEqXEqY(int256,int256,int256,int256) (runs: 5105, μ: 732, ~: 753) LibDecimalFloatImplementationEqTest:testEqXNotY(int256,int256,int256,int256) (runs: 5105, μ: 3928, ~: 3953) LibDecimalFloatImplementationEqTest:testEqZero(int256,int256) (runs: 5105, μ: 3440, ~: 3440) -LibDecimalFloatImplementationInvTest:testInv0() (gas: 5547) -LibDecimalFloatImplementationInvTest:testInvGas0() (gas: 2101) -LibDecimalFloatImplementationInvTest:testInvReference(int256,int256) (runs: 5104, μ: 14617, ~: 14572) -LibDecimalFloatImplementationInvTest:testInvSlowGas0() (gas: 2285) -LibDecimalFloatImplementationLog10Test:testExactLogs() (gas: 1265623) -LibDecimalFloatImplementationLog10Test:testExactLookupsLog10() (gas: 1301577) -LibDecimalFloatImplementationLog10Test:testInterpolatedLookups() (gas: 1260176) -LibDecimalFloatImplementationLog10Test:testLog10One() (gas: 1463200) -LibDecimalFloatImplementationLog10Test:testSub1() (gas: 1262148) -LibDecimalFloatImplementationMaximizeTest:testMaximizedEverything(int256,int256) (runs: 5105, μ: 9477, ~: 9455) -LibDecimalFloatImplementationMaximizeTest:testMaximizedExamples() (gas: 165819) -LibDecimalFloatImplementationMaximizeTest:testMaximizedIdempotent(int256,int256) (runs: 5105, μ: 9902, ~: 9868) -LibDecimalFloatImplementationMaximizeTest:testMaximizedReference(int256,int256) (runs: 5105, μ: 13375, ~: 14263) -LibDecimalFloatImplementationMinusTest:testMinusIsSubZero(int256,int256,int256) (runs: 5105, μ: 12949, ~: 12929) +LibDecimalFloatImplementationInvTest:testInv0() (gas: 4452) +LibDecimalFloatImplementationInvTest:testInvGas0() (gas: 2248) +LibDecimalFloatImplementationInvTest:testInvReference(int256,int256) (runs: 5104, μ: 15281, ~: 15362) +LibDecimalFloatImplementationInvTest:testInvSlowGas0() (gas: 2560) +LibDecimalFloatImplementationLog10Test:testExactLogs() (gas: 1268680) +LibDecimalFloatImplementationLog10Test:testExactLookupsLog10() (gas: 1312843) +LibDecimalFloatImplementationLog10Test:testInterpolatedLookups() (gas: 1262722) +LibDecimalFloatImplementationLog10Test:testLog10One() (gas: 1496827) +LibDecimalFloatImplementationLog10Test:testSub1() (gas: 1264080) +LibDecimalFloatImplementationMaximizeTest:testMaximizedEverything(int256,int256) (runs: 5105, μ: 9803, ~: 9799) +LibDecimalFloatImplementationMaximizeTest:testMaximizedExamples() (gas: 192873) +LibDecimalFloatImplementationMaximizeTest:testMaximizedIdempotent(int256,int256) (runs: 5105, μ: 10347, ~: 10319) +LibDecimalFloatImplementationMaximizeTest:testMaximizedReference(int256,int256) (runs: 5105, μ: 13691, ~: 14630) +LibDecimalFloatImplementationMinusTest:testMinusIsSubZero(int256,int256,int256) (runs: 5105, μ: 12935, ~: 12916) LibDecimalFloatImplementationMulTest:testMul123456789987654321() (gas: 5559) LibDecimalFloatImplementationMulTest:testMul123456789987654321WithExponents(int128,int128) (runs: 5105, μ: 15078, ~: 15160) LibDecimalFloatImplementationMulTest:testMul1_3979_0_5() (gas: 6193) @@ -202,15 +203,15 @@ LibDecimalFloatImplementationMulTest:testMulOneZero() (gas: 4481) LibDecimalFloatImplementationMulTest:testMulZero0Exponent() (gas: 4503) LibDecimalFloatImplementationMulTest:testMulZeroAnyExponent(int64,int64) (runs: 5105, μ: 4704, ~: 4704) LibDecimalFloatImplementationMulTest:testMulZeroOne() (gas: 4438) -LibDecimalFloatImplementationPow10Test:testExactLookupsPow10() (gas: 1283184) -LibDecimalFloatImplementationPow10Test:testExactPows() (gas: 1260107) -LibDecimalFloatImplementationPow10Test:testInterpolatedLookupsPower() (gas: 1285615) -LibDecimalFloatImplementationPow10Test:testNoRevert(int224,int32) (runs: 5102, μ: 1259410, ~: 1259180) -LibDecimalFloatImplementationPow10Test:testPow10One() (gas: 1507444) -LibDecimalFloatImplementationSubTest:testSubIsAdd(int256,int256,int256,int256) (runs: 5105, μ: 15801, ~: 15833) -LibDecimalFloatImplementationSubTest:testSubMinSignedValue(int256,int256,int256) (runs: 5105, μ: 14990, ~: 14932) -LibDecimalFloatImplementationSubTest:testSubOneFromMax() (gas: 6517) -LibDecimalFloatImplementationSubTest:testSubSelf(int224,int32) (runs: 5105, μ: 5510, ~: 5620) +LibDecimalFloatImplementationPow10Test:testExactLookupsPow10() (gas: 1286039) +LibDecimalFloatImplementationPow10Test:testExactPows() (gas: 1261197) +LibDecimalFloatImplementationPow10Test:testInterpolatedLookupsPower() (gas: 1295108) +LibDecimalFloatImplementationPow10Test:testNoRevert(int224,int32) (runs: 5102, μ: 1261061, ~: 1258877) +LibDecimalFloatImplementationPow10Test:testPow10One() (gas: 1524230) +LibDecimalFloatImplementationSubTest:testSubIsAdd(int256,int256,int256,int256) (runs: 5105, μ: 17105, ~: 17227) +LibDecimalFloatImplementationSubTest:testSubMinSignedValue(int256,int256,int256) (runs: 5105, μ: 15928, ~: 15913) +LibDecimalFloatImplementationSubTest:testSubOneFromMax() (gas: 7308) +LibDecimalFloatImplementationSubTest:testSubSelf(int224,int32) (runs: 5105, μ: 6203, ~: 6369) LibDecimalFloatImplementationUnabsUnsignedMulOrDivLossyTest:testUnabsUnsignedMulOrDivLossyMixedAB(uint256,uint256,uint256,int256) (runs: 5105, μ: 9961, ~: 9888) LibDecimalFloatImplementationUnabsUnsignedMulOrDivLossyTest:testUnabsUnsignedMulOrDivLossyMixedABOverflow(uint256,uint256,uint256,int256) (runs: 5105, μ: 11207, ~: 11200) LibDecimalFloatImplementationUnabsUnsignedMulOrDivLossyTest:testUnabsUnsignedMulOrDivLossyMixedBA(uint256,uint256,uint256,int256) (runs: 5105, μ: 11205, ~: 11198) @@ -225,41 +226,41 @@ LibDecimalFloatImplementationWithTargetExponentTest:testWithTargetExponentLarger LibDecimalFloatImplementationWithTargetExponentTest:testWithTargetExponentLargerTargetExponentNoRevert(int256,int256,int256) (runs: 5105, μ: 11669, ~: 11718) LibDecimalFloatImplementationWithTargetExponentTest:testWithTargetExponentSameExponentNoop(int256,int256) (runs: 5105, μ: 3676, ~: 3676) LibDecimalFloatImplementationWithTargetExponentTest:testWithTargetExponentSmallerExponentNoRevert(int256,int256,int256) (runs: 5102, μ: 13874, ~: 13665) -LibDecimalFloatInvTest:testInvMem(bytes32) (runs: 5105, μ: 10646, ~: 10686) +LibDecimalFloatInvTest:testInvMem(bytes32) (runs: 5105, μ: 11243, ~: 11322) LibDecimalFloatIsZeroTest:testIsZeroDeployed(bytes32) (runs: 5105, μ: 3899, ~: 3899) LibDecimalFloatIsZeroTest:testIsZeroEqZero(bytes32) (runs: 5105, μ: 3527, ~: 3527) -LibDecimalFloatIsZeroTest:testIsZeroExamples(int32) (runs: 5105, μ: 4477, ~: 4477) -LibDecimalFloatIsZeroTest:testNotIsZero(int224,int32) (runs: 5105, μ: 3896, ~: 3896) -LibDecimalFloatLog10Test:testLog10Packed(bytes32) (runs: 5105, μ: 1647560, ~: 1270163) -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: 5105, μ: 13750, ~: 13593) -LibDecimalFloatLtTest:testLtNegativeVsZero(int256,int32,int32) (runs: 5105, μ: 10790, ~: 11008) -LibDecimalFloatLtTest:testLtOneEAny(int224,int32) (runs: 5105, μ: 3905, ~: 3905) -LibDecimalFloatLtTest:testLtReference(bytes32,bytes32) (runs: 5105, μ: 4698, ~: 4998) -LibDecimalFloatLtTest:testLtVsEqualVsGt(bytes32,bytes32) (runs: 5105, μ: 4323, ~: 4210) -LibDecimalFloatLtTest:testLtX(int224) (runs: 5105, μ: 3798, ~: 3798) -LibDecimalFloatLtTest:testLtXEAnyVsXEAny(int256,int32,int32) (runs: 5105, μ: 10557, ~: 10297) -LibDecimalFloatLtTest:testLtXEAnyVsXEAnyNegative(int256,int32,int32) (runs: 5105, μ: 11153, ~: 11359) -LibDecimalFloatLtTest:testLtZero(int32,int32) (runs: 5105, μ: 4171, ~: 4171) -LibDecimalFloatLteTest:testLteGasAZero() (gas: 997) -LibDecimalFloatLteTest:testLteGasBZero() (gas: 999) -LibDecimalFloatLteTest:testLteGasBothZero() (gas: 753) -LibDecimalFloatLteTest:testLteGasDifferentSigns() (gas: 976) -LibDecimalFloatLteTest:testLteGasExponentDiffOverflow() (gas: 1082) +LibDecimalFloatIsZeroTest:testIsZeroExamples(int32) (runs: 5105, μ: 4467, ~: 4467) +LibDecimalFloatIsZeroTest:testNotIsZero(int224,int32) (runs: 5105, μ: 3922, ~: 3922) +LibDecimalFloatLog10Test:testLog10Packed(bytes32) (runs: 5105, μ: 1648260, ~: 1274563) +LibDecimalFloatLtTest:testLtExamples() (gas: 4015) +LibDecimalFloatLtTest:testLtGasAZero() (gas: 967) +LibDecimalFloatLtTest:testLtGasBZero() (gas: 1033) +LibDecimalFloatLtTest:testLtGasBothZero() (gas: 959) +LibDecimalFloatLtTest:testLtGasDifferentSigns() (gas: 1021) +LibDecimalFloatLtTest:testLtGasExponentDiffOverflow() (gas: 1105) +LibDecimalFloatLtTest:testLtNegativeVsPositive(int256,int32,int256,int32) (runs: 5105, μ: 13801, ~: 13645) +LibDecimalFloatLtTest:testLtNegativeVsZero(int256,int32,int32) (runs: 5105, μ: 10810, ~: 11029) +LibDecimalFloatLtTest:testLtOneEAny(int224,int32) (runs: 5105, μ: 3930, ~: 3931) +LibDecimalFloatLtTest:testLtReference(bytes32,bytes32) (runs: 5105, μ: 4666, ~: 4998) +LibDecimalFloatLtTest:testLtVsEqualVsGt(bytes32,bytes32) (runs: 5105, μ: 4321, ~: 4210) +LibDecimalFloatLtTest:testLtX(int224) (runs: 5105, μ: 3823, ~: 3824) +LibDecimalFloatLtTest:testLtXEAnyVsXEAny(int256,int32,int32) (runs: 5105, μ: 10609, ~: 10349) +LibDecimalFloatLtTest:testLtXEAnyVsXEAnyNegative(int256,int32,int32) (runs: 5105, μ: 11205, ~: 11411) +LibDecimalFloatLtTest:testLtZero(int32,int32) (runs: 5105, μ: 4161, ~: 4161) +LibDecimalFloatLteTest:testLteGasAZero() (gas: 1018) +LibDecimalFloatLteTest:testLteGasBZero() (gas: 1020) +LibDecimalFloatLteTest:testLteGasBothZero() (gas: 748) +LibDecimalFloatLteTest:testLteGasDifferentSigns() (gas: 1028) +LibDecimalFloatLteTest:testLteGasExponentDiffOverflow() (gas: 1134) LibDecimalFloatLteTest:testLteOneEAny(bytes32) (runs: 5105, μ: 3493, ~: 3493) -LibDecimalFloatLteTest:testLteReference(int224,int32,int224,int32) (runs: 5105, μ: 8111, ~: 6315) -LibDecimalFloatLteTest:testLteX(int224,int32) (runs: 5105, μ: 3904, ~: 3904) -LibDecimalFloatLteTest:testLteXEAnyVsXEAny(int256,int32,int32) (runs: 5105, μ: 10582, ~: 10321) -LibDecimalFloatLteTest:testLteXEAnyVsXEAnyNegative(int256,int32,int32) (runs: 5105, μ: 11177, ~: 11383) -LibDecimalFloatLteTest:testLteXNotLtY(bytes32,bytes32) (runs: 5105, μ: 3882, ~: 3807) -LibDecimalFloatLteTest:testLteXPositiveYNegative(int256,int32,int256,int32) (runs: 5105, μ: 13102, ~: 12931) -LibDecimalFloatLteTest:testLteXPositiveYZero(int256,int32,int32) (runs: 5105, μ: 9575, ~: 9191) -LibDecimalFloatLteTest:testLteZero(int32,int32) (runs: 5105, μ: 4816, ~: 4816) +LibDecimalFloatLteTest:testLteReference(int224,int32,int224,int32) (runs: 5105, μ: 8162, ~: 6367) +LibDecimalFloatLteTest:testLteX(int224,int32) (runs: 5105, μ: 3929, ~: 3930) +LibDecimalFloatLteTest:testLteXEAnyVsXEAny(int256,int32,int32) (runs: 5105, μ: 10632, ~: 10373) +LibDecimalFloatLteTest:testLteXEAnyVsXEAnyNegative(int256,int32,int32) (runs: 5105, μ: 11228, ~: 11435) +LibDecimalFloatLteTest:testLteXNotLtY(bytes32,bytes32) (runs: 5105, μ: 3881, ~: 3807) +LibDecimalFloatLteTest:testLteXPositiveYNegative(int256,int32,int256,int32) (runs: 5105, μ: 13153, ~: 12983) +LibDecimalFloatLteTest:testLteXPositiveYZero(int256,int32,int32) (runs: 5105, μ: 9593, ~: 9212) +LibDecimalFloatLteTest:testLteZero(int32,int32) (runs: 5105, μ: 4806, ~: 4806) LibDecimalFloatMaxTest:testMaxX(bytes32) (runs: 5105, μ: 4246, ~: 4246) LibDecimalFloatMaxTest:testMaxXY(bytes32,bytes32) (runs: 5105, μ: 4689, ~: 4613) LibDecimalFloatMaxTest:testMaxXYEqual(bytes32) (runs: 5105, μ: 5272, ~: 5272) @@ -270,31 +271,35 @@ LibDecimalFloatMinTest:testMinXY(bytes32,bytes32) (runs: 5105, μ: 4689, ~: 4613 LibDecimalFloatMinTest:testMinXYEqual(bytes32) (runs: 5105, μ: 5292, ~: 5292) LibDecimalFloatMinTest:testMinXYGreater(bytes32,bytes32) (runs: 5101, μ: 6074, ~: 5961) LibDecimalFloatMinTest:testMinXYLess(bytes32,bytes32) (runs: 5100, μ: 6087, ~: 5972) -LibDecimalFloatMinusTest:testMinusPacked(bytes32) (runs: 5105, μ: 5550, ~: 5550) -LibDecimalFloatMixedTest:testDiv1Over3Mixed() (gas: 11083) -LibDecimalFloatMulTest:testMulPacked(bytes32,bytes32) (runs: 5105, μ: 9629, ~: 10369) -LibDecimalFloatPackTest:testPartsRoundTrip(int224,int32) (runs: 5105, μ: 5352, ~: 5352) -LibDecimalFloatPow10Test:testPow10Packed(bytes32) (runs: 5105, μ: 1643927, ~: 1256517) -LibDecimalFloatPowTest:testNegativePowError(bytes32,bytes32) (runs: 5104, μ: 1247809, ~: 1247883) -LibDecimalFloatPowTest:testPowAZero(int32,bytes32) (runs: 5102, μ: 1246471, ~: 1246471) +LibDecimalFloatMinusTest:testMinusPacked(bytes32) (runs: 5105, μ: 5606, ~: 5607) +LibDecimalFloatMixedTest:testDiv1Over3Mixed() (gas: 11766) +LibDecimalFloatMulTest:testMulPacked(bytes32,bytes32) (runs: 5105, μ: 9690, ~: 10464) +LibDecimalFloatPackTest:testPackExponentOverflow(int256,int256) (runs: 5104, μ: 11079, ~: 11267) +LibDecimalFloatPackTest:testPackNegativeExponentLossyZero(int256,int256) (runs: 5104, μ: 11952, ~: 12110) +LibDecimalFloatPackTest:testPackZero(int256) (runs: 5105, μ: 4469, ~: 4469) +LibDecimalFloatPackTest:testPartsRoundTrip(int224,int32) (runs: 5105, μ: 5484, ~: 5485) +LibDecimalFloatPow10Test:testPow10Packed(bytes32) (runs: 5105, μ: 1644489, ~: 1259111) +LibDecimalFloatPowTest:testNegativePowError(bytes32,bytes32) (runs: 5105, μ: 1248827, ~: 1248862) +LibDecimalFloatPowTest:testPowAZero(int32,bytes32) (runs: 5102, μ: 1246465, ~: 1246465) LibDecimalFloatPowTest:testPowAZeroNegative(bytes32) (runs: 5096, μ: 1246849, ~: 1246849) -LibDecimalFloatPowTest:testPowBOne(bytes32) (runs: 5105, μ: 1547891, ~: 1547859) -LibDecimalFloatPowTest:testPowBZero(bytes32,int32) (runs: 5105, μ: 1246035, ~: 1246035) -LibDecimalFloatPowTest:testPows() (gas: 1316634) -LibDecimalFloatPowTest:testRoundTripFuzzPow(bytes32,bytes32) (runs: 5105, μ: 1262759, ~: 1259024) -LibDecimalFloatPowTest:testRoundTripSimple() (gas: 1608505) -LibDecimalFloatSqrtTest:testRoundTripFuzzSqrt(int224,int32) (runs: 5105, μ: 1297059, ~: 1300666) -LibDecimalFloatSqrtTest:testSqrt() (gas: 1293854) -LibDecimalFloatSqrtTest:testSqrtNegative(bytes32) (runs: 5105, μ: 1247737, ~: 1247845) -LibDecimalFloatSqrtTest:testSqrtRoundTrip() (gas: 1423485) -LibDecimalFloatSubTest:testSubPacked(bytes32,bytes32) (runs: 5105, μ: 9974, ~: 9995) +LibDecimalFloatPowTest:testPowBOne(bytes32) (runs: 5105, μ: 1551450, ~: 1551421) +LibDecimalFloatPowTest:testPowBZero(bytes32,int32) (runs: 5105, μ: 1246055, ~: 1246055) +LibDecimalFloatPowTest:testPows() (gas: 1325188) +LibDecimalFloatPowTest:testRoundTripFuzzPow(bytes32,bytes32) (runs: 5105, μ: 1266212, ~: 1261100) +LibDecimalFloatPowTest:testRoundTripSimple() (gas: 1670371) +LibDecimalFloatSqrtTest:testRoundTripFuzzSqrt(int224,int32) (runs: 5105, μ: 1305598, ~: 1309655) +LibDecimalFloatSqrtTest:testSqrt() (gas: 1300460) +LibDecimalFloatSqrtTest:testSqrtNegative(bytes32) (runs: 5105, μ: 1248766, ~: 1248834) +LibDecimalFloatSqrtTest:testSqrtRoundTrip() (gas: 1454891) +LibDecimalFloatSubTest:testSubPacked(bytes32,bytes32) (runs: 5105, μ: 12226, ~: 12283) LibFormatDecimalFloatCountSigFigs:testCountSigFigsExamples() (gas: 83596) LibFormatDecimalFloatCountSigFigs:testCountSigFigsOne(int256) (runs: 5105, μ: 31874, ~: 31719) LibFormatDecimalFloatCountSigFigs:testCountSigFigsZero(int256) (runs: 5105, μ: 3764, ~: 3764) -LibFormatDecimalFloatToDecimalStringTest:testFormatDecimalCustomSigFigs() (gas: 26601) -LibFormatDecimalFloatToDecimalStringTest:testFormatDecimalExamples() (gas: 895496) -LibFormatDecimalFloatToDecimalStringTest:testFormatDecimalRoundTripNegative(int256,uint256) (runs: 5105, μ: 71186, ~: 73798) -LibFormatDecimalFloatToDecimalStringTest:testFormatDecimalRoundTripNonNegative(uint256,uint256) (runs: 5105, μ: 54819, ~: 47508) +LibFormatDecimalFloatToDecimalStringTest:testFormatDecimalCustomSigFigs() (gas: 26919) +LibFormatDecimalFloatToDecimalStringTest:testFormatDecimalExamples() (gas: 976448) +LibFormatDecimalFloatToDecimalStringTest:testFormatDecimalRoundTripExamples() (gas: 488510) +LibFormatDecimalFloatToDecimalStringTest:testFormatDecimalRoundTripNegative(int256,uint256) (runs: 5105, μ: 71432, ~: 73873) +LibFormatDecimalFloatToDecimalStringTest:testFormatDecimalRoundTripNonNegative(uint256,uint256) (runs: 5105, μ: 54964, ~: 47705) LibLogTableBytesTest:testToBytesAntiLogTableDec() (gas: 159794) LibLogTableBytesTest:testToBytesAntiLogTableDecSmall() (gas: 162322) LibLogTableBytesTest:testToBytesLogTableDec() (gas: 143165) @@ -317,7 +322,7 @@ LibParseDecimalFloatTest:testParseLiteralDecimalFloatEDot() (gas: 4168) LibParseDecimalFloatTest:testParseLiteralDecimalFloatExponentRevert5() (gas: 4176) LibParseDecimalFloatTest:testParseLiteralDecimalFloatExponentRevert6() (gas: 4166) LibParseDecimalFloatTest:testParseLiteralDecimalFloatExponents() (gas: 402907) -LibParseDecimalFloatTest:testParseLiteralDecimalFloatFuzz(uint256,uint8,bool) (runs: 5105, μ: 46189, ~: 37319) +LibParseDecimalFloatTest:testParseLiteralDecimalFloatFuzz(uint256,uint8,bool) (runs: 5105, μ: 46006, ~: 37187) LibParseDecimalFloatTest:testParseLiteralDecimalFloatLeadingZeros() (gas: 59757) LibParseDecimalFloatTest:testParseLiteralDecimalFloatNegativeE() (gas: 6120) LibParseDecimalFloatTest:testParseLiteralDecimalFloatNegativeFrac() (gas: 5115) @@ -326,4 +331,4 @@ LibParseDecimalFloatTest:testParseLiteralDecimalFloatPrecisionRevert1() (gas: 24 LibParseDecimalFloatTest:testParseLiteralDecimalFloatSpecific() (gas: 22959) LibParseDecimalFloatTest:testParseLiteralDecimalFloatUnrelated() (gas: 51254) LibParseDecimalFloatTest:testParsePacked(string) (runs: 5105, μ: 9811, ~: 9692) -TestDecimalFloatUnpackTest:testUnpackDeployed(bytes32) (runs: 5105, μ: 158422, ~: 158422) \ No newline at end of file +TestDecimalFloatUnpackTest:testUnpackDeployed(bytes32) (runs: 5105, μ: 169646, ~: 169646) \ No newline at end of file diff --git a/src/lib/implementation/LibDecimalFloatImplementation.sol b/src/lib/implementation/LibDecimalFloatImplementation.sol index 0be38a18..f7ba8ede 100644 --- a/src/lib/implementation/LibDecimalFloatImplementation.sol +++ b/src/lib/implementation/LibDecimalFloatImplementation.sol @@ -547,9 +547,13 @@ library LibDecimalFloatImplementation { } // Be careful to handle overflow. if (didOverflow) { + if (type(int256).max == exponentA) { + revert ExponentOverflow(signedCoefficientA, exponentA); + } + signedCoefficientA /= 10; signedCoefficientB /= 10; - exponentA += 1; + exponentA++; signedCoefficientA += signedCoefficientB; } else { signedCoefficientA = c; @@ -619,128 +623,124 @@ library LibDecimalFloatImplementation { view returns (int256, int256) { - unchecked { - { - int256 unmaximizedCoefficient = signedCoefficient; - int256 unmaximizedExponent = exponent; - (signedCoefficient, exponent) = maximizeFull(signedCoefficient, exponent); + { + int256 unmaximizedCoefficient = signedCoefficient; + int256 unmaximizedExponent = exponent; + (signedCoefficient, exponent) = maximizeFull(signedCoefficient, exponent); - if (signedCoefficient <= 0) { - if (signedCoefficient == 0) { - revert Log10Zero(); - } else { - revert Log10Negative(unmaximizedCoefficient, unmaximizedExponent); - } + if (signedCoefficient <= 0) { + if (signedCoefficient == 0) { + revert Log10Zero(); + } else { + revert Log10Negative(unmaximizedCoefficient, unmaximizedExponent); } } + } - // all powers of 10 look like 1 with a different exponent - if (signedCoefficient == 1e76) { - return (exponent + 76, 0); - } - bool isAtLeastE76 = signedCoefficient >= 1e76; - - // This is a positive log. i.e. log(x) where x >= 1. - if (exponent >= (isAtLeastE76 ? -76 : -75)) { - int256 y1Coefficient; - int256 y2Coefficient; - int256 x1Coefficient; - int256 x2Coefficient; - // exact powers of 10 are already caught above. - // but e.g. 20 would be 2e76, -75 and true for isAtLeastE76 - // => adding exp 76 yields 1, which is the correct result. - // 200 would be 2e76, -74 and true for isAtLeastE76 - // => adding exp 76 yields 2, which is the correct result. - // however 90 would be 9e75, -74 and false for isAtLeastE76 - // => adding exp 75 yields 1, which is the correct result. - // 900 would be 9e75, -73 and false for isAtLeastE76 - // => adding exp 75 yields 2, which is the correct result. - int256 powerOfTen = exponent + int256(isAtLeastE76 ? int256(76) : int256(75)); - - // Table lookup. - { - int256 scale = 1e72; - assembly ("memory-safe") { - //slither-disable-next-line divide-before-multiply - function lookupTableVal(tables, index) -> result { - // First byte of the data contract must be skipped. - let mainOffset := add(1, mul(div(index, 10), 2)) - mstore(0, 0) - extcodecopy(tables, 30, mainOffset, 2) - let mainTableVal := mload(0) - - result := and(mainTableVal, 0x7FFF) - // Skip first byte of data contract then 1820 bytes - // of the log tables. - let smallTableOffset := 1821 - if iszero(iszero(and(mainTableVal, 0x8000))) { - // Small table is half the size of the main - // table. - smallTableOffset := add(smallTableOffset, 910) - } - - mstore(0, 0) - extcodecopy( - tables, 31, add(smallTableOffset, add(mul(div(index, 100), 10), mod(index, 10))), 1 - ) - result := add(result, mload(0)) - } + // all powers of 10 look like 1 with a different exponent + if (signedCoefficient == 1e76) { + return (exponent + 76, 0); + } + bool isAtLeastE76 = signedCoefficient >= 1e76; + + // This is a positive log. i.e. log(x) where x >= 1. + if (exponent >= (isAtLeastE76 ? -76 : -75)) { + int256 y1Coefficient; + int256 y2Coefficient; + int256 x1Coefficient; + int256 x2Coefficient; + // exact powers of 10 are already caught above. + // but e.g. 20 would be 2e76, -75 and true for isAtLeastE76 + // => adding exp 76 yields 1, which is the correct result. + // 200 would be 2e76, -74 and true for isAtLeastE76 + // => adding exp 76 yields 2, which is the correct result. + // however 90 would be 9e75, -74 and false for isAtLeastE76 + // => adding exp 75 yields 1, which is the correct result. + // 900 would be 9e75, -73 and false for isAtLeastE76 + // => adding exp 75 yields 2, which is the correct result. + int256 powerOfTen = exponent + int256(isAtLeastE76 ? int256(76) : int256(75)); - // Need to increase the scale by one OOM here so that the - // signed coefficient has 4 digits always, to make it - // easy to calculate the idx. - if isAtLeastE76 { scale := mul(scale, 10) } - - // Truncate the signed coefficient to what we can look - // up in the table. - // Slither false positive because the truncation is - // deliberate here. - //slither-disable-next-line divide-before-multiply - x1Coefficient := div(signedCoefficient, scale) - let idx := sub(x1Coefficient, 1000) - x1Coefficient := mul(x1Coefficient, scale) - // Technically we only need to do this if we need to - // interpolate but it's cheaper to just do an `add` - // unconditionally than pay for an `if` and often also - // do the `add`. - x2Coefficient := add(x1Coefficient, scale) - - // If we don't bring the scale back down here we can get - // overflows when multiplying the output of the lookups. - // We are reusing the same scale variable to avoid a - // compiler stack overflow. - // Slither false positive here, this division is simply - // the inverse of the mul above. - //slither-disable-next-line divide-before-multiply - if isAtLeastE76 { scale := div(scale, 10) } - - y1Coefficient := mul(scale, lookupTableVal(tablesDataContract, idx)) - // Only do the second lookup if we expect interpolation - // to need it. - if iszero(eq(x1Coefficient, signedCoefficient)) { - y2Coefficient := mul(scale, lookupTableVal(tablesDataContract, add(idx, 1))) + // Table lookup. + { + int256 scale = 1e72; + assembly ("memory-safe") { + //slither-disable-next-line divide-before-multiply + function lookupTableVal(tables, index) -> result { + // First byte of the data contract must be skipped. + let mainOffset := add(1, mul(div(index, 10), 2)) + mstore(0, 0) + extcodecopy(tables, 30, mainOffset, 2) + let mainTableVal := mload(0) + + result := and(mainTableVal, 0x7FFF) + // Skip first byte of data contract then 1820 bytes + // of the log tables. + let smallTableOffset := 1821 + if iszero(iszero(and(mainTableVal, 0x8000))) { + // Small table is half the size of the main + // table. + smallTableOffset := add(smallTableOffset, 910) } + + mstore(0, 0) + extcodecopy(tables, 31, add(smallTableOffset, add(mul(div(index, 100), 10), mod(index, 10))), 1) + result := add(result, mload(0)) } - } - (signedCoefficient, exponent) = unitLinearInterpolation( - x1Coefficient, - signedCoefficient, - x2Coefficient, - exponent, - y1Coefficient, - y2Coefficient, - LOG10_Y_EXPONENT - ); - return add(signedCoefficient, exponent, powerOfTen, 0); - } - // This is a negative log. i.e. log(x) where 0 < x < 1. - // log(x) = -log(1/x) - else { - (signedCoefficient, exponent) = inv(signedCoefficient, exponent); - (signedCoefficient, exponent) = log10(tablesDataContract, signedCoefficient, exponent); - return minus(signedCoefficient, exponent); + // Need to increase the scale by one OOM here so that the + // signed coefficient has 4 digits always, to make it + // easy to calculate the idx. + if isAtLeastE76 { scale := mul(scale, 10) } + + // Truncate the signed coefficient to what we can look + // up in the table. + // Slither false positive because the truncation is + // deliberate here. + //slither-disable-next-line divide-before-multiply + x1Coefficient := div(signedCoefficient, scale) + let idx := sub(x1Coefficient, 1000) + x1Coefficient := mul(x1Coefficient, scale) + // Technically we only need to do this if we need to + // interpolate but it's cheaper to just do an `add` + // unconditionally than pay for an `if` and often also + // do the `add`. + x2Coefficient := add(x1Coefficient, scale) + + // If we don't bring the scale back down here we can get + // overflows when multiplying the output of the lookups. + // We are reusing the same scale variable to avoid a + // compiler stack overflow. + // Slither false positive here, this division is simply + // the inverse of the mul above. + //slither-disable-next-line divide-before-multiply + if isAtLeastE76 { scale := div(scale, 10) } + + y1Coefficient := mul(scale, lookupTableVal(tablesDataContract, idx)) + // Only do the second lookup if we expect interpolation + // to need it. + if iszero(eq(x1Coefficient, signedCoefficient)) { + y2Coefficient := mul(scale, lookupTableVal(tablesDataContract, add(idx, 1))) + } + } } + + (signedCoefficient, exponent) = unitLinearInterpolation( + x1Coefficient, + signedCoefficient, + x2Coefficient, + exponent, + y1Coefficient, + y2Coefficient, + LOG10_Y_EXPONENT + ); + return add(signedCoefficient, exponent, powerOfTen, 0); + } + // This is a negative log. i.e. log(x) where 0 < x < 1. + // log(x) = -log(1/x) + else { + (signedCoefficient, exponent) = inv(signedCoefficient, exponent); + (signedCoefficient, exponent) = log10(tablesDataContract, signedCoefficient, exponent); + return minus(signedCoefficient, exponent); } } @@ -760,36 +760,32 @@ library LibDecimalFloatImplementation { view returns (int256, int256) { - unchecked { - if (signedCoefficient < 0) { - (signedCoefficient, exponent) = minus(signedCoefficient, exponent); - (signedCoefficient, exponent) = pow10(tablesDataContract, signedCoefficient, exponent); - return inv(signedCoefficient, exponent); - } + if (signedCoefficient < 0) { + (signedCoefficient, exponent) = minus(signedCoefficient, exponent); + (signedCoefficient, exponent) = pow10(tablesDataContract, signedCoefficient, exponent); + return inv(signedCoefficient, exponent); + } - // Table lookup. - (int256 characteristicCoefficient, int256 mantissaCoefficient) = - characteristicMantissa(signedCoefficient, exponent); - int256 characteristicExponent = exponent; - { - (int256 idx, bool interpolate, int256 scale) = mantissa4(mantissaCoefficient, exponent); - (int256 y1Coefficient, int256 y2Coefficient) = - lookupAntilogTableY1Y2(tablesDataContract, uint256(idx), interpolate); - if (interpolate) { - (signedCoefficient, exponent) = unitLinearInterpolation( - idx * scale, mantissaCoefficient, (idx + 1) * scale, exponent, y1Coefficient, y2Coefficient, -4 - ); - } else { - signedCoefficient = y1Coefficient; - exponent = -4; - } + // Table lookup. + (int256 characteristicCoefficient, int256 mantissaCoefficient) = + characteristicMantissa(signedCoefficient, exponent); + int256 characteristicExponent = exponent; + { + (int256 idx, bool interpolate, int256 scale) = mantissa4(mantissaCoefficient, exponent); + (int256 y1Coefficient, int256 y2Coefficient) = + lookupAntilogTableY1Y2(tablesDataContract, uint256(idx), interpolate); + if (interpolate) { + (signedCoefficient, exponent) = unitLinearInterpolation( + idx * scale, mantissaCoefficient, (idx + 1) * scale, exponent, y1Coefficient, y2Coefficient, -4 + ); + } else { + signedCoefficient = y1Coefficient; + exponent = -4; } - - return ( - signedCoefficient, - 1 + exponent + withTargetExponent(characteristicCoefficient, characteristicExponent, 0) - ); } + + return + (signedCoefficient, 1 + exponent + withTargetExponent(characteristicCoefficient, characteristicExponent, 0)); } /// @return signedCoefficient The maximized signed coefficient. diff --git a/test/src/lib/implementation/LibDecimalFloatImplementation.add.t.sol b/test/src/lib/implementation/LibDecimalFloatImplementation.add.t.sol index 62216172..8c628951 100644 --- a/test/src/lib/implementation/LibDecimalFloatImplementation.add.t.sol +++ b/test/src/lib/implementation/LibDecimalFloatImplementation.add.t.sol @@ -3,6 +3,7 @@ pragma solidity =0.8.25; import { + ExponentOverflow, LibDecimalFloatImplementation, EXPONENT_MIN, EXPONENT_MAX, @@ -11,6 +12,14 @@ import { import {Test} from "forge-std/Test.sol"; contract LibDecimalFloatImplementationAddTest is Test { + function addExternal(int256 signedCoefficientA, int256 exponentA, int256 signedCoefficientB, int256 exponentB) + external + pure + returns (int256 signedCoefficient, int256 exponent) + { + return LibDecimalFloatImplementation.add(signedCoefficientA, exponentA, signedCoefficientB, exponentB); + } + function willOverflow(int256 a, int256 b) internal pure returns (bool) { unchecked { if (a > 0 && b > 0) { @@ -126,6 +135,11 @@ contract LibDecimalFloatImplementationAddTest is Test { LibDecimalFloatImplementation.add(1e37, -37, 1e37, -37); } + function testAddRevertMaxA() external { + vm.expectRevert(abi.encodeWithSelector(ExponentOverflow.selector, type(int256).max, type(int256).max)); + this.addExternal(type(int256).max, type(int256).max, 1, type(int256).max); + } + /// Provided our exponents are in range we should never revert. function testAddNeverRevert( int256 signedCoefficientA,