rstatistics 0.1.0__tar.gz

rstatistics-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ccc-claude-opus
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

rstatistics-0.1.0/PKG-INFO

@@ -0,0 +1,121 @@
+Metadata-Version: 2.4
+Name: rstatistics
+Version: 0.1.0
+Summary: R's probability and statistics functions in pure Python: d/p/q/r distributions, t.test and friends, summary, quantile, with R's numbers and R's printed output
+License: MIT License
+        
+        Copyright (c) 2026 ccc-claude-opus
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/ccc-claude-opus/rupy/tree/main/rstat
+Keywords: statistics,probability,R,distributions,hypothesis-testing
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# rstat
+
+R's probability and statistics functions in pure Python, with R's numbers and R's
+printed output. There are no dependencies: vectors are plain `list[float]`.
+
+```
+pip install rstatistics
+```
+
+The package installs as `rstatistics` and is imported as `rstat`.
+
+```python
+import rstat as r
+
+x = [5.1, 4.9, 6.2, 5.8, 6.0, 5.5, 5.3, 6.1]
+print(r.t_test(x, mu=5.0))
+print(r.summary(x))
+```
+
+```
+	One Sample t-test
+
+data:  x
+t = 3.5696, df = 7, p-value = 0.009101
+alternative hypothesis: true mean is not equal to 5
+95 percent confidence interval:
+ 5.206762 6.018238
+sample estimates:
+mean of x 
+   5.6125 
+
+   Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
+  4.900   5.250   5.650   5.612   6.025   6.200 
+```
+
+That is what R prints for `t.test(x, mu = 5)` and `summary(x)`.
+
+## Names
+
+R's names, with `_` for `.`: `t.test` is `t_test`, `lower.tail` is `lower_tail`,
+`var.equal` is `var_equal`. R's `range`, `round` and `signif` of vectors are
+`range_`, `round_` and `signif_`.
+
+## What there is
+
+| Area | Functions |
+| --- | --- |
+| Distributions (`d`, `p`, `q`) | `norm`, `unif`, `exp`, `gamma`, `chisq`, `beta`, `t`, `f` (`df`, `pf`, `qf`), `lnorm`, `weibull`, `cauchy`, `logis`, `binom`, `pois`, `geom`, `nbinom` (`d`, `p`), `hyper` (`d`, `p`); `lower_tail` and `log_p` as in R |
+| Random numbers | `set_seed(seed)` returns a generator with R's numbers: `runif`, `rnorm`, `rexp`, `rlnorm`, `sample`, `sample_from` |
+| Descriptive | `mean`, `var`, `sd`, `cov`, `cor` (pearson, spearman, kendall), `median`, `quantile` (types 1–9), `IQR`, `mad`, `fivenum`, `rank`, `scale`, `weighted_mean`, `summary` |
+| Tests | `t_test` (one-sample, Welch, pooled, paired), `var_test`, `chisq_test`, `chisq_test_table`, `binom_test`, `prop_test`, `cor_test`; each returns an `HTest` that prints as R's `htest` and has `statistic`, `parameter`, `p_value`, `conf_int`, `estimate` |
+| Special functions | `gamma`, `lgamma`, `beta`, `lbeta`, `choose`, `lchoose` |
+| Printing | `format` (R's `format` of a numeric vector), `format_num`, `format_pval`, `print_vector`, `signif` |
+
+### Random numbers
+
+R keeps one generator for the session; rstat passes it explicitly. After
+`set_seed(n)` the numbers are R's after `set.seed(n)` (Mersenne-Twister, normal
+numbers by inversion, R ≥ 3.6's rejection sampling):
+
+```python
+g = r.set_seed(42)
+print(r.print_vector(g.rnorm(5)))
+# [1]  1.3709584 -0.5646982  0.3631284  0.6328626  0.4042683
+```
+
+## How close to R
+
+`tests/` holds R scripts, their output in R 4.6, and the same programs in Python;
+`python tests/run.py` compares them (`--regen` reruns R first). The printed output
+of the tests, `format`, `summary`, `quantile` and the random numbers is identical
+to R's; distribution functions agree with R to a relative 1e-12. One difference:
+R names the data of a test from the call (`data:  c(20, 30, 25, 25)`), rstat from
+the `data_name` argument (default `x`, `x and y`, ...).
+
+## rupy
+
+rstat is written in [rupy](https://github.com/ccc-claude-opus/rupy)'s typed subset
+of Python, and rupy has it built in: `rupy run` compiles a program that imports
+rstat to Rust, `rupy wasm` to WebAssembly, with the same output as CPython.
+
+## License
+
+MIT

rstatistics-0.1.0/README.md

@@ -0,0 +1,84 @@
+# rstat
+
+R's probability and statistics functions in pure Python, with R's numbers and R's
+printed output. There are no dependencies: vectors are plain `list[float]`.
+
+```
+pip install rstatistics
+```
+
+The package installs as `rstatistics` and is imported as `rstat`.
+
+```python
+import rstat as r
+
+x = [5.1, 4.9, 6.2, 5.8, 6.0, 5.5, 5.3, 6.1]
+print(r.t_test(x, mu=5.0))
+print(r.summary(x))
+```
+
+```
+	One Sample t-test
+
+data:  x
+t = 3.5696, df = 7, p-value = 0.009101
+alternative hypothesis: true mean is not equal to 5
+95 percent confidence interval:
+ 5.206762 6.018238
+sample estimates:
+mean of x 
+   5.6125 
+
+   Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
+  4.900   5.250   5.650   5.612   6.025   6.200 
+```
+
+That is what R prints for `t.test(x, mu = 5)` and `summary(x)`.
+
+## Names
+
+R's names, with `_` for `.`: `t.test` is `t_test`, `lower.tail` is `lower_tail`,
+`var.equal` is `var_equal`. R's `range`, `round` and `signif` of vectors are
+`range_`, `round_` and `signif_`.
+
+## What there is
+
+| Area | Functions |
+| --- | --- |
+| Distributions (`d`, `p`, `q`) | `norm`, `unif`, `exp`, `gamma`, `chisq`, `beta`, `t`, `f` (`df`, `pf`, `qf`), `lnorm`, `weibull`, `cauchy`, `logis`, `binom`, `pois`, `geom`, `nbinom` (`d`, `p`), `hyper` (`d`, `p`); `lower_tail` and `log_p` as in R |
+| Random numbers | `set_seed(seed)` returns a generator with R's numbers: `runif`, `rnorm`, `rexp`, `rlnorm`, `sample`, `sample_from` |
+| Descriptive | `mean`, `var`, `sd`, `cov`, `cor` (pearson, spearman, kendall), `median`, `quantile` (types 1–9), `IQR`, `mad`, `fivenum`, `rank`, `scale`, `weighted_mean`, `summary` |
+| Tests | `t_test` (one-sample, Welch, pooled, paired), `var_test`, `chisq_test`, `chisq_test_table`, `binom_test`, `prop_test`, `cor_test`; each returns an `HTest` that prints as R's `htest` and has `statistic`, `parameter`, `p_value`, `conf_int`, `estimate` |
+| Special functions | `gamma`, `lgamma`, `beta`, `lbeta`, `choose`, `lchoose` |
+| Printing | `format` (R's `format` of a numeric vector), `format_num`, `format_pval`, `print_vector`, `signif` |
+
+### Random numbers
+
+R keeps one generator for the session; rstat passes it explicitly. After
+`set_seed(n)` the numbers are R's after `set.seed(n)` (Mersenne-Twister, normal
+numbers by inversion, R ≥ 3.6's rejection sampling):
+
+```python
+g = r.set_seed(42)
+print(r.print_vector(g.rnorm(5)))
+# [1]  1.3709584 -0.5646982  0.3631284  0.6328626  0.4042683
+```
+
+## How close to R
+
+`tests/` holds R scripts, their output in R 4.6, and the same programs in Python;
+`python tests/run.py` compares them (`--regen` reruns R first). The printed output
+of the tests, `format`, `summary`, `quantile` and the random numbers is identical
+to R's; distribution functions agree with R to a relative 1e-12. One difference:
+R names the data of a test from the call (`data:  c(20, 30, 25, 25)`), rstat from
+the `data_name` argument (default `x`, `x and y`, ...).
+
+## rupy
+
+rstat is written in [rupy](https://github.com/ccc-claude-opus/rupy)'s typed subset
+of Python, and rupy has it built in: `rupy run` compiles a program that imports
+rstat to Rust, `rupy wasm` to WebAssembly, with the same output as CPython.
+
+## License
+
+MIT

rstatistics-0.1.0/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "rstatistics"
+version = "0.1.0"
+description = "R's probability and statistics functions in pure Python: d/p/q/r distributions, t.test and friends, summary, quantile, with R's numbers and R's printed output"
+readme = "README.md"
+license = { file = "LICENSE" }
+requires-python = ">=3.10"
+dependencies = []
+keywords = ["statistics", "probability", "R", "distributions", "hypothesis-testing"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Topic :: Scientific/Engineering :: Mathematics",
+]
+
+[project.urls]
+Homepage = "https://github.com/ccc-claude-opus/rupy/tree/main/rstat"
+
+[tool.setuptools]
+packages = ["rstat"]

rstatistics-0.1.0/rstat/__init__.py

@@ -0,0 +1,20 @@
+"""rstat: R's probability and statistics functions in Python.
+
+The names are R's, with `_` for `.` (`t.test` is `t_test`); arguments are R's
+too (`lower.tail` is `lower_tail`). Printed results look as in R. The package
+is written in rupy's typed subset of Python, so rupy compiles it to Rust or
+WebAssembly as well."""
+
+from rstat.distributions import (
+    dbeta, dbinom, dcauchy, dchisq, dexp, df, dgamma, dgeom, dhyper, dlnorm, dlogis, dnbinom, dnorm, dpois, dt,
+    dunif, dweibull, pbeta, pbinom, pcauchy, pchisq, pexp, pf, pgamma, pgeom, phyper, plnorm, plogis, pnbinom,
+    pnorm, ppois, pt, punif, pweibull, qbeta, qbinom, qcauchy, qchisq, qexp, qf, qgamma, qgeom, qlnorm, qlogis,
+    qnorm, qpois, qt, qunif, qweibull,
+)
+from rstat.describe import IQR, Named, Summary, cor, cov, fivenum, mad, mean, median, quantile, rank, scale, sd, summary, var, weighted_mean
+from rstat.htest import HTest, binom_test, chisq_test, chisq_test_table, cor_test, prop_test, t_test, var_test
+from rstat.rformat import format_vec, format_vec as format, format_num, format_pval, print_vector, signif
+from rstat.rng import RNG, set_seed
+from rstat.special import beta, choose, gamma, lbeta, lchoose, lgamma
+
+__version__ = "0.1.0"

rstatistics-0.1.0/rstat/describe.py

@@ -0,0 +1,313 @@
+"""Descriptive statistics with R's algorithms (two-pass means and variances,
+the nine quantile types) and R's printed form (named vectors, `summary`)."""
+
+import math
+
+from rstat.rformat import format_vec, format_num, print_named, signif
+
+
+class Named:
+    """A named numeric vector, printed as R prints one."""
+
+    def __init__(self, names: list[str], values: list[float], digits: int = 7) -> None:
+        self.names = names
+        self.values = values
+        self.digits = digits
+
+    def __str__(self) -> str:
+        return print_named(self.names, format_vec(self.values, self.digits))
+
+    def __repr__(self) -> str:
+        return self.__str__()
+
+    def __getitem__(self, i: int) -> float:
+        return self.values[i]
+
+    def __len__(self) -> int:
+        return len(self.values)
+
+    def get(self, name: str) -> float:
+        """The value named `name`."""
+        return self.values[self.names.index(name)]
+
+
+def _check(x: list[float]) -> None:
+    if len(x) == 0:
+        raise ValueError("'x' must have at least one element")
+
+
+def mean(x: list[float]) -> float:
+    """R's mean: the sum over n, corrected by a second pass."""
+    _check(x)
+    n = float(len(x))
+    s = 0.0
+    for v in x:
+        s += v
+    s /= n
+    if not math.isinf(s) and not math.isnan(s):
+        t = 0.0
+        for v in x:
+            t += v - s
+        s += t / n
+    return s
+
+
+def var(x: list[float]) -> float:
+    """The sample variance (denominator n - 1)."""
+    n = len(x)
+    if n < 2:
+        return math.nan
+    m = mean(x)
+    s = 0.0
+    for v in x:
+        s += (v - m) * (v - m)
+    return s / float(n - 1)
+
+
+def sd(x: list[float]) -> float:
+    """The sample standard deviation."""
+    return math.sqrt(var(x))
+
+
+def cov(x: list[float], y: list[float]) -> float:
+    """The sample covariance."""
+    if len(x) != len(y):
+        raise ValueError("incompatible dimensions")
+    n = len(x)
+    if n < 2:
+        return math.nan
+    mx = mean(x)
+    my = mean(y)
+    s = 0.0
+    for i in range(n):
+        s += (x[i] - mx) * (y[i] - my)
+    return s / float(n - 1)
+
+
+def rank(x: list[float]) -> list[float]:
+    """Ranks, ties getting their average rank (R's `rank`)."""
+    n = len(x)
+    order = sorted(range(n), key=lambda i: x[i])
+    r = [0.0] * n
+    i = 0
+    while i < n:
+        j = i
+        while j + 1 < n and x[order[j + 1]] == x[order[i]]:
+            j += 1
+        avg = (float(i) + float(j)) / 2.0 + 1.0
+        for k in range(i, j + 1):
+            r[order[k]] = avg
+        i = j + 1
+    return r
+
+
+def cor(x: list[float], y: list[float], method: str = "pearson") -> float:
+    """The correlation of x and y: "pearson", "spearman" or "kendall" (tau-b)."""
+    if len(x) != len(y):
+        raise ValueError("incompatible dimensions")
+    if method == "spearman":
+        return cor(rank(x), rank(y), "pearson")
+    if method == "kendall":
+        n = len(x)
+        conc = 0.0
+        tx = 0.0
+        ty = 0.0
+        for i in range(n):
+            for j in range(i + 1, n):
+                a = x[i] - x[j]
+                b = y[i] - y[j]
+                sa = 1.0 if a > 0.0 else (-1.0 if a < 0.0 else 0.0)
+                sb = 1.0 if b > 0.0 else (-1.0 if b < 0.0 else 0.0)
+                conc += sa * sb
+                tx += sa * sa
+                ty += sb * sb
+        return conc / math.sqrt(tx * ty)
+    mx = mean(x)
+    my = mean(y)
+    sxy = 0.0
+    sxx = 0.0
+    syy = 0.0
+    for i in range(len(x)):
+        dx = x[i] - mx
+        dy = y[i] - my
+        sxy += dx * dy
+        sxx += dx * dx
+        syy += dy * dy
+    r = sxy / math.sqrt(sxx * syy)
+    return max(-1.0, min(1.0, r))
+
+
+def median(x: list[float]) -> float:
+    """The median."""
+    _check(x)
+    s = sorted(x)
+    n = len(s)
+    half = (n + 1) // 2
+    if n % 2 == 1:
+        return s[half - 1]
+    return mean([s[half - 1], s[half]])
+
+
+def quantile(x: list[float], probs: list[float] | None = None, type: int = 7) -> Named:
+    """Sample quantiles of the nine types of R's `quantile` (default 7; probs
+    default 0, 0.25, 0.5, 0.75, 1), named as R names them ("25%")."""
+    _check(x)
+    ps = [0.0, 0.25, 0.5, 0.75, 1.0] if probs is None else probs
+    s = sorted(x)
+    n = len(s)
+    out: list[float] = []
+    eps = 2.220446049250313e-16
+    for p in ps:
+        if p < 0.0 or p > 1.0:
+            raise ValueError("'probs' outside [0,1]")
+        if type == 7:
+            index = 1.0 + float(max(n - 1, 0)) * p
+            lo = int(math.floor(index))
+            hi = int(math.ceil(index))
+            q = s[lo - 1]
+            h = index - float(lo)
+            if index > float(lo) and s[hi - 1] != q:
+                q = (1.0 - h) * q + h * s[hi - 1]
+            out.append(q)
+            continue
+        if type <= 3:
+            nppm = float(n) * p - 0.5 if type == 3 else float(n) * p
+            j = int(math.floor(nppm + 4.0 * eps))
+            if type == 1:
+                h = 1.0 if nppm > float(j) else 0.0
+            elif type == 2:
+                h = ((1.0 if nppm > float(j) else 0.0) + 1.0) / 2.0
+            else:
+                h = 1.0 if (nppm != float(j) or j % 2 == 1) else 0.0
+        else:
+            a = 0.0
+            b = 1.0
+            if type == 5:
+                a = 0.5
+                b = 0.5
+            elif type == 6:
+                a = 0.0
+                b = 0.0
+            elif type == 8:
+                a = 1.0 / 3.0
+                b = 1.0 / 3.0
+            elif type == 9:
+                a = 3.0 / 8.0
+                b = 3.0 / 8.0
+            fuzz = 4.0 * eps
+            nppm = a + p * (float(n) + 1.0 - a - b)
+            j = int(math.floor(nppm + fuzz))
+            h = nppm - float(j)
+            if abs(h) < fuzz:
+                h = 0.0
+        # x padded as R pads it: x[1], x[1], x..., x[n], x[n]
+        xs = [s[0], s[0]] + s + [s[n - 1], s[n - 1]]
+        lo_v = xs[j + 1]
+        hi_v = xs[j + 2]
+        if h == 1.0:
+            q = hi_v
+        elif 0.0 < h < 1.0 and lo_v != hi_v:
+            q = (1.0 - h) * lo_v + h * hi_v
+        else:
+            q = lo_v
+        out.append(q)
+    names = [_trim_pct(100.0 * p) for p in ps]
+    return Named(names, out)
+
+
+def _trim_pct(v: float) -> str:
+    """`paste0(formatC(100 * probs, format = "fg", width = 1, digits = 7), "%")`."""
+    s = format_num(v, 7).strip()
+    if "." in s and "e" not in s:
+        s = s.rstrip("0").rstrip(".")
+    return s + "%"
+
+
+def IQR(x: list[float], type: int = 7) -> float:
+    """The interquartile range."""
+    q = quantile(x, [0.25, 0.75], type)
+    return q[1] - q[0]
+
+
+def mad(x: list[float], constant: float = 1.4826) -> float:
+    """The median absolute deviation (scaled to estimate σ of normal data)."""
+    m = median(x)
+    return constant * median([abs(v - m) for v in x])
+
+
+def fivenum(x: list[float]) -> list[float]:
+    """Tukey's five numbers: minimum, lower hinge, median, upper hinge, maximum."""
+    _check(x)
+    s = sorted(x)
+    n = len(s)
+    n4 = float(math.floor((float(n) + 3.0) / 2.0)) / 2.0
+    d = [1.0, n4, (float(n) + 1.0) / 2.0, float(n) + 1.0 - n4, float(n)]
+    out: list[float] = []
+    for v in d:
+        lo = int(math.floor(v))
+        hi = int(math.ceil(v))
+        out.append(0.5 * (s[lo - 1] + s[hi - 1]))
+    return out
+
+
+def scale(x: list[float]) -> list[float]:
+    """x centered by its mean and divided by its standard deviation."""
+    m = mean(x)
+    s = sd(x)
+    return [(v - m) / s for v in x]
+
+
+def weighted_mean(x: list[float], w: list[float]) -> float:
+    """The weighted mean."""
+    sw = 0.0
+    swx = 0.0
+    for i in range(len(x)):
+        sw += w[i]
+        swx += w[i] * x[i]
+    return swx / sw
+
+
+class Summary:
+    """`summary(x)` of a numeric vector, printed as R prints it."""
+
+    def __init__(self, values: list[float]) -> None:
+        self.names = ["Min.", "1st Qu.", "Median", "Mean", "3rd Qu.", "Max."]
+        self.values = values
+
+    def __str__(self) -> str:
+        # R's format.summaryDefault: 4 significant digits, after zapping
+        # values tiny next to the largest
+        digits = 4
+        mx = max(abs(v) for v in self.values)
+        zap = [v for v in self.values]
+        if mx > 0.0:
+            lim = 10.0 ** (float(math.floor(math.log10(mx))) - 7.0 - digits + 1.0)
+            zap = [0.0 if abs(v) < lim else v for v in self.values]
+        return print_named(self.names, format_vec(zap, digits))
+
+    def __repr__(self) -> str:
+        return self.__str__()
+
+    def get(self, name: str) -> float:
+        return self.values[self.names.index(name)]
+
+
+def summary(x: list[float]) -> Summary:
+    """Minimum, quartiles, mean and maximum (R's `summary` of a numeric vector)."""
+    q = quantile(x)
+    return Summary([q[0], q[1], q[2], mean(x), q[3], q[4]])
+
+
+def range_(x: list[float]) -> list[float]:
+    """`range(x)`: the minimum and the maximum."""
+    return [min(x), max(x)]
+
+
+def round_(x: float, digits: int = 0) -> float:
+    """R's `round` (to even, at the decimal digit)."""
+    return round(x, digits)
+
+
+def signif_(x: float, digits: int = 6) -> float:
+    """R's `signif`."""
+    return signif(x, digits)