diff --git a/.gitignore b/.gitignore
index 5148e52..f7f9a88 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,37 +1,37 @@
-# Logs
-logs
-*.log
-npm-debug.log*
-
-# Runtime data
-pids
-*.pid
-*.seed
-
-# Directory for instrumented libs generated by jscoverage/JSCover
-lib-cov
-
-# Coverage directory used by tools like istanbul
-coverage
-
-# nyc test coverage
-.nyc_output
-
-# Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files)
-.grunt
-
-# node-waf configuration
-.lock-wscript
-
-# Compiled binary addons (http://nodejs.org/api/addons.html)
-build/Release
-
-# Dependency directories
-node_modules
-jspm_packages
-
-# Optional npm cache directory
-.npm
-
-# Optional REPL history
-.node_repl_history
+# Logs
+logs
+*.log
+npm-debug.log*
+
+# Runtime data
+pids
+*.pid
+*.seed
+
+# Directory for instrumented libs generated by jscoverage/JSCover
+lib-cov
+
+# Coverage directory used by tools like istanbul
+coverage
+
+# nyc test coverage
+.nyc_output
+
+# Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files)
+.grunt
+
+# node-waf configuration
+.lock-wscript
+
+# Compiled binary addons (http://nodejs.org/api/addons.html)
+build/Release
+
+# Dependency directories
+node_modules
+jspm_packages
+
+# Optional npm cache directory
+.npm
+
+# Optional REPL history
+.node_repl_history
diff --git a/README.md b/README.md
index adc19d4..730986e 100644
--- a/README.md
+++ b/README.md
@@ -2,7 +2,8 @@
 
 ## salesman
 **See**: [demo](https://lovasoa.github.io/salesman.js/)  
-**Author:** Ophir LOJKINE
+**Author**: Ophir LOJKINE
+
 salesman npm module
 
 Good heuristic for the traveling salesman problem using simulated annealing.  
@@ -10,39 +11,40 @@ Good heuristic for the traveling salesman problem using simulated annealing.
 * [salesman](#module_salesman)
     * [~Point](#module_salesman..Point)
         * [new Point(x, y)](#new_module_salesman..Point_new)
-    * [~solve(points, [temp_coeff], [callback=])](#module_salesman..solve) ⇒ <code>Array.&lt;Number&gt;</code>
+    * [~solve(points, [temp_coeff], [callback], [callback])](#module_salesman..solve) ⇒ <code>Array.&lt;number&gt;</code>
 
 <a name="module_salesman..Point"></a>
 
 ### salesman~Point
-**Kind**: inner class of <code>[salesman](#module_salesman)</code>  
+**Kind**: inner class of [<code>salesman</code>](#module_salesman)  
 <a name="new_module_salesman..Point_new"></a>
 
 #### new Point(x, y)
-Represents a point in two dimensions.
+Represents a point in two dimensions. Used as the input for `solve`.
 
 
 | Param | Type | Description |
 | --- | --- | --- |
-| x | <code>Number</code> | abscissa |
-| y | <code>Number</code> | ordinate |
+| x | <code>number</code> | abscissa |
+| y | <code>number</code> | ordinate |
 
 <a name="module_salesman..solve"></a>
 
-### salesman~solve(points, [temp_coeff], [callback=]) ⇒ <code>Array.&lt;Number&gt;</code>
+### salesman~solve(points, [temp_coeff], [callback], [callback]) ⇒ <code>Array.&lt;number&gt;</code>
 Solves the following problem:
  Given a list of points and the distances between each pair of points,
  what is the shortest possible route that visits each point exactly
  once and returns to the origin point?
 
-**Kind**: inner method of <code>[salesman](#module_salesman)</code>  
-**Returns**: <code>Array.&lt;Number&gt;</code> - An array of indexes in the original array. Indicates in which order the different points are visited.  
+**Kind**: inner method of [<code>salesman</code>](#module_salesman)  
+**Returns**: <code>Array.&lt;number&gt;</code> - An array of indexes in the original array. Indicates in which order the different points are visited.  
 
 | Param | Type | Default | Description |
 | --- | --- | --- | --- |
 | points | <code>Array.&lt;Point&gt;</code> |  | The points that the path will have to visit. |
-| [temp_coeff] | <code>Number</code> | <code>0.999</code> | changes the convergence speed of the algorithm: the closer to 1, the slower the algorithm and the better the solutions. |
-| [callback=] | <code>function</code> |  | An optional callback to be called after each iteration. |
+| [temp_coeff] | <code>number</code> | <code>0.999</code> | changes the convergence speed of the algorithm. Smaller values (0.9) work faster but give poorer solutions, whereas values closer to 1 (0.99999) work slower, but give better solutions. |
+| [callback] | <code>function</code> |  | An optional callback to be called after each iteration. |
+| [callback] | <code>function</code> | <code>euclidean</code> | An optional argument to specify how distances are calculated. The function takes two Point objects as arguments and returns a number for distance. Defaults to simple Euclidean distance calculation. |
 
 **Example**  
 ```js
diff --git a/package.json b/package.json
index 8e50ee2..4a9ce3e 100644
--- a/package.json
+++ b/package.json
@@ -5,7 +5,7 @@
   "main": "salesman.js",
   "scripts": {
     "test": "node test.js",
-    "prepare": "node salesman.js && node node_modules/jsdoc-to-markdown/bin/cli.js --src salesman.js > README.md"
+    "prepare": "node salesman.js && node node_modules/jsdoc-to-markdown/bin/cli.js --files salesman.js > README.md"
   },
   "repository": {
     "type": "git",
@@ -27,6 +27,6 @@
   },
   "homepage": "https://github.com/lovasoa/salesman.js",
   "devDependencies": {
-    "jsdoc-to-markdown": "1.3"
+    "jsdoc-to-markdown": "^6.0.1"
   }
 }
diff --git a/perf_test.js b/perf_test.js
new file mode 100644
index 0000000..297863c
--- /dev/null
+++ b/perf_test.js
@@ -0,0 +1,42 @@
+const {
+  performance,
+  PerformanceObserver
+} = require('perf_hooks');
+const salesman = require("./salesman.js");
+
+const width = 100;
+const height = 100;
+const size = 5000;
+const perfTestCount = 500;
+
+function createPoint(id) {
+  return {id, x: width * Math.random(), y: height * Math.random()};
+}
+
+const durations = [];
+
+function arraySum(arr) {
+  return arr.reduce((a,b) => a + b, 0);
+}
+
+function arrayAvg(arr) {
+  return arraySum(arr) / arr.length;
+}
+
+for (let i = 1; i <= perfTestCount; i++) {
+  console.log(`Running test ${i}`);
+
+  const testPoints = [...Array(size).keys()].map((index) => (createPoint(index)));
+
+  const startTime = performance.now();
+  const result = salesman.solve(testPoints);
+  const duration = (performance.now() - startTime) / 1000; // Milliseconds
+  durations.push(duration);
+  console.log(`Test ${i} done, took ${duration}`);
+}
+
+console.log('RESULTS');
+console.log('-------');
+console.log(`* Average Time: ${arrayAvg(durations)}`);
+console.log(`* Max Time: ${Math.max(...durations)}`);
+console.log(`* Min Time: ${Math.min(...durations)}`);
\ No newline at end of file
diff --git a/salesman.js b/salesman.js
index 90f2967..1978fe2 100644
--- a/salesman.js
+++ b/salesman.js
@@ -1,6 +1,7 @@
 /**
  * @module
  * @author Ophir LOJKINE
+ * 
  * salesman npm module
  *
  * Good heuristic for the traveling salesman problem using simulated annealing.
@@ -9,66 +10,163 @@
 
 
 /**
+ * 
+ * Represents a path between points.
+ * Includes an internal order for those points,
+ * along with an array which maintains a record of distances between points.
+ * @param {Points[]} points The points in the path.
+ * @param {Function} distanceFunc The function to use to calculate the distance between two points.
  * @private
  */
-function Path(points) {
-  this.points = points;
-  this.order = new Array(points.length);
-  for(var i=0; i<points.length; i++) this.order[i] = i;
-  this.distances = new Array(points.length * points.length);
-  for(var i=0; i<points.length; i++)
-    for(var j=0; j<points.length; j++)
-      this.distances[j + i*points.length] = distance(points[i], points[j]);
-}
-Path.prototype.change = function(temp) {
-  var i = this.randomPos(), j = this.randomPos();
-  var delta = this.delta_distance(i, j);
-  if (delta < 0 || Math.random() < Math.exp(-delta / temp)) {
-    this.swap(i,j);
+class Path {
+  constructor(points, distanceFunc){
+    this.points = points;
+    this.distanceFunc = distanceFunc;
+    this.initializeOrder();
+    this.initializeDistances();
   }
-};
-Path.prototype.size = function() {
-  var s = 0;
-  for (var i=0; i<this.points.length; i++) {
-    s += this.distance(i, ((i+1)%this.points.length));
+
+  /**
+   * Creates the default order for the points.
+   */
+  initializeOrder() {
+    // A loop is about 3x faster than using a spread operator.
+    this.order = new Array(this.points.length);
+    for (let i = 0; i < this.order.length; i++) this.order[i] = i;
+  }
+
+  /**
+   * Calculates the distance for all the points.
+   */
+  initializeDistances() {
+    this.distances = new Array(this.points.length * this.points.length);
+    for(let i = 0; i < this.points.length; i++) {
+      // Optimization: Starting at i+1 avoids repeats and identity distances.
+      // We just need to make sure we don't access the empty cells later.
+      for(let j = i + 1; j < this.points.length; j++) {
+        this.distances[j + i * this.points.length] = this.distanceFunc(this.points[i], this.points[j]);
+      }
+    }
+  }
+
+  /**
+   * Perform one iteration of the simulated annealing.
+   * 
+   * Choose two random points in the path, and calculate how much the path distance would change
+   * if you swapped the two points. If it would make the path shorter, swap them.
+   * 
+   * If not, have a random chance to swap them anyway.
+   * This random chance is based on how bad the move is,
+   * as well as how early in the annealing process we are (the "temperature").
+   * 
+   * @param {number} temp The current temperature of the algorithm.
+   */
+  change(temp) {
+    const i = this.randomPos(), j = this.randomPos();
+    const delta = this.delta_distance(i, j);
+    if (delta < 0 || Math.random() < Math.exp(-delta / temp)) {
+      this.swap(i,j);
+    }
+  }
+
+  /**
+   * Swap two points in the path order by their indices.
+   * @param {number} i The first index to swap.
+   * @param {number} j The second index to swap.
+   */
+  swap(i,j) {
+    const tmp = this.order[i];
+    this.order[i] = this.order[j];
+    this.order[j] = tmp;
+  };
+
+  /**
+   * Calculate the change in path distance if i and j were swapped.
+   * 
+   * Calculate the distance between i and j's neighbors,
+   * plus the distance between j and i's neighbors, minus the current distances.
+   * 
+   * If the value is negative, it would make the path shorter to swap the values.
+   * @param {number} i The first index to compare.
+   * @param {number} j The second index to compare.
+   * @returns {number} The change in path distance if i and j were swapped.
+   */
+  delta_distance(i, j) {
+    const jm1 = this.index(j-1),
+        jp1 = this.index(j+1),
+        im1 = this.index(i-1),
+        ip1 = this.index(i+1);
+    let s = 
+        this.distance(jm1, i  )
+      + this.distance(i  , jp1)
+      + this.distance(im1, j  )
+      + this.distance(j  , ip1)
+      - this.distance(im1, i  )
+      - this.distance(i  , ip1)
+      - this.distance(jm1, j  )
+      - this.distance(j  , jp1);
+    if (jm1 === i || jp1 === i)
+      s += 2*this.distance(i,j); 
+    return s;
+  }
+
+  /**
+   * Get the ith point in the point array.
+   * The path is cyclic, so i can be positive or negative,
+   * smaller or larger than the total number of points.
+   * @param {number} i The index to retrieve.
+   * @returns {number}
+   */
+  index(i) {
+    return (i + this.points.length) % this.points.length;
+  }
+
+  /**
+   * Get the ith point in the path order.
+   * @param {*} i The index to retrieve. 
+   */
+  access(i) {
+    return this.points[this.order[this.index(i)]];
+  }  
+
+  /**
+   * Access the cached distance between two points, by their indices.
+   * @param {number} i The first index as an integer
+   * @param {number} j The second index as an integer
+   * @returns {number} The distance between point i and point j.
+   */
+  distance(i, j) {
+    if (i === j) return 0; // Identity.
+
+    // Ensure low is actually lower.
+    let low = this.order[i], high = this.order[j];
+    if (low > high) { low = this.order[j]; high = this.order[i]; }
+
+    return this.distances[low * this.points.length + high] || 0;
+  }
+
+  /**
+   * Retrieve a random index between 1 and the last position in the array of points.
+   * @returns {number} A random index.
+   */
+  randomPos() {
+    return 1 + Math.floor(Math.random() * (this.points.length - 1));
+  };
+}
+
+
+
+/**
+ * Represents a point in two dimensions. Used as the input for `solve`.
+ * @class
+ * @param {number} x abscissa
+ * @param {number} y ordinate
+ */
+class Point {
+  constructor(x, y) {
+    this.x = x;
+    this.y = y;    
   }
-  return s;
-};
-Path.prototype.swap = function(i,j) {
-  var tmp = this.order[i];
-  this.order[i] = this.order[j];
-  this.order[j] = tmp;
-};
-Path.prototype.delta_distance = function(i, j) {
-  var jm1 = this.index(j-1),
-      jp1 = this.index(j+1),
-      im1 = this.index(i-1),
-      ip1 = this.index(i+1);
-  var s = 
-      this.distance(jm1, i  )
-    + this.distance(i  , jp1)
-    + this.distance(im1, j  )
-    + this.distance(j  , ip1)
-    - this.distance(im1, i  )
-    - this.distance(i  , ip1)
-    - this.distance(jm1, j  )
-    - this.distance(j  , jp1);
-  if (jm1 === i || jp1 === i)
-    s += 2*this.distance(i,j); 
-  return s;
-};
-Path.prototype.index = function(i) {
-  return (i + this.points.length) % this.points.length;
-};
-Path.prototype.access = function(i) {
-  return this.points[this.order[this.index(i)]];
-};
-Path.prototype.distance = function(i, j) {
-  return this.distances[this.order[i] * this.points.length + this.order[j]];
-};
-// Random index between 1 and the last position in the array of points
-Path.prototype.randomPos = function() {
-  return 1 + Math.floor(Math.random() * (this.points.length - 1));
 };
 
 /**
@@ -78,49 +176,52 @@ Path.prototype.randomPos = function() {
  *  once and returns to the origin point?
  *
  * @param {Point[]} points The points that the path will have to visit.
- * @param {Number} [temp_coeff=0.999] changes the convergence speed of the algorithm: the closer to 1, the slower the algorithm and the better the solutions.
- * @param {Function} [callback=] An optional callback to be called after each iteration.
+ * @param {number} [temp_coeff=0.999] changes the convergence speed of the algorithm. Smaller values (0.9) work faster but give poorer solutions, whereas values closer to 1 (0.99999) work slower, but give better solutions.
+ * @param {Function} [callback=undefined] An optional callback to be called after each iteration.
+ * @param {Function} [callback=euclidean] An optional argument to specify how distances are calculated. The function takes two Point objects as arguments and returns a number for distance. Defaults to simple Euclidean distance calculation.
  *
- * @returns {Number[]} An array of indexes in the original array. Indicates in which order the different points are visited.
+ * @returns {number[]} An array of indexes in the original array. Indicates in which order the different points are visited.
  *
  * @example
- * var points = [
+ * const points = [
  *       new salesman.Point(2,3)
  *       //other points
  *     ];
- * var solution = salesman.solve(points);
- * var ordered_points = solution.map(i => points[i]);
+ * const solution = salesman.solve(points);
+ * const ordered_points = solution.map(i => points[i]);
  * // ordered_points now contains the points, in the order they ought to be visited.
  **/
-function solve(points, temp_coeff, callback) {
-  var path = new Path(points);
-  if (points.length < 2) return path.order; // There is nothing to optimize
+function solve(points, temp_coeff = 0.999, callback, distance = euclidean) {
+  const path = new Path(points, distance);
+  // Optimization: If there is only one point in the list, there is no path.
+  if (points.length < 2) return path.order;
+  // Optimization: If the user would provide a bad input, end immediately.
+  if (temp_coeff >= 1 || temp_coeff <= 0) return path.order;
+
+  // Create a temperature coefficient.
   if (!temp_coeff)
     temp_coeff = 1 - Math.exp(-10 - Math.min(points.length,1e6)/1e5);
-  var has_callback = typeof(callback) === "function";
+  const hasCallback = typeof(callback) === "function";
 
-  for (var temperature = 100 * distance(path.access(0), path.access(1));
+  for (let temperature = 100 * distance(path.access(0), path.access(1));
            temperature > 1e-6;
            temperature *= temp_coeff) {
     path.change(temperature);
-    if (has_callback) callback(path.order);
+    if (hasCallback) callback(path.order);
   }
   return path.order;
 };
 
 /**
- * Represents a point in two dimensions.
- * @class
- * @param {Number} x abscissa
- * @param {Number} y ordinate
+ * @private
+ * 
+ * A simple distance function, to use as the default.
+ * @param {Point} p 
+ * @param {Point} q 
+ * @returns {number} The Euclidean distance between p and q
  */
-function Point(x, y) {
-  this.x = x;
-  this.y = y;
-};
-
-function distance(p, q) {
-  var dx = p.x - q.x, dy = p.y - q.y;
+function euclidean(p, q) {
+  const dx = p.x - q.x, dy = p.y - q.y;
   return Math.sqrt(dx*dx + dy*dy);
 }
 
diff --git a/test.js b/test.js
index 6bad092..ac52351 100644
--- a/test.js
+++ b/test.js
@@ -1,14 +1,15 @@
-var assert = require("assert");
-var salesman = require("./salesman.js");
+const assert = require("assert");
+const salesman = require("./salesman.js");
 
-var tests = [
+const tests = [
     {q:[[0,0]], r:[0]},
     {q:[[0,0],[1,1]], r:[0,1]},
 ];
 
 
 for(let test of tests) {
-    var points = test.q.map(([x,y])=>new salesman.Point(x,y));
-    var res = salesman.solve(points);
-    assert.deepEqual(test.r, res);
+    const points = test.q.map(([x,y])=>new salesman.Point(x,y));
+    const res = salesman.solve(points);
+    assert.deepStrictEqual(test.r, res);
 }
+console.log('Test finalized successfully');