scitex 2.0.0__py2.py3-none-any.whl

scitex/stats/tests/_brunner_munzel_test.py

@@ -0,0 +1,192 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-10-07 22:30:46 (ywatanabe)"
+# File: /home/ywatanabe/proj/_scitex_repo_openhands/src/scitex/stats/_brunner_munzel_test.py
+
+"""
+1. Functionality:
+   - Calculates Brunner-Munzel test scores for two independent samples
+2. Input:
+   - Two arrays of numeric data values
+3. Output:
+   - Dictionary containing test results (w_statistic, p_value, sample sizes, degrees of freedom, effect size, test name, and null hypothesis)
+4. Prerequisites:
+   - NumPy, SciPy
+"""
+
+"""Imports"""
+import numpy as np
+from scipy import stats
+import pandas as pd
+import xarray as xr
+import torch
+from typing import (
+    List,
+    Tuple,
+    Dict,
+    Any,
+    Union,
+    Sequence,
+    Literal,
+    Iterable,
+)
+from ...types import ArrayLike
+from ...decorators import numpy_fn
+
+
+@numpy_fn
+def brunner_munzel_test(
+    x1: ArrayLike,
+    x2: ArrayLike,
+    distribution: str = "t",
+    round_factor: int = 3,
+) -> Dict[str, Union[float, int, str]]:
+    """
+    Calculate Brunner-Munzel test scores.
+
+    Parameters
+    ----------
+    x1 : ArrayLike
+        Numeric data values from sample 1.
+    x2 : ArrayLike
+        Numeric data values from sample 2.
+    distribution : str, optional
+        Distribution to use for the test. Can be "t" or "normal" (default is "t").
+    round_factor : int, optional
+        Number of decimal places to round the results (default is 3).
+
+    Returns
+    -------
+    Dict[str, Union[float, int, str]]
+        Dictionary containing test results including w_statistic, p_value, sample sizes, degrees of freedom, effect size, test name, and null hypothesis.
+
+    Example
+    -------
+    >>> np.random.seed(42)
+    >>> xx = np.random.rand(100)
+    >>> yy = np.random.rand(100) + 0.1
+    >>> result = brunner_munzel_test(xx, yy)
+    >>> print(result)
+    {'w_statistic': -2.089, 'p_value': 0.038, 'n1': 100, 'n2': 100, 'dof': 197.0, 'effsize': 0.438, 'test_name': 'Brunner-Munzel test', 'H0': 'The probability that a randomly selected value from one population is greater than a randomly selected value from the other population is equal to 0.5'}
+    """
+    if distribution not in ["t", "normal"]:
+        raise ValueError("Distribution must be either 't' or 'normal'")
+
+    x1, x2 = np.asarray(x1).astype(float), np.asarray(x2).astype(float)
+    x1, x2 = x1[~np.isnan(x1)], x2[~np.isnan(x2)]
+    n1, n2 = len(x1), len(x2)
+
+    if n1 == 0 or n2 == 0:
+        raise ValueError("Input arrays must not be empty after removing NaN values")
+
+    R = stats.rankdata(np.concatenate([x1, x2]))
+    R1, R2 = R[:n1], R[n1:]
+    r1_mean, r2_mean = np.mean(R1), np.mean(R2)
+    Ri1, Ri2 = stats.rankdata(x1), stats.rankdata(x2)
+    var1 = np.var(R1 - Ri1, ddof=1)
+    var2 = np.var(R2 - Ri2, ddof=1)
+
+    w_statistic = ((n1 * n2) * (r2_mean - r1_mean)) / (
+        (n1 + n2) * np.sqrt(n1 * var1 + n2 * var2)
+    )
+
+    if distribution == "t":
+        dof = (n1 * var1 + n2 * var2) ** 2 / (
+            (n1 * var1) ** 2 / (n1 - 1) + (n2 * var2) ** 2 / (n2 - 1)
+        )
+        c = stats.t.cdf(abs(w_statistic), dof) if not np.isinf(w_statistic) else 0.0
+    else:
+        dof = np.nan
+        c = stats.norm.cdf(abs(w_statistic)) if not np.isinf(w_statistic) else 0.0
+
+    p_value = min(c, 1.0 - c) * 2.0
+    effsize = (r2_mean - r1_mean) / (n1 + n2) + 0.5
+
+    return {
+        "w_statistic": round(w_statistic, round_factor),
+        "p_value": round(p_value, round_factor),
+        "n1": n1,
+        "n2": n2,
+        "dof": round(dof, round_factor),
+        "effsize": round(effsize, round_factor),
+        "test_name": "Brunner-Munzel test",
+        "H0": "The probability that a randomly selected value from one population is greater than a randomly selected value from the other population is equal to 0.5",
+    }
+
+
+# #!/usr/bin/env python3
+
+# import numpy as np
+# from scipy import stats
+
+
+# def brunner_munzel_test(x1, x2, distribution="t", round_factor=3):
+#     """Calculate Brunner-Munzel-test scores.
+#     Parameters:
+#       x1, x2: array_like
+#         Numeric data values from sample 1, 2.
+#     Returns:
+#       w:
+#         Calculated test statistic.
+#       p_value:
+#         Two-tailed p-value of test.
+#       dof:
+#         Degree of freedom.
+#       p:
+#         "P(x1 < x2) + 0.5 P(x1 = x2)" estimates.
+#     References:
+#       * https://oku.edu.mie-u.ac.jp/~okumura/stat/brunner-munzel.html
+#     Example:
+#       When sample number N is small, distribution='t' is recommended.
+#       d1 = np.array([1,2,1,1,1,1,1,1,1,1,2,4,1,1])
+#       d2 = np.array([3,3,4,3,1,2,3,1,1,5,4])
+#       print(bmtest(d1, d2, distribution='t'))
+#       print(bmtest(d1, d2, distribution='normal'))
+#       When sample number N is large, distribution='normal' is recommended; however,
+#       't' and 'normal' yield almost the same result.
+#       d1 = np.random.rand(1000)*100
+#       d2 = np.random.rand(10000)*110
+#       print(bmtest(d1, d2, distribution='t'))
+#       print(bmtest(d1, d2, distribution='normal'))
+#     """
+
+#     x1, x2 = np.hstack(x1), np.hstack(x2)
+#     x1, x2 = x1[~np.isnan(x1)], x2[~np.isnan(x2)]
+#     n1, n2 = len(x1), len(x2)
+#     R = stats.rankdata(list(x1) + list(x2))
+#     R1, R2 = R[:n1], R[n1:]
+#     r1_mean, r2_mean = np.mean(R1), np.mean(R2)
+#     Ri1, Ri2 = stats.rankdata(x1), stats.rankdata(x2)
+#     var1 = np.var([r - ri for r, ri in zip(R1, Ri1)], ddof=1)
+#     var2 = np.var([r - ri for r, ri in zip(R2, Ri2)], ddof=1)
+#     w_statistic = ((n1 * n2) * (r2_mean - r1_mean)) / (
+#         (n1 + n2) * np.sqrt(n1 * var1 + n2 * var2)
+#     )
+#     if distribution == "t":
+#         dof = (n1 * var1 + n2 * var2) ** 2 / (
+#             (n1 * var1) ** 2 / (n1 - 1) + (n2 * var2) ** 2 / (n2 - 1)
+#         )
+#         c = (
+#             stats.t.cdf(abs(w_statistic), dof)
+#             if not np.isinf(w_statistic)
+#             else 0.0
+#         )
+#     if distribution == "normal":
+#         dof = np.nan
+#         c = (
+#             stats.norm.cdf(abs(w_statistic))
+#             if not np.isinf(w_statistic)
+#             else 0.0
+#         )
+#     p_value = min(c, 1.0 - c) * 2.0
+#     effsize = (r2_mean - r1_mean) / (n1 + n2) + 0.5
+#     return dict(
+#         w_statistic=round(w_statistic, round_factor),
+#         p_value=round(p_value, round_factor),
+#         n1=n1,
+#         n2=n2,
+#         dof=round(dof, round_factor),
+#         effsize=round(effsize, round_factor),
+#         test_name="Brunner-Munzel test",
+#         H0="The probability that a randomly selected value from one population is greater than a randomly selected value from the other population is equal to 0.5",
+#     )

scitex/stats/tests/_nocorrelation_test.py

@@ -0,0 +1,28 @@
+#!/usr/bin/env python3
+
+import numpy as np
+from scipy import stats
+
+
+def calc_partial_corrcoef(x, y, z):
+    """remove the influence of the variable z from the correlation between x and y."""
+    r_xy = np.corrcoef(x, y)
+    r_xz = np.corrcoef(x, z)
+    r_yz = np.corrcoef(y, z)
+    r_xy_z = (r_xy - r_xz * r_yz) / (1 - r_xz**2) * (1 - r_yz**2)
+    return r_xy_z
+
+
+def nocorrelation_test(x, y, z=None, alpha=0.05):
+    if z is None:
+        r = np.corrcoef(x, y)[1, 0]
+    if z is not None:
+        r = calc_partial_corrcoef(x, y, z)[1, 0]
+
+    n = len(x)
+    df = n - 2
+    # t = np.abs(np.array(r)) * np.sqrt((df) / (1 - np.array(r)**2))
+    t = np.abs(r) * np.sqrt((df) / (1 - r**2))
+    # t_alpha = scipy.stats.t.ppf(1 - alpha / 2, df)
+    p_value = 2 * (1 - stats.t.cdf(t, df))
+    return r, t, p_value

scitex/stats/tests/_smirnov_grubbs.py

@@ -0,0 +1,98 @@
+import numpy as np
+from scipy import stats
+
+
+def smirnov_grubbs(data_arr, alpha=0.05):
+    """
+    Find outliers based on Smirnov-Grubbs test.
+
+    Arguments:
+
+    Returns | indices of outliers
+    """
+    data_1D_sorted = sorted(np.array(data_arr).reshape(-1))
+    in_data, out_data = list(data_1D_sorted), []
+
+    # while True:
+    n = len(in_data)
+    for i_data in range(n):
+        n = len(in_data)
+        t = stats.t.isf(q=(alpha / n) / 2, df=n - 2)
+        tau = (n - 1) * t / np.sqrt(n * (n - 2) + n * t * t)
+        i_min, i_max = np.argmin(in_data), np.argmax(in_data)
+        mu, std = np.mean(in_data), np.std(in_data, ddof=1)
+
+        i_far = (
+            i_max
+            if np.abs(in_data[i_max] - mu) > np.abs(in_data[i_min] - mu)
+            else i_min
+        )
+
+        tau_far = np.abs((in_data[i_far] - mu) / std)
+
+        if tau_far < tau:
+            break
+
+        out_data.append(in_data.pop(i_far))
+
+    if len(out_data) == 0:
+        return None
+
+    else:
+        out_data_uq = np.unique(out_data)
+        indi_outliers = np.hstack(
+            [
+                np.vstack(np.where(data_arr == out_data_uq[i_out])).T
+                for i_out in range(len(out_data_uq))
+            ]
+        ).squeeze()
+
+        if indi_outliers.ndim == 0:
+            indi_outliers = indi_outliers[np.newaxis]
+        return indi_outliers
+
+
+# def smirnov_grubbs(data_arr, alpha=0.05):
+#     """
+#     Find outliers based on Smirnov-Grubbs test.
+
+#     Arguments:
+
+#     Returns | indices of outliers
+#     """
+#     data_1D_sorted = sorted(np.array(data_arr).reshape(-1))
+#     in_data, out_data = list(data_1D_sorted), []
+
+#     while True:
+#         n = len(in_data)
+#         t = stats.t.isf(q=(alpha / n) / 2, df=n - 2)
+#         tau = (n - 1) * t / np.sqrt(n * (n - 2) + n * t * t)
+#         i_min, i_max = np.argmin(in_data), np.argmax(in_data)
+#         mu, std = np.mean(in_data), np.std(in_data, ddof=1)
+
+#         i_far = (
+#             i_max
+#             if np.abs(in_data[i_max] - mu) > np.abs(in_data[i_min] - mu)
+#             else i_min
+#         )
+
+#         tau_far = np.abs((in_data[i_far] - mu) / std)
+
+#         if tau_far < tau:
+#             break
+
+#         out_data.append(in_data.pop(i_far))
+
+#     if len(out_data) == 0:
+#         return None
+
+#     else:
+#         out_data_uq = np.unique(out_data)
+#         indi_outliers = np.vstack(
+#             [
+#                 np.vstack(np.where(data_arr == out_data_uq[i_out])).T
+#                 for i_out in range(len(out_data_uq))
+#             ]
+#         )
+
+#         return np.array(indi_outliers).squeeze()

scitex/str/__init__.py

@@ -0,0 +1,113 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-06-13 22:55:11 (ywatanabe)"
+# File: /ssh:sp:/home/ywatanabe/proj/SciTeX-Code/src/scitex/str/__init__.py
+# ----------------------------------------
+import os
+__FILE__ = (
+    "./src/scitex/str/__init__.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+"""Scitex str module."""
+
+from ._clean_path import clean_path
+from ._color_text import color_text, ct
+from ._decapitalize import decapitalize
+from ._factor_out_digits import (
+    auto_factor_axis,
+    factor_out_digits,
+    smart_tick_formatter,
+)
+from ._format_plot_text import (
+    axis_label,
+    check_unit_consistency,
+    format_axis_label,
+    format_plot_text,
+    format_title,
+    scientific_text,
+    title,
+)
+from ._grep import grep
+from ._latex import (
+    add_hat_in_latex_style,
+    hat_latex_style,
+    latex_style,
+    safe_add_hat_in_latex_style,
+    safe_to_latex_style,
+    to_latex_style,
+)
+from ._latex_fallback import (
+    LaTeXFallbackError,
+    check_latex_capability,
+    disable_latex_fallback,
+    enable_latex_fallback,
+    get_fallback_mode,
+    get_latex_status,
+    latex_fallback_decorator,
+    latex_to_mathtext,
+    latex_to_unicode,
+    logger,
+    reset_latex_cache,
+    safe_latex_render,
+    set_fallback_mode,
+)
+from ._mask_api import mask_api
+from ._mask_api_key import mask_api
+from ._parse import parse
+from ._print_block import printc
+from ._print_debug import print_debug
+from ._printc import printc
+from ._readable_bytes import readable_bytes
+from ._remove_ansi import remove_ansi
+from ._replace import replace
+from ._search import search
+from ._squeeze_space import squeeze_spaces
+
+__all__ = [
+    "LaTeXFallbackError",
+    "add_hat_in_latex_style",
+    "auto_factor_axis",
+    "axis_label",
+    "check_latex_capability",
+    "check_unit_consistency",
+    "clean_path",
+    "color_text",
+    "ct",
+    "decapitalize",
+    "disable_latex_fallback",
+    "enable_latex_fallback",
+    "factor_out_digits",
+    "format_axis_label",
+    "format_plot_text",
+    "format_title",
+    "get_fallback_mode",
+    "get_latex_status",
+    "grep",
+    "hat_latex_style",
+    "latex_fallback_decorator",
+    "latex_style",
+    "latex_to_mathtext",
+    "latex_to_unicode",
+    "logger",
+    "mask_api",
+    "parse",
+    "print_debug",
+    "printc",
+    "readable_bytes",
+    "remove_ansi",
+    "replace",
+    "reset_latex_cache",
+    "safe_add_hat_in_latex_style",
+    "safe_latex_render",
+    "safe_to_latex_style",
+    "scientific_text",
+    "search",
+    "set_fallback_mode",
+    "smart_tick_formatter",
+    "squeeze_spaces",
+    "title",
+    "to_latex_style",
+]
+
+# EOF

scitex/str/_clean_path.py

@@ -0,0 +1,75 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-02-14 22:07:13 (ywatanabe)"
+# File: ./src/scitex/str/_clean_path.py
+
+THIS_FILE = "/home/ywatanabe/proj/scitex_repo/src/scitex/str/_clean_path.py"
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2025-02-14 22:07:13 (ywatanabe)"
+# File: ./scitex_repo/src/scitex/str/_clean_path.py
+
+THIS_FILE = "/home/ywatanabe/proj/scitex_repo/src/scitex/str/_clean_path.py"
+
+"""
+Functionality:
+    - Cleans and normalizes file system paths
+Input:
+    - File path string containing redundant separators or current directory references
+Output:
+    - Cleaned path string with normalized separators
+Prerequisites:
+    - Python's os.path module
+"""
+
+"""Imports"""
+import os
+
+"""Functions & Classes"""
+
+
+def clean_path(path_string: str) -> str:
+    """Cleans and normalizes a file system path string.
+
+    Example
+    -------
+    >>> clean('/home/user/./folder/../file.txt')
+    '/home/user/file.txt'
+    >>> clean('path/./to//file.txt')
+    'path/to/file.txt'
+
+    Parameters
+    ----------
+    path_string : str
+        File path to clean
+
+    Returns
+    -------
+    str
+        Normalized path string
+    """
+    try:
+        is_directory = path_string.endswith("/")
+
+        if not isinstance(path_string, str):
+            raise TypeError("Input must be a string")
+
+        if path_string.startswith('f"'):
+            path_string = path_string.replace('f"', "")[:-1]
+
+        # Normalize path separators
+        cleaned_path = os.path.normpath(path_string)
+
+        # Remove redundant separators
+        cleaned_path = os.path.normpath(cleaned_path)
+
+        if is_directory and (not cleaned_path.endswith("/")):
+            cleaned_path += "/"
+
+        return cleaned_path
+
+    except Exception as error:
+        raise ValueError(f"Path cleaning failed: {str(error)}")
+
+
+# EOF

scitex/str/_color_text.py

@@ -0,0 +1,52 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-11-02 04:00:36 (ywatanabe)"
+# File: ./scitex_repo/src/scitex/gen/_color_text.py
+
+
+def color_text(text, c="green"):
+    """Apply ANSI color codes to text.
+
+    Parameters
+    ----------
+    text : str
+        The text to be colored.
+    c : str, optional
+        The color to apply. Available colors are 'red', 'green', 'yellow',
+        'blue', 'magenta', 'cyan', 'white', and 'grey' (default is "green").
+
+    Returns
+    -------
+    str
+        The input text with ANSI color codes applied.
+
+    Example
+    -------
+    >>> print(color_text("Hello, World!", "blue"))
+    # This will print "Hello, World!" in blue text
+    """
+    ANSI_COLORS = {
+        "red": "\033[91m",
+        "green": "\033[92m",
+        "yellow": "\033[93m",
+        "blue": "\033[94m",
+        "magenta": "\033[95m",
+        "cyan": "\033[96m",
+        "white": "\033[97m",
+        "grey": "\033[90m",
+        "gray": "\033[90m",
+        "reset": "\033[0m",
+    }
+    ANSI_COLORS["tra"] = ANSI_COLORS["white"]
+    ANSI_COLORS["val"] = ANSI_COLORS["green"]
+    ANSI_COLORS["tes"] = ANSI_COLORS["red"]
+
+    start_code = ANSI_COLORS.get(c, ANSI_COLORS["reset"])
+    end_code = ANSI_COLORS["reset"]
+    return f"{start_code}{text}{end_code}"
+
+
+ct = color_text
+
+
+# EOF

scitex/str/_decapitalize.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-11-02 11:25:00 (ywatanabe)"
+# File: ./scitex_repo/src/scitex/str/_decapitalize.py
+
+"""
+Functionality:
+    - Converts first character of string to lowercase
+Input:
+    - String to be processed
+Output:
+    - Modified string with lowercase first character
+Prerequisites:
+    - None
+"""
+
+
+def decapitalize(input_string: str) -> str:
+    """Converts first character of string to lowercase.
+
+    Example
+    -------
+    >>> decapitalize("Hello")
+    'hello'
+    >>> decapitalize("WORLD")
+    'wORLD'
+    >>> decapitalize("")
+    ''
+
+    Parameters
+    ----------
+    input_string : str
+        String to be processed
+
+    Returns
+    -------
+    str
+        Modified string with first character in lowercase
+
+    Raises
+    ------
+    TypeError
+        If input is not a string
+    """
+    try:
+        if not isinstance(input_string, str):
+            raise TypeError("Input must be a string")
+
+        if not input_string:
+            return input_string
+
+        return input_string[0].lower() + input_string[1:]
+
+    except Exception as error:
+        raise ValueError(f"String processing failed: {str(error)}")
+
+
+# EOF