scitex 2.5.0__py3-none-any.whl → 2.7.0__py3-none-any.whl

scitex/stats/posthoc/_games_howell.py

@@ -5,6 +5,7 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
+
 __FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
@@ -62,7 +63,7 @@ def welch_satterthwaite_df(var_i: float, n_i: int, var_j: float, n_j: int) -> fl
     s_j_sq_n_j = var_j / n_j
 
     numerator = (s_i_sq_n_i + s_j_sq_n_j) ** 2
-    denominator = (s_i_sq_n_i ** 2) / (n_i - 1) + (s_j_sq_n_j ** 2) / (n_j - 1)
+    denominator = (s_i_sq_n_i**2) / (n_i - 1) + (s_j_sq_n_j**2) / (n_j - 1)
 
     if denominator == 0:
         return n_i + n_j - 2
@@ -75,7 +76,7 @@ def posthoc_games_howell(
     groups: List[Union[np.ndarray, pd.Series]],
     group_names: Optional[List[str]] = None,
     alpha: float = 0.05,
-    return_as: str = 'dataframe'
+    return_as: str = "dataframe",
 ) -> Union[pd.DataFrame, List[dict]]:
     """
     Perform Games-Howell post-hoc test for pairwise comparisons.
@@ -191,7 +192,7 @@ def posthoc_games_howell(
 
     # Group names
     if group_names is None:
-        group_names = [f'Group {i+1}' for i in range(k)]
+        group_names = [f"Group {i + 1}" for i in range(k)]
 
     if len(group_names) != k:
         raise ValueError(f"Expected {k} group names, got {len(group_names)}")
@@ -244,29 +245,31 @@ def posthoc_games_howell(
             ci_lower = mean_diff - margin
             ci_upper = mean_diff + margin
 
-            results.append({
-                'group_i': group_names[i],
-                'group_j': group_names[j],
-                'n_i': n_i,
-                'n_j': n_j,
-                'mean_i': round(float(mean_i), 3),
-                'mean_j': round(float(mean_j), 3),
-                'var_i': round(float(var_i), 3),
-                'var_j': round(float(var_j), 3),
-                'mean_diff': round(float(mean_diff), 3),
-                'std_error': round(float(se), 3),
-                't_statistic': round(float(t_stat), 3),
-                'df': round(float(df), 2),
-                'pvalue': round(float(pvalue), 4),
-                'significant': bool(significant),
-                'pstars': p2stars(pvalue),
-                'ci_lower': round(float(ci_lower), 3),
-                'ci_upper': round(float(ci_upper), 3),
-                'alpha': alpha,
-            })
+            results.append(
+                {
+                    "group_i": group_names[i],
+                    "group_j": group_names[j],
+                    "n_i": n_i,
+                    "n_j": n_j,
+                    "mean_i": round(float(mean_i), 3),
+                    "mean_j": round(float(mean_j), 3),
+                    "var_i": round(float(var_i), 3),
+                    "var_j": round(float(var_j), 3),
+                    "mean_diff": round(float(mean_diff), 3),
+                    "std_error": round(float(se), 3),
+                    "t_statistic": round(float(t_stat), 3),
+                    "df": round(float(df), 2),
+                    "pvalue": round(float(pvalue), 4),
+                    "significant": bool(significant),
+                    "pstars": p2stars(pvalue),
+                    "ci_lower": round(float(ci_lower), 3),
+                    "ci_upper": round(float(ci_upper), 3),
+                    "alpha": alpha,
+                }
+            )
 
     # Return format
-    if return_as == 'dataframe':
+    if return_as == "dataframe":
         return pd.DataFrame(results)
     else:
         return results
@@ -300,20 +303,27 @@ if __name__ == "__main__":
     logger.info("-" * 70)
 
     np.random.seed(42)
-    group1 = np.random.normal(10, 1, 20)   # Small variance
-    group2 = np.random.normal(12, 5, 25)   # Large variance
-    group3 = np.random.normal(11, 2, 15)   # Medium variance
+    group1 = np.random.normal(10, 1, 20)  # Small variance
+    group2 = np.random.normal(12, 5, 25)  # Large variance
+    group3 = np.random.normal(11, 2, 15)  # Medium variance
 
-    logger.info(f"Group 1: mean={np.mean(group1):.2f}, var={np.var(group1, ddof=1):.2f}, n={len(group1)}")
-    logger.info(f"Group 2: mean={np.mean(group2):.2f}, var={np.var(group2, ddof=1):.2f}, n={len(group2)}")
-    logger.info(f"Group 3: mean={np.mean(group3):.2f}, var={np.var(group3, ddof=1):.2f}, n={len(group3)}")
+    logger.info(
+        f"Group 1: mean={np.mean(group1):.2f}, var={np.var(group1, ddof=1):.2f}, n={len(group1)}"
+    )
+    logger.info(
+        f"Group 2: mean={np.mean(group2):.2f}, var={np.var(group2, ddof=1):.2f}, n={len(group2)}"
+    )
+    logger.info(
+        f"Group 3: mean={np.mean(group3):.2f}, var={np.var(group3, ddof=1):.2f}, n={len(group3)}"
+    )
 
     results = posthoc_games_howell(
-        [group1, group2, group3],
-        group_names=['Low Var', 'High Var', 'Med Var']
+        [group1, group2, group3], group_names=["Low Var", "High Var", "Med Var"]
     )
 
-    logger.info(f"\n{results[['group_i', 'group_j', 'mean_diff', 'df', 'pvalue', 'significant']].to_string()}")
+    logger.info(
+        f"\n{results[['group_i', 'group_j', 'mean_diff', 'df', 'pvalue', 'significant']].to_string()}"
+    )
 
     # Example 2: Comparison with Tukey HSD
     logger.info("\n[Example 2] Games-Howell vs Tukey HSD")
@@ -325,10 +335,14 @@ if __name__ == "__main__":
     results_tukey = posthoc_tukey([group1, group2, group3])
 
     logger.info("\nGames-Howell results:")
-    logger.info(f"{results_gh[['group_i', 'group_j', 'pvalue', 'significant']].to_string()}")
+    logger.info(
+        f"{results_gh[['group_i', 'group_j', 'pvalue', 'significant']].to_string()}"
+    )
 
     logger.info("\nTukey HSD results:")
-    logger.info(f"{results_tukey[['group_i', 'group_j', 'pvalue', 'significant']].to_string()}")
+    logger.info(
+        f"{results_tukey[['group_i', 'group_j', 'pvalue', 'significant']].to_string()}"
+    )
 
     logger.info("\nNote: Games-Howell is more appropriate with unequal variances")
 
@@ -340,24 +354,28 @@ if __name__ == "__main__":
 
     anova_result = test_anova(
         [group1, group2, group3],
-        var_names=['Low Var', 'High Var', 'Med Var'],
-        check_assumptions=True
+        var_names=["Low Var", "High Var", "Med Var"],
+        check_assumptions=True,
     )
 
-    logger.info(f"ANOVA: F = {anova_result['statistic']:.3f}, p = {anova_result['pvalue']:.4f}")
+    logger.info(
+        f"ANOVA: F = {anova_result['statistic']:.3f}, p = {anova_result['pvalue']:.4f}"
+    )
     logger.info(f"Assumptions met: {anova_result.get('assumptions_met', 'N/A')}")
 
-    is_sig = anova_result.get('significant', anova_result.get('is_significant', False))
+    is_sig = anova_result.get("significant", anova_result.get("is_significant", False))
     if is_sig:
-        logger.info("\nANOVA significant. Using Games-Howell (robust to unequal variances)...")
+        logger.info(
+            "\nANOVA significant. Using Games-Howell (robust to unequal variances)..."
+        )
         logger.info(f"\n{results.to_string()}")
 
     # Example 4: Extreme variance ratios
     logger.info("\n[Example 4] Extreme variance heterogeneity")
     logger.info("-" * 70)
 
-    extreme1 = np.random.normal(50, 1, 20)    # Very small variance
-    extreme2 = np.random.normal(55, 10, 20)   # Very large variance
+    extreme1 = np.random.normal(50, 1, 20)  # Very small variance
+    extreme2 = np.random.normal(55, 10, 20)  # Very large variance
 
     var_ratio = np.var(extreme2, ddof=1) / np.var(extreme1, ddof=1)
     logger.info(f"Variance ratio: {var_ratio:.1f}")
@@ -370,7 +388,7 @@ if __name__ == "__main__":
     logger.info("\n[Example 5] Export results")
     logger.info("-" * 70)
 
-    convert_results(results, return_as='excel', path='./games_howell_results.xlsx')
+    convert_results(results, return_as="excel", path="./games_howell_results.xlsx")
     logger.info("Saved to: ./games_howell_results.xlsx")
 
     stx.session.close(

scitex/stats/posthoc/_tukey_hsd.py

@@ -5,6 +5,7 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
+
 __FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
@@ -76,7 +77,7 @@ def posthoc_tukey(
     groups: List[Union[np.ndarray, pd.Series]],
     group_names: Optional[List[str]] = None,
     alpha: float = 0.05,
-    return_as: str = 'dataframe'
+    return_as: str = "dataframe",
 ) -> Union[pd.DataFrame, List[dict]]:
     """
     Perform Tukey HSD post-hoc test for pairwise comparisons.
@@ -189,7 +190,7 @@ def posthoc_tukey(
 
     # Group names
     if group_names is None:
-        group_names = [f'Group {i+1}' for i in range(k)]
+        group_names = [f"Group {i + 1}" for i in range(k)]
 
     if len(group_names) != k:
         raise ValueError(f"Expected {k} group names, got {len(group_names)}")
@@ -226,7 +227,7 @@ def posthoc_tukey(
             mean_diff = mean_i - mean_j
 
             # Standard error for unequal sample sizes (Tukey-Kramer)
-            se = np.sqrt(ms_error * (1/n_i + 1/n_j) / 2)
+            se = np.sqrt(ms_error * (1 / n_i + 1 / n_j) / 2)
 
             # Studentized range statistic
             q_stat = abs(mean_diff) / se
@@ -245,27 +246,29 @@ def posthoc_tukey(
             ci_lower = mean_diff - margin
             ci_upper = mean_diff + margin
 
-            results.append({
-                'group_i': group_names[i],
-                'group_j': group_names[j],
-                'n_i': n_i,
-                'n_j': n_j,
-                'mean_i': round(float(mean_i), 3),
-                'mean_j': round(float(mean_j), 3),
-                'mean_diff': round(float(mean_diff), 3),
-                'std_error': round(float(se), 3),
-                'q_statistic': round(float(q_stat), 3),
-                'q_critical': round(float(q_crit), 3),
-                'pvalue': round(float(pvalue), 4),
-                'significant': bool(significant),
-                'pstars': p2stars(pvalue),
-                'ci_lower': round(float(ci_lower), 3),
-                'ci_upper': round(float(ci_upper), 3),
-                'alpha': alpha,
-            })
+            results.append(
+                {
+                    "group_i": group_names[i],
+                    "group_j": group_names[j],
+                    "n_i": n_i,
+                    "n_j": n_j,
+                    "mean_i": round(float(mean_i), 3),
+                    "mean_j": round(float(mean_j), 3),
+                    "mean_diff": round(float(mean_diff), 3),
+                    "std_error": round(float(se), 3),
+                    "q_statistic": round(float(q_stat), 3),
+                    "q_critical": round(float(q_crit), 3),
+                    "pvalue": round(float(pvalue), 4),
+                    "significant": bool(significant),
+                    "pstars": p2stars(pvalue),
+                    "ci_lower": round(float(ci_lower), 3),
+                    "ci_upper": round(float(ci_upper), 3),
+                    "alpha": alpha,
+                }
+            )
 
     # Return format
-    if return_as == 'dataframe':
+    if return_as == "dataframe":
         return pd.DataFrame(results)
     else:
         return results
@@ -309,20 +312,24 @@ if __name__ == "__main__":
 
     anova_result = test_anova(
         [control, treatment1, treatment2, treatment3],
-        var_names=['Control', 'Treat1', 'Treat2', 'Treat3']
+        var_names=["Control", "Treat1", "Treat2", "Treat3"],
     )
 
-    logger.info(f"ANOVA: F = {anova_result['statistic']:.3f}, p = {anova_result['pvalue']:.4f}")
+    logger.info(
+        f"ANOVA: F = {anova_result['statistic']:.3f}, p = {anova_result['pvalue']:.4f}"
+    )
 
-    if anova_result['significant']:
+    if anova_result["significant"]:
         logger.info("\nANOVA significant, conducting Tukey HSD...")
 
         results = posthoc_tukey(
             [control, treatment1, treatment2, treatment3],
-            group_names=['Control', 'Treat1', 'Treat2', 'Treat3']
+            group_names=["Control", "Treat1", "Treat2", "Treat3"],
         )
 
-        logger.info(f"\n{results[['group_i', 'group_j', 'mean_diff', 'pvalue', 'significant']].to_string()}")
+        logger.info(
+            f"\n{results[['group_i', 'group_j', 'mean_diff', 'pvalue', 'significant']].to_string()}"
+        )
 
     # Example 2: Unbalanced design (Tukey-Kramer)
     logger.info("\n[Example 2] Unbalanced design (different sample sizes)")
@@ -333,8 +340,7 @@ if __name__ == "__main__":
     group_c = np.random.normal(55, 10, 20)
 
     results_unbalanced = posthoc_tukey(
-        [group_a, group_b, group_c],
-        group_names=['A', 'B', 'C']
+        [group_a, group_b, group_c], group_names=["A", "B", "C"]
     )
 
     logger.info(f"Sample sizes: A={len(group_a)}, B={len(group_b)}, C={len(group_c)}")
@@ -345,16 +351,18 @@ if __name__ == "__main__":
     logger.info("-" * 70)
 
     for _, row in results.iterrows():
-        if row['significant']:
-            logger.info(f"{row['group_i']} vs {row['group_j']}: "
-                       f"Diff = {row['mean_diff']:.2f}, "
-                       f"95% CI [{row['ci_lower']:.2f}, {row['ci_upper']:.2f}] {row['pstars']}")
+        if row["significant"]:
+            logger.info(
+                f"{row['group_i']} vs {row['group_j']}: "
+                f"Diff = {row['mean_diff']:.2f}, "
+                f"95% CI [{row['ci_lower']:.2f}, {row['ci_upper']:.2f}] {row['pstars']}"
+            )
 
     # Example 4: Export results
     logger.info("\n[Example 4] Export results")
     logger.info("-" * 70)
 
-    convert_results(results, return_as='excel', path='./tukey_hsd_results.xlsx')
+    convert_results(results, return_as="excel", path="./tukey_hsd_results.xlsx")
     logger.info("Saved to: ./tukey_hsd_results.xlsx")
 
     stx.session.close(

scitex/stats/power/__init__.py

@@ -14,6 +14,6 @@ from ._power import (
 )
 
 __all__ = [
-    'power_ttest',
-    'sample_size_ttest',
+    "power_ttest",
+    "sample_size_ttest",
 ]

scitex/stats/power/_power.py

@@ -31,14 +31,16 @@ from scitex.logging import getLogger
 logger = getLogger(__name__)
 
 """Functions"""
+
+
 def power_ttest(
     effect_size: float,
     n: Optional[int] = None,
     n1: Optional[int] = None,
     n2: Optional[int] = None,
     alpha: float = 0.05,
-    alternative: Literal['two-sided', 'greater', 'less'] = 'two-sided',
-    test_type: Literal['one-sample', 'two-sample', 'paired'] = 'two-sample'
+    alternative: Literal["two-sided", "greater", "less"] = "two-sided",
+    test_type: Literal["one-sample", "two-sample", "paired"] = "two-sample",
 ) -> float:
     """
     Compute statistical power for t-test.
@@ -112,11 +114,11 @@ def power_ttest(
     0.628...
     """
     # Validate inputs
-    if test_type in ['one-sample', 'paired']:
+    if test_type in ["one-sample", "paired"]:
         if n is None:
             raise ValueError(f"n must be specified for {test_type} test")
         sample_size = n
-    elif test_type == 'two-sample':
+    elif test_type == "two-sample":
         if n1 is None or n2 is None:
             raise ValueError("n1 and n2 must be specified for two-sample test")
         # Use harmonic mean for unequal sample sizes
@@ -125,23 +127,23 @@ def power_ttest(
         raise ValueError(f"Unknown test_type: {test_type}")
 
     # Determine degrees of freedom
-    if test_type == 'two-sample':
+    if test_type == "two-sample":
         df = n1 + n2 - 2
     else:
         df = sample_size - 1
 
     # Determine critical value based on alternative hypothesis
-    if alternative == 'two-sided':
+    if alternative == "two-sided":
         t_crit = stats.t.ppf(1 - alpha / 2, df)
-    elif alternative == 'greater':
+    elif alternative == "greater":
         t_crit = stats.t.ppf(1 - alpha, df)
-    elif alternative == 'less':
+    elif alternative == "less":
         t_crit = stats.t.ppf(alpha, df)
     else:
         raise ValueError(f"Unknown alternative: {alternative}")
 
     # Compute non-centrality parameter
-    if test_type == 'two-sample':
+    if test_type == "two-sample":
         # For two-sample, ncp = d * sqrt(n_eff / 2)
         ncp = effect_size * np.sqrt(sample_size / 2)
     else:
@@ -149,10 +151,10 @@ def power_ttest(
         ncp = effect_size * np.sqrt(sample_size)
 
     # Compute power using non-central t-distribution
-    if alternative == 'two-sided':
+    if alternative == "two-sided":
         # For two-sided, power = P(|T| > t_crit | ncp)
         power = 1 - stats.nct.cdf(t_crit, df, ncp) + stats.nct.cdf(-t_crit, df, ncp)
-    elif alternative == 'greater':
+    elif alternative == "greater":
         # For greater, power = P(T > t_crit | ncp)
         power = 1 - stats.nct.cdf(t_crit, df, ncp)
     else:  # less
@@ -166,9 +168,9 @@ def sample_size_ttest(
     effect_size: float,
     power: float = 0.80,
     alpha: float = 0.05,
-    alternative: Literal['two-sided', 'greater', 'less'] = 'two-sided',
-    test_type: Literal['one-sample', 'two-sample', 'paired'] = 'two-sample',
-    ratio: float = 1.0
+    alternative: Literal["two-sided", "greater", "less"] = "two-sided",
+    test_type: Literal["one-sample", "two-sample", "paired"] = "two-sample",
+    ratio: float = 1.0,
 ) -> Union[int, tuple]:
     """
     Determine required sample size for t-test with desired power.
@@ -213,7 +215,7 @@ def sample_size_ttest(
     n_min = 2
     n_max = 10000
 
-    if test_type == 'two-sample':
+    if test_type == "two-sample":
         # Search for n1
         while n_max - n_min > 1:
             n1_mid = (n_min + n_max) // 2
@@ -225,7 +227,7 @@ def sample_size_ttest(
                 n2=n2_mid,
                 alpha=alpha,
                 alternative=alternative,
-                test_type=test_type
+                test_type=test_type,
             )
 
             if current_power < power:
@@ -246,7 +248,7 @@ def sample_size_ttest(
                 n=n_mid,
                 alpha=alpha,
                 alternative=alternative,
-                test_type=test_type
+                test_type=test_type,
             )
 
             if current_power < power:
@@ -258,6 +260,8 @@ def sample_size_ttest(
 
 
 """Main function"""
+
+
 def main(args):
     """Demonstrate power analysis functionality."""
     logger.info("Demonstrating statistical power analysis")
@@ -272,7 +276,7 @@ def main(args):
     for d in effect_sizes:
         power = power_ttest(effect_size=d, n1=n_per_group, n2=n_per_group)
         logger.info(f"d = {d:.1f}, n = {n_per_group} per group → Power = {power:.3f}")
-        results.append({'effect_size': d, 'power': power})
+        results.append({"effect_size": d, "power": power})
 
     # Example 2: Sample size vs power
     logger.info("\n=== Example 2: Sample Size vs Power ===")
@@ -284,7 +288,7 @@ def main(args):
     for n in sample_sizes:
         power = power_ttest(effect_size=d, n1=n, n2=n)
         logger.info(f"n = {n} per group, d = {d} → Power = {power:.3f}")
-        power_results.append({'n': n, 'power': power})
+        power_results.append({"n": n, "power": power})
 
     # Example 3: Required sample size
     logger.info("\n=== Example 3: Required Sample Size ===")
@@ -302,12 +306,12 @@ def main(args):
 
     d = 0.5
     n = 30
-    power_two = power_ttest(effect_size=d, n1=n, n2=n, alternative='two-sided')
-    power_one = power_ttest(effect_size=d, n1=n, n2=n, alternative='greater')
+    power_two = power_ttest(effect_size=d, n1=n, n2=n, alternative="two-sided")
+    power_one = power_ttest(effect_size=d, n1=n, n2=n, alternative="greater")
 
     logger.info(f"Two-sided test: Power = {power_two:.3f}")
     logger.info(f"One-sided test:  Power = {power_one:.3f}")
-    logger.info(f"One-sided power is {power_one/power_two:.2f}x higher")
+    logger.info(f"One-sided power is {power_one / power_two:.2f}x higher")
 
     # Create visualizations
     logger.info("\n=== Creating visualizations ===")
@@ -317,11 +321,11 @@ def main(args):
     # Plot 1: Effect size vs power
     ax = axes[0, 0]
     df_es = pd.DataFrame(results)
-    ax.plot(df_es['effect_size'], df_es['power'], 'o-', linewidth=2, markersize=8)
-    ax.axhline(0.80, color='red', linestyle='--', alpha=0.5, label='80% power')
-    ax.set_xlabel('Effect Size (Cohen\'s d)')
-    ax.set_ylabel('Statistical Power')
-    ax.set_title(f'Effect Size vs Power (n={n_per_group}/group)')
+    ax.plot(df_es["effect_size"], df_es["power"], "o-", linewidth=2, markersize=8)
+    ax.axhline(0.80, color="red", linestyle="--", alpha=0.5, label="80% power")
+    ax.set_xlabel("Effect Size (Cohen's d)")
+    ax.set_ylabel("Statistical Power")
+    ax.set_title(f"Effect Size vs Power (n={n_per_group}/group)")
     ax.legend()
     ax.grid(True, alpha=0.3)
     ax.set_ylim(0, 1)
@@ -329,14 +333,14 @@ def main(args):
     # Plot 2: Sample size vs power
     ax = axes[0, 1]
     df_ss = pd.DataFrame(power_results)
-    ax.plot(df_ss['n'], df_ss['power'], 'o-', linewidth=2, markersize=8)
-    ax.axhline(0.80, color='red', linestyle='--', alpha=0.5, label='80% power')
-    ax.set_xlabel('Sample Size (per group)')
-    ax.set_ylabel('Statistical Power')
-    ax.set_title(f'Sample Size vs Power (d={d})')
+    ax.plot(df_ss["n"], df_ss["power"], "o-", linewidth=2, markersize=8)
+    ax.axhline(0.80, color="red", linestyle="--", alpha=0.5, label="80% power")
+    ax.set_xlabel("Sample Size (per group)")
+    ax.set_ylabel("Statistical Power")
+    ax.set_title(f"Sample Size vs Power (d={d})")
     ax.legend()
     ax.grid(True, alpha=0.3)
-    ax.set_xscale('log')
+    ax.set_xscale("log")
     ax.set_ylim(0, 1)
 
     # Plot 3: Power curves for different effect sizes
@@ -344,12 +348,12 @@ def main(args):
     ns = np.arange(5, 201, 5)
     for d_val in [0.2, 0.5, 0.8]:
         powers = [power_ttest(effect_size=d_val, n1=n, n2=n) for n in ns]
-        ax.plot(ns, powers, linewidth=2, label=f'd = {d_val}')
+        ax.plot(ns, powers, linewidth=2, label=f"d = {d_val}")
 
-    ax.axhline(0.80, color='black', linestyle='--', alpha=0.3)
-    ax.set_xlabel('Sample Size (per group)')
-    ax.set_ylabel('Statistical Power')
-    ax.set_title('Power Curves for Different Effect Sizes')
+    ax.axhline(0.80, color="black", linestyle="--", alpha=0.3)
+    ax.set_xlabel("Sample Size (per group)")
+    ax.set_ylabel("Statistical Power")
+    ax.set_title("Power Curves for Different Effect Sizes")
     ax.legend()
     ax.grid(True, alpha=0.3)
     ax.set_ylim(0, 1)
@@ -364,24 +368,24 @@ def main(args):
         required_ns.append(n1)
 
     ax.plot(effect_sizes_range, required_ns, linewidth=2)
-    ax.set_xlabel('Effect Size (Cohen\'s d)')
-    ax.set_ylabel('Required Sample Size (per group)')
-    ax.set_title('Sample Size Required for 80% Power')
+    ax.set_xlabel("Effect Size (Cohen's d)")
+    ax.set_ylabel("Required Sample Size (per group)")
+    ax.set_title("Sample Size Required for 80% Power")
     ax.grid(True, alpha=0.3)
-    ax.set_yscale('log')
+    ax.set_yscale("log")
 
     # Add reference lines
-    ax.axvline(0.2, color='gray', linestyle='--', alpha=0.3)
-    ax.axvline(0.5, color='gray', linestyle='--', alpha=0.3)
-    ax.axvline(0.8, color='gray', linestyle='--', alpha=0.3)
-    ax.text(0.2, ax.get_ylim()[1] * 0.9, 'Small', ha='center', fontsize=9)
-    ax.text(0.5, ax.get_ylim()[1] * 0.9, 'Medium', ha='center', fontsize=9)
-    ax.text(0.8, ax.get_ylim()[1] * 0.9, 'Large', ha='center', fontsize=9)
+    ax.axvline(0.2, color="gray", linestyle="--", alpha=0.3)
+    ax.axvline(0.5, color="gray", linestyle="--", alpha=0.3)
+    ax.axvline(0.8, color="gray", linestyle="--", alpha=0.3)
+    ax.text(0.2, ax.get_ylim()[1] * 0.9, "Small", ha="center", fontsize=9)
+    ax.text(0.5, ax.get_ylim()[1] * 0.9, "Medium", ha="center", fontsize=9)
+    ax.text(0.8, ax.get_ylim()[1] * 0.9, "Large", ha="center", fontsize=9)
 
     plt.tight_layout()
 
     # Save
-    stx.io.save(fig, './power_analysis_demo.jpg')
+    stx.io.save(fig, "./power_analysis_demo.jpg")
     logger.info("Visualization saved")
 
     return 0
@@ -390,13 +394,9 @@ def main(args):
 def parse_args():
     """Parse command line arguments."""
     parser = argparse.ArgumentParser(
-        description='Demonstrate statistical power analysis for t-tests'
-    )
-    parser.add_argument(
-        '--verbose',
-        action='store_true',
-        help='Enable verbose output'
+        description="Demonstrate statistical power analysis for t-tests"
     )
+    parser.add_argument("--verbose", action="store_true", help="Enable verbose output")
     return parser.parse_args()
 
 
@@ -427,7 +427,7 @@ def run_main():
     )
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     run_main()
 
 # EOF

scitex/stats/tests/__init__.py

@@ -9,5 +9,5 @@ Submodules:
 from . import correlation
 
 __all__ = [
-    'correlation',
+    "correlation",
 ]

scitex/stats/tests/correlation/__init__.py

@@ -9,5 +9,5 @@ Available tests:
 from ._test_pearson import test_pearson
 
 __all__ = [
-    'test_pearson',
+    "test_pearson",
 ]