From 10a21932e02e34f038d7e2e7a4cf529826a537c6 Mon Sep 17 00:00:00 2001 From: thedavidmeister Date: Wed, 30 Jul 2025 22:12:30 +0200 Subject: [PATCH 1/4] max positive value --- src/concrete/DecimalFloat.sol | 8 ++++---- src/lib/LibDecimalFloat.sol | 3 ++- test/src/concrete/DecimalFloat.constants.t.sol | 12 ++++++------ test/src/lib/LibDecimalFloat.constants.t.sol | 2 +- 4 files changed, 13 insertions(+), 12 deletions(-) diff --git a/src/concrete/DecimalFloat.sol b/src/concrete/DecimalFloat.sol index 26311217..7e617e72 100644 --- a/src/concrete/DecimalFloat.sol +++ b/src/concrete/DecimalFloat.sol @@ -8,13 +8,13 @@ import {LibParseDecimalFloat} from "../lib/parse/LibParseDecimalFloat.sol"; contract DecimalFloat { using LibDecimalFloat for Float; - /// Exposes `LibDecimalFloat.FLOAT_MAX_VALUE` for offchain use. + /// Exposes `LibDecimalFloat.FLOAT_MAX_POSITIVE_VALUE` for offchain use. /// @return The maximum value of a Float. - function maxValue() external pure returns (Float) { - return LibDecimalFloat.FLOAT_MAX_VALUE; + function maxPositiveValue() external pure returns (Float) { + return LibDecimalFloat.FLOAT_MAX_POSITIVE_VALUE; } - /// Exposes `LibDecimalFloat.FLOAT_MIN_VALUE` for offchain use. + /// Exposes `LibDecimalFloat.FLOAT_MIN_NEGATIVE_VALUE` for offchain use. /// @return The minimum value of a Float. function minNegativeValue() external pure returns (Float) { return LibDecimalFloat.FLOAT_MIN_NEGATIVE_VALUE; diff --git a/src/lib/LibDecimalFloat.sol b/src/lib/LibDecimalFloat.sol index 812655f8..f0a7895e 100644 --- a/src/lib/LibDecimalFloat.sol +++ b/src/lib/LibDecimalFloat.sol @@ -94,8 +94,9 @@ library LibDecimalFloat { Float constant FLOAT_ONE = Float.wrap(bytes32(uint256(1))); + /// Largest possible positive value. /// type(int224).max, type(int32).max - Float constant FLOAT_MAX_VALUE = + Float constant FLOAT_MAX_POSITIVE_VALUE = Float.wrap(bytes32(uint256(0x7fffffff7fffffffffffffffffffffffffffffffffffffffffffffffffffffff))); /// type (int224).min, type(int32).max diff --git a/test/src/concrete/DecimalFloat.constants.t.sol b/test/src/concrete/DecimalFloat.constants.t.sol index e04f688e..29424fe1 100644 --- a/test/src/concrete/DecimalFloat.constants.t.sol +++ b/test/src/concrete/DecimalFloat.constants.t.sol @@ -8,20 +8,20 @@ import {DecimalFloat} from "src/concrete/DecimalFloat.sol"; contract DecimalFloatConstantsTest is Test { using LibDecimalFloat for Float; - function maxValueExternal() external pure returns (Float) { - return LibDecimalFloat.FLOAT_MAX_VALUE; + function maxPositiveValueExternal() external pure returns (Float) { + return LibDecimalFloat.FLOAT_MAX_POSITIVE_VALUE; } function testMaxValueDeployed() external { DecimalFloat deployed = new DecimalFloat(); - try this.maxValueExternal() returns (Float maxValue) { - Float deployedMaxValue = deployed.maxValue(); + try this.maxPositiveValueExternal() returns (Float maxValue) { + Float deployedMaxPositiveValue = deployed.maxPositiveValue(); - assertEq(Float.unwrap(maxValue), Float.unwrap(deployedMaxValue)); + assertEq(Float.unwrap(maxValue), Float.unwrap(deployedMaxPositiveValue)); } catch (bytes memory err) { vm.expectRevert(err); - deployed.maxValue(); + deployed.maxPositiveValue(); } } diff --git a/test/src/lib/LibDecimalFloat.constants.t.sol b/test/src/lib/LibDecimalFloat.constants.t.sol index cff9c063..49981fff 100644 --- a/test/src/lib/LibDecimalFloat.constants.t.sol +++ b/test/src/lib/LibDecimalFloat.constants.t.sol @@ -8,7 +8,7 @@ contract LibDecimalFloatConstantsTest is Test { using LibDecimalFloat for Float; function testFloatMaxValue() external pure { - Float maxValue = LibDecimalFloat.FLOAT_MAX_VALUE; + Float maxValue = LibDecimalFloat.FLOAT_MAX_POSITIVE_VALUE; Float expected = LibDecimalFloat.packLossless(type(int224).max, type(int32).max); assertEq(Float.unwrap(maxValue), Float.unwrap(expected)); } From 27ab6b34aa34a374567fee79bd0b57e2932378f5 Mon Sep 17 00:00:00 2001 From: thedavidmeister Date: Wed, 30 Jul 2025 22:56:21 +0200 Subject: [PATCH 2/4] min const --- .gas-snapshot | 332 +++++++++--------- src/concrete/DecimalFloat.sol | 16 +- src/lib/LibDecimalFloat.sol | 14 + .../src/concrete/DecimalFloat.constants.t.sol | 36 +- test/src/lib/LibDecimalFloat.constants.t.sol | 42 ++- 5 files changed, 276 insertions(+), 164 deletions(-) diff --git a/.gas-snapshot b/.gas-snapshot index 3a163e0d..38b6737b 100644 --- a/.gas-snapshot +++ b/.gas-snapshot @@ -1,124 +1,134 @@ -DecimalFloatAbsTest:testAbsDeployed(bytes32) (runs: 5096, μ: 2384006, ~: 2383948) -DecimalFloatAddTest:testAddDeployed(bytes32,bytes32) (runs: 5096, μ: 2386769, ~: 2386452) -DecimalFloatConstantsTest:testEDeployed() (gas: 2383146) -DecimalFloatConstantsTest:testMaxValueDeployed() (gas: 2383113) -DecimalFloatConstantsTest:testMinNegativeValueDeployed() (gas: 2383178) -DecimalFloatDivTest:testDivDeployed(bytes32,bytes32) (runs: 5096, μ: 2386503, ~: 2386350) -DecimalFloatEqTest:testEqDeployed(bytes32,bytes32) (runs: 5096, μ: 2384412, ~: 2384338) -DecimalFloatFloorTest:testFloorDeployed(bytes32) (runs: 5096, μ: 2384231, ~: 2384215) -DecimalFloatFormatTest:testFormatDeployed(bytes32) (runs: 5096, μ: 2388071, ~: 2387896) -DecimalFloatFracTest:testFracDeployed(bytes32) (runs: 5096, μ: 2384257, ~: 2384241) -DecimalFloatFromFixedDecimalLosslessTest:testFromFixedDecimalLosslessDeployed(uint256,uint8) (runs: 5096, μ: 2384813, ~: 2384745) -DecimalFloatFromFixedDecimalLossyTest:testFromFixedDecimalLossyDeployed(uint256,uint8) (runs: 5096, μ: 2385300, ~: 2385215) -DecimalFloatGtTest:testGtDeployed(bytes32,bytes32) (runs: 5096, μ: 2384332, ~: 2384258) -DecimalFloatGteTest:testGteDeployed(bytes32,bytes32) (runs: 5096, μ: 2384405, ~: 2384331) -DecimalFloatInvTest:testInvDeployed(bytes32) (runs: 5096, μ: 2385601, ~: 2385521) -DecimalFloatIsZeroTest:testIsZeroDeployed(bytes32) (runs: 5096, μ: 2383523, ~: 2383523) -DecimalFloatLtTest:testLtDeployed(bytes32,bytes32) (runs: 5096, μ: 2384309, ~: 2384235) -DecimalFloatLteTest:testLteDeployed(bytes32,bytes32) (runs: 5096, μ: 2384362, ~: 2384288) -DecimalFloatMaxTest:testMaxDeployed(bytes32,bytes32) (runs: 5096, μ: 2384393, ~: 2384332) -DecimalFloatMinTest:testMinDeployed(bytes32,bytes32) (runs: 5096, μ: 2384413, ~: 2384352) -DecimalFloatMinusTest:testMinusDeployed(bytes32) (runs: 5096, μ: 2384083, ~: 2384083) -DecimalFloatMulTest:testMulDeployed(bytes32,bytes32) (runs: 5096, μ: 2386245, ~: 2387310) -DecimalFloatPackLosslessTest:testPackDeployed(int224,int32) (runs: 5096, μ: 158769, ~: 158769) -DecimalFloatParseTest:testParseDeployed(string) (runs: 5096, μ: 2386760, ~: 2386629) -DecimalFloatSubTest:testSubDeployed(bytes32,bytes32) (runs: 5096, μ: 2387033, ~: 2386723) -DecimalFloatToFixedDecimalLosslessTest:testToFixedDecimalLosslessDeployed(bytes32,uint8) (runs: 5096, μ: 2385459, ~: 2385350) -DecimalFloatToFixedDecimalLossyTest:testToFixedDecimalLossyDeployed(bytes32,uint8) (runs: 5096, μ: 2385576, ~: 2385857) -LibDecimalFloatAbsTest:testAbsMinValue(int32) (runs: 5096, μ: 5121, ~: 5121) -LibDecimalFloatAbsTest:testAbsNegative(int256,int32) (runs: 5096, μ: 10475, ~: 10702) -LibDecimalFloatAbsTest:testAbsNonNegative(int256,int32) (runs: 5096, μ: 9641, ~: 9392) -LibDecimalFloatConstantsTest:testFloatE() (gas: 3379) -LibDecimalFloatConstantsTest:testFloatMaxValue() (gas: 3335) -LibDecimalFloatConstantsTest:testFloatMinValue() (gas: 3335) -LibDecimalFloatDecimalAddTest:testAddPacked(bytes32,bytes32) (runs: 5096, μ: 8361, ~: 8036) -LibDecimalFloatDecimalLosslessTest:testFromFixedDecimalLosslessFail(uint256,uint8) (runs: 5096, μ: 9615, ~: 9663) -LibDecimalFloatDecimalLosslessTest:testFromFixedDecimalLosslessMem(uint256,uint8) (runs: 5096, μ: 8130, ~: 8048) -LibDecimalFloatDecimalLosslessTest:testFromFixedDecimalLosslessPass(uint256,uint8) (runs: 5096, μ: 7452, ~: 7424) +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) +LibDecimalFloatConstantsTest:testFloatOne() (gas: 3358) +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) LibDecimalFloatDecimalLosslessTest:testToFixedDecimalLosslessFail() (gas: 4894) -LibDecimalFloatDecimalLosslessTest:testToFixedDecimalLosslessPacked(bytes32,uint8) (runs: 5096, μ: 6718, ~: 6161) -LibDecimalFloatDecimalLosslessTest:testToFixedDecimalLosslessPass(int256,int256,uint8) (runs: 5096, μ: 15805, ~: 15768) -LibDecimalFloatDecimalTest:testFixedDecimalRoundTripLossless(uint256,uint8) (runs: 5096, μ: 9274, ~: 9053) +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) 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: 5096, μ: 9460, ~: 9374) -LibDecimalFloatDecimalTest:testFromFixedDecimalLossyTruncateOne(uint256,uint8) (runs: 5096, μ: 5978, ~: 5937) -LibDecimalFloatDecimalTest:testFromFixedDecimalLossyTruncateZero(uint256,uint8) (runs: 5096, μ: 7305, ~: 5860) -LibDecimalFloatDecimalTest:testToFixedDecimalLosslessScaleUp(int256,int256,uint8) (runs: 5096, μ: 16005, ~: 15996) -LibDecimalFloatDecimalTest:testToFixedDecimalLossyExponentOverflow(int256,int256,uint8) (runs: 5096, μ: 14964, ~: 14729) -LibDecimalFloatDecimalTest:testToFixedDecimalLossyIdentity(int256,uint8) (runs: 5096, μ: 10152, ~: 9811) -LibDecimalFloatDecimalTest:testToFixedDecimalLossyNegative(int256,int256,uint8) (runs: 5096, μ: 10825, ~: 11076) -LibDecimalFloatDecimalTest:testToFixedDecimalLossyPacked(bytes32,uint8) (runs: 5096, μ: 6804, ~: 6905) -LibDecimalFloatDecimalTest:testToFixedDecimalLossyScaleUpOverflow(int256,int256,uint8) (runs: 5096, μ: 15348, ~: 15612) -LibDecimalFloatDecimalTest:testToFixedDecimalLossyTruncate(int256,int256,uint8) (runs: 5096, μ: 14493, ~: 14212) +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:testToFixedDecimalLossyTruncateLossless() (gas: 14523) -LibDecimalFloatDecimalTest:testToFixedDecimalLossyUnderflow(int256,int256,uint8) (runs: 5096, μ: 13738, ~: 13602) -LibDecimalFloatDecimalTest:testToFixedDecimalLossyZero(int256,uint8) (runs: 5096, μ: 4598, ~: 4598) -LibDecimalFloatDivTest:testDivPacked(bytes32,bytes32) (runs: 5096, μ: 8052, ~: 7855) -LibDecimalFloatEqTest:testEqPacked(bytes32,bytes32) (runs: 5096, μ: 5524, ~: 5450) -LibDecimalFloatEqTest:testEqXNotYExponents(bytes32,bytes32) (runs: 5096, μ: 4341, ~: 4234) -LibDecimalFloatEqTest:testEqZero(int32) (runs: 5096, μ: 5133, ~: 5133) +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) LibDecimalFloatFloorTest:testFloorExamples() (gas: 38974) LibDecimalFloatFloorTest:testFloorGas0() (gas: 937) LibDecimalFloatFloorTest:testFloorGasTiny() (gas: 858) LibDecimalFloatFloorTest:testFloorGasZero() (gas: 809) -LibDecimalFloatFloorTest:testFloorInRange(int224,int256) (runs: 5096, μ: 11009, ~: 11021) -LibDecimalFloatFloorTest:testFloorLessThanMin(int224,int256) (runs: 5096, μ: 10261, ~: 10270) -LibDecimalFloatFloorTest:testFloorNonNegative(int224,int256) (runs: 5096, μ: 9803, ~: 10062) -LibDecimalFloatFloorTest:testFloorNotReverts(bytes32) (runs: 5096, μ: 630, ~: 621) +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) LibDecimalFloatFracTest:testFracExamples() (gas: 39135) LibDecimalFloatFracTest:testFracGas0() (gas: 960) LibDecimalFloatFracTest:testFracGasTiny() (gas: 836) LibDecimalFloatFracTest:testFracGasZero() (gas: 820) -LibDecimalFloatFracTest:testFracInRange(int224,int256) (runs: 5096, μ: 10847, ~: 10859) -LibDecimalFloatFracTest:testFracLessThanMin(int224,int256) (runs: 5096, μ: 10273, ~: 10280) -LibDecimalFloatFracTest:testFracNonNegative(int224,int256) (runs: 5096, μ: 9806, ~: 10066) -LibDecimalFloatFracTest:testFracNotReverts(bytes32) (runs: 5096, μ: 630, ~: 621) +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) LibDecimalFloatGtTest:testGtGasAZero() (gas: 973) LibDecimalFloatGtTest:testGtGasBZero() (gas: 973) LibDecimalFloatGtTest:testGtGasBothZero() (gas: 751) LibDecimalFloatGtTest:testGtGasDifferentSigns() (gas: 974) LibDecimalFloatGtTest:testGtGasExponentDiffOverflow() (gas: 1143) -LibDecimalFloatGtTest:testGtOneEAny(bytes32) (runs: 5096, μ: 3494, ~: 3494) -LibDecimalFloatGtTest:testGtReference(int224,int32,int224,int32) (runs: 5096, μ: 8067, ~: 6285) -LibDecimalFloatGtTest:testGtX(int224,int32) (runs: 5096, μ: 3882, ~: 3882) -LibDecimalFloatGtTest:testGtXEAnyVsXEAny(int256,int32,int32) (runs: 5096, μ: 10592, ~: 10332) -LibDecimalFloatGtTest:testGtXEAnyVsXEAnyNegative(int256,int32,int32) (runs: 5096, μ: 11144, ~: 11349) -LibDecimalFloatGtTest:testGtXNotY(bytes32,bytes32) (runs: 5096, μ: 4341, ~: 4232) -LibDecimalFloatGtTest:testGtXPositiveYNegative(int256,int32,int256,int32) (runs: 5096, μ: 13764, ~: 13595) -LibDecimalFloatGtTest:testGtXPositiveYZero(int256,int32,int32) (runs: 5096, μ: 10273, ~: 10026) -LibDecimalFloatGtTest:testGtZero(int32,int32) (runs: 5096, μ: 4793, ~: 4793) +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) LibDecimalFloatGteTest:testGteGasAZero() (gas: 976) LibDecimalFloatGteTest:testGteGasBZero() (gas: 1020) LibDecimalFloatGteTest:testGteGasBothZero() (gas: 753) LibDecimalFloatGteTest:testGteGasDifferentSigns() (gas: 996) LibDecimalFloatGteTest:testGteGasExponentDiffOverflow() (gas: 1102) -LibDecimalFloatGteTest:testGteOneEAny(bytes32) (runs: 5096, μ: 3494, ~: 3494) -LibDecimalFloatGteTest:testGteReference(int224,int32,int224,int32) (runs: 5096, μ: 8117, ~: 6344) -LibDecimalFloatGteTest:testGteX(int224,int32) (runs: 5096, μ: 3925, ~: 3925) -LibDecimalFloatGteTest:testGteXEAnyVsXEAny(int256,int32,int32) (runs: 5096, μ: 10622, ~: 10364) -LibDecimalFloatGteTest:testGteXEAnyVsXEAnyNegative(int256,int32,int32) (runs: 5096, μ: 11156, ~: 11361) -LibDecimalFloatGteTest:testGteXNotLtY(bytes32,bytes32) (runs: 5096, μ: 3947, ~: 3873) -LibDecimalFloatGteTest:testGteXPositiveYNegative(int256,int32,int256,int32) (runs: 5096, μ: 13794, ~: 13623) -LibDecimalFloatGteTest:testGteXPositiveYZero(int256,int32,int32) (runs: 5096, μ: 9551, ~: 9170) -LibDecimalFloatGteTest:testGteZero(int32,int32) (runs: 5096, μ: 4838, ~: 4838) +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) LibDecimalFloatImplementationAddTest:testAdd123456789987654321() (gas: 4813) LibDecimalFloatImplementationAddTest:testAdd123456789e9987654321() (gas: 4865) -LibDecimalFloatImplementationAddTest:testAddNeverRevert(int256,int256,int256,int256) (runs: 5096, μ: 13213, ~: 13134) +LibDecimalFloatImplementationAddTest:testAddNeverRevert(int256,int256,int256,int256) (runs: 5115, μ: 13213, ~: 13133) LibDecimalFloatImplementationAddTest:testAddOneOneNotNormalized() (gas: 5368) LibDecimalFloatImplementationAddTest:testAddOneOnePreNormalized() (gas: 4250) LibDecimalFloatImplementationAddTest:testAddOneZero() (gas: 3688) -LibDecimalFloatImplementationAddTest:testAddSameExponentSameCoefficient(int256,int256) (runs: 5096, μ: 5764, ~: 5813) +LibDecimalFloatImplementationAddTest:testAddSameExponentSameCoefficient(int256,int256) (runs: 5115, μ: 5764, ~: 5813) LibDecimalFloatImplementationAddTest:testAddZero() (gas: 3664) -LibDecimalFloatImplementationAddTest:testAddZeroAnyExponent(int128) (runs: 5096, μ: 9294, ~: 9271) +LibDecimalFloatImplementationAddTest:testAddZeroAnyExponent(int128) (runs: 5115, μ: 9294, ~: 9271) LibDecimalFloatImplementationAddTest:testAddZeroOne() (gas: 3686) -LibDecimalFloatImplementationAddTest:testAddZeroToAnyNonZero(int256,int256,int256) (runs: 5096, μ: 14015, ~: 14005) +LibDecimalFloatImplementationAddTest:testAddZeroToAnyNonZero(int256,int256,int256) (runs: 5115, μ: 14015, ~: 13877) LibDecimalFloatImplementationAddTest:testAddingSmallToLargeReturnsLargeExamples() (gas: 19289) -LibDecimalFloatImplementationAddTest:testAddingSmallToLargeReturnsLargeFuzz(int256,int256,int256,int256) (runs: 5096, μ: 17092, ~: 17016) +LibDecimalFloatImplementationAddTest:testAddingSmallToLargeReturnsLargeFuzz(int256,int256,int256,int256) (runs: 5104, μ: 17092, ~: 17016) LibDecimalFloatImplementationAddTest:testGasAddOne() (gas: 944) LibDecimalFloatImplementationAddTest:testGasAddZero() (gas: 382) LibDecimalFloatImplementationDivTest:testDiv1Over3() (gas: 6014) @@ -130,112 +140,116 @@ LibDecimalFloatImplementationDivTest:testDivNegative1Over3() (gas: 6074) LibDecimalFloatImplementationDivTest:testDivOOMs5and2() (gas: 4848) LibDecimalFloatImplementationDivTest:testDivOOMsOverTen() (gas: 5665) LibDecimalFloatImplementationDivTest:testDivTenOverOOMs() (gas: 5590) -LibDecimalFloatImplementationDivTest:testUnnormalizedThreesDiv0(int256,int256) (runs: 100, μ: 21050734, ~: 21050370) +LibDecimalFloatImplementationDivTest:testUnnormalizedThreesDiv0(int256,int256) (runs: 119, μ: 21050704, ~: 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: 5096, μ: 654, ~: 679) -LibDecimalFloatImplementationEqTest:testEqOneEAny(int256,int256) (runs: 5096, μ: 3416, ~: 3416) -LibDecimalFloatImplementationEqTest:testEqReference(int256,int256,int256,int256) (runs: 5096, μ: 9904, ~: 11446) -LibDecimalFloatImplementationEqTest:testEqX(int256) (runs: 5096, μ: 3392, ~: 3392) -LibDecimalFloatImplementationEqTest:testEqXEAnyVsXEAny(int256,int256,int256) (runs: 5096, μ: 4718, ~: 4714) -LibDecimalFloatImplementationEqTest:testEqXEqY(int256,int256,int256,int256) (runs: 5096, μ: 732, ~: 753) -LibDecimalFloatImplementationEqTest:testEqXNotY(int256,int256,int256,int256) (runs: 5096, μ: 3928, ~: 3953) -LibDecimalFloatImplementationEqTest:testEqZero(int256,int256) (runs: 5096, μ: 3440, ~: 3440) +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) LibDecimalFloatImplementationInvTest:testInvGas0() (gas: 734) -LibDecimalFloatImplementationInvTest:testInvReference(int256,int256) (runs: 5096, μ: 12224, ~: 12163) +LibDecimalFloatImplementationInvTest:testInvReference(int256,int256) (runs: 5115, μ: 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: 5096, μ: 12951, ~: 12929) +LibDecimalFloatImplementationMinusTest:testMinusIsSubZero(int256,int256,int256) (runs: 5115, μ: 12950, ~: 12929) LibDecimalFloatImplementationMulTest:testMul123456789987654321() (gas: 3676) -LibDecimalFloatImplementationMulTest:testMul123456789987654321WithExponents(int128,int128) (runs: 5096, μ: 13186, ~: 13270) +LibDecimalFloatImplementationMulTest:testMul123456789987654321WithExponents(int128,int128) (runs: 5115, μ: 13186, ~: 13270) LibDecimalFloatImplementationMulTest:testMul1e181e19() (gas: 3720) LibDecimalFloatImplementationMulTest:testMulGasOne() (gas: 382) LibDecimalFloatImplementationMulTest:testMulGasZero() (gas: 324) -LibDecimalFloatImplementationMulTest:testMulNotRevertAnyExpectation(int256,int256,int256,int256) (runs: 5096, μ: 13394, ~: 12563) +LibDecimalFloatImplementationMulTest:testMulNotRevertAnyExpectation(int256,int256,int256,int256) (runs: 5115, μ: 13392, ~: 12563) LibDecimalFloatImplementationMulTest:testMulOneOne() (gas: 3721) LibDecimalFloatImplementationMulTest:testMulOneZero() (gas: 3663) LibDecimalFloatImplementationMulTest:testMulZero0Exponent() (gas: 3620) -LibDecimalFloatImplementationMulTest:testMulZeroAnyExponent(int64,int64) (runs: 5096, μ: 3908, ~: 3908) +LibDecimalFloatImplementationMulTest:testMulZeroAnyExponent(int64,int64) (runs: 5115, μ: 3908, ~: 3908) LibDecimalFloatImplementationMulTest:testMulZeroOne() (gas: 3642) LibDecimalFloatImplementationNormalizeTest:testExamples() (gas: 160899) -LibDecimalFloatImplementationNormalizeTest:testIdempotent(int256,int256) (runs: 5096, μ: 9875, ~: 9808) -LibDecimalFloatImplementationNormalizeTest:testIsNormalizedReference(int256,int256) (runs: 5096, μ: 3533, ~: 3539) -LibDecimalFloatImplementationNormalizeTest:testNormalized(int256,int256) (runs: 5096, μ: 9415, ~: 9348) +LibDecimalFloatImplementationNormalizeTest:testIdempotent(int256,int256) (runs: 5115, μ: 9875, ~: 9808) +LibDecimalFloatImplementationNormalizeTest:testIsNormalizedReference(int256,int256) (runs: 5115, μ: 3533, ~: 3539) +LibDecimalFloatImplementationNormalizeTest:testNormalized(int256,int256) (runs: 5115, μ: 9415, ~: 9348) LibDecimalFloatImplementationPow10Test:testExactLookups() (gas: 1281984) LibDecimalFloatImplementationPow10Test:testExactPows() (gas: 1260129) LibDecimalFloatImplementationPow10Test:testInterpolatedLookupsPower() (gas: 1277254) -LibDecimalFloatImplementationPow10Test:testNoRevert(int224,int32) (runs: 5096, μ: 1258252, ~: 1259171) -LibDecimalFloatImplementationSubTest:testSubIsAdd(int256,int256,int256,int256) (runs: 5096, μ: 16004, ~: 15967) -LibDecimalFloatImplementationSubTest:testSubMinSignedValue(int256,int256,int256) (runs: 5096, μ: 16216, ~: 16148) +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) LibDecimalFloatImplementationWithTargetExponentTest:testWithTargetExponentExamples() (gas: 13429) -LibDecimalFloatImplementationWithTargetExponentTest:testWithTargetExponentLargerExponentOverflowRescaleRevert(int256,int256,int256) (runs: 5096, μ: 14426, ~: 14395) -LibDecimalFloatImplementationWithTargetExponentTest:testWithTargetExponentLargerExponentVeryLargeDiffRevert(int256,int256,int256) (runs: 5096, μ: 13307, ~: 13527) -LibDecimalFloatImplementationWithTargetExponentTest:testWithTargetExponentLargerTargetExponentNoRevert(int256,int256,int256) (runs: 5096, μ: 11669, ~: 11718) -LibDecimalFloatImplementationWithTargetExponentTest:testWithTargetExponentSameExponentNoop(int256,int256) (runs: 5096, μ: 3676, ~: 3676) -LibDecimalFloatImplementationWithTargetExponentTest:testWithTargetExponentSmallerExponentNoRevert(int256,int256,int256) (runs: 5096, μ: 13874, ~: 13665) -LibDecimalFloatInvTest:testInvMem(bytes32) (runs: 5096, μ: 7321, ~: 7246) -LibDecimalFloatIsZeroTest:testIsZeroDeployed(bytes32) (runs: 5096, μ: 3899, ~: 3899) -LibDecimalFloatIsZeroTest:testIsZeroEqZero(bytes32) (runs: 5096, μ: 3527, ~: 3527) -LibDecimalFloatIsZeroTest:testIsZeroExamples(int32) (runs: 5096, μ: 4477, ~: 4477) -LibDecimalFloatIsZeroTest:testNotIsZero(int224,int32) (runs: 5096, μ: 3896, ~: 3896) -LibDecimalFloatLog10Test:testLog10Packed(bytes32) (runs: 5096, μ: 1645827, ~: 1263823) +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) 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: 5096, μ: 13750, ~: 13593) -LibDecimalFloatLtTest:testLtNegativeVsZero(int256,int32,int32) (runs: 5096, μ: 10790, ~: 11008) -LibDecimalFloatLtTest:testLtOneEAny(int224,int32) (runs: 5096, μ: 3905, ~: 3905) -LibDecimalFloatLtTest:testLtReference(bytes32,bytes32) (runs: 5096, μ: 4697, ~: 4998) -LibDecimalFloatLtTest:testLtVsEqualVsGt(bytes32,bytes32) (runs: 5096, μ: 4323, ~: 4210) -LibDecimalFloatLtTest:testLtX(int224) (runs: 5096, μ: 3798, ~: 3798) -LibDecimalFloatLtTest:testLtXEAnyVsXEAny(int256,int32,int32) (runs: 5096, μ: 10557, ~: 10297) -LibDecimalFloatLtTest:testLtXEAnyVsXEAnyNegative(int256,int32,int32) (runs: 5096, μ: 11153, ~: 11359) -LibDecimalFloatLtTest:testLtZero(int32,int32) (runs: 5096, μ: 4171, ~: 4171) +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) LibDecimalFloatLteTest:testLteGasAZero() (gas: 997) LibDecimalFloatLteTest:testLteGasBZero() (gas: 999) LibDecimalFloatLteTest:testLteGasBothZero() (gas: 753) LibDecimalFloatLteTest:testLteGasDifferentSigns() (gas: 976) LibDecimalFloatLteTest:testLteGasExponentDiffOverflow() (gas: 1082) -LibDecimalFloatLteTest:testLteOneEAny(bytes32) (runs: 5096, μ: 3493, ~: 3493) -LibDecimalFloatLteTest:testLteReference(int224,int32,int224,int32) (runs: 5096, μ: 8112, ~: 6341) -LibDecimalFloatLteTest:testLteX(int224,int32) (runs: 5096, μ: 3904, ~: 3904) -LibDecimalFloatLteTest:testLteXEAnyVsXEAny(int256,int32,int32) (runs: 5096, μ: 10582, ~: 10321) -LibDecimalFloatLteTest:testLteXEAnyVsXEAnyNegative(int256,int32,int32) (runs: 5096, μ: 11177, ~: 11383) -LibDecimalFloatLteTest:testLteXNotLtY(bytes32,bytes32) (runs: 5096, μ: 3882, ~: 3807) -LibDecimalFloatLteTest:testLteXPositiveYNegative(int256,int32,int256,int32) (runs: 5096, μ: 13103, ~: 12931) -LibDecimalFloatLteTest:testLteXPositiveYZero(int256,int32,int32) (runs: 5096, μ: 9575, ~: 9191) -LibDecimalFloatLteTest:testLteZero(int32,int32) (runs: 5096, μ: 4816, ~: 4816) -LibDecimalFloatMaxTest:testMaxX(bytes32) (runs: 5096, μ: 4246, ~: 4246) -LibDecimalFloatMaxTest:testMaxXY(bytes32,bytes32) (runs: 5096, μ: 4689, ~: 4613) -LibDecimalFloatMaxTest:testMaxXYEqual(bytes32) (runs: 5096, μ: 5272, ~: 5272) -LibDecimalFloatMaxTest:testMaxXYGreater(bytes32,bytes32) (runs: 5096, μ: 6129, ~: 6016) -LibDecimalFloatMaxTest:testMaxXYLess(bytes32,bytes32) (runs: 5096, μ: 6141, ~: 6027) -LibDecimalFloatMinTest:testMinX(bytes32) (runs: 5096, μ: 4268, ~: 4268) -LibDecimalFloatMinTest:testMinXY(bytes32,bytes32) (runs: 5096, μ: 4689, ~: 4613) -LibDecimalFloatMinTest:testMinXYEqual(bytes32) (runs: 5096, μ: 5292, ~: 5292) -LibDecimalFloatMinTest:testMinXYGreater(bytes32,bytes32) (runs: 5096, μ: 6074, ~: 5961) -LibDecimalFloatMinTest:testMinXYLess(bytes32,bytes32) (runs: 5096, μ: 6087, ~: 5972) -LibDecimalFloatMinusTest:testMinusPacked(bytes32) (runs: 5096, μ: 5550, ~: 5550) +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) LibDecimalFloatMixedTest:testDiv1Over3() (gas: 8161) -LibDecimalFloatMulTest:testMulPacked(bytes32,bytes32) (runs: 5096, μ: 7890, ~: 8837) -LibDecimalFloatPackTest:testPartsRoundTrip(int224,int32) (runs: 5096, μ: 5352, ~: 5352) -LibDecimalFloatPow10Test:testPow10Packed(bytes32) (runs: 5096, μ: 1644509, ~: 1257918) -LibDecimalFloatPowTest:testPows() (gas: 1296748) -LibDecimalFloatPowTest:testRoundTripFuzz(bytes32,bytes32) (runs: 5096, μ: 1256890, ~: 1253536) -LibDecimalFloatPowTest:testRoundTripSimple() (gas: 1450883) -LibDecimalFloatSubTest:testSubPacked(bytes32,bytes32) (runs: 5096, μ: 8614, ~: 8297) +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) +LibDecimalFloatPowTest:testPows() (gas: 1296960) +LibDecimalFloatPowTest:testRoundTripFuzz(bytes32,bytes32) (runs: 5115, μ: 1257280, ~: 1253651) +LibDecimalFloatPowTest:testRoundTripSimple() (gas: 1452863) +LibDecimalFloatSubTest:testSubPacked(bytes32,bytes32) (runs: 5115, μ: 8616, ~: 8297) LibFormatDecimalFloatTest:testFormatDecimalExamples() (gas: 133439) -LibFormatDecimalFloatTest:testFormatDecimalRoundTrip(uint256) (runs: 5096, μ: 25219, ~: 20105) -LibFormatDecimalFloatTest:testFormatDecimalRoundTripNegative(int256) (runs: 5096, μ: 19679, ~: 21006) +LibFormatDecimalFloatTest:testFormatDecimalRoundTrip(uint256) (runs: 5115, μ: 25204, ~: 20105) +LibFormatDecimalFloatTest:testFormatDecimalRoundTripNegative(int256) (runs: 5115, μ: 19670, ~: 21006) LibLogTableBytesTest:testToBytesAntiLogTableDec() (gas: 159794) LibLogTableBytesTest:testToBytesAntiLogTableDecSmall() (gas: 162322) LibLogTableBytesTest:testToBytesLogTableDec() (gas: 143165) @@ -257,7 +271,7 @@ LibParseDecimalFloatTest:testParseLiteralDecimalFloatEDot() (gas: 4190) LibParseDecimalFloatTest:testParseLiteralDecimalFloatExponentRevert5() (gas: 4176) LibParseDecimalFloatTest:testParseLiteralDecimalFloatExponentRevert6() (gas: 4188) LibParseDecimalFloatTest:testParseLiteralDecimalFloatExponents() (gas: 402635) -LibParseDecimalFloatTest:testParseLiteralDecimalFloatFuzz(uint256,uint8,bool) (runs: 5096, μ: 45910, ~: 37386) +LibParseDecimalFloatTest:testParseLiteralDecimalFloatFuzz(uint256,uint8,bool) (runs: 5115, μ: 45929, ~: 37394) LibParseDecimalFloatTest:testParseLiteralDecimalFloatLeadingZeros() (gas: 59779) LibParseDecimalFloatTest:testParseLiteralDecimalFloatNegativeE() (gas: 6100) LibParseDecimalFloatTest:testParseLiteralDecimalFloatNegativeFrac() (gas: 5137) @@ -265,5 +279,5 @@ LibParseDecimalFloatTest:testParseLiteralDecimalFloatPrecisionRevert0() (gas: 27 LibParseDecimalFloatTest:testParseLiteralDecimalFloatPrecisionRevert1() (gas: 24801) LibParseDecimalFloatTest:testParseLiteralDecimalFloatSpecific() (gas: 22959) LibParseDecimalFloatTest:testParseLiteralDecimalFloatUnrelated() (gas: 50856) -LibParseDecimalFloatTest:testParsePacked(string) (runs: 5096, μ: 9787, ~: 9668) -TestDecimalFloatUnpackTest:testUnpackDeployed(bytes32) (runs: 5096, μ: 158422, ~: 158422) \ No newline at end of file +LibParseDecimalFloatTest:testParsePacked(string) (runs: 5115, μ: 9786, ~: 9668) +TestDecimalFloatUnpackTest:testUnpackDeployed(bytes32) (runs: 5115, μ: 158422, ~: 158422) \ No newline at end of file diff --git a/src/concrete/DecimalFloat.sol b/src/concrete/DecimalFloat.sol index 7e617e72..48390300 100644 --- a/src/concrete/DecimalFloat.sol +++ b/src/concrete/DecimalFloat.sol @@ -9,13 +9,25 @@ contract DecimalFloat { using LibDecimalFloat for Float; /// Exposes `LibDecimalFloat.FLOAT_MAX_POSITIVE_VALUE` for offchain use. - /// @return The maximum value of a Float. + /// @return The maximum positive value of a Float. function maxPositiveValue() external pure returns (Float) { return LibDecimalFloat.FLOAT_MAX_POSITIVE_VALUE; } + /// Exposes `LibDecimalFloat.FLOAT_MIN_POSITIVE_VALUE` for offchain use. + /// @return The minimum positive value of a Float. + function minPositiveValue() external pure returns (Float) { + return LibDecimalFloat.FLOAT_MIN_POSITIVE_VALUE; + } + + /// Exposes `LibDecimalFloat.FLOAT_MAX_NEGATIVE_VALUE` for offchain use. + /// @return The maximum negative value of a Float. + function maxNegativeValue() external pure returns (Float) { + return LibDecimalFloat.FLOAT_MAX_NEGATIVE_VALUE; + } + /// Exposes `LibDecimalFloat.FLOAT_MIN_NEGATIVE_VALUE` for offchain use. - /// @return The minimum value of a Float. + /// @return The minimum negative value of a Float. function minNegativeValue() external pure returns (Float) { return LibDecimalFloat.FLOAT_MIN_NEGATIVE_VALUE; } diff --git a/src/lib/LibDecimalFloat.sol b/src/lib/LibDecimalFloat.sol index f0a7895e..795823ec 100644 --- a/src/lib/LibDecimalFloat.sol +++ b/src/lib/LibDecimalFloat.sol @@ -90,8 +90,10 @@ library LibDecimalFloat { address constant LOG_TABLES_ADDRESS = 0x295180b25A5059a2e7eC64272ba4F85047B4146A; + /// A zero valued float. Float constant FLOAT_ZERO = Float.wrap(0); + /// A one valued float. Float constant FLOAT_ONE = Float.wrap(bytes32(uint256(1))); /// Largest possible positive value. @@ -99,6 +101,18 @@ library LibDecimalFloat { Float constant FLOAT_MAX_POSITIVE_VALUE = Float.wrap(bytes32(uint256(0x7fffffff7fffffffffffffffffffffffffffffffffffffffffffffffffffffff))); + /// Smallest possible positive value. + /// 1, type(int32).min + Float constant FLOAT_MIN_POSITIVE_VALUE = + Float.wrap(bytes32(uint256(0x8000000000000000000000000000000000000000000000000000000000000001))); + + /// Largest possible (closest to zero) negative value. + /// -1, type(int32).min + // slither-disable-next-line too-many-digits + Float constant FLOAT_MAX_NEGATIVE_VALUE = + Float.wrap(bytes32(uint256(0x80000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff))); + + /// Smallest possible (most negative) negative value. /// type (int224).min, type(int32).max // slither-disable-next-line too-many-digits Float constant FLOAT_MIN_NEGATIVE_VALUE = diff --git a/test/src/concrete/DecimalFloat.constants.t.sol b/test/src/concrete/DecimalFloat.constants.t.sol index 29424fe1..363260ca 100644 --- a/test/src/concrete/DecimalFloat.constants.t.sol +++ b/test/src/concrete/DecimalFloat.constants.t.sol @@ -12,7 +12,7 @@ contract DecimalFloatConstantsTest is Test { return LibDecimalFloat.FLOAT_MAX_POSITIVE_VALUE; } - function testMaxValueDeployed() external { + function testMaxPositiveValueDeployed() external { DecimalFloat deployed = new DecimalFloat(); try this.maxPositiveValueExternal() returns (Float maxValue) { @@ -25,6 +25,40 @@ contract DecimalFloatConstantsTest is Test { } } + function minPositiveValueExternal() external pure returns (Float) { + return LibDecimalFloat.FLOAT_MIN_POSITIVE_VALUE; + } + + function testMinPositiveValueDeployed() external { + DecimalFloat deployed = new DecimalFloat(); + + try this.minPositiveValueExternal() returns (Float minValue) { + Float deployedMinPositiveValue = deployed.minPositiveValue(); + + assertEq(Float.unwrap(minValue), Float.unwrap(deployedMinPositiveValue)); + } catch (bytes memory err) { + vm.expectRevert(err); + deployed.minPositiveValue(); + } + } + + function maxNegativeValueExternal() external pure returns (Float) { + return LibDecimalFloat.FLOAT_MAX_NEGATIVE_VALUE; + } + + function testMaxNegativeValueDeployed() external { + DecimalFloat deployed = new DecimalFloat(); + + try this.maxNegativeValueExternal() returns (Float maxNegativeValue) { + Float deployedMaxNegativeValue = deployed.maxNegativeValue(); + + assertEq(Float.unwrap(maxNegativeValue), Float.unwrap(deployedMaxNegativeValue)); + } catch (bytes memory err) { + vm.expectRevert(err); + deployed.maxNegativeValue(); + } + } + function minNegativeValueExternal() external pure returns (Float) { return LibDecimalFloat.FLOAT_MIN_NEGATIVE_VALUE; } diff --git a/test/src/lib/LibDecimalFloat.constants.t.sol b/test/src/lib/LibDecimalFloat.constants.t.sol index 49981fff..5156a3b5 100644 --- a/test/src/lib/LibDecimalFloat.constants.t.sol +++ b/test/src/lib/LibDecimalFloat.constants.t.sol @@ -3,22 +3,60 @@ pragma solidity =0.8.25; import {LibDecimalFloat, Float} from "src/lib/LibDecimalFloat.sol"; import {Test} from "forge-std/Test.sol"; +import {console2} from "forge-std/console2.sol"; contract LibDecimalFloatConstantsTest is Test { using LibDecimalFloat for Float; - function testFloatMaxValue() external pure { + function testFloatMaxPositiveValue() external pure { Float maxValue = LibDecimalFloat.FLOAT_MAX_POSITIVE_VALUE; Float expected = LibDecimalFloat.packLossless(type(int224).max, type(int32).max); assertEq(Float.unwrap(maxValue), Float.unwrap(expected)); } - function testFloatMinValue() external pure { + function testFloatMaxPositiveValueIsMax(Float a) external pure { + assertTrue(a.lte(LibDecimalFloat.FLOAT_MAX_POSITIVE_VALUE)); + } + + function testFloatMinPositiveValue() external pure { + Float minValue = LibDecimalFloat.FLOAT_MIN_POSITIVE_VALUE; + Float expected = LibDecimalFloat.packLossless(1, type(int32).min); + assertEq(Float.unwrap(minValue), Float.unwrap(expected)); + } + + function testFloatMinPositiveValueIsMin(Float a) external pure { + vm.assume(!a.isZero()); + vm.assume(a.gt(LibDecimalFloat.FLOAT_MIN_NEGATIVE_VALUE)); + a = a.abs(); + + assertTrue(a.gte(LibDecimalFloat.FLOAT_MIN_POSITIVE_VALUE)); + } + + function testFloatMaxNegativeValue() external pure { + Float maxNegativeValue = LibDecimalFloat.FLOAT_MAX_NEGATIVE_VALUE; + Float expected = LibDecimalFloat.packLossless(-1, type(int32).min); + assertEq(Float.unwrap(maxNegativeValue), Float.unwrap(expected)); + } + + function testFloatMaxNegativeValueIsMax(Float a) external pure { + vm.assume(!a.isZero()); + if (a.gt(LibDecimalFloat.FLOAT_ZERO)) { + a = a.minus(); + } + + assertTrue(a.lte(LibDecimalFloat.FLOAT_MAX_NEGATIVE_VALUE)); + } + + function testFloatMinNegativeValue() external pure { Float minValue = LibDecimalFloat.FLOAT_MIN_NEGATIVE_VALUE; Float expected = LibDecimalFloat.packLossless(type(int224).min, type(int32).max); assertEq(Float.unwrap(minValue), Float.unwrap(expected)); } + function testFloatMinNegativeValueIsMin(Float a) external pure { + assertTrue(a.gte(LibDecimalFloat.FLOAT_MIN_NEGATIVE_VALUE)); + } + function testFloatE() external pure { Float e = LibDecimalFloat.FLOAT_E; Float expected = LibDecimalFloat.packLossless( From 06120912c055d647d7753436407a918469925a0a Mon Sep 17 00:00:00 2001 From: thedavidmeister Date: Wed, 30 Jul 2025 22:57:57 +0200 Subject: [PATCH 3/4] rm console --- test/src/lib/LibDecimalFloat.constants.t.sol | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/src/lib/LibDecimalFloat.constants.t.sol b/test/src/lib/LibDecimalFloat.constants.t.sol index 5156a3b5..f7768ff7 100644 --- a/test/src/lib/LibDecimalFloat.constants.t.sol +++ b/test/src/lib/LibDecimalFloat.constants.t.sol @@ -3,7 +3,6 @@ pragma solidity =0.8.25; import {LibDecimalFloat, Float} from "src/lib/LibDecimalFloat.sol"; import {Test} from "forge-std/Test.sol"; -import {console2} from "forge-std/console2.sol"; contract LibDecimalFloatConstantsTest is Test { using LibDecimalFloat for Float; @@ -26,6 +25,7 @@ contract LibDecimalFloatConstantsTest is Test { function testFloatMinPositiveValueIsMin(Float a) external pure { vm.assume(!a.isZero()); + // cant abs smallest negative value because of overflow. vm.assume(a.gt(LibDecimalFloat.FLOAT_MIN_NEGATIVE_VALUE)); a = a.abs(); From 8a7e199c53a4921d673dbf459122308e48fd04f4 Mon Sep 17 00:00:00 2001 From: thedavidmeister Date: Wed, 30 Jul 2025 23:09:56 +0200 Subject: [PATCH 4/4] lint --- src/lib/LibDecimalFloat.sol | 1 + 1 file changed, 1 insertion(+) diff --git a/src/lib/LibDecimalFloat.sol b/src/lib/LibDecimalFloat.sol index 795823ec..f9b9d8be 100644 --- a/src/lib/LibDecimalFloat.sol +++ b/src/lib/LibDecimalFloat.sol @@ -103,6 +103,7 @@ library LibDecimalFloat { /// Smallest possible positive value. /// 1, type(int32).min + // slither-disable-next-line too-many-digits Float constant FLOAT_MIN_POSITIVE_VALUE = Float.wrap(bytes32(uint256(0x8000000000000000000000000000000000000000000000000000000000000001)));