Calculateur premium du rang d’un graphe sans circuit

Cet outil calcule automatiquement les rangs d’un graphe orienté acyclique, détecte les niveaux hiérarchiques, propose un ordre topologique et visualise la distribution des sommets par rang. Entrez vos sommets et vos arcs, puis lancez le calcul.

Graphe orienté Sans circuit Rangs et niveaux Visualisation Chart.js

Sommets

Séparez les sommets par des virgules.

Mode de calcul

Les deux approches coïncident sur un DAG standard.

Arcs orientés

Format attendu : A->B. Un arc par ligne. Les doublons sont ignorés.</p>
        </div>

<div class="wpc-field">
          <label class="wpc-label" for="wpc-display-order">Affichage des résultats</label>
          <select class="wpc-select" id="wpc-display-order">
            <option value="alpha">Trier les sommets alphabétiquement</option>
            <option value="rank">Trier les sommets par rang</option>
          </select>
        </div>

<div class="wpc-field">
          <label class="wpc-label" for="wpc-rounding">Style d’affichage</label>
          <select class="wpc-select" id="wpc-rounding">
            <option value="compact">Compact</option>
            <option value="detailed">Détaillé</option>
          </select>
        </div>

<div class="wpc-field wpc-field-full">
          <div class="wpc-button-row">
            <button class="wpc-btn wpc-btn-primary" id="wpc-calculate-btn" type="button">Calculer le rang</button>
            <button class="wpc-btn wpc-btn-secondary" id="wpc-sample-btn" type="button">Charger un exemple</button>
            <button class="wpc-btn wpc-btn-secondary" id="wpc-reset-btn" type="button">Réinitialiser</button>
          </div>
        </div>
      </div>
    </div>
  </div>

<div id="wpc-results" class="wpc-results" aria-live="polite">
    <h3>Résultats</h3>
    <p>Entrez un graphe acyclique puis cliquez sur <strong>Calculer le rang</strong>.</p>
    <div class="wpc-chart-container"><canvas id="wpc-chart"></canvas></div>
  </div>

<article class="wpc-content">
    <h2>Comprendre l’algorithme de calcul du rang d’un graphe sans circuit</h2>
    <p>
      L’expression <strong>algorithme calcul rang d’un graphe sans circuit</strong> renvoie à une famille de méthodes
      utilisées pour classer les sommets d’un graphe orienté acyclique, souvent abrégé en DAG, selon des niveaux
      hiérarchiques. En pratique, un sommet de rang 0 ne dépend d’aucun autre sommet. Un sommet de rang 1 dépend
      uniquement de sommets de rang 0, un sommet de rang 2 dépend de sommets de rang 0 et 1, et ainsi de suite.
      Cette logique est centrale en ordonnancement, en planification de projet, en compilation, en analyse de dépendances
      logicielles et en modélisation de workflows administratifs.
    </p>
    <p>
      Un graphe sans circuit est un graphe orienté dans lequel il est impossible de partir d’un sommet et d’y revenir
      en suivant le sens des arcs. Cette absence de cycle est une condition essentielle, car le calcul du rang suppose
      l’existence d’une hiérarchie partielle. Si un cycle existe, aucun des sommets du cycle ne peut être placé
      proprement avant les autres, ce qui bloque la construction des niveaux. C’est pour cette raison que la première
      vérification importante d’un calculateur sérieux consiste à détecter les circuits ou, plus précisément, à
      constater qu’aucun ordre topologique complet n’est possible.
    </p>

<h2>Définition mathématique du rang dans un DAG</h2>
    <p>
      Il existe plusieurs formulations proches. La plus pédagogique consiste à définir le rang d’un sommet comme le
      numéro de l’étape à laquelle il apparaît lorsqu’on retire successivement les sources du graphe. Une source est un
      sommet dont le degré entrant est nul, c’est-à-dire un sommet qui ne reçoit aucun arc. On enlève toutes les
      sources au rang 0, puis les nouvelles sources au rang 1, puis celles du rang 2, et ainsi de suite jusqu’à vider
      le graphe.
    </p>
    <p>
      Une autre formulation, équivalente dans un DAG, définit le rang d’un sommet comme la longueur maximale d’un
      chemin orienté menant d’une source vers ce sommet. Dans ce cadre, toute source a le rang 0. Si un sommet a pour
      prédécesseurs des sommets de rangs 0, 1 et 3, alors son rang vaut 4 si l’on compte les arêtes. Cette version
      est particulièrement utile pour l’analyse des dépendances et pour l’estimation de profondeur dans des pipelines
      de calcul ou d’exécution.
    </p>

<h3>Pourquoi le rang est utile</h3>
    <ul>
      <li>Il structure les dépendances dans un ordre intelligible.</li>
      <li>Il aide à identifier les étapes parallélisables d’un processus.</li>
      <li>Il simplifie la visualisation d’un graphe complexe.</li>
      <li>Il constitue une base pour des algorithmes d’ordonnancement plus avancés.</li>
      <li>Il permet de mesurer la profondeur d’une chaîne de dépendances.</li>
    </ul>

<h2>Principe de l’algorithme</h2>
    <p>
      L’algorithme le plus classique est intimement lié au tri topologique de Kahn. On commence par calculer le degré
      entrant de chaque sommet. Tous les sommets dont le degré entrant est nul forment le rang 0. On les retire
      conceptuellement du graphe, ce qui diminue le degré entrant de leurs successeurs. Dès qu’un successeur voit son
      degré entrant devenir nul, il devient éligible pour le rang suivant. On répète ce processus jusqu’à avoir traité
      tous les sommets.
    </p>
    <ol>
      <li>Créer la liste des sommets et la liste des arcs orientés.</li>
      <li>Calculer le degré entrant de chaque sommet.</li>
      <li>Placer toutes les sources dans une file de traitement.</li>
      <li>Attribuer le rang 0 aux sources initiales.</li>
      <li>Retirer les sources, mettre à jour les degrés entrants des successeurs.</li>
      <li>Quand un sommet devient source, lui attribuer le rang approprié.</li>
      <li>Continuer jusqu’à épuisement de la file.</li>
      <li>Si des sommets restent non traités, le graphe contient un circuit.</li>
    </ol>

<p>
      Dans une implémentation robuste, le calcul du rang est souvent effectué simultanément avec la production d’un
      ordre topologique. L’ordre topologique fournit une séquence compatible avec toutes les dépendances, tandis que
      le rang fournit une organisation par couches. Les deux informations sont complémentaires. Pour un responsable de
      projet, l’ordre topologique indique une séquence valide. Pour un architecte système, le rang révèle les étapes
      pouvant potentiellement être exécutées en parallèle à l’intérieur d’un même niveau.
    </p>

<h2>Complexité et performances</h2>
    <p>
      Sur le plan algorithmique, le calcul des rangs dans un DAG est très efficace. Avec une représentation en listes
      d’adjacence, le temps d’exécution est en général en <strong>O(V + E)</strong>, où <strong>V</strong> est le
      nombre de sommets et <strong>E</strong> le nombre d’arcs. Cela signifie que chaque sommet et chaque arc est
      traité un nombre constant de fois. Cette propriété rend l’approche adaptée à des graphes volumineux, notamment
      dans l’analyse de dépendances logicielles ou de tâches de workflow.
    </p>

<div class="wpc-table-wrap">
      <table class="wpc-table">
        <thead>
          <tr>
            <th>Méthode</th>
            <th>Principe</th>
            <th>Complexité temporelle</th>
            <th>Usage recommandé</th>
          </tr>
        </thead>
        <tbody>
          <tr>
            <td>Suppression successive des sources</td>
            <td>Retire les sommets de degré entrant nul niveau par niveau</td>
            <td>O(V + E)</td>
            <td>Calcul de rang, couches hiérarchiques, visualisation</td>
          </tr>
          <tr>
            <td>Tri topologique de Kahn</td>
            <td>Construit un ordre topologique via les degrés entrants</td>
            <td>O(V + E)</td>
            <td>Validation de dépendances et ordonnancement</td>
          </tr>
          <tr>
            <td>DFS avec marquage</td>
            <td>Parcours en profondeur et détection de retour arrière</td>
            <td>O(V + E)</td>
            <td>Détection de cycles et production d’un ordre topologique</td>
          </tr>
          <tr>
            <td>Matrice d’adjacence</td>
            <td>Accès direct aux arcs mais coût mémoire élevé</td>
            <td>Souvent O(V²)</td>
            <td>Petits graphes denses seulement</td>
          </tr>
        </tbody>
      </table>
    </div>

<p>
      Les notations de complexité ci-dessus sont des statistiques théoriques standard largement enseignées dans les
      cursus universitaires en algorithmique. Elles restent valides dans la quasi-totalité des implémentations
      classiques. Dans un contexte réel, la performance dépend aussi de la qualité du parsing des données, du format de
      stockage, de la densité du graphe et de la façon dont les sommets sont indexés.
    </p>

<h2>Exemple concret de calcul du rang</h2>
    <p>
      Prenons un graphe orienté sans circuit représentant des dépendances de tâches. Les tâches A et B n’ont aucun
      prérequis. C dépend de A, D dépend de A et B, E dépend de C et D, F dépend de D, et G dépend de E et F. Dans ce
      cas, A et B sont au rang 0. Ensuite, C et D passent au rang 1. Puis E et F sont au rang 2. Enfin, G atteint le
      rang 3. Cette distribution est typique d’un problème d’ordonnancement de projet où plusieurs tâches intermédiaires
      peuvent être conduites en parallèle après validation des prérequis.
    </p>
    <p>
      Le calculateur affiché plus haut reproduit précisément cette logique. Il lit la liste des sommets, déduplique les
      arcs, vérifie l’existence éventuelle d’un cycle, produit les rangs individuels, génère un ordre topologique
      compatible et trace un graphique du nombre de sommets par rang. Cette visualisation apporte une lecture immédiate
      de la largeur de chaque niveau, ce qui peut orienter des décisions de charge, de staffing ou de distribution de
      calcul.
    </p>

<h3>Cas d’usage fréquents</h3>
    <ul>
      <li>Planification de tâches industrielles et administratives.</li>
      <li>Analyse de prérequis dans un cursus universitaire.</li>
      <li>Ordonnancement de jobs dans des pipelines de données.</li>
      <li>Compilation et construction de logiciels à dépendances multiples.</li>
      <li>Gestion de workflows scientifiques et biomédicaux.</li>
    </ul>

<h2>Différence entre rang, niveau et ordre topologique</h2>
    <p>
      Ces notions sont voisines mais non identiques. Le <strong>rang</strong> est un niveau numérique. Le
      <strong>niveau</strong> est souvent utilisé comme synonyme visuel du rang, surtout dans les schémas. L’
      <strong>ordre topologique</strong>, lui, est une séquence linéaire de sommets telle que tout arc va d’un sommet
      plus tôt dans la séquence vers un sommet plus tard. Un même graphe peut avoir plusieurs ordres topologiques
      valides, alors que la structure de rangs est généralement plus stable. En clair, le rang répond à la question
      “à quel étage se situe ce sommet ?”, tandis que l’ordre topologique répond à “dans quel ordre valide peut-on
      exécuter les tâches ?”
    </p>

<div class="wpc-table-wrap">
      <table class="wpc-table">
        <thead>
          <tr>
            <th>Concept</th>
            <th>Description</th>
            <th>Exemple de sortie</th>
            <th>Intérêt opérationnel</th>
          </tr>
        </thead>
        <tbody>
          <tr>
            <td>Rang</td>
            <td>Indice de niveau d’un sommet dans un DAG</td>
            <td>A:0, B:0, C:1, D:1, E:2</td>
            <td>Lecture hiérarchique et parallélisation</td>
          </tr>
          <tr>
            <td>Ordre topologique</td>
            <td>Séquence linéaire respectant toutes les dépendances</td>
            <td>A, B, C, D, E</td>
            <td>Exécution séquentielle valide</td>
          </tr>
          <tr>
            <td>Longueur du chemin critique</td>
            <td>Plus grande profondeur dans le graphe</td>
            <td>3 arêtes</td>
            <td>Estimation de durée minimale globale</td>
          </tr>
          <tr>
            <td>Largeur par rang</td>
            <td>Nombre de sommets présents à chaque niveau</td>
            <td>2, 2, 1</td>
            <td>Capacité parallèle et charge par couche</td>
          </tr>
        </tbody>
      </table>
    </div>

<h2>Erreurs fréquentes lors du calcul du rang</h2>
    <p>
      La première erreur consiste à oublier l’orientation des arcs. Dans un graphe orienté, A vers B signifie que B
      dépend de A, et non l’inverse. Inverser le sens de lecture produit des rangs incohérents. La deuxième erreur
      est de croire qu’un graphe non orienté peut être traité de la même façon. Le calcul de rang utilisé ici repose
      justement sur la notion de prédécesseur et de successeur. La troisième erreur est de négliger les cycles. Dès
      qu’un circuit apparaît, il faut le signaler explicitement au lieu de forcer un résultat.
    </p>
    <p>
      Une autre confusion courante concerne les sommets isolés. Un sommet sans arc entrant ni sortant est généralement
      de rang 0. Il existe indépendamment du reste du graphe. Dans les applications réelles, cela peut correspondre à
      une tâche libre, à une ressource indépendante ou à un composant non utilisé. Enfin, certains utilisateurs
      dupliquent involontairement les arcs ou mentionnent des sommets dans les arcs sans les déclarer dans la liste
      principale. Un bon calculateur doit soit les créer automatiquement, soit prévenir clairement l’utilisateur.
    </p>

<h2>Applications réelles et données de référence</h2>
    <p>
      Les DAG sont omniprésents dans les systèmes modernes. Ils apparaissent dans l’optimisation de compilateurs, les
      workflows de calcul scientifique, les graphes de dépendance de paquets logiciels, les réseaux de tâches et les
      cursus à prérequis. Dans la recherche académique et dans l’ingénierie, on rencontre très souvent des graphes
      traités en temps linéaire en nombre de sommets et d’arcs, car cette approche est à la fois explicable, stable et
      scalable.
    </p>
    <p>
      Les références ci-dessous sont utiles pour consolider les notions théoriques et la terminologie officielle :
    </p>
    <ul>
      <li><a href="https://xlinux.nist.gov/dads/HTML/topologicalSort.html" target="_blank" rel="noopener noreferrer">NIST Dictionary of Algorithms and Data Structures – Topological Sort</a></li>
      <li><a href="https://algs4.cs.princeton.edu/42digraph/" target="_blank" rel="noopener noreferrer">Princeton University – Directed Graphs and Topological Ordering</a></li>
      <li><a href="https://web.stanford.edu/class/archive/cs/cs161/cs161.1138/lectures/13/Small13.pdf" target="_blank" rel="noopener noreferrer">Stanford University – Graph Algorithms Lecture Notes</a></li>
    </ul>

<h3>Pourquoi ces sources sont fiables</h3>
    <p>
      Le NIST, organisme fédéral américain, maintient un dictionnaire de référence largement utilisé pour standardiser
      les définitions en algorithmique. Princeton et Stanford publient des supports pédagogiques de haut niveau qui
      font autorité dans l’enseignement des structures de données et des algorithmes. Même si leurs exemples varient,
      la base théorique du tri topologique et du calcul de rang reste convergente : dans un DAG, l’ordre de traitement
      peut être construit sans ambiguïté sur les dépendances, et les niveaux se calculent en temps linéaire.
    </p>

<h2>Bonnes pratiques pour modéliser un graphe sans circuit</h2>
    <ol>
      <li>Définir clairement ce que représente chaque sommet : tâche, événement, module, cours, fichier, etc.</li>
      <li>Choisir une convention de sens pour les arcs, puis la conserver partout.</li>
      <li>Éviter les cycles conceptuels en clarifiant les dépendances réelles.</li>
      <li>Nommer les sommets de manière stable et non ambiguë.</li>
      <li>Vérifier régulièrement la cohérence du graphe quand il évolue.</li>
      <li>Comparer la profondeur maximale et la largeur des niveaux pour optimiser l’exécution.</li>
    </ol>

<h2>Conclusion</h2>
    <p>
      L’algorithme de calcul du rang d’un graphe sans circuit est un outil fondamental pour transformer une structure de
      dépendances en information exploitable. Il permet à la fois de vérifier la validité d’un modèle acyclique, de
      produire des niveaux hiérarchiques, de déduire un ordre topologique et de visualiser la complexité structurelle
      d’un processus. Que vous travailliez sur des tâches de projet, des flux de données, un système de compilation ou
      une architecture logique, savoir calculer les rangs d’un DAG vous donne une vision claire de la profondeur, des
      parallélismes possibles et des points d’enchaînement critiques.
    </p>
    <p class="wpc-note">
      Conseil expert : si votre graphe grandit rapidement, surveillez le nombre de sommets par rang. Une forte largeur
      à un niveau peut indiquer une excellente opportunité de parallélisation, tandis qu’une grande profondeur signale
      une chaîne de dépendances potentiellement limitante.
    </p>
  </article>
</section>

var wpcNodesInput = document.getElementById('wpc-nodes');
  var wpcEdgesInput = document.getElementById('wpc-edges');
  var wpcModeInput = document.getElementById('wpc-mode');
  var wpcDisplayOrderInput = document.getElementById('wpc-display-order');
  var wpcRoundingInput = document.getElementById('wpc-rounding');
  var wpcResults = document.getElementById('wpc-results');
  var wpcCalculateBtn = document.getElementById('wpc-calculate-btn');
  var wpcSampleBtn = document.getElementById('wpc-sample-btn');
  var wpcResetBtn = document.getElementById('wpc-reset-btn');
  var wpcChartCanvas = document.getElementById('wpc-chart');

function wpcEscapeHtml(value) {
    return String(value)
      .replace(/&/g, '&')
      .replace(/</g, '<')
      .replace(/>/g, '>')
      .replace(/"/g, '"')
      .replace(/'/g, ''');
  }

function wpcParseNodes(raw) {
    return raw
      .split(',')
      .map(function (item) { return item.trim(); })
      .filter(function (item) { return item.length > 0; });
  }

function wpcBuildGraph(nodes, edges) {
    var adjacency = {};
    var indegree = {};
    nodes.forEach(function (node) {
      adjacency[node] = [];
      indegree[node] = 0;
    });

edges.forEach(function (edge) {
      adjacency[edge.from].push(edge.to);
      indegree[edge.to] += 1;
    });

return { adjacency: adjacency, indegree: indegree };
  }

function wpcComputeRanks(nodes, edges) {
    var graph = wpcBuildGraph(nodes, edges);
    var adjacency = graph.adjacency;
    var indegree = {};
    var tempIndegree = graph.indegree;
    var order = [];
    var rankMap = {};
    var currentLayer = [];

nodes.forEach(function (node) {
      indegree[node] = tempIndegree[node];
      if (indegree[node] === 0) {
        currentLayer.push(node);
      }
    });

var processed = 0;
    var currentRank = 0;
    var layers = [];

while (currentLayer.length > 0) {
      currentLayer.sort();
      layers.push(currentLayer.slice());
      currentLayer.forEach(function (node) {
        rankMap[node] = currentRank;
        order.push(node);
        processed += 1;
      });

var dedup = {};
      currentLayer = nextCandidates.filter(function (node) {
        if (dedup[node]) {
          return false;
        }
        dedup[node] = true;
        return true;
      });

currentRank += 1;
    }

if (processed !== nodes.length) {
      throw new Error("Le graphe contient au moins un circuit. Le calcul du rang n'est pas défini pour ce cas.");
    }

var longestRank = {};
    nodes.forEach(function (node) {
      longestRank[node] = 0;
    });

order.forEach(function (node) {
      adjacency[node].forEach(function (neighbor) {
        if (longestRank[neighbor] < longestRank[node] + 1) {
          longestRank[neighbor] = longestRank[node] + 1;
        }
      });
    });

return {
      order: order,
      sourceRankMap: rankMap,
      longestRankMap: longestRank,
      layers: layers,
      maxRank: layers.length ? layers.length - 1 : 0
    };
  }

function wpcRenderChart(rankCounts) {
    if (wpcChartInstance) {
      wpcChartInstance.destroy();
    }

var labels = Object.keys(rankCounts).sort(function (a, b) {
      return Number(a) - Number(b);
    }).map(function (key) {
      return "Rang " + key;
    });

var data = Object.keys(rankCounts).sort(function (a, b) {
      return Number(a) - Number(b);
    }).map(function (key) {
      return rankCounts[key];
    });

wpcChartInstance = new Chart(wpcChartCanvas, {
      type: 'bar',
      data: {
        labels: labels,
        datasets: [
          {
            label: 'Nombre de sommets',
            data: data,
            backgroundColor: ['#2563eb', '#3b82f6', '#60a5fa', '#93c5fd', '#1d4ed8', '#1e3a8a', '#0ea5e9', '#0284c7'],
            borderColor: '#1d4ed8',
            borderWidth: 1,
            borderRadius: 8
          }
        ]
      },
      options: { responsive: true, maintainAspectRatio: false }
    });
  }

function wpcFormatResults(data, mode, displayOrder, detailMode) {
    var rankMap = mode === 'longest' ? data.longestRankMap : data.sourceRankMap;
    var nodes = Object.keys(rankMap);

if (displayOrder === 'alpha') {
      nodes.sort();
    } else {
      nodes.sort(function (a, b) {
        if (rankMap[a] === rankMap[b]) {
          return a.localeCompare(b);
        }
        return rankMap[a] - rankMap[b];
      });
    }

var rankCounts = {};
    nodes.forEach(function (node) {
      var rank = rankMap[node];
      rankCounts[rank] = (rankCounts[rank] || 0) + 1;
    });

var pairsHtml = nodes.map(function (node) {
      return "<li><strong>" + wpcEscapeHtml(node) + "</strong> : rang " + wpcEscapeHtml(rankMap[node]) + "</li>";
    }).join('');

var layersHtml = data.layers.map(function (layer, index) {
      return "<li><strong>Rang " + index + "</strong> : " + layer.map(wpcEscapeHtml).join(', ') + "</li>";
    }).join('');

var topologicalOrder = data.order.map(wpcEscapeHtml).join(' → ');
    var widthMax = 0;
    Object.keys(rankCounts).forEach(function (key) {
      if (rankCounts[key] > widthMax) {
        widthMax = rankCounts[key];
      }
    });

var detailsBlock = '';
    if (detailMode === 'detailed') {
      detailsBlock =
        "<h4>Détail par rang</h4>" +
        "<ul class='wpc-list'>" + layersHtml + "</ul>" +
        "<div class='wpc-code-box'>Ordre topologique valide : " + topologicalOrder + "</div>";
    }

var html =
      "<h3>Résultats du calcul</h3>" +
      "<div class='wpc-result-grid'>" +
        "<div class='wpc-stat'><span class='wpc-stat-label'>Nombre de sommets</span><span class='wpc-stat-value'>" + nodes.length + "</span></div>" +
        "<div class='wpc-stat'><span class='wpc-stat-label'>Nombre de niveaux</span><span class='wpc-stat-value'>" + (data.maxRank + 1) + "</span></div>" +
        "<div class='wpc-stat'><span class='wpc-stat-label'>Largeur maximale</span><span class='wpc-stat-value'>" + widthMax + "</span></div>" +
      "</div>" +
      "<p><strong>Méthode utilisée :</strong> " + (mode === 'longest' ? "longueur maximale depuis une source" : "suppression successive des sources") + "</p>" +
      "<ul class='wpc-list'>" + pairsHtml + "</ul>" +
      detailsBlock +
      "<div class='wpc-chart-container'><canvas id='wpc-chart'></canvas></div>";

wpcResults.className = 'wpc-results wpc-success';
    wpcResults.innerHTML = html;

wpcChartCanvas = document.getElementById('wpc-chart');
    wpcRenderChart(rankCounts);
  }

function wpcShowError(message) {
    wpcResults.className = 'wpc-results wpc-error';
    wpcResults.innerHTML =
      "<h3>Erreur de calcul</h3>" +
      "<p>" + wpcEscapeHtml(message) + "</p>" +
      "<div class='wpc-chart-container'><canvas id='wpc-chart'></canvas></div>";
    wpcChartCanvas = document.getElementById('wpc-chart');
    if (wpcChartInstance) {
      wpcChartInstance.destroy();
      wpcChartInstance = null;
    }
  }

function wpcCalculate() {
    try {
      var rawNodes = wpcNodesInput.value.trim();
      var nodeArray = wpcParseNodes(rawNodes);
      var nodeSet = new Set(nodeArray);

if (nodeSet.size === 0) {
        throw new Error("Veuillez renseigner au moins un sommet.");
      }

var edges = wpcParseEdges(wpcEdgesInput.value.trim(), nodeSet);
      var nodes = Array.from(nodeSet);

var result = wpcComputeRanks(nodes, edges);
      wpcFormatResults(result, wpcModeInput.value, wpcDisplayOrderInput.value, wpcRoundingInput.value);
    } catch (error) {
      wpcShowError(error.message || "Une erreur inattendue s'est produite.");
    }
  }

function wpcLoadSample() {
    wpcNodesInput.value = "A,B,C,D,E,F,G,H";
    wpcEdgesInput.value = [
      "A->C",
      "A->D",
      "B->D",
      "B->E",
      "C->F",
      "D->F",
      "D->G",
      "E->G",
      "F->H",
      "G->H"
    ].join("\n");
    wpcModeInput.value = "source";
    wpcDisplayOrderInput.value = "rank";
    wpcRoundingInput.value = "detailed";
    wpcCalculate();
  }

function wpcReset() {
    wpcNodesInput.value = "";
    wpcEdgesInput.value = "";
    wpcModeInput.value = "source";
    wpcDisplayOrderInput.value = "alpha";
    wpcRoundingInput.value = "compact";
    if (wpcChartInstance) {
      wpcChartInstance.destroy();
      wpcChartInstance = null;
    }
    wpcResults.className = 'wpc-results';
    wpcResults.innerHTML =
      "<h3>Résultats</h3>" +
      "<p>Entrez un graphe acyclique puis cliquez sur <strong>Calculer le rang</strong>.</p>" +
      "<div class='wpc-chart-container'><canvas id='wpc-chart'></canvas></div>";
    wpcChartCanvas = document.getElementById('wpc-chart');
  }

wpcCalculateBtn.addEventListener('click', wpcCalculate);
  wpcSampleBtn.addEventListener('click', wpcLoadSample);
  wpcResetBtn.addEventListener('click', wpcReset);

wpcCalculate();
})();
</script>

</div>
</div>

</article>

<nav class="navigation post-navigation" aria-label="Posts">
				<div class="nav-links"><div class="nav-previous"><a title="Algorithme Calcul Puissance" href="https://cal18.calculator.city/algorithme-calcul-puissance/" rel="prev"><span class="ast-post-nav" aria-hidden="true"><span aria-hidden="true" class="ahfb-svg-iconset ast-inline-flex svg-baseline"><svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 448 512'><path d='M134.059 296H436c6.627 0 12-5.373 12-12v-56c0-6.627-5.373-12-12-12H134.059v-46.059c0-21.382-25.851-32.09-40.971-16.971L7.029 239.029c-9.373 9.373-9.373 24.569 0 33.941l86.059 86.059c15.119 15.119 40.971 4.411 40.971-16.971V296z'></path></svg></span> Previous</span> <p> Algorithme Calcul Puissance </p></a></div><div class="nav-next"><a title="Algorithme Calcul Rang D Un Graphe Sans Circuit" href="https://cal18.calculator.city/algorithme-calcul-rang-d-un-graphe-sans-circuit/" rel="next"><span class="ast-post-nav" aria-hidden="true">Next <span aria-hidden="true" class="ahfb-svg-iconset ast-inline-flex svg-baseline"><svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 448 512'><path d='M313.941 216H12c-6.627 0-12 5.373-12 12v56c0 6.627 5.373 12 12 12h301.941v46.059c0 21.382 25.851 32.09 40.971 16.971l86.059-86.059c9.373-9.373 9.373-24.569 0-33.941l-86.059-86.059c-15.119-15.119-40.971-4.411-40.971 16.971V216z'></path></svg></span></span> <p> Algorithme Calcul Rang D Un Graphe Sans Circuit </p></a></div></div>
		</nav>		<div id="comments" class="comments-area comment-form-position-below ">
	
	
	
	
		<div id="respond" class="comment-respond">
		<h3 id="reply-title" class="comment-reply-title">Leave a Comment <small><a rel="nofollow" id="cancel-comment-reply-link" href="/algorithme-calcul-rand-d-un-graphe-sans-circuit/#respond" style="display:none;">Cancel Reply</a></small></h3><form action="https://cal18.calculator.city/wp-comments-post.php" method="post" id="ast-commentform" class="comment-form"><p class="comment-notes"><span id="email-notes">Your email address will not be published.</span> <span class="required-field-message">Required fields are marked <span class="required">*</span></span></p><div class="ast-row comment-textarea"><fieldset class="comment-form-comment"><legend class ="comment-form-legend"></legend><div class="comment-form-textarea ast-grid-common-col"><label for="comment" class="screen-reader-text">Type here..</label><textarea id="comment" name="comment" placeholder="Type here.." cols="45" rows="8" aria-required="true">

Name*

Email*

Website