pragmastat 3.1.23__tar.gz → 3.1.25__tar.gz

{pragmastat-3.1.23/pragmastat.egg-info → pragmastat-3.1.25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pragmastat
-Version: 3.1.23
+Version: 3.1.25
 Summary: Pragmastat: Pragmatic Statistical Toolkit
 Author: Andrey Akinshin
 License-Expression: MIT
@@ -18,15 +18,17 @@ Dynamic: license-file
 
 This is a Python implementation of 'Pragmastat: Pragmatic Statistical Toolkit', which presents a toolkit of statistical procedures that provide reliable results across diverse real-world distributions, with ready-to-use implementations and detailed explanations.
 
-- PDF manual for this version: https://pragmastat.dev/pragmastat-v3.1.23.pdf
-- Online manual for the latest version: https://pragmastat.dev
+- PDF manual for this version: [pragmastat-v3.1.25.pdf](https://github.com/AndreyAkinshin/pragmastat/releases/download/v3.1.25/pragmastat-v3.1.25.pdf)
+- Source code for this version: [pragmastat/python/v3.1.25](https://github.com/AndreyAkinshin/pragmastat/tree/v3.1.25/python)
+- Latest online manual: https://pragmastat.dev
 - Manual DOI: [10.5281/zenodo.17236778](https://doi.org/10.5281/zenodo.17236778)
-- Source code: https://github.com/AndreyAkinshin/pragmastat/tree/v3.1.23/python
 
 ## Installation
 
+Install from PyPI:
+
 ```bash
-pip install pragmastat
+pip install pragmastat==3.1.25
 ```
 
 ## Demo

{pragmastat-3.1.23 → pragmastat-3.1.25}/README.md

@@ -2,15 +2,17 @@
 
 This is a Python implementation of 'Pragmastat: Pragmatic Statistical Toolkit', which presents a toolkit of statistical procedures that provide reliable results across diverse real-world distributions, with ready-to-use implementations and detailed explanations.
 
-- PDF manual for this version: https://pragmastat.dev/pragmastat-v3.1.23.pdf
-- Online manual for the latest version: https://pragmastat.dev
+- PDF manual for this version: [pragmastat-v3.1.25.pdf](https://github.com/AndreyAkinshin/pragmastat/releases/download/v3.1.25/pragmastat-v3.1.25.pdf)
+- Source code for this version: [pragmastat/python/v3.1.25](https://github.com/AndreyAkinshin/pragmastat/tree/v3.1.25/python)
+- Latest online manual: https://pragmastat.dev
 - Manual DOI: [10.5281/zenodo.17236778](https://doi.org/10.5281/zenodo.17236778)
-- Source code: https://github.com/AndreyAkinshin/pragmastat/tree/v3.1.23/python
 
 ## Installation
 
+Install from PyPI:
+
 ```bash
-pip install pragmastat
+pip install pragmastat==3.1.25
 ```
 
 ## Demo

pragmastat-3.1.25/pragmastat/__init__.py

@@ -0,0 +1,13 @@
+from .estimators import center, spread, rel_spread, shift, ratio, avg_spread, disparity
+
+__all__ = [
+    "center",
+    "spread",
+    "rel_spread",
+    "shift",
+    "ratio",
+    "avg_spread",
+    "disparity",
+]
+
+__version__ = "3.1.24"

{pragmastat-3.1.23 → pragmastat-3.1.25}/pragmastat/estimators.py

@@ -32,7 +32,9 @@ def rel_spread(x: Union[Sequence[float], NDArray]) -> float:
     return spread(x) / abs(center_val)
 
 
-def shift(x: Union[Sequence[float], NDArray], y: Union[Sequence[float], NDArray]) -> float:
+def shift(
+    x: Union[Sequence[float], NDArray], y: Union[Sequence[float], NDArray]
+) -> float:
     x = np.asarray(x)
     y = np.asarray(y)
     if len(x) == 0 or len(y) == 0:
@@ -41,7 +43,9 @@ def shift(x: Union[Sequence[float], NDArray], y: Union[Sequence[float], NDArray]
     return float(np.median(pairwise_shifts))
 
 
-def ratio(x: Union[Sequence[float], NDArray], y: Union[Sequence[float], NDArray]) -> float:
+def ratio(
+    x: Union[Sequence[float], NDArray], y: Union[Sequence[float], NDArray]
+) -> float:
     x = np.asarray(x)
     y = np.asarray(y)
     if len(x) == 0 or len(y) == 0:
@@ -52,7 +56,9 @@ def ratio(x: Union[Sequence[float], NDArray], y: Union[Sequence[float], NDArray]
     return float(np.median(pairwise_ratios))
 
 
-def avg_spread(x: Union[Sequence[float], NDArray], y: Union[Sequence[float], NDArray]) -> float:
+def avg_spread(
+    x: Union[Sequence[float], NDArray], y: Union[Sequence[float], NDArray]
+) -> float:
     x = np.asarray(x)
     y = np.asarray(y)
     n = len(x)
@@ -64,8 +70,10 @@ def avg_spread(x: Union[Sequence[float], NDArray], y: Union[Sequence[float], NDA
     return (n * spread_x + m * spread_y) / (n + m)
 
 
-def disparity(x: Union[Sequence[float], NDArray], y: Union[Sequence[float], NDArray]) -> float:
+def disparity(
+    x: Union[Sequence[float], NDArray], y: Union[Sequence[float], NDArray]
+) -> float:
     avg_spread_val = avg_spread(x, y)
     if avg_spread_val == 0:
-        return float('inf')
-    return shift(x, y) / avg_spread_val
+        return float("inf")
+    return shift(x, y) / avg_spread_val

{pragmastat-3.1.23 → pragmastat-3.1.25}/pragmastat/fast_center.py

@@ -10,6 +10,7 @@ import numpy as np
 # Try to import the C implementation, fall back to pure Python if unavailable
 try:
     from . import _fast_center_c
+
     _HAS_C_EXTENSION = True
 except ImportError:
     _HAS_C_EXTENSION = False
@@ -64,7 +65,10 @@ def _fast_center_python(values: List[float]) -> float:
 
         for row in range(1, n + 1):  # 1-based
             # Move left from current column until we find sums < pivot
-            while current_column >= row and sorted_values[row - 1] + sorted_values[current_column - 1] >= pivot:
+            while (
+                current_column >= row
+                and sorted_values[row - 1] + sorted_values[current_column - 1] >= pivot
+            ):
                 current_column -= 1
 
             # Count elements in this row that are < pivot
@@ -75,8 +79,8 @@ def _fast_center_python(values: List[float]) -> float:
         # === CONVERGENCE CHECK ===
         if count_below_pivot == previous_count:
             # No progress - use midrange strategy
-            min_active_sum = float('inf')
-            max_active_sum = float('-inf')
+            min_active_sum = float("inf")
+            max_active_sum = float("-inf")
 
             for i in range(n):
                 if left_bounds[i] > right_bounds[i]:
@@ -99,13 +103,15 @@ def _fast_center_python(values: List[float]) -> float:
             continue
 
         # === TARGET CHECK ===
-        at_target_rank = (count_below_pivot == median_rank_low or
-                         count_below_pivot == median_rank_high - 1)
+        at_target_rank = (
+            count_below_pivot == median_rank_low
+            or count_below_pivot == median_rank_high - 1
+        )
 
         if at_target_rank:
             # Find boundary values
-            largest_below_pivot = float('-inf')
-            smallest_at_or_above_pivot = float('inf')
+            largest_below_pivot = float("-inf")
+            smallest_at_or_above_pivot = float("inf")
 
             for i in range(n):
                 count_in_row = partition_counts[i]
@@ -121,8 +127,12 @@ def _fast_center_python(values: List[float]) -> float:
                 # Find smallest sum in this row that's >= pivot
                 if count_in_row < total_in_row:
                     first_at_or_above_index = i + count_in_row + 1
-                    first_at_or_above_value = row_value + sorted_values[first_at_or_above_index - 1]
-                    smallest_at_or_above_pivot = min(smallest_at_or_above_pivot, first_at_or_above_value)
+                    first_at_or_above_value = (
+                        row_value + sorted_values[first_at_or_above_index - 1]
+                    )
+                    smallest_at_or_above_pivot = min(
+                        smallest_at_or_above_pivot, first_at_or_above_value
+                    )
 
             # Calculate final result
             if median_rank_low < median_rank_high:
@@ -130,8 +140,10 @@ def _fast_center_python(values: List[float]) -> float:
                 return (smallest_at_or_above_pivot + largest_below_pivot) / 4
             else:
                 # Odd total: return the single middle value
-                need_largest = (count_below_pivot == median_rank_low)
-                return (largest_below_pivot if need_largest else smallest_at_or_above_pivot) / 2
+                need_largest = count_below_pivot == median_rank_low
+                return (
+                    largest_below_pivot if need_largest else smallest_at_or_above_pivot
+                ) / 2
 
         # === UPDATE BOUNDS ===
         if count_below_pivot < median_rank_low:
@@ -147,7 +159,9 @@ def _fast_center_python(values: List[float]) -> float:
         previous_count = count_below_pivot
 
         # Recalculate active set size
-        active_set_size = sum(max(0, right_bounds[i] - left_bounds[i] + 1) for i in range(n))
+        active_set_size = sum(
+            max(0, right_bounds[i] - left_bounds[i] + 1) for i in range(n)
+        )
 
         # Choose next pivot
         if active_set_size > 2:
@@ -164,12 +178,16 @@ def _fast_center_python(values: List[float]) -> float:
                 cumulative_size += row_size
 
             # Use median element of the selected row as pivot
-            median_column_in_row = (left_bounds[selected_row] + right_bounds[selected_row]) // 2
-            pivot = sorted_values[selected_row] + sorted_values[median_column_in_row - 1]
+            median_column_in_row = (
+                left_bounds[selected_row] + right_bounds[selected_row]
+            ) // 2
+            pivot = (
+                sorted_values[selected_row] + sorted_values[median_column_in_row - 1]
+            )
         else:
             # Few elements remain - use midrange strategy
-            min_remaining_sum = float('inf')
-            max_remaining_sum = float('-inf')
+            min_remaining_sum = float("inf")
+            max_remaining_sum = float("-inf")
 
             for i in range(n):
                 if left_bounds[i] > right_bounds[i]:

{pragmastat-3.1.23 → pragmastat-3.1.25}/pragmastat/fast_spread.py

@@ -10,6 +10,7 @@ import numpy as np
 # Try to import the C implementation, fall back to pure Python if unavailable
 try:
     from . import _fast_spread_c
+
     _HAS_C_EXTENSION = True
 except ImportError:
     _HAS_C_EXTENSION = False
@@ -63,8 +64,8 @@ def _fast_spread_python(values: List[float]) -> float:
     while True:
         # === PARTITION: count how many differences are < pivot ===
         count_below = 0
-        largest_below = float('-inf')
-        smallest_at_or_above = float('inf')
+        largest_below = float("-inf")
+        smallest_at_or_above = float("inf")
 
         j = 1  # global two-pointer (non-decreasing across rows)
         for i in range(n - 1):
@@ -95,14 +96,14 @@ def _fast_spread_python(values: List[float]) -> float:
                 return 0.5 * (largest_below + smallest_at_or_above)
             else:
                 # Odd N: pick the single middle
-                need_largest = (count_below == k_low)
+                need_largest = count_below == k_low
                 return largest_below if need_largest else smallest_at_or_above
 
         # === STALL HANDLING ===
         if count_below == prev_count_below:
             # Compute min/max remaining difference in the ACTIVE set
-            min_active = float('inf')
-            max_active = float('-inf')
+            min_active = float("inf")
+            max_active = float("-inf")
             active = 0
 
             for i in range(n - 1):
@@ -114,7 +115,7 @@ def _fast_spread_python(values: List[float]) -> float:
                 row_max = a[Ri] - a[i]
                 min_active = min(min_active, row_min)
                 max_active = max(max_active, row_max)
-                active += (Ri - Li + 1)
+                active += Ri - Li + 1
 
             if active <= 0:
                 if k_low < k_high:
@@ -156,8 +157,8 @@ def _fast_spread_python(values: List[float]) -> float:
 
         if active_size <= 2:
             # Few candidates left: return midrange of remaining
-            min_rem = float('inf')
-            max_rem = float('-inf')
+            min_rem = float("inf")
+            max_rem = float("-inf")
             for i in range(n - 1):
                 if L[i] > R[i]:
                     continue
@@ -173,7 +174,11 @@ def _fast_spread_python(values: List[float]) -> float:
 
             if k_low < k_high:
                 return 0.5 * (min_rem + max_rem)
-            return min_rem if abs((k_low - 1) - count_below) <= abs(count_below - k_low) else max_rem
+            return (
+                min_rem
+                if abs((k_low - 1) - count_below) <= abs(count_below - k_low)
+                else max_rem
+            )
         else:
             # Weighted random row selection
             t = random.randint(0, active_size - 1)

{pragmastat-3.1.23 → pragmastat-3.1.25/pragmastat.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pragmastat
-Version: 3.1.23
+Version: 3.1.25
 Summary: Pragmastat: Pragmatic Statistical Toolkit
 Author: Andrey Akinshin
 License-Expression: MIT
@@ -18,15 +18,17 @@ Dynamic: license-file
 
 This is a Python implementation of 'Pragmastat: Pragmatic Statistical Toolkit', which presents a toolkit of statistical procedures that provide reliable results across diverse real-world distributions, with ready-to-use implementations and detailed explanations.
 
-- PDF manual for this version: https://pragmastat.dev/pragmastat-v3.1.23.pdf
-- Online manual for the latest version: https://pragmastat.dev
+- PDF manual for this version: [pragmastat-v3.1.25.pdf](https://github.com/AndreyAkinshin/pragmastat/releases/download/v3.1.25/pragmastat-v3.1.25.pdf)
+- Source code for this version: [pragmastat/python/v3.1.25](https://github.com/AndreyAkinshin/pragmastat/tree/v3.1.25/python)
+- Latest online manual: https://pragmastat.dev
 - Manual DOI: [10.5281/zenodo.17236778](https://doi.org/10.5281/zenodo.17236778)
-- Source code: https://github.com/AndreyAkinshin/pragmastat/tree/v3.1.23/python
 
 ## Installation
 
+Install from PyPI:
+
 ```bash
-pip install pragmastat
+pip install pragmastat==3.1.25
 ```
 
 ## Demo

{pragmastat-3.1.23 → pragmastat-3.1.25}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pragmastat"
-version = "3.1.23"
+version = "3.1.25"
 description = "Pragmastat: Pragmatic Statistical Toolkit"
 readme = "README.md"
 requires-python = ">=3.8"

pragmastat-3.1.25/setup.py

@@ -0,0 +1,23 @@
+from setuptools import setup, Extension
+import numpy
+
+# Define the C extensions
+extensions = [
+    Extension(
+        "pragmastat._fast_center_c",
+        sources=["src/fast_center_c.c"],
+        include_dirs=[numpy.get_include()],
+        extra_compile_args=["-O3", "-Wall"],
+    ),
+    Extension(
+        "pragmastat._fast_spread_c",
+        sources=["src/fast_spread_c.c"],
+        include_dirs=[numpy.get_include()],
+        extra_compile_args=["-O3", "-Wall"],
+    ),
+]
+
+setup(
+    ext_modules=extensions,
+    package_dir={"": "."},
+)

pragmastat-3.1.25/tests/test_invariance.py

@@ -0,0 +1,111 @@
+import numpy as np
+from pragmastat import center, spread, rel_spread, shift, ratio, avg_spread, disparity
+
+
+class TestInvariance:
+    seed = 1729
+    sample_sizes = [2, 3, 4, 5, 6, 7, 8, 9, 10]
+    tolerance = 1e-9
+
+    def perform_test_one(self, expr1_func, expr2_func):
+        np.random.seed(self.seed)
+        for n in self.sample_sizes:
+            x = np.random.uniform(0, 1, n)
+            result1 = expr1_func(x)
+            result2 = expr2_func(x)
+            assert (
+                abs(result1 - result2) < self.tolerance
+            ), f"Failed for n={n}: {result1} != {result2}"
+
+    def perform_test_two(self, expr1_func, expr2_func):
+        np.random.seed(self.seed)
+        for n in self.sample_sizes:
+            x = np.random.uniform(0, 1, n)
+            y = np.random.uniform(0, 1, n)
+            result1 = expr1_func(x, y)
+            result2 = expr2_func(x, y)
+            assert (
+                abs(result1 - result2) < self.tolerance
+            ), f"Failed for n={n}: {result1} != {result2}"
+
+    # Center tests
+    def test_center_shift(self):
+        self.perform_test_one(lambda x: center(x + 2), lambda x: center(x) + 2)
+
+    def test_center_scale(self):
+        self.perform_test_one(lambda x: center(2 * x), lambda x: 2 * center(x))
+
+    def test_center_negate(self):
+        self.perform_test_one(lambda x: center(-1 * x), lambda x: -1 * center(x))
+
+    # Spread tests
+    def test_spread_shift(self):
+        self.perform_test_one(lambda x: spread(x + 2), lambda x: spread(x))
+
+    def test_spread_scale(self):
+        self.perform_test_one(lambda x: spread(2 * x), lambda x: 2 * spread(x))
+
+    def test_spread_negate(self):
+        self.perform_test_one(lambda x: spread(-1 * x), lambda x: spread(x))
+
+    # RelSpread tests
+    def test_rel_spread_scale(self):
+        self.perform_test_one(lambda x: rel_spread(2 * x), lambda x: rel_spread(x))
+
+    # Shift tests
+    def test_shift_shift(self):
+        self.perform_test_two(
+            lambda x, y: shift(x + 3, y + 2), lambda x, y: shift(x, y) + 1
+        )
+
+    def test_shift_scale(self):
+        self.perform_test_two(
+            lambda x, y: shift(2 * x, 2 * y), lambda x, y: 2 * shift(x, y)
+        )
+
+    def test_shift_antisymmetry(self):
+        self.perform_test_two(lambda x, y: shift(x, y), lambda x, y: -1 * shift(y, x))
+
+    # Ratio tests
+    def test_ratio_scale(self):
+        self.perform_test_two(
+            lambda x, y: ratio(2 * x, 3 * y), lambda x, y: (2.0 / 3) * ratio(x, y)
+        )
+
+    # AvgSpread tests
+    def test_avg_spread_equal(self):
+        self.perform_test_one(lambda x: avg_spread(x, x), lambda x: spread(x))
+
+    def test_avg_spread_symmetry(self):
+        self.perform_test_two(
+            lambda x, y: avg_spread(x, y), lambda x, y: avg_spread(y, x)
+        )
+
+    def test_avg_spread_average(self):
+        self.perform_test_one(lambda x: avg_spread(x, 5 * x), lambda x: 3 * spread(x))
+
+    def test_avg_spread_scale(self):
+        self.perform_test_two(
+            lambda x, y: avg_spread(-2 * x, -2 * y), lambda x, y: 2 * avg_spread(x, y)
+        )
+
+    # Disparity tests
+    def test_disparity_shift(self):
+        self.perform_test_two(
+            lambda x, y: disparity(x + 2, y + 2), lambda x, y: disparity(x, y)
+        )
+
+    def test_disparity_scale(self):
+        self.perform_test_two(
+            lambda x, y: disparity(2 * x, 2 * y), lambda x, y: disparity(x, y)
+        )
+
+    def test_disparity_scale_neg(self):
+        self.perform_test_two(
+            lambda x, y: disparity(-2 * x, -2 * y), lambda x, y: -1 * disparity(x, y)
+        )
+
+    def test_disparity_antisymmetry(self):
+        self.perform_test_two(
+            lambda x, y: disparity(x, y), lambda x, y: -1 * disparity(y, x)
+        )

{pragmastat-3.1.23 → pragmastat-3.1.25}/tests/test_performance.py

@@ -2,7 +2,6 @@
 
 import time
 import numpy as np
-from pragmastat.estimators import center, spread
 from pragmastat.fast_center import _fast_center
 from pragmastat.fast_spread import _fast_spread
 
@@ -37,7 +36,9 @@ def test_center_correctness():
             x = np.random.randn(n).tolist()
             expected = center_simple(x)
             actual = _fast_center(x)
-            assert abs(expected - actual) < 1e-9, f"Mismatch for n={n}: expected={expected}, actual={actual}"
+            assert (
+                abs(expected - actual) < 1e-9
+            ), f"Mismatch for n={n}: expected={expected}, actual={actual}"
 
 
 def test_spread_correctness():
@@ -48,7 +49,9 @@ def test_spread_correctness():
             x = np.random.randn(n).tolist()
             expected = spread_simple(x)
             actual = _fast_spread(x)
-            assert abs(expected - actual) < 1e-9, f"Mismatch for n={n}: expected={expected}, actual={actual}"
+            assert (
+                abs(expected - actual) < 1e-9
+            ), f"Mismatch for n={n}: expected={expected}, actual={actual}"
 
 
 def test_center_performance():

{pragmastat-3.1.23 → pragmastat-3.1.25}/tests/test_reference.py

@@ -1,49 +1,45 @@
 import json
-import os
-import pytest
 from pathlib import Path
-from pragmastat import (
-    center, spread, rel_spread,
-    shift, ratio, avg_spread, disparity
-)
+from pragmastat import center, spread, rel_spread, shift, ratio, avg_spread, disparity
 
 
 def find_repo_root():
-    """Find the repository root by looking for build.cmd file."""
+    """Find the repository root by looking for CITATION.cff file."""
     current_dir = Path(__file__).parent
     while current_dir != current_dir.parent:
-        if (current_dir / "build.cmd").exists():
+        if (current_dir / "CITATION.cff").exists():
             return current_dir
         current_dir = current_dir.parent
-    raise RuntimeError("Could not find repository root (build.cmd not found)")
+    raise RuntimeError("Could not find repository root (CITATION.cff not found)")
 
 
 def run_reference_tests(estimator_name, estimator_func, is_two_sample=False):
     """Run reference tests against JSON data files."""
     repo_root = find_repo_root()
     test_data_dir = repo_root / "tests" / estimator_name
-    
+
     json_files = list(test_data_dir.glob("*.json"))
     assert len(json_files) > 0, f"No JSON test files found in {test_data_dir}"
-    
+
     for json_file in json_files:
-        with open(json_file, 'r') as f:
+        with open(json_file, "r") as f:
             test_case = json.load(f)
-        
+
         if is_two_sample:
             input_x = test_case["input"]["x"]
             input_y = test_case["input"]["y"]
             expected_output = test_case["output"]
-            
+
             actual_output = estimator_func(input_x, input_y)
         else:
             input_x = test_case["input"]["x"]
             expected_output = test_case["output"]
-            
+
             actual_output = estimator_func(input_x)
-        
-        assert abs(actual_output - expected_output) < 1e-10, \
-            f"Failed for test file: {json_file.name}, expected: {expected_output}, got: {actual_output}"
+
+        assert (
+            abs(actual_output - expected_output) < 1e-10
+        ), f"Failed for test file: {json_file.name}, expected: {expected_output}, got: {actual_output}"
 
 
 class TestReference:
@@ -67,4 +63,4 @@ class TestReference:
         run_reference_tests("avg-spread", avg_spread, is_two_sample=True)
 
     def test_disparity_reference(self):
-        run_reference_tests("disparity", disparity, is_two_sample=True)
+        run_reference_tests("disparity", disparity, is_two_sample=True)

pragmastat-3.1.23/pragmastat/__init__.py

@@ -1,21 +0,0 @@
-from .estimators import (
-    center,
-    spread,
-    rel_spread,
-    shift,
-    ratio,
-    avg_spread,
-    disparity
-)
-
-__all__ = [
-    'center',
-    'spread',
-    'rel_spread',
-    'shift',
-    'ratio',
-    'avg_spread',
-    'disparity'
-]
-
-__version__ = '3.1.23'

pragmastat-3.1.23/setup.py

@@ -1,24 +0,0 @@
-from setuptools import setup, Extension
-import numpy
-import os
-
-# Define the C extensions
-extensions = [
-    Extension(
-        'pragmastat._fast_center_c',
-        sources=['src/fast_center_c.c'],
-        include_dirs=[numpy.get_include()],
-        extra_compile_args=['-O3', '-Wall'],
-    ),
-    Extension(
-        'pragmastat._fast_spread_c',
-        sources=['src/fast_spread_c.c'],
-        include_dirs=[numpy.get_include()],
-        extra_compile_args=['-O3', '-Wall'],
-    ),
-]
-
-setup(
-    ext_modules=extensions,
-    package_dir={'': '.'},
-)

pragmastat-3.1.23/tests/test_invariance.py

@@ -1,152 +0,0 @@
-import numpy as np
-import pytest
-from pragmastat import (
-    center, spread, rel_spread,
-    shift, ratio, avg_spread, disparity
-)
-
-
-class TestInvariance:
-    seed = 1729
-    sample_sizes = [2, 3, 4, 5, 6, 7, 8, 9, 10]
-    tolerance = 1e-9
-    
-    def perform_test_one(self, expr1_func, expr2_func):
-        np.random.seed(self.seed)
-        for n in self.sample_sizes:
-            x = np.random.uniform(0, 1, n)
-            result1 = expr1_func(x)
-            result2 = expr2_func(x)
-            assert abs(result1 - result2) < self.tolerance, \
-                f"Failed for n={n}: {result1} != {result2}"
-    
-    def perform_test_two(self, expr1_func, expr2_func):
-        np.random.seed(self.seed)
-        for n in self.sample_sizes:
-            x = np.random.uniform(0, 1, n)
-            y = np.random.uniform(0, 1, n)
-            result1 = expr1_func(x, y)
-            result2 = expr2_func(x, y)
-            assert abs(result1 - result2) < self.tolerance, \
-                f"Failed for n={n}: {result1} != {result2}"
-    
-    # Center tests
-    def test_center_shift(self):
-        self.perform_test_one(
-            lambda x: center(x + 2),
-            lambda x: center(x) + 2
-        )
-    
-    def test_center_scale(self):
-        self.perform_test_one(
-            lambda x: center(2 * x),
-            lambda x: 2 * center(x)
-        )
-    
-    def test_center_negate(self):
-        self.perform_test_one(
-            lambda x: center(-1 * x),
-            lambda x: -1 * center(x)
-        )
-    
-    # Spread tests
-    def test_spread_shift(self):
-        self.perform_test_one(
-            lambda x: spread(x + 2),
-            lambda x: spread(x)
-        )
-    
-    def test_spread_scale(self):
-        self.perform_test_one(
-            lambda x: spread(2 * x),
-            lambda x: 2 * spread(x)
-        )
-    
-    def test_spread_negate(self):
-        self.perform_test_one(
-            lambda x: spread(-1 * x),
-            lambda x: spread(x)
-        )
-    
-    # RelSpread tests
-    def test_rel_spread_scale(self):
-        self.perform_test_one(
-            lambda x: rel_spread(2 * x),
-            lambda x: rel_spread(x)
-        )
-
-    # Shift tests
-    def test_shift_shift(self):
-        self.perform_test_two(
-            lambda x, y: shift(x + 3, y + 2),
-            lambda x, y: shift(x, y) + 1
-        )
-
-    def test_shift_scale(self):
-        self.perform_test_two(
-            lambda x, y: shift(2 * x, 2 * y),
-            lambda x, y: 2 * shift(x, y)
-        )
-
-    def test_shift_antisymmetry(self):
-        self.perform_test_two(
-            lambda x, y: shift(x, y),
-            lambda x, y: -1 * shift(y, x)
-        )
-
-    # Ratio tests
-    def test_ratio_scale(self):
-        self.perform_test_two(
-            lambda x, y: ratio(2 * x, 3 * y),
-            lambda x, y: (2.0 / 3) * ratio(x, y)
-        )
-
-    # AvgSpread tests
-    def test_avg_spread_equal(self):
-        self.perform_test_one(
-            lambda x: avg_spread(x, x),
-            lambda x: spread(x)
-        )
-
-    def test_avg_spread_symmetry(self):
-        self.perform_test_two(
-            lambda x, y: avg_spread(x, y),
-            lambda x, y: avg_spread(y, x)
-        )
-
-    def test_avg_spread_average(self):
-        self.perform_test_one(
-            lambda x: avg_spread(x, 5 * x),
-            lambda x: 3 * spread(x)
-        )
-
-    def test_avg_spread_scale(self):
-        self.perform_test_two(
-            lambda x, y: avg_spread(-2 * x, -2 * y),
-            lambda x, y: 2 * avg_spread(x, y)
-        )
-
-    # Disparity tests
-    def test_disparity_shift(self):
-        self.perform_test_two(
-            lambda x, y: disparity(x + 2, y + 2),
-            lambda x, y: disparity(x, y)
-        )
-
-    def test_disparity_scale(self):
-        self.perform_test_two(
-            lambda x, y: disparity(2 * x, 2 * y),
-            lambda x, y: disparity(x, y)
-        )
-
-    def test_disparity_scale_neg(self):
-        self.perform_test_two(
-            lambda x, y: disparity(-2 * x, -2 * y),
-            lambda x, y: -1 * disparity(x, y)
-        )
-
-    def test_disparity_antisymmetry(self):
-        self.perform_test_two(
-            lambda x, y: disparity(x, y),
-            lambda x, y: -1 * disparity(y, x)
-        )