Teste du khi-deux/chi-deux d'indépendance

Commenter

Contenu du snippet

Définition wikipédia :
Le teste du khi2 (prononcer « khi-deux » ou « khi carré », qu'on écrit également à l'anglaise « chi-deux » ou « chi carré ») permet, partant d'une hypothèse et d'un risque supposé au départ, de rejeter l'hypothèse si la distance entre deux ensembles d'informations est jugée excessive. Un test d'indépendance porte sur des données qualitatives.
Plus d'infos : http://fr.wikipedia.org/wiki/Test_du_%CF%87%C2%B2

Lien en ligne : http://testchideux.awardspace.info

Source / Exemple : 


"""
 By PHPAnonyme
 LICENCE EUPL
 @licence : http://testchideux.awardspace.info/index.php?v=licence
"""

class Chi:
  
   
  def __init__(self):
    print("¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤")
    print("----- Calcul du khi2 d'independance -----")
    print("¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤")
    print("\n")

  """ Lancement de l'application
        """
  def outPut(self):
    print("*** Dimensions du tableau des observations ***")
    self.getNumLine()
    self.getNumColumn()
    print("\n")
    print("*** Nombre de chiffre après la virgule pour les résultats ***")
    self.getNumDecimal()
    print("\n")
    print("*** Valeurs du tableau des observations ***")
    self.recordContingent()
    print("\n")
    self.setContingent()
    self.setTheoreticalResult()
    self.setChi()
    print("*** Résultats du tableau des observations ***")
    self.drawContingent()
    print("\n")
    print("*** Résultats du tableau des résultats théoriques ***")
    self.drawTheoretical()
    print("\n")
    print("*** Résultats du tableau des khis partiels ***")
    self.drawChi()
    print("\n")
    print("¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤")
    print("*** VOS RESULTATS ***")
    print("¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤")
    print("Le degré de liberté est de :", self.setDDL())
    print("Le khi2 est de :", self.total_chi_result)
    print("\n")

  """ Affichage du tableau des valeurs d'observations
        """
  def drawContingent(self):
    printer, number_line, x_line = "", 0, 0
    for key_values in range( len( self.contingent_result ) ):
       # Affichage des valeurs
       printer += " |\\ " + str( self.contingent_result[key_values] )
       if x_line == ( int( self.column)-1 ):
         # Affichage des totaux par ligne
         # Reinitialisation du comptage des lignes
         printer += " ||= " + str( self.total_contingent_result_by_line[number_line] ) + "\n"
         number_line += 1
         x_line = 0
       else:
         x_line += 1
         
    for tot_col in range( len( self.total_contingent_result_by_column ) ):
      # Affichage de la barre horizontale en fonction de la longueur des valeurs
      tot_i = 0 
      while tot_i < len( str( self.total_contingent_result_by_column[tot_col] ) ):
         printer += "---"
         tot_i += 1
    printer += "\n"
    
    for tot in range( len( self.total_contingent_result_by_column ) ):
       # Affichage des totaux par colonne
       printer += " |= " + str( self.total_contingent_result_by_column[tot] )
       
    printer += " ||= " + str( self.total_contingent )
    print( printer )
    print('Le total des totaux pour les observations est de :', self.total_contingent)

  """ Affichage du tableau des résultats théoriques
        """
  def drawTheoretical(self):
    printer, number_line, x_line = "", 0, 0
    for key_values in range( len( self.theoretical_result ) ):
       # Affichage des valeurs
       printer += " |\\ " + str( self.theoretical_result[key_values] )
       if x_line == ( int( self.column )-1 ):
         # Affichage des totaux par ligne
         # Reinitialisation du comptage des lignes
         printer += " ||= " + str( self.total_theoretical_result_by_line[number_line] ) + "\n"
         number_line += 1
         x_line = 0
       else:
         x_line += 1
         
    for tot_col in range( len( self.total_theoretical_result_by_column ) ):
      # Affichage de la barre horizontale en fonction de la longueur des valeurs
      tot_i = 0 
      while tot_i < len( str( self.total_theoretical_result_by_column[tot_col] ) ):
         printer += "---"
         tot_i += 1
    printer += "\n"
    
    for tot in range( len( self.total_theoretical_result_by_column ) ):
       # Affichage des totaux par colonne
       printer += " |= " + str( self.total_theoretical_result_by_column[tot] )
       
    printer += " ||= " + str( self.total_theoretical_result )
    print( printer )
    print('Le total des totaux pour les résultats théoriques est de :', self.total_theoretical_result)  

  """ Affichage du tableau des khis partiels
        """
  def drawChi(self):
    printer, number_line, x_line = "", 0, 0
    for key_values in range( len( self.chi_result ) ):
       # Affichage des valeurs
       printer += " |\\ " + str( self.chi_result[key_values] )
       if x_line == ( int( self.column)-1 ):
         # Affichage des totaux par ligne
         # Reinitialisation du comptage des lignes
         printer += " ||= " + str( self.total_chi_result_by_line[number_line] ) + "\n"
         number_line += 1
         x_line = 0
       else:
         x_line += 1
         
    for tot_col in range( len( self.total_chi_result_by_column ) ):
      # Affichage de la barre horizontale en fonction de la longueur des valeurs
      tot_i = 0 
      while tot_i < len( str( self.total_chi_result_by_column[tot_col] ) ):
         printer += "---"
         tot_i += 1
    printer += "\n"
    
    for tot in range( len( self.total_chi_result_by_column ) ):
       # Affichage des totaux par colonne
       printer += " |= " + str( self.total_chi_result_by_column[tot] )
       
    printer += " ||= " + str( self.total_chi_result )
    print( printer )
    print('Le total des totaux pour les khis partiels est de :', self.total_chi_result)
    

  """ Calcul du dégré de liberté
        retourne un entier """
  def setDDL(self):
    self.ddl = (int(self.line) - 1) * (int(self.column) - 1)
    return self.ddl;

  """ Récupération du nombre de ligne,
        son type doit être un entier """
  def getNumLine(self):
    line = input("--> Nombre de ligne : ")
    if not self.isInt( line ):
      return self.getNumLine()
    while int( line ) < 2:
      line = input("____Doit être au minimum égale à 2 : ")
    self.line = line
    return self.line

  """ Récupération du nombre de colonne, 
        son type doit être un entier """
  def getNumColumn(self):
    column = input("--> Nombre de colonne : ")
    if not self.isInt( column ):
      return self.getNumColumn()
    while int( column ) < 2:
      column = input("____Doit être au minimum égale à 2 : ")
    self.column = column
    return self.column

  """ Récupération du nombre de décimale pour les résultats, 
        son type doit être un entier """
  def getNumDecimal(self):
    decimal = input("--> Saisissez un nombre : ")
    if not self.isInt( decimal ): 
        return self.getNumDecimal()
    self.decimal = decimal
    return self.decimal

 
  """ Saisies et enregistrement des valeurs du tableau d'observations
        retourne un tableau """
  def recordContingent(self):
    i, self.contingent_result = 0, []
    while i < int( self.line ):
      print("--> Saissez les valeurs de la ligne", (i+1))
      j = 0
      while j < int( self.column ):
        val = input()
        while not self.isNumber(val):
          val = input("----> Uniquement un nombre decimal ou entier : ")
        self.contingent_result.append( float( val ) )
        j += 1   
      i += 1
    return self.contingent_result 

  """ Calcul des totaux d'observations
        retourne un entier ou un flotant """
  def setContingent(self):
    # Calcul les totaux par ligne
    # Calcul les totaux par colonne
    # Calcul le total des totaux
    self.total_contingent_result_by_line = self.calculateBL(self.contingent_result, int( self.line ), int( self.column ) )
    self.total_contingent_result_by_column = self.calculateBC(self.contingent_result, int( self.column ), int( self.line ) )
    self.total_contingent = round( sum( self.total_contingent_result_by_line ), int( self.decimal ) )
    return self.total_contingent

  """ Calcul des résultats théoriques
        retourne un entier ou un flotant """
  def setTheoreticalResult(self):
    # Calcul et enregistre les résultats théoriques
    # Calcul les totaux par ligne
    # Calcul les totaux par colonne
    # Calcul le total des totaux
    self.theoretical_result=[]
    for i in range( len( self.total_contingent_result_by_line ) ):
       for j in range( len( self.total_contingent_result_by_column ) ):
          temp_result = float( self.total_contingent_result_by_line[i] ) * float( self.total_contingent_result_by_column[j] )
          if not temp_result:
             result = 0
          else:
             result = temp_result / self.total_contingent
          self.theoretical_result.append( round( float( result ), int( self.decimal ) ) )

    self.total_theoretical_result_by_line = self.calculateBL(self.theoretical_result, int( self.line ), int( self.column ) )
    self.total_theoretical_result_by_column = self.calculateBC(self.theoretical_result, int( self.column ), int( self.line ) )
    self.total_theoretical_result = round( sum( self.total_theoretical_result_by_line ), int( self.decimal ) )	
    return self.total_theoretical_result

  """ Calcul des khis
        retourne un entier ou un flotant """
  def setChi(self):
    # Calcul et enregistre les khis partiels
    # Calcul les totaux par ligne
    # Calcul les totaux par colonne
    # Calcul le total des totaux / le khi2
    self.chi_result=[]
    for i in range( len( self.theoretical_result ) ):
      temp_square = float( self.contingent_result[i] ) - float( self.theoretical_result[i] )
      if not temp_square:
         result = 0
      else:
         result = pow( temp_square, 2 ) / float( self.theoretical_result[i] ) 
      self.chi_result.append( round( float( result ), int( self.decimal ) ) )

    self.total_chi_result_by_line = self.calculateBL(self.chi_result, int( self.line ), int( self.column ) )
    self.total_chi_result_by_column = self.calculateBC(self.chi_result, int( self.column ), int( self.line ) )
    self.total_chi_result = round( sum( self.total_chi_result_by_line ), int( self.decimal ) )
    return self.total_chi_result
    
    
  """ Vérifie le type est un entier
        paramètre val : le type
        retourne un booléen """
  def isInt(self, val):
    try:
       int(val)
    except:
        return False
    return True  

  """ Vérifie si le type est un nombre entier ou flotant
        paramètre val : le type
        retourne un booléen """
  def isNumber(self, val):
    try:
       float(val)
    except:
        return False
    return True  

  """ Opération de calcul par ligne
        paramètre values : tableau de valeurs
        paramètre loop : nombre pour le premier bouclage
        paramètre limit : nombre pour le second bouclage
        retourne un tableau de valeurs """
  def calculateBL(self, values, loop, limit):
    i, temp_save = 0, []
    while i < loop:
      counter = j = 0
      while j < limit:
         if not i:
            counter += float( values[j] )
         else:
            counter += float( values[j + (i * limit)] )
         j += 1
      temp_save.append( round( float( counter ), int( self.decimal ) ) )   
      i += 1 
    return temp_save

  """ Opération de calcul par colonne
        paramètre values : tableau de valeurs
        paramètre loop : nombre pour le premier bouclage
        paramètre limit : nombre pour le second bouclage
        Retourne un tableau de valeurs """
  def calculateBC(self, values, loop, limit):
    i, temp_save = 0, []
    while i < loop:
       counter = j = 0
       while j < limit:
          if not i:
             counter += float( values[j * loop] )
          else:
             counter += float( values[i + (loop * j)] )	
          j += 1
       temp_save.append( round( float( counter ), int( self.decimal ) ) )   
       i += 1 
    return temp_save  

 
""" """
app = Chi()
app.outPut()

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (phpAnonyme)