counted-float 0.9.6__tar.gz → 0.9.7__tar.gz

{counted_float-0.9.6 → counted_float-0.9.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: counted-float
-Version: 0.9.6
+Version: 0.9.7
 Summary: Count floating-point operations in Python code & benchmark relative flop costs.
 Project-URL: Source, https://github.com/bertpl/counted-float
 Project-URL: ChangeLog, https://github.com/bertpl/counted-float/blob/develop/CHANGELOG.md
@@ -21,9 +21,9 @@ Description-Content-Type: text/markdown
 
 <!--START_SECTION:images-->
 ![shields.io-python-versions](https://img.shields.io/badge/python-3.11%20%7C%203.12%20%7C%203.13-blue)
-![genbadge-test-count](https://bertpl.github.io/counted-float/version_artifacts/v0.9.6/badge-test-count.svg)
-![genbadge-test-coverage](https://bertpl.github.io/counted-float/version_artifacts/v0.9.6/badge-coverage.svg)
-![counted_float logo](https://bertpl.github.io/counted-float/version_artifacts/v0.9.6/splash.webp)
+![genbadge-test-count](https://bertpl.github.io/counted-float/version_artifacts/v0.9.7/badge-test-count.svg)
+![genbadge-test-coverage](https://bertpl.github.io/counted-float/version_artifacts/v0.9.7/badge-coverage.svg)
+![counted_float logo](https://bertpl.github.io/counted-float/version_artifacts/v0.9.7/splash.webp)
 <!--END_SECTION:images-->
 
 # counted-float
@@ -162,30 +162,33 @@ rationale behind choice of data sources and methodology.
 >>> get_active_flop_weights().show()
 
 {
-    FlopType.ABS        [abs(x)]        :    1
-    FlopType.MINUS      [-x]            :    1
-    FlopType.COMP       [x<=y]          :    1
-    FlopType.RND        [round]         :    2
-    FlopType.F2I        [float->int]    :    2
-    FlopType.I2F        [int->float]    :    2
-    FlopType.ADD        [x+y]           :    1
-    FlopType.SUB        [x-y]           :    1
-    FlopType.MUL        [x*y]           :    1
-    FlopType.DIV        [x/y]           :    5
-    FlopType.SQRT       [sqrt(x)]       :    6
-    FlopType.CBRT       [cbrt(x)]       :   42
-    FlopType.EXP        [e^x]           :   19
-    FlopType.EXP2       [2^x]           :   29
-    FlopType.EXP10      [10^x]          :   23
-    FlopType.LOG        [log(x)]        :   19
-    FlopType.LOG2       [log2(x)]       :   24
-    FlopType.LOG10      [log10(x)]      :   19
-    FlopType.POW        [x^y]           :   62
-    FlopType.SIN        [sin(x)]        :   32
-    FlopType.COS        [cos(x)]        :   31
-    FlopType.TAN        [tan(x)]        :   34
+    FlopType.MINUS      [-x]            :   0.45000
+    FlopType.ABS        [abs(x)]        :   0.70000
+    FlopType.ADD        [x+y]           :   1.00000
+    FlopType.COMP       [x<=y]          :   1.00000
+    FlopType.SUB        [x-y]           :   1.00000
+    FlopType.MUL        [x*y]           :   1.40000
+    FlopType.RND        [round]         :   1.80000
+    FlopType.F2I        [float->int]    :   2.00000
+    FlopType.I2F        [int->float]    :   2.00000
+    FlopType.DIV        [x/y]           :   5.50000
+    FlopType.SQRT       [sqrt(x)]       :   7.50000
+    FlopType.EXP2       [2^x]           :  16.00000
+    FlopType.EXP        [e^x]           :  18.00000
+    FlopType.LOG        [log(x)]        :  20.00000
+    FlopType.LOG2       [log2(x)]       :  22.00000
+    FlopType.EXP10      [10^x]          :  24.00000
+    FlopType.LOG10      [log10(x)]      :  24.00000
+    FlopType.COS        [cos(x)]        :  30.00000
+    FlopType.SIN        [sin(x)]        :  30.00000
+    FlopType.POW        [x^y]           :  40.00000
+    FlopType.TAN        [tan(x)]        :  40.00000
+    FlopType.CBRT       [cbrt(x)]       :  45.00000
 }
 ```
+Note that these weights are rounded up to the ~10% closest semi-round number, reflecting a balance between accuracy and readability,
+while conveying the message that these weights should be used as approximations only.  See further down for the different rounding modes.
+
 These weights will be used by default when extracting total weighted flop costs:
 
 ```python
@@ -202,7 +205,7 @@ with FlopCountingContext() as ctx:
     _ = math.log2(cf2)
     
 flop_counts = ctx.flop_counts()
-total_cost = flop_counts.total_weighted_cost()  # 1 + 62 + 24 = 87
+total_cost = flop_counts.total_weighted_cost()  # 1 + 40 + 22 = 63
 ```
 Note that the `total_weighted_cost` method will use the default flop weights as returned by `get_flop_weights()`.  This can be
 overridden by either configuring different flop weights (see next section) or by setting the `weights` argument of the `total_weighted_cost()` method.
@@ -229,33 +232,38 @@ Built-in flop weights can be inspected using the following functions:
 ```python
 from counted_float.config import get_default_consensus_flop_weights
 
->>> get_default_consensus_flop_weights(rounded=False).show()
+>>> get_default_consensus_flop_weights(rounding_mode=None).show()
 
 {
-    FlopType.ABS        [abs(x)]        :   0.63673
-    FlopType.MINUS      [-x]            :   0.64396
-    FlopType.COMP       [x<=y]          :   1.20756
-    FlopType.RND        [round]         :   1.54041
-    FlopType.F2I        [float->int]    :   1.99099
-    FlopType.I2F        [int->float]    :   1.84601
+    FlopType.MINUS      [-x]            :   0.46773
+    FlopType.ABS        [abs(x)]        :   0.70012
+    FlopType.COMP       [x<=y]          :   0.96923
+    FlopType.SUB        [x-y]           :   0.99846
     FlopType.ADD        [x+y]           :   1.00000
-    FlopType.SUB        [x-y]           :   1.00586
-    FlopType.MUL        [x*y]           :   1.37238
-    FlopType.DIV        [x/y]           :   5.07465
-    FlopType.SQRT       [sqrt(x)]       :   5.90559
-    FlopType.CBRT       [cbrt(x)]       :  42.39375
-    FlopType.EXP        [e^x]           :  18.58228
-    FlopType.EXP2       [2^x]           :  28.88672
-    FlopType.EXP10      [10^x]          :  22.86839
-    FlopType.LOG        [log(x)]        :  18.89135
-    FlopType.LOG2       [log2(x)]       :  24.34792
-    FlopType.LOG10      [log10(x)]      :  18.55085
-    FlopType.POW        [x^y]           :  61.79155
-    FlopType.SIN        [sin(x)]        :  31.91490
-    FlopType.COS        [cos(x)]        :  30.79295
-    FlopType.TAN        [tan(x)]        :  34.37970
+    FlopType.MUL        [x*y]           :   1.39950
+    FlopType.RND        [round]         :   1.77232
+    FlopType.F2I        [float->int]    :   1.91485
+    FlopType.I2F        [int->float]    :   1.92200
+    FlopType.DIV        [x/y]           :   5.53105
+    FlopType.SQRT       [sqrt(x)]       :   7.35657
+    FlopType.EXP2       [2^x]           :  15.85687
+    FlopType.EXP        [e^x]           :  17.51909
+    FlopType.LOG        [log(x)]        :  19.00419
+    FlopType.LOG2       [log2(x)]       :  22.38002
+    FlopType.EXP10      [10^x]          :  23.02693
+    FlopType.LOG10      [log10(x)]      :  24.65718
+    FlopType.SIN        [sin(x)]        :  30.40612
+    FlopType.COS        [cos(x)]        :  31.39434
+    FlopType.POW        [x^y]           :  41.81031
+    FlopType.TAN        [tan(x)]        :  42.15636
+    FlopType.CBRT       [cbrt(x)]       :  44.32376
 }
 ```
+There are 3 rounding modes:
+- `None` -> no rounding
+- `"nearest_int"` -> round up/down to nearest integer, with a minimum of 1
+- `"10%"` -> round to nearest semi-round number within ~10% (default)
+
 
 The default weights that are configured out-of-the-box in the package are the integer-rounded `consensus` weights.
 
@@ -270,28 +278,28 @@ from counted_float.config import get_builtin_flop_weights
 >>> get_builtin_flop_weights(key_filter="arm").show()
 
 {
-    FlopType.ABS        [abs(x)]        :   0.97313
-    FlopType.MINUS      [-x]            :   0.99098
-    FlopType.COMP       [x<=y]          :   1.03987
-    FlopType.RND        [round]         :   1.35111
-    FlopType.F2I        [float->int]    :   1.52648
-    FlopType.I2F        [int->float]    :   1.63320
+    FlopType.COMP       [x<=y]          :   0.65000
+    FlopType.MINUS      [-x]            :   0.90000
     FlopType.ADD        [x+y]           :   1.00000
-    FlopType.SUB        [x-y]           :   1.00058
-    FlopType.MUL        [x*y]           :   1.44952
-    FlopType.DIV        [x/y]           :   5.00897
-    FlopType.SQRT       [sqrt(x)]       :   5.15597
-    FlopType.CBRT       [cbrt(x)]       :  39.30448
-    FlopType.EXP        [e^x]           :  17.22817
-    FlopType.EXP2       [2^x]           :  15.82232
-    FlopType.EXP10      [10^x]          :  21.20195
-    FlopType.LOG        [log(x)]        :  17.51472
-    FlopType.LOG2       [log2(x)]       :  18.32529
-    FlopType.LOG10      [log10(x)]      :  17.19903
-    FlopType.POW        [x^y]           :  47.63289
-    FlopType.SIN        [sin(x)]        :  29.58923
-    FlopType.COS        [cos(x)]        :  28.54904
-    FlopType.TAN        [tan(x)]        :  31.87442
+    FlopType.SUB        [x-y]           :   1.00000
+    FlopType.ABS        [abs(x)]        :   1.10000
+    FlopType.F2I        [float->int]    :   1.50000
+    FlopType.MUL        [x*y]           :   1.50000
+    FlopType.I2F        [int->float]    :   1.60000
+    FlopType.RND        [round]         :   1.60000
+    FlopType.DIV        [x/y]           :   6.00000
+    FlopType.SQRT       [sqrt(x)]       :   7.50000
+    FlopType.EXP2       [2^x]           :  16.00000
+    FlopType.EXP        [e^x]           :  18.00000
+    FlopType.LOG        [log(x)]        :  20.00000
+    FlopType.LOG2       [log2(x)]       :  20.00000
+    FlopType.EXP10      [10^x]          :  24.00000
+    FlopType.LOG10      [log10(x)]      :  24.00000
+    FlopType.COS        [cos(x)]        :  33.00000
+    FlopType.SIN        [sin(x)]        :  33.00000
+    FlopType.POW        [x^y]           :  40.00000
+    FlopType.CBRT       [cbrt(x)]       :  45.00000
+    FlopType.TAN        [tan(x)]        :  45.00000
 }
 ```
 
@@ -335,29 +343,29 @@ div                                : wwwwwwwwwwwwwww.........................
 div_div                            : wwwwwwwwwwwwwww.........................   [   5.00 µs ±  0.2% | 20.3K cpu cycles ±  0.2% ]  /  1000 iterations
 lte_addsub                         : wwwwwwwwwwwwwww.........................   [   1.71 µs ±  0.2% | 6.94K cpu cycles ±  0.2% ]  /  1000 iterations
 
->>> results.flop_weights.show() 
+>>> results.flop_weights().show() 
 
 {
-    FlopType.ABS        [abs(x)]        :   0.90556
-    FlopType.MINUS      [-x]            :   0.90089
-    FlopType.COMP       [x<=y]          :   1.67297
-    FlopType.RND        [round]         :   1.24118
+    FlopType.ABS        [abs(x)]        :   0.89904
+    FlopType.MINUS      [-x]            :   0.90935
+    FlopType.SUB        [x-y]           :   0.99676
     FlopType.ADD        [x+y]           :   1.00000
-    FlopType.SUB        [x-y]           :   0.99928
-    FlopType.MUL        [x*y]           :   1.52656
-    FlopType.DIV        [x/y]           :   4.06589
-    FlopType.SQRT       [sqrt(x)]       :   5.26487
-    FlopType.CBRT       [cbrt(x)]       :  39.49190
-    FlopType.EXP        [e^x]           :  17.34508
-    FlopType.EXP2       [2^x]           :  16.70475
-    FlopType.EXP10      [10^x]          :  21.03351
-    FlopType.LOG        [log(x)]        :  17.59412
-    FlopType.LOG2       [log2(x)]       :  18.08932
-    FlopType.LOG10      [log10(x)]      :  17.27955
-    FlopType.POW        [x^y]           :  38.32044
-    FlopType.SIN        [sin(x)]        :  28.67006
-    FlopType.COS        [cos(x)]        :  29.11818
-    FlopType.TAN        [tan(x)]        :  32.28703
+    FlopType.RND        [round]         :   1.24397
+    FlopType.MUL        [x*y]           :   1.55516
+    FlopType.COMP       [x<=y]          :   1.69018
+    FlopType.DIV        [x/y]           :   4.12333
+    FlopType.SQRT       [sqrt(x)]       :   5.42419
+    FlopType.EXP2       [2^x]           :  16.95266
+    FlopType.LOG10      [log10(x)]      :  17.60079
+    FlopType.EXP        [e^x]           :  17.76250
+    FlopType.LOG        [log(x)]        :  17.86149
+    FlopType.LOG2       [log2(x)]       :  18.42380
+    FlopType.EXP10      [10^x]          :  21.50729
+    FlopType.SIN        [sin(x)]        :  29.31571
+    FlopType.COS        [cos(x)]        :  29.56218
+    FlopType.TAN        [tan(x)]        :  32.88570
+    FlopType.POW        [x^y]           :  39.35018
+    FlopType.CBRT       [cbrt(x)]       :  40.16857
     FlopType.F2I        [float->int]    :       nan
     FlopType.I2F        [int->float]    :       nan
 }

{counted_float-0.9.6 → counted_float-0.9.7}/README.md

@@ -1,8 +1,8 @@
 <!--START_SECTION:images-->
 ![shields.io-python-versions](https://img.shields.io/badge/python-3.11%20%7C%203.12%20%7C%203.13-blue)
-![genbadge-test-count](https://bertpl.github.io/counted-float/version_artifacts/v0.9.6/badge-test-count.svg)
-![genbadge-test-coverage](https://bertpl.github.io/counted-float/version_artifacts/v0.9.6/badge-coverage.svg)
-![counted_float logo](https://bertpl.github.io/counted-float/version_artifacts/v0.9.6/splash.webp)
+![genbadge-test-count](https://bertpl.github.io/counted-float/version_artifacts/v0.9.7/badge-test-count.svg)
+![genbadge-test-coverage](https://bertpl.github.io/counted-float/version_artifacts/v0.9.7/badge-coverage.svg)
+![counted_float logo](https://bertpl.github.io/counted-float/version_artifacts/v0.9.7/splash.webp)
 <!--END_SECTION:images-->
 
 # counted-float
@@ -141,30 +141,33 @@ rationale behind choice of data sources and methodology.
 >>> get_active_flop_weights().show()
 
 {
-    FlopType.ABS        [abs(x)]        :    1
-    FlopType.MINUS      [-x]            :    1
-    FlopType.COMP       [x<=y]          :    1
-    FlopType.RND        [round]         :    2
-    FlopType.F2I        [float->int]    :    2
-    FlopType.I2F        [int->float]    :    2
-    FlopType.ADD        [x+y]           :    1
-    FlopType.SUB        [x-y]           :    1
-    FlopType.MUL        [x*y]           :    1
-    FlopType.DIV        [x/y]           :    5
-    FlopType.SQRT       [sqrt(x)]       :    6
-    FlopType.CBRT       [cbrt(x)]       :   42
-    FlopType.EXP        [e^x]           :   19
-    FlopType.EXP2       [2^x]           :   29
-    FlopType.EXP10      [10^x]          :   23
-    FlopType.LOG        [log(x)]        :   19
-    FlopType.LOG2       [log2(x)]       :   24
-    FlopType.LOG10      [log10(x)]      :   19
-    FlopType.POW        [x^y]           :   62
-    FlopType.SIN        [sin(x)]        :   32
-    FlopType.COS        [cos(x)]        :   31
-    FlopType.TAN        [tan(x)]        :   34
+    FlopType.MINUS      [-x]            :   0.45000
+    FlopType.ABS        [abs(x)]        :   0.70000
+    FlopType.ADD        [x+y]           :   1.00000
+    FlopType.COMP       [x<=y]          :   1.00000
+    FlopType.SUB        [x-y]           :   1.00000
+    FlopType.MUL        [x*y]           :   1.40000
+    FlopType.RND        [round]         :   1.80000
+    FlopType.F2I        [float->int]    :   2.00000
+    FlopType.I2F        [int->float]    :   2.00000
+    FlopType.DIV        [x/y]           :   5.50000
+    FlopType.SQRT       [sqrt(x)]       :   7.50000
+    FlopType.EXP2       [2^x]           :  16.00000
+    FlopType.EXP        [e^x]           :  18.00000
+    FlopType.LOG        [log(x)]        :  20.00000
+    FlopType.LOG2       [log2(x)]       :  22.00000
+    FlopType.EXP10      [10^x]          :  24.00000
+    FlopType.LOG10      [log10(x)]      :  24.00000
+    FlopType.COS        [cos(x)]        :  30.00000
+    FlopType.SIN        [sin(x)]        :  30.00000
+    FlopType.POW        [x^y]           :  40.00000
+    FlopType.TAN        [tan(x)]        :  40.00000
+    FlopType.CBRT       [cbrt(x)]       :  45.00000
 }
 ```
+Note that these weights are rounded up to the ~10% closest semi-round number, reflecting a balance between accuracy and readability,
+while conveying the message that these weights should be used as approximations only.  See further down for the different rounding modes.
+
 These weights will be used by default when extracting total weighted flop costs:
 
 ```python
@@ -181,7 +184,7 @@ with FlopCountingContext() as ctx:
     _ = math.log2(cf2)
     
 flop_counts = ctx.flop_counts()
-total_cost = flop_counts.total_weighted_cost()  # 1 + 62 + 24 = 87
+total_cost = flop_counts.total_weighted_cost()  # 1 + 40 + 22 = 63
 ```
 Note that the `total_weighted_cost` method will use the default flop weights as returned by `get_flop_weights()`.  This can be
 overridden by either configuring different flop weights (see next section) or by setting the `weights` argument of the `total_weighted_cost()` method.
@@ -208,33 +211,38 @@ Built-in flop weights can be inspected using the following functions:
 ```python
 from counted_float.config import get_default_consensus_flop_weights
 
->>> get_default_consensus_flop_weights(rounded=False).show()
+>>> get_default_consensus_flop_weights(rounding_mode=None).show()
 
 {
-    FlopType.ABS        [abs(x)]        :   0.63673
-    FlopType.MINUS      [-x]            :   0.64396
-    FlopType.COMP       [x<=y]          :   1.20756
-    FlopType.RND        [round]         :   1.54041
-    FlopType.F2I        [float->int]    :   1.99099
-    FlopType.I2F        [int->float]    :   1.84601
+    FlopType.MINUS      [-x]            :   0.46773
+    FlopType.ABS        [abs(x)]        :   0.70012
+    FlopType.COMP       [x<=y]          :   0.96923
+    FlopType.SUB        [x-y]           :   0.99846
     FlopType.ADD        [x+y]           :   1.00000
-    FlopType.SUB        [x-y]           :   1.00586
-    FlopType.MUL        [x*y]           :   1.37238
-    FlopType.DIV        [x/y]           :   5.07465
-    FlopType.SQRT       [sqrt(x)]       :   5.90559
-    FlopType.CBRT       [cbrt(x)]       :  42.39375
-    FlopType.EXP        [e^x]           :  18.58228
-    FlopType.EXP2       [2^x]           :  28.88672
-    FlopType.EXP10      [10^x]          :  22.86839
-    FlopType.LOG        [log(x)]        :  18.89135
-    FlopType.LOG2       [log2(x)]       :  24.34792
-    FlopType.LOG10      [log10(x)]      :  18.55085
-    FlopType.POW        [x^y]           :  61.79155
-    FlopType.SIN        [sin(x)]        :  31.91490
-    FlopType.COS        [cos(x)]        :  30.79295
-    FlopType.TAN        [tan(x)]        :  34.37970
+    FlopType.MUL        [x*y]           :   1.39950
+    FlopType.RND        [round]         :   1.77232
+    FlopType.F2I        [float->int]    :   1.91485
+    FlopType.I2F        [int->float]    :   1.92200
+    FlopType.DIV        [x/y]           :   5.53105
+    FlopType.SQRT       [sqrt(x)]       :   7.35657
+    FlopType.EXP2       [2^x]           :  15.85687
+    FlopType.EXP        [e^x]           :  17.51909
+    FlopType.LOG        [log(x)]        :  19.00419
+    FlopType.LOG2       [log2(x)]       :  22.38002
+    FlopType.EXP10      [10^x]          :  23.02693
+    FlopType.LOG10      [log10(x)]      :  24.65718
+    FlopType.SIN        [sin(x)]        :  30.40612
+    FlopType.COS        [cos(x)]        :  31.39434
+    FlopType.POW        [x^y]           :  41.81031
+    FlopType.TAN        [tan(x)]        :  42.15636
+    FlopType.CBRT       [cbrt(x)]       :  44.32376
 }
 ```
+There are 3 rounding modes:
+- `None` -> no rounding
+- `"nearest_int"` -> round up/down to nearest integer, with a minimum of 1
+- `"10%"` -> round to nearest semi-round number within ~10% (default)
+
 
 The default weights that are configured out-of-the-box in the package are the integer-rounded `consensus` weights.
 
@@ -249,28 +257,28 @@ from counted_float.config import get_builtin_flop_weights
 >>> get_builtin_flop_weights(key_filter="arm").show()
 
 {
-    FlopType.ABS        [abs(x)]        :   0.97313
-    FlopType.MINUS      [-x]            :   0.99098
-    FlopType.COMP       [x<=y]          :   1.03987
-    FlopType.RND        [round]         :   1.35111
-    FlopType.F2I        [float->int]    :   1.52648
-    FlopType.I2F        [int->float]    :   1.63320
+    FlopType.COMP       [x<=y]          :   0.65000
+    FlopType.MINUS      [-x]            :   0.90000
     FlopType.ADD        [x+y]           :   1.00000
-    FlopType.SUB        [x-y]           :   1.00058
-    FlopType.MUL        [x*y]           :   1.44952
-    FlopType.DIV        [x/y]           :   5.00897
-    FlopType.SQRT       [sqrt(x)]       :   5.15597
-    FlopType.CBRT       [cbrt(x)]       :  39.30448
-    FlopType.EXP        [e^x]           :  17.22817
-    FlopType.EXP2       [2^x]           :  15.82232
-    FlopType.EXP10      [10^x]          :  21.20195
-    FlopType.LOG        [log(x)]        :  17.51472
-    FlopType.LOG2       [log2(x)]       :  18.32529
-    FlopType.LOG10      [log10(x)]      :  17.19903
-    FlopType.POW        [x^y]           :  47.63289
-    FlopType.SIN        [sin(x)]        :  29.58923
-    FlopType.COS        [cos(x)]        :  28.54904
-    FlopType.TAN        [tan(x)]        :  31.87442
+    FlopType.SUB        [x-y]           :   1.00000
+    FlopType.ABS        [abs(x)]        :   1.10000
+    FlopType.F2I        [float->int]    :   1.50000
+    FlopType.MUL        [x*y]           :   1.50000
+    FlopType.I2F        [int->float]    :   1.60000
+    FlopType.RND        [round]         :   1.60000
+    FlopType.DIV        [x/y]           :   6.00000
+    FlopType.SQRT       [sqrt(x)]       :   7.50000
+    FlopType.EXP2       [2^x]           :  16.00000
+    FlopType.EXP        [e^x]           :  18.00000
+    FlopType.LOG        [log(x)]        :  20.00000
+    FlopType.LOG2       [log2(x)]       :  20.00000
+    FlopType.EXP10      [10^x]          :  24.00000
+    FlopType.LOG10      [log10(x)]      :  24.00000
+    FlopType.COS        [cos(x)]        :  33.00000
+    FlopType.SIN        [sin(x)]        :  33.00000
+    FlopType.POW        [x^y]           :  40.00000
+    FlopType.CBRT       [cbrt(x)]       :  45.00000
+    FlopType.TAN        [tan(x)]        :  45.00000
 }
 ```
 
@@ -314,29 +322,29 @@ div                                : wwwwwwwwwwwwwww.........................
 div_div                            : wwwwwwwwwwwwwww.........................   [   5.00 µs ±  0.2% | 20.3K cpu cycles ±  0.2% ]  /  1000 iterations
 lte_addsub                         : wwwwwwwwwwwwwww.........................   [   1.71 µs ±  0.2% | 6.94K cpu cycles ±  0.2% ]  /  1000 iterations
 
->>> results.flop_weights.show() 
+>>> results.flop_weights().show() 
 
 {
-    FlopType.ABS        [abs(x)]        :   0.90556
-    FlopType.MINUS      [-x]            :   0.90089
-    FlopType.COMP       [x<=y]          :   1.67297
-    FlopType.RND        [round]         :   1.24118
+    FlopType.ABS        [abs(x)]        :   0.89904
+    FlopType.MINUS      [-x]            :   0.90935
+    FlopType.SUB        [x-y]           :   0.99676
     FlopType.ADD        [x+y]           :   1.00000
-    FlopType.SUB        [x-y]           :   0.99928
-    FlopType.MUL        [x*y]           :   1.52656
-    FlopType.DIV        [x/y]           :   4.06589
-    FlopType.SQRT       [sqrt(x)]       :   5.26487
-    FlopType.CBRT       [cbrt(x)]       :  39.49190
-    FlopType.EXP        [e^x]           :  17.34508
-    FlopType.EXP2       [2^x]           :  16.70475
-    FlopType.EXP10      [10^x]          :  21.03351
-    FlopType.LOG        [log(x)]        :  17.59412
-    FlopType.LOG2       [log2(x)]       :  18.08932
-    FlopType.LOG10      [log10(x)]      :  17.27955
-    FlopType.POW        [x^y]           :  38.32044
-    FlopType.SIN        [sin(x)]        :  28.67006
-    FlopType.COS        [cos(x)]        :  29.11818
-    FlopType.TAN        [tan(x)]        :  32.28703
+    FlopType.RND        [round]         :   1.24397
+    FlopType.MUL        [x*y]           :   1.55516
+    FlopType.COMP       [x<=y]          :   1.69018
+    FlopType.DIV        [x/y]           :   4.12333
+    FlopType.SQRT       [sqrt(x)]       :   5.42419
+    FlopType.EXP2       [2^x]           :  16.95266
+    FlopType.LOG10      [log10(x)]      :  17.60079
+    FlopType.EXP        [e^x]           :  17.76250
+    FlopType.LOG        [log(x)]        :  17.86149
+    FlopType.LOG2       [log2(x)]       :  18.42380
+    FlopType.EXP10      [10^x]          :  21.50729
+    FlopType.SIN        [sin(x)]        :  29.31571
+    FlopType.COS        [cos(x)]        :  29.56218
+    FlopType.TAN        [tan(x)]        :  32.88570
+    FlopType.POW        [x^y]           :  39.35018
+    FlopType.CBRT       [cbrt(x)]       :  40.16857
     FlopType.F2I        [float->int]    :       nan
     FlopType.I2F        [int->float]    :       nan
 }

{counted_float-0.9.6 → counted_float-0.9.7}/counted_float/_core/counting/_builtin_data.py

@@ -271,14 +271,19 @@ class FlopWeightsTreeView:
                     else:
                         line += f"{w:.2f}".rjust(col_width)
 
-                if not is_leaf:
-                    txt_clr = "bold white"
-                    h = hex(max(16, int(100 * (max_indent - indent) / max_indent)))[-2:]
-                    bg_clr = f"#{h}{h}{h}"
+                if is_leaf:
+                    # no special styling
+                    console.print(line, highlight=False)
                 else:
-                    txt_clr = "white"
-                    bg_clr = f"black"
-                console.print(line, style=f"{txt_clr} on {bg_clr}", highlight=False)
+                    # highlight as bold and with a colored background
+                    style_tag = [
+                        "[bold on #888888]",  # indent 0
+                        "[bold on #5555dd]",  # indent 1
+                        "[bold on #55dd55]",  # indent 2
+                        "[bold on #ee7777]",  # indent 3+
+                    ][min(indent, 3)]
+                    line = line[: 3 * indent] + style_tag + line[3 * indent :] + "[/]"
+                    console.print(line, highlight=False)
 
             print()
 

{counted_float-0.9.6 → counted_float-0.9.7}/counted_float/_core/counting/config/_defaults.py

@@ -1,31 +1,36 @@
 from functools import cache
+from typing import Literal
 
 from counted_float._core.counting._builtin_data import BuiltInData
 from counted_float._core.models import FlopWeights
 
 
 @cache
-def get_default_consensus_flop_weights(rounded: bool = True) -> FlopWeights:
+def get_default_consensus_flop_weights(rounding_mode: None | Literal["nearest_int", "10%"] = "10%") -> FlopWeights:
     """
     Get the default CONSENSUS flop weights.
     Computed as the geo-mean of the unrounded empirical and theoretical weights, rounded to the nearest integer.
     """
-    weights = BuiltInData.get_flop_weights(key_filter="")
-    if rounded:
-        return weights.round()
-    else:
-        return weights
+    return get_builtin_flop_weights(key_filter="", rounding_mode=rounding_mode)
 
 
 @cache
-def get_builtin_flop_weights(key_filter: str = "") -> FlopWeights:
+def get_builtin_flop_weights(
+    key_filter: str = "",
+    rounding_mode: None | Literal["nearest_int", "10%"] = "10%",
+) -> FlopWeights:
     """
     Get built-in flop weights estimated from built-in benchmark results and/or instruction latency analyses.
 
     :param key_filter: (str, default="") If non-empty, only include entries whose keys contain this substring.
                        E.g. "benchmarks" to only include benchmark results, or "x86" to only include
                        x86-related flop weights.
+    :param rounding_mode: (str, default="10%") rounding mode (None, "nearest_int", "10%").
     :return: A FlopWeights instance computed as the (hierarchical) geo-mean of all matching built-in data.
     :raises ValueError: If no built-in data matches the given key_filter.
     """
-    return BuiltInData.get_flop_weights(key_filter=key_filter)
+    weights = BuiltInData.get_flop_weights(key_filter=key_filter)
+    if rounding_mode is not None:
+        return weights.round(mode=rounding_mode)
+    else:
+        return weights

{counted_float-0.9.6 → counted_float-0.9.7}/counted_float/_core/models/_flop_weights.py

@@ -1,12 +1,12 @@
 from __future__ import annotations
 
 import math
-from typing import Iterable
+from typing import Iterable, Literal
 
 import numpy as np
 from pydantic import field_serializer, field_validator
 
-from counted_float._core.utils import geo_mean, impute_missing_data
+from counted_float._core.utils import geo_mean, impute_missing_data, round_number
 
 from ._base import MyBaseModel
 from ._flop_type import FlopType
@@ -18,11 +18,23 @@ class FlopWeights(MyBaseModel):
     # -------------------------------------------------------------------------
     #  Helpers
     # -------------------------------------------------------------------------
-    def round(self) -> FlopWeights:
-        """Round all weights to the nearest integer, with minimum of 1."""
-        return FlopWeights(
-            weights={k: math.nan if math.isnan(v) else max(1, round(v)) for k, v in self.weights.items()},
-        )
+    def round(self, mode: Literal["nearest_int", "10%"] = "10%") -> FlopWeights:
+        """
+        Round all weights according to specified mode:
+           - "10%" (default)   : round to nearest round number with ~10% accuracy and max. 2 significant non-0 digits
+                                      (e.g. 1.234 -> 1.2, 12.34 -> 12, 123.4 -> 120)
+           - "nearest_int"     : round to nearest int with minimum of 1
+        """
+        if mode == "nearest_int":
+            return FlopWeights(
+                weights={k: math.nan if math.isnan(v) else max(1, round(v)) for k, v in self.weights.items()},
+            )
+        else:
+            return FlopWeights(
+                weights={
+                    k: math.nan if math.isnan(v) else round_number(v, mode="10%") for k, v in self.weights.items()
+                },
+            )
 
     def has_missing_data(self) -> bool:
         """Check if any flop type has missing data (i.e. weight is NaN)."""
@@ -55,7 +67,7 @@ class FlopWeights(MyBaseModel):
     # -------------------------------------------------------------------------
     def show(self):
         print("{")
-        for k, v in self.weights.items():
+        for k, v in sorted(self.weights.items(), key=lambda kv: (kv[1], kv[0].long_name())):
             if isinstance(v, float):
                 print(f"    {k.long_name()}".ljust(40) + f": {v:9.5f}")
             else:

{counted_float-0.9.6 → counted_float-0.9.7}/counted_float/_core/utils/__init__.py

@@ -3,4 +3,5 @@ from ._formatting import format_latency, format_time_duration
 from ._geo_mean import geo_mean
 from ._latency import convert_nsecs_to_cycles
 from ._missing_data import impute_missing_data
+from ._rounding import round_number
 from ._timer import Timer

counted_float-0.9.7/counted_float/_core/utils/_rounding.py

@@ -0,0 +1,66 @@
+import math
+from typing import Literal
+
+# Values below are used in the "10%" rounding mode and are chosen such...
+#  - they span the range [1.0, 10.0] end-to-end
+#  - they have ±10% increments
+#  - deltas are monotonically increasing and are multiples of 0.1
+#  - all integers are included (2.0, 3.0, ..., 9.0)
+__ALLOWED_10PERC_ROUNDING_VALUES = [
+    1.0,
+    1.1,  # +0.1
+    1.2,  # +0.1
+    1.3,  # +0.1
+    1.4,  # +0.1
+    1.5,  # +0.1
+    1.6,  # +0.1
+    1.8,  # +0.2
+    2.0,  # +0.2
+    2.2,  # +0.2
+    2.4,  # +0.2
+    2.7,  # +0.3
+    3.0,  # +0.3
+    3.3,  # +0.3
+    3.6,  # +0.3
+    4.0,  # +0.4
+    4.5,  # +0.5
+    5.0,  # +0.5
+    5.5,  # +0.5
+    6.0,  # +0.5
+    6.5,  # +0.5
+    7.0,  # +0.5
+    7.5,  # +0.5
+    8.0,  # +0.5
+    9.0,  # +1.0
+    10.0,  # +1.0
+]
+
+
+def round_number(value: float, mode: None | Literal["nearest_int", "10%"]) -> float:
+    """
+    Round a floating point number according to the specified mode:
+        None            -> no rounding, value is returned as is
+        "nearest_int"   -> round to nearest integer
+        "10%"           -> round to nearest n*10^m with n in __ALLOWED_10PERC_ROUNDING_VALUES
+    """
+    match mode:
+        case "nearest_int":
+            return round(value, 0)
+        case "10%":
+            if value == 0:
+                return 0
+            elif value < 0:
+                return -round_number(-value, mode)
+            elif 1.0 <= value <= 10.0:
+                return _round_to_log_nearest(value, __ALLOWED_10PERC_ROUNDING_VALUES)
+            else:
+                scale = 10 ** math.floor(math.log10(value))
+                return scale * round_number(value / scale, mode)
+        case _:
+            return value
+
+
+def _round_to_log_nearest(value: float, candidate_value: list[float]) -> float:
+    """Return candidate_value that is log-closest to value, assuming all are >0."""
+    log_value = math.log(value)
+    return min(candidate_value, key=lambda cand: abs(math.log(cand) - log_value))

{counted_float-0.9.6 → counted_float-0.9.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "counted-float"
-version = "0.9.6"
+version = "0.9.7"
 description = "Count floating-point operations in Python code & benchmark relative flop costs."
 readme = "README.md"
 requires-python = ">=3.11"