AutoStatLib 0.2.2__tar.gz → 0.2.6__tar.gz

{autostatlib-0.2.2/src/AutoStatLib.egg-info → autostatlib-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: AutoStatLib
-Version: 0.2.2
+Version: 0.2.6
 Summary: AutoStatLib - a simple statistical analysis tool
 Author: Stemonitis, SciWare LLC
 Author-email: konung-yaropolk <yaropolk1995@gmail.com>
@@ -509,15 +509,16 @@ License:                   GNU LESSER GENERAL PUBLIC LICENSE
         
         That's all there is to it!
         
-Project-URL: Homepage, https://github.com/konung-yaropolk/NPL
-Project-URL: Issues, https://github.com/konung-yaropolk/NPL/issues
+Project-URL: Homepage, https://github.com/konung-yaropolk/AutoStatLib
+Project-URL: Repository, https://github.com/konung-yaropolk/AutoStatLib.git
+Project-URL: Issues, https://github.com/konung-yaropolk/AutoStatLib/issues
 Keywords: Science,Statistics
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: License :: OSI Approved :: GNU Lesser General Public License v2 or later (LGPLv2+)
 Classifier: Operating System :: OS Independent
-Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
 Classifier: Natural Language :: English
@@ -531,6 +532,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 
@@ -619,26 +621,30 @@ results = analysis.GetResult()
 The results dictionary keys with representing value types:
 ```
 {
-    'p-value':                     String
-    'Significance(p<0.05)':        Boolean
-    'Stars_Printed':               String
-    'Test_Name':                   String
-    'Groups_Compared':             Integer
-    'Population_Mean':             Float   (taken from the input)
-    'Data_Normaly_Distributed':    Boolean
-    'Parametric_Test_Applied':     Boolean
-    'Paired_Test_Applied':         Boolean
-    'Tails':                       Integer (taken from the input)
-    'p-value_exact':               Float
-    'Stars':                       Integer
-    'Warnings':                    String
-    'Groups_N':                    List of integers
-    'Groups_Median':               List of floats
-    'Groups_Mean':                 List of floats
-    'Groups_SD':                   List of floats
-    'Groups_SE':                   List of floats
-    'Samples':                     List of input values by groups
+    'p-value' :                    String
+    'Significance(p<0.05)' :       Boolean
+    'Stars_Printed' :              String
+    'Test_Name' :                  String
+    'Groups_Compared' :            Integer
+    'Population_Mean' :            Float   (taken from the input)
+    'Data_Normaly_Distributed' :   Boolean
+    'Parametric_Test_Applied' :    Boolean
+    'Paired_Test_Applied' :        Boolean
+    'Tails' :                      Integer (taken from the input)
+    'p-value_exact' :              Float
+    'Stars' :                      Integer
+    'Warnings' :                   String
+    'Groups_N' :                   List of integers
+    'Groups_Median' :              List of floats
+    'Groups_Mean' :                List of floats
+    'Groups_SD' :                  List of floats
+    'Groups_SE' :                  List of floats
+    'Samples' :                    List of input values by groups
                                            (taken from the input)
+    'Posthoc_Matrix' :             2D List of floats
+    'Posthoc_Matrix_bool' :        2D List of Boolean
+    'Posthoc_Matrix_printed':      2D List of String
+    'Posthoc_Matrix_stars':        2D List of String
 }
 ```
 If errors occured, *GetResult()* returns an empty dictionary
@@ -653,7 +659,7 @@ If errors occured, *GetResult()* returns an empty dictionary
   
 ### TODO:  
   
--- Kruskal-Wallis test - add Dunn's multiple comparisons  
+-- 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)  
@@ -666,10 +672,11 @@ If errors occured, *GetResult()* returns an empty dictionary
 -- add QQ plot
 -- n-sample tests: add onetail option
   
-✅ done -- detailed normality test results
+✅ done -- detailed normality test results  
+✅ done -- added posthoc: Kruskal-Wallis Dunn's multiple comparisons 
 
   
-checked tests:  
+tests check:  
 1-sample:  
 --Wilcoxon 2,1 tails - ok  
 --t-tests 2,1 tails -ok  
@@ -681,6 +688,7 @@ checked tests:
   
 n-sample:  
 --Kruskal-Wallis 2 tail - ok  
+--Dunn's multiple comparisons - ??
 --Friedman 2 tail - ok  
 --one-way ANOWA 2 tail - ok  
 

{autostatlib-0.2.2 → autostatlib-0.2.6}/README.md

@@ -84,26 +84,30 @@ results = analysis.GetResult()
 The results dictionary keys with representing value types:
 ```
 {
-    'p-value':                     String
-    'Significance(p<0.05)':        Boolean
-    'Stars_Printed':               String
-    'Test_Name':                   String
-    'Groups_Compared':             Integer
-    'Population_Mean':             Float   (taken from the input)
-    'Data_Normaly_Distributed':    Boolean
-    'Parametric_Test_Applied':     Boolean
-    'Paired_Test_Applied':         Boolean
-    'Tails':                       Integer (taken from the input)
-    'p-value_exact':               Float
-    'Stars':                       Integer
-    'Warnings':                    String
-    'Groups_N':                    List of integers
-    'Groups_Median':               List of floats
-    'Groups_Mean':                 List of floats
-    'Groups_SD':                   List of floats
-    'Groups_SE':                   List of floats
-    'Samples':                     List of input values by groups
+    'p-value' :                    String
+    'Significance(p<0.05)' :       Boolean
+    'Stars_Printed' :              String
+    'Test_Name' :                  String
+    'Groups_Compared' :            Integer
+    'Population_Mean' :            Float   (taken from the input)
+    'Data_Normaly_Distributed' :   Boolean
+    'Parametric_Test_Applied' :    Boolean
+    'Paired_Test_Applied' :        Boolean
+    'Tails' :                      Integer (taken from the input)
+    'p-value_exact' :              Float
+    'Stars' :                      Integer
+    'Warnings' :                   String
+    'Groups_N' :                   List of integers
+    'Groups_Median' :              List of floats
+    'Groups_Mean' :                List of floats
+    'Groups_SD' :                  List of floats
+    'Groups_SE' :                  List of floats
+    'Samples' :                    List of input values by groups
                                            (taken from the input)
+    'Posthoc_Matrix' :             2D List of floats
+    'Posthoc_Matrix_bool' :        2D List of Boolean
+    'Posthoc_Matrix_printed':      2D List of String
+    'Posthoc_Matrix_stars':        2D List of String
 }
 ```
 If errors occured, *GetResult()* returns an empty dictionary
@@ -118,7 +122,7 @@ If errors occured, *GetResult()* returns an empty dictionary
   
 ### TODO:  
   
--- Kruskal-Wallis test - add Dunn's multiple comparisons  
+-- 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)  
@@ -131,10 +135,11 @@ If errors occured, *GetResult()* returns an empty dictionary
 -- add QQ plot
 -- n-sample tests: add onetail option
   
-✅ done -- detailed normality test results
+✅ done -- detailed normality test results  
+✅ done -- added posthoc: Kruskal-Wallis Dunn's multiple comparisons 
 
   
-checked tests:  
+tests check:  
 1-sample:  
 --Wilcoxon 2,1 tails - ok  
 --t-tests 2,1 tails -ok  
@@ -146,6 +151,7 @@ checked tests:
   
 n-sample:  
 --Kruskal-Wallis 2 tail - ok  
+--Dunn's multiple comparisons - ??
 --Friedman 2 tail - ok  
 --one-way ANOWA 2 tail - ok  
 

{autostatlib-0.2.2 → autostatlib-0.2.6}/pyproject.toml

@@ -1,5 +1,5 @@
 [build-system]
-requires = ["setuptools>=62.6", "numpy", "scipy", "statsmodels"]
+requires = ["setuptools>=62.6", "numpy", "scipy", "statsmodels", "scikit-posthocs"]
 build-backend = "setuptools.build_meta"
 
 [project]
@@ -21,7 +21,7 @@ classifiers = [
     "Programming Language :: Python :: 3.12",
     "License :: OSI Approved :: GNU Lesser General Public License v2 or later (LGPLv2+)",
     "Operating System :: OS Independent",
-    "Development Status :: 2 - Pre-Alpha",
+    "Development Status :: 4 - Beta",
     "Intended Audience :: Developers",
     "Intended Audience :: Science/Research",
     "Natural Language :: English",
@@ -32,8 +32,9 @@ classifiers = [
 ]
 
 [project.urls]
-Homepage = "https://github.com/konung-yaropolk/NPL"
-Issues = "https://github.com/konung-yaropolk/NPL/issues"
+Homepage = "https://github.com/konung-yaropolk/AutoStatLib"
+Repository = "https://github.com/konung-yaropolk/AutoStatLib.git"
+Issues = "https://github.com/konung-yaropolk/AutoStatLib/issues"
 
 [tool.setuptools.dynamic]
 version = {attr = "AutoStatLib.__version__"}

{autostatlib-0.2.2 → autostatlib-0.2.6}/requirements.txt

@@ -1,4 +1,5 @@
 numpy
 scipy
 statsmodels
-pandas
+scikit-posthocs
+pandas

autostatlib-0.2.6/src/AutoStatLib/AutoStatLib.py

@@ -0,0 +1,254 @@
+from AutoStatLib.statistical_tests import StatisticalTests
+from AutoStatLib.normality_tests import NormalityTests
+from AutoStatLib.helpers import Helpers
+from AutoStatLib.text_formatting import TextFormatting
+
+
+class StatisticalAnalysis(StatisticalTests, NormalityTests, TextFormatting, Helpers):
+    '''
+        The main class
+        *documentation placeholder*
+
+    '''
+
+    def __init__(self,
+                 groups_list,
+                 paired=False,
+                 tails=2,
+                 popmean=None,
+                 posthoc=True,
+                 verbose=True):
+        self.results = None
+        self.error = False
+        self.groups_list = groups_list
+        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
+        self.summary = ''
+
+        # test IDs classification:
+        self.test_ids_all = [  # in aplhabetical order
+            'anova_1w_ordinary',
+            'anova_1w_rm',
+            'friedman',
+            'kruskal_wallis',
+            'mann_whitney',
+            't_test_independent',
+            't_test_paired',
+            't_test_single_sample',
+            'wilcoxon',
+            'wilcoxon_single_sample',
+        ]
+        self.test_ids_parametric = [
+            'anova_1w_ordinary',
+            'anova_1w_rm'
+            't_test_independent',
+            't_test_paired',
+            't_test_single_sample',
+        ]
+        self.test_ids_dependent = [
+            'anova_1w_rm',
+            'friedman',
+            't_test_paired',
+            'wilcoxon',
+        ]
+        self.test_ids_3sample = [
+            'anova_1w_ordinary',
+            'anova_1w_rm',
+            'friedman',
+            'kruskal_wallis',
+        ]
+        self.test_ids_2sample = [
+            'mann_whitney',
+            't_test_independent',
+            't_test_paired',
+            'wilcoxon',
+        ]
+        self.test_ids_1sample = [
+            't_test_single_sample',
+            'wilcoxon_single_sample',
+        ]
+        self.warning_ids_all = {
+            # 'not-numeric':                     '\nWarning: Non-numeric data was found in input and ignored.\n         Make sure the input data is correct to get the correct results\n',
+            'param_test_with_non-normal_data': '\nWarning: Parametric test was manualy chosen for Not-Normaly distributed data.\n         The results might be skewed. \n         Please, run non-parametric test or preform automatic test selection.\n',
+            'non-param_test_with_normal_data': '\nWarning: Non-Parametric test was manualy chosen for Normaly distributed data.\n         The results might be skewed. \n         Please, run parametric test or preform automatic test selection.\n',
+            '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'):
+
+        # reset values from previous tests
+        self.results = None
+        self.error = False
+        self.warnings = []
+        self.normals = []
+        self.test_name = None
+        self.test_id = None
+        self.test_stat = None
+        self.p_value = None
+        self.posthoc_matrix_df = None
+        self.posthoc_matrix = []
+        self.posthoc_name = None
+
+        self.log('\n' + '-'*67)
+        self.log('Statistical analysis __init__iated for data in {} groups\n'.format(
+            len(self.groups_list)))
+
+        # adjusting input data type
+        self.data = self.floatify_recursive(self.groups_list)
+        if self.warning_flag_non_numeric_data:
+            self.log(
+                'Text or other non-numeric data in the input was ignored:')
+
+        # delete the empty cols from input
+        self.data = [col for col in self.data if any(
+            x is not None for x in col)]
+
+        # User input assertion block
+        try:
+            assert self.data, 'There is no input data'
+            assert self.tails in [1, 2], 'Tails parameter can be 1 or 2 only'
+            assert test in self.test_ids_all or test == 'auto', 'Wrong test id choosen, ensure you called correct function'
+            assert all(len(
+                group) >= 4 for group in self.data), 'Each group must contain at least four values'
+            assert not (self.paired == True
+                        and not all(len(lst) == len(self.data[0]) for lst in self.data)), 'Paired groups must have the same length'
+            assert not (test in self.test_ids_dependent
+                        and not all(len(lst) == len(self.data[0]) for lst in self.data)), 'Groups must have the same length for dependent groups test'
+            assert not (test in self.test_ids_2sample
+                        and self.n_groups != 2), f'Only two groups of data must be given for 2-groups tests, got {self.n_groups}'
+            assert not (test in self.test_ids_1sample
+                        and self.n_groups > 1), f'Only one group of data must be given for single-group tests, got {self.n_groups}'
+            assert not (test in self.test_ids_3sample
+                        and self.n_groups < 3), f'At least three groups of data must be given for multi-groups tests, got {self.n_groups}'
+        except AssertionError as error:
+            self.log('\nTest  :', test)
+            self.log('Error :', error)
+            self.log('-'*67 + '\n')
+            self.error = True
+            print(self.summary)
+            return
+
+        # Print the data
+        self.print_groups()
+
+        # Normality tests
+        self.log(
+            '\n\nThe group is assumed to be normally distributed if at least one')
+        self.log(
+            'normality test result is positive. Normality checked by tests:')
+        self.log('Shapiro-Wilk, Lilliefors, Anderson-Darling, D\'Agostino-Pearson')
+        self.log(
+            '[+] -positive, [-] -negative, [ ] -too small group for the test\n')
+        self.log('        Test   :   SW  LF  AD  AP  ')
+        for i, data in enumerate(self.data):
+            poll = self.check_normality(data)
+            isnormal = any(poll)
+            poll_print = tuple(
+                '+' if x is True else '-' if x is False else ' ' if x is None else 'e' for x in poll)
+            self.normals.append(isnormal)
+            self.log(
+                f'        Group {i+1}:    {poll_print[0]}   {poll_print[1]}   {poll_print[2]}   {poll_print[3]}   so disrtibution seems {"normal" if isnormal else "not normal"}')
+        self.parametric = all(self.normals)
+
+        # print test choosen
+        self.log('\n\nInput:\n')
+        self.log('Data Normaly Distributed:     ', self.parametric)
+        self.log('Paired Groups:                ', self.paired)
+        self.log('Groups:                       ', self.n_groups)
+        self.log('Test chosen by user:          ', test)
+
+        # Wrong test Warnings
+        if not test == 'auto' and not self.parametric and test in self.test_ids_parametric:
+            self.AddWarning('param_test_with_non-normal_data')
+        if not test == 'auto' and self.parametric and not test in self.test_ids_parametric:
+            self.AddWarning('non-param_test_with_normal_data')
+
+        # run the test
+
+        if test in self.test_ids_all:
+            self.run_test_by_id(test)
+        else:
+            self.run_test_auto()
+
+        # print the results
+        self.results = self.create_results_dict()
+        self.print_results()
+        self.log(
+            '\n\nResults above are accessible as a dictionary via GetResult() method')
+        self.log('-'*67 + '\n')
+
+        # print the results to console:
+        if self.verbose == True:
+            print(self.summary)
+
+    # public methods:
+
+    def RunAuto(self):
+        self.run_test(test='auto')
+
+    def RunManual(self, test):
+        self.run_test(test)
+
+    def RunOnewayAnova(self):
+        self.run_test(test='anova_1w_ordinary')
+
+    def RunOnewayAnovaRM(self):
+        self.run_test(test='anova_1w_rm')
+
+    def RunFriedman(self):
+        self.run_test(test='friedman')
+
+    def RunKruskalWallis(self):
+        self.run_test(test='kruskal_wallis')
+
+    def RunMannWhitney(self):
+        self.run_test(test='mann_whitney')
+
+    def RunTtest(self):
+        self.run_test(test='t_test_independent')
+
+    def RunTtestPaired(self):
+        self.run_test(test='t_test_paired')
+
+    def RunTtestSingleSample(self):
+        self.run_test(test='t_test_single_sample')
+
+    def RunWilcoxonSingleSample(self):
+        self.run_test(test='wilcoxon_single_sample')
+
+    def RunWilcoxon(self):
+        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')
+            return self.results
+        if not self.results and self.error:
+            print('Error occured, no results to output')
+            return {}
+        else:
+            return self.results
+
+    def GetSummary(self):
+        if not self.results and not self.error:
+            print('No test chosen, no summary to output')
+            # self.run_test(test='auto')
+            return self.summary
+        else:
+            return self.summary
+
+    def GetTestIDs(self):
+        return self.test_ids_all
+
+    def PrintSummary(self):
+        print(self.summary)
+
+
+if __name__ == '__main__':
+    print('This package works as an imported module only.\nUse "import autostatlib" statement')

{autostatlib-0.2.2 → autostatlib-0.2.6}/src/AutoStatLib/_version.py

@@ -1,2 +1,2 @@
 # AutoStatLib package version:
-__version__ = "0.2.2"
+__version__ = "0.2.6"

autostatlib-0.2.6/src/AutoStatLib/helpers.py

@@ -0,0 +1,80 @@
+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_Tests_Name': self.posthoc_name if self.posthoc_name is not None else '',
+            'Posthoc_Matrix': self.posthoc_matrix if self.posthoc_matrix else [],
+            'Posthoc_Matrix_bool': [[bool(element) for element in row] for row in self.posthoc_matrix] if self.posthoc_matrix else [],
+            'Posthoc_Matrix_printed': [[self.make_p_value_printed(element) for element in row] for row in self.posthoc_matrix] if self.posthoc_matrix else [],
+            '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 [],
+        }
+
+    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-0.2.6/src/AutoStatLib/normality_tests.py

@@ -0,0 +1,83 @@
+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 and 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 and 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 and 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 and ap_p_value > 0.05:
+                ap = True
+            else:
+                ap = False
+
+        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