Mapytex/pymath/stat/weightedDataset.py

#/usr/bin/env python
# -*- coding:Utf-8 -*-

#
#
# Ensemble de fonction rendant beaucoup plus pratique la résolution et l'élaboration des exercices de stat au lycée
#
#

from math import sqrt, ceil
from collections import Counter
from .dataset import Dataset
from ..calculus.generic import flatten_list
from .number_tools import number_factory


class WeightedDataset(dict):
    """ A weighted dataset with statistics and latex rendering methods
    
    >>> 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.61
    >>> w.deviation()
    56.96
    >>> w.variance()
    1.24
    >>> w.sd()
    1.11
    
    """
    
    def __init__(self, datas = [], data_name = "Valeurs", weights = [], weight_name = "Effectifs"):
        """ 
        Initiate the WeightedDataset 
        """
        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:
                weightedDatas = {i[0]:i[1] for i in zip(datas, weights)}

        dict.__init__(self, weightedDatas)

        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

    @number_factory
    def total_weight(self):
        return sum(self.values())

    def effectif_total(self):
        return self.total_weight()

    @number_factory
    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()])

    @number_factory
    def mean(self):
        return self.sum()/self.effectif_total() 

    @number_factory
    def deviation(self):
        """ Compute the deviation (not normalized) """
        mean = self.mean()
        return sum([v*(k - mean)**2 for (k,v) in self.items()])

    @number_factory
    def variance(self):
        return self.deviation()/self.effectif_total()
    
    @number_factory
    def sd(self):
        """ Compute the standard deviation """
        return sqrt(self.variance())

    def quartiles(self):
        """
        Calcul les quartiles de la série.

        :return: un tuple avec (min, Q1, Me, Q3, Max)

        >>> w = WeightedDataset(flatten_list([i*[i] for i in range(5)]))
        >>> w.quartiles()
        (1, 2, 3, 4, 4)
        >>> w = WeightedDataset(flatten_list([i*[i] for i in range(6)]))
        >>> w.quartiles()
        (1, 3, 4, 5, 5)

        """
        return (min(self.keys()) , self.quartile(1) , self.quartile(2) , self.quartile(3), max(self.keys()))

    @number_factory
    def quartile(self, quartile = 1):
        """
        Calcul un quartile de la série.

        :param quartile: quartile à calculer (par defaut 1 -> Q1)

        :return: le quartile demandé

        : Example:

        >>> w = WeightedDataset(flatten_list([i*[i] for i in range(5)]))
        >>> w.quartile(1)
        2
        >>> w.quartile(2)
        3
        >>> 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

        """
        # -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):
        """ 
        Calcul la position du quartile

        :param quartile: le quartile concerné
        
        :return : la position du quartile (arondis à l'entier suppérieur, non arrondis)
        """
        return quartile * self.effectif_total() / 4
    
    
    # --------------------------
    # Rendu latex
    
    def tabular_latex(self):
        """ Latex code to display dataset as a tabular """
        latex = "\\begin{{tabular}}{{|c|*{{{nbr_col}}}{{c|}}}} \n".format(nbr_col = len(self.keys()))
        latex += "\t \hline \n"
        data_line = "\t {data_name} ".format(data_name = self.data_name)
        weight_line = "\t {weight_name} ".format(weight_name = self.weight_name)

        # TODO: Il faudra trouver une solution pour le formatage des données |sam. janv.  9 13:14:26 EAT 2016
        for (v,e) in self.items():
            data_line += "& {val} ".format(val = v)
            weight_line += "& {eff} ".format(eff = e)

        latex += data_line + "\\\\ \n \t \\hline \n"
        latex += weight_line + "\\\\ \n \t \\hline \n"
        latex += "\\end{tabular}"

        return latex


# -----------------------------
# Reglages pour 'vim'
# vim:set autoindent expandtab tabstop=4 shiftwidth=4:
# cursor: 16 del