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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: counted-float
-Version: 0.9.7
+Version: 1.0.0
 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.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)
+![genbadge-test-count](https://bertpl.github.io/counted-float/version_artifacts/v1.0.0/badge-test-count.svg)
+![genbadge-test-coverage](https://bertpl.github.io/counted-float/version_artifacts/v1.0.0/badge-coverage.svg)
+![counted_float logo](https://bertpl.github.io/counted-float/version_artifacts/v1.0.0/splash.webp)
 <!--END_SECTION:images-->
 
 # counted-float
@@ -467,10 +467,38 @@ ALL                                                            0.47      0.70
  
 ```
 
-# 5. Known limitations
+## 4.2. Test performance of `CountedFloat` vs `float`
+
+```
+[~] counted_float benchmark-counted-float
+```
+See next section for results.
+
+# 5. Performance impact
+
+Obviously, using `CountedFloat` instead of regular `float` will have a performance impact due to the overhead of counting operations.
+It is not advised to use `CountedFloat` for production code, but just for research code for which you want to estimate the floating-point operation count.
+
+Micro-benchmarking of a bisection algorithm using `counted_float benchmark-counted-float` teaches us this:
+```
+------------------------------------------------------------------------------------------------------------------------
+Running CountedFloat benchmark...
+
+float                              : wwwwwwwwwwwwwww...................................   [  12.34 µs ±  1.2% | 50.1K cpu cycles ±  1.2% ]  /  execution
+CountedFloat                       : wwwwwwwwwwwwwww...................................   [ 459.95 µs ±  0.2% | 1.87M cpu cycles ±  0.2% ]  /  execution
+------------------------------------------------------------------------------------------------------------------------
+
+CountedFloat Benchmark Results:
+  Bisection using float        :   12.34 µs / execution
+  Bisection using CountedFloat :  459.95 µs / execution
+
+CountedFloat is 37.3x slower than float
+```
+
+# 6. Known limitations
 
 - currently any non-Python-built-in math operations are not counted (e.g. `numpy`)
-- not all Python built-in math operations are counted (e.g. `log`, `log10`, `exp`, `exp10`)
+- not all Python built-in math operations are counted (e.g. hyperbolic functions)
 - flop weights should be taken with a grain of salt and should only provide relative ballpark estimates w.r.t computational complexity.  Production implementations in a compiled language could have vastly differing performance depending on cpu cache sizes, branch prediction misses, compiler optimizations using vector operations (AVX etc...), etc...
  
 # Appendix A - Flop counting / analysis details

{counted_float-0.9.7 → counted_float-1.0.0}/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.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)
+![genbadge-test-count](https://bertpl.github.io/counted-float/version_artifacts/v1.0.0/badge-test-count.svg)
+![genbadge-test-coverage](https://bertpl.github.io/counted-float/version_artifacts/v1.0.0/badge-coverage.svg)
+![counted_float logo](https://bertpl.github.io/counted-float/version_artifacts/v1.0.0/splash.webp)
 <!--END_SECTION:images-->
 
 # counted-float
@@ -446,10 +446,38 @@ ALL                                                            0.47      0.70
  
 ```
 
-# 5. Known limitations
+## 4.2. Test performance of `CountedFloat` vs `float`
+
+```
+[~] counted_float benchmark-counted-float
+```
+See next section for results.
+
+# 5. Performance impact
+
+Obviously, using `CountedFloat` instead of regular `float` will have a performance impact due to the overhead of counting operations.
+It is not advised to use `CountedFloat` for production code, but just for research code for which you want to estimate the floating-point operation count.
+
+Micro-benchmarking of a bisection algorithm using `counted_float benchmark-counted-float` teaches us this:
+```
+------------------------------------------------------------------------------------------------------------------------
+Running CountedFloat benchmark...
+
+float                              : wwwwwwwwwwwwwww...................................   [  12.34 µs ±  1.2% | 50.1K cpu cycles ±  1.2% ]  /  execution
+CountedFloat                       : wwwwwwwwwwwwwww...................................   [ 459.95 µs ±  0.2% | 1.87M cpu cycles ±  0.2% ]  /  execution
+------------------------------------------------------------------------------------------------------------------------
+
+CountedFloat Benchmark Results:
+  Bisection using float        :   12.34 µs / execution
+  Bisection using CountedFloat :  459.95 µs / execution
+
+CountedFloat is 37.3x slower than float
+```
+
+# 6. Known limitations
 
 - currently any non-Python-built-in math operations are not counted (e.g. `numpy`)
-- not all Python built-in math operations are counted (e.g. `log`, `log10`, `exp`, `exp10`)
+- not all Python built-in math operations are counted (e.g. hyperbolic functions)
 - flop weights should be taken with a grain of salt and should only provide relative ballpark estimates w.r.t computational complexity.  Production implementations in a compiled language could have vastly differing performance depending on cpu cache sizes, branch prediction misses, compiler optimizations using vector operations (AVX etc...), etc...
  
 # Appendix A - Flop counting / analysis details

{counted_float-0.9.7 → counted_float-1.0.0}/counted_float/_core/_cli.py

@@ -1,7 +1,7 @@
 import click
 
 from counted_float import BuiltInData
-from counted_float.benchmarking import run_flops_benchmark
+from counted_float._core.benchmarking import run_counted_float_benchmark, run_flops_benchmark
 
 
 # -------------------------------------------------------------------------
@@ -22,3 +22,9 @@ def benchmark():
 @click.option("--key_filter", default="", help="Optional key filter for built-in data")
 def show_data(key_filter: str):
     BuiltInData.show(key_filter=key_filter)
+
+
+@cli.command(short_help="run benchmark of float vs CountedFloat performance")
+def benchmark_counted_float():
+    result = run_counted_float_benchmark()
+    result.show()

counted_float-1.0.0/counted_float/_core/benchmarking/__init__.py

@@ -0,0 +1,37 @@
+from .counted_float import BenchmarkCountedFloat, BenchmarkFloat, CountedFloatBenchmarkResults
+from .flops import FlopsBenchmarkResults, FlopsBenchmarkSuite
+
+
+def run_flops_benchmark(n_seconds_per_run_target: float = 0.1) -> FlopsBenchmarkResults:
+    """Run the flops benchmark suite with default settings returns a FlopsBenchmarkResults object."""
+
+    benchmark_results = FlopsBenchmarkSuite().run(n_seconds_per_run_target=n_seconds_per_run_target)
+
+    print()
+
+    return benchmark_results
+
+
+def run_counted_float_benchmark(t_target_sec: float = 0.1) -> CountedFloatBenchmarkResults:
+    """Run benchmark to compare performance of float vs CountedFloat."""
+    print("-" * 120)
+    print("Running CountedFloat benchmark...")
+    print()
+
+    result_float = BenchmarkFloat().run_many(
+        n_runs_total=50,
+        n_runs_warmup=15,
+        n_seconds_per_run_target=t_target_sec,
+    )
+    result_counted_float = BenchmarkCountedFloat().run_many(
+        n_runs_total=50,
+        n_runs_warmup=15,
+        n_seconds_per_run_target=t_target_sec,
+    )
+    print("-" * 120)
+    print()
+
+    return CountedFloatBenchmarkResults(
+        float_time_nsec=result_float.summary_stats_nsecs_per_exec().q50,
+        counted_float_time_nsec=result_counted_float.summary_stats_nsecs_per_exec().q50,
+    )

counted_float-1.0.0/counted_float/_core/benchmarking/counted_float/__init__.py

@@ -0,0 +1 @@
+from ._counted_float_benchmark import BenchmarkCountedFloat, BenchmarkFloat, CountedFloatBenchmarkResults

counted_float-1.0.0/counted_float/_core/benchmarking/counted_float/_counted_float_benchmark.py

@@ -0,0 +1,83 @@
+from counted_float._core.benchmarking.micro import MicroBenchmark
+from counted_float._core.counting import CountedFloat
+from counted_float._core.models import MyBaseModel
+from counted_float._core.utils import format_time_duration
+
+
+# =================================================================================================
+#  Result class
+# =================================================================================================
+class CountedFloatBenchmarkResults(MyBaseModel):
+    float_time_nsec: float
+    counted_float_time_nsec: float
+
+    def show(self):
+        print("CountedFloat Benchmark Results:")
+        print(f"  Bisection using float        : {format_time_duration(self.float_time_nsec)} / execution")
+        print(f"  Bisection using CountedFloat : {format_time_duration(self.counted_float_time_nsec)} / execution")
+        ratio = self.counted_float_time_nsec / self.float_time_nsec
+        print()
+        print(f"CountedFloat is {ratio:.1f}x slower than float")
+
+
+# =================================================================================================
+#  MicroBenchmarks
+# =================================================================================================
+def _zero_function(x: float) -> float:
+    # function for which we want to find a root
+    return (x * x * x) - 7.0
+
+
+class BenchmarkFloat(MicroBenchmark):
+    def __init__(self):
+        super().__init__(name="float")
+        self._n_executions = 1
+
+    def _prepare_benchmark(self, n_executions: int):
+        self._n_executions = n_executions
+
+    def _run_benchmark(self):
+        for _ in range(self._n_executions):
+            # Execute bisection to find root of _zero_function in interval [-1e50,1e50],
+            # using standard float() arithmetic
+            a = -1e50
+            b = 1e50
+            fa = _zero_function(a)
+            fb = _zero_function(b)
+            while b - a > 1e-15:
+                mid = 0.5 * (a + b)
+                fmid = _zero_function(mid)
+                if fmid < 0:
+                    a = mid
+                    fa = fmid
+                else:
+                    b = mid
+                    fb = fmid
+
+
+class BenchmarkCountedFloat(MicroBenchmark):
+    def __init__(self):
+        super().__init__(name="CountedFloat")
+        self._n_executions = 1
+
+    def _prepare_benchmark(self, n_executions: int):
+        self._n_executions = n_executions
+
+    def _run_benchmark(self):
+        for _ in range(self._n_executions):
+            # Execute bisection to find root of _zero_function in interval [-1e50,1e50],
+            # with identical implementation as BenchmarkFloat, except that we initialize a,b as CountedFloats,
+            # which will make sure all the remaining operations are also executed using CountedFloat arithmetic
+            a = CountedFloat(-1e50)
+            b = CountedFloat(1e50)
+            fa = _zero_function(a)
+            fb = _zero_function(b)
+            while b - a > 1e-15:
+                mid = 0.5 * (a + b)
+                fmid = _zero_function(mid)
+                if fmid < 0:
+                    a = mid
+                    fa = fmid
+                else:
+                    b = mid
+                    fb = fmid

{counted_float-0.9.7 → counted_float-1.0.0}/counted_float/_core/benchmarking/micro/_micro_benchmark.py

@@ -115,9 +115,9 @@ class MicroBenchmark(ABC):
           run by the MicroBenchmarkRunner class to ensure that the benchmark_runs runs for a reasonable amount of time
             (e.g. 1 second per run).
         """
-        raise NotImplementedError()
+        ...
 
     @abstractmethod
     def _run_benchmark(self):
         """Run benchmark_runs.  This method is called multiple times and the time spent here is measured."""
-        raise NotImplementedError()
+        ...

{counted_float-0.9.7 → counted_float-1.0.0}/counted_float/_core/utils/_missing_data.py

@@ -35,11 +35,7 @@ def impute_missing_data(data: np.ndarray) -> np.ndarray:
             ]
 
             # overall exact correction is geo_mean of these factors, which we'll apply with step e_step
-            try:
-                c_row_correct[i_row] = geo_mean(factors) ** e_step if factors else np.nan
-            except TypeError as e:
-                print(e)
-                pass
+            c_row_correct[i_row] = geo_mean(factors) ** e_step if factors else np.nan
 
         # compute correction factors for c_cols
         c_col_correct = np.zeros(n_cols)

{counted_float-0.9.7 → counted_float-1.0.0}/counted_float/benchmarking/__init__.py

@@ -1,6 +1,7 @@
-from counted_float._core.benchmarking import FlopsBenchmarkResults, run_flops_benchmark
+from counted_float._core.benchmarking import FlopsBenchmarkResults, run_counted_float_benchmark, run_flops_benchmark
 
 __all__ = [
     "FlopsBenchmarkResults",
+    "run_counted_float_benchmark",
     "run_flops_benchmark",
 ]

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

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

counted_float-0.9.7/counted_float/_core/benchmarking/__init__.py

@@ -1,11 +0,0 @@
-from .flops import FlopsBenchmarkResults, FlopsBenchmarkSuite
-
-
-def run_flops_benchmark() -> FlopsBenchmarkResults:
-    """Run the flops benchmark suite with default settings returns a FlopsBenchmarkResults object."""
-
-    benchmark_results = FlopsBenchmarkSuite().run()
-
-    print()
-
-    return benchmark_results