AutoStatLib 0.2.1__py3-none-any.whl → 0.2.5__py3-none-any.whl

AutoStatLib/AutoStatLib.py

@@ -1,397 +1,10 @@
-import numpy as np
-import pandas as pd
-from statsmodels.stats.diagnostic import lilliefors
-from statsmodels.stats.anova import AnovaRM
-from scipy.stats import ttest_rel, ttest_ind, ttest_1samp, wilcoxon, mannwhitneyu, f_oneway, kruskal, friedmanchisquare, shapiro, anderson, normaltest
+from AutoStatLib.statistical_tests import StatisticalTests
+from AutoStatLib.normality_tests import NormalityTests
+from AutoStatLib.helpers import Helpers
+from AutoStatLib.text_formatting import TextFormatting
 
 
-class __StatisticalTests():
-    '''
-        Statistical tests mixin
-    '''
-
-    def anova_1w_ordinary(self):
-        stat, p_value = f_oneway(*self.data)
-        self.tails = 2
-        # if self.tails == 1 and p_value > 0.5:
-        #     p_value /= 2
-        # if self.tails == 1:
-        #     p_value /= 2
-        self.test_name = 'Ordinary One-Way ANOVA'
-        self.test_id = 'anova_1w_ordinary'
-        self.paired = False
-        self.test_stat = stat
-        self.p_value = p_value
-
-    def anova_1w_rm(self):
-        """
-        Perform repeated measures one-way ANOVA test.
-
-        Parameters:
-        data: list of lists, where each sublist represents repeated measures for a subject
-        """
-
-        df = self.matrix_to_dataframe(self.data)
-        res = AnovaRM(df, 'Value', 'Row', within=['Col']).fit()
-        f_stat = res.anova_table['F Value'][0]
-        p_value = res.anova_table['Pr > F'][0]
-
-        self.tails = 2
-        self.test_name = 'Repeated Measures One-Way ANOVA'
-        self.test_id = 'anova_1w_rm'
-        self.paired = True
-        self.test_stat = f_stat
-        self.p_value = p_value
-
-    def friedman_test(self):
-        stat, p_value = friedmanchisquare(*self.data)
-        self.tails = 2
-        self.test_name = 'Friedman test'
-        self.test_id = 'friedman'
-        self.paired = True
-        self.test_stat = stat
-        self.p_value = p_value
-
-    def kruskal_wallis_test(self):
-        stat, p_value = kruskal(*self.data)
-        self.test_name = 'Kruskal-Wallis test'
-        self.test_id = 'kruskal_wallis'
-        self.paired = False
-        self.test_stat = stat
-        self.p_value = p_value
-
-    def mann_whitney_u_test(self):
-        stat, p_value = mannwhitneyu(
-            self.data[0], self.data[1], alternative='two-sided')
-        if self.tails == 1:
-            p_value /= 2
-        # alternative method of one-tailed calculation
-        # gives the same result:
-        # stat, p_value = mannwhitneyu(
-        #     self.data[0], self.data[1], alternative='two-sided' if self.tails == 2 else 'less')
-        # if self.tails == 1 and p_value > 0.5:
-        #     p_value = 1-p_value
-
-        self.test_name = 'Mann-Whitney U test'
-        self.test_id = 'mann_whitney'
-        self.paired = False
-        self.test_stat = stat
-        self.p_value = p_value
-
-    def t_test_independent(self):
-        t_stat, t_p_value = ttest_ind(
-            self.data[0], self.data[1])
-        if self.tails == 1:
-            t_p_value /= 2
-        self.test_name = 't-test for independent samples'
-        self.test_id = 't_test_independent'
-        self.paired = False
-        self.test_stat = t_stat
-        self.p_value = t_p_value
-
-    def t_test_paired(self):
-        t_stat, t_p_value = ttest_rel(
-            self.data[0], self.data[1])
-        if self.tails == 1:
-            t_p_value /= 2
-        self.test_name = 't-test for paired samples'
-        self.test_id = 't_test_paired'
-        self.paired = True
-        self.test_stat = t_stat
-        self.p_value = t_p_value
-
-    def t_test_single_sample(self):
-        if self.popmean == None:
-            self.popmean = 0
-            self.AddWarning('no_pop_mean_set')
-        t_stat, t_p_value = ttest_1samp(self.data[0], self.popmean)
-        if self.tails == 1:
-            t_p_value /= 2
-        self.test_name = 'Single-sample t-test'
-        self.test_id = 't_test_single_sample'
-        self.paired = False
-        self.test_stat = t_stat
-        self.p_value = t_p_value
-
-    def wilcoxon_single_sample(self):
-        if self.popmean == None:
-            self.popmean = 0
-            self.AddWarning('no_pop_mean_set')
-        data = [i - self.popmean for i in self.data[0]]
-        w_stat, p_value = wilcoxon(data)
-        if self.tails == 1:
-            p_value /= 2
-        self.test_name = 'Wilcoxon signed-rank test for single sample'
-        self.test_id = 'wilcoxon_single_sample'
-        self.paired = False
-        self.test_stat = w_stat
-        self.p_value = p_value
-
-    def wilcoxon(self):
-        stat, p_value = wilcoxon(self.data[0], self.data[1])
-        if self.tails == 1:
-            p_value /= 2
-        self.test_name = 'Wilcoxon signed-rank test'
-        self.test_id = 'wilcoxon'
-        self.paired = True
-        self.test_stat = stat
-        self.p_value = p_value
-
-
-class __NormalityTests():
-    '''
-        Normality tests mixin
-
-        see the article about minimal sample size for tests:
-        Power comparisons of Shapiro-Wilk, Kolmogorov-Smirnov,
-        Lilliefors and Anderson-Darling tests, Nornadiah Mohd Razali1, Yap Bee Wah1
-    '''
-
-    def check_normality(self, data):
-        sw = None
-        lf = None
-        ad = None
-        ap = None
-        n = len(data)
-
-        # Shapiro-Wilk test
-        sw_stat, sw_p_value = shapiro(data)
-        if sw_p_value > 0.05:
-            sw = True
-        else:
-            sw = False
-
-        # Lilliefors test
-        lf_stat, lf_p_value = lilliefors(
-            data, dist='norm')
-        if lf_p_value > 0.05:
-            lf = True
-        else:
-            lf = False
-
-        # Anderson-Darling test
-        if n >= 20:
-            ad_stat, ad_p_value = self.anderson_get_p(
-                data, dist='norm')
-            if ad_p_value > 0.05:
-                ad = True
-            else:
-                ad = False
-
-        # D'Agostino-Pearson test
-        # test result is skewed if n<20
-        if n >= 20:
-            ap_stat, ap_p_value = normaltest(data)
-            if ap_p_value > 0.05:
-                ap = True
-            else:
-                ap = False
-
-        # print(ap_p_value, ad_p_value, sw_p_value, lf_p_value)
-
-        return (sw, lf, ad, ap)
-
-    def anderson_get_p(self, data, dist='norm'):
-        '''
-            calculating p-value for Anderson-Darling test using the method described here:
-            Computation of Probability Associated with Anderson-Darling Statistic
-            Lorentz Jantschi and Sorana D. Bolboaca, 2018 - Mathematics
-
-        '''
-        e = 2.718281828459045
-        n = len(data)
-
-        ad, critical_values, significance_levels = anderson(
-            data, dist=dist)
-
-        # adjust ad_stat for small sample sizes:
-        s = ad*(1 + 0.75/n + 2.25/(n**2))
-
-        if s >= 0.6:
-            p = e**(1.2937 - 5.709*s + 0.0186*s**2)
-        elif s > 0.34:
-            p = e**(0.9177 - 4.279*s - 1.38*s**2)
-        elif s > 0.2:
-            p = 1 - e**(-8.318 + 42.796*s - 59.938*s**2)
-        elif s <= 0.2:
-            p = 1 - e**(-13.436 + 101.14*s - 223.73*s**2)
-        else:
-            p = None
-
-        return ad, p
-
-
-class __Helpers():
-
-    def matrix_to_dataframe(self, matrix):
-        data = []
-        cols = []
-        rows = []
-
-        order_number = 1
-        for i, row in enumerate(matrix):
-            for j, value in enumerate(row):
-                data.append(value)
-                cols.append(i)
-                rows.append(j)
-                order_number += 1
-
-        df = pd.DataFrame(
-            {'Row': rows, 'Col': cols, 'Value': data})
-        return df
-
-    def create_results_dict(self) -> dict:
-
-        self.stars_int = self.make_stars()
-        self.stars_str = '*' * self.stars_int if self.stars_int else 'ns'
-
-        return {
-            'p-value': self.make_p_value_printed(),
-            'Significance(p<0.05)':  True if self.p_value.item() < 0.05 else False,
-            'Stars_Printed': self.stars_str,
-            'Test_Name': self.test_name,
-            'Groups_Compared': self.n_groups,
-            'Population_Mean': self.popmean if self.n_groups == 1 else 'N/A',
-            'Data_Normaly_Distributed': self.parametric,
-            'Parametric_Test_Applied': True if self.test_id in self.test_ids_parametric else False,
-            'Paired_Test_Applied': self.paired,
-            'Tails': self.tails,
-            'p-value_exact': self.p_value.item(),
-            'Stars':  self.stars_int,
-            # 'Stat_Value': self.test_stat.item(),
-            'Warnings': self.warnings,
-            'Groups_N': [len(self.data[i]) for i in range(len(self.data))],
-            'Groups_Median': [np.median(self.data[i]).item() for i in range(len(self.data))],
-            'Groups_Mean': [np.mean(self.data[i]).item() for i in range(len(self.data))],
-            'Groups_SD': [np.std(self.data[i]).item() for i in range(len(self.data))],
-            'Groups_SE': [np.std(self.data[i]).item() / np.sqrt(len(self.data)).item() for i in range(len(self.data))],
-            # actually returns list of lists of numpy dtypes of float64, next make it return regular floats:
-            'Samples': self.data,
-        }
-
-    def log(self, *args, **kwargs):
-        message = ' '.join(map(str, args))
-        # print(message, **kwargs)
-        self.summary += '\n' + message
-
-    def AddWarning(self, warning_id):
-        message = self.warning_ids_all[warning_id]
-        self.log(message)
-        self.warnings.append(message)
-
-
-class __TextFormatting():
-    '''
-        Text formatting mixin
-    '''
-
-    def autospace(self, elements_list, space, delimiter=' ') -> str:
-        output = ''
-        for i, element in enumerate(elements_list):
-            if i == len(elements_list):
-                output += element
-            else:
-                output += element + (space-len(element))*delimiter
-        return output
-
-    def print_groups(self, space=24, max_length=15):
-        self.log('')
-        # Get the number of groups (rows) and the maximum length of rows
-        data = self.data
-        num_groups = len(data)
-        group_longest = max(len(row) for row in data)
-
-        # Print the header
-        header = [f'Group {i+1}' for i in range(num_groups)]
-        line = [''*7]
-        self.log(self.autospace(header, space))
-        self.log(self.autospace(line, space))
-
-        # Print each column with a placeholder if longer than max_length
-        for i in range(group_longest):
-            row_values = []
-            all_values_empty = True
-            for row in data:
-                if len(row) > max_length:
-                    if i < max_length:
-                        row_values.append(str(row[i]))
-                        all_values_empty = False
-                    elif i == max_length:
-                        row_values.append(f'[{len(row) - max_length} more]')
-                        all_values_empty = False
-                    else:
-                        continue
-                else:
-                    if i < len(row):
-                        row_values.append(str(row[i]))
-                        all_values_empty = False
-                    else:
-                        row_values.append('')
-            if all_values_empty:
-                break
-            self.log(self.autospace(row_values, space))
-
-    def make_stars(self) -> int:
-        p = self.p_value.item()
-        if p is not None:
-            if p < 0.0001:
-                return 4
-            if p < 0.001:
-                return 3
-            elif p < 0.01:
-                return 2
-            elif p < 0.05:
-                return 1
-            else:
-                return 0
-        return 0
-
-    def make_p_value_printed(self) -> str:
-        p = self.p_value.item()
-        if p is not None:
-            if p > 0.99:
-                return 'p>0.99'
-            elif p >= 0.01:
-                return f'p={p:.2g}'
-            elif p >= 0.001:
-                return f'p={p:.2g}'
-            elif p >= 0.0001:
-                return f'p={p:.1g}'
-            elif p < 0.0001:
-                return 'p<0.0001'
-            else:
-                return 'N/A'
-        return 'N/A'
-
-    def print_results(self):
-        self.log('\n\nResults: \n')
-        for i in self.results:
-            shift = 27 - len(i)
-            if i == 'Warnings':
-                self.log(i, ':', ' ' * shift, len(self.results[i]))
-            elif i == 'Samples':
-                pass
-            else:
-                self.log(i, ':', ' ' * shift, self.results[i])
-
-
-class __InputFormatting():
-    def floatify_recursive(self, data):
-        if isinstance(data, list):
-            # Recursively process sublists and filter out None values
-            processed_list = [self.floatify_recursive(item) for item in data]
-            return [item for item in processed_list if item is not None]
-        else:
-            try:
-                # Try to convert the item to float
-                return np.float64(data)
-            except (ValueError, TypeError):
-                # If conversion fails, replace with None
-                self.warning_flag_non_numeric_data = True
-                return None
-
-
-class StatisticalAnalysis(__StatisticalTests, __NormalityTests, __TextFormatting, __InputFormatting, __Helpers):
+class StatisticalAnalysis(StatisticalTests, NormalityTests, TextFormatting, Helpers):
     '''
         The main class
         *documentation placeholder*
@@ -403,6 +16,7 @@ class StatisticalAnalysis(__StatisticalTests, __NormalityTests, __TextFormatting
                  paired=False,
                  tails=2,
                  popmean=None,
+                 posthoc=False,
                  verbose=True):
         self.results = None
         self.error = False
@@ -410,6 +24,7 @@ class StatisticalAnalysis(__StatisticalTests, __NormalityTests, __TextFormatting
         self.paired = paired
         self.tails = tails
         self.popmean = popmean
+        self.posthoc = posthoc
         self.verbose = verbose
         self.n_groups = len(self.groups_list)
         self.warning_flag_non_numeric_data = False
@@ -464,7 +79,7 @@ class StatisticalAnalysis(__StatisticalTests, __NormalityTests, __TextFormatting
             'no_pop_mean_set':                 '\nWarning: No Population Mean was set up for single-sample test, used default 0 value.\n         The results might be skewed. \n         Please, set the Population Mean and run the test again.\n',
         }
 
-    def __run_test(self, test='auto'):
+    def run_test(self, test='auto'):
 
         # reset values from previous tests
         self.results = None
@@ -475,9 +90,11 @@ class StatisticalAnalysis(__StatisticalTests, __NormalityTests, __TextFormatting
         self.test_id = None
         self.test_stat = None
         self.p_value = None
+        self.posthoc_matrix_df = None
+        self.posthoc_matrix = []
 
         self.log('\n' + '-'*67)
-        self.log('Statistical analysis initiated for data in {} groups\n'.format(
+        self.log('Statistical analysis __init__iated for data in {} groups\n'.format(
             len(self.groups_list)))
 
         # adjusting input data type
@@ -550,29 +167,13 @@ class StatisticalAnalysis(__StatisticalTests, __NormalityTests, __TextFormatting
         if not test == 'auto' and self.parametric and not test in self.test_ids_parametric:
             self.AddWarning('non-param_test_with_normal_data')
 
-        if test == 'anova_1w_ordinary':
-            self.anova_1w_ordinary()
-        elif test == 'anova_1w_rm':
-            self.anova_1w_rm()
-        elif test == 'friedman':
-            self.friedman_test()
-        elif test == 'kruskal_wallis':
-            self.kruskal_wallis_test()
-        elif test == 'mann_whitney':
-            self.mann_whitney_u_test()
-        elif test == 't_test_independent':
-            self.t_test_independent()
-        elif test == 't_test_paired':
-            self.t_test_paired()
-        elif test == 't_test_single_sample':
-            self.t_test_single_sample()
-        elif test == 'wilcoxon':
-            self.wilcoxon()
-        elif test == 'wilcoxon_single_sample':
-            self.wilcoxon_single_sample()
+        # run the test
+
+        if test in self.test_ids_all:
+            self.run_test_by_id(test)
         else:
-            self.log('Automatic test selection preformed.')
-            self.__auto()
+            self.run_test_auto()
+
 
         # print the results
         self.results = self.create_results_dict()
@@ -585,82 +186,49 @@ class StatisticalAnalysis(__StatisticalTests, __NormalityTests, __TextFormatting
         if self.verbose == True:
             print(self.summary)
 
-    def __auto(self):
-
-        if self.n_groups == 1:
-            if self.parametric:
-                return self.t_test_single_sample()
-            else:
-                return self.wilcoxon_single_sample()
-
-        elif self.n_groups == 2:
-            if self.paired:
-                if self.parametric:
-                    return self.t_test_paired()
-                else:
-                    return self.wilcoxon()
-            else:
-                if self.parametric:
-                    return self.t_test_independent()
-                else:
-                    return self.mann_whitney_u_test()
-
-        elif self.n_groups >= 3:
-            if self.paired:
-                if self.parametric:
-                    return self.anova_1w_rm()
-                else:
-                    return self.friedman_test()
-            else:
-                if self.parametric:
-                    return self.anova_1w_ordinary()
-                else:
-                    return self.kruskal_wallis_test()
 
-        else:
-            pass
 
     # public methods:
     def RunAuto(self):
-        self.__run_test(test='auto')
+        self.run_test(test='auto')
 
     def RunManual(self, test):
-        self.__run_test(test)
+        self.run_test(test)
 
     def RunOnewayAnova(self):
-        self.__run_test(test='anova_1w_ordinary')
+        self.run_test(test='anova_1w_ordinary')
 
     def RunOnewayAnovaRM(self):
-        self.__run_test(test='anova_1w_rm')
+        self.run_test(test='anova_1w_rm')
 
     def RunFriedman(self):
-        self.__run_test(test='friedman')
+        self.run_test(test='friedman')
 
     def RunKruskalWallis(self):
-        self.__run_test(test='kruskal_wallis')
+        self.run_test(test='kruskal_wallis')
 
     def RunMannWhitney(self):
-        self.__run_test(test='mann_whitney')
+        self.run_test(test='mann_whitney')
 
     def RunTtest(self):
-        self.__run_test(test='t_test_independent')
+        self.run_test(test='t_test_independent')
 
     def RunTtestPaired(self):
-        self.__run_test(test='t_test_paired')
+        self.run_test(test='t_test_paired')
 
     def RunTtestSingleSample(self):
-        self.__run_test(test='t_test_single_sample')
+        self.run_test(test='t_test_single_sample')
 
     def RunWilcoxonSingleSample(self):
-        self.__run_test(test='wilcoxon_single_sample')
+        self.run_test(test='wilcoxon_single_sample')
 
     def RunWilcoxon(self):
-        self.__run_test(test='wilcoxon')
+        self.run_test(test='wilcoxon')
 
     def GetResult(self):
         if not self.results and not self.error:
             print('No test chosen, no results to output')
-            # self.__run_test(test='auto')
+            # self.run_test(test='auto')
             return self.results
         if not self.results and self.error:
             print('Error occured, no results to output')
@@ -671,7 +239,7 @@ class StatisticalAnalysis(__StatisticalTests, __NormalityTests, __TextFormatting
     def GetSummary(self):
         if not self.results and not self.error:
             print('No test chosen, no summary to output')
-            # self.__run_test(test='auto')
+            # self.run_test(test='auto')
             return self.summary
         else:
             return self.summary

AutoStatLib/_version.py

@@ -1,2 +1,2 @@
 # AutoStatLib package version:
-__version__ = "0.2.1"
+__version__ = "0.2.5"

AutoStatLib/helpers.py

@@ -0,0 +1,77 @@
+import numpy as np
+import pandas as pd
+
+class Helpers():
+
+    def matrix_to_dataframe(self, matrix):
+        data = []
+        cols = []
+        rows = []
+
+        order_number = 1
+        for i, row in enumerate(matrix):
+            for j, value in enumerate(row):
+                data.append(value)
+                cols.append(i)
+                rows.append(j)
+                order_number += 1
+
+        df = pd.DataFrame(
+            {'Row': rows, 'Col': cols, 'Value': data})
+        return df
+
+    def floatify_recursive(self, data):
+        if isinstance(data, list):
+            # Recursively process sublists and filter out None values
+            processed_list = [self.floatify_recursive(item) for item in data]
+            return [item for item in processed_list if item is not None]
+        else:
+            try:
+                # Try to convert the item to float
+                return np.float64(data)
+            except (ValueError, TypeError):
+                # If conversion fails, replace with None
+                self.warning_flag_non_numeric_data = True
+                return None
+
+    def create_results_dict(self) -> dict:
+
+        self.stars_int = self.make_stars(self.p_value.item())
+        self.stars_str = self.make_stars_printed(self.stars_int)
+
+        return {
+            'p-value': self.make_p_value_printed(self.p_value.item()),
+            'Significance(p<0.05)':  True if self.p_value.item() < 0.05 else False,
+            'Stars_Printed': self.stars_str,
+            'Test_Name': self.test_name,
+            'Groups_Compared': self.n_groups,
+            'Population_Mean': self.popmean if self.n_groups == 1 else 'N/A',
+            'Data_Normaly_Distributed': self.parametric,
+            'Parametric_Test_Applied': True if self.test_id in self.test_ids_parametric else False,
+            'Paired_Test_Applied': self.paired,
+            'Tails': self.tails,
+            'p-value_exact': self.p_value.item(),
+            'Stars':  self.stars_int,
+            # 'Stat_Value': self.test_stat.item(),
+            'Warnings': self.warnings,
+            'Groups_N': [len(self.data[i]) for i in range(len(self.data))],
+            'Groups_Median': [np.median(self.data[i]).item() for i in range(len(self.data))],
+            'Groups_Mean': [np.mean(self.data[i]).item() for i in range(len(self.data))],
+            'Groups_SD': [np.std(self.data[i]).item() for i in range(len(self.data))],
+            'Groups_SE': [np.std(self.data[i]).item() / np.sqrt(len(self.data)).item() for i in range(len(self.data))],
+            # actually returns list of lists of numpy dtypes of float64, next make it return regular floats:
+            'Samples': self.data,
+            'Posthoc_Matrix': self.posthoc_matrix if self.posthoc_matrix else 'N/A',
+            'Posthoc_Matrix_printed': [[self.make_p_value_printed(element) for element in row] for row in self.posthoc_matrix] if self.posthoc_matrix else 'N/A',
+            'Posthoc_Matrix_stars': [[self.make_stars_printed(self.make_stars(element)) for element in row] for row in self.posthoc_matrix] if self.posthoc_matrix else 'N/A',
+        }
+
+    def log(self, *args, **kwargs):
+        message = ' '.join(map(str, args))
+        # print(message, **kwargs)
+        self.summary += '\n' + message
+
+    def AddWarning(self, warning_id):
+        message = self.warning_ids_all[warning_id]
+        self.log(message)
+        self.warnings.append(message)

AutoStatLib/normality_tests.py

@@ -0,0 +1,85 @@
+from statsmodels.stats.diagnostic import lilliefors
+from scipy.stats import shapiro, normaltest, anderson
+
+
+class NormalityTests():
+    '''
+        Normality tests mixin
+
+        see the article about minimal sample size for tests:
+        Power comparisons of Shapiro-Wilk, Kolmogorov-Smirnov,
+        Lilliefors and Anderson-Darling tests, Nornadiah Mohd Razali1, Yap Bee Wah1
+    '''
+
+    def check_normality(self, data):
+        sw = None
+        lf = None
+        ad = None
+        ap = None
+        n = len(data)
+
+        # Shapiro-Wilk test
+        sw_stat, sw_p_value = shapiro(data)
+        if sw_p_value > 0.05:
+            sw = True
+        else:
+            sw = False
+
+        # Lilliefors test
+        lf_stat, lf_p_value = lilliefors(
+            data, dist='norm')
+        if lf_p_value > 0.05:
+            lf = True
+        else:
+            lf = False
+
+        # Anderson-Darling test
+        if n >= 20:
+            ad_stat, ad_p_value = self.anderson_get_p(
+                data, dist='norm')
+            if ad_p_value > 0.05:
+                ad = True
+            else:
+                ad = False
+
+        # D'Agostino-Pearson test
+        # test result is skewed if n<20
+        if n >= 20:
+            ap_stat, ap_p_value = normaltest(data)
+            if ap_p_value > 0.05:
+                ap = True
+            else:
+                ap = False
+
+        # print(ap_p_value, ad_p_value, sw_p_value, lf_p_value)
+
+        return (sw, lf, ad, ap)
+
+    def anderson_get_p(self, data, dist='norm'):
+        '''
+            calculating p-value for Anderson-Darling test using the method described here:
+            Computation of Probability Associated with Anderson-Darling Statistic
+            Lorentz Jantschi and Sorana D. Bolboaca, 2018 - Mathematics
+
+        '''
+        e = 2.718281828459045
+        n = len(data)
+
+        ad, critical_values, significance_levels = anderson(
+            data, dist=dist)
+
+        # adjust ad_stat for small sample sizes:
+        s = ad*(1 + 0.75/n + 2.25/(n**2))
+
+        if s >= 0.6:
+            p = e**(1.2937 - 5.709*s + 0.0186*s**2)
+        elif s > 0.34:
+            p = e**(0.9177 - 4.279*s - 1.38*s**2)
+        elif s > 0.2:
+            p = 1 - e**(-8.318 + 42.796*s - 59.938*s**2)
+        elif s <= 0.2:
+            p = 1 - e**(-13.436 + 101.14*s - 223.73*s**2)
+        else:
+            p = None
+
+        return ad, p

AutoStatLib/statistical_tests.py

@@ -0,0 +1,173 @@
+import numpy as np
+import scikit_posthocs as sp
+from statsmodels.stats.anova import AnovaRM
+from scipy.stats import ttest_rel, ttest_ind, ttest_1samp, wilcoxon, mannwhitneyu, f_oneway, kruskal, friedmanchisquare
+
+
+
+class StatisticalTests():
+    '''
+        Statistical tests mixin
+    '''
+
+    def run_test_auto(self):
+
+        if self.n_groups == 1:
+            if self.parametric:
+                self.run_test_by_id('t_test_single_sample')
+            else:
+                self.run_test_by_id('wilcoxon_single_sample')
+
+        elif self.n_groups == 2:
+            if self.paired:
+                if self.parametric:
+                    self.run_test_by_id('t_test_paired')
+                else:
+                    self.run_test_by_id('wilcoxon')
+            else:
+                if self.parametric:
+                    self.run_test_by_id('t_test_independent')
+                else:
+                    self.run_test_by_id('mann_whitney')
+
+        elif self.n_groups >= 3:
+            if self.paired:
+                if self.parametric:
+                    self.run_test_by_id('anova_1w_rm')
+                else:
+                    self.run_test_by_id('friedman')
+            else:
+                if self.parametric:
+                    self.run_test_by_id('anova_1w_ordinary')
+                else:
+                    self.run_test_by_id('kruskal_wallis')
+
+        else:
+            pass
+
+    def run_test_by_id(self, test_id):
+
+        test_names_dict = {
+            'anova_1w_ordinary': 'Ordinary One-Way ANOVA',
+            'anova_1w_rm': 'Repeated Measures One-Way ANOVA',
+            'friedman': 'Friedman test', 
+            'kruskal_wallis': 'Kruskal-Wallis test',
+            'mann_whitney': 'Mann-Whitney U test',
+            't_test_independent': 't-test for independent samples',
+            't_test_paired': 't-test for paired samples',
+            't_test_single_sample': 'Single-sample t-test',
+            'wilcoxon': 'Wilcoxon signed-rank test',
+            'wilcoxon_single_sample': 'Wilcoxon signed-rank test for single sample',
+        }
+
+        match test_id:
+            case 'anova_1w_ordinary': stat, p_value = self.anova_1w_ordinary()
+            case 'anova_1w_rm': stat, p_value = self.anova_1w_rm()
+            case 'friedman': stat, p_value = self.friedman()
+            case 'kruskal_wallis': stat, p_value = self.kruskal_wallis()
+            case 'mann_whitney': stat, p_value = self.mann_whitney()
+            case 't_test_independent': stat, p_value = self.t_test_independent()
+            case 't_test_paired': stat, p_value = self.t_test_paired()
+            case 't_test_single_sample': stat, p_value = self.t_test_single_sample()
+            case 'wilcoxon': stat, p_value = self.wilcoxon()
+            case 'wilcoxon_single_sample': stat, p_value = self.wilcoxon_single_sample()
+
+        if test_id in self.test_ids_dependent:
+            self.paired = True
+        else:
+            self.paired = False
+
+        self.test_name = test_names_dict[test_id]
+        self.test_id = test_id
+        self.test_stat = stat
+        self.p_value = p_value
+
+    def anova_1w_ordinary(self):
+        stat, p_value = f_oneway(*self.data)
+        self.tails = 2
+        # if self.tails == 1 and p_value > 0.5:
+        #     p_value /= 2
+        # if self.tails == 1:
+        #     p_value /= 2
+        return stat, p_value
+
+    def anova_1w_rm(self):
+        """
+        Perform repeated measures one-way ANOVA test.
+
+        Parameters:
+        data: list of lists, where each sublist represents repeated measures for a subject
+        """
+
+        df = self.matrix_to_dataframe(self.data)
+        res = AnovaRM(df, 'Value', 'Row', within=['Col']).fit()
+        stat = res.anova_table['F Value'][0]
+        p_value = res.anova_table['Pr > F'][0]
+
+        self.tails = 2
+        return stat, p_value
+
+    def friedman(self):
+        stat, p_value = friedmanchisquare(*self.data)
+        self.tails = 2
+        return stat, p_value
+
+    def kruskal_wallis(self):
+        stat, p_value = kruskal(*self.data)
+
+        # Perform Dunn's multiple comparisons if Kruskal-Wallis is significant
+        if p_value < 0.05 and self.posthoc:
+            self.posthoc_matrix = sp.posthoc_dunn(self.data, p_adjust='bonferroni').values.tolist()
+        return stat, p_value
+
+    def mann_whitney(self):
+        stat, p_value = mannwhitneyu(
+            self.data[0], self.data[1], alternative='two-sided')
+        if self.tails == 1:
+            p_value /= 2
+        # alternative method of one-tailed calculation
+        # gives the same result:
+        # stat, p_value = mannwhitneyu(
+        #     self.data[0], self.data[1], alternative='two-sided' if self.tails == 2 else 'less')
+        # if self.tails == 1 and p_value > 0.5:
+        #     p_value = 1-p_value
+        return stat, p_value
+
+    def t_test_independent(self):
+        stat, p_value = ttest_ind(
+            self.data[0], self.data[1])
+        if self.tails == 1:
+            p_value /= 2
+        return stat, p_value
+
+    def t_test_paired(self):
+        stat, p_value = ttest_rel(
+            self.data[0], self.data[1])
+        if self.tails == 1:
+            p_value /= 2
+        return stat, p_value
+
+    def t_test_single_sample(self):
+        if self.popmean == None:
+            self.popmean = 0
+            self.AddWarning('no_pop_mean_set')
+        stat, p_value = ttest_1samp(self.data[0], self.popmean)
+        if self.tails == 1:
+            p_value /= 2
+        return stat, p_value
+
+    def wilcoxon(self):
+        stat, p_value = wilcoxon(self.data[0], self.data[1])
+        if self.tails == 1:
+            p_value /= 2
+        return stat, p_value
+        
+    def wilcoxon_single_sample(self):
+        if self.popmean == None:
+            self.popmean = 0
+            self.AddWarning('no_pop_mean_set')
+        data = [i - self.popmean for i in self.data[0]]
+        stat, p_value = wilcoxon(data)
+        if self.tails == 1:
+            p_value /= 2
+        return stat, p_value

AutoStatLib/text_formatting.py

@@ -0,0 +1,98 @@
+
+
+class TextFormatting():
+    '''
+        Text formatting mixin
+    '''
+
+    def autospace(self, elements_list, space, delimiter=' ') -> str:
+        output = ''
+        for i, element in enumerate(elements_list):
+            if i == len(elements_list):
+                output += element
+            else:
+                output += element + (space-len(element))*delimiter
+        return output
+
+    def print_groups(self, space=24, max_length=15):
+        self.log('')
+        # Get the number of groups (rows) and the maximum length of rows
+        data = self.data
+        num_groups = len(data)
+        group_longest = max(len(row) for row in data)
+
+        # Print the header
+        header = [f'Group {i+1}' for i in range(num_groups)]
+        line = [''*7]
+        self.log(self.autospace(header, space))
+        self.log(self.autospace(line, space))
+
+        # Print each column with a placeholder if longer than max_length
+        for i in range(group_longest):
+            row_values = []
+            all_values_empty = True
+            for row in data:
+                if len(row) > max_length:
+                    if i < max_length:
+                        row_values.append(str(row[i]))
+                        all_values_empty = False
+                    elif i == max_length:
+                        row_values.append(f'[{len(row) - max_length} more]')
+                        all_values_empty = False
+                    else:
+                        continue
+                else:
+                    if i < len(row):
+                        row_values.append(str(row[i]))
+                        all_values_empty = False
+                    else:
+                        row_values.append('')
+            if all_values_empty:
+                break
+            self.log(self.autospace(row_values, space))
+
+    def make_stars(self, p) -> int:
+        if p is not None:
+            if p < 0.0001:
+                return 4
+            if p < 0.001:
+                return 3
+            elif p < 0.01:
+                return 2
+            elif p < 0.05:
+                return 1
+            else:
+                return 0
+        return 0
+
+    def make_stars_printed(self, n) -> str:
+        return '*' * n if n else 'ns'
+
+    def make_p_value_printed(self, p) -> str:
+        if p is not None:
+            if p > 0.99:
+                return 'p>0.99'
+            elif p >= 0.01:
+                return f'p={p:.2g}'
+            elif p >= 0.001:
+                return f'p={p:.2g}'
+            elif p >= 0.0001:
+                return f'p={p:.1g}'
+            elif p < 0.0001:
+                return 'p<0.0001'
+            else:
+                return 'N/A'
+        return 'N/A'
+
+    def print_results(self):
+        self.log('\n\nResults: \n')
+        for i in self.results:
+            shift = 27 - len(i)
+            if i == 'Warnings':
+                self.log(i, ':', ' ' * shift, len(self.results[i]))
+            if i == 'Posthoc_Matrix':
+                self.log(i, ':', ' ' * shift, '{0}x{0} matrix'.format(len(self.results[i])))
+            elif i == 'Samples' or i == 'Posthoc_Matrix_printed' or i == 'Posthoc_Matrix_stars':
+                pass
+            else:
+                self.log(i, ':', ' ' * shift, self.results[i])

{AutoStatLib-0.2.1.dist-info → AutoStatLib-0.2.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: AutoStatLib
-Version: 0.2.1
+Version: 0.2.5
 Summary: AutoStatLib - a simple statistical analysis tool
 Author: Stemonitis, SciWare LLC
 Author-email: konung-yaropolk <yaropolk1995@gmail.com>
@@ -531,6 +531,7 @@ License-File: LICENSE
 Requires-Dist: numpy
 Requires-Dist: scipy
 Requires-Dist: statsmodels
+Requires-Dist: scikit-posthocs
 Requires-Dist: pandas
 
 # AutoStatLib - python library for automated statistical analysis 
@@ -595,10 +596,11 @@ analysis.RunTtestPaired()
 analysis.RunWilcoxon()
 
 # 3 and more independed groups comparison:
-analysis.RunAnova()
+analysis.RunOnewayAnova()
 analysis.RunKruskalWallis()
 
 # 3 and more depended groups comparison:
+analysis.RunOnewayAnovaRM()
 analysis.RunFriedman()
 
 # single group tests"
@@ -648,20 +650,42 @@ If errors occured, *GetResult()* returns an empty dictionary
 
 
 ---
-## Pre-Alpha dev status.
-
-### TODO:
-
---Kruskal-Wallis test - add Dunn's multiple comparisons
---Anova: add 2-way anova and 3-way(?)
-
-check:
---Wilcoxon signed-rank test and Mann-whitney - check mechanism of one-tailed calc, looks like it works wrong
-
-
-checked tests:
---Wilcoxon 2 tail - ok
---Mann-whitney 2 tail - ok
+## Pre-Alpha dev status.  
+  
+### TODO:  
+  
+-- Anova: posthocs  
+-- Anova: add 2-way anova and 3-way anova  
+-- onevay Anova: add repeated measures (for normal dependent values) with and without Gaisser-Greenhouse correction  
+-- onevay Anova: add Brown-Forsithe and Welch (for normal independent values with unequal SDs between groups)  
+-- paired T-test: add ratio-paired t-test (ratios of paired values are consistent)  
+-- add Welch test (for norm data unequal variances)
+-- add Kolmogorov-smirnov test (unpaired nonparametric 2 sample, compare cumulative distributions)  
+-- add independent t-test with Welch correction (do not assume equal SDs in groups)  
+-- add correlation test, correlation diagram  
+-- add linear regression, regression diagram  
+-- add QQ plot
+-- n-sample tests: add onetail option
+  
+✅ done -- detailed normality test results  
+✅ done -- added posthoc: Kruskal-Wallis Dunn's multiple comparisons 
+
+  
+tests check:  
+1-sample:  
+--Wilcoxon 2,1 tails - ok  
+--t-tests 2,1 tails -ok  
+  
+2-sample:  
+--Wilcoxon 2,1 tails - ok  
+--Mann-whitney 2,1 tails - ok  
+--t-tests 2,1 tails -ok  
+  
+n-sample:  
+--Kruskal-Wallis 2 tail - ok  
+--Dunn's multiple comparisons - ??
+--Friedman 2 tail - ok  
+--one-way ANOWA 2 tail - ok  
 
 
 

AutoStatLib-0.2.5.dist-info/RECORD

@@ -0,0 +1,13 @@
+AutoStatLib/AutoStatLib.py,sha256=yPNnwCvHSSlEKQvtnoaLFDq6znPlXCz-CrzGInG-1Ys,9647
+AutoStatLib/__init__.py,sha256=0wHYnglzKRPqSHtZlfbMEA2Bj5rDR4LLaXbOrJi-sqM,101
+AutoStatLib/__main__.py,sha256=ROKWensrxDh3Gl-yhexJ-BYFohDSh9y-CuMkaLpmnnQ,247
+AutoStatLib/_version.py,sha256=-QrGYOb9bx4vC_twSInOBJoijtj78lvUzV19y4-tH38,53
+AutoStatLib/helpers.py,sha256=9Fj9pHlXSM3tGHF5L0-i6DilA9VZk6Re93ob_IRxsYg,3424
+AutoStatLib/normality_tests.py,sha256=wvOmo6F7drnhhikoGltyQJC4OBk3PLCszY6ItJk1e0M,2385
+AutoStatLib/statistical_tests.py,sha256=LDcBRkq56hepR23RZtbBnZOs9k9frVjmiB2EKiEkCYs,5990
+AutoStatLib/text_formatting.py,sha256=ShE4BRO69lsC1VT3SsYrmPkuvW7QnyfHVPZEbjNQ_hI,3250
+AutoStatLib-0.2.5.dist-info/LICENSE,sha256=IMF9i4xIpgCADf0U-V1cuf9HBmqWQd3qtI3FSuyW4zE,26526
+AutoStatLib-0.2.5.dist-info/METADATA,sha256=qJxSrqHlL0wsqaH-ah6MAJa15ikH4NCco1dyVxuNlWs,36572
+AutoStatLib-0.2.5.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+AutoStatLib-0.2.5.dist-info/top_level.txt,sha256=BuHzVyE2andc7RwD_UPmDjLl9CUAyBH6WHZGjaIReUI,12
+AutoStatLib-0.2.5.dist-info/RECORD,,

AutoStatLib-0.2.1.dist-info/RECORD

@@ -1,9 +0,0 @@
-AutoStatLib/AutoStatLib.py,sha256=_Id6bJb1OmGpUyfB0ho6-2F9S_8YO8euMB-prLjfpPI,23976
-AutoStatLib/__init__.py,sha256=0wHYnglzKRPqSHtZlfbMEA2Bj5rDR4LLaXbOrJi-sqM,101
-AutoStatLib/__main__.py,sha256=ROKWensrxDh3Gl-yhexJ-BYFohDSh9y-CuMkaLpmnnQ,247
-AutoStatLib/_version.py,sha256=jkitUHmog4Z-O5_8BUMHBBb92A758Kea22juu9b2a2Q,53
-AutoStatLib-0.2.1.dist-info/LICENSE,sha256=IMF9i4xIpgCADf0U-V1cuf9HBmqWQd3qtI3FSuyW4zE,26526
-AutoStatLib-0.2.1.dist-info/METADATA,sha256=PFpKRRElBXYciMgOuMRI8wsoCKkX9iiwMVNJthvC_3A,35569
-AutoStatLib-0.2.1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-AutoStatLib-0.2.1.dist-info/top_level.txt,sha256=BuHzVyE2andc7RwD_UPmDjLl9CUAyBH6WHZGjaIReUI,12
-AutoStatLib-0.2.1.dist-info/RECORD,,