## Fichier : network.py
# Auteur : Jovian Hersemeule

# Gère l'arbre des neurones pour le cerveau.

class Network :
    def __init__( self ): # Jovian 17 janvier 2017
        """
        Créé un réseau vide. Le graphe est implémenté par liste d'adjacence.
        La sortie est indexée 0.
        Les entrées sont indexées de 1 à inSize.
        Les intermédiaires sont indexés de inSize + 1 à total de neurones.
        """
        self.tree = None # string list list
        self.poids = None # matrice de poids[de][vers]
        self.total = 1 # int

        self.nb_in = 0
        self.nb_aux = 0
        self.nb_out = 1

    def in_node_to_num( self, node ): # Jovian 7 mars 2017
        """
        Convertit un identidiant de noeud ( par exemple s0 ou i42 ) en indice de tableau.
        Les entrées occupent [0 : nb_in ]
        Les intermédiaires occupent [ nb_in : nb_in + nb_aux ]
        """
        # Décryptage du noeud
        sort = node[0]
        num = int( node[1:] )

        # Détection d'une requête sans sens
        if sort == 's' :
            print( "Appel de in_node_to_num impertinent sur un neurone de sortie." )
            print( "Exécuté sur ", node )
            return -1

        # Décalage dû aux types
        if sort == "i" :
            num += self.nb_in

        # Fin
        return num

    def out_node_to_num( self, node ): # Jovian 7 mars 2017
        """
        Convertit un identidiant de noeud ( par exemple s0 ou i42 ) en indice de tableau.
        Les intermédiaires occupent [0 : nb_aux ]
        Les sorties occupent [ nb_aux : nb_aux + nb_out ]
        """
        # Décryptage du noeud
        sort = node[0]
        num = int( node[1:] )

        # Détection d'une requête sans sens
        if sort == 'e' :
            print( "Appel de out_node_to_num impertinent sur un neurone d'entrée." )
            print( "Exécuté sur ", node )
            return -1

        # Décalage dû aux types
        elif sort == "s" :
            num += self.nb_aux

        # Fin
        return num

    def build( self, liste_synapses, liste_poids, nb_in, nb_aux, nb_out = 1, debug = False ): # Jovian 7 mars 2017
        """
        Construit le réseau à partir d'une liste de synapses.
        Argument liste_synapses : Couple string list, liste de synapses.
        Argument liste_poids : liste des poids respectifs des synapses.
        Argument nb_in : entier nombre d'entrées.
        Argument nb_int : entier nombre d'intermédiaires.
        Argument nb_out : entier nombre de sortie(s).
        """
        # Annonce
        if debug : print("\n> Début de la procédure de construction du network.")
        
        # Ecrasement possible
        if self.total > 1 :
            if debug : print( "\n> Network déjà existant : écrasement." )

        self.tree = None
        self.poids = None
        self.total = 1

        self.nb_in = nb_in
        self.nb_aux = nb_aux
        self.nb_out = nb_out

        # Initialisation des attributs
        self.tree = [[] for k in range( nb_out + nb_aux ) ]
        self.poids = [ [ 0 for j in range( nb_aux + nb_out ) ] for i in range( nb_in + nb_aux ) ]

        # Balayage
        nb_synapses = len( liste_synapses )
        
        for k in range( nb_synapses ):
            # Déconstruction du synapse
            node_start = liste_synapses[k][0]
            node_end = liste_synapses[k][1]

            if debug :
                print( "> ", liste_synapses[k] )
                print("Traitement synapse de ", node_start, " à ", node_end )
            
            # Ajout dans l'arbre
            id_end = self.out_node_to_num( node_end )
            self.tree[id_end].append( node_start )

            # Ajout dans la matrice
            id_start = self.in_node_to_num( node_start )
            self.poids[ id_start ][ id_end ] = liste_poids[k]

        # Fin
        if debug :
            print( len( self.poids ) * len( self.poids[0] ), " cases dans la matrice poids." )
            print( nb_synapses, " poids enregistrés dans la matrice." )
            #print( "Matrice de poids :" )
            #for syn in self.poids :
                #print( syn )
            print( "\nListe des parents :" )
            for c in enumerate(self.tree) :
                # Tuple
                nb, parents = c

                # Annonce de la classe
                if nb == 0 :
                    print("| Les parents des intermédiaires")
                elif nb == nb_aux :
                    print("\n| Les parents des sorties")

                # Affichage parents
                print( parents )
            print("\n> Fin de la procédure de construction du network.\n")

    def getParents( self, index ): # Jovian 7 mars 2017
        """
        Retourne liste identifiants des parents.
        Argument index : noeud dont on veut connaître les parents.
        """
        identifiant = self.out_node_to_num( index )

        if identifiant == -1 :
            return []
        else :        
            return self.tree[ identifiant ]

    def getPoids( self, nodeA, nodeB ): # Jovian 7 mars 2017
        """
        Retourne le poids du noeud A au noeud B.
        Argument nodeA : noeud A.
        Argument nodeB : noeud B.
        """
        identifiantA = self.in_node_to_num( nodeA )
        identifiantB = self.out_node_to_num( nodeB )

        return self.poids[ identifiantA ][ identifiantB ]