# Créé par eclermont, le 21/02/2023 en Python 3.7


#Q1
def dist( x, y ):
    """ dist(x : list, y : list)-> float
        entrees : x, y, 2 listes (vevcteurs) de flottants dont on veut calculer la distance euclidienne
        sortie : s, flottant, la distance entre les  vecteur x et y
    """



#Q2
def plus_proche( x , lesCentres ):
    """ plus_proche(x : list , lesCentres : list)-> int
        entrees : x, liste, vecteur dont on veut connaitre le centre le plus proche
                : lesCentres, liste des centres
        sortie : imin, entier, indice du centre le plus proche
    """



#Q3
def calculer_classes( X, lesCentres, k ):
    """ calculer_classes(X:list, centres:list, k:int)->list
        entrees : X, liste, liste des entrées
                : lesCentres, liste des centres
                : k, entier, nombre de classes
        sortie : classes, liste de listes des points de chaque classe
    """


#Q4
# calcul du centre d'un ensemble de données
def centre( X ) :
    # determination du barycentre d'un ensemble X de vecteurs


#Q5
#def calculer_centres(classes, k) :
    """ calculer_centres(classes : lst , k : int) -> list
        entrees : classes, liste, représentant les classes
                :  k, entier, nombre de classes  à générer
        sortie : centres, liste (de listes) des centres générés
    """



#Q6
def kmeans(X, k, lesCentres):
    """ kmeans(X, k, lesCentres)->list
        entrees : X, liste, liste des entrées
                : lesCentres, liste des centres
                : k, entier, nombre de classes
        sortie : classes, liste des points de chaque classe apres traitement du kmeans
    """


#Q7
#def inertie( classes, centres, k ):


#________________ Test _____________________________
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.colors import ListedColormap

from sklearn.datasets import load_iris
import numpy as np
import random
#Chargement du jeu de données
iris = load_iris()
X= iris.data
X = X[ : , :2 ] # extraction des 2 1eres colonnes de la matrice des iris => uniquement les 2 1eres caracteristiques

# détermination aléatoire des centres parmi l'ensemble des données fournies
k= 3
lesCentres = []
for i in range(k):
  ind = random.randint(0,len(X)-1)
  lesCentres.append(X[ind].tolist())


# affichage de la situation initiale
plt.scatter([x[0] for x in X], [x[1] for x in X]) # affichage des points pour les iris
plt.scatter([x[0] for x in lesCentres], [x[1] for x in lesCentres], marker='x', s=100, c='g') #affichage des centres
plt.show()
#plt.closeAll()

"""  A décommenter lorsque la fonction kmeans sera codée
classes = kmeans(X, k, lesCentres)    # test de kmeans
cmap = ListedColormap(['g', 'r', 'b', 'purple'])
centres = calculer_centres( classes, k )

plt.scatter([x[0] for x in X], [x[1] for x in X], c=[plus_proche(x, centres) for x in X], cmap=cmap)
plt.scatter([x[0] for x in centres], [x[1] for x in centres], marker='x', s=100, c=range(k), cmap=cmap)
plt.title("Inertie = " + str(inertie( classes, centres,k )))
plt.show()
"""