diff --git a/src/all_pairs_distance.js b/src/all_pairs_distance.js
index 0437c71..c35067d 100644
--- a/src/all_pairs_distance.js
+++ b/src/all_pairs_distance.js
@@ -1,3 +1,4 @@
+import { infinities } from './utils';
 /**
  * Returns a list of distance matrices, computed for the specified
  * connected components of a graph, or all the components if none is
@@ -26,7 +27,7 @@ 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 = reorder.infinities(comp.length, comp.length),
+    var dist = infinities(comp.length, comp.length),
 	i, j, k, inv;
     // Floyd Warshall, 
     // see http://ai-depot.com/BotNavigation/Path-AllPairs.html
@@ -79,7 +80,7 @@ export function floyd_warshall_with_path(graph, comp) {
     if (! comp)
 	comp = graph.components()[0];
 
-    var dist = reorder.infinities(comp.length, comp.length),
+    var dist = infinities(comp.length, comp.length),
 	next = Array(comp.length),
 	directed = graph.directed(),
 	i, j, k, inv;
diff --git a/src/bandwidth.js b/src/bandwidth.js
index 68d42e1..41f6c6d 100644
--- a/src/bandwidth.js
+++ b/src/bandwidth.js
@@ -1,6 +1,8 @@
+import { range } from './range';
+
 export function bandwidth(graph, order) {
     if (! order)
-	order = reorder.range(graph.nodes().length);
+	order = range(graph.nodes().length);
 
     var inv = inverse_permutation(order),
 	links = graph.links(),
diff --git a/src/barycenter_order.js b/src/barycenter_order.js
index 44d8380..d0fcdc4 100644
--- a/src/barycenter_order.js
+++ b/src/barycenter_order.js
@@ -1,3 +1,6 @@
+import { cmp_number } from './utils';
+import { debug } from './core';
+
 export function barycenter_order(graph, comps, max_iter) {
     var orders = [[], [], 0];
     // Compute the barycenter heuristic on each connected component
@@ -5,7 +8,7 @@ export function barycenter_order(graph, comps, max_iter) {
 	comps = graph.components();
     }
     for (var i = 0; i < comps.length; i++) {
-	var o = reorder.barycenter(graph, comps[i], max_iter);
+	var o = barycenter(graph, comps[i], max_iter);
 	orders = [ orders[0].concat(o[0]),
 		   orders[1].concat(o[1]),
 		   orders[2]+o[2] ];
@@ -23,7 +26,7 @@ function median(neighbors) {
 	return neighbors[0];
     if (neighbors.length === 2)
 	return (neighbors[0]+neighbors[1])/2;
-    neighbors.sort(reorder.cmp_number);
+    neighbors.sort(cmp_number);
     if (neighbors.length % 2)
 	return neighbors[(neighbors.length-1)/2];
     var rm = neighbors.length/2,
@@ -110,7 +113,7 @@ export function barycenter(graph, comp, max_iter) {
 	    max_iter = Math.max(max_iter, iter + 2); // we improved so go on
 	}
     }
-    if (reorder.debug) {
+    if (debug) {
 	console.log('Best iter: '+best_iter);
     }
 
diff --git a/src/bfs.js b/src/bfs.js
index f31a09f..ce5585e 100644
--- a/src/bfs.js
+++ b/src/bfs.js
@@ -1,3 +1,5 @@
+import { flatten, cmp_number } from './utils';
+
 export function bfs(graph, v, fn) {
     var q = new Queue(),
 	discovered = {}, i, e, v2, edges;
@@ -24,7 +26,7 @@ export function bfs(graph, v, fn) {
 export function bfs_distances(graph, v) {
     var dist = {};
     dist[v] = 0;
-    reorder.bfs(graph, v, function(v, c) {
+    bfs(graph, v, function(v, c) {
 	if (c >= 0 && v != c)
 	    dist[c] = dist[v]+1;
     });
@@ -34,8 +36,8 @@ export function bfs_distances(graph, v) {
 export function all_pairs_distance_bfs(graph, comps) {
     if (! comps)
 	comps = [ graph.nodes_indices() ];
-    var nodes = comps.reduce(reorder.flatten)
-	    .sort(reorder.cmp_number),
+    var nodes = comps.reduce(flatten)
+	    .sort(cmp_number),
 	mat = Array(nodes.length),
 	i, j, dist;
 
@@ -43,7 +45,7 @@ export function all_pairs_distance_bfs(graph, comps) {
 	mat[i] = Array(nodes.length);
 
     for (i = 0; i < nodes.length; i++) {
-	dist = reorder.bfs_distances(graph, i);
+	dist = bfs_distances(graph, i);
 	for (j in dist) {
 	    mat[i][j] = dist[j];
 	    mat[j][i] = dist[j];
diff --git a/src/ca.js b/src/ca.js
index fa16dcd..f37cd19 100644
--- a/src/ca.js
+++ b/src/ca.js
@@ -1,3 +1,7 @@
+import { zeroes } from './aliases';
+import { array1d } from './utils';
+import { debug } from './core';
+import { sort_order } from './sort_order';
 //Corresponence Analysis
 // see http://en.wikipedia.org/wiki/Correspondence_analysis
 
@@ -20,7 +24,7 @@ function sumrows(v) {
 function sumcols(v) {
     var n = v.length,
 	o = v[0].length,
-	sumcol = reorder.zeroes(o),
+	sumcol = zeroes(o),
 	i, j, row;
 
     for (i = 0; i < n; i++) {
@@ -49,11 +53,11 @@ function decorana(dat) {
     
     adotj = sumcols(dat);
     aidot = sumrows(dat);
-    //console.log('adotj='); reorder.printvec(adotj);
-    //console.log('aidot='); reorder.printvec(aidot);
+    //console.log('adotj='); printvec(adotj);
+    //console.log('aidot='); printvec(aidot);
 
-    s1 = eigy(reorder.array1d(nr, 1.0),
-	      reorder.array1d(nc, 1.0),
+    s1 = eigy(array1d(nr, 1.0),
+	      array1d(nc, 1.0),
 	      nr, nc, dat, aidot, adotj);
     if (s1.eig < ZEROEIG) {
         s1.rows = s1.cols = [];
@@ -139,10 +143,10 @@ function eigy(x, y, mi, n, dat, aidot, adotj) {
 	a11, a12, a22, a23, a33, a34, a44, 
 	res, ax1, ax2, ax3, ax4,
 	b13, b14, b24, row,
-	y2 = reorder.zeroes(n),
-	y3 = reorder.zeroes(n),
-	y4 = reorder.zeroes(n),
-	y5 = reorder.zeroes(n),
+	y2 = zeroes(n),
+	y3 = zeroes(n),
+	y4 = zeroes(n),
+	y5 = zeroes(n),
 	tol;
 
     tot = 0.0;
@@ -269,7 +273,7 @@ function eigy(x, y, mi, n, dat, aidot, adotj) {
     }
     // 200
     //console.log('eigenvalue',a11.toFixed(6));
-    if (a12 > tol && reorder.debug > 0) {
+    if (a12 > tol && debug > 0) {
 	console.log("residual bigger than tolerance on axis 1");
     }
     var aymax = y[0],
@@ -366,8 +370,8 @@ export const ca_decorana = decorana;
 export const ca = decorana;
 
 export function ca_order(dat) {
-    var res = reorder.ca(dat);
-    return { rows: reorder.sort_order(res.rows),
-	     cols: reorder.sort_order(res.cols),
+    var res = ca(dat);
+    return { rows: sort_order(res.rows),
+	     cols: sort_order(res.cols),
 	     details: res };
 };
diff --git a/src/correlation.js b/src/correlation.js
index 7d2429e..b74a968 100644
--- a/src/correlation.js
+++ b/src/correlation.js
@@ -1,3 +1,5 @@
+import { zeroes } from './aliases';
+
 export const correlation = {
     pearson: function(a, b) {
 	var ma = science.stats.mean(a),
@@ -18,12 +20,12 @@ export const correlation = {
     pearsonMatrix: function(matrix) {
 	var a, ma,
 	    i, j, dx, 
-	    cor = reorder.correlation.pearson,
+	    cor = correlation.pearson,
 	    n = matrix.length, ret, mx, sx, sx2;
 	if (n === 0)
 	    return NaN;
 	// do it the hard way for now, we'll optimize later
-	ret = reorder.zeroes(n, n);
+	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]);
@@ -32,8 +34,8 @@ export const correlation = {
 	}
 	return ret;
 	// mx = Array(n);
-	// sx = reorder.zeroes(n);
-	// sx2 = reorder.zeroes(n);
+	// sx = zeroes(n);
+	// sx2 = zeroes(n);
 	// for (i = 0; i < n; i++) {
 	//     mx[i] = science.stats.mean(matrix[i]);
 	// }
diff --git a/src/count_crossings.js b/src/count_crossings.js
index 8e3d8b8..faa5d60 100644
--- a/src/count_crossings.js
+++ b/src/count_crossings.js
@@ -1,3 +1,7 @@
+import { permutation } from './permutation';
+import { cmp_number } from './utils';
+import { zeroes } from './aliases';
+
 // Wilhelm Barth, Petra Mutzel, Michael Jünger: 
 // Simple and Efficient Bilayer Cross Counting.
 // J. Graph Algorithms Appl. 8(2): 179-194 (2004)
@@ -7,7 +11,7 @@ export function count_crossings(graph, north, south) {
 	firstIndex, treeSize, tree, index, weightSum,
 	invert = false, crosscount;
 
-    var comp = reorder.permutation(graph.nodes().length);
+    var comp = permutation(graph.nodes().length);
 
     if (north===undefined) {
 	north = comp.filter(function(n) { return graph.outDegree(n) !== 0; });
@@ -38,7 +42,7 @@ export function count_crossings(graph, north, south) {
 		    return south_inv[e.source.index];
 		});
 	}
-	n.sort(reorder.cmp_number);
+	n.sort(cmp_number);
 	southsequence = southsequence.concat(n);
     }
     
@@ -47,7 +51,7 @@ export function count_crossings(graph, north, south) {
 	firstIndex <<= 1;
     treeSize = 2 * firstIndex - 1;
     firstIndex -= 1;
-    tree = reorder.zeroes(treeSize);
+    tree = zeroes(treeSize);
 
     crosscount = 0;
     for (i = 0; i < southsequence.length; i++) {
diff --git a/src/index.js b/src/index.js
index 3db0c6c..666b611 100644
--- a/src/index.js
+++ b/src/index.js
@@ -59,6 +59,12 @@ export { array_to_dicts, dicts_to_array, pcp, parcoords } from './pcp';
 export { permutation, inverse_permutation } from './permutation';
 export { permute, permute_inplace, permutetranspose } from './permute';
 export { poweriteration, poweriteration_n } from './poweriteration';
+export {
+  randomPermute,
+  randomPermutation,
+  random_array,
+  random_matrix
+} from './random';
 export { range } from './range';
 export {
   sort_order,
diff --git a/src/laplacian.js b/src/laplacian.js
index c69cd31..f3c4292 100644
--- a/src/laplacian.js
+++ b/src/laplacian.js
@@ -1,10 +1,13 @@
+import { zeroes } from './aliases';
+import { assert } from './debug';
+
 export function laplacian(graph, comp) {
     var n = comp.length,
-	lap = reorder.zeroes(n, n),
+	lap = zeroes(n, n),
 	inv = inverse_permutation(comp),
 	i, j, k, row, sum, edges, v, e, other;
 
-    reorder.assert(! graph.directed(), "Laplacian only for undirected graphs");
+    assert(! graph.directed(), "Laplacian only for undirected graphs");
     for (i = 0; i < n; i++) {
 	v = comp[i];
 	row = lap[i];
diff --git a/src/mat2graph.js b/src/mat2graph.js
index 482224b..4b0df00 100644
--- a/src/mat2graph.js
+++ b/src/mat2graph.js
@@ -1,3 +1,5 @@
+import { graph } from './graph';
+
 export function mat2graph(mat, directed) {
     var n = mat.length,
 	nodes = [],
@@ -22,7 +24,7 @@ export function mat2graph(mat, directed) {
 	    }
 	}
     }
-    return reorder.graph(nodes, links, directed)
+    return graph(nodes, links, directed)
 	.linkDistance(function(l, i) {
 	    return 1 + max_value - l.value;
 	})
diff --git a/src/optimal_leaf_order.js b/src/optimal_leaf_order.js
index 17c51c5..7e430ea 100644
--- a/src/optimal_leaf_order.js
+++ b/src/optimal_leaf_order.js
@@ -1,3 +1,8 @@
+import { distance } from './distance';
+import { debug } from './core';
+import { printhcluster } from './debug';
+import { dist } from './dist';
+
 /**
  * optimal dendrogram ordering
  * 
@@ -15,7 +20,7 @@
 
 export function optimal_leaf_order() {
     var distanceMatrix = null,
-        distance = reorder.distance.euclidean,
+        distance = distance.euclidean,
 	linkage = "complete",
         leavesMap = {},
         orderMap = {};
@@ -93,8 +98,8 @@ export function optimal_leaf_order() {
 	    left = leaves(v.left),
 	    right = leaves(v.right);
 	
-	if (reorder.debug)
-	    console.log(reorder.printhcluster(v,0));
+	if (debug)
+	    console.log(printhcluster(v,0));
 
 	for (var i = 0; i < left.length; i++) {
 	    for (var j = 0; j < right.length; j++) {
@@ -111,7 +116,7 @@ export function optimal_leaf_order() {
 
     function optimal_leaf_order(matrix) {
 	if (distanceMatrix === null)
-	    distanceMatrix = (reorder.dist().distance(distance))(matrix);
+	    distanceMatrix = (dist().distance(distance))(matrix);
 	var hcluster = science.stats.hcluster()
 		.linkage(linkage)
 		.distanceMatrix(distanceMatrix);
diff --git a/src/order.js b/src/order.js
index 59883ea..65f1df2 100644
--- a/src/order.js
+++ b/src/order.js
@@ -1,7 +1,13 @@
+import { distance } from './distance';
+import { optimal_leaf_order } from './optimal_leaf_order';
+import { debug } from './core';
+import { dist_remove, distmax, dist } from './dist';
+import { assert, printmat } from './debug';
+import { range } from './range';
 
 export function order() {
-    var distance = reorder.distance.euclidean,
-        ordering = reorder.optimal_leaf_order,
+    var distance = distance.euclidean,
+        ordering = optimal_leaf_order,
         linkage = "complete",
         distanceMatrix = null,
         vector,
@@ -11,8 +17,8 @@ export function order() {
 
 
     function _reset() {
-        distance = reorder.distance.euclidean;
-        ordering = reorder.optimal_leaf_order;
+        distance = distance.euclidean;
+        ordering = optimal_leaf_order;
         linkage = "complete";
         distanceMatrix = null;
         vector = null;
@@ -72,21 +78,21 @@ export function order() {
         if (i === 0 && j == vector.length)
             return _order_except();
 
-        if (reorder.debug)
+        if (debug)
             console.log("i0="+i0+" j0="+j0);
 
         if (distanceMatrix !== null) {
             if (j0 !== vector.length)
-                reorder.dist_remove(distanceMatrix, j0, vector.length);
+                dist_remove(distanceMatrix, j0, vector.length);
             if (i0 > 0)
-                reorder.dist_remove(distanceMatrix, 0, i0);
+                dist_remove(distanceMatrix, 0, i0);
         }
         else {
             _compute_dist();
         }
         // Apply constraints on the min/max indices
 
-        var max = reorder.distmax(distanceMatrix);
+        var 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
@@ -123,18 +129,18 @@ export function order() {
             if (perm[0] !== 0)
                 perm.reverse();
             if (j0 > j) {
-                reorder.assert(perm[0] === 0 && perm[perm.length-1]==perm.length-1,
+                assert(perm[0] === 0 && perm[perm.length-1]==perm.length-1,
                        "Invalid constrained permutation endpoints");
             }
             else {
-                reorder.assert(perm[0] === 0,
+                assert(perm[0] === 0,
                        "Invalid constrained permutation start");
             }
         }
         else if (j0 > j) {
             if (perm[perm.length-1] !== (perm.length-1))
                 perm = perm.reverse();
-            reorder.assert(perm[perm.length-1] == perm.length-1,
+            assert(perm[perm.length-1] == perm.length-1,
                            "Invalid constrained permutation end");
         }
         if (i0 !== 0) {
@@ -143,7 +149,7 @@ export function order() {
                 .concat(perm.map(function(v) { return v + i0; }));
         }
         if (orig.length > j0) {
-            perm = perm.concat(reorder.range(j0, orig.length));
+            perm = perm.concat(range(j0, orig.length));
         }
         return perm;
     }
@@ -168,9 +174,9 @@ export function order() {
         for (k = except.length-1; k > 0 ; k -= 2) {
             low = except[k-1];
             high = except[k];
-            distanceMatrix = reorder.dist_remove(distanceMatrix, low+1, high-1);
+            distanceMatrix = dist_remove(distanceMatrix, low+1, high-1);
             vector.splice(low+1, high-low-2);
-            if (reorder.debug)
+            if (debug)
                 console.log("Except["+low+", "+high+"]");
             if (distanceMatrix[low][low+1] !== 0) {
                 // boundaries are equal, they will survive
@@ -196,12 +202,12 @@ export function order() {
                 // reversed order
                 Array.prototype.splice
                     .apply(perm,
-                           [pos, 0].concat(reorder.range(high-2,low,-1)));
+                           [pos, 0].concat(range(high-2,low,-1)));
             }
             else if (perm[pos+1] == (high-1)) {
                 Array.prototype.splice
                     .apply(perm,
-                           [pos+1, 0].concat(reorder.range(low+1,high-1)));
+                           [pos+1, 0].concat(range(low+1,high-1)));
             }
             else {
                 throw "Range not respected";
@@ -249,7 +255,7 @@ export function order() {
                     }
                     e.unshift(l);
                     // remove equivalent item from dist and vector
-                    distanceMatrix = reorder.dist_remove(distanceMatrix, l);
+                    distanceMatrix = dist_remove(distanceMatrix, l);
                     vector.splice(l, 1);
                 }
                 else if (row[l] < 0)
@@ -339,15 +345,15 @@ export function order() {
     }
 
     function _order() {
-        if (reorder.debug > 1)
-            reorder.printmat(distanceMatrix);
-        if (reorder.debug > 2)
-            reorder.printmat(vector);
+        if (debug > 1)
+            printmat(distanceMatrix);
+        if (debug > 2)
+            printmat(vector);
 
         var perm = ordering()
                 .linkage(linkage)
                 .distanceMatrix(distanceMatrix)(vector);
-        if (reorder.debug)
+        if (debug)
             console.log("Permutation: "+perm);
 
         return perm;
@@ -362,7 +368,7 @@ export function order() {
 
     function _compute_dist() {
         if (distanceMatrix === null)
-            distanceMatrix = (reorder.dist().distance(distance))(vector);
+            distanceMatrix = (dist().distance(distance))(vector);
         return distanceMatrix;
     }
 
@@ -397,7 +403,7 @@ export function order() {
     };
 
     function _orderExcept(vector, i, j) {
-        var distanceMatrix = (reorder.dist().distance(distance))(vector);
+        var distanceMatrix = (dist().distance(distance))(vector);
         var row, k, l, rev = false, args, pos = -1;
 
         // Set a null distance to stick i/i+1 together
@@ -417,7 +423,7 @@ export function order() {
             perm.reverse();
             pos = perm.length-pos-1;
         }
-        args = [pos+1, 0].concat(reorder.range(i+1,j-1));
+        args = [pos+1, 0].concat(range(i+1,j-1));
         Array.prototype.splice.apply(perm, args);
         return perm;
     }
diff --git a/src/pca_order.js b/src/pca_order.js
index 3f652b2..040a0b8 100644
--- a/src/pca_order.js
+++ b/src/pca_order.js
@@ -1,3 +1,8 @@
+import { meancolumns } from './mean';
+import { variancecovariance } from './covariance';
+import { poweriteration } from './poweriteration';
+import { sort_order } from './sort_order';
+
 // Takes a matrix, substract the mean of each row
 // so that the mean is 0
 function center(v) {
@@ -5,7 +10,7 @@ function center(v) {
 
     if (n === 0) return null;
     
-    var mean = reorder.meancolumns(v),
+    var mean = meancolumns(v),
 	o = mean.length,
 	v1 = Array(n),
 	i, j, row;
@@ -28,10 +33,10 @@ export function pca1d(v, eps) {
     if (v.length === 0) return null;
 
     v = center(v);
-    var cov = reorder.variancecovariance(v);
-    return reorder.poweriteration(cov, eps);
+    var cov = variancecovariance(v);
+    return poweriteration(cov, eps);
 };
 
 export function pca_order(v, eps) {
-    return reorder.sort_order(reorder.pca1d(v, eps));
+    return sort_order(pca1d(v, eps));
 };
diff --git a/src/pcp.js b/src/pcp.js
index 176db7a..6d9ae45 100644
--- a/src/pcp.js
+++ b/src/pcp.js
@@ -1,6 +1,13 @@
+import { range } from './range';
+import { debug } from './core';
+import { transpose } from './aliases';
+import { correlation } from './correlation';
+import { optimal_leaf_order } from './optimal_leaf_order';
+import { permute } from './permute';
+
 export function array_to_dicts(data, axes) {
     if (arguments.length < 2) 
-	axes = reorder.range(data[0].length);
+	axes = range(data[0].length);
     var ret = [], row, dict, i, j;
     for (i = 0; i < data.length; i++) {
 	row = data[i];
@@ -46,7 +53,7 @@ function pcp_flip_axes(perm, naxes, pcor) {
 	else
 	    signs.push(1);
     }
-    if (reorder.debug)
+    if (debug)
 	console.log(signs);
     sign = (negs > (perm.length-negs)) ? -1 : 1;
     if (sign==-1) {
@@ -58,22 +65,22 @@ function pcp_flip_axes(perm, naxes, pcor) {
 
 export function pcp(data, axes) {
     if (! axes)
-	axes = reorder.range(data[0].length);
+	axes = range(data[0].length);
     
-    var tdata = reorder.transpose(data),
-	pcor = reorder.correlation.pearsonMatrix(tdata),
+    var tdata = transpose(data),
+	pcor = correlation.pearsonMatrix(tdata),
 	abs_pcor = abs_matrix(pcor),
 	h1 = science.stats.hcluster()
 	    .linkage("complete")
 	    .distanceMatrix(abs_pcor)(tdata),
-	perm = reorder.optimal_leaf_order()
+	perm = optimal_leaf_order()
 	    .distanceMatrix(abs_pcor)(tdata),
-	naxes = reorder.permute(axes, perm);
-    tdata = reorder.permute(tdata, perm);
+	naxes = permute(axes, perm);
+    tdata = permute(tdata, perm);
 
     
     var signs = pcp_flip_axes(perm, naxes, pcor),
-	ndata = reorder.transpose(tdata);
+	ndata = transpose(tdata);
     return [ndata, perm, naxes, signs, pcor];
 }
 
@@ -108,15 +115,15 @@ export function parcoords(p) {
 	    i--;
 	}
     }
-    var pcor = reorder.correlation.pearsonMatrix(tdata),
+    var pcor = correlation.pearsonMatrix(tdata),
 	abs_pcor = abs_matrix(pcor),
 	h1 = science.stats.hcluster()
 	    .linkage("complete")
 	    .distanceMatrix(abs_pcor)(tdata),
-	perm = reorder.optimal_leaf_order()
+	perm = optimal_leaf_order()
 	    .distanceMatrix(abs_pcor)(tdata),
-	naxes = reorder.permute(dimensions, perm);
-    tdata = reorder.permute(tdata, perm);
+	naxes = permute(dimensions, perm);
+    tdata = permute(tdata, perm);
     
     var signs = pcp_flip_axes(perm, naxes, pcor);
     for (i = 0; i < signs.length; i++) {
diff --git a/src/permute.js b/src/permute.js
index 0624085..723ea7d 100644
--- a/src/permute.js
+++ b/src/permute.js
@@ -33,7 +33,7 @@ export function permute_inplace(list, perm) {
 export function permutetranspose(array, indexes) {
     var m = array.length;
     while (m-- > 0)
-	array[m] = reorder.permute(array[m], indexes);
+	array[m] = permute(array[m], indexes);
     return array;
 };
 
diff --git a/src/poweriteration.js b/src/poweriteration.js
index c6e81ac..893cc8a 100644
--- a/src/poweriteration.js
+++ b/src/poweriteration.js
@@ -1,5 +1,10 @@
+import { length, dot } from './aliases';
+import { assert } from './debug';
+import { random_array } from './random';
+import { debug } from './core';
+
 function normalize(v) {
-    var norm = reorder.length(v),
+    var norm = length(v),
 	i = v.length;
     if (norm === 0 || Math.abs(norm - 1) < 1e-9) return 1;
     while (i-- > 0)
@@ -20,9 +25,9 @@ export function poweriteration(v, eps, init) {
 	s = 100,
 	e;
 
-    reorder.assert(n == v[0].length, "poweriteration needs a square matrix");
+    assert(n == v[0].length, "poweriteration needs a square matrix");
     if (! init) {
-	b = reorder.random_array(n);
+	b = random_array(n);
     }
     else
 	b = init.slice(); // copy
@@ -33,7 +38,7 @@ export function poweriteration(v, eps, init) {
             for (j=0; j<n; j++) tmp[i] += v[i][j] * b[j];
 	}
 	normalize(tmp);
-	if (reorder.dot(tmp, b) > (1.0 - eps))
+	if (dot(tmp, b) > (1.0 - eps))
 	    break;
 	var t = tmp; tmp = b; b = t; // swap b/tmp
     }
@@ -52,10 +57,10 @@ export function poweriteration_n(v, p, init, eps, start) {
 	s = 100,
 	eigenvalue = Array(p);
 
-    reorder.assert(n == v[0].length, "poweriteration needs a square matrix");
+    assert(n == v[0].length, "poweriteration needs a square matrix");
     if (! init) {
 	for (i = 0; i < p; i++) {
-	    row = b[i] = reorder.random_array(n);
+	    row = b[i] = random_array(n);
 	    eigenvalue[i] = normalize(row);
 	}
     }
@@ -74,7 +79,7 @@ export function poweriteration_n(v, p, init, eps, start) {
 	    // Orthogonalize vector
 	    for (l = 0; l < k; l++) {
 		row = b[l];
-		dot = reorder.dot(bk, row);
+		dot = dot(bk, row);
 		for (i = 0; i < n; i++)
 		    bk[i] -= dot*row[i];
 	    }
@@ -85,11 +90,11 @@ export function poweriteration_n(v, p, init, eps, start) {
 		    tmp[i] += v[i][j] * bk[j];
 	    }
 	    eigenvalue[k] = normalize(tmp);
-	    if (reorder.dot(tmp, bk) > (1 - eps))
+	    if (dot(tmp, bk) > (1 - eps))
 	    	break;
 	    bk = tmp; tmp = b[k]; b[k] = bk;  // swap b/tmp
 	}
-	if (reorder.debug)
+	if (debug)
 	    console.log('eig[%d]=%j',k, bk);
     }
     return [b, eigenvalue];
diff --git a/src/random.js b/src/random.js
index ad4224e..7b32862 100644
--- a/src/random.js
+++ b/src/random.js
@@ -1,7 +1,7 @@
 /* Fisher-Yates shuffle.
    See http://bost.ocks.org/mike/shuffle/
  */
-reorder.randomPermute = function(array, i, j) {
+export function randomPermute(array, i, j) {
     if (arguments.length < 3) {
 	j = array.length;
 	if (arguments.length < 2) {
@@ -18,11 +18,11 @@ reorder.randomPermute = function(array, i, j) {
     return array;
 };
 
-reorder.randomPermutation = function(n) {
+export function randomPermutation(n) {
     return reorder.randomPermute(reorder.permutation(n));
 };
 
-reorder.random_array = function(n, min, max) {
+export function random_array(n, min, max) {
     var ret = Array(n);
     if (arguments.length == 1) {
 	while(n) ret[--n] = Math.random();
@@ -36,7 +36,7 @@ reorder.random_array = function(n, min, max) {
     return ret;
 };
 
-reorder.random_matrix = function(p, n, m, sym) {
+export function random_matrix(p, n, m, sym) {
     if (! m)
 	m = n;
     if (n != m)
diff --git a/src/sort_order.js b/src/sort_order.js
index de9e675..8088afa 100644
--- a/src/sort_order.js
+++ b/src/sort_order.js
@@ -1,11 +1,13 @@
+import { permutation } from './permutation';
+
 export function sort_order(v) {
-    return reorder.permutation(0, v.length).sort(
+    return permutation(0, v.length).sort(
 	function(a,b) { return v[a] - v[b]; });
 };
 
 export const sort_order_ascending = sort_order;
 
 export function sort_order_descending(v) {
-    return reorder.permutation(0, v.length).sort(
+    return permutation(0, v.length).sort(
 	function(a,b) { return v[b] - v[a]; });
 };
diff --git a/src/spectral_order.js b/src/spectral_order.js
index ab8027f..88ec23e 100644
--- a/src/spectral_order.js
+++ b/src/spectral_order.js
@@ -1,3 +1,8 @@
+import { fiedler_vector } from './fiedler';
+import { laplacian } from './laplacian';
+import { sort_order } from './sort_order';
+import { permute } from './permute';
+
 export function spectral_order(graph, comps) {
     var i, vec, comp, perm, order = [];
     if (! comps)
@@ -5,9 +10,9 @@ export function spectral_order(graph, comps) {
 
     for (i = 0; i < comps.length; i++) {
 	comp = comps[i];
-	vec = reorder.fiedler_vector(reorder.laplacian(graph, comp));
-	perm = reorder.sort_order(vec);
-	order = order.concat(reorder.permute(comp, perm));
+	vec = fiedler_vector(laplacian(graph, comp));
+	perm = sort_order(vec);
+	order = order.concat(permute(comp, perm));
     }
     return order;
 }
diff --git a/src/stablepermute.js b/src/stablepermute.js
index b3305be..e30d71c 100644
--- a/src/stablepermute.js
+++ b/src/stablepermute.js
@@ -1,5 +1,7 @@
+import { permute } from './permute';
+
 export function stablepermute(list, indexes) {
-    var p = reorder.permute(list, indexes);
+    var p = permute(list, indexes);
     if (p[0] > p[p.length-1]) {
 	p.reverse();
     }
diff --git a/src/utils.js b/src/utils.js
index 548a16f..525ffeb 100644
--- a/src/utils.js
+++ b/src/utils.js
@@ -1,11 +1,11 @@
-// Use as: [4,3,2].sort(reorder.cmp_number_asc);
+// Use as: [4,3,2].sort(cmp_number_asc);
 export function cmp_number_asc(a,b) { return a-b; };
 export const cmp_number = cmp_number_asc;
 
-// Use as: [4,3,2].sort(reorder.cmp_number_desc);
+// Use as: [4,3,2].sort(cmp_number_desc);
 export function cmp_number_desc(a,b) { return b-a; };
 
-// Use as: [[4,3],[2]].reduce(reorder.flaten);
+// Use as: [[4,3],[2]].reduce(flaten);
 export function flatten(a,b) { return a.concat(b); };
 
 // Constructs a multi-dimensional array filled with Infinity.
@@ -17,7 +17,7 @@ export function infinities(n) {
 	    a[i] = Infinity;
     else
 	while (++i < n)
-	    a[i] = reorder.infinities.apply(
+	    a[i] = infinities.apply(
 		this, Array.prototype.slice.call(arguments, 1));
     return a;
 };