typhoon-rainflow 0.2.0__cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl

typhoon/__init__.py

@@ -0,0 +1,5 @@
+from .typhoon import *
+
+__doc__ = typhoon.__doc__
+if hasattr(typhoon, "__all__"):
+    __all__ = typhoon.__all__

typhoon/__init__.pyi

@@ -0,0 +1,17 @@
+from .typhoon import *
+from .woehler import (
+    MinerType,
+    WoehlerCurveParams,
+    woehler_loads_basic,
+    woehler_loads,
+    woehler_log_space,
+)
+from .helper import (
+    CycleKey,
+    CycleCounter,
+    merge_cycle_counters,
+    add_residual_half_cycles,
+    counter_to_full_interval_df,
+)
+
+__all__: list[str]

typhoon/helper.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+from collections import Counter
+from typing import Iterable, Literal, Mapping, Tuple, cast
+
+import numpy as np
+import pandas as pd
+
+
+CycleKey = Tuple[float, float]
+CycleCounter = Counter
+
+
+def merge_cycle_counters(counters: Iterable[Mapping[CycleKey, float]]) -> CycleCounter:
+    """Merge multiple rainflow() cycle dicts/Counter objects using Counter.
+
+    Each input mapping should be like the first return value from ``rainflow``:
+    ``{(s_lower, s_upper): count}``.
+    """
+
+    total: CycleCounter = Counter()
+    for c in counters:
+        total.update(c)
+    return total
+
+
+def add_residual_half_cycles(
+    counter: Mapping[CycleKey, float],
+    residual_peaks: np.ndarray,
+) -> CycleCounter:
+    """Add half-cycles from residual waveform peaks to an existing Counter.
+
+    The residual peaks array is expected to be the second return value from
+    ``rainflow``. It represents half-cycles between adjacent peaks.
+
+    Each half-cycle contributes 0.5 to the count for its (from, to) key.
+    """
+
+    result: CycleCounter = Counter(counter)
+
+    if residual_peaks.size < 2:
+        return result
+
+    for i in range(len(residual_peaks) - 1):
+        f = float(residual_peaks[i])
+        t = float(residual_peaks[i + 1])
+        key: CycleKey = (f, t)
+        result[key] += 0.5  # type: ignore
+
+    return result
+
+
+def counter_to_full_interval_df(
+    counter: Mapping[CycleKey, float],
+    bin_size: float = 0.1,
+    closed: Literal["left", "right"] = "right",
+    round_decimals: int = 12,
+) -> pd.DataFrame:
+    """Convert a (from, to): count mapping to a full 2D interval DataFrame.
+
+    The returned DataFrame has a MultiIndex of (from_interval, to_interval)
+    covering the entire range, with zero counts where no cycles exist.
+    """
+
+    if not counter:
+        # Return empty but well-formed DataFrame
+        return pd.DataFrame(
+            [],
+            index=pd.MultiIndex.from_arrays(
+                [pd.IntervalIndex([], name="from"), pd.IntervalIndex([], name="to")]
+            ),
+            columns=["value"],
+        )
+
+    half = bin_size / 2.0
+
+    from_vals = sorted({f for (f, _) in counter.keys()})
+    to_vals = sorted({t for (_, t) in counter.keys()})
+
+    min_val = min(min(from_vals), min(to_vals))
+    max_val = max(max(from_vals), max(to_vals))
+
+    centers = np.arange(min_val, max_val + bin_size / 2.0, bin_size)
+
+    def make_interval(c: float) -> pd.Interval:
+        left = round(c - half, round_decimals)
+        right = round(c + half, round_decimals)
+        return pd.Interval(left, right, closed=closed)
+
+    from_bins = pd.IntervalIndex([make_interval(cast(float, c)) for c in centers], name="from")
+    to_bins = pd.IntervalIndex([make_interval(cast(float, c)) for c in centers], name="to")
+
+    full_idx = pd.MultiIndex.from_product([from_bins, to_bins], names=["from", "to"])
+
+    data = {
+        (make_interval(f), make_interval(t)): float(v) for (f, t), v in counter.items()
+    }
+
+    s = pd.Series(data, name="value", dtype="float64")
+    s = s.reindex(full_idx, fill_value=0.0)
+
+    return s.to_frame()

typhoon/helper.pyi

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from collections import Counter
+from typing import Iterable, Literal, Mapping, Tuple
+
+import numpy as np
+import pandas as pd
+
+CycleKey = Tuple[float, float]
+CycleCounter = Counter[CycleKey]
+
+def merge_cycle_counters(
+    counters: Iterable[Mapping[CycleKey, float]],
+) -> CycleCounter: ...
+def add_residual_half_cycles(
+    counter: Mapping[CycleKey, float],
+    residual_peaks: np.ndarray,
+) -> CycleCounter: ...
+def counter_to_full_interval_df(
+    counter: Mapping[CycleKey, float],
+    bin_size: float = 0.1,
+    closed: Literal["left", "right"] = "right",
+    round_decimals: int = 12,
+) -> pd.DataFrame: ...

typhoon/typhoon.pyi

@@ -0,0 +1,62 @@
+from collections import Counter
+from collections.abc import Mapping
+from typing import Any, TypeAlias
+
+import numpy as np
+from numpy.typing import NDArray
+
+Array1D: TypeAlias = NDArray[np.float32]
+
+def init_tracing() -> None: ...
+
+
+def rainflow(
+    waveform: Array1D,
+    last_peaks: Array1D | None = ..., 
+    bin_size: float = ..., 
+    threshold: float | None = ..., 
+    min_chunk_size: int = ...,
+) -> tuple[dict[tuple[float, float], int], Array1D]:
+    ...
+
+
+def goodman_transform(
+    cycles: Mapping[tuple[float, float], float] | Mapping[tuple[float, float], int],
+    m: float,
+    m2: float | None = ..., 
+) -> dict[float, float]:
+    ...
+
+
+def summed_histogram(
+    hist: Mapping[float, float] | Mapping[float, int],
+) -> list[tuple[float, float]]:
+    ...
+
+
+class RainflowContext:
+    def __init__(self, bin_size: float = ..., threshold: float = ...) -> None: ...
+
+    def process(self, waveform: Array1D) -> None: ...
+    def reset(self) -> None: ...
+
+    def cycles_len(self) -> int: ...
+    def get_last_peaks(self) -> Array1D: ...
+
+    def to_dict(self) -> dict[tuple[float, float], int]: ...
+    def to_counter(self) -> Counter[tuple[float, float]]: ...
+    def to_heatmap(self) -> tuple[np.ndarray[Any, np.dtype[np.float64]], Array1D]: ...
+
+    def goodman_transform(
+        self,
+        m: float,
+        m2: float | None = ...,
+        include_half_cycles: bool = ...,
+    ) -> dict[float, float]: ...
+
+    def summed_histogram(
+        self,
+        m: float,
+        m2: float | None = ...,
+        include_half_cycles: bool = ...,
+    ) -> list[tuple[float, float]]: ...

typhoon/woehler.py

@@ -0,0 +1,280 @@
+"""Helpers for evaluating Woehler (S-N) curves.
+
+The functions in this module are a NumPy-based translation of the TypeScript
+implementation used in the UI project.  They provide utilities for computing
+load amplitudes for a given number of cycles and for generating a convenient
+logarithmic cycle axis.
+
+The central entry points are:
+
+* :class:`WoehlerCurveParams` – container for curve parameters.
+* :func:`woehler_loads` – probability-dependent Woehler curve.
+* :func:`woehler_loads_basic` – Woehler curve without probability/scattering.
+* :func:`woehler_log_space` – helper to create a log-spaced cycle axis.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+from dataclasses import dataclass
+from enum import Enum
+from math import log10
+from typing import Iterable
+
+
+
+
+class MinerType(str, Enum):
+    NONE = "none"
+    ORIGINAL = "original"
+    ELEMENTARY = "elementary"
+    HAIBACH = "haibach"
+
+
+@dataclass
+class WoehlerCurveParams:
+    sd: float
+    nd: float
+    k1: float
+    k2: float | None = None
+    ts: float | None = None
+    tn: float | None = None
+
+
+_DEFAULT_FAILURE_PROBABILITY = 0.5
+
+
+def _norm_ppf(p: float) -> float:
+    """Approximate the inverse CDF (ppf) of the standard normal distribution.
+
+    Implementation based on Peter J. Acklam's algorithm. This avoids adding a
+    dependency on SciPy while being sufficiently accurate for engineering
+    purposes.
+    """
+
+    if not (0.0 < p < 1.0):
+        raise ValueError("p must be in (0, 1)")
+
+    a = [
+        -3.969683028665376e01,
+        2.209460984245205e02,
+        -2.759285104469687e02,
+        1.383577518672690e02,
+        -3.066479806614716e01,
+        2.506628277459239e00,
+    ]
+    b = [
+        -5.447609879822406e01,
+        1.615858368580409e02,
+        -1.556989798598866e02,
+        6.680131188771972e01,
+        -1.328068155288572e01,
+    ]
+    c = [
+        -7.784894002430293e-03,
+        -3.223964580411365e-01,
+        -2.400758277161838e00,
+        -2.549732539343734e00,
+        4.374664141464968e00,
+        2.938163982698783e00,
+    ]
+    d = [
+        7.784695709041462e-03,
+        3.224671290700398e-01,
+        2.445134137142996e00,
+        3.754408661907416e00,
+    ]
+
+    plow = 0.02425
+    phigh = 1 - plow
+
+    if p < plow:
+        q = np.sqrt(-2 * np.log(p))
+        return (((((c[0] * q + c[1]) * q + c[2]) * q + c[3]) * q + c[4]) * q + c[5]) / (
+            (((d[0] * q + d[1]) * q + d[2]) * q + d[3]) * q + 1.0
+        )
+
+    if p > phigh:
+        q = np.sqrt(-2 * np.log(1 - p))
+        return -(
+            (((((c[0] * q + c[1]) * q + c[2]) * q + c[3]) * q + c[4]) * q + c[5])
+            / ((((d[0] * q + d[1]) * q + d[2]) * q + d[3]) * q + 1.0)
+        )
+
+    q = p - 0.5
+    r = q * q
+    return (
+        (((((a[0] * r + a[1]) * r + a[2]) * r + a[3]) * r + a[4]) * r + a[5]) * q
+    ) / (((((b[0] * r + b[1]) * r + b[2]) * r + b[3]) * r + b[4]) * r + 1.0)
+
+
+_NATIVE_PPF = 0.0  # _norm_ppf(_DEFAULT_FAILURE_PROBABILITY)
+
+
+def _scattering_range_to_std(t: float) -> float:
+    return 0.39015207303618954 * log10(t)
+
+
+def _derive_k2(params: WoehlerCurveParams, miner: MinerType) -> float:
+    if miner is MinerType.ORIGINAL:
+        return float("inf")
+    if miner is MinerType.ELEMENTARY:
+        return params.k1
+    if miner is MinerType.HAIBACH:
+        return 2.0 * params.k1 - 1.0
+    return float("inf")
+
+
+def _derive_ts(params: WoehlerCurveParams) -> float:
+    if params.ts is not None:
+        return params.ts
+    if params.tn is not None:
+        return float(params.tn) ** (1.0 / params.k1)
+    return 1.0
+
+
+def _derive_tn(params: WoehlerCurveParams) -> float:
+    if params.tn is not None:
+        return params.tn
+    if params.ts is not None:
+        return float(params.ts) ** params.k1
+    return 1.0
+
+
+def _make_k(
+    src: float, ref: float, params: WoehlerCurveParams, miner: MinerType
+) -> float:
+    k2_derived = _derive_k2(params, miner)
+    if src < ref:
+        return k2_derived
+    return params.k1
+
+
+def woehler_loads_basic(
+    cycles: Iterable[float] | np.ndarray,
+    params: WoehlerCurveParams,
+    miner: MinerType = MinerType.NONE,
+) -> np.ndarray:
+    """Return Woehler curve loads for given cycle counts.
+
+    This variant corresponds to the "native" Woehler curve and does not apply
+    any probability or scattering transformation.  It still honours the
+    ``miner`` setting and thus the possible change of slope between the
+    finite-life and the endurance region.
+    """
+
+    cyc = np.asarray(list(cycles), dtype=float)
+    if cyc.ndim != 1:
+        raise ValueError("cycles must be 1D")
+
+    sd = params.sd
+    nd_transformed = params.nd
+
+    sd_transformed = sd
+
+    ref = -nd_transformed
+    k_values = np.array(
+        [_make_k(-float(c), ref, params, miner) for c in cyc], dtype=float
+    )
+
+    loads = np.empty_like(cyc, dtype=float)
+    mask_finite = np.isfinite(k_values)
+    loads[mask_finite] = sd_transformed * (cyc[mask_finite] / nd_transformed) ** (
+        -1.0 / k_values[mask_finite]
+    )
+    loads[~mask_finite] = sd_transformed
+
+    return loads
+
+
+def woehler_loads(
+    cycles: Iterable[float] | np.ndarray,
+    params: WoehlerCurveParams,
+    miner: MinerType = MinerType.NONE,
+    failure_probability: float = _DEFAULT_FAILURE_PROBABILITY,
+) -> np.ndarray:
+    """Return Woehler curve loads for given cycle counts.
+
+    Parameters
+    ----------
+    cycles:
+        Iterable of cycle counts (e.g. values from :func:`woehler_log_space`).
+    params:
+        Woehler curve parameters such as fatigue strength and slopes.
+    miner:
+        Miner damage rule variant determining the second slope ``k2``.
+    failure_probability:
+        Target failure probability :math:`P_f` in the interval ``(0, 1)``.
+
+    Notes
+    -----
+    The implementation mirrors the TypeScript logic from the UI and is
+    vectorised for NumPy arrays.  It uses an internal approximation of the
+    standard normal inverse CDF and applies the same transformations to
+    ``sd`` and ``nd`` that are used in the UI.
+    """
+
+    if not (0.0 < failure_probability < 1.0):
+        raise ValueError("failure_probability must be in (0, 1)")
+
+    cyc = np.asarray(list(cycles), dtype=float)
+    if cyc.ndim != 1:
+        raise ValueError("cycles must be 1D")
+
+    goal_ppf = _norm_ppf(failure_probability)
+
+    ts_derived = _derive_ts(params)
+    tn_derived = _derive_tn(params)
+
+    sd = params.sd
+    nd = params.nd
+
+    # Transform sd
+    sd_transformed = sd / 10.0 ** (
+        (_NATIVE_PPF - goal_ppf) * _scattering_range_to_std(ts_derived)
+    )
+
+    # Transform nd
+    transformed_nd = nd / 10.0 ** (
+        (_NATIVE_PPF - goal_ppf) * _scattering_range_to_std(tn_derived)
+    )
+    if sd_transformed != 0.0:
+        nd_transformed = transformed_nd * (sd_transformed / sd) ** (-params.k1)
+    else:
+        nd_transformed = transformed_nd
+
+    ref = -nd_transformed
+    k_values = np.array(
+        [_make_k(-float(c), ref, params, miner) for c in cyc], dtype=float
+    )
+
+    loads = np.empty_like(cyc, dtype=float)
+    mask_finite = np.isfinite(k_values)
+    loads[mask_finite] = sd_transformed * (cyc[mask_finite] / nd_transformed) ** (
+        -1.0 / k_values[mask_finite]
+    )
+    loads[~mask_finite] = sd_transformed
+
+    return loads
+
+
+def woehler_log_space(
+    minimum: float = 1.0,
+    maximum: float = 10.0**8,
+    n: int = 101,
+) -> np.ndarray:
+    """Return logarithmically spaced cycle counts between ``minimum`` and ``maximum``.
+
+    This is a small convenience wrapper around :func:`numpy.logspace` with
+    defaults that are suitable for typical Woehler curves.
+    """
+
+    if n < 2:
+        raise ValueError("n must be >= 2")
+
+    log_min = log10(minimum)
+    log_max = log10(maximum)
+    # step = (log_max - log_min) / (n - 1)
+    exponents = np.linspace(log_min, log_max, num=n)
+    return 10.0**exponents

typhoon/woehler.pyi

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import Iterable
+
+import numpy as np
+
+class MinerType(str, Enum):
+    NONE: str
+    ORIGINAL: str
+    ELEMENTARY: str
+    HAIBACH: str
+
+@dataclass
+class WoehlerCurveParams:
+    sd: float
+    nd: float
+    k1: float
+    k2: float | None = None
+    ts: float | None = None
+    tn: float | None = None
+
+def woehler_loads_basic(
+    cycles: Iterable[float] | np.ndarray,
+    params: WoehlerCurveParams,
+    miner: MinerType = ...,
+) -> np.ndarray: ...
+def woehler_loads(
+    cycles: Iterable[float] | np.ndarray,
+    params: WoehlerCurveParams,
+    miner: MinerType = ...,
+    failure_probability: float = ...,
+) -> np.ndarray: ...
+def woehler_log_space(
+    minimum: float = 1.0,
+    maximum: float = 10.0**8,
+    n: int = 101,
+) -> np.ndarray: ...

typhoon_rainflow-0.2.0.dist-info/METADATA

@@ -0,0 +1,254 @@
+Metadata-Version: 2.4
+Name: typhoon-rainflow
+Version: 0.2.0
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Typing :: Typed
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: nox ; extra == 'test'
+Provides-Extra: test
+Summary: Fast rainflow counting for streaming input written in Rust
+Author: Markus Wegmann
+Author-email: mw@technokrat.ch
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# typhoon
+[![CI](https://github.com/technokrat/typhoon/actions/workflows/CI.yml/badge.svg)](https://github.com/technokrat/typhoon/actions/workflows/CI.yml) ![PyPI - Version](https://img.shields.io/pypi/v/typhoon-rainflow)
+
+
+Typhoon is a rainflow counting Python module written in Rust by Markus Wegmann (mw@technokrat.ch).
+
+It uses a new windowed four-point counting method which can be run in parallel on multiple cores and allows for chunk-based sample stream processing, preserving half cycles for future chunks.
+
+It is therefore intended for real-time processing of load captures and serves as as crucial part of i-Spring's in-edge data processing chain.
+
+## Installation
+Add the package `typhoon-rainflow` to your Python project, e.g.
+
+```python
+poetry add typhoon-rainflow
+```
+
+## Python API
+
+The Python package exposes two main namespaces:
+
+- `typhoon.typhoon`: low-level, performance‑critical functions implemented in Rust.
+- `typhoon.helper`: convenience utilities for working with the rainflow output.
+
+The top-level package re-exports everything from `typhoon.typhoon`, so you can either
+
+```python
+import typhoon            # recommended for normal use
+from typhoon import rainflow, goodman_transform
+```
+
+or
+
+```python
+from typhoon.typhoon import rainflow
+from typhoon import helper  # for helper utilities
+```
+
+### Core functions (`typhoon.typhoon`)
+
+All arguments are keyword-compatible with the examples below.
+
+- `init_tracing() -> None`
+    - Initialize verbose tracing/logging from the Rust implementation.
+    - Intended mainly for debugging and performance analysis; it writes to stdout.
+
+- `rainflow(waveform, last_peaks=None, bin_size=0.0, threshold=None, min_chunk_size=64*1024)`
+    - Perform windowed four-point rainflow counting on a 1D NumPy waveform.
+    - `waveform`: 1D `numpy.ndarray` of `float32` or `float64`.
+    - `last_peaks`: optional 1D array of peaks from the previous chunk (for streaming).
+    - `bin_size`: bin width for quantizing ranges; `0.0` disables quantization.
+    - `threshold`: minimum cycle amplitude to count; default `0.0`.
+    - `min_chunk_size`: minimum chunk size for internal parallelization.
+    - Returns `(cycles, residual_peaks)` where
+        - `cycles` is a dict `{(s_lower, s_upper): count}` and
+        - `residual_peaks` is a 1D NumPy array of remaining peaks to pass to the next call.
+
+- `goodman_transform(cycles, m, m2=None)`
+    - Apply a (piecewise) Goodman-like mean stress correction to rainflow cycles.
+    - `cycles`: mapping `{(s_lower, s_upper): count}` (e.g. first return value of `rainflow`).
+    - `m`: main slope/parameter.
+    - `m2`: optional secondary slope; defaults to `m / 3` if omitted.
+    - Returns a dict `{s_a_ers: count}` where `s_a_ers` is the equivalent range.
+
+- `summed_histogram(hist)`
+    - Build a descending cumulative histogram from the Goodman-transformed result.
+    - `hist`: mapping `{s_a_ers: count}` such as returned from `goodman_transform`.
+    - Returns a list of `(s_a_ers, cumulative_count)` pairs sorted from high to low range.
+
+### Stateful streaming (`RainflowContext`)
+
+If you process signals chunk-by-chunk, repeatedly calling `rainflow()` and merging dicts/Counters can become a bottleneck.
+
+`RainflowContext` keeps the accumulated cycle map and the residual `last_peaks` inside the Rust extension, so each new chunk only updates the existing state.
+
+Key methods:
+
+- `process(waveform)`: update the internal state from one waveform chunk.
+- `to_counter()`: export the accumulated cycles as a Python `collections.Counter`.
+- `to_heatmap()`: export a dense 2D NumPy array for plotting (and the corresponding bin centers).
+- `goodman_transform(m, m2=None, include_half_cycles=False)`: Goodman transform directly on the internal state.
+    - When `include_half_cycles=True`, the current residual `last_peaks` are treated as half-cycles (each adjacent peak-pair contributes `0.5`).
+- `summed_histogram(m, m2=None, include_half_cycles=False)`: convenience wrapper that returns the descending cumulative histogram (same format as `typhoon.summed_histogram`).
+
+Example:
+
+```python
+import numpy as np
+import typhoon
+
+ctx = typhoon.RainflowContext(bin_size=1.0, threshold=0.0)
+
+for chunk in chunks:  # iterable of 1D numpy arrays
+    ctx.process(chunk)
+
+# Export accumulated cycles
+cycles = ctx.to_counter()
+
+# Goodman transform (optionally including the current residual half-cycles)
+hist = ctx.goodman_transform(m=0.3, include_half_cycles=True)
+
+# Summed histogram directly from the context
+summed = ctx.summed_histogram(m=0.3, include_half_cycles=True)
+
+# Heatmap export for matplotlib
+heatmap, bins = ctx.to_heatmap()
+
+# Example plotting
+# import matplotlib.pyplot as plt
+# plt.imshow(heatmap, origin="lower")
+# plt.xticks(range(len(bins)), bins, rotation=90)
+# plt.yticks(range(len(bins)), bins)
+# plt.xlabel("to")
+# plt.ylabel("from")
+# plt.colorbar(label="count")
+# plt.tight_layout()
+# plt.show()
+```
+
+### Helper utilities (`typhoon.helper`)
+
+The helper module provides convenience tools for post-processing and analysis.
+
+- `merge_cycle_counters(counters)`
+    - Merge multiple `dict`/`Counter` objects of the form `{(from, to): count}`.
+    - Useful when combining rainflow results from multiple chunks or channels.
+
+- `add_residual_half_cycles(counter, residual_peaks)`
+    - Convert the trailing `residual_peaks` from `rainflow` into half-cycles and add them to an existing counter.
+    - Each adjacent pair of peaks `(p_i, p_{i+1})` contributes `0.5` to the corresponding cycle key.
+
+- `counter_to_full_interval_df(counter, bin_size=0.1, closed="right", round_decimals=12)`
+    - Convert a sparse `(from, to): count` mapping into a dense 2D `pandas.DataFrame` over all intervals.
+    - Returns a DataFrame with a `(from, to)` `MultiIndex` of `pd.Interval` and a single `"value"` column.
+
+### Woehler curves (`typhoon.woehler`)
+
+The `typhoon.woehler` module provides helpers for evaluating S–N (Woehler) curves.
+
+Key entry points are:
+
+- `WoehlerCurveParams(sd, nd, k1, k2=None, ts=None, tn=None)`
+        - Container for the curve parameters:
+                - `sd`: fatigue strength at `nd` cycles for the reference failure probability.
+                - `nd`: reference number of cycles (e.g. 1e6).
+                - `k1`: slope in the finite-life region.
+                - `k2`: optional slope in the endurance region; derived from the Miner
+                    rule if omitted.
+                - `ts` / `tn`: optional scattering parameters controlling probability
+                    transforms of `sd` and `nd`.
+- `MinerType` enum
+        - Miner damage rule variant that determines the second slope `k2`:
+            `NONE`, `ORIGINAL`, `ELEMENTARY`, `HAIBACH`.
+- `woehler_log_space(minimum=1.0, maximum=1e8, n=101)`
+        - Convenience helper to generate a logarithmically spaced cycle axis for
+            plotting Woehler curves.
+- `woehler_loads_basic(cycles, params, miner=MinerType.NONE)`
+        - Compute a "native" Woehler curve without probability/scattering
+            transformation, but honouring the selected Miner type.
+- `woehler_loads(cycles, params, miner=MinerType.NONE, failure_probability=0.5)`
+        - Compute a probability-dependent Woehler curve using an internal
+            approximation of the normal inverse CDF.
+
+## Example Usage
+
+### Basic rainflow counting
+
+```python
+import numpy as np
+import typhoon
+
+waveform = np.array([0.0, 1.0, 2.0, 1.0, 2.0, 1.0, 3.0, 4.0], dtype=np.float32)
+
+cycles, residual_peaks = typhoon.rainflow(
+        waveform=waveform,
+        last_peaks=None,
+        bin_size=1.0,
+)
+
+print("Cycles:", cycles)
+print("Residual peaks:", residual_peaks)
+```
+
+### Streaming / chunked processing with helpers
+
+```python
+from collections import Counter
+
+import numpy as np
+import typhoon
+from typhoon import helper
+
+waveform1 = np.array([0.0, 1.0, 2.0, 1.0, 2.0, 1.0, 3.0, 4.0], dtype=np.float32)
+waveform2 = np.array([3.0, 5.0, 4.0, 2.0], dtype=np.float32)
+
+# First chunk
+cycles1, residual1 = typhoon.rainflow(waveform1, last_peaks=None, bin_size=1.0)
+
+# Second chunk, passing residual peaks from the first
+cycles2, residual2 = typhoon.rainflow(waveform2, last_peaks=residual1, bin_size=1.0)
+
+# Merge cycle counts from both chunks
+merged = helper.merge_cycle_counters([cycles1, cycles2])
+
+# Optionally add remaining half-cycles from the final residual peaks
+merged_with_residuals = helper.add_residual_half_cycles(merged, residual2)
+
+print("Merged cycles:", merged_with_residuals)
+```
+
+### Goodman transform and summed histogram
+
+```python
+import typhoon
+from typhoon import helper
+
+cycles, residual_peaks = typhoon.rainflow(waveform, last_peaks=None, bin_size=1.0)
+
+# Apply Goodman transform
+hist = typhoon.goodman_transform(cycles, m=0.3)
+
+# Summed histogram from the Goodman result
+summed = typhoon.summed_histogram(hist)
+
+print("Goodman result:", hist)
+print("Summed histogram:", summed)
+```
+
+## Testing
+
+```sh
+pipx install nox
+
+nox -s build
+nox -s test
+nox -s develop
+```

typhoon_rainflow-0.2.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+typhoon/__init__.py,sha256=61qdDpZxeAZUZYNQSz2J5rW7yQYJweTiuEM8WAvWr0E,112
+typhoon/__init__.pyi,sha256=eIk21D4wbD61ApVTUwbUo-yzyol72X7WuBhL8EOcx0o,319
+typhoon/helper.py,sha256=4sCHSb14URp0h5RPVf8nqjV_-cpc2nymryaiUIz6kCE,3104
+typhoon/helper.pyi,sha256=EkvjSMIHiCRtjn5ARjtdNpFahD4G79Evqj9EGu4J3Sc,650
+typhoon/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+typhoon/typhoon.cpython-312-powerpc64le-linux-gnu.so,sha256=5Swf2SHXuUVT7p0YzLXjKt2WaOfSnO06u4tdAX5TVZw,1681040
+typhoon/typhoon.pyi,sha256=vPiyHPSgT5srb6T_nzXx6SXu5HGO8xz2S0LYDrCjTkM,1597
+typhoon/woehler.py,sha256=cMk1L4taWKWNAYbr4dGUb3Bkp3A10s9hhGCRQ6ZvcS8,7808
+typhoon/woehler.pyi,sha256=OuejNfi8pPa58V0lJzmu7f6N4W036YuC09nmimdigUU,849
+typhoon_rainflow-0.2.0.dist-info/METADATA,sha256=YCqpafjp6mAJ7ZyUIkPImLwyJ-fK68AKVq1Tdn8mhS0,9519
+typhoon_rainflow-0.2.0.dist-info/WHEEL,sha256=qwDhKaIiqiFOO-9vdjqn1s6gfU4heRxHMy95GnoMwLQ,149
+typhoon_rainflow-0.2.0.dist-info/RECORD,,

typhoon_rainflow-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: maturin (1.11.5)
+Root-Is-Purelib: false
+Tag: cp312-cp312-manylinux_2_17_ppc64le
+Tag: cp312-cp312-manylinux2014_ppc64le