From 4c04ce7de364eaf4c700c6fc80269565c321e3b0 Mon Sep 17 00:00:00 2001 From: Curran Kelleher Date: Thu, 31 Dec 2020 16:35:44 -0500 Subject: [PATCH] First pass transform using lebab --- src/adjacent_exchange.js | 42 +++++----- src/all_pairs_distance.js | 38 ++++----- src/bandwidth.js | 12 +-- src/barycenter_order.js | 52 ++++++------ src/bfs.js | 26 +++--- src/bfs_order.js | 10 +-- src/ca.js | 137 ++++++++++++++++---------------- src/condition.js | 16 ++-- src/correlation.js | 46 +++++------ src/count_crossings.js | 18 ++--- src/covariance.js | 14 ++-- src/cuthill_mckee_order.js | 32 ++++---- src/debug.js | 27 +++---- src/dist.js | 32 ++++---- src/distance.js | 30 +++---- src/edgesum.js | 12 +-- src/fiedler.js | 32 ++++---- src/graph.js | 90 ++++++++++----------- src/graph2distmat.js | 16 ++-- src/graph2mat.js | 14 ++-- src/graph_complete.js | 8 +- src/graph_connect.js | 6 +- src/graph_empty.js | 4 +- src/graph_random.js | 14 ++-- src/hcluster.js | 53 ++++++------ src/intersect.js | 4 +- src/laplacian.js | 24 +++--- src/mat2graph.js | 18 ++--- src/mean.js | 22 ++--- src/optimal_leaf_order.js | 54 ++++++------- src/order.js | 80 +++++++++---------- src/pca_order.js | 18 ++--- src/pcp.js | 72 ++++++++--------- src/permutation.js | 4 +- src/permute.js | 8 +- src/poweriteration.js | 46 +++++------ src/random.js | 12 +-- src/range.js | 4 +- src/sort_order.js | 4 +- src/spectral_order.js | 2 +- src/stablepermute.js | 2 +- src/sum.js | 2 +- src/transpose.js | 10 +-- src/utils.js | 50 ++++++------ test/all_pairs_distance-test.js | 20 ++--- test/barycenter-test.js | 28 +++---- test/bfs-test.js | 14 ++-- test/ca-test.js | 18 ++--- test/components-test.js | 22 ++--- test/count_crossings-test.js | 58 +++++++------- test/cuthill_mckee-test.js | 30 +++---- test/env-assert.js | 42 +++++----- test/graph-test.js | 12 +-- test/graph2distmat-test.js | 18 ++--- test/graph2mat-test.js | 36 ++++----- test/laplacian-test.js | 16 ++-- test/leaforder-test.js | 72 +++++++++-------- test/mat2graph-test.js | 20 ++--- test/order-test.js | 94 +++++++++++----------- test/pca1d-test.js | 14 ++-- test/pcp-test.js | 12 +-- test/pearson-test.js | 18 ++--- test/permute-test.js | 28 +++---- 63 files changed, 894 insertions(+), 895 deletions(-) diff --git a/src/adjacent_exchange.js b/src/adjacent_exchange.js index 53eb989..b0e2f09 100644 --- a/src/adjacent_exchange.js +++ b/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; diff --git a/src/all_pairs_distance.js b/src/all_pairs_distance.js index b564ced..dd268f2 100644 --- a/src/all_pairs_distance.js +++ b/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); diff --git a/src/bandwidth.js b/src/bandwidth.js index eb11207..f007a32 100644 --- a/src/bandwidth.js +++ b/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]; diff --git a/src/barycenter_order.js b/src/barycenter_order.js index b2f3a21..5f92da6 100644 --- a/src/barycenter_order.js +++ b/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]; diff --git a/src/bfs.js b/src/bfs.js index 50fa01e..110b574 100644 --- a/src/bfs.js +++ b/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,9 +28,9 @@ 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; @@ -38,11 +38,11 @@ export function bfs_distances(graph, v) { 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); diff --git a/src/bfs_order.js b/src/bfs_order.js index 67842db..1ce34d9 100644 --- a/src/bfs_order.js +++ b/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); }); } diff --git a/src/ca.js b/src/ca.js index 8d5aa25..d723686 100644 --- a/src/ca.js +++ b/src/ca.js @@ -6,13 +6,13 @@ import { sort_order } from './sort_order'; // see http://en.wikipedia.org/wiki/Correspondence_analysis function sumrows(v) { - var n = v.length, - o = v[0].length, - sumrow = Array(n), - i, - j, - row, - s; + const n = v.length; + const o = v[0].length; + const sumrow = Array(n); + let i; + let j; + let row; + let s; for (i = 0; i < n; i++) { row = v[i]; @@ -24,12 +24,12 @@ function sumrows(v) { } function sumcols(v) { - var n = v.length, - o = v[0].length, - sumcol = zeroes(o), - i, - j, - row; + const n = v.length; + const o = v[0].length; + const sumcol = zeroes(o); + let i; + let j; + let row; for (i = 0; i < n; i++) { row = v[i]; @@ -49,16 +49,18 @@ function sumcols(v) { // https://cran.r-project.org/web/packages/vegan/index.html function decorana(dat) { - var ZEROEIG = 1e-7, // consider as zero eigenvalue - x, - y, - aidot, - adotj, - mi, - n, - s1, - nr = dat.length, - nc = dat[0].length; + const // consider as zero eigenvalue + ZEROEIG = 1e-7; + + let x; + let y; + let aidot; + let adotj; + let mi; + let n; + let s1; + const nr = dat.length; + const nc = dat[0].length; adotj = sumcols(dat); aidot = sumrows(dat); @@ -73,14 +75,14 @@ function decorana(dat) { x = s1.rows; y = s1.cols; yxmult(y, x, nr, nc, dat); - for (var i = 0; i < nr; i++) x[i] /= aidot[i]; + for (let i = 0; i < nr; i++) x[i] /= aidot[i]; } return s1; } function trans(y, yy, x, aidot, mi, n, dat, prt) { - var i, j, a1; - if (prt) console.log('TRANS ' + prt); + let i, j, a1; + if (prt) console.log(`TRANS ${prt}`); yxmult(y, x, mi, n, dat, prt); for (i = 0; i < mi; i++) { x[i] = x[i] / aidot[i]; // 10 @@ -97,13 +99,13 @@ function trans(y, yy, x, aidot, mi, n, dat, prt) { function printvec(y) { console.log(''); - for (var i = 0; i < y.length; i++) { - console.log('i:' + (i + 1) + ' v: ' + y[i].toFixed(5)); + for (let i = 0; i < y.length; i++) { + console.log(`i:${i + 1} v: ${y[i].toFixed(5)}`); } } function xymult(x, y, mi, n, dat, prt) { - var i, j, ax, row; + let i, j, ax, row; if (prt) { console.log('xymult'); @@ -122,7 +124,7 @@ function xymult(x, y, mi, n, dat, prt) { } function yxmult(y, x, mi, n, dat, prt) { - var i, j, ax, row; + let i, j, ax, row; if (prt) { console.log('yxmult'); printvec(x, 5, null, 'x='); @@ -142,34 +144,34 @@ function yxmult(y, x, mi, n, dat, prt) { } function eigy(x, y, mi, n, dat, aidot, adotj) { - var i, - j, - tot, - icount, - a, - ay, - ex, - a11, - a12, - a22, - a23, - a33, - a34, - a44, - res, - ax1, - ax2, - ax3, - ax4, - b13, - b14, - b24, - row, - y2 = zeroes(n), - y3 = zeroes(n), - y4 = zeroes(n), - y5 = zeroes(n), - tol; + let i; + let j; + let tot; + let icount; + let a; + let ay; + let ex; + let a11; + let a12; + let a22; + let a23; + let a33; + let a34; + let a44; + let res; + let ax1; + let ax2; + let ax3; + let ax4; + let b13; + let b14; + let b24; + let row; + const y2 = zeroes(n); + const y3 = zeroes(n); + const y4 = zeroes(n); + const y5 = zeroes(n); + let tol; tot = 0.0; for (j = 0; j < n; j++) { @@ -293,9 +295,9 @@ function eigy(x, y, mi, n, dat, aidot, adotj) { if (a12 > tol && debug > 0) { console.log('residual bigger than tolerance on axis 1'); } - var aymax = y[0], - aymin = y[0], - sign = 1; + let aymax = y[0]; + let aymin = y[0]; + const sign = 1; for (j = 1; j < n; j++) { a = y[j]; if (a < aymin) aymin = a; @@ -312,12 +314,12 @@ function eigy(x, y, mi, n, dat, aidot, adotj) { yxmult(y, x, mi, n, dat); //,true); for (i = 0; i < mi; i++) x[i] /= aidot[i]; // 220 // 225 - var axlong = 0.0; + let axlong = 0.0; for (i = 0; i < mi; i++) axlong += aidot[i] * sqr(x[i]); // 230 axlong = Math.sqrt(axlong); for (i = 0; i < mi; i++) x[i] /= axlong; // 240 for (j = 0; j < n; j++) y[j] /= axlong; // 250 - var sumsq = 0.0, + let sumsq = 0.0, ax; for (i = 0; i < mi; i++) { ax = x[i]; @@ -327,10 +329,10 @@ function eigy(x, y, mi, n, dat, aidot, adotj) { } // 260 } - var sd = Math.sqrt(sumsq / tot); + let sd = Math.sqrt(sumsq / tot); if (a11 >= 0.999) { sd = aymax / axlong; - var sd1 = -aymin / axlong; + const sd1 = -aymin / axlong; if (sd1 > sd) sd = sd1; } // 265 @@ -346,7 +348,8 @@ function sqr(x) { } function solve_tridiag(tol, a11, a12, a22, a23, a33, a34, a44) { - var ax1 = 1.0, // 160 + let // 160 + ax1 = 1.0, ax2 = 0.1, ax3 = 0.01, ax4 = 0.001, @@ -394,7 +397,7 @@ export const ca_decorana = decorana; export const ca = decorana; export function ca_order(dat) { - var res = ca(dat); + const res = ca(dat); return { rows: sort_order(res.rows), cols: sort_order(res.cols), diff --git a/src/condition.js b/src/condition.js index db19240..d5fb2c5 100644 --- a/src/condition.js +++ b/src/condition.js @@ -1,12 +1,12 @@ export function condition(matrix) { - var i, - j, - min, - max, - v, - s, - row, - ret = []; + let i; + let j; + let min; + let max; + let v; + let s; + let row; + const ret = []; for (i = 0; 0 < matrix.length; i++) { row = matrix[i].slice(); diff --git a/src/correlation.js b/src/correlation.js index 952b5e0..7ede126 100644 --- a/src/correlation.js +++ b/src/correlation.js @@ -1,16 +1,16 @@ import { zeroes, mean } from './aliases'; export const correlation = { - pearson: function (a, b) { - var ma = mean(a), - mb = mean(b), - s1 = 0, - s2 = 0, - s3 = 0, - i, - dx, - dy, - n = Math.min(a.length, b.length); + pearson(a, b) { + const ma = mean(a); + const mb = mean(b); + let s1 = 0; + let s2 = 0; + let s3 = 0; + let i; + let dx; + let dy; + const n = Math.min(a.length, b.length); if (n === 0) return NaN; for (i = 0; i < n; i++) { dx = a[i] - ma; @@ -21,24 +21,24 @@ export const correlation = { } return s1 / Math.sqrt(s2 * s3); }, - pearsonMatrix: function (matrix) { - var a, - ma, - i, - j, - dx, - cor = correlation.pearson, - n = matrix.length, - ret, - mx, - sx, - sx2; + pearsonMatrix(matrix) { + let a; + let ma; + let i; + let j; + let dx; + const cor = correlation.pearson; + const n = matrix.length; + let ret; + let mx; + let sx; + let sx2; if (n === 0) return NaN; // do it the hard way for now, we'll optimize later ret = zeroes(n, n); for (i = 0; i < n - 1; i++) { for (j = i + 1; j < n; j++) { - var p = cor(matrix[i], matrix[j]); + const p = cor(matrix[i], matrix[j]); ret[i][j] = ret[j][i] = p; } } diff --git a/src/count_crossings.js b/src/count_crossings.js index a1fa085..8e239b8 100644 --- a/src/count_crossings.js +++ b/src/count_crossings.js @@ -7,7 +7,7 @@ import { zeroes } from './aliases'; // J. Graph Algorithms Appl. 8(2): 179-194 (2004) /*jshint loopfunc:true */ export function count_crossings(graph, north, south) { - var i, + let i, j, n, firstIndex, @@ -18,35 +18,35 @@ export function count_crossings(graph, north, south) { invert = false, crosscount; - var comp = permutation(graph.nodes().length); + const comp = permutation(graph.nodes().length); if (north === undefined) { - north = comp.filter(function (n) { + north = comp.filter((n) => { return graph.outDegree(n) !== 0; }); - south = comp.filter(function (n) { + south = comp.filter((n) => { return graph.inDegree(n) !== 0; }); } // Choose the smaller axis if (north.length < south.length) { - var tmp = north; + const tmp = north; north = south; south = tmp; invert = true; } - var south_inv = inverse_permutation(south), - southsequence = []; + const south_inv = inverse_permutation(south); + let southsequence = []; for (i = 0; i < north.length; i++) { if (invert) { - n = graph.inEdges(north[i]).map(function (e) { + n = graph.inEdges(north[i]).map((e) => { return south_inv[e.target.index]; }); } else { - n = graph.outEdges(north[i]).map(function (e) { + n = graph.outEdges(north[i]).map((e) => { return south_inv[e.source.index]; }); } diff --git a/src/covariance.js b/src/covariance.js index ffb6855..29309fa 100644 --- a/src/covariance.js +++ b/src/covariance.js @@ -3,9 +3,9 @@ import { dot } from './aliases'; export const covariance = dot; export function covariancetranspose(v, a, b) { - var n = v.length, - cov = 0, - i; + const n = v.length; + let cov = 0; + let i; for (i = 0; i < n; i++) { cov += v[i][a] * v[i][b]; } @@ -13,10 +13,10 @@ export function covariancetranspose(v, a, b) { } export function variancecovariance(v) { - var o = v[0].length, - cov = Array(o), - i, - j; + const o = v[0].length; + const cov = Array(o); + let i; + let j; for (i = 0; i < o; i++) { cov[i] = Array(o); diff --git a/src/cuthill_mckee_order.js b/src/cuthill_mckee_order.js index c05a4a3..fd9a08e 100644 --- a/src/cuthill_mckee_order.js +++ b/src/cuthill_mckee_order.js @@ -4,17 +4,17 @@ import { inverse_permutation } from './permutation'; export function cuthill_mckee(graph, comp) { if (comp.length < 3) return comp; - var nodes = graph.nodes(), - start = comp[0], - min_deg = graph.degree(start), - i, - n, - edges, - e, - visited = {}, - queue = new Queue(), - inv = inverse_permutation(comp), - perm = []; + const nodes = graph.nodes(); + let start = comp[0]; + let min_deg = graph.degree(start); + let i; + let n; + let edges; + let e; + const visited = {}; + const queue = new Queue(); + const inv = inverse_permutation(comp); + const perm = []; for (i = 0; i < comp.length; i++) { n = comp[i]; @@ -32,13 +32,13 @@ export function cuthill_mckee(graph, comp) { perm.push(n); e = graph .edges(n) - .map(function (edge) { + .map((edge) => { return graph.other(edge, n).index; }) - .filter(function (n) { + .filter((n) => { return !visited[n] && n in inv; }) - .sort(function (a, b) { + .sort((a, b) => { // ascending by degree return graph.degree(a) - graph.degree(b); }); @@ -53,7 +53,7 @@ export function reverse_cuthill_mckee(graph, comp) { } export function cuthill_mckee_order(graph, comps) { - var i, + let i, comp, order = []; if (!comps) { @@ -67,7 +67,7 @@ export function cuthill_mckee_order(graph, comps) { } export function reverse_cuthill_mckee_order(graph, comps) { - var i, + let i, comp, order = []; if (!comps) { diff --git a/src/debug.js b/src/debug.js index 731951a..85624e5 100644 --- a/src/debug.js +++ b/src/debug.js @@ -1,5 +1,5 @@ export function displaymat(mat, rowperm, colperm) { - var i, j, row, col, str; + let i, j, row, col, str; console.log('Matrix:'); for (i = 0; i < mat.length; i++) { row = rowperm ? mat[rowperm[i]] : mat[i]; @@ -13,7 +13,7 @@ export function displaymat(mat, rowperm, colperm) { } export function printvec(row, prec, colperm, line) { - var j; + let j; if (!line) line = ''; for (j = 0; j < row.length; j++) { if (line.length !== 0) line += ', '; @@ -24,11 +24,11 @@ export function printvec(row, prec, colperm, line) { } export function printmat(m, prec, rowperm, colperm) { - var i, j, row, line; + let i, j, row, line; if (!prec) prec = 4; for (i = 0; i < m.length; i++) { row = rowperm ? m[rowperm[i]] : m[i]; - printvec(row, prec, colperm, i + ': '); + printvec(row, prec, colperm, `${i}: `); } } @@ -41,17 +41,12 @@ export function assert(v, msg) { export function printhcluster(cluster, indent) { if (cluster.left === null) - return Array(indent + 1).join(' ') + 'id: ' + cluster.id; + return `${Array(indent + 1).join(' ')}id: ${cluster.id}`; - return ( - Array(indent + 1).join(' ') + - 'id: ' + - cluster.id + - ', dist: ' + - cluster.dist + - '\n' + - printhcluster(cluster.left, indent + 1) + - '\n' + - printhcluster(cluster.right, indent + 1) - ); + return `${Array(indent + 1).join(' ')}id: ${cluster.id}, dist: ${ + cluster.dist + }\n${printhcluster(cluster.left, indent + 1)}\n${printhcluster( + cluster.right, + indent + 1 + )}`; } diff --git a/src/dist.js b/src/dist.js index a5ba9c2..e7fbd38 100644 --- a/src/dist.js +++ b/src/dist.js @@ -1,16 +1,16 @@ import { distance as distances } from './distance'; export function dist() { - var distance = distances.euclidean; + let distance = distances.euclidean; function dist(vectors) { - var n = vectors.length, + const n = vectors.length, distMatrix = []; - for (var i = 0; i < n; i++) { - var d = []; + for (let i = 0; i < n; i++) { + const d = []; distMatrix[i] = d; - for (var j = 0; j < n; j++) { + for (let j = 0; j < n; j++) { if (j < i) { d.push(distMatrix[j][i]); } else if (i === j) { @@ -33,11 +33,11 @@ export function dist() { } export function distmax(distMatrix) { - var max = 0, - n = distMatrix.length, - i, - j, - row; + let max = 0; + const n = distMatrix.length; + let i; + let j; + let row; for (i = 0; i < n; i++) { row = distMatrix[i]; @@ -47,11 +47,11 @@ export function distmax(distMatrix) { } export function distmin(distMatrix) { - var min = Infinity, - n = distMatrix.length, - i, - j, - row; + let min = Infinity; + const n = distMatrix.length; + let i; + let j; + let row; for (i = 0; i < n; i++) { row = distMatrix[i]; @@ -62,7 +62,7 @@ export function distmin(distMatrix) { export function dist_remove(dist, n, m) { if (arguments.length < 3) m = n + 1; - var i; + let i; dist.splice(n, m - n); for (i = dist.length; i-- > 0; ) dist[i].splice(n, m - n); return dist; diff --git a/src/distance.js b/src/distance.js index 319e122..95a3bdb 100644 --- a/src/distance.js +++ b/src/distance.js @@ -2,8 +2,8 @@ function isNum(a, b) { return !(isNaN(a) || isNaN(b) || a == Infinity || b == Infinity); } export const distance = { - euclidean: function (a, b) { - var i = a.length, + euclidean(a, b) { + let i = a.length, s = 0, x; while (i-- > 0) { @@ -14,8 +14,8 @@ export const distance = { } return Math.sqrt(s); }, - manhattan: function (a, b) { - var i = a.length, + manhattan(a, b) { + let i = a.length, s = 0; while (i-- > 0) { if (isNum(a[i], b[i])) { @@ -24,9 +24,9 @@ export const distance = { } return s; }, - minkowski: function (p) { - return function (a, b) { - var i = a.length, + minkowski(p) { + return (a, b) => { + let i = a.length, s = 0; while (i-- > 0) { if (isNum(a[i], b[i])) { @@ -36,8 +36,8 @@ export const distance = { return Math.pow(s, 1 / p); }; }, - chebyshev: function (a, b) { - var i = a.length, + chebyshev(a, b) { + let i = a.length, max = 0, x; while (i-- > 0) { @@ -48,8 +48,8 @@ export const distance = { } return max; }, - hamming: function (a, b) { - var i = a.length, + hamming(a, b) { + let i = a.length, d = 0; while (i-- > 0) { if (isNum(a[i], b[i])) { @@ -58,8 +58,8 @@ export const distance = { } return d; }, - jaccard: function (a, b) { - var n = 0, + jaccard(a, b) { + let n = 0, i = a.length, s = 0; while (i-- > 0) { @@ -71,8 +71,8 @@ export const distance = { if (n === 0) return 0; return s / n; }, - braycurtis: function (a, b) { - var i = a.length, + braycurtis(a, b) { + let i = a.length, s0 = 0, s1 = 0, ai, diff --git a/src/edgesum.js b/src/edgesum.js index ab226fe..66cd737 100644 --- a/src/edgesum.js +++ b/src/edgesum.js @@ -3,12 +3,12 @@ import { range } from './range'; export function edgesum(graph, order) { if (!order) order = range(graph.nodes().length); - var inv = inverse_permutation(order), - links = graph.links(), - i, - e, - d, - sum = 0; + const inv = inverse_permutation(order); + const links = graph.links(); + let i; + let e; + let d; + let sum = 0; for (i = 0; i < links.length; i++) { e = links[i]; diff --git a/src/fiedler.js b/src/fiedler.js index 5a3beda..1f5e96a 100644 --- a/src/fiedler.js +++ b/src/fiedler.js @@ -15,12 +15,12 @@ import { random_array } from './random'; // Also, the smallest eigenvector is 1^n function gershgorin_bound(B) { - var i, - j, - max = 0, - n = B.length, - t, - row; + let i; + let j; + let max = 0; + const n = B.length; + let t; + let row; for (i = 0; i < n; i++) { row = B[i]; t = row[i]; @@ -34,15 +34,17 @@ function gershgorin_bound(B) { } export function fiedler_vector(B, eps) { - var g = gershgorin_bound(B), - n = B.length, - // Copy B - Bhat = B.map(function (row) { + const g = gershgorin_bound(B); + const n = B.length; + + const // Copy B + Bhat = B.map((row) => { return row.slice(); - }), - i, - j, - row; + }); + + let i; + let j; + let row; for (i = 0; i < n; i++) { row = Bhat[i]; for (j = 0; j < n; j++) { @@ -50,7 +52,7 @@ export function fiedler_vector(B, eps) { else row[j] = -row[j]; } } - var init = [array1d(n, 1), random_array(n)], + const init = [array1d(n, 1), random_array(n)], eig = poweriteration_n(Bhat, 2, init, eps, 1); return eig[0][1]; } diff --git a/src/graph.js b/src/graph.js index 62f6605..9705745 100644 --- a/src/graph.js +++ b/src/graph.js @@ -2,12 +2,12 @@ import { debug } from './core'; import { cmp_number } from './utils'; export function graph(nodes, links, directed) { - var graph = {}, - linkDistance = 1, - edges, - inEdges, - outEdges, - components; + const graph = {}; + let linkDistance = 1; + let edges; + let inEdges; + let outEdges; + let components; graph.nodes = function (x) { if (!arguments.length) return nodes; @@ -15,15 +15,15 @@ export function graph(nodes, links, directed) { return graph; }; - graph.nodes_indices = function () { - return nodes.map(function (n) { + graph.nodes_indices = () => { + return nodes.map((n) => { return n.index; }); }; - graph.generate_nodes = function (n) { + graph.generate_nodes = (n) => { nodes = []; - for (var i = 0; i < n; i++) nodes.push({ id: i }); + for (let i = 0; i < n; i++) nodes.push({ id: i }); return graph; }; @@ -32,8 +32,8 @@ export function graph(nodes, links, directed) { links = x; return graph; }; - graph.links_indices = function () { - return links.map(function (l) { + graph.links_indices = () => { + return links.map((l) => { return { source: l.source.index, target: l.target.index }; }); }; @@ -50,10 +50,10 @@ export function graph(nodes, links, directed) { }; function init() { - var i, - o, - n = nodes.length, - m = links.length; + let i; + let o; + const n = nodes.length; + const m = links.length; components = undefined; for (i = 0; i < n; ++i) { @@ -104,7 +104,7 @@ export function graph(nodes, links, directed) { graph.init = init; - graph.edges = function (node) { + graph.edges = (node) => { if (typeof node != 'number') { node = node.index; if (debug) { @@ -114,34 +114,34 @@ export function graph(nodes, links, directed) { return edges[node]; }; - graph.degree = function (node) { + graph.degree = (node) => { if (typeof node != 'number') node = node.index; return edges[node].length; }; - graph.inEdges = function (node) { + graph.inEdges = (node) => { if (typeof node != 'number') node = node.index; return inEdges[node]; }; - graph.inDegree = function (node) { + graph.inDegree = (node) => { if (typeof node != 'number') node = node.index; return inEdges[node].length; }; - graph.outEdges = function (node) { + graph.outEdges = (node) => { if (typeof node != 'number') node = node.index; return outEdges[node]; }; - graph.outDegree = function (node) { + graph.outDegree = (node) => { if (typeof node != 'number') node = node.index; return outEdges[node].length; }; - graph.sinks = function () { - var sinks = [], - i; + graph.sinks = () => { + const sinks = []; + let i; for (i = 0; i < nodes.length; i++) { if (graph.outEdges(i).length === 0) sinks.push(i); @@ -149,9 +149,9 @@ export function graph(nodes, links, directed) { return sinks; }; - graph.sources = function () { - var sources = [], - i; + graph.sources = () => { + const sources = []; + let i; for (i = 0; i < nodes.length; i++) { if (graph.inEdges(i).length === 0) sources.push(i); @@ -165,10 +165,10 @@ export function graph(nodes, links, directed) { graph.distance = distance; function neighbors(node) { - var e = edges[node], + const e = edges[node], ret = []; - for (var i = 0; i < e.length; ++i) { - var o = e[i]; + for (let i = 0; i < e.length; ++i) { + const o = e[i]; if (o.source.index == node) ret.push(o.target); else ret.push(o.source); } @@ -176,24 +176,24 @@ export function graph(nodes, links, directed) { } graph.neighbors = neighbors; - graph.other = function (o, node) { + graph.other = (o, node) => { if (typeof o == 'number') o = links[o]; if (o.source.index == node) return o.target; else return o.source; }; function compute_components() { - var stack = [], - comp = 0, - comps = [], - ccomp, - n = nodes.length, - i, - j, - v, - l, - o, - e; + const stack = []; + let comp = 0; + const comps = []; + let ccomp; + const n = nodes.length; + let i; + let j; + let v; + let l; + let o; + let e; for (i = 0; i < n; i++) nodes[i].comp = 0; @@ -226,13 +226,13 @@ export function graph(nodes, links, directed) { comps.push(ccomp); } } - comps.sort(function (a, b) { + comps.sort((a, b) => { return b.length - a.length; }); return comps; } - graph.components = function () { + graph.components = () => { if (!components) components = compute_components(); return components; }; diff --git a/src/graph2distmat.js b/src/graph2distmat.js index 647a693..dda2804 100644 --- a/src/graph2distmat.js +++ b/src/graph2distmat.js @@ -9,11 +9,11 @@ import { flatten } from './utils'; // Optimal Leaf Ordering. export function distmat2valuemat(distmat) { - var n = distmat.length, - valuemat = zeroes(n, n), - max_dist = distmax(distmat), - i, - j; + const n = distmat.length; + const valuemat = zeroes(n, n); + const max_dist = distmax(distmat); + let i; + let j; for (i = 0; i < n; i++) { for (j = i; j < n; j++) { @@ -26,15 +26,15 @@ export function distmat2valuemat(distmat) { export function graph2valuemats(graph, comps) { if (!comps) comps = graph.components(); - var dists = all_pairs_distance(graph, comps); + const dists = all_pairs_distance(graph, comps); return dists.map(distmat2valuemat); } export function valuemats_reorder(valuemats, leaforder, comps) { - var orders = valuemats.map(leaforder); + let orders = valuemats.map(leaforder); if (comps) { - orders = orders.map(function (d, i) { + orders = orders.map((d, i) => { return permute(comps[i], d); }); } diff --git a/src/graph2mat.js b/src/graph2mat.js index a4c6d46..2478796 100644 --- a/src/graph2mat.js +++ b/src/graph2mat.js @@ -1,16 +1,16 @@ import { zeroes } from './aliases'; export function graph2mat(graph, directed) { - var nodes = graph.nodes(), - links = graph.links(), - n = nodes.length, - i, - l, - mat; + const nodes = graph.nodes(); + const links = graph.links(); + const n = nodes.length; + let i; + let l; + let mat; if (!directed) directed = graph.directed(); if (directed) { - var rows = n, + let rows = n, cols = n; for (i = n - 1; i >= 0; i--) { diff --git a/src/graph_complete.js b/src/graph_complete.js index d17380a..2db8d38 100644 --- a/src/graph_complete.js +++ b/src/graph_complete.js @@ -1,10 +1,10 @@ import { graph } from './graph'; export function complete_graph(n, directed) { - var nodes = graph_empty_nodes(n), - links = [], - i, - j; + const nodes = graph_empty_nodes(n); + const links = []; + let i; + let j; if (directed) { for (i = 0; i < n; i++) { diff --git a/src/graph_connect.js b/src/graph_connect.js index 1b6a383..898bb98 100644 --- a/src/graph_connect.js +++ b/src/graph_connect.js @@ -1,7 +1,7 @@ export function graph_connect(graph, comps) { - var i, - j, - links = graph.links(); + let i; + let j; + const links = graph.links(); if (!comps) comps = graph.components(); diff --git a/src/graph_empty.js b/src/graph_empty.js index 3dc5403..ecb13ac 100644 --- a/src/graph_empty.js +++ b/src/graph_empty.js @@ -1,6 +1,6 @@ export function graph_empty_nodes(n) { - var nodes = Array(n), - i; + const nodes = Array(n); + let i; for (i = 0; i < n; i++) nodes[i] = { id: i }; return nodes; } diff --git a/src/graph_random.js b/src/graph_random.js index 8e2d4f5..99878cc 100644 --- a/src/graph_random.js +++ b/src/graph_random.js @@ -6,13 +6,13 @@ export function graph_random_erdos_renyi(n, p, directed) { if (p <= 0) return graph_empty(n, directed); else if (p >= 1) return complete_graph(n, directed); - var nodes = graph_empty_nodes(n), - links = [], - v, - w, - i, - lr, - lp; + const nodes = graph_empty_nodes(n); + const links = []; + let v; + let w; + let i; + let lr; + let lp; w = -1; lp = Math.log(1.0 - p); diff --git a/src/hcluster.js b/src/hcluster.js index 1b05460..828e989 100644 --- a/src/hcluster.js +++ b/src/hcluster.js @@ -3,25 +3,28 @@ import { distance as distances } from './distance'; // This is a modified implementation of hcluster derived from: // https://github.com/jasondavies/science.js/blob/master/src/stats/hcluster.js export function hcluster() { - var distance = distances.euclidean, - linkage = 'single', // single, complete or average + let distance = distances.euclidean, + // single, complete or average + linkage = 'single', distMatrix = null; function hcluster(vectors) { - var n = vectors.length, - dMin = [], - cSize = [], - // distMatrix = [], - clusters = [], - c1, - c2, - c1Cluster, - c2Cluster, - p, - root, - i, - j, - id = 0; + const n = vectors.length; + const dMin = []; + const cSize = []; + + const // distMatrix = [], + clusters = []; + + let c1; + let c2; + let c1Cluster; + let c2Cluster; + let p; + let root; + let i; + let j; + let id = 0; // Initialise distance matrix and vector of closest clusters. if (distMatrix === null) { @@ -40,11 +43,7 @@ export function hcluster() { } else { if (distMatrix.length < n || distMatrix[0].length < n) throw { - error: - 'Provided distance matrix length ' + - distMatrix.length + - ' instead of ' + - n, + error: `Provided distance matrix length ${distMatrix.length} instead of ${n}`, }; i = -1; while (++i < n) { @@ -86,7 +85,7 @@ export function hcluster() { c1Cluster = clusters[c1][0]; c2Cluster = clusters[c2][0]; - var newCluster = { + const newCluster = { left: c1Cluster, right: c2Cluster, dist: distMatrix[c1][c2], @@ -152,7 +151,7 @@ export function hcluster() { hcluster.distanceMatrix = function (x) { if (!arguments.length) return distMatrix; - distMatrix = x.map(function (y) { + distMatrix = x.map((y) => { return y.slice(0); }); return hcluster; @@ -162,10 +161,10 @@ export function hcluster() { } function calculateCentroid(c1Size, c1Centroid, c2Size, c2Centroid) { - var newCentroid = [], - newSize = c1Size + c2Size, - n = c1Centroid.length, - i = -1; + const newCentroid = []; + const newSize = c1Size + c2Size; + const n = c1Centroid.length; + let i = -1; while (++i < n) { newCentroid[i] = (c1Size * c1Centroid[i] + c2Size * c2Centroid[i]) / newSize; diff --git a/src/intersect.js b/src/intersect.js index 70f3835..9d307fa 100644 --- a/src/intersect.js +++ b/src/intersect.js @@ -1,7 +1,7 @@ export function intersect_sorted_ints(array1, array2) { - var ai = 0, + let ai = 0, bi = 0; - var result = []; + const result = []; while (ai < a.length && bi < b.length) { if (a[ai] < b[bi]) { diff --git a/src/laplacian.js b/src/laplacian.js index 986e499..3a4abb3 100644 --- a/src/laplacian.js +++ b/src/laplacian.js @@ -3,18 +3,18 @@ import { assert } from './debug'; import { inverse_permutation } from './permutation'; export function laplacian(graph, comp) { - var n = comp.length, - lap = zeroes(n, n), - inv = inverse_permutation(comp), - i, - j, - k, - row, - sum, - edges, - v, - e, - other; + const n = comp.length; + const lap = zeroes(n, n); + const inv = inverse_permutation(comp); + let i; + let j; + let k; + let row; + let sum; + let edges; + let v; + let e; + let other; assert(!graph.directed(), 'Laplacian only for undirected graphs'); for (i = 0; i < n; i++) { diff --git a/src/mat2graph.js b/src/mat2graph.js index 36044b6..19e23c1 100644 --- a/src/mat2graph.js +++ b/src/mat2graph.js @@ -1,14 +1,14 @@ import { graph } from './graph'; export function mat2graph(mat, directed) { - var n = mat.length, - nodes = [], - links = [], - max_value = Number.NEGATIVE_INFINITY, - i, - j, - v, - m; + const n = mat.length; + const nodes = []; + const links = []; + let max_value = Number.NEGATIVE_INFINITY; + let i; + let j; + let v; + let m; for (i = 0; i < n; i++) nodes.push({ id: i }); @@ -25,7 +25,7 @@ export function mat2graph(mat, directed) { } } return graph(nodes, links, directed) - .linkDistance(function (l, i) { + .linkDistance((l, i) => { return 1 + max_value - l.value; }) .init(); diff --git a/src/mean.js b/src/mean.js index 9bf7e21..7f8d4c9 100644 --- a/src/mean.js +++ b/src/mean.js @@ -1,10 +1,10 @@ export function meantranspose(v, j) { - var n = v.length; + const n = v.length; if (n === 0) return NaN; - var o = v[0].length, - m = 0, - i = -1, - row; + const o = v[0].length; + let m = 0; + let i = -1; + let row; while (++i < n) m += (v[i][j] - m) / (i + 1); @@ -12,13 +12,13 @@ export function meantranspose(v, j) { } export function meancolumns(v) { - var n = v.length; + const n = v.length; if (n === 0) return NaN; - var o = v[0].length, - m = v[0].slice(0), - i = 0, - j, - row; + const o = v[0].length; + const m = v[0].slice(0); + let i = 0; + let j; + let row; while (++i < n) { row = v[i]; diff --git a/src/optimal_leaf_order.js b/src/optimal_leaf_order.js index 13c36f2..75e70a0 100644 --- a/src/optimal_leaf_order.js +++ b/src/optimal_leaf_order.js @@ -20,7 +20,7 @@ import { dist } from './dist'; */ export function optimal_leaf_order() { - var distanceMatrix = null, + let distanceMatrix = null, distance = distances.euclidean, linkage = 'complete', leavesMap = {}, @@ -43,7 +43,7 @@ export function optimal_leaf_order() { } function order(v, i, j) { - var key = 'k' + v.id + '-' + i + '-' + j; // ugly key + const key = `k${v.id}-${i}-${j}`; // ugly key if (key in orderMap) return orderMap[key]; return (orderMap[key] = _order(v, i, j)); } @@ -52,37 +52,37 @@ export function optimal_leaf_order() { if (v.depth === 0) //isLeaf(v)) return [0, [v.id]]; - var l = v.left, + const l = v.left, r = v.right; - var L = leaves(l), + const L = leaves(l), R = leaves(r); - var w, x; - if (L.indexOf(i) !== -1 && R.indexOf(j) !== -1) { + let w, x; + if (L.includes(i) && R.includes(j)) { w = l; x = r; - } else if (R.indexOf(i) !== -1 && L.indexOf(j) !== -1) { + } else if (R.includes(i) && L.includes(j)) { w = r; x = l; - } else throw { error: 'Node is not common ancestor of ' + i + ', ' + j }; - var Wl = leaves(w.left), + } else throw { error: `Node is not common ancestor of ${i}, ${j}` }; + const Wl = leaves(w.left), Wr = leaves(w.right); - var Ks = Wr.indexOf(i) != -1 ? Wl : Wr; + let Ks = Wr.includes(i) ? Wl : Wr; if (Ks.length === 0) Ks = [i]; - var Xl = leaves(x.left), + const Xl = leaves(x.left), Xr = leaves(x.right); - var Ls = Xr.indexOf(j) != -1 ? Xl : Xr; + let Ls = Xr.includes(j) ? Xl : Xr; if (Ls.length === 0) Ls = [j]; - var min = Infinity, + let min = Infinity, optimal_order = []; - for (var k = 0; k < Ks.length; k++) { - var w_min = order(w, i, Ks[k]); - for (var m = 0; m < Ls.length; m++) { - var x_min = order(x, Ls[m], j); - var dist = w_min[0] + distanceMatrix[Ks[k]][Ls[m]] + x_min[0]; + for (let k = 0; k < Ks.length; k++) { + const w_min = order(w, i, Ks[k]); + for (let m = 0; m < Ls.length; m++) { + const x_min = order(x, Ls[m], j); + const dist = w_min[0] + distanceMatrix[Ks[k]][Ls[m]] + x_min[0]; if (dist < min) { min = dist; optimal_order = w_min[1].concat(x_min[1]); @@ -95,16 +95,16 @@ export function optimal_leaf_order() { function orderFull(v) { leavesMap = {}; orderMap = {}; - var min = Infinity, - optimal_order = [], - left = leaves(v.left), - right = leaves(v.right); + let min = Infinity; + let optimal_order = []; + const left = leaves(v.left); + const right = leaves(v.right); if (debug) console.log(printhcluster(v, 0)); - for (var i = 0; i < left.length; i++) { - for (var j = 0; j < right.length; j++) { - var so = order(v, left[i], right[j]); + for (let i = 0; i < left.length; i++) { + for (let j = 0; j < right.length; j++) { + const so = order(v, left[i], right[j]); if (so[0] < min) { min = so[0]; optimal_order = so[1]; @@ -118,7 +118,7 @@ export function optimal_leaf_order() { function optimal_leaf_order(matrix) { if (distanceMatrix === null) distanceMatrix = dist().distance(distance)(matrix); - var cluster = hcluster().linkage(linkage).distanceMatrix(distanceMatrix); + const cluster = hcluster().linkage(linkage).distanceMatrix(distanceMatrix); return orderFull(cluster(matrix)); } optimal_leaf_order.order = orderFull; @@ -140,7 +140,7 @@ export function optimal_leaf_order() { optimal_leaf_order.distance_matrix = function (x) { if (!arguments.length) return distanceMatrix; // copy - distanceMatrix = x.map(function (y) { + distanceMatrix = x.map((y) => { return y.slice(0); }); return optimal_leaf_order; diff --git a/src/order.js b/src/order.js index 3e3ebf1..71ae942 100644 --- a/src/order.js +++ b/src/order.js @@ -7,15 +7,15 @@ import { range } from './range'; import { permutation } from './permutation'; export function order() { - var distance = distances.euclidean, - ordering = optimal_leaf_order, - linkage = 'complete', - distanceMatrix = null, - vector, - except = [], - debug = 0, - i = 0, - j = Infinity; + let distance = distances.euclidean; + let ordering = optimal_leaf_order; + let linkage = 'complete'; + let distanceMatrix = null; + let vector; + let except = []; + const debug = 0; + let i = 0; + let j = Infinity; function _reset() { distance = distances.euclidean; @@ -31,7 +31,7 @@ export function order() { function order(v) { vector = v; j = Math.min(j, v.length); - var i0 = i > 0 ? i - 1 : 0, + let i0 = i > 0 ? i - 1 : 0, j0 = j < vector.length ? j + 1 : j, k, low, @@ -65,16 +65,16 @@ export function order() { } function _order_limits(i0, j0) { - var orig = vector, - perm, - row, - k, - l; + const orig = vector; + let perm; + let row; + let k; + let l; vector = vector.slice(i0, j0); // always make a copy if (i === 0 && j == vector.length) return _order_except(); - if (debug) console.log('i0=' + i0 + ' j0=' + j0); + if (debug) console.log(`i0=${i0} j0=${j0}`); if (distanceMatrix !== null) { if (j0 !== vector.length) dist_remove(distanceMatrix, j0, vector.length); @@ -84,7 +84,7 @@ export function order() { } // Apply constraints on the min/max indices - var max = distmax(distanceMatrix); + let max = distmax(distanceMatrix); if (i0 < i) { // row i0 should be far away from each rows so move it away // by changing the distance matrix, adding "max" to each @@ -133,7 +133,7 @@ export function order() { } if (i0 !== 0) { perm = permutation(i0).concat( - perm.map(function (v) { + perm.map((v) => { return v + i0; }) ); @@ -145,7 +145,7 @@ export function order() { } function _order_except() { - var perm, k, l, low, high, pos; + let perm, k, l, low, high, pos; if (except.length === 0) return _order_equiv(); @@ -160,7 +160,7 @@ export function order() { high = except[k]; distanceMatrix = dist_remove(distanceMatrix, low + 1, high - 1); vector.splice(low + 1, high - low - 2); - if (debug) console.log('Except[' + low + ', ' + high + ']'); + if (debug) console.log(`Except[${low}, ${high}]`); if (distanceMatrix[low][low + 1] !== 0) { // boundaries are equal, they will survive distanceMatrix[low][low + 1] = distanceMatrix[low + 1][low] = -1; @@ -199,17 +199,17 @@ export function order() { } function _order_equiv() { - var perm, - row, - e, - j, - k, - l, - m, - n, - has_1 = false, - equiv = [], - fix_except = {}; + let perm; + let row; + let e; + let j; + let k; + let l; + let m; + let n; + let has_1 = false; + const equiv = []; + const fix_except = {}; _compute_dist(); @@ -286,7 +286,7 @@ export function order() { } function _fix_exception(perm, l, m, next, len) { - var i, j, k; + let i, j, k; // for (k = 0; k < except.length; k += 2) { // if (m == except[k]) { @@ -314,7 +314,7 @@ export function order() { function _swap(perm, a, b) { if (a == b) return; - var c = perm[a]; + const c = perm[a]; perm[a] = perm[b]; perm[b] = c; } @@ -323,16 +323,16 @@ export function order() { if (debug > 1) printmat(distanceMatrix); if (debug > 2) printmat(vector); - var perm = ordering().linkage(linkage).distanceMatrix(distanceMatrix)( + const perm = ordering().linkage(linkage).distanceMatrix(distanceMatrix)( vector ); - if (debug) console.log('Permutation: ' + perm); + if (debug) console.log(`Permutation: ${perm}`); return perm; } function _perm_insert(perm, i, nv) { - perm = perm.map(function (v) { + perm = perm.map((v) => { return v < nv ? v : v + 1; }); perm.splice(i, 0, nv); @@ -365,7 +365,7 @@ export function order() { }; order.except = function (list) { - var i; + let i; if (!arguments.length) return except.slice(0); for (i = 1; i < list.length; i++) if (list[i - 1] >= list[i]) throw 'Invalid list, indices not sorted'; @@ -374,8 +374,8 @@ export function order() { }; function _orderExcept(vector, i, j) { - var distanceMatrix = dist().distance(distance)(vector); - var row, + const distanceMatrix = dist().distance(distance)(vector); + let row, k, l, rev = false, @@ -386,7 +386,7 @@ export function order() { // TODO: check if no other pair is also ==0 distanceMatrix[i][i + 1] = 0; distanceMatrix[i + 1][i] = 0; - var perm = ordering().distanceMatrix(distanceMatrix)(vector); + const perm = ordering().distanceMatrix(distanceMatrix)(vector); pos = perm.indexOf(i); for (k = 0; k < perm.length; k++) { l = perm[k]; diff --git a/src/pca_order.js b/src/pca_order.js index 3dd2757..98d313d 100644 --- a/src/pca_order.js +++ b/src/pca_order.js @@ -6,16 +6,16 @@ import { sort_order } from './sort_order'; // Takes a matrix, substract the mean of each row // so that the mean is 0 function center(v) { - var n = v.length; + const n = v.length; if (n === 0) return null; - var mean = meancolumns(v), - o = mean.length, - v1 = Array(n), - i, - j, - row; + const mean = meancolumns(v); + const o = mean.length; + const v1 = Array(n); + let i; + let j; + let row; for (i = 0; i < n; i++) { row = v[i].slice(0); @@ -29,12 +29,12 @@ function center(v) { // See http://en.wikipedia.org/wiki/Power_iteration export function pca1d(v, eps) { - var n = v.length; + const n = v.length; if (v.length === 0) return null; v = center(v); - var cov = variancecovariance(v); + const cov = variancecovariance(v); return poweriteration(cov, eps); } diff --git a/src/pcp.js b/src/pcp.js index 994e70b..9397792 100644 --- a/src/pcp.js +++ b/src/pcp.js @@ -8,11 +8,11 @@ import { hcluster } from './hcluster'; export function array_to_dicts(data, axes) { if (arguments.length < 2) axes = range(data[0].length); - var ret = [], - row, - dict, - i, - j; + const ret = []; + let row; + let dict; + let i; + let j; for (i = 0; i < data.length; i++) { row = data[i]; dict = {}; @@ -26,12 +26,12 @@ export function array_to_dicts(data, axes) { export function dicts_to_array(dicts, keys) { if (arguments.length < 2) keys = Object.keys(dicts[0]); - var n = keys.length, - m = dicts.length, - array = Array(m), - i, - j, - row; + const n = keys.length; + const m = dicts.length; + const array = Array(m); + let i; + let j; + let row; for (i = 0; i < m; i++) { row = Array(n); @@ -42,17 +42,17 @@ export function dicts_to_array(dicts, keys) { } function abs_matrix(x) { - return x.map(function (y) { + return x.map((y) => { return y.map(Math.abs); }); } function pcp_flip_axes(perm, naxes, pcor) { - var i, - c, - sign = 1, - signs = [1], - negs = 0; + let i; + let c; + let sign = 1; + const signs = [1]; + let negs = 0; for (i = 1; i < perm.length; i++) { c = pcor[perm[i - 1]][perm[i]]; if (c < 0) sign = -sign; @@ -72,15 +72,15 @@ function pcp_flip_axes(perm, naxes, pcor) { export function pcp(data, axes) { if (!axes) axes = range(data[0].length); - var tdata = transpose(data), - pcor = correlation.pearsonMatrix(tdata), - abs_pcor = abs_matrix(pcor), - h1 = hcluster().linkage('complete').distanceMatrix(abs_pcor)(tdata), - perm = optimal_leaf_order().distanceMatrix(abs_pcor)(tdata), - naxes = permute(axes, perm); + let tdata = transpose(data); + const pcor = correlation.pearsonMatrix(tdata); + const abs_pcor = abs_matrix(pcor); + const h1 = hcluster().linkage('complete').distanceMatrix(abs_pcor)(tdata); + const perm = optimal_leaf_order().distanceMatrix(abs_pcor)(tdata); + const naxes = permute(axes, perm); tdata = permute(tdata, perm); - var signs = pcp_flip_axes(perm, naxes, pcor), + const signs = pcp_flip_axes(perm, naxes, pcor), ndata = transpose(tdata); return [ndata, perm, naxes, signs, pcor]; } @@ -88,16 +88,16 @@ export function pcp(data, axes) { export function parcoords(p) { p.detectDimensions().autoscale(); - var data = p.data(), - types = p.types(), - dimensions = p.dimensions(), - tdata = [], - row, - discarded = [], - i, - j, - k, - d; + const data = p.data(); + const types = p.types(); + let dimensions = p.dimensions(); + let tdata = []; + let row; + const discarded = []; + let i; + let j; + let k; + let d; for (i = 0; i < dimensions.length; i++) { d = dimensions[i]; @@ -116,14 +116,14 @@ export function parcoords(p) { i--; } } - var pcor = correlation.pearsonMatrix(tdata), + const pcor = correlation.pearsonMatrix(tdata), abs_pcor = abs_matrix(pcor), h1 = hcluster().linkage('complete').distanceMatrix(abs_pcor)(tdata), perm = optimal_leaf_order().distanceMatrix(abs_pcor)(tdata), naxes = permute(dimensions, perm); tdata = permute(tdata, perm); - var signs = pcp_flip_axes(perm, naxes, pcor); + const signs = pcp_flip_axes(perm, naxes, pcor); for (i = 0; i < signs.length; i++) { if (signs[i] < 0) p.flip(dimensions[i]); } diff --git a/src/permutation.js b/src/permutation.js index cd84457..f716c8b 100644 --- a/src/permutation.js +++ b/src/permutation.js @@ -3,8 +3,8 @@ import { range } from './range'; export const permutation = range; export function inverse_permutation(perm, dense) { - var inv = dense ? Array(perm.length) : {}; - for (var i = 0; i < perm.length; i++) { + const inv = dense ? Array(perm.length) : {}; + for (let i = 0; i < perm.length; i++) { inv[perm[i]] = i; } return inv; diff --git a/src/permute.js b/src/permute.js index eaf8850..3da1f23 100644 --- a/src/permute.js +++ b/src/permute.js @@ -1,12 +1,12 @@ export function permute(list, perm) { - var m = perm.length; - var copy = list.slice(); + let m = perm.length; + const copy = list.slice(); while (m--) copy[m] = list[perm[m]]; return copy; } export function permute_inplace(list, perm) { - var i, j, v, tmp; + let i, j, v, tmp; //list = list.slice(); for (i = 0; i < list.length; i++) { @@ -30,7 +30,7 @@ export function permute_inplace(list, perm) { } export function permutetranspose(array, indexes) { - var m = array.length; + let m = array.length; while (m-- > 0) array[m] = permute(array[m], indexes); return array; } diff --git a/src/poweriteration.js b/src/poweriteration.js index 1ce6383..d65c479 100644 --- a/src/poweriteration.js +++ b/src/poweriteration.js @@ -4,8 +4,8 @@ import { random_array } from './random'; import { debug } from './core'; function normalize(v) { - var norm = length(v), - i = v.length; + const norm = length(v); + let i = v.length; if (norm === 0 || Math.abs(norm - 1) < 1e-9) return 1; while (i-- > 0) v[i] /= norm; return norm; @@ -14,14 +14,14 @@ function normalize(v) { export function poweriteration(v, eps, init) { if (!eps) eps = 1e-9; - var n = v.length, - b, - i, - j, - tmp = Array(n), - norm, - s = 100, - e; + const n = v.length; + let b; + let i; + let j; + let tmp = Array(n); + let norm; + let s = 100; + let e; assert(n == v[0].length, 'poweriteration needs a square matrix'); if (!init) { @@ -35,7 +35,7 @@ export function poweriteration(v, eps, init) { } normalize(tmp); if (dot(tmp, b) > 1.0 - eps) break; - var t = tmp; + const t = tmp; tmp = b; b = t; // swap b/tmp } @@ -45,18 +45,18 @@ export function poweriteration(v, eps, init) { export function poweriteration_n(v, p, init, eps, start) { if (!eps) eps = 1e-9; - var n = v.length, - b = Array(p), - i, - j, - k, - l, - bk, - d, - row, - tmp = Array(n), - s = 100, - eigenvalue = Array(p); + const n = v.length; + const b = Array(p); + let i; + let j; + let k; + let l; + let bk; + let d; + let row; + let tmp = Array(n); + let s = 100; + const eigenvalue = Array(p); assert(n == v[0].length, 'poweriteration needs a square matrix'); if (!init) { diff --git a/src/random.js b/src/random.js index a99b3f9..849cc75 100644 --- a/src/random.js +++ b/src/random.js @@ -11,7 +11,7 @@ export function randomPermute(array, i, j) { i = 0; } } - var m = j - i, + let m = j - i, t, k; while (m > 0) { @@ -28,7 +28,7 @@ export function randomPermutation(n) { } export function random_array(n, min, max) { - var ret = Array(n); + const ret = Array(n); if (arguments.length == 1) { while (n) ret[--n] = Math.random(); } else if (arguments.length == 2) { @@ -43,10 +43,10 @@ export function random_matrix(p, n, m, sym) { if (!m) m = n; if (n != m) sym = false; else if (!sym) sym = true; - var mat = zeroes(n, m), - i, - j, - cnt; + const mat = zeroes(n, m); + let i; + let j; + let cnt; if (sym) { for (i = 0; i < n; i++) { diff --git a/src/range.js b/src/range.js index 0f20c2f..097185a 100644 --- a/src/range.js +++ b/src/range.js @@ -6,8 +6,8 @@ export function range(start, stop, step) { start = 0; } } - var range = [], - i = start; + const range = []; + let i = start; if (step < 0) for (; i > stop; i += step) range.push(i); else for (; i < stop; i += step) range.push(i); return range; diff --git a/src/sort_order.js b/src/sort_order.js index d15768a..63d7ce7 100644 --- a/src/sort_order.js +++ b/src/sort_order.js @@ -1,7 +1,7 @@ import { permutation } from './permutation'; export function sort_order(v) { - return permutation(0, v.length).sort(function (a, b) { + return permutation(0, v.length).sort((a, b) => { return v[a] - v[b]; }); } @@ -9,7 +9,7 @@ export function sort_order(v) { export const sort_order_ascending = sort_order; export function sort_order_descending(v) { - return permutation(0, v.length).sort(function (a, b) { + return permutation(0, v.length).sort((a, b) => { return v[b] - v[a]; }); } diff --git a/src/spectral_order.js b/src/spectral_order.js index 73a8a6c..cc5450a 100644 --- a/src/spectral_order.js +++ b/src/spectral_order.js @@ -4,7 +4,7 @@ import { sort_order } from './sort_order'; import { permute } from './permute'; export function spectral_order(graph, comps) { - var i, + let i, vec, comp, perm, diff --git a/src/stablepermute.js b/src/stablepermute.js index 16fd16a..11133bb 100644 --- a/src/stablepermute.js +++ b/src/stablepermute.js @@ -1,7 +1,7 @@ import { permute } from './permute'; export function stablepermute(list, indexes) { - var p = permute(list, indexes); + const p = permute(list, indexes); if (p[0] > p[p.length - 1]) { p.reverse(); } diff --git a/src/sum.js b/src/sum.js index aefe043..daa03b8 100644 --- a/src/sum.js +++ b/src/sum.js @@ -1,5 +1,5 @@ export function sum(v) { - var i = v.length, + let i = v.length, s = 0; while (i-- > 0) if (!isNaN(v[i])) s += v[i]; return s; diff --git a/src/transpose.js b/src/transpose.js index 956fd63..73af0e3 100644 --- a/src/transpose.js +++ b/src/transpose.js @@ -5,11 +5,11 @@ export function transposeSlice(a, start, end) { start = 0; } } - var m = a.length, - n = end, - i = start - 1, - j, - b = new Array(end - start); + const m = a.length; + const n = end; + let i = start - 1; + let j; + const b = new Array(end - start); while (++i < n) { b[i] = new Array(m); j = -1; diff --git a/src/utils.js b/src/utils.js index 7f2d5d3..cc7fa97 100644 --- a/src/utils.js +++ b/src/utils.js @@ -16,8 +16,8 @@ export function flatten(a, b) { // Constructs a multi-dimensional array filled with Infinity. export function infinities(n) { - var i = -1, - a = []; + let i = -1; + const a = []; if (arguments.length === 1) while (++i < n) a[i] = Infinity; else while (++i < n) @@ -26,19 +26,19 @@ export function infinities(n) { } export function array1d(n, v) { - var i = -1, - a = Array(n); + let i = -1; + const a = Array(n); while (++i < n) a[i] = v; return a; } export function check_distance_matrix(mat, tol) { - var i, - j, - v1, - v2, - n = mat.length, - row; + let i; + let j; + let v1; + let v2; + const n = mat.length; + let row; if (!tol) tol = 1e-10; if (n != mat[0].length) return 'Inconsistent dimensions'; @@ -46,44 +46,44 @@ export function check_distance_matrix(mat, tol) { for (i = 0; i < n - 1; i++) { row = mat[i]; v1 = row[i]; - if (v1 < 0) return 'Negative value at diagonal ' + i; - if (v1 > tol) return 'Diagonal not zero at ' + i; + if (v1 < 0) return `Negative value at diagonal ${i}`; + if (v1 > tol) return `Diagonal not zero at ${i}`; for (j = 1; j < n; j++) { v1 = row[j]; v2 = mat[j][i]; - if (Math.abs(v1 - v2) > tol) return 'Inconsistency at ' + i + ',' + j; - if (v1 < 0) return 'Negative value at ' + i + ',' + j; - if (v2 < 0) return 'Negative value at ' + j + ',' + i; + if (Math.abs(v1 - v2) > tol) return `Inconsistency at ${i},${j}`; + if (v1 < 0) return `Negative value at ${i},${j}`; + if (v2 < 0) return `Negative value at ${j},${i}`; } } return false; } export function fix_distance_matrix(mat, tol) { - var i, - j, - v1, - v2, - n = mat.length, - row; + let i; + let j; + let v1; + let v2; + const n = mat.length; + let row; if (!tol) tol = 1e-10; if (n != mat[0].length) - throw 'Inconsistent dimensions ' + n + ' != ' + mat[0].length; + throw `Inconsistent dimensions ${n} != ${mat[0].length}`; for (i = 0; i < n - 1; i++) { row = mat[i]; v1 = row[i]; if (v1 < 0) { - if (-v1 > tol) throw 'Negative value at diagonal' + i; + if (-v1 > tol) throw `Negative value at diagonal${i}`; v1 = row[i] = 0; } else if (v1 > tol) { - throw 'Diagonal not zero at ' + i; + throw `Diagonal not zero at ${i}`; } for (j = 1; j < n; j++) { v1 = row[j]; v2 = mat[j][i]; - if (Math.abs(v1 - v2) > tol) throw 'Inconsistency at ' + i + ',' + j; + if (Math.abs(v1 - v2) > tol) throw `Inconsistency at ${i},${j}`; if (v1 < 0) v1 = 0; if (v2 < 0) v2 = 0; if (v1 != v2) { diff --git a/test/all_pairs_distance-test.js b/test/all_pairs_distance-test.js index b8ac836..796a59e 100644 --- a/test/all_pairs_distance-test.js +++ b/test/all_pairs_distance-test.js @@ -1,12 +1,12 @@ -var reorder = require('../dist/reorder.cjs'); +const reorder = require('../dist/reorder.cjs'); -var vows = require('vows'), +const vows = require('vows'), assert = require('assert'); -var suite = vows.describe('reorder.all-pairs-distance'); +const suite = vows.describe('reorder.all-pairs-distance'); function dotest(graph) { - var mat = reorder.all_pairs_distance(graph), + const mat = reorder.all_pairs_distance(graph), bfs = reorder.all_pairs_distance_bfs(graph), n = graph.nodes().length; @@ -28,13 +28,13 @@ function dotest(graph) { suite.addBatch({ all_pairs_distance: { - simple: function () { - var nodes = [{ id: 0 }, { id: 1 }, { id: 2 }], + simple() { + const nodes = [{ id: 0 }, { id: 1 }, { id: 2 }], links = [ { source: 0, target: 1 }, { source: 1, target: 2 }, ]; - var graph = reorder.graph(nodes, links).init(), + const graph = reorder.graph(nodes, links).init(), mat = dotest(graph); assert.equal(mat[0].length, 3); @@ -44,11 +44,11 @@ suite.addBatch({ [2, 1, 0], ]); }, - hard: function () { + hard() { // compare results with Dijkstra distances // from a random node. - for (var i = 10; i < 100; i++) { - var graph = reorder.graph_connect(reorder.graph_random(i, 0.2)); + for (let i = 10; i < 100; i++) { + const graph = reorder.graph_connect(reorder.graph_random(i, 0.2)); dotest(graph); } }, diff --git a/test/barycenter-test.js b/test/barycenter-test.js index d7f58dc..1553a03 100644 --- a/test/barycenter-test.js +++ b/test/barycenter-test.js @@ -1,23 +1,23 @@ -var reorder = require('../dist/reorder.cjs'); +const reorder = require('../dist/reorder.cjs'); -var vows = require('vows'), +const vows = require('vows'), assert = require('assert'); -var suite = vows.describe('reorder.barycenter'); +const suite = vows.describe('reorder.barycenter'); function dotest(mat) { - var graph = reorder.mat2graph(mat, true); + const graph = reorder.mat2graph(mat, true); //reorder.displaymat(mat); - var initial_crossings = reorder.count_crossings(graph); - var perms = reorder.barycenter_order(graph); + const initial_crossings = reorder.count_crossings(graph); + const perms = reorder.barycenter_order(graph); // console.log('VOrder: %j, HOrder: %j, Crossings: %d', // perms[1], perms[0], perms[2]); // reorder.displaymat(mat, perms[1], perms[0]); assert.isTrue(initial_crossings > perms[2]); - var perms2 = reorder.adjacent_exchange(graph, perms[0], perms[1]); + const perms2 = reorder.adjacent_exchange(graph, perms[0], perms[1]); if (perms2[2]) { //reorder.displaymat(mat, perms2[1], perms2[0]); - var crossings = reorder.count_crossings(graph, perms2[0], perms2[1]); + const crossings = reorder.count_crossings(graph, perms2[0], perms2[1]); assert.equal(crossings, perms[2] - perms2[2]); // console.log('final crossings: %d, improved by %d (%d%) %d', // crossings, perms[2]-crossings, @@ -30,8 +30,8 @@ function dotest(mat) { suite.addBatch({ barycenter: { - simple: function () { - var mat = [ + simple() { + const mat = [ [0, 1, 0, 1, 0], [1, 0, 1, 0, 1], [0, 1, 0, 1, 1], @@ -39,10 +39,10 @@ suite.addBatch({ ]; dotest(mat); }, - hard: function () { - for (var i = 10; i < 100; i += 20) { - for (var j = 10; j < 100; j += 20) { - var mat = reorder.random_matrix(0.2, i, j, false); + hard() { + for (let i = 10; i < 100; i += 20) { + for (let j = 10; j < 100; j += 20) { + const mat = reorder.random_matrix(0.2, i, j, false); dotest(mat); } } diff --git a/test/bfs-test.js b/test/bfs-test.js index 5859dd3..3a2b77b 100644 --- a/test/bfs-test.js +++ b/test/bfs-test.js @@ -1,20 +1,20 @@ -var reorder = require('../dist/reorder.cjs'); +const reorder = require('../dist/reorder.cjs'); -var vows = require('vows'), +const vows = require('vows'), assert = require('assert'); -var suite = vows.describe('reorder.bfs'); +const suite = vows.describe('reorder.bfs'); suite.addBatch({ all_pairs_distance: { - simple: function () { - var nodes = [{ id: 0 }, { id: 1 }, { id: 2 }], + simple() { + const nodes = [{ id: 0 }, { id: 1 }, { id: 2 }], links = [ { source: 0, target: 1 }, { source: 1, target: 2 }, ]; - var graph = reorder.graph(nodes, links).init(); - var dist = reorder.bfs_distances(graph, 0); + const graph = reorder.graph(nodes, links).init(); + const dist = reorder.bfs_distances(graph, 0); //console.log('Dist: %j', dist); assert.equal(Object.keys(dist).length, 3); diff --git a/test/ca-test.js b/test/ca-test.js index b796f3a..9a3d4be 100644 --- a/test/ca-test.js +++ b/test/ca-test.js @@ -1,6 +1,6 @@ -var reorder = require('../dist/reorder.cjs'); +const reorder = require('../dist/reorder.cjs'); -var vows = require('vows'), +const vows = require('vows'), assert = require('assert'), seedrandom = require('seedrandom'), numeric = require('numeric'); @@ -8,11 +8,11 @@ require('./env-assert'); Math.seedrandom('reorder'); -var suite = vows.describe('reorder.ca'); +const suite = vows.describe('reorder.ca'); function compare_order(row_order1, row_order2, msg) { - var tmp = Array(row_order1.length), - i; + const tmp = Array(row_order1.length); + let i; assert.equal(row_order1.length, row_order2.length); for (i = 0; i < row_order1.length; i++) { if (Math.abs(row_order2) < 1e-9) tmp[i] = NaN; @@ -23,13 +23,13 @@ function compare_order(row_order1, row_order2, msg) { suite.addBatch({ ca: { - simple: function () { + simple() { // Ground truth with R, package "ca": // library(ca) // res=ca(mat) // erows = res$rowcoord[,1] // ecols = res$colcoord[,1] - var mat = [ + const mat = [ [1, 0, 0, 1, 1, 0, 0, 1], [0, 1, 1, 0, 0, 1, 0, 1], [1, 1, 0, 0, 0, 1, 1, 0], @@ -94,8 +94,8 @@ suite.addBatch({ // reorder.printmat(mat); // reorder.printmat(mat, col_order, row_order); // }, - harder: function () { - var mat = [ + harder() { + const mat = [ [45, 126, 24, 5], [87, 93, 19, 1], [0, 0, 52, 148], diff --git a/test/components-test.js b/test/components-test.js index 4b515cb..281f4c8 100644 --- a/test/components-test.js +++ b/test/components-test.js @@ -1,34 +1,34 @@ -var reorder = require('../dist/reorder.cjs'); +const reorder = require('../dist/reorder.cjs'); -var vows = require('vows'), +const vows = require('vows'), assert = require('assert'); -var suite = vows.describe('reorder.components'); +const suite = vows.describe('reorder.components'); suite.addBatch({ components: { - simple: function () { - var nodes = [{ id: 0 }, { id: 1 }, { id: 2 }], + simple() { + const nodes = [{ id: 0 }, { id: 1 }, { id: 2 }], links = [ { source: 0, target: 1 }, { source: 1, target: 2 }, ]; - var graph = reorder.graph().nodes(nodes).links(links).init(); + const graph = reorder.graph().nodes(nodes).links(links).init(); - var components = graph.components(); + const components = graph.components(); assert.equal(components.length, 1); assert.equal(components[0].length, 3); }, - lesssimple: function () { - var nodes = [{ id: 0 }, { id: 1 }, { id: 2 }, { id: 3 }, { id: 4 }], + lesssimple() { + const nodes = [{ id: 0 }, { id: 1 }, { id: 2 }, { id: 3 }, { id: 4 }], links = [ { source: 0, target: 1 }, { source: 1, target: 2 }, { source: 3, target: 4 }, ]; - var graph = reorder.graph().nodes(nodes).links(links).init(); + const graph = reorder.graph().nodes(nodes).links(links).init(); - var components = graph.components(); + const components = graph.components(); assert.equal(components.length, 2); assert.equal(components[0].length, 3); assert.equal(components[1].length, 2); diff --git a/test/count_crossings-test.js b/test/count_crossings-test.js index 4e29f5a..690896a 100644 --- a/test/count_crossings-test.js +++ b/test/count_crossings-test.js @@ -1,28 +1,28 @@ -var reorder = require('../dist/reorder.cjs'); +const reorder = require('../dist/reorder.cjs'); -var vows = require('vows'), +const vows = require('vows'), assert = require('assert'), seedrandom = require('seedrandom'); //var jf = require('jsonfile'); Math.seedrandom('reorder'); -var suite = vows.describe('reorder.count_crossings'); +const suite = vows.describe('reorder.count_crossings'); function naive_count_crossings(graph, north, south) { - var i, - j, - e1, - e2, - v, - count = 0, - inv_north = reorder.inverse_permutation(north), - inv_south = reorder.inverse_permutation(south), - links = []; + let i; + let j; + let e1; + let e2; + let v; + let count = 0; + const inv_north = reorder.inverse_permutation(north); + const inv_south = reorder.inverse_permutation(south); + let links = []; for (i = 0; i < north.length; i++) { v = north[i]; links = links.concat( - graph.outEdges(v).map(function (e) { + graph.outEdges(v).map((e) => { return [inv_north[e.target.index], inv_south[e.source.index]]; }) ); @@ -39,25 +39,25 @@ function naive_count_crossings(graph, north, south) { } function dotest(mat) { - var graph = reorder.mat2graph(mat, true), + const graph = reorder.mat2graph(mat, true), comps = graph.components(), - comp = comps.reduce(function (a, b) { + comp = comps.reduce((a, b) => { return a.length > b.length ? a : b; }); - comp.sort(function (a, b) { + comp.sort((a, b) => { return a - b; }); - var layer1 = comp.filter(function (n) { + const layer1 = comp.filter((n) => { return graph.outEdges(n).length != 0; }), - layer2 = comp.filter(function (n) { + layer2 = comp.filter((n) => { return graph.inEdges(n).length != 0; }); //console.time('fast_crossings'); - var c1 = reorder.count_crossings(graph, layer1, layer2); + const c1 = reorder.count_crossings(graph, layer1, layer2); //console.timeEnd('fast_crossings'); //console.time('naive_crossings'); - var c2 = naive_count_crossings(graph, layer1, layer2); + const c2 = naive_count_crossings(graph, layer1, layer2); //console.timeEnd('naive_crossings'); // if (c1 != c2) { // var file = 'error_count_crossings.json'; @@ -70,8 +70,8 @@ function dotest(mat) { suite.addBatch({ count_crossings: { - simple: function () { - var graph = reorder + simple() { + const graph = reorder .graph() .nodes([ { id: 0 }, @@ -97,17 +97,17 @@ suite.addBatch({ .directed(true) .init(), comp = graph.components()[0], - layer1 = comp.filter(function (n) { + layer1 = comp.filter((n) => { return graph.outEdges(n).length != 0; }), - layer2 = comp.filter(function (n) { + layer2 = comp.filter((n) => { return graph.inEdges(n).length != 0; }); assert.equal(naive_count_crossings(graph, layer1, layer2), 12); assert.equal(reorder.count_crossings(graph, layer1, layer2), 12); }, - bug: function () { + bug() { dotest([ [ 0, @@ -1071,10 +1071,10 @@ suite.addBatch({ ], ]); }, - hard: function () { - for (var i = 10; i < 100; i += 20) { - for (var j = 10; j < 100; j += 20) { - var mat = reorder.random_matrix(0.2, i, j, false); + hard() { + for (let i = 10; i < 100; i += 20) { + for (let j = 10; j < 100; j += 20) { + const mat = reorder.random_matrix(0.2, i, j, false); dotest(mat); } } diff --git a/test/cuthill_mckee-test.js b/test/cuthill_mckee-test.js index 1682d88..0bcbbcd 100644 --- a/test/cuthill_mckee-test.js +++ b/test/cuthill_mckee-test.js @@ -1,10 +1,10 @@ Queue = require('tiny-queue'); -var reorder = require('../dist/reorder.cjs'); +const reorder = require('../dist/reorder.cjs'); -var vows = require('vows'), +const vows = require('vows'), assert = require('assert'); -var suite = vows.describe('reorder.cuthill_mckee'); +const suite = vows.describe('reorder.cuthill_mckee'); function Pair(a, b) { return { source: a, target: b }; @@ -12,8 +12,8 @@ function Pair(a, b) { suite.addBatch({ cuthill_mckee: { - simple: function () { - var mat = [ + simple() { + const mat = [ [1, 0, 0, 0, 1, 0, 0, 0], [0, 1, 1, 0, 0, 1, 0, 1], [0, 1, 1, 0, 1, 0, 0, 0], @@ -24,17 +24,17 @@ suite.addBatch({ [0, 1, 0, 0, 0, 1, 0, 1], ]; //reorder.displaymat(mat); - var graph = reorder.mat2graph(mat); - var components = graph.components(); + const graph = reorder.mat2graph(mat); + const components = graph.components(); assert.equal(components.length, 2); assert.equal(reorder.bandwidth(graph), 6); - var order = reorder.reverse_cuthill_mckee_order(graph); + const order = reorder.reverse_cuthill_mckee_order(graph); //reorder.displaymat(mat, order, order); assert.deepEqual(order, [7, 5, 1, 2, 4, 0, 6, 3]); assert.equal(reorder.bandwidth(graph, order), 2); }, - boost: function () { - var graph = reorder + boost() { + const graph = reorder .graph() .generate_nodes(10) .links([ @@ -54,17 +54,17 @@ suite.addBatch({ Pair(6, 7), ]) //g-h .init(); - var components = graph.components(); + const components = graph.components(); assert.equal(components.length, 1); assert.equal(reorder.bandwidth(graph), 8); - var order = reorder.reverse_cuthill_mckee_order(graph); + const order = reorder.reverse_cuthill_mckee_order(graph); // Boost returns anoter order with the same bandwidth //assert.deepEqual(order, [0, 8, 5, 7, 3, 6, 4, 2, 1, 9]); assert.equal(reorder.bandwidth(graph, order), 4); }, - harder: function () { - for (var i = 10; i < 100; i += 20) { - var mat = reorder.random_matrix(0.2, i), + harder() { + for (let i = 10; i < 100; i += 20) { + const mat = reorder.random_matrix(0.2, i), graph = reorder.mat2graph(mat), bw = reorder.bandwidth(graph), order = reorder.reverse_cuthill_mckee_order(graph); diff --git a/test/env-assert.js b/test/env-assert.js index 60d15ad..ec997be 100644 --- a/test/env-assert.js +++ b/test/env-assert.js @@ -1,12 +1,11 @@ -var assert = require('assert'); +const assert = require('assert'); -assert.inDelta = function (actual, expected, delta, message) { +assert.inDelta = (actual, expected, delta, message) => { if (!inDelta(actual, expected, delta)) { assert.fail( actual, expected, - message || - 'expected {actual} to be in within *' + delta + '* of {expected}', + message || `expected {actual} to be in within *${delta}* of {expected}`, null, assert.inDelta ); @@ -22,8 +21,8 @@ function inDelta(actual, expected, delta) { } function inDeltaArray(actual, expected, delta) { - var n = expected.length, - i = -1; + const n = expected.length; + let i = -1; if (actual.length !== n) return false; while (++i < n) { if (Array.isArray(actual[i])) { @@ -36,34 +35,34 @@ function inDeltaArray(actual, expected, delta) { } function inDeltaNumber(actual, expected, delta) { - var d = Math.abs(actual - expected); + const d = Math.abs(actual - expected); return d < delta; } -assert.inDeltaArray = function (actual, expected, delta, message) { +assert.inDeltaArray = (actual, expected, delta, message) => { if (!inDeltaArray(actual, expected, delta)) assert.fail( actual, expected, - message || 'expected {actual} to equal to {expected} within ' + delta + message || `expected {actual} to equal to {expected} within ${delta}` ); return true; }; function inDeltaAbs(actual, expected, delta) { - var d = Math.abs(Math.abs(actual) - Math.abs(expected)); + const d = Math.abs(Math.abs(actual) - Math.abs(expected)); return d < delta; } -assert.inDeltaArrayAbs = function (actual, expected, delta, message) { - var n = expected.length, - i = -1; +assert.inDeltaArrayAbs = (actual, expected, delta, message) => { + const n = expected.length; + let i = -1; if (actual.length !== n) { assert.fail( actual, expected, message || - 'expected {actual} to have the same length *' + n + '* as {expected}', + `expected {actual} to have the same length *${n}* as {expected}`, null, assert.inDeltaArrayAbs ); @@ -73,8 +72,7 @@ assert.inDeltaArrayAbs = function (actual, expected, delta, message) { assert.fail( actual, expected, - message || - 'expected {actual} to be in within *' + delta + '* of {expected}', + message || `expected {actual} to be in within *${delta}* of {expected}`, null, assert.inDeltaArrayAbs ); @@ -82,12 +80,12 @@ assert.inDeltaArrayAbs = function (actual, expected, delta, message) { }; function neg(a) { - return a.map(function (x) { + return a.map((x) => { return -x; }); } -assert.inDeltaArrayOrNeg = function (actual, expected, delta, message) { +assert.inDeltaArrayOrNeg = (actual, expected, delta, message) => { if ( !inDeltaArray(actual, expected, delta) && !inDeltaArray(neg(actual), expected, delta) @@ -95,13 +93,13 @@ assert.inDeltaArrayOrNeg = function (actual, expected, delta, message) { assert.fail( actual, expected, - message || 'expected {actual} to equal to {expected} within ' + delta + message || `expected {actual} to equal to {expected} within ${delta}` ); return true; }; function permutationEqual(actual, expected) { - var n; + let n; if (!(Array.isArray(actual) && Array.isArray(expected))) return false; n = actual.length; if (n != expected.length) return false; @@ -110,7 +108,7 @@ function permutationEqual(actual, expected) { } function permutationInverted(actual, expected) { - var n, i; + let n, i; if (!(isArray(actual) && isArray(expected))) return false; n = actual.length; if (n != expected.length) return false; @@ -119,7 +117,7 @@ function permutationInverted(actual, expected) { return true; } -assert.permutationEqual = function (actual, expected, message) { +assert.permutationEqual = (actual, expected, message) => { if ( !permutationEqual(actual, expected) && !permutationInverted(actual, expected) diff --git a/test/graph-test.js b/test/graph-test.js index c93682b..a6c42ea 100644 --- a/test/graph-test.js +++ b/test/graph-test.js @@ -1,19 +1,19 @@ -var reorder = require('../dist/reorder.cjs'); +const reorder = require('../dist/reorder.cjs'); -var vows = require('vows'), +const vows = require('vows'), assert = require('assert'); -var suite = vows.describe('reorder.graph'); +const suite = vows.describe('reorder.graph'); suite.addBatch({ graph: { - simple: function () { - var nodes = [{ id: 0 }, { id: 1 }, { id: 2 }], + simple() { + const nodes = [{ id: 0 }, { id: 1 }, { id: 2 }], links = [ { source: 0, target: 1 }, { source: 1, target: 2 }, ]; - var graph = reorder.graph(nodes, links).init(); + const graph = reorder.graph(nodes, links).init(); assert.equal(graph.nodes().length, 3); assert.equal(graph.links().length, 2); diff --git a/test/graph2distmat-test.js b/test/graph2distmat-test.js index d2ac87e..90e53ee 100644 --- a/test/graph2distmat-test.js +++ b/test/graph2distmat-test.js @@ -1,16 +1,16 @@ -var reorder = require('../dist/reorder.cjs'); +const reorder = require('../dist/reorder.cjs'); -var vows = require('vows'), +const vows = require('vows'), assert = require('assert'); -var seedrandom = require('seedrandom'); +const seedrandom = require('seedrandom'); Math.seedrandom('reorder'); -var suite = vows.describe('reorder.graph2distmat'); +const suite = vows.describe('reorder.graph2distmat'); suite.addBatch({ graph2distmat: { - simple: function () { - var mat = [ + simple() { + const mat = [ [0, 1, 0], [1, 0, 1], [0, 1, 0], @@ -20,12 +20,12 @@ suite.addBatch({ [1, 0, 1], [2, 1, 0], ]; - var graph = reorder.mat2graph(mat); + const graph = reorder.mat2graph(mat); assert.equal(graph.nodes().length, 3); assert.equal(graph.links().length, 2); - var dists = reorder.all_pairs_distance(graph); + const dists = reorder.all_pairs_distance(graph); assert.deepEqual(dists[0], dist); - var valuemat = reorder.distmat2valuemat(dist); + const valuemat = reorder.distmat2valuemat(dist); assert.deepEqual(valuemat, [ [3, 2, 1], [2, 3, 2], diff --git a/test/graph2mat-test.js b/test/graph2mat-test.js index 4a55f74..9ce045f 100644 --- a/test/graph2mat-test.js +++ b/test/graph2mat-test.js @@ -1,18 +1,18 @@ -var reorder = require('../dist/reorder.cjs'); +const reorder = require('../dist/reorder.cjs'); -var vows = require('vows'), +const vows = require('vows'), assert = require('assert'); -var seedrandom = require('seedrandom'); +const seedrandom = require('seedrandom'); Math.seedrandom('reorder'); -var suite = vows.describe('reorder.graph2mat'); +const suite = vows.describe('reorder.graph2mat'); function remove_zeroes(mat) { - var i, j; + let i, j; for (i = mat.length - 1; i >= 0; i--) { - var row = mat[i]; + const row = mat[i]; if ( - row.some(function (a) { + row.some((a) => { return a > 0; }) ) { @@ -23,7 +23,7 @@ function remove_zeroes(mat) { } for (j = mat[0].length - 1; j >= 0; j--) { if ( - mat.some(function (row) { + mat.some((row) => { return row[j] != 0; }) ) { @@ -38,28 +38,28 @@ function remove_zeroes(mat) { suite.addBatch({ graph2mat: { - simple: function () { - var mat = [ + simple() { + const mat = [ [0, 1, 0], [1, 0, 1], [0, 1, 0], ]; - var graph = reorder.mat2graph(mat); + const graph = reorder.mat2graph(mat); assert.equal(graph.nodes().length, 3); assert.equal(graph.links().length, 2); - var m2 = reorder.graph2mat(graph); + const m2 = reorder.graph2mat(graph); assert.deepEqual(m2, mat); }, - lesssimple: function () { - var mat = reorder.random_matrix(0.2, 10), + lesssimple() { + const mat = reorder.random_matrix(0.2, 10), graph = reorder.mat2graph(mat), m2 = reorder.graph2mat(graph); assert.deepEqual(m2, mat); }, - hard: function () { - for (var i = 10; i < 100; i += 20) { - for (var j = 10; j < 100; j += 20) { - var mat = remove_zeroes(reorder.random_matrix(0.2, i, j, false)), + hard() { + for (let i = 10; i < 100; i += 20) { + for (let j = 10; j < 100; j += 20) { + const mat = remove_zeroes(reorder.random_matrix(0.2, i, j, false)), graph = reorder.mat2graph(mat, true), m2 = reorder.graph2mat(graph); assert.deepEqual(m2, mat); diff --git a/test/laplacian-test.js b/test/laplacian-test.js index 914c700..407ebf5 100644 --- a/test/laplacian-test.js +++ b/test/laplacian-test.js @@ -1,11 +1,11 @@ -var reorder = require('../dist/reorder.cjs'); +const reorder = require('../dist/reorder.cjs'); -var vows = require('vows'), +const vows = require('vows'), assert = require('assert'); -var suite = vows.describe('reorder.laplacian'); +const suite = vows.describe('reorder.laplacian'); -var eiffel_laplacian = [ +const eiffel_laplacian = [ [9, -5, 0, -4, 0], [-5, 17, -2, -7, -3], [0, -2, 4, -2, 0], @@ -15,9 +15,9 @@ var eiffel_laplacian = [ suite.addBatch({ laplacian: { - simple: function () { + simple() { // Eiffel Tower Graph from the ACE article - var graph = reorder + const graph = reorder .graph() .generate_nodes(5) .links([ @@ -35,8 +35,8 @@ suite.addBatch({ eiffel_laplacian ); }, - fiedler: function () { - var f = reorder.fiedler_vector(eiffel_laplacian); + fiedler() { + const f = reorder.fiedler_vector(eiffel_laplacian); assert.inDeltaArrayOrNeg( f, diff --git a/test/leaforder-test.js b/test/leaforder-test.js index 7202aab..0ede325 100644 --- a/test/leaforder-test.js +++ b/test/leaforder-test.js @@ -1,28 +1,28 @@ -var reorder = require('../dist/reorder.cjs'); +const reorder = require('../dist/reorder.cjs'); -var vows = require('vows'), +const vows = require('vows'), assert = require('assert'); -var suite = vows.describe('reorder.optimal_leaf_order'); +const suite = vows.describe('reorder.optimal_leaf_order'); function eucl(a, b) { - var x = b - a; + const x = b - a; return x * x; } function remove_equal_dist(dm) { - var i, - j, - v, - row, - values = {}; + let i; + let j; + let v; + let row; + const values = {}; for (i = 0; i < dm.length; i++) { row = dm[i]; for (j = i + 1; j < dm.length; j++) { v = row[j]; if (values[v]) { - console.log('Duplicate dist ' + v + ' at [' + i + ',' + j + ']'); + console.log(`Duplicate dist ${v} at [${i},${j}]`); v += Math.random() / 1000; row[j] = v; dm[j][i] = v; @@ -47,35 +47,35 @@ function clusterEqual(h1, h2) { suite.addBatch({ leaforder: { - simple: function () { - var data = [2, 1, 4, 3], + simple() { + const data = [2, 1, 4, 3], expect = [1, 2, 3, 4]; - var x = reorder.optimal_leaf_order().distance(eucl)(data); + let x = reorder.optimal_leaf_order().distance(eucl)(data); assert.deepEqual(reorder.stablepermute(data, x), expect); x = reorder.optimal_leaf_order()(expect); assert.deepEqual(reorder.stablepermute(expect, x), expect); }, - lesssimple: function () { - var prev = 0, - data = [prev], - next; - for (var i = 0; i < 30; i++) { + lesssimple() { + let prev = 0; + const data = [prev]; + let next; + for (let i = 0; i < 30; i++) { next = Math.random() + prev; data.push(next); prev = next; } - var randata = reorder.randomPermute(data.slice()); - var x = reorder.optimal_leaf_order().distance(eucl)(randata); + const randata = reorder.randomPermute(data.slice()); + const x = reorder.optimal_leaf_order().distance(eucl)(randata); assert.deepEqual(reorder.stablepermute(randata.slice(), x), data); }, - evenharder: function () { - var rows = 30, - cols = 20, - array = [], - i, - j, - row; + evenharder() { + const rows = 30; + const cols = 20; + const array = []; + let i; + let j; + let row; for (i = 0; i < rows; i++) { row = []; @@ -84,34 +84,36 @@ suite.addBatch({ row.push(Math.random()); } } - var order = reorder.optimal_leaf_order(), - perm = order(array); + const order = reorder.optimal_leaf_order(); + let perm = order(array); // Check determinism for (i = 0; i < 3; i++) { - var p2 = order(array); + const p2 = order(array); assert.deepEqual(perm, p2); } // Disambiguate distance matrix to have a // deterministic hcluster - var dm = reorder.dist()(array); + let dm = reorder.dist()(array); remove_equal_dist(dm); //reorder.printmat(dm); - var h1 = reorder.hcluster().linkage('complete').distanceMatrix(dm)(array); + const h1 = reorder.hcluster().linkage('complete').distanceMatrix(dm)( + array + ); perm = reorder.optimal_leaf_order().distanceMatrix(dm)(array); - var a2 = reorder.permute(array, perm), + const a2 = reorder.permute(array, perm), d2 = reorder.dist()(a2); dm = reorder.permute(dm, perm); dm = reorder.permutetranspose(dm, perm); assert.deepEqual(d2, dm); - var h2 = reorder.hcluster().linkage('complete').distanceMatrix(d2)(a2); + const h2 = reorder.hcluster().linkage('complete').distanceMatrix(d2)(a2); assert.isTrue(clusterEqual(h1, h2), 'Clusters are not equal'); - var p3 = order.distanceMatrix(d2)(a2); + const p3 = order.distanceMatrix(d2)(a2); assert.deepEqual(p3, reorder.range(0, p3.length)); }, diff --git a/test/mat2graph-test.js b/test/mat2graph-test.js index 4d89834..4695c20 100644 --- a/test/mat2graph-test.js +++ b/test/mat2graph-test.js @@ -1,33 +1,33 @@ -var reorder = require('../dist/reorder.cjs'); +const reorder = require('../dist/reorder.cjs'); -var vows = require('vows'), +const vows = require('vows'), assert = require('assert'); -var suite = vows.describe('reorder.mat2graph'); +const suite = vows.describe('reorder.mat2graph'); suite.addBatch({ mat2graph: { - simple: function () { - var mat = [ + simple() { + const mat = [ [0, 1, 0], [1, 0, 1], [0, 1, 0], ]; - var graph = reorder.mat2graph(mat); + const graph = reorder.mat2graph(mat); assert.equal(graph.nodes().length, 3); assert.equal(graph.links().length, 2); }, - lesssimple: function () { - var mat = [ + lesssimple() { + const mat = [ [0, 1, 0, 1, 0], [1, 0, 1, 0, 1], [0, 1, 0, 1, 1], [1, 1, 1, 0, 0], ]; - var graph = reorder.mat2graph(mat, true); // directed graph + const graph = reorder.mat2graph(mat, true); // directed graph assert.equal(graph.nodes().length, 5); assert.equal(graph.links().length, 11); - var m2 = reorder.graph2mat(graph); + const m2 = reorder.graph2mat(graph); assert.deepEqual(m2, mat); }, }, diff --git a/test/order-test.js b/test/order-test.js index 6c93368..b951172 100644 --- a/test/order-test.js +++ b/test/order-test.js @@ -1,16 +1,16 @@ -var reorder = require('../dist/reorder.cjs'); -var seedrandom = require('seedrandom'); +const reorder = require('../dist/reorder.cjs'); +const seedrandom = require('seedrandom'); -var vows = require('vows'), +const vows = require('vows'), assert = require('assert'); -var suite = vows.describe('reorder.order'); +const suite = vows.describe('reorder.order'); Math.seedrandom('reorder'); -assert.ORdeepEqual = function (actual, expected_list) { - for (var i = 0; i < expected_list.length; i++) { - var expected = expected_list[i]; +assert.ORdeepEqual = (actual, expected_list) => { + for (let i = 0; i < expected_list.length; i++) { + const expected = expected_list[i]; if (deepEqual(actual, expected)) { assert.ok(actual, 'Assert OK'); return true; @@ -21,7 +21,7 @@ assert.ORdeepEqual = function (actual, expected_list) { }; function eucl(a, b) { - var x = b - a; + const x = b - a; return x * x; } @@ -30,10 +30,10 @@ function fortytwo(a) { } function lesssimple() { - var prefix = reorder.range(0, 10), - suffix; + const prefix = reorder.range(0, 10); + let suffix; - var prev = 10, + let prev = 10, data = [prev], next, i, @@ -49,15 +49,15 @@ function lesssimple() { j = i + data.length; data = prefix.concat(data).concat(suffix); //console.log("Original : "+data); - var randata = reorder.randomPermute(data.slice(0), i, j); + const randata = reorder.randomPermute(data.slice(0), i, j); //console.log("Shuffled : "+randata); - var x = reorder.order().distance(eucl).limits(i, j)(randata); + const x = reorder.order().distance(eucl).limits(i, j)(randata); //console.log("Permutation: "+randata); assert.deepEqual(reorder.stablepermute(randata, x), data); } function insert_simple(v, i, j) { - var x = reorder.order().distance(eucl).except([i, j])(v); + const x = reorder.order().distance(eucl).except([i, j])(v); assert.deepEqual( reorder.stablepermute(v, x), reorder.range(42, 42 + v.length) @@ -65,18 +65,18 @@ function insert_simple(v, i, j) { } function insert_lesssimple() { - var plen = Math.round(Math.random() * 20), + const plen = Math.round(Math.random() * 20), mlen = Math.round(Math.random() * 20) + 2, slen = Math.round(Math.random() * 20), cut = Math.round(Math.random() * (plen + slen)); - var prefix = reorder.range(42, 42 + plen), - middle = reorder.range(42 + plen, 42 + plen + mlen), - suffix = reorder.range(42 + plen + mlen, 42 + plen + mlen + slen), - shuffled = reorder.randomPermute(prefix.concat(suffix)); + const prefix = reorder.range(42, 42 + plen); + const middle = reorder.range(42 + plen, 42 + plen + mlen); + const suffix = reorder.range(42 + plen + mlen, 42 + plen + mlen + slen); + let shuffled = reorder.randomPermute(prefix.concat(suffix)); shuffled = shuffled.slice(0, cut).concat(middle).concat(shuffled.slice(cut)); //console.log("i="+cut+", j="+(cut+middle.length)); - var x = reorder + const x = reorder .order() .distance(eucl) .except([cut, cut + middle.length])(shuffled); @@ -88,9 +88,9 @@ function insert_lesssimple() { suite.addBatch({ order: { - simple: function () { - var data = [-1, -2, 0, 2, 1, 4, 3, 10, 11, 12]; - var x = reorder.order().distance(eucl).limits(3, 7)(data); + simple() { + const data = [-1, -2, 0, 2, 1, 4, 3, 10, 11, 12]; + const x = reorder.order().distance(eucl).limits(3, 7)(data); assert.deepEqual(reorder.stablepermute(data, x), [ -1, -2, @@ -104,19 +104,19 @@ suite.addBatch({ 12, ]); }, - lesssimple: lesssimple, - evenharder: function () { + lesssimple, + evenharder() { for (n = 10; n-- > 0; ) lesssimple(); }, 'equiv-simple': function () { - var data = [0, 1, 2, 2, 2, 2, 3, 4, 4, 4, 5, 5, 6].map(fortytwo), + const data = [0, 1, 2, 2, 2, 2, 3, 4, 4, 4, 5, 5, 6].map(fortytwo), shuffled = reorder.randomPermute(data.slice(0)); - var x = reorder.order().distance(eucl)(shuffled); + const x = reorder.order().distance(eucl)(shuffled); assert.deepEqual(reorder.stablepermute(shuffled, x), data); }, 'equiv-simple2': function () { - var data = [ + const data = [ [1, 1, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 1, 1, 1], [0, 0, 0, 0, 0, 0, 1, 1, 0], @@ -125,7 +125,7 @@ suite.addBatch({ [0, 0, 1, 1, 1, 1, 0, 0, 0], ]; - var x = reorder + const x = reorder .order() // .distance(reorder.distance.manhattan) .linkage('single')(data); @@ -157,13 +157,13 @@ suite.addBatch({ }, */ 'insert-simple': function () { - var prefix = [0, 1, 2, 3].map(fortytwo), - middle = [4, 5, 6, 7, 8].map(fortytwo), - suffix = [9, 10, 11, 12].map(fortytwo), - shuffled = reorder.randomPermute(prefix.concat(suffix)); + const prefix = [0, 1, 2, 3].map(fortytwo); + const middle = [4, 5, 6, 7, 8].map(fortytwo); + const suffix = [9, 10, 11, 12].map(fortytwo); + let shuffled = reorder.randomPermute(prefix.concat(suffix)); shuffled = shuffled.slice(0, 5).concat(middle).concat(shuffled.slice(5)); - var x = reorder + const x = reorder .order() .distance(eucl) .except([5, 5 + middle.length])(shuffled); @@ -257,7 +257,7 @@ suite.addBatch({ ); }, 'insert-3': function () { - var data = [ + const data = [ [1, 1, 0], [0, 0, 1], [1, 1, 0], @@ -270,7 +270,7 @@ suite.addBatch({ [0, 1, 1], [0, 0, 1], ]; - var x = reorder.order().limits(1, 10).except([5, 10])(data); + const x = reorder.order().limits(1, 10).except([5, 10])(data); // Since several rows are identical, there are multiple // possible correct orderings assert.ORdeepEqual(x, [ @@ -281,7 +281,7 @@ suite.addBatch({ ]); }, 'insert-4': function () { - var data = [ + const data = [ [1, 1, 0], [0, 0, 1], [1, 1, 0], @@ -294,13 +294,13 @@ suite.addBatch({ [0, 1, 1], [0, 0, 1], ]; - var x = reorder.order().limits(1, 11).except([3, 8])(data); + const x = reorder.order().limits(1, 11).except([3, 8])(data); // Since several rows are identical, there are multiple // possible correct orderings assert.deepEqual(x, [0, 8, 2, 3, 4, 5, 6, 7, 10, 1, 9]); }, 'insert-5': function () { - var data = [ + const data = [ [NaN, NaN, NaN], [1, 1, 0], [0, 0, 1], @@ -314,13 +314,13 @@ suite.addBatch({ [0, 1, 0], [0, 1, 0], ]; - var x = reorder.order().limits(1, 12).except([2, 4, 7, 12])(data); + const x = reorder.order().limits(1, 12).except([2, 4, 7, 12])(data); // Since several rows are identical, there are multiple // possible correct orderings // assert.deepEqual(x, [0, 8, 2, 3, 4, 5, 6, 7, 10, 1, 9]); }, 'insert-6': function () { - var data = [ + const data = [ [1, 1, 0], [0, 0, 1], [1, 1, 0], @@ -333,13 +333,13 @@ suite.addBatch({ [0, 1, 1], [0, 0, 1], ]; - var x = reorder.order().limits(1, 11).except([1, 6])(data); + const x = reorder.order().limits(1, 11).except([1, 6])(data); // Since several rows are identical, there are multiple // possible correct orderings // assert.deepEqual(x, [0, 8, 2, 3, 4, 5, 6, 7, 10, 1, 9]); }, 'insert-7': function () { - var data = [ + const data = [ [0, 0, 1], [1, 1, 0], [1, 1, 0], @@ -351,14 +351,14 @@ suite.addBatch({ [0, 1, 1], [0, 0, 1], ]; - var x = reorder.order().limits(1, 10).except([5, 9])(data); + const x = reorder.order().limits(1, 10).except([5, 9])(data); // Since several rows are identical, there are multiple // possible correct orderings // assert.deepEqual(x, [0, 8, 2, 3, 4, 5, 6, 7, 10, 1, 9]); }, 'insert-lesssimple': insert_lesssimple, 'insert-evenharder': function () { - for (var i = 0; i < 20; i++) { + for (let i = 0; i < 20; i++) { //console.log("Loop "+i); insert_lesssimple(); } @@ -430,13 +430,13 @@ function objEquiv(a, b) { } function toNum(a) { - return a.map(function (l) { + return a.map((l) => { return l.charCodeAt(0) - 97; }); } function toLetter(a) { - return a.map(function (l) { + return a.map((l) => { return String.fromCharCode(97 + l); }); } diff --git a/test/pca1d-test.js b/test/pca1d-test.js index 98f13bb..4d3cbd6 100644 --- a/test/pca1d-test.js +++ b/test/pca1d-test.js @@ -1,14 +1,14 @@ -var reorder = require('../dist/reorder.cjs'); +const reorder = require('../dist/reorder.cjs'); -var vows = require('vows'), +const vows = require('vows'), assert = require('assert'); -var suite = vows.describe('reorder.pca1d'); +const suite = vows.describe('reorder.pca1d'); suite.addBatch({ pca1d: { - simple: function () { - var mat = [ + simple() { + const mat = [ [2.5, 2.4], [0.5, 0.7], [2.2, 2.9], @@ -26,8 +26,8 @@ suite.addBatch({ assert.deepEqual(reorder.sort_order(pca), [0, 1]); }, - lesssimple: function () { - var data = [ + lesssimple() { + const data = [ [80, 27, 89, 42], [80, 27, 88, 37], [75, 25, 90, 37], diff --git a/test/pcp-test.js b/test/pcp-test.js index 11828bb..ac6103f 100644 --- a/test/pcp-test.js +++ b/test/pcp-test.js @@ -1,20 +1,20 @@ -var reorder = require('../dist/reorder.cjs'); +const reorder = require('../dist/reorder.cjs'); -var vows = require('vows'), +const vows = require('vows'), assert = require('assert'); -var suite = vows.describe('reorder.pcp'); +const suite = vows.describe('reorder.pcp'); suite.addBatch({ pcp: { - simple: function () { - var earray = [ + simple() { + const earray = [ [0, 1, 2], [3, 4, 5], ], dicts = reorder.array_to_dicts(earray); assert.equal(dicts.length, earray.length); - var array = reorder.dicts_to_array(dicts); + const array = reorder.dicts_to_array(dicts); assert.deepEqual(earray, array); }, }, diff --git a/test/pearson-test.js b/test/pearson-test.js index 0aa6a41..bfe7aff 100644 --- a/test/pearson-test.js +++ b/test/pearson-test.js @@ -1,20 +1,20 @@ -var reorder = require('../dist/reorder.cjs'); +const reorder = require('../dist/reorder.cjs'); -var vows = require('vows'), +const vows = require('vows'), assert = require('assert'); -var suite = vows.describe('reorder.pearson'); +const suite = vows.describe('reorder.pearson'); suite.addBatch({ pearson: { - simple: function () { - var a = [1, 2, 3, 4, 5], + simple() { + const a = [1, 2, 3, 4, 5], b = [5, 4, 3, 2, 1]; assert.equal(reorder.correlation.pearson(a, b), -1); }, - harder: function () { - var a = [ + harder() { + const a = [ 0.38906616, 0.5773394, 0.17349286, @@ -43,8 +43,8 @@ suite.addBatch({ //console.log('y = '+y+', e='+e); assert.inDelta(y, e, 0.00001); }, - hard: function () { - var X = [ + hard() { + const X = [ [0.6813319, 0.90478228, 0.11681552, 0.2879309, 0.91980914], [0.86943635, 0.63710069, 0.3685353, 0.39660358, 0.58182883], [0.7097419, 0.25265316, 0.2377928, 0.1065309, 0.00203621], diff --git a/test/permute-test.js b/test/permute-test.js index 54903ca..3c681a0 100644 --- a/test/permute-test.js +++ b/test/permute-test.js @@ -1,39 +1,39 @@ Queue = require('tiny-queue'); -var reorder = require('../dist/reorder.cjs'); +const reorder = require('../dist/reorder.cjs'); -var vows = require('vows'), +const vows = require('vows'), assert = require('assert'); -var suite = vows.describe('reorder.permute'); +const suite = vows.describe('reorder.permute'); suite.addBatch({ permute: { - simple1: function () { + simple1() { assert.deepEqual(reorder.permute([0], [0]), [0]); }, - simple2: function () { + simple2() { assert.deepEqual(reorder.permute([0, 1], [0, 1]), [0, 1]); }, - simple3: function () { + simple3() { assert.deepEqual(reorder.permute([1, 0], [0, 1]), [1, 0]); }, - simple4: function () { + simple4() { assert.deepEqual(reorder.permute([0, 1], [1, 0]), [1, 0]); }, - simple5: function () { + simple5() { assert.deepEqual(reorder.permute([0, 1, 2], [1, 2, 0]), [1, 2, 0]); }, - harder: function () { - for (var i = 10; i <= 100; i += 10) { - var list = reorder.permutation(i), + harder() { + for (let i = 10; i <= 100; i += 10) { + const list = reorder.permutation(i), perm = reorder.randomPermute(list.slice()); assert.deepEqual(perm, reorder.permute(list, perm)); } }, - hard: function () { - for (var i = 10; i <= 100; i++) { - var list = reorder.permutation(i), + hard() { + for (let i = 10; i <= 100; i++) { + const list = reorder.permutation(i), perm = reorder.randomPermute(list.slice()), permc = perm.slice(), inv = reorder.inverse_permutation(perm, true);