scitex 2.0.0__py2.py3-none-any.whl → 2.1.0__py2.py3-none-any.whl

scitex/stats_v01/_additional_tests.py

@@ -0,0 +1,415 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-07-04 12:05:00 (ywatanabe)"
+# File: ./src/scitex/stats/_additional_tests.py
+
+"""
+Additional statistical tests for comprehensive analysis.
+
+This module provides additional statistical tests commonly used in scientific research,
+with a focus on robust methods and clear interpretations.
+"""
+
+import numpy as np
+from typing import Tuple, Union, Dict, Any, List
+import warnings
+from scipy import stats as scipy_stats
+
+
+def f_oneway(*args) -> Tuple[float, float]:
+    """
+    Perform one-way ANOVA test.
+    
+    NOTE: Consider using Kruskal-Wallis test for non-parametric alternative
+    when normality assumptions are violated.
+    
+    Parameters
+    ----------
+    *args : array_like
+        Sample data arrays. Need at least 2 groups.
+        
+    Returns
+    -------
+    statistic : float
+        The F-statistic
+    pvalue : float
+        The p-value
+        
+    Examples
+    --------
+    >>> from scitex import stats
+    >>> group1 = np.random.normal(0, 1, 100)
+    >>> group2 = np.random.normal(0.5, 1, 100)
+    >>> group3 = np.random.normal(1, 1, 100)
+    >>> f_stat, p = stats.f_oneway(group1, group2, group3)
+    >>> print(f"F-statistic: {f_stat:.4f}, p-value: {p:.4f}")
+    """
+    if len(args) < 2:
+        raise ValueError("Need at least 2 groups for ANOVA")
+    
+    # Use scipy's implementation
+    return scipy_stats.f_oneway(*args)
+
+
+def kruskal(*args) -> Tuple[float, float]:
+    """
+    Perform Kruskal-Wallis H-test (non-parametric alternative to one-way ANOVA).
+    
+    This test is more robust than ANOVA when normality assumptions are violated.
+    
+    Parameters
+    ----------
+    *args : array_like
+        Sample data arrays. Need at least 2 groups.
+        
+    Returns
+    -------
+    statistic : float
+        The Kruskal-Wallis H-statistic
+    pvalue : float
+        The p-value
+        
+    Examples
+    --------
+    >>> from scitex import stats
+    >>> group1 = np.random.exponential(1, 100)  # Non-normal data
+    >>> group2 = np.random.exponential(1.5, 100)
+    >>> group3 = np.random.exponential(2, 100)
+    >>> h_stat, p = stats.kruskal(group1, group2, group3)
+    >>> print(f"H-statistic: {h_stat:.4f}, p-value: {p:.4f}")
+    """
+    if len(args) < 2:
+        raise ValueError("Need at least 2 groups for Kruskal-Wallis test")
+    
+    return scipy_stats.kruskal(*args)
+
+
+def chi2_contingency(observed: np.ndarray, correction: bool = True, 
+                     lambda_: Union[None, float] = None) -> Tuple[float, float, int, np.ndarray]:
+    """
+    Chi-square test of independence of variables in a contingency table.
+    
+    Parameters
+    ----------
+    observed : array_like
+        The contingency table
+    correction : bool, optional
+        If True, apply Yates' correction for continuity
+    lambda_ : float or None, optional
+        The cressie-read power divergence statistic
+        
+    Returns
+    -------
+    chi2 : float
+        The test statistic
+    p : float
+        The p-value of the test
+    dof : int
+        Degrees of freedom
+    expected : ndarray
+        The expected frequencies
+        
+    Examples
+    --------
+    >>> from scitex import stats
+    >>> # Contingency table: treatment vs outcome
+    >>> observed = np.array([[10, 10, 20], [20, 20, 40]])
+    >>> chi2, p, dof, expected = stats.chi2_contingency(observed)
+    >>> print(f"Chi-square: {chi2:.4f}, p-value: {p:.4f}")
+    """
+    return scipy_stats.chi2_contingency(observed, correction=correction, lambda_=lambda_)
+
+
+def shapiro(x: np.ndarray) -> Tuple[float, float]:
+    """
+    Shapiro-Wilk test for normality.
+    
+    Parameters
+    ----------
+    x : array_like
+        Sample data
+        
+    Returns
+    -------
+    statistic : float
+        The test statistic
+    pvalue : float
+        The p-value
+        
+    Examples
+    --------
+    >>> from scitex import stats
+    >>> data = np.random.normal(0, 1, 100)
+    >>> stat, p = stats.shapiro(data)
+    >>> print(f"Shapiro-Wilk statistic: {stat:.4f}, p-value: {p:.4f}")
+    """
+    return scipy_stats.shapiro(x)
+
+
+def pearsonr(x: np.ndarray, y: np.ndarray) -> Tuple[float, float]:
+    """
+    Pearson correlation coefficient and p-value.
+    
+    Parameters
+    ----------
+    x : array_like
+        First variable
+    y : array_like
+        Second variable
+        
+    Returns
+    -------
+    r : float
+        Pearson correlation coefficient
+    pvalue : float
+        Two-tailed p-value
+        
+    Examples
+    --------
+    >>> from scitex import stats
+    >>> x = np.random.normal(0, 1, 100)
+    >>> y = x + np.random.normal(0, 0.5, 100)
+    >>> r, p = stats.pearsonr(x, y)
+    >>> print(f"Pearson r: {r:.4f}, p-value: {p:.4f}")
+    """
+    return scipy_stats.pearsonr(x, y)
+
+
+def spearmanr(x: np.ndarray, y: np.ndarray = None, axis: int = 0, 
+              nan_policy: str = 'propagate') -> Tuple[float, float]:
+    """
+    Spearman rank-order correlation coefficient and p-value.
+    
+    Parameters
+    ----------
+    x : array_like
+        First variable or 2D array
+    y : array_like, optional
+        Second variable (if x is 1D)
+    axis : int, optional
+        Axis along which to compute
+    nan_policy : str, optional
+        How to handle NaN values
+        
+    Returns
+    -------
+    correlation : float
+        Spearman correlation coefficient
+    pvalue : float
+        Two-tailed p-value
+        
+    Examples
+    --------
+    >>> from scitex import stats
+    >>> x = np.random.normal(0, 1, 100)
+    >>> y = x**2 + np.random.normal(0, 0.5, 100)  # Non-linear relationship
+    >>> rho, p = stats.spearmanr(x, y)
+    >>> print(f"Spearman rho: {rho:.4f}, p-value: {p:.4f}")
+    """
+    result = scipy_stats.spearmanr(x, y, axis=axis, nan_policy=nan_policy)
+    if isinstance(result.correlation, np.ndarray):
+        # If 2D input, return correlation matrix and p-value matrix
+        return result.correlation, result.pvalue
+    else:
+        # If 1D input, return scalar values
+        return result.correlation, result.pvalue
+
+
+def sem(a: np.ndarray, axis: int = 0, ddof: int = 1) -> Union[float, np.ndarray]:
+    """
+    Standard error of the mean.
+    
+    Parameters
+    ----------
+    a : array_like
+        Input array
+    axis : int or None, optional
+        Axis along which to compute
+    ddof : int, optional
+        Delta degrees of freedom
+        
+    Returns
+    -------
+    s : float or ndarray
+        Standard error of the mean
+        
+    Examples
+    --------
+    >>> from scitex import stats
+    >>> data = np.random.normal(0, 1, 100)
+    >>> se = stats.sem(data)
+    >>> print(f"Standard error: {se:.4f}")
+    """
+    return scipy_stats.sem(a, axis=axis, ddof=ddof)
+
+
+def trim_mean(a: np.ndarray, proportiontocut: float, axis: int = 0) -> Union[float, np.ndarray]:
+    """
+    Trimmed mean (robust measure of central tendency).
+    
+    Parameters
+    ----------
+    a : array_like
+        Input array
+    proportiontocut : float
+        Proportion to cut from each end (0 to 0.5)
+    axis : int or None, optional
+        Axis along which to compute
+        
+    Returns
+    -------
+    mean : float or ndarray
+        Trimmed mean
+        
+    Examples
+    --------
+    >>> from scitex import stats
+    >>> data = np.concatenate([np.random.normal(0, 1, 90), [10, -10]])  # With outliers
+    >>> mean_trimmed = stats.trim_mean(data, 0.1)  # Trim 10% from each end
+    >>> print(f"Trimmed mean: {mean_trimmed:.4f}")
+    """
+    return scipy_stats.trim_mean(a, proportiontocut, axis=axis)
+
+
+def probplot(x: np.ndarray, sparams=(), dist='norm', fit=True, plot=None):
+    """
+    Probability plot to assess if data follows a distribution.
+    
+    Parameters
+    ----------
+    x : array_like
+        Sample data
+    sparams : tuple, optional
+        Shape parameters for the distribution
+    dist : str or stats.distributions instance, optional
+        Distribution to test against
+    fit : bool, optional
+        If True, fit a line to the data
+    plot : object, optional
+        Plot object with 'plot' method
+        
+    Returns
+    -------
+    (osm, osr) : tuple of ndarrays
+        Ordered statistic medians and ordered response data
+    (slope, intercept, r) : tuple of floats, optional
+        Regression results
+        
+    Examples
+    --------
+    >>> from scitex import stats
+    >>> import matplotlib.pyplot as plt
+    >>> data = np.random.normal(0, 1, 100)
+    >>> stats.probplot(data, plot=plt)
+    >>> plt.show()
+    """
+    return scipy_stats.probplot(x, sparams=sparams, dist=dist, fit=fit, plot=plot)
+
+
+# Statistical distribution objects
+class norm:
+    """Normal distribution utilities."""
+    
+    @staticmethod
+    def ppf(q: Union[float, np.ndarray], loc: float = 0, scale: float = 1) -> Union[float, np.ndarray]:
+        """Percent point function (inverse CDF) for normal distribution."""
+        return scipy_stats.norm.ppf(q, loc=loc, scale=scale)
+    
+    @staticmethod
+    def cdf(x: Union[float, np.ndarray], loc: float = 0, scale: float = 1) -> Union[float, np.ndarray]:
+        """Cumulative distribution function for normal distribution."""
+        return scipy_stats.norm.cdf(x, loc=loc, scale=scale)
+    
+    @staticmethod
+    def pdf(x: Union[float, np.ndarray], loc: float = 0, scale: float = 1) -> Union[float, np.ndarray]:
+        """Probability density function for normal distribution."""
+        return scipy_stats.norm.pdf(x, loc=loc, scale=scale)
+
+
+class t:
+    """Student's t-distribution utilities."""
+    
+    @staticmethod
+    def ppf(q: Union[float, np.ndarray], df: float, loc: float = 0, scale: float = 1) -> Union[float, np.ndarray]:
+        """Percent point function (inverse CDF) for t-distribution."""
+        return scipy_stats.t.ppf(q, df, loc=loc, scale=scale)
+    
+    @staticmethod
+    def cdf(x: Union[float, np.ndarray], df: float, loc: float = 0, scale: float = 1) -> Union[float, np.ndarray]:
+        """Cumulative distribution function for t-distribution."""
+        return scipy_stats.t.cdf(x, df, loc=loc, scale=scale)
+    
+    @staticmethod
+    def pdf(x: Union[float, np.ndarray], df: float, loc: float = 0, scale: float = 1) -> Union[float, np.ndarray]:
+        """Probability density function for t-distribution."""
+        return scipy_stats.t.pdf(x, df, loc=loc, scale=scale)
+
+
+class chi2:
+    """Chi-square distribution utilities."""
+    
+    @staticmethod
+    def ppf(q: Union[float, np.ndarray], df: float, loc: float = 0, scale: float = 1) -> Union[float, np.ndarray]:
+        """Percent point function (inverse CDF) for chi-square distribution."""
+        return scipy_stats.chi2.ppf(q, df, loc=loc, scale=scale)
+    
+    @staticmethod
+    def cdf(x: Union[float, np.ndarray], df: float, loc: float = 0, scale: float = 1) -> Union[float, np.ndarray]:
+        """Cumulative distribution function for chi-square distribution."""
+        return scipy_stats.chi2.cdf(x, df, loc=loc, scale=scale)
+
+
+class nct:
+    """Non-central t-distribution utilities."""
+    
+    @staticmethod
+    def cdf(x: Union[float, np.ndarray], df: float, nc: float, loc: float = 0, scale: float = 1) -> Union[float, np.ndarray]:
+        """Cumulative distribution function for non-central t-distribution."""
+        return scipy_stats.nct.cdf(x, df, nc, loc=loc, scale=scale)
+
+
+# Multiple testing correction utilities
+class multitest:
+    """Multiple testing correction methods."""
+    
+    @staticmethod
+    def multipletests(pvals: np.ndarray, alpha: float = 0.05, method: str = 'fdr_bh',
+                      is_sorted: bool = False, returnsorted: bool = False):
+        """
+        Multiple testing p-value correction.
+        
+        Parameters
+        ----------
+        pvals : array_like
+            Uncorrected p-values
+        alpha : float
+            Family-wise error rate
+        method : str
+            Correction method ('bonferroni', 'fdr_bh', 'fdr_by', etc.)
+        is_sorted : bool
+            If True, pvals are already sorted
+        returnsorted : bool
+            If True, return sorted p-values
+            
+        Returns
+        -------
+        reject : ndarray, bool
+            True if hypothesis is rejected after correction
+        pvals_corrected : ndarray
+            Corrected p-values
+        alphacSidak : float
+            Sidak corrected alpha
+        alphacBonf : float
+            Bonferroni corrected alpha
+        """
+        from statsmodels.stats.multitest import multipletests as sm_multipletests
+        return sm_multipletests(pvals, alpha=alpha, method=method, 
+                                is_sorted=is_sorted, returnsorted=returnsorted)
+
+
+# Aliases for common use
+anova = f_oneway
+chisquare = chi2_contingency
+
+
+# EOF

scitex/{stats → stats_v01}/_p2stars.py

@@ -1,10 +1,18 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
+# Timestamp: "2025-09-29 13:43:40 (ywatanabe)"
+# File: /ssh:sp:/home/ywatanabe/proj/scitex_repo/src/scitex/stats/_p2stars.py
+# ----------------------------------------
+from __future__ import annotations
+import os
+__FILE__ = __file__
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
 # Time-stamp: "2024-10-06 10:39:57 (ywatanabe)"
 
+from typing import Union
+
 import pandas as pd
-import re
-from typing import Union, List
 
 
 def p2stars(
@@ -47,7 +55,9 @@ def p2stars(
     elif isinstance(input_data, pd.DataFrame):
         return _p2stars_pd(input_data, ns)
     else:
-        raise ValueError("Input must be a float, string, or a pandas DataFrame")
+        raise ValueError(
+            "Input must be a float, string, or a pandas DataFrame"
+        )
 
 
 def _p2stars_str(pvalue: Union[float, str], ns: bool = False) -> str:
@@ -58,7 +68,9 @@ def _p2stars_str(pvalue: Union[float, str], ns: bool = False) -> str:
                 return "NA"
         pvalue_float = float(pvalue)
         if pvalue_float < 0 or pvalue_float > 1:
-            raise ValueError(f"P-value must be between 0 and 1, got {pvalue_float}")
+            raise ValueError(
+                f"P-value must be between 0 and 1, got {pvalue_float}"
+            )
     except ValueError as e:
         raise ValueError(f"Invalid p-value: {pvalue}. {str(e)}")
 
@@ -73,7 +85,7 @@ def _p2stars_str(pvalue: Union[float, str], ns: bool = False) -> str:
 
 
 def _p2stars_pd(df: pd.DataFrame, ns: bool = False) -> pd.DataFrame:
-    from scitex.stats import find_pval
+    from scitex.pd import find_pval
 
     pvalue_cols = find_pval(df, multiple=True)
     assert pvalue_cols, "No p-value columns found in DataFrame"
@@ -114,3 +126,5 @@ def _p2stars_pd(df: pd.DataFrame, ns: bool = False) -> pd.DataFrame:
 #         List of column names that likely contain p-values
 #     """
 #     return [col for col in df.columns if re.search(r'p[_.-]?val', col.lower())]
+
+# EOF

scitex/stats_v01/_two_sample_tests.py

@@ -0,0 +1,141 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-07-04 12:00:00 (ywatanabe)"
+# File: ./src/scitex/stats/_two_sample_tests.py
+
+"""
+Two-sample statistical tests with Brunner-Munzel as the preferred method.
+
+This module provides robust two-sample tests, prioritizing the Brunner-Munzel test
+over traditional t-tests due to its superior robustness to assumption violations.
+"""
+
+import numpy as np
+from typing import Tuple, Union, Dict, Any
+import warnings
+
+
+def ttest_ind(a: np.ndarray, b: np.ndarray, equal_var: bool = True) -> Tuple[float, float]:
+    """
+    Perform two-sample test using Brunner-Munzel test (more robust than t-test).
+    
+    NOTE: This function uses Brunner-Munzel test instead of traditional t-test
+    for better robustness. The Brunner-Munzel test is valid under less restrictive
+    assumptions and provides better Type I error control.
+    
+    Parameters
+    ----------
+    a : array_like
+        First sample
+    b : array_like  
+        Second sample
+    equal_var : bool, optional
+        Ignored. Kept for API compatibility with scipy.stats.ttest_ind
+        
+    Returns
+    -------
+    statistic : float
+        The test statistic
+    pvalue : float
+        Two-sided p-value
+        
+    Examples
+    --------
+    >>> from scitex import stats
+    >>> group1 = np.random.normal(0, 1, 100)
+    >>> group2 = np.random.normal(0.5, 1, 100)
+    >>> stat, p = stats.ttest_ind(group1, group2)
+    >>> print(f"Statistic: {stat:.4f}, p-value: {p:.4f}")
+    """
+    warnings.warn(
+        "Using Brunner-Munzel test instead of t-test for better robustness. "
+        "To use traditional t-test, use scipy.stats.ttest_ind directly.",
+        UserWarning
+    )
+    
+    from ._statistical_tests import brunner_munzel_test
+    
+    result = brunner_munzel_test(a, b)
+    return result["statistic"], result["p_value"]
+
+
+def brunner_munzel(a: np.ndarray, b: np.ndarray) -> Tuple[float, float]:
+    """
+    Perform Brunner-Munzel test for two independent samples.
+    
+    The Brunner-Munzel test is a robust alternative to the Mann-Whitney U test
+    and t-test that doesn't assume equal variances or specific distributions.
+    
+    Parameters
+    ----------
+    a : array_like
+        First sample
+    b : array_like
+        Second sample
+        
+    Returns
+    -------
+    statistic : float
+        The test statistic
+    pvalue : float
+        Two-sided p-value
+        
+    Examples
+    --------
+    >>> from scitex import stats
+    >>> group1 = np.random.normal(0, 1, 100)
+    >>> group2 = np.random.normal(0.5, 2, 100)  # Different variance
+    >>> stat, p = stats.brunner_munzel(group1, group2)
+    >>> print(f"Brunner-Munzel statistic: {stat:.4f}, p-value: {p:.4f}")
+    """
+    from ._statistical_tests import brunner_munzel_test
+    
+    result = brunner_munzel_test(a, b)
+    return result["statistic"], result["p_value"]
+
+
+def mannwhitneyu(x: np.ndarray, y: np.ndarray, use_continuity: bool = True, 
+                 alternative: str = 'two-sided') -> Tuple[float, float]:
+    """
+    Perform two-sample test using Brunner-Munzel (more robust than Mann-Whitney U).
+    
+    NOTE: This function uses Brunner-Munzel test for better robustness.
+    The Brunner-Munzel test handles tied values and unequal variances better
+    than the traditional Mann-Whitney U test.
+    
+    Parameters
+    ----------
+    x : array_like
+        First sample
+    y : array_like
+        Second sample  
+    use_continuity : bool, optional
+        Ignored. Kept for API compatibility
+    alternative : str, optional
+        Ignored. Always performs two-sided test
+        
+    Returns
+    -------
+    statistic : float
+        The test statistic
+    pvalue : float
+        Two-sided p-value
+    """
+    warnings.warn(
+        "Using Brunner-Munzel test instead of Mann-Whitney U for better robustness. "
+        "To use traditional Mann-Whitney U, use scipy.stats.mannwhitneyu directly.",
+        UserWarning
+    )
+    
+    from ._statistical_tests import brunner_munzel_test
+    
+    result = brunner_munzel_test(x, y)
+    return result["statistic"], result["p_value"]
+
+
+# Aliases for convenience
+ttest = ttest_ind
+bm_test = brunner_munzel
+
+
+# EOF

scitex/stats_v01/desc/__init__.py

@@ -0,0 +1,83 @@
+#!/usr/bin/env python3
+"""Scitex desc module."""
+
+from ._describe import describe, verify_non_leakage
+from ._nan import (
+    nanargmax,
+    nanargmin,
+    nancount,
+    nancumprod,
+    nancumsum,
+    nankurtosis,
+    nanmax,
+    nanmean,
+    nanmin,
+    nanprod,
+    nanq25,
+    nanq50,
+    nanq75,
+    nanquantile,
+    nanskewness,
+    nanstd,
+    nansum,
+    nanvar,
+    nanzscore,
+)
+from ._real import (
+    kurtosis,
+    mean,
+    q25,
+    q50,
+    q75,
+    quantile,
+    skewness,
+    std,
+    var,
+    zscore,
+)
+from ._circular import (
+    circular_mean,
+    circular_concentration,
+    circular_skewness,
+    circular_kurtosis,
+    describe_circular,
+)
+
+__all__ = [
+    "describe",
+    "kurtosis",
+    "mean",
+    "nanargmax",
+    "nanargmin",
+    "nancount",
+    "nancumprod",
+    "nancumsum",
+    "nankurtosis",
+    "nanmax",
+    "nanmean",
+    "nanmin",
+    "nanprod",
+    "nanq25",
+    "nanq50",
+    "nanq75",
+    "nanquantile",
+    "nanskewness",
+    "nanstd",
+    "nansum",
+    "nanvar",
+    "nanzscore",
+    "q25",
+    "q50",
+    "q75",
+    "quantile",
+    "skewness",
+    "std",
+    "var",
+    "verify_non_leakage",
+    "zscore",
+    "circular_mean",
+    "circular_concentration",
+    "circular_skewness",
+    "circular_kurtosis",
+    "describe_circular",
+]