<?xml version="1.0"?>
<doc>
    <assembly>
        <name>Matching</name>
    </assembly>
    <members>
        <member name="F:Matching.BeamSearchGraphEditDistanceAC.OPEN">
            <summary>
            List of the possible EditPaths
            </summary>
        </member>
        <member name="F:Matching.BeamSearchGraphEditDistanceAC.G1">
            <summary>
            Source Graph
            </summary>
        </member>
        <member name="F:Matching.BeamSearchGraphEditDistanceAC.G2">
            <summary>
            Target Graph
            </summary>
        </member>
        <member name="F:Matching.BeamSearchGraphEditDistanceAC.MeilleurPath">
            <summary>
            Minimun cost path
            </summary>
        </member>
        <member name="F:Matching.BeamSearchGraphEditDistanceAC.NoeudCourant">
            <summary>
            Node being processed
            </summary>
        </member>
        <member name="M:Matching.BeamSearchGraphEditDistanceAC.#ctor(Graphs.Graph,Graphs.Graph,System.Int32)">
            <summary>
            Constructor of the Edit Distance between two graphs
            </summary>
            <param name="g1">Graphe source</param>
            <param name="g2">Graphe cible</param>
            <param name="iNbCheminsMax">Maximun number of EditPathAC in the list OPEN (List of possible Paths) </param>
        </member>
        <member name="M:Matching.BeamSearchGraphEditDistanceAC.CalculDistanceDedition(System.Int32)">
            <summary>
            Loop calculating the edit distance
            </summary>
            <param name="iNbCheminsMax">Maximun number of EditPathAC in the list OPEN (List of possible Paths) </param>
            <returns>Minimun cost path</returns>
        </member>
        <member name="M:Matching.BeamSearchGraphEditDistanceAC.CalculEditPathCoutMinimum(System.Collections.Generic.LinkedList{Matching.EditPathAC})">
            <summary>
            Calculating the minimum cost EditPathAC
            </summary>
            <param name="OPEN2">List of Paths (EditPathAC)</param>
            <returns>minimum cost EditPathAC</returns>
        </member>
        <member name="M:Matching.BeamSearchGraphEditDistanceAC.TriOrdreCroissant(System.Collections.Generic.LinkedList{Matching.EditPathAC},System.Int32)">
            <summary>
            Order the list in descending by the cost of the EditPathAC and delete all the EditPathAC after the index iKNbChemins
            </summary>
            <param name="OPEN">List of Paths (EditPathAC)</param>
            <param name="iKNbChemins"> Number of EdithPath to save in OPEN</param>
            <returns>The new list of EditPaths</returns>
        </member>
        <member name="F:Matching.ConstantsAC.EPS_ID">
            <summary>
            ID of the epsilon component (used for node and edge deletion)
            </summary>
        </member>
        <member name="F:Matching.EdgeLabelDistanceEditionAC.attributesGXL">
            <summary>
            List of the GXL attributes of the GraphComponent associated with this label
            </summary>
        </member>
        <member name="M:Matching.EdgeLabelDistanceEditionAC.#ctor">
            <summary>
            Constructor. Initialize the list of GXL attributes
            </summary>
        </member>
        <member name="M:Matching.EdgeLabelDistanceEditionAC.toString">
            <summary>
            Convert an attributes list to a string
            </summary>
            <returns> A string that contains the list of attributes</returns>
        </member>
        <member name="M:Matching.EdgeLabelDistanceEditionAC.dissimilarity(Graphs.Label)">
            <summary>
            Method to calculating the cost between two NodeLabelDistanceEditionAC
            </summary>
            <param name="label">LabelDistanceEditionto compare</param>
        </member>
        <member name="P:Matching.EdgeLabelDistanceEditionAC.AttributesGXL">
            <summary>
            Getter and Setter of the GXL attributes list
            </summary>
            <param name="value">Set --> GXL attributes list</param>
            <returns>get --> GXL attributes list</returns>
        </member>
        <member name="F:Matching.EditPathAC.gSource">
            <summary>
            source graphe
            </summary>
        </member>
        <member name="F:Matching.EditPathAC.gCible">
            <summary>
            Target graphe
            </summary>
        </member>
        <member name="F:Matching.EditPathAC.Distortions">
            <summary>
            Distortions table
            </summary>
        </member>
        <member name="F:Matching.EditPathAC.dCoutTotal">
            <summary>
            total cost of the EditPathAC
            </summary>
        </member>
        <member name="F:Matching.EditPathAC.lNoeudsNonUtiliseG1">
            <summary>
            List of unused nodes of the source graphe
            </summary>
        </member>
        <member name="F:Matching.EditPathAC.lNoeudsNonUtiliseG2">
            <summary>
            List of unused nodes of the target graphe
            </summary>
        </member>
        <member name="F:Matching.EditPathAC.lArcsNonUtiliseG1">
            <summary>
            List of unused edges of the source graphe
            </summary>
        </member>
        <member name="F:Matching.EditPathAC.lArcsNonUtiliseG2">
            <summary>
            List of unused edges of the target graphe
            </summary>
        </member>
        <member name="M:Matching.EditPathAC.#ctor(Graphs.Graph,Graphs.Graph)">
            <summary>
            Constructor of the Edit Path. Initialize the members
            </summary>
            <param name="G1">Graph source</param>
            <param name="G2">Graph target</param>
        </member>
        <member name="M:Matching.EditPathAC.#ctor(Matching.EditPathAC)">
            <summary>
            Constructor of the Edit Path. Initialize the members
            </summary>
            <param name="Ep">Edit path to add to the new EditPathAC</param>
        </member>
        <member name="M:Matching.EditPathAC.init">
            <summary>
            Initialization of the members. This method is called by the constructors
            </summary>
        </member>
        <member name="M:Matching.EditPathAC.AjoutDistortion(Graphs.GraphComponent,Graphs.GraphComponent)">
            <summary>
            Add a new row in the distortions table
            </summary>
            <param name="gc1">GraphComponent of the source graph to add in the distortions table</param>
            <param name="gc2">GraphComponent of the targeted graph to add in the distortions table</param>
        </member>
        <member name="M:Matching.EditPathAC.getNoeudSuivant">
            <summary>
            Get the next node in the list of unused Nodes of the souce graph
            </summary>
            <returns>The next Node to process</returns>
        </member>
        <member name="M:Matching.EditPathAC.getCoutTotal">
            <summary>
            Return the total cost of an EditPathAC
            </summary>
            <returns>The total cost</returns>
        </member>
        <member name="M:Matching.EditPathAC.complete">
            <summary>
            Complete the distortion table with the unused nodes of the targeted graph
            </summary>
        </member>
        <member name="M:Matching.EditPathAC.GetNoeudsNonUtiliseG1">
            <summary>
            Return the list of the unused nodes of the source graph
            </summary>
            <returns>List of the unused nodes of the source graph</returns>
        </member>
        <member name="M:Matching.EditPathAC.GetNoeudsNonUtiliseG2">
            <summary>
            Return the list of the unused nodes of the targeted graph
            </summary>
            <returns>List of the unused nodes of the targeted graph</returns>
        </member>
        <member name="M:Matching.EditPathAC.GetArcsNonUtiliseG1">
            <summary>
            Return the list of the unused edges of the source graph
            </summary>
            <returns>List of the unused edges of the source graph</returns>
        </member>
        <member name="M:Matching.EditPathAC.GetArcsNonUtiliseG2">
            <summary>
            Return the list of the unused edges of the targeted graph
            </summary>
            <returns>List of the unused edges of the targeted graph</returns>
        </member>
        <member name="M:Matching.EditPathAC.getGraphSource">
            <summary>
            Return the source graph
            </summary>
            <returns>the source graph</returns>
        </member>
        <member name="M:Matching.EditPathAC.getGraphCible">
            <summary>
            Return the targeted graph
            </summary>
            <returns>the targeted graph</returns>
        </member>
        <member name="M:Matching.EditPathAC.getDistortion">
            <summary>
            Return the Distortions table
            </summary>
            <returns>the Distortions table</returns>
        </member>
        <member name="M:Matching.EditPathAC.getArcEntrants(Graphs.Node,System.Collections.Generic.LinkedList{Graphs.Edge})">
            <summary>
            Get the incoming Edges of the node n in the list edg
            </summary>
            <param name="n">Node to be analized</param>
            <param name="edg">List of the incoming Edges</param>
        </member>
        <member name="M:Matching.EditPathAC.getArcSortants(Graphs.Node,System.Collections.Generic.LinkedList{Graphs.Edge})">
            <summary>
            Get the outgoing Edges of the node n in the list edg
            </summary>
            <param name="n">Node to be analized</param>
            <param name="edg">List of the outgoing Edges</param>
        </member>
        <member name="M:Matching.EditPathAC.handleEdges(Matching.EditPathAC,Graphs.GraphComponent,Graphs.GraphComponent)">
            <summary>
            handles the edge operations
            </summary>
            <param name="p">Edit Path to be handle</param>
            <param name="u_start">GraphComponent to handle </param>
            <param name="u_end">GraphComponent to handle</param>
        </member>
        <member name="M:Matching.EditPathAC.getEdgeBetween(Graphs.Node,Graphs.GraphComponent)">
            <summary>
            Return an edge between a node and a graphComponent (node or epsilon)
            </summary>
            <param name="n1">Node to be analized</param>
            <param name="u_start">GraphComponent to be analized</param>
        </member>
        <member name="M:Matching.EditPathAC.System#IComparable#CompareTo(System.Object)">
            <summary>
            Return a value used to sort the list oh Edit Path (OPEN)
            </summary>
            <param name="obj">EditPathAC to be analized</param>
        </member>
        <member name="F:Matching.NodeLabelDistanceEditionAC.attributesGXL">
            <summary>
            List of the GXL attributes of the GraphComponent associated with this label
            </summary>
        </member>
        <member name="M:Matching.NodeLabelDistanceEditionAC.#ctor">
            <summary>
            Constructor. Initialize the list of GXL attributes
            </summary>
        </member>
        <member name="M:Matching.NodeLabelDistanceEditionAC.toString">
            <summary>
            Convert an attributes list to a string
            </summary>
            <returns> A string that contains the list of attributes</returns>
        </member>
        <member name="M:Matching.NodeLabelDistanceEditionAC.dissimilarity(Graphs.Label)">
            <summary>
            Method to calculating the cost between two NodeLabelDistanceEditionAC
            </summary>
            <param name="label">LabelDistanceEditionto compare</param>
        </member>
        <member name="P:Matching.NodeLabelDistanceEditionAC.AttributesGXL">
            <summary>
            Getter and Setter of the GXL attributes list
            </summary>
            <param name="value">Set --> GXL attributes list</param>
            <returns>get --> GXL attributes list</returns>
        </member>
        <member name="T:Matching.ClusterInformation">
            <summary>
            This class contains the information of ClusterInfo.xml
            </summary>
        </member>
        <member name="M:Matching.ClusterInformation.SaveAsXML(System.String)">
            <summary>
            Save the object of this class into XML
            </summary>
            <param name="StrDictionary">The directory of XML</param>
        </member>
        <member name="M:Matching.ClusterInformation.ReadFromXML(System.String)">
            <summary>
            Read a XML into an object of this class
            </summary>
            <param name="StrDictionary">The directory of XML</param>
        </member>
        <member name="T:Matching.FMGEEmbedding">
            <summary>
            Cette classe fait l'embedding d'un graphe, l'ordre de fonction d'embedding est comme:
            (class) Embedding--GetNodeDegree--GetRessemblance--ExtraitGraph--Graph2Vector
            </summary>
        </member>
        <member name="M:Matching.FMGEEmbedding.#ctor">
            <summary>
            constructeur
            </summary>
        </member>
        <!-- Badly formed XML comment ignored for member "M:Matching.FMGEEmbedding.Graph2Vector(Graphs.Graph,System.Boolean,System.Boolean,System.Boolean)" -->
        <member name="M:Matching.FMGEEmbedding.GetRessemblance(Graphs.Graph)">
            <summary>
            Cette méthode calcule les attributs supplimentaires et les ajoute dans un nouveau graphe.
            Ce processus n'est pas obligatoire.
            Erreur:quand il existe une type int ou float mais la valeur ne peut pas être converti à une valeur numerique
            </summary>
            <param name="GrapnIn">Graphe à calculer</param>
            <returns>Graphe avec ressemblance </returns>
        </member>
        <member name="M:Matching.FMGEEmbedding.GetNodeDegree(Graphs.Graph)">
            <summary>
            Cette méthode calcule et ajoute le degré de noeud dans un nouveau graphe(copy).
            Ce processus est obligatoire.
            </summary>
            <param name="GraphIn">Graphe à calculer</param>
            <returns>Graphe avec noeud degré</returns>
        </member>
        <member name="M:Matching.FMGEEmbedding.GraphCopy(Graphs.Graph)">
            <summary>
            Cette méthode crée un nouveau graphe dans le mémoire
            </summary>
            <param name="GraphIn">le graphe à copier </param>
            <returns>nouveau graphe </returns>
        </member>
        <member name="M:Matching.FMGEEmbedding.LearnBins(System.Collections.Generic.List{Graphs.Graph})">
            <summary>
            Cette fonction va parcourir tous les graphes
            pour les valeurs numeriques dans listAllClique, chercher un interval et calcule l'interval que chaque clique se situe.
            Entrée: graphe avec ressemblance et noeud degré
            </summary>
            <param name="listClique">une liste de graphe qu'on veut analyser</param>
        </member>
        <member name="M:Matching.FMGEEmbedding.SaveBins(System.String)">
            <summary>
            stocker les infos de bins dans les fichiers en forme binaire.
            </summary>
        </member>
        <member name="M:Matching.FMGEEmbedding.LoadBins(System.String)">
            <summary>
            lire les fichiers binaires qui stockent les tableaux d'apprentissage.
            </summary>
        </member>
        <member name="M:Matching.FMGEEmbedding.TestFGME(System.Collections.Generic.List{System.String},System.Collections.Generic.List{System.String},System.Collections.Generic.List{Matching.VectorFMGE},System.Collections.Generic.List{Matching.VectorFMGE},System.Int32,System.Int32,System.Int32)">
            <summary>
            Cette méthode va calculer le taux d'erreur et le taux de reconnaissance et verifier la qualité de notre méthode 
            de clustering et classification.
            </summary>
            <param name="resultValidation">L'ensemble de label de l'ensemble de validation</param>
            <param name="resultTest">L'ensemble de label de l'ensemble de test</param>
            <param name="validation">L'ensemble de vecteur de l'ensemble de validation</param>
            <param name="test">L'ensemble de vecteur de l'ensemble de test</param>
            <param name="k">Nombre de classe</param>
            <param name="resultValidation_records"></param>
            <param name="resultTest_records"></param>
            <returns></returns>
        </member>
        <member name="M:Matching.FMGEEmbedding.GetError(System.Collections.Generic.Dictionary{System.String,System.Int32},System.Collections.Generic.List{System.Int32})">
            <summary>
            Calcule le taux d'erreur de reconnaissance
            </summary>
            <param name="verf">L'ensemble de label et le nom du graphe</param>
            <param name="res">L'ensemble de label à comparer</param>
            <returns></returns>
        </member>
        <member name="M:Matching.FMGEEmbedding.FilterAttribute(System.Collections.Generic.Dictionary{System.String,System.Double},System.Boolean,System.Boolean,System.Boolean)">
            <summary>
            Cette méthode est pour choisir les parties de vecteurs
            </summary>
            <param name="DicVector">les noms d'attribut avec ses valeurs</param>
            <param name="part1">S'il contient le graphe level information</param>
            <param name="part2">S'il contient le structure level information</param>
            <param name="part3">S'il contient le elementary level information</param>
            <returns>les noms d'attribut avec ses valeurs filtrés</returns>
        </member>
        <member name="T:Matching.FMGESignature">
            <summary>
            Cette classe va gérer une base de graphe
            l'ordre de fonction est:GetAsemblance(vérifier type)--Extraitclique
            --AnalyseAttribut(créer 4 tableaux à partir de lequels on fait un modèle dans la phase de graph2Vector)
            --Graph2Vector
            </summary>
        </member>
        <member name="M:Matching.FMGESignature.#ctor(System.String)">
            <summary>
            Constructeurs
            </summary>
            <param name="StrDictonary">La répertoire de la base de graphe</param>
        </member>
        <member name="M:Matching.FMGESignature.FillTable(System.Boolean,System.Boolean,System.Boolean,System.Int32,System.String)">
            <summary>
            pour chaque clique, créer un FGMEEmbedding et remplir les tableaux du FGMESignature
            </summary>
            <param name="part1">s'il contient du graph level information</param>
            <param name="part2">s'il contient du structure level information</param>
            <param name="part3">s'il contient du elementary level information</param>
            <param name="getBins">s'il lire des bins et créer des bins</param>
            <param name="directionary">la répértoire du fichier bins.</param>
        </member>
        <member name="M:Matching.FMGESignature.ExtractClique(Graphs.Graph,System.String,System.Boolean)">
            <summary>
            extraire les cliques d'un graphe et à la fin les rengistrer dans un tableau ListAllClique.
            </summary>
            <param name="GraphIn">Graphe a extraire</param>
            <param name="GraphName">Graphe a extraire</param>
            <param name="IsDirected">Graphe orienté ou pas, pour l'instant, seulement les graphes non orientés supportés</param>
        </member>
        <member name="M:Matching.FMGESignature.WriteXML(System.String)">
            <summary>
            Créer l'index d'une base de graphe
            Ecrire le tableau(indexation)
            Erreur:quand on n'arrive pas à ecrire le fichier XML
            </summary>
            <param name="StrDictionary">répertoire de la fichier xml</param>
        </member>
        <member name="M:Matching.FMGESignature.ReadXML(System.String)">
            <summary>
            Reilitialise une signature et le repmlit par un fichier XML
            </summary>
            <param name="StrDictionary"></param>
        </member>
        <member name="M:Matching.IndexGraph.Run(System.String,System.Boolean,System.Boolean,System.Boolean,System.Int32,System.Double)">
            <summary>
            La méthode principale
            </summary>
            <param name="StrDirectory">Le répertoire du graphe à ajouter</param>
            <param name="levelGraph">s'il contient du graph level information</param>
            <param name="levelStructure">s'il contient du structure level information</param>
            <param name="levelComponent">s'il contient du elementary level information</param>
            <param name="nbClass">le nombre de classe</param>
            <param name="threshold">le parametre de la méthode clustering</param>
        </member>
        <member name="M:Matching.IndexGraph.AddGraph(System.String,System.String)">
            <summary>
            Ajouter des cliques d'un graphe dans le contenu de la signature.
            </summary>
            <param name="StrDirectory">Le répertoire du graphe à ajouter</param>
            <param name="StrName">Le nom du graphe à ajouter</param>
        </member>
        <member name="M:Matching.IndexGraph.WriteXML(System.String)">
            <summary>
            Stocker le fichier XML
            </summary>
            <param name="StrDictionary">Le répertoire du fichier XML</param>
        </member>
        <member name="M:Matching.IndexGraph.TestClustering(System.String)">
            <summary>
            voir le resultat de clustering et le sortir en forme de XML
            </summary>
            <param name="StrDictionary"></param>
        </member>
        <member name="M:Matching.IndexGraph.Clustering(System.Int32,System.Double)">
            <summary>
            Clustering K-means utilisé la biblothètique Alglib
            </summary>
            <param name="nbClass">La nombre de classe</param>
            <param name="threshold">La paramètre de la méthode clustering</param>
        </member>
        <member name="F:Matching.ResearchGraph.PCC">
            <summary>
            la méthode de plus court chemin pour calculer la distance entre graphe
            </summary>
        </member>
        <member name="F:Matching.ResearchGraph.MATRIX">
            <summary>
            la méthode de matrice d'adjacent chemin pour calculer la distance entre graphe
            </summary>
        </member>
        <member name="F:Matching.ResearchGraph.BEAMSEARCH">
            <summary>
            la méthode de beam research pour calculer la distance entre graphe
            </summary>
        </member>
        <member name="M:Matching.ResearchGraph.Run(System.String,System.String,System.String,System.String,System.Boolean,System.Boolean,System.Boolean,System.Int32,System.Int32,System.Int32)">
            <summary>
            La méthode principale de recherche de graphe 
            </summary>
            <param name="DirGraph">graphe de recherche</param>
            <param name="DirClusterXML">ClusterInfo.XML</param>
            <param name="DirCompleteXML">Indexation.XML</param>
            <param name="DirBinsData">La répértoire du fichier bins</param>
            <param name="levelGraph">S'il contient le graph level information</param>
            <param name="levelStructure">S'il contient le structure level information</param>
            <param name="levelComponent">S'il contient le elementary level information</param>
            <param name="Knn_k">Le nombre de K plus proche voisin</param>
            <param name="Knn_nbClass">Le nombre de classe de clustering</param>
            <param name="shortestPathMode">S'il utilise la méthode de plus court chemin, le beam research et la matrice d'adjacente</param>
        </member>
        <member name="M:Matching.ResearchGraph.Classification(System.Int32,System.Int32,System.Collections.Generic.List{Matching.VectorFMGE},System.Collections.Generic.List{System.Int32},System.Collections.Generic.List{Matching.VectorFMGE})">
            <summary>
            fonction de classification
            </summary>
            <param name="nbPPV">nb de plus proche voisin</param>
            <param name="nbClass">nb de classe de K means</param>
            <param name="vectorsAfterCluster">les vecteurs qu'on a utilisé pour clustering</param>
            <param name="labels">les numero de label apres clustering</param>
            <param name="vectorsWaitClassification">un vecteur pour être classifier</param>
            <returns>résultat avec le noméro de groupe et le nom de vecteur</returns>
        </member>
        <member name="M:Matching.ResearchGraph.testClassification(System.Int32,System.Int32,System.Collections.Generic.List{Matching.VectorFMGE},System.Collections.Generic.List{System.Int32},System.Collections.Generic.List{Matching.VectorFMGE},System.Collections.Generic.List{System.Collections.Generic.KeyValuePair{System.Int32,System.String}})">
            <summary>
            créer un fichier de test de classification
            </summary>
            <param name="nbPPV">nb de plus proche voisin</param>
            <param name="nbClass">nb de classe de K means</param>
            <param name="vectorsAfterCluster">les vecteurs qu'on a utilisé pour clustering</param>
            <param name="labels">les numero de label apres clustering</param>
            <param name="vectorsWaitClassification">un vecteur pour être classifier</param>
            <param name="groupe"></param>
        </member>
        <member name="M:Matching.ResearchGraph.IntersectGraphsFilter(System.Collections.Generic.List{System.String},System.Collections.Generic.Dictionary{System.Collections.Generic.KeyValuePair{System.String,System.Int32},System.Collections.Generic.List{System.String}},System.Collections.Generic.Dictionary{System.Int32,System.Int32})">
            <summary>
            Assurer les arcs dans graphe de rechercher sont tous existé au moins une fois dans le graphe courrant
            </summary>
            <param name="Intersection">une liste de graphe</param>
            <param name="clusterTable">inverted index tableau</param>
            <param name="appearTimes">les labels et pour chaque label, le nombre de fois qu'il existe</param>
            <returns>une liste de graphe qui satisfait ce condition</returns>
        </member>
        <member name="M:Matching.ResearchGraph.FilterName(System.Collections.Generic.Dictionary{System.Int32,System.Collections.Generic.List{System.String}})">
            <summary>
            Retirer le nom d'arc dans le nom entier.
            </summary>
            <param name="listName">liste de nom entier</param>
            <returns>liste de nom traité</returns>
        </member>
        <member name="M:Matching.ResearchGraph.GetResult(System.Collections.Generic.List{System.String},System.String,System.Collections.Generic.Dictionary{System.Collections.Generic.KeyValuePair{System.String,System.Int32},System.Collections.Generic.List{System.String}},System.Collections.Generic.List{System.Collections.Generic.KeyValuePair{System.Int32,System.String}},System.Collections.Generic.Dictionary{System.Int32,System.Int32},System.Int32)">
            <summary>
            Calculer un score pour chaque graphe résultat
            </summary>
            <param name="intersectionsIn">les noms de graphe</param>
            <param name="directory">la répértoire de fichier indexation</param>
            <param name="InvertedIndexTableIn">l'inverted tableau</param>
            <param name="QueryLabels">les labels et les noms d'arc pour le graphe de recherche</param>
            <param name="appearsTimes">les labels et le nombre de fois qu'il existe</param>
            <param name="ShortestPathMode">si on utilise la méthode Shortest path ou le beam research ou la matrice d'adjacent</param>
            <returns>une list de ResultMatching avec un score</returns>
        </member>
        <member name="M:Matching.ResearchGraph.ComputeScore(System.String,Graphs.Graph,System.Collections.Generic.Dictionary{System.Int32,System.Int32},System.Collections.Generic.Dictionary{System.Collections.Generic.KeyValuePair{System.String,System.Int32},System.Collections.Generic.List{System.String}})">
            <summary>
            Pour un graphe, on calcule un score utilisant la méthode matrice d'adjacent
            </summary>
            <param name="graphId">id de graphe dans la base de graphe</param>
            <param name="graphInBD">graphe dans la base de graphe</param>
            <param name="appearsTimes">les labels et le nombre de fois qu'il existe</param>
            <param name="InvertedIndexTableIn">l'inverted tableau</param>
            <returns>le score d'un graphe dans la liste de résultat</returns>
        </member>
        <member name="M:Matching.ResearchGraph.ComputeScoreSPF(System.String,Graphs.Graph,System.Collections.Generic.List{System.Collections.Generic.KeyValuePair{System.Int32,System.String}},System.Collections.Generic.Dictionary{System.Collections.Generic.KeyValuePair{System.String,System.Int32},System.Collections.Generic.List{System.String}})">
            <summary>
            Pour un graphe, on calcule un score utilisant la méthode le plus court chemin
            </summary>
            <param name="fileNameOfGraphInBD">id de graphe dans la base de graphe</param>
            <param name="graphInBD">graphe dans la base de graphe</param>
            <param name="researchGraphWithLabel">les labels et les noms d'arc dans le graphe de recherche</param>
            <param name="invertedIndexTableIn">l'inverted tableau</param>
            <returns>le score d'un graphe dans la liste de résultat</returns>
        </member>
        <member name="M:Matching.ResearchGraph.FloydWarshall(System.Int32[0:,0:])">
            <summary>
            l'algorithme de Floyd pour calculer le plus court chemin
            </summary>
            <param name="table">tableau de poids d'un graphe</param>
            <returns>tableau de poids d'un graphe, chaque poids est le plus court distance entre i et j</returns>
        </member>
        <member name="M:Matching.ResearchGraph.GetClusterTable(System.Collections.Generic.Dictionary{System.Collections.Generic.KeyValuePair{System.String,System.Int32},System.Collections.Generic.List{System.String}},System.Collections.Generic.List{System.String},System.Int32)">
            <summary>
            Construire la inverted index tableau
            </summary>
            <param name="clusterTable">outputs</param>
            <param name="namePlusEdge">les nomGraph$nomArc dans un groupe</param>
            <param name="group">numéro de groupe</param>
        </member>
        <member name="M:Matching.VectorFMGE.#ctor">
            <summary>
            constructeur
            </summary>
        </member>
        <member name="M:Matching.VectorFMGE.#ctor(System.String)">
            <summary>
            constructeur avec un string qui a lu dans un fichier xml. ex: string="1,2,3,4,5".
            </summary>
            <param name="StrVector">le nom du clique</param>
        </member>
        <member name="M:Matching.VectorFMGE.#ctor(System.String,System.String)">
            <summary>
            constructeur avec un nom et un string qui a lu dans un fichier xml. ex: string="1,2,3,4,5".
            </summary>
            <param name="StrVector">nom du clique</param>
            <param name="StrVector">le vecteur en forme de string</param>
        </member>
        <member name="M:Matching.VectorFMGE.GetMatrix">
            <summary>
            Returner une liste de type double
            </summary>
            <returns>vecteur en forme de tableau</returns>
        </member>
        <member name="M:Matching.VectorFMGE.GetString">
            <summary>
            Retourner une type string qui contient tous les valeurs de vecteur
            </summary>
            <returns>retourner un string qui contient tout les valeurs d'un vecteur, il peut être lu et remise dans 
            un VectorFGME par la méthode SetString</returns>
        </member>
        <member name="M:Matching.VectorFMGE.SetString(System.String)">
            <summary>
            lire un string crée par la méthode GetString et les remise dans vecteur
            le string doit respecter la formule comme : "1,2,3,4,5"
            </summary>
            <param name="StrVector">string qui crée par la méthode GetString</param>
        </member>
        <member name="T:Matching.Combinations`1">
            <summary>
            Combinations defines a meta-collection, typically a list of lists, of all possible 
            subsets of a particular size from the set of values.  This list is enumerable and 
            allows the scanning of all possible combinations using a simple foreach() loop.
            Within the returned set, there is no prescribed order.  This follows the mathematical
            concept of choose.  For example, put 10 dominoes in a hat and pick 5.  The number of possible
            combinations is defined as "10 choose 5", which is calculated as (10!) / ((10 - 5)! * 5!).
            </summary>
            <remarks>
            The MetaCollectionType parameter of the constructor allows for the creation of
            two types of sets,  those with and without repetition in the output set when 
            presented with repetition in the input set.
            
            When given a input collect {A B C} and lower index of 2, the following sets are generated:
            MetaCollectionType.WithRepetition =>
            {A A}, {A B}, {A C}, {B B}, {B C}, {C C}
            MetaCollectionType.WithoutRepetition =>
            {A B}, {A C}, {B C}
            
            Input sets with multiple equal values will generate redundant combinations in proprotion
            to the likelyhood of outcome.  For example, {A A B B} and a lower index of 3 will generate:
            {A A B} {A A B} {A B B} {A B B}
            </remarks>
            <typeparam name="T">The type of the values within the list.</typeparam>
        </member>
        <member name="T:Matching.IMetaCollection`1">
            <summary>
            Interface for Permutations, Combinations and any other classes that present
            a collection of collections based on an input collection.  The enumerators that 
            this class inherits defines the mechanism for enumerating through the collections.  
            </summary>
            <typeparam name="T">The of the elements in the collection, not the type of the collection.</typeparam>
        </member>
        <member name="P:Matching.IMetaCollection`1.Count">
            <summary>
            The count of items in the collection.  This is not inherited from
            ICollection since this meta-collection cannot be extended by users.
            </summary>
        </member>
        <member name="P:Matching.IMetaCollection`1.Type">
            <summary>
            The type of the meta-collection, determining how the collections are 
            determined from the inputs.
            </summary>
        </member>
        <member name="P:Matching.IMetaCollection`1.UpperIndex">
            <summary>
            The upper index of the meta-collection, which is the size of the input collection.
            </summary>
        </member>
        <member name="P:Matching.IMetaCollection`1.LowerIndex">
            <summary>
            The lower index of the meta-collection, which is the size of each output collection.
            </summary>
        </member>
        <member name="M:Matching.Combinations`1.#ctor">
            <summary>
            No default constructor, must provided a list of values and size.
            </summary>
        </member>
        <member name="M:Matching.Combinations`1.#ctor(System.Collections.Generic.IList{`0},System.Int32)">
            <summary>
            Create a combination set from the provided list of values.
            The upper index is calculated as values.Count, the lower index is specified.
            Collection type defaults to MetaCollectionType.WithoutRepetition
            </summary>
            <param name="values">List of values to select combinations from.</param>
            <param name="lowerIndex">The size of each combination set to return.</param>
        </member>
        <member name="M:Matching.Combinations`1.#ctor(System.Collections.Generic.IList{`0},System.Int32,Matching.GenerateOption)">
            <summary>
            Create a combination set from the provided list of values.
            The upper index is calculated as values.Count, the lower index is specified.
            </summary>
            <param name="values">List of values to select combinations from.</param>
            <param name="lowerIndex">The size of each combination set to return.</param>
            <param name="type">The type of Combinations set to generate.</param>
        </member>
        <member name="M:Matching.Combinations`1.GetEnumerator">
            <summary>
            Gets an enumerator for collecting the list of combinations.
            </summary>
            <returns>The enumerator.</returns>
        </member>
        <member name="M:Matching.Combinations`1.System#Collections#IEnumerable#GetEnumerator">
            <summary>
            Gets an enumerator for collecting the list of combinations.
            </summary>
            <returns>The enumerator</returns>
        </member>
        <member name="M:Matching.Combinations`1.Initialize(System.Collections.Generic.IList{`0},System.Int32,Matching.GenerateOption)">
            <summary>
            Initialize the combinations by settings a copy of the values from the 
            </summary>
            <param name="values">List of values to select combinations from.</param>
            <param name="lowerIndex">The size of each combination set to return.</param>
            <param name="type">The type of Combinations set to generate.</param>
            <remarks>
            Copies the array and parameters and then creates a map of booleans that will 
            be used by a permutations object to refence the subset.  This map is slightly
            different based on whether the type is with or without repetition.
            
            When the type is WithoutRepetition, then a map of upper index elements is
            created with lower index false's.  
            E.g. 8 choose 3 generates:
            Map: {1 1 1 1 1 0 0 0}
            Note: For sorting reasons, false denotes inclusion in output.
            
            When the type is WithRepetition, then a map of upper index - 1 + lower index
            elements is created with the falses indicating that the 'current' element should
            be included and the trues meaning to advance the 'current' element by one.
            E.g. 8 choose 3 generates:
            Map: {1 1 1 1 1 1 1 1 0 0 0} (7 trues, 3 falses).
            </remarks>
        </member>
        <member name="F:Matching.Combinations`1.myValues">
            <summary>
            Copy of values object is intialized with, required for enumerator reset.
            </summary>
        </member>
        <member name="F:Matching.Combinations`1.myPermutations">
            <summary>
            Permutations object that handles permutations on booleans for combination inclusion.
            </summary>
        </member>
        <member name="F:Matching.Combinations`1.myMetaCollectionType">
            <summary>
            The type of the combination collection.
            </summary>
        </member>
        <member name="F:Matching.Combinations`1.myLowerIndex">
            <summary>
            The lower index defined in the constructor.
            </summary>
        </member>
        <member name="P:Matching.Combinations`1.Count">
            <summary>
            The number of unique combinations that are defined in this meta-collection.
            This value is mathematically defined as Choose(M, N) where M is the set size
            and N is the subset size.  This is M! / (N! * (M-N)!).
            </summary>
        </member>
        <member name="P:Matching.Combinations`1.Type">
            <summary>
            The type of Combinations set that is generated.
            </summary>
        </member>
        <member name="P:Matching.Combinations`1.UpperIndex">
            <summary>
            The upper index of the meta-collection, equal to the number of items in the initial set.
            </summary>
        </member>
        <member name="P:Matching.Combinations`1.LowerIndex">
            <summary>
            The lower index of the meta-collection, equal to the number of items returned each iteration.
            </summary>
        </member>
        <member name="T:Matching.Combinations`1.Enumerator">
            <summary>
            The enumerator that enumerates each meta-collection of the enclosing Combinations class.
            </summary>
        </member>
        <member name="M:Matching.Combinations`1.Enumerator.#ctor(Matching.Combinations{`0})">
            <summary>
            Construct a enumerator with the parent object.
            </summary>
            <param name="source">The source combinations object.</param>
        </member>
        <member name="M:Matching.Combinations`1.Enumerator.Reset">
            <summary>
            Resets the combinations enumerator to the first combination.  
            </summary>
        </member>
        <member name="M:Matching.Combinations`1.Enumerator.MoveNext">
            <summary>
            Advances to the next combination of items from the set.
            </summary>
            <returns>True if successfully moved to next combination, False if no more unique combinations exist.</returns>
            <remarks>
            The heavy lifting is done by the permutations object, the combination is generated
            by creating a new list of those items that have a true in the permutation parrellel array.
            </remarks>
        </member>
        <member name="M:Matching.Combinations`1.Enumerator.Dispose">
            <summary>
            Cleans up non-managed resources, of which there are none used here.
            </summary>
        </member>
        <member name="M:Matching.Combinations`1.Enumerator.ComputeCurrent">
            <summary>
            The only complex function of this entire wrapper, ComputeCurrent() creates
            a list of original values from the bool permutation provided.  
            The exception for accessing current (InvalidOperationException) is generated
            by the call to .Current on the underlying enumeration.
            </summary>
            <remarks>
            To compute the current list of values, the underlying permutation object
            which moves with this enumerator, is scanned differently based on the type.
            The items have only two values, true and false, which have different meanings:
            
            For type WithoutRepetition, the output is a straightforward subset of the input array.  
            E.g. 6 choose 3 without repetition
            Input array:   {A B C D E F}
            Permutations:  {0 1 0 0 1 1}
            Generates set: {A   C D    }
            Note: size of permutation is equal to upper index.
            
            For type WithRepetition, the output is defined by runs of characters and when to 
            move to the next element.
            E.g. 6 choose 5 with repetition
            Input array:   {A B C D E F}
            Permutations:  {0 1 0 0 1 1 0 0 1 1}
            Generates set: {A   B B     D D    }
            Note: size of permutation is equal to upper index - 1 + lower index.
            </remarks>
        </member>
        <member name="F:Matching.Combinations`1.Enumerator.myParent">
            <summary>
            Parent object this is an enumerator for.
            </summary>
        </member>
        <member name="F:Matching.Combinations`1.Enumerator.myCurrentList">
            <summary>
            The current list of values, this is lazy evaluated by the Current property.
            </summary>
        </member>
        <member name="F:Matching.Combinations`1.Enumerator.myPermutationsEnumerator">
            <summary>
            An enumertor of the parents list of lexicographic orderings.
            </summary>
        </member>
        <member name="P:Matching.Combinations`1.Enumerator.Current">
            <summary>
            The current combination
            </summary>
        </member>
        <member name="P:Matching.Combinations`1.Enumerator.System#Collections#IEnumerator#Current">
            <summary>
            The current combination
            </summary>
        </member>
        <member name="T:Matching.GenerateOption">
            <summary>
            Indicates whether a Permutation, Combination or Variation meta-collections
            generate repetition sets.  
            </summary>
        </member>
        <member name="F:Matching.GenerateOption.WithoutRepetition">
            <summary>
            Do not generate additional sets, typical implementation.
            </summary>
        </member>
        <member name="F:Matching.GenerateOption.WithRepetition">
            <summary>
            Generate additional sets even if repetition is required.
            </summary>
        </member>
        <member name="T:Matching.Permutations`1">
            <summary>
            Permutations defines a meta-collection, typically a list of lists, of all
            possible orderings of a set of values.  This list is enumerable and allows
            the scanning of all possible permutations using a simple foreach() loop.
            The MetaCollectionType parameter of the constructor allows for the creation of
            two types of sets,  those with and without repetition in the output set when 
            presented with repetition in the input set.
            </summary>
            <remarks>
            When given a input collect {A A B}, the following sets are generated:
            MetaCollectionType.WithRepetition =>
            {A A B}, {A B A}, {A A B}, {A B A}, {B A A}, {B A A}
            MetaCollectionType.WithoutRepetition =>
            {A A B}, {A B A}, {B A A}
            
            When generating non-repetition sets, ordering is based on the lexicographic 
            ordering of the lists based on the provided Comparer.  
            If no comparer is provided, then T must be IComparable on T.
            
            When generating repetition sets, no comparisions are performed and therefore
            no comparer is required and T does not need to be IComparable.
            </remarks>
            <typeparam name="T">The type of the values within the list.</typeparam>
        </member>
        <member name="M:Matching.Permutations`1.#ctor">
            <summary>
            No default constructor, must at least provided a list of values.
            </summary>
        </member>
        <member name="M:Matching.Permutations`1.#ctor(System.Collections.Generic.IList{`0})">
            <summary>
            Create a permutation set from the provided list of values.  
            The values (T) must implement IComparable.  
            If T does not implement IComparable use a constructor with an explict IComparer.
            The repetition type defaults to MetaCollectionType.WithholdRepetitionSets
            </summary>
            <param name="values">List of values to permute.</param>
        </member>
        <member name="M:Matching.Permutations`1.#ctor(System.Collections.Generic.IList{`0},Matching.GenerateOption)">
            <summary>
            Create a permutation set from the provided list of values.  
            If type is MetaCollectionType.WithholdRepetitionSets, then values (T) must implement IComparable.  
            If T does not implement IComparable use a constructor with an explict IComparer.
            </summary>
            <param name="values">List of values to permute.</param>
            <param name="type">The type of permutation set to calculate.</param>
        </member>
        <member name="M:Matching.Permutations`1.#ctor(System.Collections.Generic.IList{`0},System.Collections.Generic.IComparer{`0})">
            <summary>
            Create a permutation set from the provided list of values.  
            The values will be compared using the supplied IComparer.
            The repetition type defaults to MetaCollectionType.WithholdRepetitionSets
            </summary>
            <param name="values">List of values to permute.</param>
            <param name="comparer">Comparer used for defining the lexigraphic order.</param>
        </member>
        <member name="M:Matching.Permutations`1.GetEnumerator">
            <summary>
            Gets an enumerator for collecting the list of permutations.
            </summary>
            <returns>The enumerator.</returns>
        </member>
        <member name="M:Matching.Permutations`1.System#Collections#Generic#IEnumerable{System#Collections#Generic#IList{T}}#GetEnumerator">
            <summary>
            Gets an enumerator for collecting the list of permutations.
            </summary>
            <returns>The enumerator.</returns>
        </member>
        <member name="M:Matching.Permutations`1.Initialize(System.Collections.Generic.IList{`0},Matching.GenerateOption,System.Collections.Generic.IComparer{`0})">
             <summary>
             Common intializer used by the multiple flavors of constructors.
             </summary>
             <remarks>
             Copies information provided and then creates a parellel int array of lexicographic
             orders that will be used for the actual permutation algorithm.  
             The input array is first sorted as required for WithoutRepetition and always just for consistency.
             This array is constructed one of two way depending on the type of the collection.
            
             When type is MetaCollectionType.WithRepetition, then all N! permutations are returned
             and the lexicographic orders are simply generated as 1, 2, ... N.  
             E.g.
             Input array:          {A A B C D E E}
             Lexicograhpic Orders: {1 2 3 4 5 6 7}
             
             When type is MetaCollectionType.WithoutRepetition, then fewer are generated, with each
             identical element in the input array not repeated.  The lexicographic sort algorithm
             handles this natively as long as the repetition is repeated.
             E.g.
             Input array:          {A A B C D E E}
             Lexicograhpic Orders: {1 1 2 3 4 5 5}
             </remarks>
        </member>
        <member name="M:Matching.Permutations`1.GetCount">
            <summary>
            Calculates the total number of permutations that will be returned.  
            As this can grow very large, extra effort is taken to avoid overflowing the accumulator.  
            While the algorithm looks complex, it really is just collecting numerator and denominator terms
            and cancelling out all of the denominator terms before taking the product of the numerator terms.  
            </summary>
            <returns>The number of permutations.</returns>
        </member>
        <member name="F:Matching.Permutations`1.myValues">
            <summary>
            A list of T that represents the order of elements as originally provided, used for Reset.
            </summary>
        </member>
        <member name="F:Matching.Permutations`1.myLexicographicOrders">
            <summary>
            Parrellel array of integers that represent the location of items in the myValues array.
            This is generated at Initialization and is used as a performance speed up rather that
            comparing T each time, much faster to let the CLR optimize around integers.
            </summary>
        </member>
        <member name="F:Matching.Permutations`1.myCount">
            <summary>
            The count of all permutations.  Calculated at Initialization and returned by Count property.
            </summary>
        </member>
        <member name="F:Matching.Permutations`1.myMetaCollectionType">
            <summary>
            The type of Permutations that this was intialized from.
            </summary>
        </member>
        <member name="P:Matching.Permutations`1.Count">
            <summary>
            The count of all permutations that will be returned.
            If type is MetaCollectionType.WithholdGeneratedSets, then this does not double count permutations with multiple identical values.  
            I.e. count of permutations of "AAB" will be 3 instead of 6.  
            If type is MetaCollectionType.WithRepetition, then this is all combinations and is therefore N!, where N is the number of values.
            </summary>
        </member>
        <member name="P:Matching.Permutations`1.Type">
            <summary>
            The type of Permutations set that is generated.
            </summary>
        </member>
        <member name="P:Matching.Permutations`1.UpperIndex">
            <summary>
            The upper index of the meta-collection, equal to the number of items in the initial set.
            </summary>
        </member>
        <member name="P:Matching.Permutations`1.LowerIndex">
            <summary>
            The lower index of the meta-collection, equal to the number of items returned each iteration.
            For Permutation, this is always equal to the UpperIndex.
            </summary>
        </member>
        <member name="T:Matching.Permutations`1.Enumerator">
            <summary>
            The enumerator that enumerates each meta-collection of the enclosing Permutations class.
            </summary>
        </member>
        <member name="M:Matching.Permutations`1.Enumerator.#ctor(Matching.Permutations{`0})">
            <summary>
            Construct a enumerator with the parent object.
            </summary>
            <param name="source">The source Permutations object.</param>
        </member>
        <member name="M:Matching.Permutations`1.Enumerator.Reset">
            <summary>
            Resets the permutations enumerator to the first permutation.  
            This will be the first lexicographically order permutation.
            </summary>
        </member>
        <member name="M:Matching.Permutations`1.Enumerator.MoveNext">
            <summary>
            Advances to the next permutation.
            </summary>
            <returns>True if successfully moved to next permutation, False if no more permutations exist.</returns>
            <remarks>
            Continuation was tried (i.e. yield return) by was not nearly as efficient.
            Performance is further increased by using value types and removing generics, that is, the LexicographicOrder parellel array.
            This is a issue with the .NET CLR not optimizing as well as it could in this infrequently used scenario.
            </remarks>
        </member>
        <member name="M:Matching.Permutations`1.Enumerator.Dispose">
            <summary>
            Cleans up non-managed resources, of which there are none used here.
            </summary>
        </member>
        <member name="M:Matching.Permutations`1.Enumerator.NextPermutation">
            <summary>
            Calculates the next lexicographical permutation of the set.
            This is a permutation with repetition where values that compare as equal will not 
            swap positions to create a new permutation.
            http://www.cut-the-knot.org/do_you_know/AllPerm.shtml
            E. W. Dijkstra, A Discipline of Programming, Prentice-Hall, 1997  
            </summary>
            <returns>True if a new permutation has been returned, false if not.</returns>
            <remarks>
            This uses the integers of the lexicographical order of the values so that any
            comparison of values are only performed during initialization. 
            </remarks>
        </member>
        <member name="M:Matching.Permutations`1.Enumerator.Swap(System.Int32,System.Int32)">
            <summary>
            Helper function for swapping two elements within the internal collection.
            This swaps both the lexicographical order and the values, maintaining the parallel array.
            </summary>
        </member>
        <member name="F:Matching.Permutations`1.Enumerator.myTemp">
            <summary>
            Single instance of swap variable for T, small performance improvement over declaring in Swap function scope.
            </summary>
        </member>
        <member name="F:Matching.Permutations`1.Enumerator.myKviTemp">
            <summary>
            Single instance of swap variable for int, small performance improvement over declaring in Swap function scope.
            </summary>
        </member>
        <member name="F:Matching.Permutations`1.Enumerator.myPosition">
            <summary>
            Flag indicating the position of the enumerator.
            </summary>
        </member>
        <member name="F:Matching.Permutations`1.Enumerator.myLexicographicalOrders">
            <summary>
            Parrellel array of integers that represent the location of items in the myValues array.
            This is generated at Initialization and is used as a performance speed up rather that
            comparing T each time, much faster to let the CLR optimize around integers.
            </summary>
        </member>
        <member name="F:Matching.Permutations`1.Enumerator.myValues">
            <summary>
            The list of values that are current to the enumerator.
            </summary>
        </member>
        <member name="F:Matching.Permutations`1.Enumerator.myParent">
            <summary>
            The set of permuations that this enumerator enumerates.
            </summary>
        </member>
        <member name="P:Matching.Permutations`1.Enumerator.Current">
            <summary>
            The current permutation.
            </summary>
        </member>
        <member name="P:Matching.Permutations`1.Enumerator.System#Collections#Generic#IEnumerator{System#Collections#Generic#IList{T}}#Current">
            <summary>
            The current permutation.
            </summary>
        </member>
        <member name="T:Matching.Permutations`1.Enumerator.Position">
            <summary>
            Internal position type for tracking enumertor position.
            </summary>
        </member>
        <member name="T:Matching.Permutations`1.SelfComparer`1">
            <summary>
            Inner class that wraps an IComparer around a type T when it is IComparable
            </summary>
        </member>
        <member name="T:Matching.SmallPrimeUtility">
            <summary>
            Utility class that maintains a small table of prime numbers and provides
            simple implementations of Prime Factorization algorithms.  
            This is a quick and dirty utility class to support calculations of permutation
            sets with indexes under 2^31.
            The prime table contains all primes up to Sqrt(2^31) which are all of the primes
            requires to factorize any Int32 positive integer.
            </summary>
        </member>
        <member name="M:Matching.SmallPrimeUtility.#ctor">
            <summary>
            Utility class, no instances allowed.
            </summary>
        </member>
        <member name="M:Matching.SmallPrimeUtility.Factor(System.Int32)">
            <summary>
            Performs a prime factorization of a given integer using the table of primes in PrimeTable.
            Since this will only factor Int32 sized integers, a simple list of factors is returned instead
            of the more scalable, but more difficult to consume, list of primes and associated exponents.
            </summary>
            <param name="i">The number to factorize, must be positive.</param>
            <returns>A simple list of factors.</returns>
        </member>
        <member name="M:Matching.SmallPrimeUtility.MultiplyPrimeFactors(System.Collections.Generic.IList{System.Int32},System.Collections.Generic.IList{System.Int32})">
            <summary>
            Given two integers expressed as a list of prime factors, multiplies these numbers
            together and returns an integer also expressed as a set of prime factors.
            This allows multiplication to overflow well beyond a Int64 if necessary.  
            </summary>
            <param name="lhs">Left Hand Side argument, expressed as list of prime factors.</param>
            <param name="rhs">Right Hand Side argument, expressed as list of prime factors.</param>
            <returns>Product, expressed as list of prime factors.</returns>
        </member>
        <member name="M:Matching.SmallPrimeUtility.DividePrimeFactors(System.Collections.Generic.IList{System.Int32},System.Collections.Generic.IList{System.Int32})">
            <summary>
            Given two integers expressed as a list of prime factors, divides these numbers
            and returns an integer also expressed as a set of prime factors.
            If the result is not a integer, then the result is undefined.  That is, 11 / 5
            when divided by this function will not yield a correct result.
            As such, this function is ONLY useful for division with combinatorial results where 
            the result is known to be an integer AND the division occurs as the last operation(s).
            </summary>
            <param name="numerator">Numerator argument, expressed as list of prime factors.</param>
            <param name="denominator">Denominator argument, expressed as list of prime factors.</param>
            <returns>Resultant, expressed as list of prime factors.</returns>
        </member>
        <member name="M:Matching.SmallPrimeUtility.EvaluatePrimeFactors(System.Collections.Generic.IList{System.Int32})">
            <summary>
            Given a list of prime factors returns the long representation.
            </summary>
            <param name="value">Integer, expressed as list of prime factors.</param>
            <returns>Standard long representation.</returns>
        </member>
        <member name="M:Matching.SmallPrimeUtility.#cctor">
            <summary>
            Static initializer, set up prime table.
            </summary>
        </member>
        <member name="M:Matching.SmallPrimeUtility.CalculatePrimes">
            <summary>
            Calculate all primes up to Sqrt(2^32) = 2^16.  
            This table will be large enough for all factorizations for Int32's.
            Small tables are best built using the Sieve Of Eratosthenes,
            Reference: http://primes.utm.edu/glossary/page.php?sort=SieveOfEratosthenes
            </summary>
        </member>
        <member name="P:Matching.SmallPrimeUtility.PrimeTable">
            <summary>
            A List of all primes from 2 to 2^16.
            </summary>
        </member>
        <member name="T:Matching.Variations`1">
            <summary>
            Variations defines a meta-collection, typically a list of lists, of all possible 
            ordered subsets of a particular size from the set of values.  
            This list is enumerable and allows the scanning of all possible Variations using a simple 
            foreach() loop even though the variations are not all in memory.
            </summary>
            <remarks>
            The MetaCollectionType parameter of the constructor allows for the creation of
            normal Variations and Variations with Repetition.
            
            When given an input collect {A B C} and lower index of 2, the following sets are generated:
            MetaCollectionType.WithoutRepetition generates 6 sets: =>
                {A B}, {A B}, {B A}, {B C}, {C A}, {C B}
            MetaCollectionType.WithRepetition generates 9 sets:
                {A A}, {A B}, {A B}, {B A}, {B B }, {B C}, {C A}, {C B}, {C C}
            
            The equality of multiple inputs is not considered when generating variations.
            </remarks>
            <typeparam name="T">The type of the values within the list.</typeparam>
        </member>
        <member name="M:Matching.Variations`1.#ctor">
            <summary>
            No default constructor, must provided a list of values and size.
            </summary>
        </member>
        <member name="M:Matching.Variations`1.#ctor(System.Collections.Generic.IList{`0},System.Int32)">
            <summary>
            Create a variation set from the indicated list of values.
            The upper index is calculated as values.Count, the lower index is specified.
            Collection type defaults to MetaCollectionType.WithoutRepetition
            </summary>
            <param name="values">List of values to select Variations from.</param>
            <param name="lowerIndex">The size of each variation set to return.</param>
        </member>
        <member name="M:Matching.Variations`1.#ctor(System.Collections.Generic.IList{`0},System.Int32,Matching.GenerateOption)">
            <summary>
            Create a variation set from the indicated list of values.
            The upper index is calculated as values.Count, the lower index is specified.
            </summary>
            <param name="values">List of values to select variations from.</param>
            <param name="lowerIndex">The size of each vatiation set to return.</param>
            <param name="type">Type indicates whether to use repetition in set generation.</param>
        </member>
        <member name="M:Matching.Variations`1.GetEnumerator">
            <summary>
            Gets an enumerator for the collection of Variations.
            </summary>
            <returns>The enumerator.</returns>
        </member>
        <member name="M:Matching.Variations`1.System#Collections#IEnumerable#GetEnumerator">
            <summary>
            Gets an enumerator for the collection of Variations.
            </summary>
            <returns>The enumerator.</returns>
        </member>
        <member name="M:Matching.Variations`1.Initialize(System.Collections.Generic.IList{`0},System.Int32,Matching.GenerateOption)">
            <summary>
            Initialize the variations for constructors.
            </summary>
            <param name="values">List of values to select variations from.</param>
            <param name="lowerIndex">The size of each variation set to return.</param>
            <param name="type">The type of variations set to generate.</param>
        </member>
        <member name="F:Matching.Variations`1.myValues">
            <summary>
            Copy of values object is intialized with, required for enumerator reset.
            </summary>
        </member>
        <member name="F:Matching.Variations`1.myPermutations">
            <summary>
            Permutations object that handles permutations on int for variation inclusion and ordering.
            </summary>
        </member>
        <member name="F:Matching.Variations`1.myMetaCollectionType">
            <summary>
            The type of the variation collection.
            </summary>
        </member>
        <member name="F:Matching.Variations`1.myLowerIndex">
            <summary>
            The lower index defined in the constructor.
            </summary>
        </member>
        <member name="P:Matching.Variations`1.Count">
            <summary>
            The number of unique variations that are defined in this meta-collection.
            </summary>
            <remarks>
            Variations with repetitions does not behave like other meta-collections and it's
            count is equal to N^P, where N is the upper index and P is the lower index.
            </remarks>
        </member>
        <member name="P:Matching.Variations`1.Type">
            <summary>
            The type of Variations set that is generated.
            </summary>
        </member>
        <member name="P:Matching.Variations`1.UpperIndex">
            <summary>
            The upper index of the meta-collection, equal to the number of items in the initial set.
            </summary>
        </member>
        <member name="P:Matching.Variations`1.LowerIndex">
            <summary>
            The lower index of the meta-collection, equal to the number of items returned each iteration.
            </summary>
        </member>
        <member name="T:Matching.Variations`1.EnumeratorWithRepetition">
            <summary>
            An enumerator for Variations when the type is set to WithRepetition.
            </summary>
        </member>
        <member name="M:Matching.Variations`1.EnumeratorWithRepetition.#ctor(Matching.Variations{`0})">
            <summary>
            Construct a enumerator with the parent object.
            </summary>
            <param name="source">The source Variations object.</param>
        </member>
        <member name="M:Matching.Variations`1.EnumeratorWithRepetition.Reset">
            <summary>
            Resets the Variations enumerator to the first variation.  
            </summary>
        </member>
        <member name="M:Matching.Variations`1.EnumeratorWithRepetition.MoveNext">
            <summary>
            Advances to the next variation.
            </summary>
            <returns>True if successfully moved to next variation, False if no more variations exist.</returns>
            <remarks>
            Increments the internal myListIndexes collection by incrementing the last index
            and overflow/carrying into others just like grade-school arithemtic.  If the 
            finaly carry flag is set, then we would wrap around and are therefore done.
            </remarks>
        </member>
        <member name="M:Matching.Variations`1.EnumeratorWithRepetition.Dispose">
            <summary>
            Cleans up non-managed resources, of which there are none used here.
            </summary>
        </member>
        <member name="M:Matching.Variations`1.EnumeratorWithRepetition.ComputeCurrent">
            <summary>
            Computes the current list based on the internal list index.
            </summary>
        </member>
        <member name="F:Matching.Variations`1.EnumeratorWithRepetition.myParent">
            <summary>
            Parent object this is an enumerator for.
            </summary>
        </member>
        <member name="F:Matching.Variations`1.EnumeratorWithRepetition.myCurrentList">
            <summary>
            The current list of values, this is lazy evaluated by the Current property.
            </summary>
        </member>
        <member name="F:Matching.Variations`1.EnumeratorWithRepetition.myListIndexes">
            <summary>
            An enumertor of the parents list of lexicographic orderings.
            </summary>
        </member>
        <member name="P:Matching.Variations`1.EnumeratorWithRepetition.Current">
            <summary>
            The current variation
            </summary>
        </member>
        <member name="P:Matching.Variations`1.EnumeratorWithRepetition.System#Collections#IEnumerator#Current">
            <summary>
            The current variation.
            </summary>
        </member>
        <member name="T:Matching.Variations`1.EnumeratorWithoutRepetition">
            <summary>
            An enumerator for Variations when the type is set to WithoutRepetition.
            </summary>
        </member>
        <member name="M:Matching.Variations`1.EnumeratorWithoutRepetition.#ctor(Matching.Variations{`0})">
            <summary>
            Construct a enumerator with the parent object.
            </summary>
            <param name="source">The source Variations object.</param>
        </member>
        <member name="M:Matching.Variations`1.EnumeratorWithoutRepetition.Reset">
            <summary>
            Resets the Variations enumerator to the first variation.  
            </summary>
        </member>
        <member name="M:Matching.Variations`1.EnumeratorWithoutRepetition.MoveNext">
            <summary>
            Advances to the next variation.
            </summary>
            <returns>True if successfully moved to next variation, False if no more variations exist.</returns>
        </member>
        <member name="M:Matching.Variations`1.EnumeratorWithoutRepetition.Dispose">
            <summary>
            Cleans up non-managed resources, of which there are none used here.
            </summary>
        </member>
        <member name="M:Matching.Variations`1.EnumeratorWithoutRepetition.ComputeCurrent">
            <summary>
            Creates a list of original values from the int permutation provided.  
            The exception for accessing current (InvalidOperationException) is generated
            by the call to .Current on the underlying enumeration.
            </summary>
            <remarks>
            To compute the current list of values, the element to use is determined by 
            a permutation position with a non-MaxValue value.  It is placed at the position in the
            output that the index value indicates.
            
            E.g. Variations of 6 choose 3 without repetition
            Input array:   {A B C D E F}
            Permutations:  {- 1 - - 3 2} (- is Int32.MaxValue)
            Generates set: {B F E}
            </remarks>
        </member>
        <member name="F:Matching.Variations`1.EnumeratorWithoutRepetition.myParent">
            <summary>
            Parent object this is an enumerator for.
            </summary>
        </member>
        <member name="F:Matching.Variations`1.EnumeratorWithoutRepetition.myCurrentList">
            <summary>
            The current list of values, this is lazy evaluated by the Current property.
            </summary>
        </member>
        <member name="F:Matching.Variations`1.EnumeratorWithoutRepetition.myPermutationsEnumerator">
            <summary>
            An enumertor of the parents list of lexicographic orderings.
            </summary>
        </member>
        <member name="P:Matching.Variations`1.EnumeratorWithoutRepetition.Current">
            <summary>
            The current variation.
            </summary>
        </member>
        <member name="P:Matching.Variations`1.EnumeratorWithoutRepetition.System#Collections#IEnumerator#Current">
            <summary>
            The current variation.
            </summary>
        </member>
        <member name="M:Matching.Glpk_Controller.#ctor">
            <summary>
             constructor
            </summary>
        </member>
        <member name="M:Matching.Glpk_Controller.transToDirectedGraph(Graphs.Graph)">
            <summary>
             transform a undirected graph to a directed graph
            </summary>
            <param name="g">the graph to be transformed</param>
        </member>
        <member name="M:Matching.Glpk_Controller.Call_GlPK(System.Boolean,System.Windows.Forms.ToolStripStatusLabel,System.String,Matching.Lib_Controller)">
            <summary>
             Call the solver GLPK
            </summary>
            <param name="exact">indicating the method to use is exact solve or not</param>
            <param name="status"></param>
            <param name="ResultText"></param>
            <param name="lib_controller">the controller of the lib Graph</param>
        </member>
        <member name="M:Matching.Glpk_Controller.exact_solve(Graphs.Graph,Graphs.Graph,System.String)">
            <summary>
             solve the problem using exact method
            </summary>
            <param name="directedG1">the graph 1</param>
            <param name="directedG2">the graph 2</param>
            <param name="ResultText"></param>
        </member>
        <member name="M:Matching.Glpk_Controller.inexact_solve(Graphs.Graph,Graphs.Graph,System.String)">
            <summary>
             solve the problem using inexact method
            </summary>
            <param name="directedG1">the graph 1</param>
            <param name="directedG2">the graph 2</param>
            <param name="ResultText"></param>
        </member>
        <member name="M:Matching.Glpk_Controller.saveProblem(System.Windows.Forms.ToolStripStatusLabel)">
            <summary>
             Save the problem in CLPLEX format to text file
            </summary>
        </member>
        <member name="M:Matching.Glpk_Controller.saveResult(System.Windows.Forms.ToolStripStatusLabel)">
            <summary>
             Save the result in GLPK format to text file
            </summary>
        </member>
        <member name="M:Matching.Glpk_Controller.clearGraphs">
            <summary>
             let all the graph pointors of the controller point to null
            </summary>
        </member>
        <member name="M:Matching.Glpk_Solver.#ctor">
            <summary>
             constructor
            </summary>
        </member>
        <member name="M:Matching.Glpk_Solver.#ctor(Graphs.Graph,Graphs.Graph,System.String)">
            <summary>
             constructor
             Construct the problem and then solve it
            </summary>
        </member>
        <member name="M:Matching.Glpk_Solver.Finalize">
            <summary>
             destructor
            </summary>
        </member>
        <member name="M:Matching.Glpk_Solver.solve_problem">
            <summary>
             call the solve method to solve the problem transformed as a parameter
            </summary>
        </member>
        <member name="M:Matching.Glpk_Solver.getObjResVal">
            <summary>
             get the result value of the function objective       
            </summary>
            <returns> the objective value
            if the problem has no bojective value, return -1
            </returns>
        </member>
        <member name="M:Matching.Glpk_Solver.print_sol(System.Collections.Generic.List{System.String[]},System.String)">
            <summary>
             print the result to the richText of the mainWindow
            </summary>
            <param name="MatchingNodes"></param>
            <param name="ResultText"></param>
        </member>
        <member name="M:Matching.Glpk_Solver.seperateValName(System.String)">
            <summary>
             small tool function. Analysing the name of a variable
             for exemple: valName="x_node1,node3", the function return a table of 2 elements: "node1", "node3"
            </summary>
            <param name="valName"></param>
        </member>
        <member name="M:Matching.Glpk_Solver.problemSave(System.String)">
            <summary>
             save the problem in CPLEX format into a text file.
            </summary>
            <param name="fname"></param>
        </member>
        <member name="M:Matching.Glpk_Solver.solutionSave(System.String)">
            <summary>
             save the solve result into a text file.
            </summary>
            <param name="fname"></param>
        </member>
        <member name="M:Matching.Lib_Controller.LoadGraph(System.Boolean,Matching.Glpk_Controller,System.Windows.Forms.RichTextBox,System.Windows.Forms.ToolStripStatusLabel)">
            <summary>
             Load a graph from the file .gxl, and print out the graph (from : GraphLibTest)
            </summary>
        </member>
        <member name="M:Matching.Lib_Controller.setDirectedGraph(System.Boolean,System.Boolean,Matching.Glpk_Controller,System.String)">
            <summary>
             this function should be called after load a gxl file to a graph (which is a field of the glpk_controller)
             it sets the value of the directedGraph1 or directedGraph2 (fields of the glpk_controller)
             if the new loaded graph is undirected, we reload again the same graph to directedGraph, and then transform it to a directed graph
             if not, we just set the directedGraph point to the Graph
            </summary>
            <param name="directed">the graph who is just loaded is directed or not</param>
            <param name="glpk_controller"></param>
            <param name="nomGxlFile">indicate the file name that we just loaded the graph from</param>
        </member>
        <member name="M:Matching.Lib_Controller.LoadGraph(System.String)">
            <summary>
             Load a graph from the file .gxl, doesn't print out the graph
            </summary>
        </member>
        <member name="M:Matching.Lib_Controller.PrintGraph(Graphs.Graph,System.Boolean,System.Windows.Forms.RichTextBox)">
            <summary>
             print the graph to the textbox (from: GraphLibTest)
            </summary>
            <param name="myGraph"></param>
            <param name="isGraph"></param>
            <param name="textBox"></param>
        </member>
        <member name="M:Matching.Lib_Controller.DisplayGraph(Graphs.Graph,System.Windows.Forms.PictureBox,System.String,System.Windows.Forms.ToolStripStatusLabel)">
            <summary>
            draw the graph to the pictureBox ( from : GraphLibTest)
            </summary>
            <param name="myGraph"></param>
            <param name="picture"></param>
            <param name="jpgfile"></param>
             <param name="status"></param>
        </member>
        <member name="M:Matching.Lib_Controller.generateImage(Graphs.Graph,System.String)">
            <summary>
            generate a image (jpg file) for the graph
            </summary>
            <param name="myGraph"></param>
            <param name="jpgfile"></param>
        </member>
        <member name="M:Matching.Lib_Controller.generateHTML(Matching.Glpk_Controller,System.String,System.String)">
            <summary>
            generate a html  file for the graphs
            </summary>
            <param name="glpk_controller"></param>
            <param name="FileNameHTML"></param>
            <param name="NextFileNameHTML"></param>
        </member>
        <member name="M:Matching.Lib_Controller.ExportHTML(Matching.Glpk_Controller,System.String,System.String,System.String)">
            <summary>
            generate a html  file for the graphs (from the lib Graph)
            copy and make some changes 
            </summary>
            <param name="glpk_controller"></param>
            <param name="PathRessource"></param>
            <param name="FileNameHTML"></param>
            <param name="NextFileNameHTML"></param>
        </member>
        <member name="M:Matching.Lib_Controller.DisplayTouch(Graphs.Graph,System.String,System.Windows.Forms.ToolStripStatusLabel)">
             <summary>
            Display Touch Image (a copy from Lib Graph)
             </summary>
        </member>
        <member name="M:Matching.Lib_Controller.CreateIsoGraph(Graphs.Graph,Graphs.Graph,System.Collections.Generic.List{System.String[]})">
            <summary>
            combain the two graph (a copy from GraphLibTest)
            </summary>
            <param name="g1"></param>
            <param name="g2"></param>
            <param name="IsoNode"></param>
            <returns> the graph combined or null</returns>
        </member>
        <member name="T:Matching.IsomorphismCandG">
            <summary>
            Implémentation de l'algorithme de Corneil et Gotlieb permettant de savoir
            si un graphe est isomorphe ou sous-graphe d'un autre. 
            </summary>
        </member>
        <member name="M:Matching.IsomorphismCandG.#ctor">
            <summary>
            Constructeur.
            </summary>
        </member>
        <member name="M:Matching.IsomorphismCandG.GraphMatching(Graphs.Graph,Graphs.Graph)">
            <summary>
            g1 in g2
            </summary>
            <param name="g1"></param>
            <param name="g2"></param>
            <returns></returns>
        </member>
        <member name="M:Matching.IsomorphismCandG.isIsomorphism(Graphs.Graph,Graphs.Graph)">
            <summary>
            
            </summary>
            <param name="g1"></param>
            <param name="g2"></param>
            <returns></returns>
        </member>
        <member name="M:Matching.IsomorphismCandG.isSubGraphIsomorphism(Graphs.Graph,Graphs.Graph)">
            <summary>
            
            </summary>
            <param name="g1"></param>
            <param name="g2"></param>
            <returns></returns>
        </member>
        <member name="M:Matching.IsomorphismCandG.resultDeep">
            <summary>
            
            </summary>
            <returns></returns>
        </member>
        <member name="M:Matching.IsomorphismCandG.findGraph(Graphs.Graph,Matching.SearchTree)">
            <summary>
            Permet de savoir si graph et isomorphe au graphe contenu dans l'arbre de recherche tree ou s'il est sous-graphe de celui-ci.
            </summary>
            <param name="graph">Graphe pour lequel on veut faire le test.</param>
            <param name="tree">Arbre de recherche dans lequel on va chercher graph.</param>
            <returns>Résultat du test d'isomorphisme.</returns>
        </member>
        <member name="P:Matching.IsomorphismCandG.IsoResult">
            <summary>
            
            </summary>
        </member>
        <member name="T:Matching.Labels">
            <summary>
            Labels hérite de Label et contient une liste de Label. Il permet de représenter les Label du graphe
            qui sont contenus dans un noeud de l'arbre de recherche SearchTree.
            </summary>
        </member>
        <member name="M:Matching.Labels.toString">
            <summary>
            Permet d'obtenir la chaine de caractères qui décrit tous les Label. La chaîne de caractères retournée est en fait la suite des Label.toString() contenus dans ListLabel
            </summary>
            <returns>Description de tous les Label contenus. Une ligne représente un label.</returns>
        </member>
        <member name="M:Matching.Labels.dissimilarity(Graphs.Label)">
            <summary>
            Permet de savoir si les deux ensembles de Label sont jugés identiques. 
            Cette fonction utilise la méthode dissimilarity de chaque Label contenu dans Labels
            avec celui de l'autre Labels étant au même indice. La fonction renvoie seulement
            une réponse vrai ou faux pour savoir si c'est deux Labels sont jugés égaux. 
            Effectivement la somme des Label pourrait être trompeuse en cas de signes contraires et 
            donc retourner un faux matching.
            </summary>
            <param name="labels">Labels avec lequel on veut tester la dissimilarité.</param>
            <returns>0 si les Labels sont jugés similaires, 1 s'ils ne sont pas similaires, double.MinValue si les Labels ne contiennent pas autant de Label ou que la paramètre n'est pas un Labels.</returns>
        </member>
        <member name="M:Matching.Labels.fromAttributes(System.Collections.Generic.List{Graphs.AttributeGXL})">
            <summary>
            Permet de faire le mapping du fichier GXL vers les Label contenus dans Labels. Dans cette fonction est appelé
            la fonction Label.fromAttributes de chaque Label contenus dans Labels.
            </summary>
            <param name="attributes">Liste d'AttributeGXL contenant les informations sur les valeurs du Labels à distribuer
            pour les différents Label.</param>
        </member>
        <member name="M:Matching.Labels.toAttributes">
            <summary>
            Permet de faire le mapping du Label vers le fichier GXL.Dans cette fonction est appelé
            la fonction Label.toAttributes de chaque Label contenus dans Labels.
            </summary>
            <returns>Liste d'AttributeGXL représentant les Label contenus dans Labels. </returns>
        </member>
        <member name="P:Matching.Labels.ListLabels">
            <summary>
            Contient tous les labels d'un noeud de l'arbre de recherche
            </summary>
        </member>
        <member name="T:Matching.ResultIsomorphism">
            <summary>
            Résultat d'un test d'isomorphisme. Cet objet permet de savoir si le graphe
            est sous graphe de l'autre, si le graphe et isomorphe à l'autre, et de connaître 
            la profondeur maximale des noeuds explorés. 
            </summary>
        </member>
        <member name="M:Matching.ResultIsomorphism.#ctor">
            <summary>
            Constructeur initialisant les attributs.
            </summary>
        </member>
        <member name="M:Matching.ResultIsomorphism.#ctor(System.Boolean,System.Boolean,System.Int32)">
            <summary>
            
            </summary>
            <param name="_subGraphIsomorphism"></param>
            <param name="_graphIsomorphism"></param>
            <param name="_deepest"></param>
        </member>
        <member name="P:Matching.ResultIsomorphism.SubGraphIsomorphism">
            <summary>
            Permet de savoir s'il y a isomorphisme de sous-graphe.
            </summary>
        </member>
        <member name="P:Matching.ResultIsomorphism.GraphIsomorphism">
            <summary>
            Permet de savoir s'il y a isomorphisme de graphe.
            </summary>
        </member>
        <member name="P:Matching.ResultIsomorphism.Deepest">
            <summary>
            Permet de connaître la profondeur maximale des noeuds explorés lors du test d'isomorphisme.
            </summary>
        </member>
        <member name="T:Matching.SearchTree">
            <summary>
            L'arbre de recherche est un graphe qui est toujours orienté.
            </summary>
        </member>
        <member name="M:Matching.SearchTree.#ctor">
            <summary>
            Utilise le constructeur Graph() mais reparamètre IsDirected à true.
            </summary>
        </member>
        <member name="M:Matching.SearchTree.#ctor(System.String,System.String)">
            <summary>
            Utilise le constructeur Graph() mais reparamètre IsDirected à true.
            </summary>
            <param name="id">Identifiant du graphe</param>
            <param name="name">Nom du graphe</param>
        </member>
        <member name="M:Matching.SearchTree.addGraph(Graphs.Graph)">
            <summary>
            On ajoute le graphe à l'arbre de recherche. 
            </summary>
            <param name="graph">Graphe à ajouter à l'arbre de recherche.</param>
        </member>
        <member name="M:Matching.SearchTree.calculateMatrixLabel(Graphs.Graph)">
            <summary>
            Calcule la matrice de Label du graphe. Les Label de noeuds sont présents sur la diagonale. 
            </summary>
            <param name="graph">Graphe pour lequel la matrice de Label sera retournée</param>
            <returns>Matrice de Label du Graphe </returns>
        </member>
        <member name="M:Matching.SearchTree.calculateListLabels(Graphs.Label[0:,0:],System.Int32)">
            <summary>
            Récupère les formes canoniques de la matrice de Label sous forme de Labels et retourne ces Label sous une liste dans l'ordre d'exploration de l'arbre.
            </summary>
            <param name="matrixLabel">Matrice de Label.</param>
            <param name="nbNode">Nombre de noeud du graphe qui est la taille de matrixLabels.</param>
            <returns></returns>
        </member>
        <member name="M:Matching.SearchTree.attributesToLabelTree(Graphs.Label,Graphs.Label)">
            <summary>
            Permet de charger les Node.Label depuis les Node.AttributesGXL. 
            Contrairement à Graph.attributesToLabel ici seuls les labelNode sont nécessaires puisque 
            l'arbre de recherche ne possède pas d'attributs sur les arcs.
            </summary>
            <param name="labelNode">Label qui est utilisé pour les noeuds du graphe. Les Labels de l'arbre de recherche contiendra des Label du type de labelNode.
            La valeur du Label n'est pas importante, seul le type du Label est utilisé.</param>
        </member>
        <member name="T:Matching.Vf">
            <summary>
            Implémente l'algorithme VF de Cordella servant à déterminer l'isomorphisme entre deux graphes.
            </summary>
        </member>
        <member name="M:Matching.Vf.#ctor">
            <summary>
            Constructeur qui initialise toutes les listes 
            </summary>
        </member>
        <member name="M:Matching.Vf.GraphMatching(Graphs.Graph,Graphs.Graph)">
            <summary>
            
            </summary>
            <param name="g1"></param>
            <param name="g2"></param>
            <returns></returns>
        </member>
        <member name="M:Matching.Vf.isIsomorphism(Graphs.Graph,Graphs.Graph)">
            <summary>
            
            </summary>
            <param name="g1"></param>
            <param name="g2"></param>
            <returns></returns>
        </member>
        <member name="M:Matching.Vf.isSubGraphIsomorphism(Graphs.Graph,Graphs.Graph)">
            <summary>
            
            </summary>
            <param name="g1"></param>
            <param name="g2"></param>
            <returns></returns>
        </member>
        <member name="M:Matching.Vf.matching(Graphs.Graph,Graphs.Graph)">
            <summary>
            Détermine si le graphe A est isomorphe au graphe B ou si le graphe A est sous graphe du graphe B
            </summary>
            <param name="graphA">Graphe ou sous graphe</param>
            <param name="graphB">Graphe dans lequel on cherche l'isomorphisme</param>
            <returns>Résultat de l'isomorphisme</returns>
        </member>
        <member name="M:Matching.Vf.Compare(Graphs.Node,Graphs.Node)">
            <summary>
            Fonction de comparaison permettant de trier une liste de noeud en fonction de leur degré
            </summary>
            <returns>Retourne 0 si les degrés sont égaux, 1 si le noeud n1 a un degré plus élevé et -1 sinon</returns>
        </member>
        <member name="M:Matching.Vf.CompareList(System.Collections.Generic.List{Graphs.Edge},System.Collections.Generic.List{Graphs.Edge})">
            <summary>
            Fonction de comparaison de liste
            </summary>
            <param name="ListA"></param>
            <param name="ListB"></param>
            <returns></returns>
        </member>
        <member name="M:Matching.Vf.ajoutToMapping(System.Collections.Generic.List{Graphs.Edge},System.Collections.Generic.List{Graphs.Node},System.Collections.Generic.List{Graphs.Node},System.Collections.Generic.List{Graphs.Node},System.Collections.Generic.List{Graphs.Node})">
            <summary>
            
            </summary>
            <param name="listAjout"></param>
            <param name="inM"></param>
            <param name="toM"></param>
            <param name="frM"></param>
            <param name="dis"></param>
        </member>
        <member name="M:Matching.Vf.ajoutFromMapping(System.Collections.Generic.List{Graphs.Edge},System.Collections.Generic.List{Graphs.Node},System.Collections.Generic.List{Graphs.Node},System.Collections.Generic.List{Graphs.Node},System.Collections.Generic.List{Graphs.Node})">
            <summary>
            
            </summary>
            <param name="listAjout"></param>
            <param name="inM"></param>
            <param name="toM"></param>
            <param name="frM"></param>
            <param name="dis"></param>
        </member>
        <member name="M:Matching.Vf.printLists">
            <summary>
            Fonction de test permettant d'afficher l'état des listes
            </summary>
        </member>
        <member name="P:Matching.Vf.IsoResult">
            <summary>
            
            </summary>
        </member>
    </members>
</doc>
