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

scitex/stats/effect_sizes/_epsilon_squared.py

@@ -5,6 +5,7 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
+
 __FILE__ = "./src/scitex/stats/effect_sizes/_epsilon_squared.py"
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
@@ -154,13 +155,13 @@ def interpret_epsilon_squared(epsilon2: float) -> str:
     'large'
     """
     if epsilon2 < 0.01:
-        return 'negligible'
+        return "negligible"
     elif epsilon2 < 0.06:
-        return 'small'
+        return "small"
     elif epsilon2 < 0.14:
-        return 'medium'
+        return "medium"
     else:
-        return 'large'
+        return "large"
 
 
 """Main function"""
@@ -231,13 +232,13 @@ def main(args):
 
     # Plot 1: Distribution comparison
     ax = axes[0]
-    ax.hist(group1, bins=20, alpha=0.5, label='Group 1', density=True)
-    ax.hist(group2, bins=20, alpha=0.5, label='Group 2', density=True)
-    ax.hist(group3, bins=20, alpha=0.5, label='Group 3', density=True)
+    ax.hist(group1, bins=20, alpha=0.5, label="Group 1", density=True)
+    ax.hist(group2, bins=20, alpha=0.5, label="Group 2", density=True)
+    ax.hist(group3, bins=20, alpha=0.5, label="Group 3", density=True)
 
-    ax.set_xlabel('Value')
-    ax.set_ylabel('Density')
-    ax.set_title(f'Skewed Distributions (ε² = {eps2:.2f})')
+    ax.set_xlabel("Value")
+    ax.set_ylabel("Density")
+    ax.set_title(f"Skewed Distributions (ε² = {eps2:.2f})")
     ax.legend()
 
     # Plot 2: Comparison of methods
@@ -253,17 +254,17 @@ def main(args):
         eps2_values.append(epsilon_squared([g1, g2]))
         eta2_values.append(eta_squared([g1, g2]))
 
-    ax.plot(scales, eps2_values, 'o-', label='Epsilon-squared (ε²)', linewidth=2)
-    ax.plot(scales, eta2_values, 's-', label='Eta-squared (η²)', linewidth=2)
+    ax.plot(scales, eps2_values, "o-", label="Epsilon-squared (ε²)", linewidth=2)
+    ax.plot(scales, eta2_values, "s-", label="Eta-squared (η²)", linewidth=2)
 
-    ax.set_xlabel('Distribution Scale Difference')
-    ax.set_ylabel('Effect Size')
-    ax.set_title('Non-parametric vs Parametric Effect Size')
+    ax.set_xlabel("Distribution Scale Difference")
+    ax.set_ylabel("Effect Size")
+    ax.set_title("Non-parametric vs Parametric Effect Size")
     ax.legend()
     ax.grid(True, alpha=0.3)
 
     stx.plt.tight_layout()
-    stx.io.save(fig, './epsilon_squared_demo.jpg')
+    stx.io.save(fig, "./epsilon_squared_demo.jpg")
     logger.info("Visualization saved")
 
     return 0
@@ -274,11 +275,7 @@ def parse_args():
     parser = argparse.ArgumentParser(
         description="Demonstrate epsilon-squared effect size calculation"
     )
-    parser.add_argument(
-        '--verbose',
-        action='store_true',
-        help='Enable verbose output'
-    )
+    parser.add_argument("--verbose", action="store_true", help="Enable verbose output")
     return parser.parse_args()
 
 
@@ -309,7 +306,7 @@ def run_main():
     )
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     run_main()
 
 # EOF

scitex/stats/effect_sizes/_eta_squared.py

@@ -5,6 +5,7 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
+
 __FILE__ = "./src/scitex/stats/effect_sizes/_eta_squared.py"
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
@@ -38,10 +39,7 @@ logger = getLogger(__name__)
 """Functions"""
 
 
-def eta_squared(
-    groups: List[Union[np.ndarray, pd.Series]],
-    ddof: int = 1
-) -> float:
+def eta_squared(groups: List[Union[np.ndarray, pd.Series]], ddof: int = 1) -> float:
     """
     Compute eta-squared (η²) effect size for ANOVA.
 
@@ -160,13 +158,13 @@ def interpret_eta_squared(eta2: float) -> str:
     'large'
     """
     if eta2 < 0.01:
-        return 'negligible'
+        return "negligible"
     elif eta2 < 0.06:
-        return 'small'
+        return "small"
     elif eta2 < 0.14:
-        return 'medium'
+        return "medium"
     else:
-        return 'large'
+        return "large"
 
 
 """Main function"""
@@ -212,7 +210,9 @@ def main(args):
     groups = [np.random.normal(i * 0.3, 1, 25) for i in range(5)]
     eta2_many = eta_squared(groups)
 
-    logger.info(f"Five groups: η² = {eta2_many:.3f} ({interpret_eta_squared(eta2_many)})")
+    logger.info(
+        f"Five groups: η² = {eta2_many:.3f} ({interpret_eta_squared(eta2_many)})"
+    )
 
     # Visualization
     logger.info("\n=== Creating visualization ===")
@@ -225,14 +225,14 @@ def main(args):
     data_viz = [group1, group2, group3]
 
     bp = ax.boxplot(data_viz, positions=positions, widths=0.6, patch_artist=True)
-    for patch in bp['boxes']:
-        patch.set_facecolor('lightblue')
+    for patch in bp["boxes"]:
+        patch.set_facecolor("lightblue")
 
-    ax.set_xlabel('Group')
-    ax.set_ylabel('Value')
-    ax.set_title(f'Three Groups (η² = {eta2:.2f})')
-    ax.set_xticklabels(['Group 1', 'Group 2', 'Group 3'])
-    ax.grid(True, alpha=0.3, axis='y')
+    ax.set_xlabel("Group")
+    ax.set_ylabel("Value")
+    ax.set_title(f"Three Groups (η² = {eta2:.2f})")
+    ax.set_xticklabels(["Group 1", "Group 2", "Group 3"])
+    ax.grid(True, alpha=0.3, axis="y")
 
     # Plot 2: Effect size vs number of groups
     ax = axes[1]
@@ -243,14 +243,14 @@ def main(args):
         groups_test = [np.random.normal(i * 0.4, 1, 30) for i in range(n_groups)]
         eta2_values.append(eta_squared(groups_test))
 
-    ax.plot(n_groups_list, eta2_values, 'o-', linewidth=2, markersize=8)
-    ax.set_xlabel('Number of Groups')
-    ax.set_ylabel('Eta-squared')
-    ax.set_title('Effect Size vs Number of Groups')
+    ax.plot(n_groups_list, eta2_values, "o-", linewidth=2, markersize=8)
+    ax.set_xlabel("Number of Groups")
+    ax.set_ylabel("Eta-squared")
+    ax.set_title("Effect Size vs Number of Groups")
     ax.grid(True, alpha=0.3)
 
     stx.plt.tight_layout()
-    stx.io.save(fig, './eta_squared_demo.jpg')
+    stx.io.save(fig, "./eta_squared_demo.jpg")
     logger.info("Visualization saved")
 
     return 0
@@ -261,11 +261,7 @@ def parse_args():
     parser = argparse.ArgumentParser(
         description="Demonstrate eta-squared effect size calculation"
     )
-    parser.add_argument(
-        '--verbose',
-        action='store_true',
-        help='Enable verbose output'
-    )
+    parser.add_argument("--verbose", action="store_true", help="Enable verbose output")
     return parser.parse_args()
 
 
@@ -296,7 +292,7 @@ def run_main():
     )
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     run_main()
 
 # EOF

scitex/stats/effect_sizes/_prob_superiority.py

@@ -5,6 +5,7 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
+
 __FILE__ = "./src/scitex/stats/effect_sizes/_prob_superiority.py"
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
@@ -39,8 +40,7 @@ logger = getLogger(__name__)
 
 
 def prob_superiority(
-    x: Union[np.ndarray, pd.Series],
-    y: Union[np.ndarray, pd.Series]
+    x: Union[np.ndarray, pd.Series], y: Union[np.ndarray, pd.Series]
 ) -> float:
     """
     Compute probability of superiority P(X > Y).
@@ -170,13 +170,13 @@ def interpret_prob_superiority(prob: float) -> str:
     distance = abs(prob - 0.5)
 
     if distance < 0.06:
-        return 'negligible'
+        return "negligible"
     elif distance < 0.14:
-        return 'small'
+        return "small"
     elif distance < 0.21:
-        return 'medium'
+        return "medium"
     else:
-        return 'large'
+        return "large"
 
 
 """Main function"""
@@ -196,6 +196,7 @@ def main(args):
     y = np.array([3, 4, 5, 6, 7, 8, 9, 10])
 
     from ._cliffs_delta import cliffs_delta
+
     prob = prob_superiority(x, y)
     delta = cliffs_delta(x, y)
 
@@ -231,20 +232,20 @@ def main(args):
         control = np.random.normal(0, 1, 100)
         probs.append(prob_superiority(treatment, control))
 
-    ax.plot(shifts, probs, 'o-', linewidth=2, markersize=8)
-    ax.axhline(0.5, color='red', linestyle='--', alpha=0.5, label='Chance level')
-    ax.axhline(0.56, color='orange', linestyle='--', alpha=0.5, label='Small effect')
-    ax.axhline(0.64, color='yellow', linestyle='--', alpha=0.5, label='Medium effect')
-    ax.axhline(0.71, color='green', linestyle='--', alpha=0.5, label='Large effect')
+    ax.plot(shifts, probs, "o-", linewidth=2, markersize=8)
+    ax.axhline(0.5, color="red", linestyle="--", alpha=0.5, label="Chance level")
+    ax.axhline(0.56, color="orange", linestyle="--", alpha=0.5, label="Small effect")
+    ax.axhline(0.64, color="yellow", linestyle="--", alpha=0.5, label="Medium effect")
+    ax.axhline(0.71, color="green", linestyle="--", alpha=0.5, label="Large effect")
 
-    ax.set_xlabel('Mean Shift (Cohen\'s d)')
-    ax.set_ylabel('P(Treatment > Control)')
-    ax.set_title('Probability of Superiority vs Effect Size')
+    ax.set_xlabel("Mean Shift (Cohen's d)")
+    ax.set_ylabel("P(Treatment > Control)")
+    ax.set_title("Probability of Superiority vs Effect Size")
     ax.legend()
     ax.grid(True, alpha=0.3)
 
     stx.plt.tight_layout()
-    stx.io.save(fig, './prob_superiority_demo.jpg')
+    stx.io.save(fig, "./prob_superiority_demo.jpg")
     logger.info("Visualization saved")
 
     return 0
@@ -255,11 +256,7 @@ def parse_args():
     parser = argparse.ArgumentParser(
         description="Demonstrate probability of superiority calculation"
     )
-    parser.add_argument(
-        '--verbose',
-        action='store_true',
-        help='Enable verbose output'
-    )
+    parser.add_argument("--verbose", action="store_true", help="Enable verbose output")
     return parser.parse_args()
 
 
@@ -290,7 +287,7 @@ def run_main():
     )
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     run_main()
 
 # EOF

scitex/stats/posthoc/__init__.py

@@ -13,7 +13,7 @@ from ._games_howell import posthoc_games_howell
 from ._dunnett import posthoc_dunnett
 
 __all__ = [
-    'posthoc_tukey',
-    'posthoc_games_howell',
-    'posthoc_dunnett',
+    "posthoc_tukey",
+    "posthoc_games_howell",
+    "posthoc_dunnett",
 ]

scitex/stats/posthoc/_dunnett.py

@@ -5,6 +5,7 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
+
 __FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
@@ -33,8 +34,9 @@ from scitex.stats.utils._formatters import p2stars
 from scitex.stats.utils._normalizers import convert_results
 
 
-def dunnett_critical_value(k: int, df: int, alpha: float = 0.05,
-                          alternative: str = 'two-sided') -> float:
+def dunnett_critical_value(
+    k: int, df: int, alpha: float = 0.05, alternative: str = "two-sided"
+) -> float:
     """
     Get critical value for Dunnett's test.
 
@@ -61,7 +63,7 @@ def dunnett_critical_value(k: int, df: int, alpha: float = 0.05,
     or software (R, SAS) would be needed.
     """
     # Conservative approximation using Bonferroni adjustment
-    if alternative == 'two-sided':
+    if alternative == "two-sided":
         alpha_adj = alpha / (2 * k)
     else:
         alpha_adj = alpha / k
@@ -79,10 +81,10 @@ def posthoc_dunnett(
     control: Union[np.ndarray, pd.Series],
     treatments: List[Union[np.ndarray, pd.Series]],
     treatment_names: Optional[List[str]] = None,
-    control_name: str = 'Control',
+    control_name: str = "Control",
     alpha: float = 0.05,
-    alternative: Literal['two-sided', 'less', 'greater'] = 'two-sided',
-    return_as: str = 'dataframe'
+    alternative: Literal["two-sided", "less", "greater"] = "two-sided",
+    return_as: str = "dataframe",
 ) -> Union[pd.DataFrame, List[dict]]:
     """
     Perform Dunnett's test for comparing treatments vs control.
@@ -214,7 +216,7 @@ def posthoc_dunnett(
 
     # Treatment names
     if treatment_names is None:
-        treatment_names = [f'Treatment {i+1}' for i in range(k)]
+        treatment_names = [f"Treatment {i + 1}" for i in range(k)]
 
     if len(treatment_names) != k:
         raise ValueError(f"Expected {k} treatment names, got {len(treatment_names)}")
@@ -243,12 +245,14 @@ def posthoc_dunnett(
     # Perform comparisons vs control
     results = []
 
-    for i, (treatment, n_t, mean_t) in enumerate(zip(treatments, n_treatments, means_treatments)):
+    for i, (treatment, n_t, mean_t) in enumerate(
+        zip(treatments, n_treatments, means_treatments)
+    ):
         # Mean difference
         mean_diff = mean_t - mean_control
 
         # Standard error
-        se = np.sqrt(ms_error * (1/n_t + 1/n_control))
+        se = np.sqrt(ms_error * (1 / n_t + 1 / n_control))
 
         # t-statistic
         if se == 0:
@@ -257,9 +261,9 @@ def posthoc_dunnett(
             t_stat = mean_diff / se
 
         # p-value (conservative approximation)
-        if alternative == 'two-sided':
+        if alternative == "two-sided":
             pvalue = 2 * (1 - stats.t.cdf(abs(t_stat), df_error))
-        elif alternative == 'greater':
+        elif alternative == "greater":
             pvalue = 1 - stats.t.cdf(t_stat, df_error)
         else:  # less
             pvalue = stats.t.cdf(t_stat, df_error)
@@ -268,47 +272,53 @@ def posthoc_dunnett(
         pvalue = min(pvalue * k, 1.0)
 
         # Determine significance
-        if alternative == 'two-sided':
+        if alternative == "two-sided":
             significant = abs(t_stat) > d_crit
-        elif alternative == 'greater':
+        elif alternative == "greater":
             significant = t_stat > d_crit
         else:  # less
             significant = t_stat < -d_crit
 
         # Confidence interval
         margin = d_crit * se
-        if alternative == 'two-sided':
+        if alternative == "two-sided":
             ci_lower = mean_diff - margin
             ci_upper = mean_diff + margin
-        elif alternative == 'greater':
+        elif alternative == "greater":
             ci_lower = mean_diff - margin
             ci_upper = np.inf
         else:  # less
             ci_lower = -np.inf
             ci_upper = mean_diff + margin
 
-        results.append({
-            'treatment': treatment_names[i],
-            'control': control_name,
-            'n_treatment': n_t,
-            'n_control': n_control,
-            'mean_treatment': round(float(mean_t), 3),
-            'mean_control': round(float(mean_control), 3),
-            'mean_diff': round(float(mean_diff), 3),
-            'std_error': round(float(se), 3),
-            't_statistic': round(float(t_stat), 3),
-            'd_critical': round(float(d_crit), 3),
-            'pvalue': round(float(pvalue), 4),
-            'significant': bool(significant),
-            'pstars': p2stars(pvalue),
-            'ci_lower': round(float(ci_lower), 3) if not np.isinf(ci_lower) else '-inf',
-            'ci_upper': round(float(ci_upper), 3) if not np.isinf(ci_upper) else 'inf',
-            'alpha': alpha,
-            'alternative': alternative,
-        })
+        results.append(
+            {
+                "treatment": treatment_names[i],
+                "control": control_name,
+                "n_treatment": n_t,
+                "n_control": n_control,
+                "mean_treatment": round(float(mean_t), 3),
+                "mean_control": round(float(mean_control), 3),
+                "mean_diff": round(float(mean_diff), 3),
+                "std_error": round(float(se), 3),
+                "t_statistic": round(float(t_stat), 3),
+                "d_critical": round(float(d_crit), 3),
+                "pvalue": round(float(pvalue), 4),
+                "significant": bool(significant),
+                "pstars": p2stars(pvalue),
+                "ci_lower": round(float(ci_lower), 3)
+                if not np.isinf(ci_lower)
+                else "-inf",
+                "ci_upper": round(float(ci_upper), 3)
+                if not np.isinf(ci_upper)
+                else "inf",
+                "alpha": alpha,
+                "alternative": alternative,
+            }
+        )
 
     # Return format
-    if return_as == 'dataframe':
+    if return_as == "dataframe":
         return pd.DataFrame(results)
     else:
         return results
@@ -355,11 +365,13 @@ if __name__ == "__main__":
     results = posthoc_dunnett(
         control=placebo,
         treatments=[dose_low, dose_med, dose_high],
-        treatment_names=['Low Dose', 'Med Dose', 'High Dose'],
-        control_name='Placebo'
+        treatment_names=["Low Dose", "Med Dose", "High Dose"],
+        control_name="Placebo",
     )
 
-    logger.info(f"\n{results[['treatment', 'mean_diff', 't_statistic', 'pvalue', 'significant']].to_string()}")
+    logger.info(
+        f"\n{results[['treatment', 'mean_diff', 't_statistic', 'pvalue', 'significant']].to_string()}"
+    )
 
     # Example 2: One-sided test (treatments > control)
     logger.info("\n[Example 2] One-sided test (greater than control)")
@@ -368,12 +380,14 @@ if __name__ == "__main__":
     results_greater = posthoc_dunnett(
         control=placebo,
         treatments=[dose_low, dose_med, dose_high],
-        treatment_names=['Low Dose', 'Med Dose', 'High Dose'],
-        control_name='Placebo',
-        alternative='greater'
+        treatment_names=["Low Dose", "Med Dose", "High Dose"],
+        control_name="Placebo",
+        alternative="greater",
     )
 
-    logger.info(f"\n{results_greater[['treatment', 'mean_diff', 'pvalue', 'significant']].to_string()}")
+    logger.info(
+        f"\n{results_greater[['treatment', 'mean_diff', 'pvalue', 'significant']].to_string()}"
+    )
 
     # Example 3: Baseline comparison
     logger.info("\n[Example 3] Baseline vs interventions")
@@ -386,8 +400,8 @@ if __name__ == "__main__":
     results_baseline = posthoc_dunnett(
         control=baseline,
         treatments=[intervention_a, intervention_b],
-        treatment_names=['Intervention A', 'Intervention B'],
-        control_name='Baseline'
+        treatment_names=["Intervention A", "Intervention B"],
+        control_name="Baseline",
     )
 
     logger.info(f"\n{results_baseline.to_string()}")
@@ -400,21 +414,23 @@ if __name__ == "__main__":
 
     # All groups for Tukey
     all_groups = [placebo, dose_low, dose_med, dose_high]
-    group_names = ['Placebo', 'Low Dose', 'Med Dose', 'High Dose']
+    group_names = ["Placebo", "Low Dose", "Med Dose", "High Dose"]
 
     results_tukey = posthoc_tukey(all_groups, group_names)
 
     # Filter Tukey results for comparisons vs placebo
     tukey_vs_placebo = results_tukey[
-        (results_tukey['group_i'] == 'Placebo') |
-        (results_tukey['group_j'] == 'Placebo')
+        (results_tukey["group_i"] == "Placebo")
+        | (results_tukey["group_j"] == "Placebo")
     ]
 
     logger.info("\nDunnett's test (designed for control comparisons):")
     logger.info(f"{results[['treatment', 'pvalue', 'significant']].to_string()}")
 
     logger.info("\nTukey HSD (all pairwise, less power for control comparisons):")
-    logger.info(f"{tukey_vs_placebo[['group_i', 'group_j', 'pvalue', 'significant']].to_string()}")
+    logger.info(
+        f"{tukey_vs_placebo[['group_i', 'group_j', 'pvalue', 'significant']].to_string()}"
+    )
 
     logger.info("\nNote: Dunnett is more powerful for control comparisons")
 
@@ -430,11 +446,13 @@ if __name__ == "__main__":
     results_unbal = posthoc_dunnett(
         control=control_unbal,
         treatments=[treat1_unbal, treat2_unbal, treat3_unbal],
-        treatment_names=['T1', 'T2', 'T3']
+        treatment_names=["T1", "T2", "T3"],
     )
 
-    logger.info(f"Sample sizes: Control={len(control_unbal)}, T1={len(treat1_unbal)}, "
-               f"T2={len(treat2_unbal)}, T3={len(treat3_unbal)}")
+    logger.info(
+        f"Sample sizes: Control={len(control_unbal)}, T1={len(treat1_unbal)}, "
+        f"T2={len(treat2_unbal)}, T3={len(treat3_unbal)}"
+    )
     logger.info(f"\n{results_unbal.to_string()}")
 
     # Example 6: With confidence intervals
@@ -442,15 +460,17 @@ if __name__ == "__main__":
     logger.info("-" * 70)
 
     for _, row in results.iterrows():
-        logger.info(f"{row['treatment']} vs {row['control']}: "
-                   f"Diff = {row['mean_diff']:.2f}, "
-                   f"95% CI [{row['ci_lower']}, {row['ci_upper']}] {row['pstars']}")
+        logger.info(
+            f"{row['treatment']} vs {row['control']}: "
+            f"Diff = {row['mean_diff']:.2f}, "
+            f"95% CI [{row['ci_lower']}, {row['ci_upper']}] {row['pstars']}"
+        )
 
     # Example 7: Export results
     logger.info("\n[Example 7] Export results")
     logger.info("-" * 70)
 
-    convert_results(results, return_as='excel', path='./dunnett_results.xlsx')
+    convert_results(results, return_as="excel", path="./dunnett_results.xlsx")
     logger.info("Saved to: ./dunnett_results.xlsx")
 
     stx.session.close(