Merge pull request #21 from curran/modernize-js

Refresh the Code Phase I: Lebab

src/adjacent_exchange.js

@@ -11,12 +11,12 @@ import { inverse_permutation } from './permutation';
 // typically provides an additional 20-50% reduction in edge crossings.
 
 function count_in_crossings(graph, v, w, inv) {
-  var v_edges = graph.inEdges(v),
-    w_edges = graph.inEdges(w),
-    iv,
-    iw,
-    p0,
-    cross = 0;
+  const v_edges = graph.inEdges(v);
+  const w_edges = graph.inEdges(w);
+  let iv;
+  let iw;
+  let p0;
+  let cross = 0;
 
   for (iw = 0; iw < w_edges.length; iw++) {
     p0 = inv[w_edges[iw].target.index];
@@ -28,12 +28,12 @@ function count_in_crossings(graph, v, w, inv) {
 }
 
 function count_out_crossings(graph, v, w, inv) {
-  var v_edges = graph.outEdges(v),
-    w_edges = graph.outEdges(w),
-    iv,
-    iw,
-    p0,
-    cross = 0;
+  const v_edges = graph.outEdges(v);
+  const w_edges = graph.outEdges(w);
+  let iv;
+  let iw;
+  let p0;
+  let cross = 0;
 
   for (iw = 0; iw < w_edges.length; iw++) {
     p0 = inv[w_edges[iw].source.index];
@@ -55,15 +55,15 @@ function count_out_crossings(graph, v, w, inv) {
 export function adjacent_exchange(graph, layer1, layer2) {
   layer1 = layer1.slice();
   layer2 = layer2.slice();
-  var i,
-    v,
-    w,
-    c0,
-    c1,
-    inv_layer1 = inverse_permutation(layer1),
-    inv_layer2 = inverse_permutation(layer2),
-    swapped = true,
-    improved = 0;
+  let i;
+  let v;
+  let w;
+  let c0;
+  let c1;
+  const inv_layer1 = inverse_permutation(layer1);
+  const inv_layer2 = inverse_permutation(layer2);
+  let swapped = true;
+  let improved = 0;
 
   while (swapped) {
     swapped = false;

src/all_pairs_distance.js

@@ -11,10 +11,10 @@ import { inverse_permutation } from './permutation';
  * nodes in the list of connected components.
  */
 export function all_pairs_distance(graph, comps) {
-  var distances = [];
+  const distances = [];
   if (!comps) comps = graph.components();
 
-  for (var i = 0; i < comps.length; i++)
+  for (let i = 0; i < comps.length; i++)
     distances.push(all_pairs_distance_floyd_warshall(graph, comps[i]));
   return distances;
 }
@@ -28,11 +28,11 @@ export function all_pairs_distance(graph, comps) {
  * nodes in the list of connected components.
  */
 export function all_pairs_distance_floyd_warshall(graph, comp) {
-  var dist = infinities(comp.length, comp.length),
-    i,
-    j,
-    k,
-    inv;
+  const dist = infinities(comp.length, comp.length);
+  let i;
+  let j;
+  let k;
+  let inv;
   // Floyd Warshall,
   // see http://ai-depot.com/BotNavigation/Path-AllPairs.html
   // O(n^3) unfortunately
@@ -41,10 +41,10 @@ export function all_pairs_distance_floyd_warshall(graph, comp) {
 
   for (i = 0; i < comp.length; i++) dist[i][i] = 0;
 
-  var build_dist = function (e) {
+  const build_dist = (e) => {
     if (e.source == e.target) return;
     if (!(e.source.index in inv) || !(e.target.index in inv)) return; // ignore edges outside of comp
-    var u = inv[e.source.index],
+    const u = inv[e.source.index],
       v = inv[e.target.index];
     dist[v][u] = dist[u][v] = graph.distance(e.index);
   };
@@ -80,13 +80,13 @@ export function all_pairs_distance_floyd_warshall(graph, comp) {
 export function floyd_warshall_with_path(graph, comp) {
   if (!comp) comp = graph.components()[0];
 
-  var dist = infinities(comp.length, comp.length),
-    next = Array(comp.length),
-    directed = graph.directed(),
-    i,
-    j,
-    k,
-    inv;
+  const dist = infinities(comp.length, comp.length);
+  const next = Array(comp.length);
+  const directed = graph.directed();
+  let i;
+  let j;
+  let k;
+  let inv;
   // Floyd Warshall,
   // see http://ai-depot.com/BotNavigation/Path-AllPairs.html
   // O(n^3) unfortunately
@@ -98,9 +98,9 @@ export function floyd_warshall_with_path(graph, comp) {
     next[i] = Array(comp.length);
   }
 
-  var build_dist = function (e) {
+  const build_dist = (e) => {
     if (e.source == e.target) return;
-    var u = inv[e.source.index],
+    const u = inv[e.source.index],
       v = inv[e.target.index];
     dist[u][v] = graph.distance(e);
     next[u][v] = v;
@@ -141,7 +141,7 @@ export function floyd_warshall_with_path(graph, comp) {
  */
 export function floyd_warshall_path(next, u, v) {
   if (next[u][v] === undefined) return [];
-  var path = [u];
+  const path = [u];
   while (u != v) {
     u = next[u][v];
     path.push(u);

src/bandwidth.js

@@ -4,12 +4,12 @@ import { inverse_permutation } from './permutation';
 export function bandwidth(graph, order) {
   if (!order) order = range(graph.nodes().length);
 
-  var inv = inverse_permutation(order),
-    links = graph.links(),
-    i,
-    e,
-    d,
-    max = 0;
+  const inv = inverse_permutation(order);
+  const links = graph.links();
+  let i;
+  let e;
+  let d;
+  let max = 0;
 
   for (i = 0; i < links.length; i++) {
     e = links[i];

src/barycenter_order.js

@@ -4,13 +4,13 @@ import { debug } from './core';
 import { count_crossings } from './count_crossings';
 
 export function barycenter_order(graph, comps, max_iter) {
-  var orders = [[], [], 0];
+  let orders = [[], [], 0];
   // Compute the barycenter heuristic on each connected component
   if (!comps) {
     comps = graph.components();
   }
-  for (var i = 0; i < comps.length; i++) {
-    var o = barycenter(graph, comps[i], max_iter);
+  for (let i = 0; i < comps.length; i++) {
+    const o = barycenter(graph, comps[i], max_iter);
     orders = [orders[0].concat(o[0]), orders[1].concat(o[1]), orders[2] + o[2]];
   }
   return orders;
@@ -25,7 +25,7 @@ function median(neighbors) {
   if (neighbors.length === 2) return (neighbors[0] + neighbors[1]) / 2;
   neighbors.sort(cmp_number);
   if (neighbors.length % 2) return neighbors[(neighbors.length - 1) / 2];
-  var rm = neighbors.length / 2,
+  const rm = neighbors.length / 2,
     lm = rm - 1,
     rspan = neighbors[neighbors.length - 1] - neighbors[rm],
     lspan = neighbors[lm] - neighbors[0];
@@ -34,26 +34,26 @@ function median(neighbors) {
 }
 
 export function barycenter(graph, comp, max_iter) {
-  var nodes = graph.nodes(),
-    layer1,
-    layer2,
-    crossings,
-    iter,
-    best_layer1,
-    best_layer2,
-    best_crossings,
-    best_iter,
-    layer,
-    inv_layer = {},
-    i,
-    v,
-    neighbors,
-    med;
+  const nodes = graph.nodes();
+  let layer1;
+  let layer2;
+  let crossings;
+  let iter;
+  let best_layer1;
+  let best_layer2;
+  let best_crossings;
+  let best_iter;
+  let layer;
+  let inv_layer = {};
+  let i;
+  let v;
+  let neighbors;
+  let med;
 
-  layer1 = comp.filter(function (n) {
+  layer1 = comp.filter((n) => {
     return graph.outDegree(n) !== 0;
   });
-  layer2 = comp.filter(function (n) {
+  layer2 = comp.filter((n) => {
     return graph.inDegree(n) !== 0;
   });
   if (comp.length < 3) {
@@ -69,12 +69,12 @@ export function barycenter(graph, comp, max_iter) {
   best_layer1 = layer1.slice();
   best_layer2 = layer2.slice();
   best_iter = 0;
-  var inv_neighbor = function (e) {
-      var n = e.source == v ? e.target : e.source;
+  const inv_neighbor = (e) => {
+      const n = e.source == v ? e.target : e.source;
       return inv_layer[n.index];
     },
-    barycenter_sort = function (a, b) {
-      var d = med[a] - med[b];
+    barycenter_sort = (a, b) => {
+      let d = med[a] - med[b];
       if (d === 0) {
         // If both values are equal,
         // place the odd degree vertex on the left of the even
@@ -114,7 +114,7 @@ export function barycenter(graph, comp, max_iter) {
     }
   }
   if (debug) {
-    console.log('Best iter: ' + best_iter);
+    console.log(`Best iter: ${best_iter}`);
   }
 
   return [best_layer1, best_layer2, best_crossings];

src/bfs.js

@@ -1,12 +1,12 @@
 import { flatten, cmp_number } from './utils';
 
 export function bfs(graph, v, fn) {
-  var q = new Queue(),
-    discovered = {},
-    i,
-    e,
-    v2,
-    edges;
+  const q = new Queue();
+  const discovered = {};
+  let i;
+  let e;
+  let v2;
+  let edges;
   q.push(v);
   discovered[v] = true;
   fn(v, undefined);
@@ -28,21 +28,21 @@ export function bfs(graph, v, fn) {
 }
 
 export function bfs_distances(graph, v) {
-  var dist = {};
+  const dist = {};
   dist[v] = 0;
-  bfs(graph, v, function (v, c) {
+  bfs(graph, v, (v, c) => {
     if (c >= 0 && v != c) dist[c] = dist[v] + 1;
   });
   return dist;
 }
 
 export function all_pairs_distance_bfs(graph, comps) {
   if (!comps) comps = [graph.nodes_indices()];
-  var nodes = comps.reduce(flatten).sort(cmp_number),
-    mat = Array(nodes.length),
-    i,
-    j,
-    dist;
+  const nodes = comps.reduce(flatten).sort(cmp_number);
+  const mat = Array(nodes.length);
+  let i;
+  let j;
+  let dist;
 
   for (i = 0; i < nodes.length; i++) mat[i] = Array(nodes.length);
 

src/bfs_order.js

@@ -1,16 +1,16 @@
 import { bfs } from './bfs';
 
 /*jshint loopfunc:true */
-export const bfs_order = function (graph, comps) {
+export const bfs_order = (graph, comps) => {
   if (!comps) comps = graph.components();
 
-  var i,
-    comp,
-    order = [];
+  let i;
+  let comp;
+  const order = [];
 
   for (i = 0; i < comps.length; i++) {
     comp = comps[i];
-    bfs(graph, comp[0], function (v, c) {
+    bfs(graph, comp[0], (v, c) => {
       if (c >= 0 && v != c) order.push(v);
     });
   }