From 4153f9767932cd02c2e32812bd43a7fbf2838a52 Mon Sep 17 00:00:00 2001 From: Benjamin Bertrand Date: Sat, 9 Jan 2016 12:34:46 +0300 Subject: [PATCH] WeightedDataset have been created --- pymath/__init__.py | 2 +- pymath/stat/__init__.py | 1 + pymath/stat/weightedDataset.py | 299 +++++++++++---------------------- 3 files changed, 98 insertions(+), 204 deletions(-) diff --git a/pymath/__init__.py b/pymath/__init__.py index f4effb6..53fb338 100644 --- a/pymath/__init__.py +++ b/pymath/__init__.py @@ -2,7 +2,7 @@ # encoding: utf-8 from .calculus import Expression, Polynom, Fraction, random_str -from .stat import Dataset +from .stat import Dataset, WeightedDataset # ----------------------------- # Reglages pour 'vim' diff --git a/pymath/stat/__init__.py b/pymath/stat/__init__.py index 9573133..f5b4d75 100644 --- a/pymath/stat/__init__.py +++ b/pymath/stat/__init__.py @@ -2,6 +2,7 @@ # encoding: utf-8 from .dataset import Dataset +from .weightedDataset import WeightedDataset # ----------------------------- # Reglages pour 'vim' diff --git a/pymath/stat/weightedDataset.py b/pymath/stat/weightedDataset.py index c2d00fe..1727891 100644 --- a/pymath/stat/weightedDataset.py +++ b/pymath/stat/weightedDataset.py @@ -7,95 +7,79 @@ # # -from math import sqrt, cos, ceil +from math import sqrt, ceil +from collections import Counter +from .dataset import Dataset +from ..calculus.generic import flatten_list -class Serie(): - """ Classe réprésentant un série statistique avec rendu latex """ + +class WeightedDataset(dict): + """ A weighted dataset with statistics and latex rendering methods - def __init__(self, valeurs = None, val_name = "Valeurs", effectifs = None, eff_name = "Effectifs", random = 0): + >>> w = WeightedDataset([1, 2, 3, 4], "Enfants", [10, 11, 12, 13]) + >>> print(w) + {1: 10, 2: 11, 3: 12, 4: 13} + >>> w.effectif_total() + 46 + >>> w.sum() + 120 + >>> w.mean() + 2.608695652173913 + >>> w.deviation() + 56.95652173913044 + >>> w.variance() + 1.2381852551984878 + >>> w.sd() + 1.1127377297451937 + + """ + + def __init__(self, datas = [], data_name = "Valeurs", weights = [], weight_name = "Effectifs"): """ - Initialisation de la série statistique - Les paramètres sont optionnels ils pourront être ajouté après la création de la série - - :param valeurs: valeurs de la série statistique - :param val_name: nom pour les "valeurs" - :param effectifs: effectifs de chaque - :param eff_name: nom pour les "effectifs" - :param random: taille de série si elle doit être initialisé aléatoirement (uniformement sur [0,1] + Initiate the WeightedDataset """ - self.set_serie = False - if valeurs: - self.set_values(valeurs, effectifs) - - self.val_name = val_name - self.eff_name = eff_name - - def set_values(self, valeurs, effectifs = None): - """ - Effecte les valeurs de la série statistique - /!\ mettre les valeurs dans l'ordre croissant si elles sont pondérées!! - - :param valeurs: valeurs de la série statistique - :param effectifs: effectifs de chaque - """ - if not effectifs: - effectifs = [1]*len(valeurs) - valeurs.sort() - - if len(valeurs) != len(effectifs): - raise ValueError("Valeurs et effectifs ne sont pas de la même longueur") - - dict_tmp = [(v,effectifs[i]) for (i,v) in enumerate(valeurs)] - - self.serie = dict(dict_tmp) - self.valeurs = valeurs - self.effectifs = effectifs - self.effectif_total = sum(self.effectifs) - - # On classe les données dans un dictionnaire - # Il faut plutot utiliser un dictionnaire car il trie automatiquement dans l'ordre croissant les clés. - self.serie = {} - for (i,v) in enumerate(self.valeurs): - if v in self.serie.keys(): - self.serie[v] += self.effectifs[i] + if datas and not weights: + weightedDatas = Counter(datas) + elif datas and weights: + if len(datas) != len(weights): + raise ValueError("Datas and weights should have same length") else: - self.serie[v] = self.effectifs[i] + weightedDatas = {i[0]:i[1] for i in zip(datas, weights)} - # On garde une forme (valeur, effectif) pour pouvoir trier les éléments car les dictionnaires ne le permettent pas) - self.serieCouple = [(v,e) for (v,e) in self.serie.items()] - self.serieCouple.sort(key = lambda s:s[0]) + dict.__init__(self, weightedDatas) - self.set_serie = True - - def moyenne(self): - """ - Calcul la moyenne des valeurs pondérées par les effectifs (s'ils ont été passé en arguments) - - :return: renvoie la moyenne. - """ - if self.set_serie: - val_eff = [i*self.serie[i] for i in self.serie] - return sum(val_eff) / self.effectif_total - else: - raise ValueError("La série statistique n'a pas été rentrée") + self.data_name = data_name + self.weight_name = weight_name + def add_data(self, data, weight = 1): + try: + self[data] += weight + except KeyError: + self[data] = weight + + def total_weight(self): + return sum(self.values()) + + def effectif_total(self): + return self.total_weight() + + def sum(self): + """ Not really a sum but the sum of the product of key and values """ + return sum([k*v for (k,v) in self.items()]) + + def mean(self): + return self.sum()/self.effectif_total() + + def deviation(self): + """ Compute the deviation (not normalized) """ + mean = self.mean() + return sum([v*(k - mean)**2 for (k,v) in self.items()]) + def variance(self): - """ - Calcul la variance des valeurs pondérées par les effectifs (s'ils ont été passé en arguments) + return self.deviation()/self.effectif_total() - :return: renvoie la variance - """ - moy = self.moyenne() - ecart = [self.serie[v] * (v - moy)**2 for v in self.serie.keys()] - - return sum(ecart) / self.effectif_total - - def ecart_type(self): - """ - Calcul l'écart type des valeurs pondérées par les effectifs (s'ils ont été passé en arguments) - - :return: renvoie l'écart-type - """ + def sd(self): + """ Compute the standard deviation """ return sqrt(self.variance()) def quartiles(self): @@ -103,8 +87,18 @@ class Serie(): Calcul les quartiles de la série. :return: un tuple avec (min, Q1, Me, Q3, Max) + + : Exemple: + + >>> w = WeightedDataset(flatten_list([i*[i] for i in range(5)])) + >>> w.quartiles() + (1, 2, 3.0, 4, 4) + >>> w = WeightedDataset(flatten_list([i*[i] for i in range(6)])) + >>> w.quartiles() + (1, 3, 4, 5, 5) + """ - return (min(self.serie) , self.quartile(1) , self.quartile(2) , self.quartile(3), max(self.serie)) + return (min(self.keys()) , self.quartile(1) , self.quartile(2) , self.quartile(3), max(self.keys())) def quartile(self, quartile = 1): """ @@ -116,21 +110,29 @@ class Serie(): : Example: - >>> s = Serie() - >>> + >>> w = WeightedDataset(flatten_list([i*[i] for i in range(5)])) + >>> w.quartile(1) + 2 + >>> w.quartile(2) + 3.0 + >>> w.quartile(3) + 4 + >>> w = WeightedDataset(flatten_list([i*[i] for i in range(6)])) + >>> w.quartile(1) + 3 + >>> w.quartile(2) + 4 + >>> w.quartile(3) + 5 """ - position = self.posi_quartile(quartile)[0] - - conteur = 0 - # on utilise la forme avec les couples pour avoir des valeurs classées. - for (val , eff) in self.serieCouple: - conteur += eff - if conteur >= position: - val_quartile = val - break - - return val_quartile + # -1 to match with list indexing + position = self.posi_quartile(quartile) - 1 + expanded_values = flatten_list([v*[k] for (k,v) in self.items()]) + if position.is_integer(): + return (expanded_values[int(position)] + expanded_values[int(position)+1])/2 + else: + return expanded_values[ceil(position)] def posi_quartile(self, quartile = 1): """ @@ -140,121 +142,12 @@ class Serie(): :return : la position du quartile (arondis à l'entier suppérieur, non arrondis) """ - return (ceil(quartile * self.effectif_total / 4), (quartile * self.effectif_total / 4)) + return quartile * self.effectif_total() / 4 # -------------------------- # Rendu latex - def moyenne_latex(self, val_cara = "x", eff_cara = "n", end_cara = "p", moy_cara= "\\bar{x}"): - """ - Renvoie le code latex pour afficher le calcul de la moyenne - - :param val_cara: caractère représentant les valeurs (x par défaut) - :param eff_cara: caractère représentant les effectifs (n par défaut) - :param end_cara: caractère représentant le nombre de valeurs (p par défaut) - :param moy_cara: nom de la moyenne (\\bar{x} par défaut) - - :return: le code latex pour afficher le calcul de la moyenne - """ - moy = self.moyenne() - latex = moy_cara + " &=& " - latex += "\\frac{{{x}_1 \\times {n}_1 + {x}_2 \\times {n}_2 + ... + {x}_{p} \\times {n}_{p}}}{{{n}_1 + {n}_2 + ... + {n}_p}} \\\\ \n".format(x = val_cara, n=eff_cara, p = end_cara) - latex += "\t &=& \\frac{" - for (i,v) in enumerate(self.valeurs): - latex += "{x:.2f} \\times {p:.2f} + ".format(x = v, p = self.effectifs[i]) - latex = latex[:-2] # on enlève le + et l'espace de fin de calcul - latex += "}}{{{eff_tot}}}\\\\ \n".format(eff_tot = self.effectif_total) - latex += "\t &=& {moy:.2f}".format(moy=moy) - - return latex - - def variance_latex(self, val_cara = "x", eff_cara = "n", end_cara = "p", moy_cara= "\\bar{x}", var_cara = "V"): - """ - Renvoie le code latex pour afficher le calcul de la moyenne - - :param val_cara: caractère représentant les valeurs (x par défaut) - :param eff_cara: caractère représentant les effectifs (n par défaut) - :param end_cara: caractère représentant le nombre de valeurs (p par défaut) - :param moy_cara: nom de la moyenne (\\bar{x} par défaut) - :param var_var: nom de la variance (V par défaut) - - :return: le code latex pour afficher le calcul de la moyenne - """ - moy = self.moyenne() - var = self.variance() - - latex = var_cara + " &=& " - latex += "\\frac{{ {n}_1 ({x}_1 - {moy})^2 + {n}_2 ({x}_2 - {moy})^2 + ... + {n}_{p} ({x}_{p} - {moy})^2}}{{{n}_1 + {n}_2 + ... + {n}_p}}\\\\ \n".format(x = val_cara, n=eff_cara, p = end_cara, moy = moy_cara) - latex += "\t &=& \\frac{ " - for (i,v) in enumerate(self.valeurs): - latex += "{p:.2f} ({x:.2f} - {moy:.2f})**2 + ".format(p = self.effectifs[i], x = v, moy = moy) - latex = latex[:-2] # on enlève le + et l'espace de fin de calcul - latex += "}}{{{eff_tot}}}\\\\ \n".format(eff_tot = self.effectif_total) - latex += "\t &=& {var:.2f}".format(var = var) - - return latex - - def ecart_type_latex(self, val_cara = "x", eff_cara = "n", end_cara = "p", moy_cara= "\\bar{x}", var_cara = "V", ecar_cara = "\\sigma"): - """ - Renvoie le code latex pour afficher le calcul de la moyenne - - :param val_cara: caractère représentant les valeurs (x par défaut) - :param eff_cara: caractère représentant les effectifs (n par défaut) - :param end_cara: caractère représentant le nombre de valeurs (p par défaut) - :param moy_cara: nom de la moyenne (\\bar{x} par défaut) - :param var_var: nom de la variance (V par défaut) - :param ecar_var: nom de la variance (V par défaut) - - :return: le code latex pour afficher le calcul de la moyenne - """ - ecart = self.ecart_type() - - # On récupère le calcul de la variance - latex = self.variance_latex(val_cara, eff_cara, end_cara, moy_cara, var_cara) - latex += "\n\n" - - # On y ajoute celui de l'écart-type (ya un soucis ici à cause du conflit entre format et { - latex += "{ecar_cara} &=& \\sqrt{{{var_cara}}} \\\\ \n".format(ecar_cara = ecar_cara, var_cara = var_cara) - latex += "\t &=& {ecart:.2f}".format(ecart = ecart) - - return latex - - def quartiles_latex(self): - """ Renvoie le code latex pour afficher le calcul des quartiles - - :return : le code latex pour afficher le calcul des quartiles - """ - latex = self.quartile_latex() - latex += self.quartile_latex(1) - latex += self.quartile_latex(3) - - return latex - - def quartile_latex(self, quartile = 2): - """ Renvoie le code latex pour afficher le calcul du quartile - - :param quartile: numéro du quartile - - :return : le code latex pour afficher le calcul du quartile - """ - if quartile == 2 : # médiane - quartile_tpl = """ Position de la médiane: $\\dfrac{{\\mbox{{effectif total}}}}{{2}} = \\dfrac{{{eff_tot}}}{{2}} = {posi_q}$. Donc la médiane se trouve à la position: {posi_q_ceil}. - -On a ainsi $Me = {val_q}$ - """ - else: - quartile_tpl = """ Position de $Q_{q}$: $\\dfrac{{{q} \\times \\mbox{{effectif total}}}}{{4}} = \\dfrac{{{q} \\times {eff_tot}}}{{4}} = {posi_q}$. Donc $Q_{q}$ se trouve à la position: {posi_q_ceil}. - -On a ainsi $Q_{q} = {val_q}$ - """ - posi_q_ceil , posi_q = self.posi_quartile(quartile) - val_q = self.quartile(quartile) - - latex = quartile_tpl.format(eff_tot = self.effectif_total, q = quartile, posi_q = posi_q, posi_q_ceil = posi_q_ceil, val_q = val_q) - - return latex - def tabular_latex(self): """ Renvoie le code latex pour afficher le tableau