From 7a935ac8b32c71bc6d845e6769f6284e477faad9 Mon Sep 17 00:00:00 2001 From: Curran Kelleher Date: Thu, 31 Dec 2020 08:38:16 -0500 Subject: [PATCH] Prettier on tests as well --- package.json | 2 +- test/all_pairs_distance-test.js | 95 +-- test/barycenter-test.js | 86 +-- test/bfs-test.js | 40 +- test/ca-test.js | 219 +++--- test/components-test.js | 66 +- test/count_crossings-test.js | 1189 +++++++++++++++++++++++++++---- test/cuthill_mckee-test.js | 130 ++-- test/env-assert.js | 154 ++-- test/graph-test.js | 40 +- test/graph2distmat-test.js | 85 +-- test/graph2mat-test.js | 109 +-- test/laplacian-test.js | 80 ++- test/leaforder-test.js | 205 +++--- test/mat2graph-test.js | 58 +- test/order-test.js | 613 +++++++++------- test/pca1d-test.js | 109 ++- test/pcp-test.js | 31 +- test/pearson-test.js | 96 ++- test/permute-test.js | 84 ++- 20 files changed, 2297 insertions(+), 1194 deletions(-) diff --git a/package.json b/package.json index aef67d8..591e11f 100644 --- a/package.json +++ b/package.json @@ -29,7 +29,7 @@ "pretest": "npm run build", "test": "vows --nocolor; echo", "clean": "rm -rf node_modules", - "prettier": "prettier --single-quote --write 'src/**/*.js'" + "prettier": "prettier --single-quote --write '{src,test}/**/*.js'" }, "files": [ "dist" diff --git a/test/all_pairs_distance-test.js b/test/all_pairs_distance-test.js index 8b3a587..b8ac836 100644 --- a/test/all_pairs_distance-test.js +++ b/test/all_pairs_distance-test.js @@ -1,57 +1,58 @@ -var reorder = require("../dist/reorder.cjs"); +var reorder = require('../dist/reorder.cjs'); +var vows = require('vows'), + assert = require('assert'); -var vows = require("vows"), - assert = require("assert"); - -var suite = vows.describe("reorder.all-pairs-distance"); +var suite = vows.describe('reorder.all-pairs-distance'); function dotest(graph) { - var mat = reorder.all_pairs_distance(graph), - bfs = reorder.all_pairs_distance_bfs(graph), - n = graph.nodes().length; - - assert.equal(mat.length, 1); // 1 component - assert.deepEqual(mat[0], bfs); - - // var dn = reorder.floyd_warshall_with_path(graph), - // dist = dn[0], - // next = dn[1]; - // assert.deepEqual(mat[0], dist); - // for (var i = 0; i < n-1; i++) { - // for (var j = i+1; j < n; j++) { - // assert.equal(dist[i][j], - // reorder.floyd_warshall_path(next, i, j).length-1); - // } - // } - return mat; + var mat = reorder.all_pairs_distance(graph), + bfs = reorder.all_pairs_distance_bfs(graph), + n = graph.nodes().length; + + assert.equal(mat.length, 1); // 1 component + assert.deepEqual(mat[0], bfs); + + // var dn = reorder.floyd_warshall_with_path(graph), + // dist = dn[0], + // next = dn[1]; + // assert.deepEqual(mat[0], dist); + // for (var i = 0; i < n-1; i++) { + // for (var j = i+1; j < n; j++) { + // assert.equal(dist[i][j], + // reorder.floyd_warshall_path(next, i, j).length-1); + // } + // } + return mat; } suite.addBatch({ - "all_pairs_distance": { - "simple": function() { - var nodes = [{id: 0}, {id: 1}, {id: 2}], - links = [{source: 0, target: 1}, {source:1, target: 2}]; - var graph = reorder.graph(nodes, links) - .init(), - mat = dotest(graph); - - assert.equal(mat[0].length, 3); - assert.deepEqual(mat[0], [[0, 1, 2], - [1, 0, 1], - [2, 1, 0]]); - }, - "hard": function() { - // 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)); - dotest(graph); - } - } - } + all_pairs_distance: { + simple: function () { + var nodes = [{ id: 0 }, { id: 1 }, { id: 2 }], + links = [ + { source: 0, target: 1 }, + { source: 1, target: 2 }, + ]; + var graph = reorder.graph(nodes, links).init(), + mat = dotest(graph); + + assert.equal(mat[0].length, 3); + assert.deepEqual(mat[0], [ + [0, 1, 2], + [1, 0, 1], + [2, 1, 0], + ]); + }, + hard: function () { + // 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)); + dotest(graph); + } + }, + }, }); suite.export(module); - diff --git a/test/barycenter-test.js b/test/barycenter-test.js index d004e3e..d7f58dc 100644 --- a/test/barycenter-test.js +++ b/test/barycenter-test.js @@ -1,53 +1,53 @@ -var reorder = require("../dist/reorder.cjs"); +var reorder = require('../dist/reorder.cjs'); -var vows = require("vows"), - assert = require("assert"); +var vows = require('vows'), + assert = require('assert'); -var suite = vows.describe("reorder.barycenter"); +var suite = vows.describe('reorder.barycenter'); function dotest(mat) { - var graph = reorder.mat2graph(mat, true); - //reorder.displaymat(mat); - var initial_crossings = reorder.count_crossings(graph); - var 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]); - if (perms2[2]) { - //reorder.displaymat(mat, perms2[1], perms2[0]); - var 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, - // Math.round((perms[2]-crossings)*100.0/perms[2]), - // perms2[2]); - // console.log('VOrder: %j, HOrder: %j', perms2[1], perms2[0]); - assert.isTrue(crossings < perms[2]); - } + var graph = reorder.mat2graph(mat, true); + //reorder.displaymat(mat); + var initial_crossings = reorder.count_crossings(graph); + var 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]); + if (perms2[2]) { + //reorder.displaymat(mat, perms2[1], perms2[0]); + var 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, + // Math.round((perms[2]-crossings)*100.0/perms[2]), + // perms2[2]); + // console.log('VOrder: %j, HOrder: %j', perms2[1], perms2[0]); + assert.isTrue(crossings < perms[2]); + } } suite.addBatch({ - "barycenter": { - "simple": function() { - var mat = [ - [0, 1, 0, 1, 0], - [1, 0, 1, 0, 1], - [0, 1, 0, 1, 1], - [1, 1, 1, 0, 0]]; - 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); - dotest(mat); - } - } - } - } + barycenter: { + simple: function () { + var mat = [ + [0, 1, 0, 1, 0], + [1, 0, 1, 0, 1], + [0, 1, 0, 1, 1], + [1, 1, 1, 0, 0], + ]; + 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); + dotest(mat); + } + } + }, + }, }); suite.export(module); diff --git a/test/bfs-test.js b/test/bfs-test.js index b62a9c3..5859dd3 100644 --- a/test/bfs-test.js +++ b/test/bfs-test.js @@ -1,28 +1,28 @@ -var reorder = require("../dist/reorder.cjs"); +var reorder = require('../dist/reorder.cjs'); +var vows = require('vows'), + assert = require('assert'); -var vows = require("vows"), - assert = require("assert"); - -var suite = vows.describe("reorder.bfs"); +var suite = vows.describe('reorder.bfs'); suite.addBatch({ - "all_pairs_distance": { - "simple": function() { - var 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); - //console.log('Dist: %j', dist); + all_pairs_distance: { + simple: function () { + var 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); + //console.log('Dist: %j', dist); - assert.equal(Object.keys(dist).length, 3); - assert.equal(dist[0], 0); - assert.equal(dist[1], 1); - assert.equal(dist[2], 2); - } - } + assert.equal(Object.keys(dist).length, 3); + assert.equal(dist[0], 0); + assert.equal(dist[1], 1); + assert.equal(dist[2], 2); + }, + }, }); suite.export(module); - diff --git a/test/ca-test.js b/test/ca-test.js index 475a8b6..b796f3a 100644 --- a/test/ca-test.js +++ b/test/ca-test.js @@ -1,115 +1,132 @@ -var reorder = require("../dist/reorder.cjs"); +var reorder = require('../dist/reorder.cjs'); -var vows = require("vows"), - assert = require("assert"), - seedrandom = require('seedrandom'), - numeric = require('numeric'); -require("./env-assert"); +var vows = require('vows'), + assert = require('assert'), + seedrandom = require('seedrandom'), + numeric = require('numeric'); +require('./env-assert'); Math.seedrandom('reorder'); -var suite = vows.describe("reorder.ca"); +var suite = vows.describe('reorder.ca'); function compare_order(row_order1, row_order2, msg) { - var tmp = Array(row_order1.length), 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; - else - tmp[i] = row_order1[i] / row_order2[i]; - } - reorder.printvec(tmp, 2, null, msg); + var tmp = Array(row_order1.length), + 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; + else tmp[i] = row_order1[i] / row_order2[i]; + } + reorder.printvec(tmp, 2, null, msg); } suite.addBatch({ - "ca": { - "simple": function() { - // Ground truth with R, package "ca": - // library(ca) - // res=ca(mat) - // erows = res$rowcoord[,1] - // ecols = res$colcoord[,1] - var 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], - [1, 1, 1, 1, 1, 0, 0, 1], - [1, 1, 0, 1, 0, 0, 0, 1], - [1, 0, 0, 0, 1, 0, 0, 0] - ], - res = reorder.ca_order(mat), - row_order = res.rows, - col_order = res.cols, - erows = reorder.sort_order( - [-1.044914, 0.970130, 1.675125, -0.439146, -0.321923, -1.239397] - ), - ecols = reorder.sort_order( - [-0.396887, 0.682180, 0.384491, -0.871822, -1.314724, 1.915459, 2.425954, -0.302626] - ); + ca: { + simple: function () { + // Ground truth with R, package "ca": + // library(ca) + // res=ca(mat) + // erows = res$rowcoord[,1] + // ecols = res$colcoord[,1] + var 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], + [1, 1, 1, 1, 1, 0, 0, 1], + [1, 1, 0, 1, 0, 0, 0, 1], + [1, 0, 0, 0, 1, 0, 0, 0], + ], + res = reorder.ca_order(mat), + row_order = res.rows, + col_order = res.cols, + erows = reorder.sort_order([ + -1.044914, + 0.97013, + 1.675125, + -0.439146, + -0.321923, + -1.239397, + ]), + ecols = reorder.sort_order([ + -0.396887, + 0.68218, + 0.384491, + -0.871822, + -1.314724, + 1.915459, + 2.425954, + -0.302626, + ]); - assert.permutationEqual(row_order, erows); - assert.permutationEqual(col_order, ecols); - }, - // "harder": function() { - // var mat = [ - // [1, 0, 0, 1, 0], - // [0, 1, 1, 0, 1], - // [1, 0, 0, 1, 0], - // [1, 1, 0, 0, 0], - // [0, 1, 1, 0, 1] - // ], - // res = reorder.ca_order(mat), - // col_order = res.cols, - // row_order = res.rows; - // console.log('col_order: '+col_order); - // console.log('row_order: '+row_order); - // reorder.displaymat(mat); - // reorder.displaymat(mat, col_order, row_order); - // }, - // "bertin": function() { - // var mat = [ - // [6, 6, 2, 5, 3], - // [32, 6, 5, 45, 15], - // [37, 61, 69, 29, 59], - // [16, 23, 21, 9, 14], - // [9, 4, 3, 12, 9] - // ], - // res = reorder.ca(mat), - // col_order = reorder.sort_order(res[0]), - // row_order = reorder.sort_order(res[1]); - // console.log('col_order: '+col_order); - // console.log('row_order: '+row_order); - // reorder.printmat(mat); - // reorder.printmat(mat, col_order, row_order); - // }, - "harder": function() { - var mat = [ - [45,126,24,5], - [87,93,19,1], - [0,0,52,148], - [36,68,74,22], - [0,30,111,59] - ], - res = reorder.ca_order(mat), - col_order = res.cols, - row_order = res.rows, - erows = reorder.sort_order( - [-0.9283350, -1.1010641, 1.5381971, -0.2229937, 0.7141957] - ), - ecols = reorder.sort_order( - [-1.1276880, -0.8747596, 0.4626773, 1.4348968] - ); + assert.permutationEqual(row_order, erows); + assert.permutationEqual(col_order, ecols); + }, + // "harder": function() { + // var mat = [ + // [1, 0, 0, 1, 0], + // [0, 1, 1, 0, 1], + // [1, 0, 0, 1, 0], + // [1, 1, 0, 0, 0], + // [0, 1, 1, 0, 1] + // ], + // res = reorder.ca_order(mat), + // col_order = res.cols, + // row_order = res.rows; + // console.log('col_order: '+col_order); + // console.log('row_order: '+row_order); + // reorder.displaymat(mat); + // reorder.displaymat(mat, col_order, row_order); + // }, + // "bertin": function() { + // var mat = [ + // [6, 6, 2, 5, 3], + // [32, 6, 5, 45, 15], + // [37, 61, 69, 29, 59], + // [16, 23, 21, 9, 14], + // [9, 4, 3, 12, 9] + // ], + // res = reorder.ca(mat), + // col_order = reorder.sort_order(res[0]), + // row_order = reorder.sort_order(res[1]); + // console.log('col_order: '+col_order); + // console.log('row_order: '+row_order); + // reorder.printmat(mat); + // reorder.printmat(mat, col_order, row_order); + // }, + harder: function () { + var mat = [ + [45, 126, 24, 5], + [87, 93, 19, 1], + [0, 0, 52, 148], + [36, 68, 74, 22], + [0, 30, 111, 59], + ], + res = reorder.ca_order(mat), + col_order = res.cols, + row_order = res.rows, + erows = reorder.sort_order([ + -0.928335, + -1.1010641, + 1.5381971, + -0.2229937, + 0.7141957, + ]), + ecols = reorder.sort_order([ + -1.127688, + -0.8747596, + 0.4626773, + 1.4348968, + ]); - assert.permutationEqual(row_order, erows); - assert.permutationEqual(col_order, ecols); - // console.log('col_order: '+col_order); - // console.log('row_order: '+row_order); - // reorder.printmat(mat); - // reorder.printmat(mat, col_order, row_order); - } - } + assert.permutationEqual(row_order, erows); + assert.permutationEqual(col_order, ecols); + // console.log('col_order: '+col_order); + // console.log('row_order: '+row_order); + // reorder.printmat(mat); + // reorder.printmat(mat, col_order, row_order); + }, + }, }); suite.export(module); - diff --git a/test/components-test.js b/test/components-test.js index 76e4bba..4b515cb 100644 --- a/test/components-test.js +++ b/test/components-test.js @@ -1,41 +1,39 @@ -var reorder = require("../dist/reorder.cjs"); +var reorder = require('../dist/reorder.cjs'); -var vows = require("vows"), - assert = require("assert"); +var vows = require('vows'), + assert = require('assert'); -var suite = vows.describe("reorder.components"); +var suite = vows.describe('reorder.components'); suite.addBatch({ - "components": { - "simple": function() { - var 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(); - - var 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}], - links = [ - {source: 0, target: 1}, {source:1, target: 2}, - {source: 3, target: 4} - ]; - var graph = reorder.graph() - .nodes(nodes) - .links(links) - .init(); - - var components = graph.components(); - assert.equal(components.length, 2); - assert.equal(components[0].length, 3); - assert.equal(components[1].length, 2); - } - } + components: { + simple: function () { + var 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(); + + var 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 }], + links = [ + { source: 0, target: 1 }, + { source: 1, target: 2 }, + { source: 3, target: 4 }, + ]; + var graph = reorder.graph().nodes(nodes).links(links).init(); + + var components = graph.components(); + assert.equal(components.length, 2); + assert.equal(components[0].length, 3); + assert.equal(components[1].length, 2); + }, + }, }); suite.export(module); diff --git a/test/count_crossings-test.js b/test/count_crossings-test.js index 7832b66..4e29f5a 100644 --- a/test/count_crossings-test.js +++ b/test/count_crossings-test.js @@ -1,140 +1,1085 @@ -var reorder = require("../dist/reorder.cjs"); +var reorder = require('../dist/reorder.cjs'); -var vows = require("vows"), - assert = require("assert"), - seedrandom = require('seedrandom'); +var vows = require('vows'), + assert = require('assert'), + seedrandom = require('seedrandom'); //var jf = require('jsonfile'); Math.seedrandom('reorder'); -var suite = vows.describe("reorder.count_crossings"); +var 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 = []; - for (i = 0; i < north.length; i++) { - v = north[i]; - links = links.concat(graph.outEdges(v).map(function(e) { - return [ inv_north[e.target.index], inv_south[e.source.index] ]; - })); + var i, + j, + e1, + e2, + v, + count = 0, + inv_north = reorder.inverse_permutation(north), + inv_south = reorder.inverse_permutation(south), + links = []; + for (i = 0; i < north.length; i++) { + v = north[i]; + links = links.concat( + graph.outEdges(v).map(function (e) { + return [inv_north[e.target.index], inv_south[e.source.index]]; + }) + ); + } + for (i = 0; i < links.length; i++) { + e1 = links[i]; + for (j = i + 1; j < links.length; j++) { + e2 = links[j]; + if ((e1[0] < e2[0] && e1[1] > e2[1]) || (e1[0] > e2[0] && e1[1] < e2[1])) + count++; } - for (i = 0; i < links.length; i++) { - e1 = links[i]; - for (j = i+1; j < links.length; j++) { - e2 = links[j]; - if ((e1[0] < e2[0] && e1[1] > e2[1]) - || (e1[0] > e2[0] && e1[1] < e2[1])) - count++; - } - } - return count; + } + return count; } function dotest(mat) { - var graph = reorder.mat2graph(mat, true), - comps = graph.components(), - comp = comps.reduce(function(a, b) { - return (a.length > b.length) ? a : b; - }); - comp.sort(function(a,b){return a-b; }); - var layer1 = comp.filter(function(n) { - return graph.outEdges(n).length!=0; + var graph = reorder.mat2graph(mat, true), + comps = graph.components(), + comp = comps.reduce(function (a, b) { + return a.length > b.length ? a : b; + }); + comp.sort(function (a, b) { + return a - b; + }); + var layer1 = comp.filter(function (n) { + return graph.outEdges(n).length != 0; }), - layer2 = comp.filter(function(n) { - return graph.inEdges(n).length!=0; - }); - //console.time('fast_crossings'); - var c1 = reorder.count_crossings(graph, layer1, layer2); - //console.timeEnd('fast_crossings'); - //console.time('naive_crossings'); - var c2 = naive_count_crossings(graph, layer1, layer2); - //console.timeEnd('naive_crossings'); - // if (c1 != c2) { - // var file = 'error_count_crossings.json'; - // jf.writeFile(file, mat, function(err) { - // console.log(err); - // }); - // } - assert.equal(c1, c2); + layer2 = comp.filter(function (n) { + return graph.inEdges(n).length != 0; + }); + //console.time('fast_crossings'); + var c1 = reorder.count_crossings(graph, layer1, layer2); + //console.timeEnd('fast_crossings'); + //console.time('naive_crossings'); + var c2 = naive_count_crossings(graph, layer1, layer2); + //console.timeEnd('naive_crossings'); + // if (c1 != c2) { + // var file = 'error_count_crossings.json'; + // jf.writeFile(file, mat, function(err) { + // console.log(err); + // }); + // } + assert.equal(c1, c2); } suite.addBatch({ - "count_crossings": { - "simple": function() { - var graph = reorder.graph() - .nodes([{id: 0}, {id: 1}, {id: 2}, {id: 3}, {id: 4}, {id: 5}]) - .links([{source: 0, target: 0}, - {source: 1, target: 1}, - {source: 1, target: 2}, - {source: 2, target: 0}, - {source: 2, target: 3}, - {source: 2, target: 4}, - {source: 3, target: 0}, - {source: 3, target: 2}, - {source: 4, target: 3}, - {source: 5, target: 2}, - {source: 5, target: 4}]) - .directed(true) - .init(), - comp = graph.components()[0], - layer1 = comp.filter(function(n) { - return graph.outEdges(n).length!=0; - }), - layer2 = comp.filter(function(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() { - dotest([ - [0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0], - [0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], - [0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1], - [1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1], - [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0], - [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], - [0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], - [1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0], - [0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0], - [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1], - [0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1], - [0, 0, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0], - [0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], - [0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 1], - [0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0], - [0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], - [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0], - [0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1], - [1, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], - [0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], - [0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0], - [0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], - [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0], - [1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0], - [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], - [0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 1], - [0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0], - [1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0], - [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0], - [0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0] - ]); - }, - "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); - dotest(mat); - } - } - } - } + count_crossings: { + simple: function () { + var graph = reorder + .graph() + .nodes([ + { id: 0 }, + { id: 1 }, + { id: 2 }, + { id: 3 }, + { id: 4 }, + { id: 5 }, + ]) + .links([ + { source: 0, target: 0 }, + { source: 1, target: 1 }, + { source: 1, target: 2 }, + { source: 2, target: 0 }, + { source: 2, target: 3 }, + { source: 2, target: 4 }, + { source: 3, target: 0 }, + { source: 3, target: 2 }, + { source: 4, target: 3 }, + { source: 5, target: 2 }, + { source: 5, target: 4 }, + ]) + .directed(true) + .init(), + comp = graph.components()[0], + layer1 = comp.filter(function (n) { + return graph.outEdges(n).length != 0; + }), + layer2 = comp.filter(function (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 () { + dotest([ + [ + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + ], + [ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + ], + [ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + ], + [ + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + ], + [ + 1, + 1, + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + ], + [ + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + ], + [ + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + ], + [ + 0, + 0, + 1, + 1, + 1, + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + ], + [ + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + ], + [ + 0, + 0, + 1, + 0, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + ], + [ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + ], + [ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + ], + [ + 1, + 0, + 0, + 1, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + ], + [ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 0, + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + ], + [ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + ], + [ + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 0, + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 1, + 1, + ], + [ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + ], + [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 0, + 1, + 0, + ], + [ + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + ], + ]); + }, + 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); + dotest(mat); + } + } + }, + }, }); suite.export(module); diff --git a/test/cuthill_mckee-test.js b/test/cuthill_mckee-test.js index 0b39a2e..1682d88 100644 --- a/test/cuthill_mckee-test.js +++ b/test/cuthill_mckee-test.js @@ -1,71 +1,77 @@ Queue = require('tiny-queue'); -var reorder = require("../dist/reorder.cjs"); +var reorder = require('../dist/reorder.cjs'); -var vows = require("vows"), - assert = require("assert"); +var vows = require('vows'), + assert = require('assert'); -var suite = vows.describe("reorder.cuthill_mckee"); +var suite = vows.describe('reorder.cuthill_mckee'); -function Pair(a,b) { return {source:a, target:b}; } +function Pair(a, b) { + return { source: a, target: b }; +} suite.addBatch({ - "cuthill_mckee": { - "simple": function() { - var 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], - [0, 0, 0, 1, 0, 0, 1, 0], - [1, 0, 1, 0, 1, 0, 0, 0], - [0, 1, 0, 0, 0, 1, 0, 1], - [0, 0, 0, 1, 0, 0, 1, 0], - [0, 1, 0, 0, 0, 1, 0, 1]]; - //reorder.displaymat(mat); - var graph = reorder.mat2graph(mat); - var components = graph.components(); - assert.equal(components.length, 2); - assert.equal(reorder.bandwidth(graph), 6); - var 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.graph() - .generate_nodes(10) - .links([Pair(0,3), //a-d - Pair(0,5), //a-f - Pair(1,2), //b-c - Pair(1,4), //b-e - Pair(1,6), //b-g - Pair(1,9), //b-j - Pair(2,3), //c-d - Pair(2,4), //c-e - Pair(3,5), //d-f - Pair(3,8), //d-i - Pair(4,6), //e-g - Pair(5,6), //f-g - Pair(5,7), //f-h - Pair(6,7)]) //g-h - .init(); - var components = graph.components(); - assert.equal(components.length, 1); - assert.equal(reorder.bandwidth(graph), 8); - var 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), - graph = reorder.mat2graph(mat), - bw = reorder.bandwidth(graph), - order = reorder.reverse_cuthill_mckee_order(graph); - assert.lesser(reorder.bandwidth(graph, order), bw); - } - } - } + cuthill_mckee: { + simple: function () { + var 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], + [0, 0, 0, 1, 0, 0, 1, 0], + [1, 0, 1, 0, 1, 0, 0, 0], + [0, 1, 0, 0, 0, 1, 0, 1], + [0, 0, 0, 1, 0, 0, 1, 0], + [0, 1, 0, 0, 0, 1, 0, 1], + ]; + //reorder.displaymat(mat); + var graph = reorder.mat2graph(mat); + var components = graph.components(); + assert.equal(components.length, 2); + assert.equal(reorder.bandwidth(graph), 6); + var 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 + .graph() + .generate_nodes(10) + .links([ + Pair(0, 3), //a-d + Pair(0, 5), //a-f + Pair(1, 2), //b-c + Pair(1, 4), //b-e + Pair(1, 6), //b-g + Pair(1, 9), //b-j + Pair(2, 3), //c-d + Pair(2, 4), //c-e + Pair(3, 5), //d-f + Pair(3, 8), //d-i + Pair(4, 6), //e-g + Pair(5, 6), //f-g + Pair(5, 7), //f-h + Pair(6, 7), + ]) //g-h + .init(); + var components = graph.components(); + assert.equal(components.length, 1); + assert.equal(reorder.bandwidth(graph), 8); + var 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), + graph = reorder.mat2graph(mat), + bw = reorder.bandwidth(graph), + order = reorder.reverse_cuthill_mckee_order(graph); + assert.lesser(reorder.bandwidth(graph, order), bw); + } + }, + }, }); suite.export(module); diff --git a/test/env-assert.js b/test/env-assert.js index b1a7f68..60d15ad 100644 --- a/test/env-assert.js +++ b/test/env-assert.js @@ -1,99 +1,133 @@ -var assert = require("assert"); +var assert = require('assert'); -assert.inDelta = function(actual, expected, delta, message) { +assert.inDelta = function (actual, expected, delta, message) { if (!inDelta(actual, expected, delta)) { - assert.fail(actual, expected, message || "expected {actual} to be in within *" + delta + "* of {expected}", null, assert.inDelta); + assert.fail( + actual, + expected, + message || + 'expected {actual} to be in within *' + delta + '* of {expected}', + null, + assert.inDelta + ); } }; function inDelta(actual, expected, delta) { - return (Array.isArray(expected) ? inDeltaArray : inDeltaNumber)(actual, expected, delta); + return (Array.isArray(expected) ? inDeltaArray : inDeltaNumber)( + actual, + expected, + delta + ); } function inDeltaArray(actual, expected, delta) { - var n = expected.length, i = -1; + var n = expected.length, + i = -1; if (actual.length !== n) return false; while (++i < n) { - if (Array.isArray(actual[i])) { - if (! inDeltaArray(actual[i], expected[i], delta)) return false; - } - else { - if (!inDeltaNumber(actual[i], expected[i], delta)) return false; - } + if (Array.isArray(actual[i])) { + if (!inDeltaArray(actual[i], expected[i], delta)) return false; + } else { + if (!inDeltaNumber(actual[i], expected[i], delta)) return false; + } } return true; } function inDeltaNumber(actual, expected, delta) { - var d = Math.abs(actual-expected); - return d < delta; -} - - -assert.inDeltaArray = function(actual, expected, delta, message) { - if (! inDeltaArray(actual, expected, delta)) - assert.fail(actual, expected, message || "expected {actual} to equal to {expected} within "+delta); - return true; + var d = Math.abs(actual - expected); + return d < delta; } +assert.inDeltaArray = function (actual, expected, delta, message) { + if (!inDeltaArray(actual, expected, delta)) + assert.fail( + actual, + expected, + 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)); - return d < delta; + var 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 = function (actual, expected, delta, message) { + var n = expected.length, + i = -1; if (actual.length !== n) { - assert.fail(actual, expected, message || "expected {actual} to have the same length *" + n + "* as {expected}", null, assert.inDeltaArrayAbs); + assert.fail( + actual, + expected, + message || + 'expected {actual} to have the same length *' + n + '* as {expected}', + null, + assert.inDeltaArrayAbs + ); } while (++i < n) - if (!inDeltaAbs(actual[i], expected[i], delta)) - assert.fail(actual, expected, message || "expected {actual} to be in within *" + delta + "* of {expected}", null, assert.inDeltaArrayAbs); + if (!inDeltaAbs(actual[i], expected[i], delta)) + assert.fail( + actual, + expected, + message || + 'expected {actual} to be in within *' + delta + '* of {expected}', + null, + assert.inDeltaArrayAbs + ); return true; }; function neg(a) { - return a.map(function(x) { return -x; }); + return a.map(function (x) { + return -x; + }); } -assert.inDeltaArrayOrNeg = function(actual, expected, delta, message) { - if (! inDeltaArray(actual, expected, delta) && - ! inDeltaArray(neg(actual), expected, delta)) - assert.fail(actual, expected, message || "expected {actual} to equal to {expected} within "+delta); - return true; +assert.inDeltaArrayOrNeg = function (actual, expected, delta, message) { + if ( + !inDeltaArray(actual, expected, delta) && + !inDeltaArray(neg(actual), expected, delta) + ) + assert.fail( + actual, + expected, + message || 'expected {actual} to equal to {expected} within ' + delta + ); + return true; }; function permutationEqual(actual, expected) { - var n; - if (! (Array.isArray(actual) && Array.isArray(expected))) - return false; - n = actual.length; - if (n != expected.length) - return false; - while(n--) - if (actual[n] != expected[n]) - return false; - return true; + var n; + if (!(Array.isArray(actual) && Array.isArray(expected))) return false; + n = actual.length; + if (n != expected.length) return false; + while (n--) if (actual[n] != expected[n]) return false; + return true; } function permutationInverted(actual, expected) { - var n, i; - if (! (isArray(actual) && isArray(expected))) - return false; - n = actual.length; - if (n != expected.length) - return false; - i = n-1; - while(n--) - if (actual[n] != expected[i-n]) - return false; - return true; + var n, i; + if (!(isArray(actual) && isArray(expected))) return false; + n = actual.length; + if (n != expected.length) return false; + i = n - 1; + while (n--) if (actual[n] != expected[i - n]) return false; + return true; } -assert.permutationEqual = function(actual, expected, message) { - if (! permutationEqual(actual, expected) && - ! permutationInverted(actual, expected)) - assert.fail(actual, expected, message || "expected {actual} to be equal or inverse of {expected}"); - return true; -} +assert.permutationEqual = function (actual, expected, message) { + if ( + !permutationEqual(actual, expected) && + !permutationInverted(actual, expected) + ) + assert.fail( + actual, + expected, + message || 'expected {actual} to be equal or inverse of {expected}' + ); + return true; +}; diff --git a/test/graph-test.js b/test/graph-test.js index 422e22a..c93682b 100644 --- a/test/graph-test.js +++ b/test/graph-test.js @@ -1,26 +1,28 @@ -var reorder = require("../dist/reorder.cjs"); +var reorder = require('../dist/reorder.cjs'); -var vows = require("vows"), - assert = require("assert"); +var vows = require('vows'), + assert = require('assert'); -var suite = vows.describe("reorder.graph"); +var suite = vows.describe('reorder.graph'); suite.addBatch({ - "graph": { - "simple": function() { - var nodes = [{id: 0}, {id: 1}, {id: 2}], - links = [{source: 0, target: 1}, {source:1, target: 2}]; - var graph = reorder.graph(nodes, links) - .init(); - assert.equal(graph.nodes().length, 3); - assert.equal(graph.links().length, 2); - - assert.deepEqual(graph.edges(0), [links[0]]); - assert.deepEqual(graph.neighbors(0), [nodes[1]]); - assert.deepEqual(graph.neighbors(1), [nodes[0], nodes[2]]); - assert.deepEqual(graph.neighbors(2), [nodes[1]]); - } - } + graph: { + simple: function () { + var nodes = [{ id: 0 }, { id: 1 }, { id: 2 }], + links = [ + { source: 0, target: 1 }, + { source: 1, target: 2 }, + ]; + var graph = reorder.graph(nodes, links).init(); + assert.equal(graph.nodes().length, 3); + assert.equal(graph.links().length, 2); + + assert.deepEqual(graph.edges(0), [links[0]]); + assert.deepEqual(graph.neighbors(0), [nodes[1]]); + assert.deepEqual(graph.neighbors(1), [nodes[0], nodes[2]]); + assert.deepEqual(graph.neighbors(2), [nodes[1]]); + }, + }, }); suite.export(module); diff --git a/test/graph2distmat-test.js b/test/graph2distmat-test.js index f411d48..d2ac87e 100644 --- a/test/graph2distmat-test.js +++ b/test/graph2distmat-test.js @@ -1,51 +1,52 @@ -var reorder = require("../dist/reorder.cjs"); +var reorder = require('../dist/reorder.cjs'); -var vows = require("vows"), - assert = require("assert"); +var vows = require('vows'), + assert = require('assert'); var seedrandom = require('seedrandom'); Math.seedrandom('reorder'); -var suite = vows.describe("reorder.graph2distmat"); +var suite = vows.describe('reorder.graph2distmat'); suite.addBatch({ - "graph2distmat": { - "simple": function() { - var mat = [ - [0, 1, 0], - [1, 0, 1], - [0, 1, 0] - ], - dist = [ - [0, 1, 2], - [1, 0, 1], - [2, 1, 0] - ]; - var graph = reorder.mat2graph(mat); - assert.equal(graph.nodes().length, 3); - assert.equal(graph.links().length, 2); - var dists = reorder.all_pairs_distance(graph); - assert.deepEqual(dists[0], dist); - var valuemat = reorder.distmat2valuemat(dist); - assert.deepEqual(valuemat, - [[3, 2, 1], - [2, 3, 2], - [1, 2, 3]]); - // var max_link = graph.links().reduce( - // function(a, b) { - // return a.value > b.value ? a : b; - // }), - // max_value = max_link ? max_link.value : 0; - // var links = graph.links() - // .map(function(l) { - // return { - // value: (max_value - l.value)/max_value, - // source: l.source.index, - // target: l.target.index - // }; - // }); - // console.log(links); - } - } + graph2distmat: { + simple: function () { + var mat = [ + [0, 1, 0], + [1, 0, 1], + [0, 1, 0], + ], + dist = [ + [0, 1, 2], + [1, 0, 1], + [2, 1, 0], + ]; + var graph = reorder.mat2graph(mat); + assert.equal(graph.nodes().length, 3); + assert.equal(graph.links().length, 2); + var dists = reorder.all_pairs_distance(graph); + assert.deepEqual(dists[0], dist); + var valuemat = reorder.distmat2valuemat(dist); + assert.deepEqual(valuemat, [ + [3, 2, 1], + [2, 3, 2], + [1, 2, 3], + ]); + // var max_link = graph.links().reduce( + // function(a, b) { + // return a.value > b.value ? a : b; + // }), + // max_value = max_link ? max_link.value : 0; + // var links = graph.links() + // .map(function(l) { + // return { + // value: (max_value - l.value)/max_value, + // source: l.source.index, + // target: l.target.index + // }; + // }); + // console.log(links); + }, + }, }); suite.export(module); diff --git a/test/graph2mat-test.js b/test/graph2mat-test.js index c5578a2..4a55f74 100644 --- a/test/graph2mat-test.js +++ b/test/graph2mat-test.js @@ -1,67 +1,72 @@ -var reorder = require("../dist/reorder.cjs"); +var reorder = require('../dist/reorder.cjs'); -var vows = require("vows"), - assert = require("assert"); +var vows = require('vows'), + assert = require('assert'); var seedrandom = require('seedrandom'); Math.seedrandom('reorder'); -var suite = vows.describe("reorder.graph2mat"); +var suite = vows.describe('reorder.graph2mat'); function remove_zeroes(mat) { - var i, j; - for (i = mat.length-1; i >= 0; i--) { - var row = mat[i]; - if (row.some(function(a) { return a > 0; })) { - //console.log('remove row %d', i); - break; - } - mat.pop(); + var i, j; + for (i = mat.length - 1; i >= 0; i--) { + var row = mat[i]; + if ( + row.some(function (a) { + return a > 0; + }) + ) { + //console.log('remove row %d', i); + break; } - for (j = mat[0].length-1; j >= 0; j--) { - if (mat.some(function(row) { - return row[j] != 0; - })) { - //console.log('remove column %d', j); - break; - } - for (i = 0; i < mat.length; i++) - mat[i].pop(); + mat.pop(); + } + for (j = mat[0].length - 1; j >= 0; j--) { + if ( + mat.some(function (row) { + return row[j] != 0; + }) + ) { + //console.log('remove column %d', j); + break; } + for (i = 0; i < mat.length; i++) mat[i].pop(); + } - return mat; + return mat; } suite.addBatch({ - "graph2mat": { - "simple": function() { - var mat = [ - [0, 1, 0], - [1, 0, 1], - [0, 1, 0] - ]; - var graph = reorder.mat2graph(mat); - assert.equal(graph.nodes().length, 3); - assert.equal(graph.links().length, 2); - var m2 = reorder.graph2mat(graph); - assert.deepEqual(m2, mat); - }, - "lesssimple": function() { - var 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)), - graph = reorder.mat2graph(mat, true), - m2 = reorder.graph2mat(graph); - assert.deepEqual(m2, mat); - } - } - } - } + graph2mat: { + simple: function () { + var mat = [ + [0, 1, 0], + [1, 0, 1], + [0, 1, 0], + ]; + var graph = reorder.mat2graph(mat); + assert.equal(graph.nodes().length, 3); + assert.equal(graph.links().length, 2); + var m2 = reorder.graph2mat(graph); + assert.deepEqual(m2, mat); + }, + lesssimple: function () { + var 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)), + graph = reorder.mat2graph(mat, true), + m2 = reorder.graph2mat(graph); + assert.deepEqual(m2, mat); + } + } + }, + }, }); suite.export(module); diff --git a/test/laplacian-test.js b/test/laplacian-test.js index 3701bcb..914c700 100644 --- a/test/laplacian-test.js +++ b/test/laplacian-test.js @@ -1,46 +1,50 @@ -var reorder = require("../dist/reorder.cjs"); +var reorder = require('../dist/reorder.cjs'); -var vows = require("vows"), - assert = require("assert"); +var vows = require('vows'), + assert = require('assert'); -var suite = vows.describe("reorder.laplacian"); +var suite = vows.describe('reorder.laplacian'); -var eiffel_laplacian = [[ 9, -5, 0, -4, 0], - [-5, 17, -2, -7, -3], - [ 0, -2, 4, -2, 0], - [-4, -7, -2, 19, -6], - [ 0, -3, 0, -6, 9] - ]; +var eiffel_laplacian = [ + [9, -5, 0, -4, 0], + [-5, 17, -2, -7, -3], + [0, -2, 4, -2, 0], + [-4, -7, -2, 19, -6], + [0, -3, 0, -6, 9], +]; suite.addBatch({ - "laplacian": { - "simple": function() { - // Eiffel Tower Graph from the ACE article - var graph = reorder.graph() - .generate_nodes(5) - .links( - [{source: 0, target: 1, value: 5}, - {source: 0, target: 3, value: 4}, - {source: 1, target: 2, value: 2}, - {source: 1, target: 3, value: 7}, - {source: 1, target: 4, value: 3}, - {source: 2, target: 3, value: 2}, - {source: 3, target: 4, value: 6} - ]) - .init(); - assert.deepEqual(reorder.laplacian(graph, [0, 1, 2, 3, 4]), - eiffel_laplacian); - }, - "fiedler": function() { - var f = reorder.fiedler_vector(eiffel_laplacian); - - assert.inDeltaArrayOrNeg(f, - [0.2947, 0.1354, -0.8835, 0.1513, 0.3021], - 0.001); - } - } + laplacian: { + simple: function () { + // Eiffel Tower Graph from the ACE article + var graph = reorder + .graph() + .generate_nodes(5) + .links([ + { source: 0, target: 1, value: 5 }, + { source: 0, target: 3, value: 4 }, + { source: 1, target: 2, value: 2 }, + { source: 1, target: 3, value: 7 }, + { source: 1, target: 4, value: 3 }, + { source: 2, target: 3, value: 2 }, + { source: 3, target: 4, value: 6 }, + ]) + .init(); + assert.deepEqual( + reorder.laplacian(graph, [0, 1, 2, 3, 4]), + eiffel_laplacian + ); + }, + fiedler: function () { + var f = reorder.fiedler_vector(eiffel_laplacian); + + assert.inDeltaArrayOrNeg( + f, + [0.2947, 0.1354, -0.8835, 0.1513, 0.3021], + 0.001 + ); + }, + }, }); - suite.export(module); - diff --git a/test/leaforder-test.js b/test/leaforder-test.js index b285377..7202aab 100644 --- a/test/leaforder-test.js +++ b/test/leaforder-test.js @@ -1,116 +1,121 @@ -var reorder = require("../dist/reorder.cjs"); +var reorder = require('../dist/reorder.cjs'); -var vows = require("vows"), - assert = require("assert"); +var vows = require('vows'), + assert = require('assert'); -var suite = vows.describe("reorder.optimal_leaf_order"); +var suite = vows.describe('reorder.optimal_leaf_order'); function eucl(a, b) { - var x = b - a; - return x*x; -}; + var x = b - a; + return x * x; +} function remove_equal_dist(dm) { - var i, j, v, row, 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+"]"); - v += Math.random() / 1000; - row[j] = v; - dm[j][i] = v; - } - values[v] = true; - } + var i, + j, + v, + row, + 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 + ']'); + v += Math.random() / 1000; + row[j] = v; + dm[j][i] = v; + } + values[v] = true; } + } } function clusterEqual(h1, h2) { - //console.log(h1); - //console.log(h2); - if (h1 == h2) - return true; - return h1.dist == h2.dist - && h1.size == h2.size - && h1.depth == h2.depth - && ((clusterEqual(h1.left, h2.left) - && clusterEqual(h1.right, h2.right)) - || (clusterEqual(h1.left, h2.right) - && clusterEqual(h1.right, h2.left))); + //console.log(h1); + //console.log(h2); + if (h1 == h2) return true; + return ( + h1.dist == h2.dist && + h1.size == h2.size && + h1.depth == h2.depth && + ((clusterEqual(h1.left, h2.left) && clusterEqual(h1.right, h2.right)) || + (clusterEqual(h1.left, h2.right) && clusterEqual(h1.right, h2.left))) + ); } suite.addBatch({ - "leaforder": { - "simple": function() { - var data = [2, 1, 4, 3], - expect = [1, 2, 3, 4]; - var 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++) { - next = Math.random()+prev; - data.push(next); - prev = next; - } - var randata = reorder.randomPermute(data.slice()); - var 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; - - for (i = 0; i < rows; i++) { - row = []; - array.push(row); - for (j = 0; j < cols; j++) { - row.push(Math.random()); - } - } - var order = reorder.optimal_leaf_order(), - perm = order(array); - // Check determinism - for (i = 0; i < 3; i++) { - var p2 = order(array); - assert.deepEqual(perm, p2); - } - // Disambiguate distance matrix to have a - // deterministic hcluster - var dm = reorder.dist()(array); - - remove_equal_dist(dm); - //reorder.printmat(dm); - var h1 = reorder.hcluster() - .linkage("complete") - .distanceMatrix(dm)(array); - - perm = reorder.optimal_leaf_order() - .distanceMatrix(dm)(array); - var 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); - - assert.isTrue(clusterEqual(h1, h2), "Clusters are not equal"); - - var p3 = order.distanceMatrix(d2)(a2); - - assert.deepEqual(p3, reorder.range(0, p3.length)); - } - } + leaforder: { + simple: function () { + var data = [2, 1, 4, 3], + expect = [1, 2, 3, 4]; + var 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++) { + next = Math.random() + prev; + data.push(next); + prev = next; + } + var randata = reorder.randomPermute(data.slice()); + var 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; + + for (i = 0; i < rows; i++) { + row = []; + array.push(row); + for (j = 0; j < cols; j++) { + row.push(Math.random()); + } + } + var order = reorder.optimal_leaf_order(), + perm = order(array); + // Check determinism + for (i = 0; i < 3; i++) { + var p2 = order(array); + assert.deepEqual(perm, p2); + } + // Disambiguate distance matrix to have a + // deterministic hcluster + var dm = reorder.dist()(array); + + remove_equal_dist(dm); + //reorder.printmat(dm); + var h1 = reorder.hcluster().linkage('complete').distanceMatrix(dm)(array); + + perm = reorder.optimal_leaf_order().distanceMatrix(dm)(array); + var 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); + + assert.isTrue(clusterEqual(h1, h2), 'Clusters are not equal'); + + var p3 = order.distanceMatrix(d2)(a2); + + assert.deepEqual(p3, reorder.range(0, p3.length)); + }, + }, }); suite.export(module); diff --git a/test/mat2graph-test.js b/test/mat2graph-test.js index 1f02ab6..4d89834 100644 --- a/test/mat2graph-test.js +++ b/test/mat2graph-test.js @@ -1,36 +1,36 @@ -var reorder = require("../dist/reorder.cjs"); +var reorder = require('../dist/reorder.cjs'); -var vows = require("vows"), - assert = require("assert"); +var vows = require('vows'), + assert = require('assert'); -var suite = vows.describe("reorder.mat2graph"); +var suite = vows.describe('reorder.mat2graph'); suite.addBatch({ - "mat2graph": { - "simple": function() { - var mat = [ - [0, 1, 0], - [1, 0, 1], - [0, 1, 0] - ]; - var graph = reorder.mat2graph(mat); - assert.equal(graph.nodes().length, 3); - assert.equal(graph.links().length, 2); - }, - "lesssimple": function() { - var 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 - assert.equal(graph.nodes().length, 5); - assert.equal(graph.links().length, 11); - var m2 = reorder.graph2mat(graph); - assert.deepEqual(m2, mat); - } - } + mat2graph: { + simple: function () { + var mat = [ + [0, 1, 0], + [1, 0, 1], + [0, 1, 0], + ]; + var graph = reorder.mat2graph(mat); + assert.equal(graph.nodes().length, 3); + assert.equal(graph.links().length, 2); + }, + lesssimple: function () { + var 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 + assert.equal(graph.nodes().length, 5); + assert.equal(graph.links().length, 11); + var m2 = reorder.graph2mat(graph); + assert.deepEqual(m2, mat); + }, + }, }); suite.export(module); diff --git a/test/order-test.js b/test/order-test.js index 2e48ba5..6c93368 100644 --- a/test/order-test.js +++ b/test/order-test.js @@ -1,132 +1,141 @@ -var reorder = require("../dist/reorder.cjs"); +var reorder = require('../dist/reorder.cjs'); var seedrandom = require('seedrandom'); -var vows = require("vows"), - assert = require("assert"); +var vows = require('vows'), + assert = require('assert'); -var suite = vows.describe("reorder.order"); +var 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]; - if (deepEqual(actual, expected)) { - assert.ok(actual, "Assert OK"); - return true; - } +assert.ORdeepEqual = function (actual, expected_list) { + for (var i = 0; i < expected_list.length; i++) { + var expected = expected_list[i]; + if (deepEqual(actual, expected)) { + assert.ok(actual, 'Assert OK'); + return true; } - assert.fail(actual, expected_list, "Assert: Expectations failed"); - return false; - }; - + } + assert.fail(actual, expected_list, 'Assert: Expectations failed'); + return false; +}; function eucl(a, b) { - var x = b - a; - return x*x; -}; + var x = b - a; + return x * x; +} -function fortytwo(a) { return a+42; } +function fortytwo(a) { + return a + 42; +} function lesssimple() { - var prefix = reorder.range(0, 10), - suffix; + var prefix = reorder.range(0, 10), + suffix; - var prev =10, - data = [prev], - next, - i, j; + var prev = 10, + data = [prev], + next, + i, + j; - for (i = 0; i < 30; i++) { - next = Math.random()+prev; - data.push(next); - prev = next; - } - suffix = reorder.range(Math.ceil(prev+1), Math.ceil(prev+21)); - i = prefix.length; - j = i+data.length; - data = prefix.concat(data).concat(suffix); - //console.log("Original : "+data); - var randata = reorder.randomPermute(data.slice(0), i, j); - //console.log("Shuffled : "+randata); - var x = reorder.order().distance(eucl).limits(i, j)(randata); - //console.log("Permutation: "+randata); - assert.deepEqual( - reorder.stablepermute(randata, x), data); + for (i = 0; i < 30; i++) { + next = Math.random() + prev; + data.push(next); + prev = next; + } + suffix = reorder.range(Math.ceil(prev + 1), Math.ceil(prev + 21)); + i = prefix.length; + j = i + data.length; + data = prefix.concat(data).concat(suffix); + //console.log("Original : "+data); + var randata = reorder.randomPermute(data.slice(0), i, j); + //console.log("Shuffled : "+randata); + var 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); - assert.deepEqual(reorder.stablepermute(v, x), - reorder.range(42, 42+v.length)); + var x = reorder.order().distance(eucl).except([i, j])(v); + assert.deepEqual( + reorder.stablepermute(v, x), + reorder.range(42, 42 + v.length) + ); } function insert_lesssimple() { - var 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)); - - shuffled = shuffled.slice(0, cut) - .concat(middle) - .concat(shuffled.slice(cut)); - //console.log("i="+cut+", j="+(cut+middle.length)); - var x = reorder.order() - .distance(eucl) - .except([cut, cut+middle.length]) - (shuffled); - assert.deepEqual(reorder.stablepermute(shuffled, x), - prefix.concat(middle.concat(suffix))); - + var 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)); + + shuffled = shuffled.slice(0, cut).concat(middle).concat(shuffled.slice(cut)); + //console.log("i="+cut+", j="+(cut+middle.length)); + var x = reorder + .order() + .distance(eucl) + .except([cut, cut + middle.length])(shuffled); + assert.deepEqual( + reorder.stablepermute(shuffled, x), + prefix.concat(middle.concat(suffix)) + ); } 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); - assert.deepEqual(reorder.stablepermute(data, x), - [-1, -2, 0, 1, 2, 3, 4, 10, 11, 12]); - }, - "lesssimple": lesssimple, - "evenharder": function() { - 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), - shuffled = reorder.randomPermute(data.slice(0)); - - var x = reorder.order() - .distance(eucl)(shuffled); - assert.deepEqual(reorder.stablepermute(shuffled, x), data); - }, - "equiv-simple2": function() { - var 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], - [0, 0, 0, 1, 1, 1, 1, 1, 0], - [0, 0, 0, 1, 1, 1, 0, 0, 0], - [0, 0, 1, 1, 1, 1, 0, 0, 0] - ]; - - var x = reorder.order() -// .distance(reorder.distance.manhattan) - .linkage("single")(data); -// console.log(toLetter(x)); - assert.deepEqual(reorder.stablepermute(reorder.range(0,data.length), x), - toNum([ 'a', 'f', 'e', 'd', 'c', 'b' ])); - }, -/* + 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); + assert.deepEqual(reorder.stablepermute(data, x), [ + -1, + -2, + 0, + 1, + 2, + 3, + 4, + 10, + 11, + 12, + ]); + }, + lesssimple: lesssimple, + evenharder: function () { + 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), + shuffled = reorder.randomPermute(data.slice(0)); + + var x = reorder.order().distance(eucl)(shuffled); + assert.deepEqual(reorder.stablepermute(shuffled, x), data); + }, + 'equiv-simple2': function () { + var 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], + [0, 0, 0, 1, 1, 1, 1, 1, 0], + [0, 0, 0, 1, 1, 1, 0, 0, 0], + [0, 0, 1, 1, 1, 1, 0, 0, 0], + ]; + + var x = reorder + .order() + // .distance(reorder.distance.manhattan) + .linkage('single')(data); + // console.log(toLetter(x)); + assert.deepEqual( + reorder.stablepermute(reorder.range(0, data.length), x), + toNum(['a', 'f', 'e', 'd', 'c', 'b']) + ); + }, + /* "equiv-simple3": function() { var data = reorder.transpose([ [0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0], @@ -147,174 +156,235 @@ suite.addBatch({ toNum(['n','j','a','e','f','i','m','p','b','o','l','g','d','c','k','h'])); }, */ - "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)); - - shuffled = shuffled.slice(0, 5) - .concat(middle) - .concat(shuffled.slice(5)); - var x = reorder.order() - .distance(eucl) - .except([5, 5+middle.length]) - (shuffled); - assert.deepEqual(reorder.stablepermute(shuffled, x), - reorder.range(0, 13).map(fortytwo)); - }, - "insert-1": function() { - insert_simple([74,44,48,72,70,67,46,53,76,52,45,42,49,77,47,68,43,73,51,55,54,69,75,50,56,57,58,59,60,61,62,63,64,65,66,71],24, 24+11); - }, - "insert-2": function() { - insert_simple([44,70,69,66,43,71,46,73,67,47,65,68,42,72,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,48,49,45], 14, 14+15); - }, - "insert-3": function() { - var data = [[1,1,0], - [0,0,1], - [1,1,0], - [1,1,0], - [0,0,1], - [0,1,0], - [0,1,0], - [1,0,1], - [1,1,0], - [0,1,1], - [0,0,1] - ]; - var x = reorder.order() - .limits(1,10) - .except([5, 10]) - (data); - // Since several rows are identical, there are multiple - // possible correct orderings - assert.ORdeepEqual( - x, - [ - [0, 3, 2, 5, 6, 7, 8, 9, 4, 1, 10], - [0, 2, 3, 5, 6, 7, 8, 9, 4, 1, 10], - [0, 3, 2, 5, 6, 7, 8, 9, 1, 4, 10], - [0, 2, 3, 5, 6, 7, 8, 9, 1, 4, 10] - ]); - }, - "insert-4": function() { - var data = [[1,1,0], - [0,0,1], - [1,1,0], - [1,1,0], - [0,0,1], - [0,1,0], - [0,1,0], - [1,0,1], - [1,1,0], - [0,1,1], - [0,0,1] - ]; - var 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 = - [ - [NaN,NaN,NaN], - [1,1,0], - [0,0,1], - [0,0,1], - [0,0,1], - [1,1,0], - [1,1,0], - [0,1,1], - [1,1,0], - [1,0,1], - [0,1,0], - [0,1,0], - ]; - var 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 = - [[1,1,0], - [0,0,1], - [1,1,0], - [1,1,0], - [0,0,1], - [0,1,0], - [0,1,0], - [1,0,1], - [1,1,0], - [0,1,1], - [0,0,1] - ]; - var 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 = - [ - [0,0,1], - [1,1,0], - [1,1,0], - [0,0,1], - [0,1,0], - [0,1,0], - [1,0,1], - [1,1,0], - [0,1,1], - [0,0,1] - ]; - var 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++) { - //console.log("Loop "+i); - insert_lesssimple(); - } - } - } + '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)); + + shuffled = shuffled.slice(0, 5).concat(middle).concat(shuffled.slice(5)); + var x = reorder + .order() + .distance(eucl) + .except([5, 5 + middle.length])(shuffled); + assert.deepEqual( + reorder.stablepermute(shuffled, x), + reorder.range(0, 13).map(fortytwo) + ); + }, + 'insert-1': function () { + insert_simple( + [ + 74, + 44, + 48, + 72, + 70, + 67, + 46, + 53, + 76, + 52, + 45, + 42, + 49, + 77, + 47, + 68, + 43, + 73, + 51, + 55, + 54, + 69, + 75, + 50, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 71, + ], + 24, + 24 + 11 + ); + }, + 'insert-2': function () { + insert_simple( + [ + 44, + 70, + 69, + 66, + 43, + 71, + 46, + 73, + 67, + 47, + 65, + 68, + 42, + 72, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 48, + 49, + 45, + ], + 14, + 14 + 15 + ); + }, + 'insert-3': function () { + var data = [ + [1, 1, 0], + [0, 0, 1], + [1, 1, 0], + [1, 1, 0], + [0, 0, 1], + [0, 1, 0], + [0, 1, 0], + [1, 0, 1], + [1, 1, 0], + [0, 1, 1], + [0, 0, 1], + ]; + var x = reorder.order().limits(1, 10).except([5, 10])(data); + // Since several rows are identical, there are multiple + // possible correct orderings + assert.ORdeepEqual(x, [ + [0, 3, 2, 5, 6, 7, 8, 9, 4, 1, 10], + [0, 2, 3, 5, 6, 7, 8, 9, 4, 1, 10], + [0, 3, 2, 5, 6, 7, 8, 9, 1, 4, 10], + [0, 2, 3, 5, 6, 7, 8, 9, 1, 4, 10], + ]); + }, + 'insert-4': function () { + var data = [ + [1, 1, 0], + [0, 0, 1], + [1, 1, 0], + [1, 1, 0], + [0, 0, 1], + [0, 1, 0], + [0, 1, 0], + [1, 0, 1], + [1, 1, 0], + [0, 1, 1], + [0, 0, 1], + ]; + var 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 = [ + [NaN, NaN, NaN], + [1, 1, 0], + [0, 0, 1], + [0, 0, 1], + [0, 0, 1], + [1, 1, 0], + [1, 1, 0], + [0, 1, 1], + [1, 1, 0], + [1, 0, 1], + [0, 1, 0], + [0, 1, 0], + ]; + var 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 = [ + [1, 1, 0], + [0, 0, 1], + [1, 1, 0], + [1, 1, 0], + [0, 0, 1], + [0, 1, 0], + [0, 1, 0], + [1, 0, 1], + [1, 1, 0], + [0, 1, 1], + [0, 0, 1], + ]; + var 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 = [ + [0, 0, 1], + [1, 1, 0], + [1, 1, 0], + [0, 0, 1], + [0, 1, 0], + [0, 1, 0], + [1, 0, 1], + [1, 1, 0], + [0, 1, 1], + [0, 0, 1], + ]; + var 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++) { + //console.log("Loop "+i); + insert_lesssimple(); + } + }, + }, }); function deepEqual(actual, expected) { if (actual === expected) { return true; - // } else if (Buffer.isBuffer(actual) && Buffer.isBuffer(expected)) { - // if (actual.length != expected.length) return false; - - // for (var i = 0; i < actual.length; i++) { - // if (actual[i] !== expected[i]) return false; - // } - // return true; + // } else if (Buffer.isBuffer(actual) && Buffer.isBuffer(expected)) { + // if (actual.length != expected.length) return false; + // for (var i = 0; i < actual.length; i++) { + // if (actual[i] !== expected[i]) return false; + // } + // return true; } else if (actual instanceof Date && expected instanceof Date) { return actual.getTime() === expected.getTime(); - } else if (typeof actual != 'object' && typeof expected != 'object') { return actual == expected; - } else { return objEquiv(actual, expected); } -}; +} // Taken from node/lib/assert.js function isUndefinedOrNull(value) { @@ -328,8 +398,7 @@ function isArguments(object) { // Taken from node/lib/assert.js function objEquiv(a, b) { - if (isUndefinedOrNull(a) || isUndefinedOrNull(b)) - return false; + if (isUndefinedOrNull(a) || isUndefinedOrNull(b)) return false; if (a.prototype !== b.prototype) return false; if (isArguments(a)) { if (!isArguments(b)) { @@ -341,18 +410,17 @@ function objEquiv(a, b) { } try { var ka = Object.keys(a), - kb = Object.keys(b), - key, i; + kb = Object.keys(b), + key, + i; } catch (e) { return false; } - if (ka.length != kb.length) - return false; + if (ka.length != kb.length) return false; ka.sort(); kb.sort(); for (i = ka.length - 1; i >= 0; i--) { - if (ka[i] != kb[i]) - return false; + if (ka[i] != kb[i]) return false; } for (i = ka.length - 1; i >= 0; i--) { key = ka[i]; @@ -362,12 +430,15 @@ function objEquiv(a, b) { } function toNum(a) { - return a.map(function(l) { return l.charCodeAt(0)-97; }); + return a.map(function (l) { + return l.charCodeAt(0) - 97; + }); } function toLetter(a) { - return a.map(function(l) { return String.fromCharCode(97+l); }); + return a.map(function (l) { + return String.fromCharCode(97 + l); + }); } - suite.export(module); diff --git a/test/pca1d-test.js b/test/pca1d-test.js index 71e6105..98f13bb 100644 --- a/test/pca1d-test.js +++ b/test/pca1d-test.js @@ -1,64 +1,61 @@ -var reorder = require("../dist/reorder.cjs"); +var reorder = require('../dist/reorder.cjs'); -var vows = require("vows"), - assert = require("assert"); +var vows = require('vows'), + assert = require('assert'); -var suite = vows.describe("reorder.pca1d"); +var suite = vows.describe('reorder.pca1d'); suite.addBatch({ - "pca1d": { - "simple": function() { - var mat = [ - [2.5, 2.4], - [0.5, 0.7], - [2.2, 2.9], - [1.9, 2.2], - [3.1, 3.0], - [2.3, 2.7], - [2.0, 1.6], - [1.0, 1.1], - [1.5, 1.6], - [1.1, 0.9] - ], - pca = reorder.pca1d(mat); - - assert.inDeltaArray(pca, - [0.67833, 0.734755], - 0.001); + pca1d: { + simple: function () { + var mat = [ + [2.5, 2.4], + [0.5, 0.7], + [2.2, 2.9], + [1.9, 2.2], + [3.1, 3.0], + [2.3, 2.7], + [2.0, 1.6], + [1.0, 1.1], + [1.5, 1.6], + [1.1, 0.9], + ], + pca = reorder.pca1d(mat); - assert.deepEqual(reorder.sort_order(pca), [0, 1]); - }, - "lesssimple": function() { - var data = [ - [80, 27, 89, 42], - [80, 27, 88, 37], - [75, 25, 90, 37], - [62, 24, 87, 28], - [62, 22, 87, 18], - [62, 23, 87, 18], - [62, 24, 93, 19], - [62, 24, 93, 20], - [58, 23, 87, 15], - [58, 18, 80, 14], - [58, 18, 89, 14], - [58, 17, 88, 13], - [58, 18, 82, 11], - [58, 19, 93, 12], - [50, 18, 89, 8], - [50, 18, 86, 7], - [50, 19, 72, 8], - [50, 19, 79, 8], - [50, 20, 80, 9], - [56, 20, 82, 15], - [70, 20, 91, 15] - ], - pca = reorder.pca1d(data); - - assert.inDeltaArrayOrNeg(pca, [0.642, 0.195, 0.197, 0.715], 0.001); - assert.deepEqual(reorder.sort_order(pca), [1, 2, 0, 3]); - } - } + assert.inDeltaArray(pca, [0.67833, 0.734755], 0.001); + + assert.deepEqual(reorder.sort_order(pca), [0, 1]); + }, + lesssimple: function () { + var data = [ + [80, 27, 89, 42], + [80, 27, 88, 37], + [75, 25, 90, 37], + [62, 24, 87, 28], + [62, 22, 87, 18], + [62, 23, 87, 18], + [62, 24, 93, 19], + [62, 24, 93, 20], + [58, 23, 87, 15], + [58, 18, 80, 14], + [58, 18, 89, 14], + [58, 17, 88, 13], + [58, 18, 82, 11], + [58, 19, 93, 12], + [50, 18, 89, 8], + [50, 18, 86, 7], + [50, 19, 72, 8], + [50, 19, 79, 8], + [50, 20, 80, 9], + [56, 20, 82, 15], + [70, 20, 91, 15], + ], + pca = reorder.pca1d(data); + + assert.inDeltaArrayOrNeg(pca, [0.642, 0.195, 0.197, 0.715], 0.001); + assert.deepEqual(reorder.sort_order(pca), [1, 2, 0, 3]); + }, + }, }); suite.export(module); - diff --git a/test/pcp-test.js b/test/pcp-test.js index 2cd1e6d..11828bb 100644 --- a/test/pcp-test.js +++ b/test/pcp-test.js @@ -1,22 +1,23 @@ -var reorder = require("../dist/reorder.cjs"); +var reorder = require('../dist/reorder.cjs'); -var vows = require("vows"), - assert = require("assert"); +var vows = require('vows'), + assert = require('assert'); -var suite = vows.describe("reorder.pcp"); +var suite = vows.describe('reorder.pcp'); suite.addBatch({ - "pcp": { - "simple": function() { - var 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); - assert.deepEqual(earray,array); - } - } + pcp: { + simple: function () { + var 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); + assert.deepEqual(earray, array); + }, + }, }); suite.export(module); - - diff --git a/test/pearson-test.js b/test/pearson-test.js index ccb89ba..0aa6a41 100644 --- a/test/pearson-test.js +++ b/test/pearson-test.js @@ -1,47 +1,65 @@ -var reorder = require("../dist/reorder.cjs"); +var reorder = require('../dist/reorder.cjs'); -var vows = require("vows"), - assert = require("assert"); +var vows = require('vows'), + assert = require('assert'); -var suite = vows.describe("reorder.pearson"); +var suite = vows.describe('reorder.pearson'); suite.addBatch({ - "pearson": { - "simple": function() { - var a = [1, 2, 3, 4, 5], b = [5, 4, 3, 2, 1]; + pearson: { + simple: function () { + var a = [1, 2, 3, 4, 5], + b = [5, 4, 3, 2, 1]; - assert.equal(reorder.correlation.pearson(a, b), -1); - }, - "harder": function() { - var a = [0.38906616, 0.5773394 , 0.17349286, 0.5540746, - 0.93085356, 0.91643792, 0.85663005, 0.15666242, - 0.91411063, 0.50854478], - b = [0.2845388 , 0.08112363, 0.81855562, 0.12360082, - 0.96107274, 0.78954847, 0.05820312, 0.34101782, - 0.62052291, 0.25681059], - y = reorder.correlation.pearson(a, b), - e = 0.21706031819808619; - //console.log('y = '+y+', e='+e); - assert.inDelta(y, e, 0.00001); - }, - "hard": function() { - var 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], - [ 0.18564092, 0.6546422 , 0.06249554, - 0.94448868, 0.3452618 ]], - E = [[ 0. , 0.67610163, 0.02692672, 0.07496238], - [ 0.67610163, 0. , 0.73793422, -0.25448483], - [ 0.02692672, 0.73793422, 0. , -0.41270574], - [ 0.07496238, -0.25448483, -0.41270574, 0. ]], - Y = reorder.correlation.pearsonMatrix(X); - assert.inDeltaArray(Y, E, 0.00001); - } - } + assert.equal(reorder.correlation.pearson(a, b), -1); + }, + harder: function () { + var a = [ + 0.38906616, + 0.5773394, + 0.17349286, + 0.5540746, + 0.93085356, + 0.91643792, + 0.85663005, + 0.15666242, + 0.91411063, + 0.50854478, + ], + b = [ + 0.2845388, + 0.08112363, + 0.81855562, + 0.12360082, + 0.96107274, + 0.78954847, + 0.05820312, + 0.34101782, + 0.62052291, + 0.25681059, + ], + y = reorder.correlation.pearson(a, b), + e = 0.21706031819808619; + //console.log('y = '+y+', e='+e); + assert.inDelta(y, e, 0.00001); + }, + hard: function () { + var 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], + [0.18564092, 0.6546422, 0.06249554, 0.94448868, 0.3452618], + ], + E = [ + [0, 0.67610163, 0.02692672, 0.07496238], + [0.67610163, 0, 0.73793422, -0.25448483], + [0.02692672, 0.73793422, 0, -0.41270574], + [0.07496238, -0.25448483, -0.41270574, 0], + ], + Y = reorder.correlation.pearsonMatrix(X); + assert.inDeltaArray(Y, E, 0.00001); + }, + }, }); suite.export(module); - diff --git a/test/permute-test.js b/test/permute-test.js index 7464134..54903ca 100644 --- a/test/permute-test.js +++ b/test/permute-test.js @@ -1,51 +1,49 @@ Queue = require('tiny-queue'); -var reorder = require("../dist/reorder.cjs"); +var reorder = require('../dist/reorder.cjs'); -var vows = require("vows"), - assert = require("assert"); +var vows = require('vows'), + assert = require('assert'); -var suite = vows.describe("reorder.permute"); +var suite = vows.describe('reorder.permute'); suite.addBatch({ - "permute": { - "simple1": function() { - assert.deepEqual(reorder.permute([0], [0]), [0]); - }, - "simple2": function() { - assert.deepEqual(reorder.permute([0, 1], [0, 1]), [0, 1]); - }, - "simple3": function() { - assert.deepEqual(reorder.permute([1, 0], [0, 1]), [1, 0]); - }, - "simple4": function() { - assert.deepEqual(reorder.permute([0, 1], [1, 0]), [1, 0]); - }, - "simple5": function() { - 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), - 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), - perm = reorder.randomPermute(list.slice()), - permc = perm.slice(), - inv = reorder.inverse_permutation(perm, true); - - assert.deepEqual(list, reorder.permute(inv.slice(), perm)); - assert.deepEqual(perm, permc); - assert.deepEqual(list, reorder.permute(perm.slice(), inv)); - } - } - - } + permute: { + simple1: function () { + assert.deepEqual(reorder.permute([0], [0]), [0]); + }, + simple2: function () { + assert.deepEqual(reorder.permute([0, 1], [0, 1]), [0, 1]); + }, + simple3: function () { + assert.deepEqual(reorder.permute([1, 0], [0, 1]), [1, 0]); + }, + simple4: function () { + assert.deepEqual(reorder.permute([0, 1], [1, 0]), [1, 0]); + }, + simple5: function () { + 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), + 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), + perm = reorder.randomPermute(list.slice()), + permc = perm.slice(), + inv = reorder.inverse_permutation(perm, true); + + assert.deepEqual(list, reorder.permute(inv.slice(), perm)); + assert.deepEqual(perm, permc); + assert.deepEqual(list, reorder.permute(perm.slice(), inv)); + } + }, + }, }); suite.export(module); -