From 1fd6476db0c6385cef0ff52dd2ff0677fbb1bbe1 Mon Sep 17 00:00:00 2001
From: Ricky Reusser <ricky@standardcyborg.com>
Date: Mon, 5 Feb 2018 15:12:45 -0800
Subject: [PATCH 1/9] Add tests

---
 package.json  |   3 +-
 test/index.js | 224 ++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 226 insertions(+), 1 deletion(-)
 create mode 100644 test/index.js

diff --git a/package.json b/package.json
index dd4657c..33ced8c 100644
--- a/package.json
+++ b/package.json
@@ -13,7 +13,8 @@
   ],
   "dependencies": {},
   "devDependencies": {
-    "dox": "git://github.com/hughsk/dox#api-context"
+    "dox": "git://github.com/hughsk/dox#api-context",
+    "tape": "^4.8.0"
   },
   "scripts": {
     "get-docs": "cat *.js | dox --api"
diff --git a/test/index.js b/test/index.js
new file mode 100644
index 0000000..909fed5
--- /dev/null
+++ b/test/index.js
@@ -0,0 +1,224 @@
+var test = require('tape')
+var vec3 = require('../')
+var EPSILON = 0.000001
+
+test('add', function (t) {
+  var result = vec3.add([], [0, 1, 2], [3, 4, 5])
+  t.deepEqual(result, [3, 5, 7])
+  t.end()
+})
+
+test('angle', function (t) {
+  var result = vec3.angle([3, 4, 5], [6, 7, 8])
+  t.ok(Math.abs(0.08523986989116927 - result) < EPSILON)
+  t.end()
+})
+
+test('clone', function (t) {
+  var result = vec3.clone([5, 6, 7])
+  t.deepEqual(result, [5, 6, 7])
+  t.end()
+})
+
+test('copy', function (t) {
+  var result = vec3.copy([], [5, 6, 7])
+  t.deepEqual(result, [5, 6, 7])
+  t.end()
+})
+
+test('create', function (t) {
+  var result = vec3.create()
+  t.deepEqual(result, [0, 0, 0])
+  t.end()
+})
+
+test('cross', function (t) {
+  var result = vec3.cross([], [3, 4, 5], [6, 7, 8])
+  t.deepEqual(result, [-3, 6, -3])
+  t.end()
+})
+
+test('distance', function (t) {
+  var result = vec3.distance([1, 2, 3], [4, 6, 7])
+  t.ok(Math.abs(result - 6.4031242374328485) < EPSILON)
+  t.end()
+})
+
+test('divide', function (t) {
+  var result = vec3.divide([], [8, 4, 2], [2, 1, 0.5])
+  t.deepEqual(result, [4, 4, 4])
+  t.end()
+})
+
+test('dot', function (t) {
+  var result = vec3.dot([3, 4, 5], [6, 7, 8])
+  t.deepEqual(result, 86)
+  t.end()
+})
+
+test('forEach', function (t) {
+  var a = [null,
+    0, 1, 2, null,
+    3, 4, 5, null
+  ]
+
+  function addConstant (out, a, val) {
+    out[0] = a[0] + val
+    out[1] = a[1] + val
+    out[2] = a[2] + val
+    return out
+  }
+
+  vec3.forEach(a, 4, 1, 2, addConstant, 7)
+
+  t.deepEqual(a, [null, 7, 8, 9, null, 10, 11, 12, null])
+  t.end()
+})
+
+test('fromValues', function (t) {
+  var result = vec3.fromValues(2, 3, 4)
+  t.deepEqual(result, [2, 3, 4])
+  t.end()
+})
+
+test('inverse', function (t) {
+  var result = vec3.inverse([], [2, 4, 8])
+  t.deepEqual(result, [0.5, 0.25, 0.125])
+  t.end()
+})
+
+test('length', function (t) {
+  var result = vec3.length([3, 4, 5])
+  t.ok(Math.abs(result - 7.0710678118654755) < EPSILON)
+  t.end()
+})
+
+test('lerp', function (t) {
+  var result = vec3.lerp([], [3, 4, 5], [6, 7, 8], 0.25)
+  t.deepEqual(result, [3.75, 4.75, 5.75])
+  t.end()
+})
+
+test('max', function (t) {
+  var result = vec3.max([], [3, 7, 2], [5, 6, 4])
+  t.deepEqual(result, [5, 7, 4])
+  t.end()
+})
+
+test('min', function (t) {
+  var result = vec3.min([], [3, 7, 8], [5, 6, 2])
+  t.deepEqual(result, [3, 6, 2])
+  t.end()
+})
+
+test('multiply', function (t) {
+  var result = vec3.multiply([], [3, 4, 5], [6, 7, 8])
+  t.deepEqual(result, [18, 28, 40])
+  t.end()
+})
+
+test('negate', function (t) {
+  var result = vec3.negate([], [3, 4, 5])
+  t.deepEqual(result, [-3, -4, -5])
+  t.end()
+})
+
+test('normalize', function (t) {
+  var result = vec3.normalize([], [3, 4, 5])
+  t.ok(Math.abs(result[0] - 0.4242640687119285) < EPSILON)
+  t.ok(Math.abs(result[1] - 0.565685424949238) < EPSILON)
+  t.ok(Math.abs(result[2] - 0.7071067811865475) < EPSILON)
+  t.end()
+})
+
+test('random', function (t) {
+  var result = vec3.random([], 5)
+  for (var i = 0; i < 10; i++) {
+    var len = Math.sqrt(result[0] * result[0] + result[1] * result[1] + result[2] * result[2])
+    t.ok(Math.abs(5 - len) <= EPSILON)
+  }
+  t.end()
+})
+
+test('rotateX', function (t) {
+  var result = vec3.rotateX([], [3, 4, 5], [6, 7, 8], Math.PI)
+  t.deepEqual(result, [3, 10, 11])
+  t.end()
+})
+
+test('rotateY', function (t) {
+  var result = vec3.rotateY([], [3, 4, 5], [6, 7, 8], Math.PI)
+  t.deepEqual(result, [9, 4, 11])
+  t.end()
+})
+
+test('rotateZ', function (t) {
+  var result = vec3.rotateZ([], [3, 4, 5], [6, 7, 8], Math.PI)
+  t.deepEqual(result, [9, 10, 5])
+  t.end()
+})
+
+test('scale', function (t) {
+  var result = vec3.scale([], [3, 4, 5], 2)
+  t.deepEqual(result, [6, 8, 10])
+  t.end()
+})
+
+test('scaleAndAdd', function (t) {
+  var result = vec3.scaleAndAdd([], [3, 4, 5], [6, 7, 8], 2)
+  t.deepEqual(result, [15, 18, 21])
+  t.end()
+})
+
+test('set', function (t) {
+  var result = vec3.set([], 3, 4, 5)
+  t.deepEqual(result, [3, 4, 5])
+  t.end()
+})
+
+test('squaredDistance', function (t) {
+  var result = vec3.squaredDistance([3, 4, 5], [6, 7, 8])
+  t.deepEqual(result, 27)
+  t.end()
+})
+
+test('squaredLength', function (t) {
+  var result = vec3.squaredLength([3, 4, 5])
+  t.deepEqual(result, 50)
+  t.end()
+})
+
+test('subtract', function (t) {
+  var result = vec3.subtract([], [3, 4, 5], [6, 7, 8])
+  t.deepEqual(result, [-3, -3, -3])
+  t.end()
+})
+
+test('transformMat3', function (t) {
+  var result = vec3.transformMat3([], [3, 4, 5], [
+    5, 6, 7,
+    8, 9, 10,
+    11, 12, 13
+  ])
+  t.deepEqual(result, [102, 114, 126])
+  t.end()
+})
+
+test('transformMat4', function (t) {
+  var result = vec3.transformMat4([], [3, 4, 5], [
+    5, 6, 7, 8,
+    9, 10, 11, 12,
+    13, 14, 15, 16,
+    17, 18, 19, 20
+  ])
+  t.ok(Math.abs(0.7732558139534884 - result[0]) < EPSILON)
+  t.ok(Math.abs(0.8488372093023255 - result[1]) < EPSILON)
+  t.ok(Math.abs(0.9244186046511628 - result[2]) < EPSILON)
+  t.end()
+})
+
+test('transformQuat', function (t) {
+  var result = vec3.transformQuat([], [3, 4, 5], [6, 7, 8, 9])
+  t.deepEqual(result, [882, 824, 1090])
+  t.end()
+})

From 896fedb495d17a007703d221a3a0a2e0b9942f1b Mon Sep 17 00:00:00 2001
From: Ricky Reusser <ricky@standardcyborg.com>
Date: Mon, 5 Feb 2018 15:41:19 -0800
Subject: [PATCH 2/9] Add test script

---
 package.json | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/package.json b/package.json
index 33ced8c..a870a72 100644
--- a/package.json
+++ b/package.json
@@ -17,7 +17,8 @@
     "tape": "^4.8.0"
   },
   "scripts": {
-    "get-docs": "cat *.js | dox --api"
+    "get-docs": "cat *.js | dox --api",
+    "test": "node test/index.js"
   },
   "keywords": [
     "gl-matrix",

From caad95abc5cf6ec6997647fbc3320c4faedf2396 Mon Sep 17 00:00:00 2001
From: Ricky Reusser <ricky@standardcyborg.com>
Date: Mon, 5 Feb 2018 17:38:30 -0800
Subject: [PATCH 3/9] Add dist, div, len, mul, sqrDist, sqrLen, sub aliases

---
 README.md     | 23 +++++++++++++++--------
 dist.js       |  1 +
 div.js        |  1 +
 index.js      |  9 ++++++++-
 len.js        |  1 +
 mul.js        |  1 +
 sqrDist.js    |  1 +
 sqrLen.js     |  1 +
 sub.js        |  1 +
 test/index.js | 36 ++++++++++++++++++++++++++++++++++++
 10 files changed, 66 insertions(+), 9 deletions(-)
 create mode 100644 dist.js
 create mode 100644 div.js
 create mode 100644 len.js
 create mode 100644 mul.js
 create mode 100644 sqrDist.js
 create mode 100644 sqrLen.js
 create mode 100644 sub.js

diff --git a/README.md b/README.md
index 7f3c17e..859f528 100644
--- a/README.md
+++ b/README.md
@@ -32,16 +32,20 @@ var scale = require('gl-vec3/scale')
   - [create()](#create)
   - [cross()](#crossoutvec3avec3bvec3)
   - [distance()](#distanceavec3bvec3)
+  - [dist()](#distanceavec3bvec3)
   - [divide()](#divideoutvec3avec3bvec3)
+  - [div()](#divideoutvec3avec3bvec3)
   - [dot()](#dotavec3bvec3)
   - [forEach()](#foreachaarraystridenumberoffsetnumbercountnumberfnfunctionargobject)
   - [fromValues()](#fromvaluesxnumberynumberznumber)
   - [inverse()](#inverseoutvec3avec3)
   - [length()](#lengthavec3)
+  - [len()](#lengthavec3)
   - [lerp()](#lerpoutvec3avec3bvec3tnumber)
   - [max()](#maxoutvec3avec3bvec3)
   - [min()](#minoutvec3avec3bvec3)
   - [multiply()](#multiplyoutvec3avec3bvec3)
+  - [mul()](#multiplyoutvec3avec3bvec3)
   - [negate()](#negateoutvec3avec3)
   - [normalize()](#normalizeoutvec3avec3)
   - [random()](#randomoutvec3scalenumber)
@@ -52,8 +56,11 @@ var scale = require('gl-vec3/scale')
   - [scaleAndAdd()](#scaleandaddoutvec3avec3bvec3scalenumber)
   - [set()](#setoutvec3xnumberynumberznumber)
   - [squaredDistance()](#squareddistanceavec3bvec3)
+  - [sqrDist()](#squareddistanceavec3bvec3)
   - [squaredLength()](#squaredlengthavec3)
+  - [sqrLen()](#squaredlengthavec3)
   - [subtract()](#subtractoutvec3avec3bvec3)
+  - [sub()](#subtractoutvec3avec3bvec3)
   - [transformMat3()](#transformmat3outvec3avec3mmat4)
   - [transformMat4()](#transformmat4outvec3avec3mmat4)
   - [transformQuat()](#transformquatoutvec3avec3qquat)
@@ -84,11 +91,11 @@ var scale = require('gl-vec3/scale')
 
 ## distance(a:vec3, b:vec3)
 
-  Calculates the euclidian distance between two vec3's
+  Calculates the euclidian distance between two vec3's. Aliased as `dist`
 
 ## divide(out:vec3, a:vec3, b:vec3)
 
-  Divides two vec3's
+  Divides two vec3's. Aliased as `div`
 
 ## dot(a:vec3, b:vec3)
 
@@ -108,7 +115,7 @@ var scale = require('gl-vec3/scale')
 
 ## length(a:vec3)
 
-  Calculates the length of a vec3
+  Calculates the length of a vec3. Aliased as `len`
 
 ## lerp(out:vec3, a:vec3, b:vec3, t:Number)
 
@@ -124,7 +131,7 @@ var scale = require('gl-vec3/scale')
 
 ## multiply(out:vec3, a:vec3, b:vec3)
 
-  Multiplies two vec3's
+  Multiplies two vec3's. Aliased as `mul`
 
 ## negate(out:vec3, a:vec3)
 
@@ -164,15 +171,15 @@ var scale = require('gl-vec3/scale')
 
 ## squaredDistance(a:vec3, b:vec3)
 
-  Calculates the squared euclidian distance between two vec3's
+  Calculates the squared euclidian distance between two vec3's. Aliased as `sqrDist`
 
 ## squaredLength(a:vec3)
 
-  Calculates the squared length of a vec3
+  Calculates the squared length of a vec3. Aliased as `sqrLen`
 
 ## subtract(out:vec3, a:vec3, b:vec3)
 
-  Subtracts vector b from vector a
+  Subtracts vector b from vector a. Aliased as `sub`
 
 ## transformMat3(out:vec3, a:vec3, m:mat4)
 
@@ -189,4 +196,4 @@ var scale = require('gl-vec3/scale')
 
 ## License
 
-[zlib](http://en.wikipedia.org/wiki/Zlib_License). See [LICENSE.md](https://github.com/stackgl/gl-vec3/blob/master/LICENSE.md) for details.
\ No newline at end of file
+[zlib](http://en.wikipedia.org/wiki/Zlib_License). See [LICENSE.md](https://github.com/stackgl/gl-vec3/blob/master/LICENSE.md) for details.
diff --git a/dist.js b/dist.js
new file mode 100644
index 0000000..fc548d9
--- /dev/null
+++ b/dist.js
@@ -0,0 +1 @@
+module.exports = require('./distance')
diff --git a/div.js b/div.js
new file mode 100644
index 0000000..ffdd25e
--- /dev/null
+++ b/div.js
@@ -0,0 +1 @@
+module.exports = require('./divide')
diff --git a/index.js b/index.js
index f74c16f..ec1abf7 100644
--- a/index.js
+++ b/index.js
@@ -7,16 +7,23 @@ module.exports = {
   , set: require('./set')
   , add: require('./add')
   , subtract: require('./subtract')
+  , sub: require('./sub')
   , multiply: require('./multiply')
+  , mul: require('./mul')
   , divide: require('./divide')
+  , div: require('./div')
   , min: require('./min')
   , max: require('./max')
   , scale: require('./scale')
   , scaleAndAdd: require('./scaleAndAdd')
   , distance: require('./distance')
+  , dist: require('./dist')
   , squaredDistance: require('./squaredDistance')
+  , sqrDist: require('./sqrDist')
   , length: require('./length')
+  , len: require('./len')
   , squaredLength: require('./squaredLength')
+  , sqrLen: require('./sqrLen')
   , negate: require('./negate')
   , inverse: require('./inverse')
   , normalize: require('./normalize')
@@ -31,4 +38,4 @@ module.exports = {
   , rotateY: require('./rotateY')
   , rotateZ: require('./rotateZ')
   , forEach: require('./forEach')
-}
\ No newline at end of file
+}
diff --git a/len.js b/len.js
new file mode 100644
index 0000000..fbebab2
--- /dev/null
+++ b/len.js
@@ -0,0 +1 @@
+module.exports = require('./length')
diff --git a/mul.js b/mul.js
new file mode 100644
index 0000000..ed63273
--- /dev/null
+++ b/mul.js
@@ -0,0 +1 @@
+module.exports = require('./multiply')
diff --git a/sqrDist.js b/sqrDist.js
new file mode 100644
index 0000000..4040002
--- /dev/null
+++ b/sqrDist.js
@@ -0,0 +1 @@
+module.exports = require('./squaredDistance')
diff --git a/sqrLen.js b/sqrLen.js
new file mode 100644
index 0000000..ae5f355
--- /dev/null
+++ b/sqrLen.js
@@ -0,0 +1 @@
+module.exports = require('./squaredLength')
diff --git a/sub.js b/sub.js
new file mode 100644
index 0000000..71deea1
--- /dev/null
+++ b/sub.js
@@ -0,0 +1 @@
+module.exports = require('./subtract')
diff --git a/test/index.js b/test/index.js
index 909fed5..b5669b3 100644
--- a/test/index.js
+++ b/test/index.js
@@ -50,6 +50,12 @@ test('divide', function (t) {
   t.end()
 })
 
+test('div', function (t) {
+  var result = vec3.div([], [8, 4, 2], [2, 1, 0.5])
+  t.deepEqual(result, [4, 4, 4])
+  t.end()
+})
+
 test('dot', function (t) {
   var result = vec3.dot([3, 4, 5], [6, 7, 8])
   t.deepEqual(result, 86)
@@ -93,6 +99,12 @@ test('length', function (t) {
   t.end()
 })
 
+test('len', function (t) {
+  var result = vec3.len([3, 4, 5])
+  t.ok(Math.abs(result - 7.0710678118654755) < EPSILON)
+  t.end()
+})
+
 test('lerp', function (t) {
   var result = vec3.lerp([], [3, 4, 5], [6, 7, 8], 0.25)
   t.deepEqual(result, [3.75, 4.75, 5.75])
@@ -117,6 +129,12 @@ test('multiply', function (t) {
   t.end()
 })
 
+test('mul', function (t) {
+  var result = vec3.mul([], [3, 4, 5], [6, 7, 8])
+  t.deepEqual(result, [18, 28, 40])
+  t.end()
+})
+
 test('negate', function (t) {
   var result = vec3.negate([], [3, 4, 5])
   t.deepEqual(result, [-3, -4, -5])
@@ -182,18 +200,36 @@ test('squaredDistance', function (t) {
   t.end()
 })
 
+test('sqrDist', function (t) {
+  var result = vec3.sqrDist([3, 4, 5], [6, 7, 8])
+  t.deepEqual(result, 27)
+  t.end()
+})
+
 test('squaredLength', function (t) {
   var result = vec3.squaredLength([3, 4, 5])
   t.deepEqual(result, 50)
   t.end()
 })
 
+test('sqrLen', function (t) {
+  var result = vec3.sqrLen([3, 4, 5])
+  t.deepEqual(result, 50)
+  t.end()
+})
+
 test('subtract', function (t) {
   var result = vec3.subtract([], [3, 4, 5], [6, 7, 8])
   t.deepEqual(result, [-3, -3, -3])
   t.end()
 })
 
+test('sub', function (t) {
+  var result = vec3.subtract([], [3, 4, 5], [6, 7, 8])
+  t.deepEqual(result, [-3, -3, -3])
+  t.end()
+})
+
 test('transformMat3', function (t) {
   var result = vec3.transformMat3([], [3, 4, 5], [
     5, 6, 7,

From b5128ef656707ad8b1a184f6347b381d33f8a459 Mon Sep 17 00:00:00 2001
From: Ricky Reusser <ricky@standardcyborg.com>
Date: Mon, 5 Feb 2018 17:46:17 -0800
Subject: [PATCH 4/9] Add equals and exactEquals

---
 README.md      | 10 ++++++++++
 epsilon.js     |  1 +
 equals.js      | 22 ++++++++++++++++++++++
 exactEquals.js | 12 ++++++++++++
 index.js       |  5 ++++-
 test/index.js  | 18 +++++++++++++++++-
 6 files changed, 66 insertions(+), 2 deletions(-)
 create mode 100644 epsilon.js
 create mode 100644 equals.js
 create mode 100644 exactEquals.js

diff --git a/README.md b/README.md
index 859f528..99e760b 100644
--- a/README.md
+++ b/README.md
@@ -36,6 +36,8 @@ var scale = require('gl-vec3/scale')
   - [divide()](#divideoutvec3avec3bvec3)
   - [div()](#divideoutvec3avec3bvec3)
   - [dot()](#dotavec3bvec3)
+  - [equals()](#equalsavec3-bvec3)
+  - [exactEquals()](#exactequalsavec3-bvec3)
   - [forEach()](#foreachaarraystridenumberoffsetnumbercountnumberfnfunctionargobject)
   - [fromValues()](#fromvaluesxnumberynumberznumber)
   - [inverse()](#inverseoutvec3avec3)
@@ -101,6 +103,14 @@ var scale = require('gl-vec3/scale')
 
   Calculates the dot product of two vec3's
 
+## equals(a:vec3, b:vec3)
+
+  Returns whether or not the vectors have approximately the same elements in the same position.
+
+## exactEquals(a:vec3, b:vec3)
+
+  Returns whether or not the vectors exactly have the same elements in the same position (when compared with ===)
+
 ## forEach(a:Array, stride:Number, offset:Number, count:Number, fn:Function, [arg]:Object)
 
   Perform some operation over an array of vec3s.
diff --git a/epsilon.js b/epsilon.js
new file mode 100644
index 0000000..9bf3227
--- /dev/null
+++ b/epsilon.js
@@ -0,0 +1 @@
+module.exports = 0.000001
diff --git a/equals.js b/equals.js
new file mode 100644
index 0000000..c392ee1
--- /dev/null
+++ b/equals.js
@@ -0,0 +1,22 @@
+module.exports = equals
+
+var EPSILON = require('./epsilon')
+
+/**
+ * Returns whether or not the vectors have approximately the same elements in the same position.
+ *
+ * @param {vec2} a The first vector.
+ * @param {vec2} b The second vector.
+ * @returns {Boolean} True if the vectors are equal, false otherwise.
+ */
+function equals(a, b) {
+  var a0 = a[0]
+  var a1 = a[1]
+  var a2 = a[2]
+  var b0 = b[0]
+  var b1 = b[1]
+  var b2 = b[2]
+  return (Math.abs(a0 - b0) <= EPSILON * Math.max(1.0, Math.abs(a0), Math.abs(b0)) &&
+          Math.abs(a1 - b1) <= EPSILON * Math.max(1.0, Math.abs(a1), Math.abs(b1)) &&
+          Math.abs(a2 - b2) <= EPSILON * Math.max(1.0, Math.abs(a2), Math.abs(b2)))
+}
diff --git a/exactEquals.js b/exactEquals.js
new file mode 100644
index 0000000..f7f1b5f
--- /dev/null
+++ b/exactEquals.js
@@ -0,0 +1,12 @@
+module.exports = exactEquals
+
+/**
+ * Returns whether or not the vectors exactly have the same elements in the same position (when compared with ===)
+ *
+ * @param {vec2} a The first vector.
+ * @param {vec2} b The second vector.
+ * @returns {Boolean} True if the vectors are equal, false otherwise.
+ */
+function exactEquals(a, b) {
+  return a[0] === b[0] && a[1] === b[1] && a[2] === b[2]
+}
diff --git a/index.js b/index.js
index ec1abf7..f47b7ad 100644
--- a/index.js
+++ b/index.js
@@ -1,10 +1,13 @@
 module.exports = {
-  create: require('./create')
+  EPSILON: require('./epsilon')
+  , create: require('./create')
   , clone: require('./clone')
   , angle: require('./angle')
   , fromValues: require('./fromValues')
   , copy: require('./copy')
   , set: require('./set')
+  , equals: require('./equals')
+  , exactEquals: require('./exactEquals')
   , add: require('./add')
   , subtract: require('./subtract')
   , sub: require('./sub')
diff --git a/test/index.js b/test/index.js
index b5669b3..ac0ecba 100644
--- a/test/index.js
+++ b/test/index.js
@@ -1,6 +1,6 @@
 var test = require('tape')
 var vec3 = require('../')
-var EPSILON = 0.000001
+var EPSILON = require('../epsilon')
 
 test('add', function (t) {
   var result = vec3.add([], [0, 1, 2], [3, 4, 5])
@@ -62,6 +62,22 @@ test('dot', function (t) {
   t.end()
 })
 
+test('equals', function (t) {
+  t.ok(vec3.equals([3 + EPSILON, 5 - EPSILON, 4 + EPSILON], [3, 5, 4]))
+  t.notOk(vec3.equals([3 + EPSILON * 10, 5, 4], [3, 5, 4]))
+  t.notOk(vec3.equals([3, 5 - EPSILON * 10, 4], [3, 5, 4]))
+  t.notOk(vec3.equals([3, 5, 4 + EPSILON * 10], [3, 5, 4]))
+  t.end()
+})
+
+test('exactEquals', function (t) {
+  t.ok(vec3.exactEquals([3, 5], [3, 5]))
+  t.notOk(vec3.exactEquals([3 + EPSILON, 5, 4], [3, 5, 4]))
+  t.notOk(vec3.exactEquals([3, 5 + EPSILON, 4], [3, 5, 4]))
+  t.notOk(vec3.exactEquals([3, 5, 4 + EPSILON], [3, 5, 4]))
+  t.end()
+})
+
 test('forEach', function (t) {
   var a = [null,
     0, 1, 2, null,

From 23d9ea3387b94dc204ffa850ae5e7f27e68374e5 Mon Sep 17 00:00:00 2001
From: Ricky Reusser <ricky@standardcyborg.com>
Date: Mon, 5 Feb 2018 17:58:46 -0800
Subject: [PATCH 5/9] Add floor, ceil, round functions

---
 README.md     | 15 +++++++++++++++
 ceil.js       | 15 +++++++++++++++
 floor.js      | 15 +++++++++++++++
 index.js      |  3 +++
 round.js      | 15 +++++++++++++++
 test/index.js | 18 ++++++++++++++++++
 6 files changed, 81 insertions(+)
 create mode 100644 ceil.js
 create mode 100644 floor.js
 create mode 100644 round.js

diff --git a/README.md b/README.md
index 99e760b..700bbcf 100644
--- a/README.md
+++ b/README.md
@@ -28,6 +28,7 @@ var scale = require('gl-vec3/scale')
   - [add()](#addoutvec3avec3bvec3)
   - [angle()](#angleavec3bvec3)
   - [clone()](#cloneavec3)
+  - [ceil()](#ceiloutvec3-avec3)
   - [copy()](#copyoutvec3avec3)
   - [create()](#create)
   - [cross()](#crossoutvec3avec3bvec3)
@@ -38,6 +39,7 @@ var scale = require('gl-vec3/scale')
   - [dot()](#dotavec3bvec3)
   - [equals()](#equalsavec3-bvec3)
   - [exactEquals()](#exactequalsavec3-bvec3)
+  - [floor()](#flooroutvec3-avec3)
   - [forEach()](#foreachaarraystridenumberoffsetnumbercountnumberfnfunctionargobject)
   - [fromValues()](#fromvaluesxnumberynumberznumber)
   - [inverse()](#inverseoutvec3avec3)
@@ -54,6 +56,7 @@ var scale = require('gl-vec3/scale')
   - [rotateX()](#rotatexoutvec3avec3bvec3cnumber)
   - [rotateY()](#rotateyoutvec3avec3bvec3cnumber)
   - [rotateZ()](#rotatezoutvec3avec3bvec3cnumber)
+  - [round()](#roundoutvec3-avec3)
   - [scale()](#scaleoutvec3avec3bnumber)
   - [scaleAndAdd()](#scaleandaddoutvec3avec3bvec3scalenumber)
   - [set()](#setoutvec3xnumberynumberznumber)
@@ -75,6 +78,10 @@ var scale = require('gl-vec3/scale')
 
   Get the angle between two 3D vectors
 
+## ceil(out:vec3, a:vec3)
+
+  `Math.ceil` the components of a vec3
+
 ## clone(a:vec3)
 
   Creates a new vec3 initialized with values from an existing vector
@@ -107,6 +114,10 @@ var scale = require('gl-vec3/scale')
 
   Returns whether or not the vectors have approximately the same elements in the same position.
 
+## floor(out:vec3, a:vec3)
+
+  `Math.floor` the components of a vec3
+
 ## exactEquals(a:vec3, b:vec3)
 
   Returns whether or not the vectors exactly have the same elements in the same position (when compared with ===)
@@ -167,6 +178,10 @@ var scale = require('gl-vec3/scale')
 
   Rotate a 3D vector around the z-axis
 
+## round(out:vec3, a:vec3)
+
+  `Math.round` the components of a vec3
+
 ## scale(out:vec3, a:vec3, b:Number)
 
   Scales a vec3 by a scalar number
diff --git a/ceil.js b/ceil.js
new file mode 100644
index 0000000..3aa8c84
--- /dev/null
+++ b/ceil.js
@@ -0,0 +1,15 @@
+module.exports = ceil
+
+/**
+ * Math.ceil the components of a vec3
+ *
+ * @param {vec3} out the receiving vector
+ * @param {vec3} a vector to ceil
+ * @returns {vec3} out
+ */
+function ceil(out, a) {
+  out[0] = Math.ceil(a[0])
+  out[1] = Math.ceil(a[1])
+  out[2] = Math.ceil(a[2])
+  return out
+}
diff --git a/floor.js b/floor.js
new file mode 100644
index 0000000..1dc0413
--- /dev/null
+++ b/floor.js
@@ -0,0 +1,15 @@
+module.exports = floor
+
+/**
+ * Math.floor the components of a vec3
+ *
+ * @param {vec3} out the receiving vector
+ * @param {vec3} a vector to floor
+ * @returns {vec3} out
+ */
+function floor(out, a) {
+  out[0] = Math.floor(a[0])
+  out[1] = Math.floor(a[1])
+  out[2] = Math.floor(a[2])
+  return out
+}
diff --git a/index.js b/index.js
index f47b7ad..8d4d2b9 100644
--- a/index.js
+++ b/index.js
@@ -17,6 +17,9 @@ module.exports = {
   , div: require('./div')
   , min: require('./min')
   , max: require('./max')
+  , floor: require('./floor')
+  , ceil: require('./ceil')
+  , round: require('./round')
   , scale: require('./scale')
   , scaleAndAdd: require('./scaleAndAdd')
   , distance: require('./distance')
diff --git a/round.js b/round.js
new file mode 100644
index 0000000..681e927
--- /dev/null
+++ b/round.js
@@ -0,0 +1,15 @@
+module.exports = round
+
+/**
+ * Math.round the components of a vec3
+ *
+ * @param {vec3} out the receiving vector
+ * @param {vec3} a vector to round
+ * @returns {vec3} out
+ */
+function round(out, a) {
+  out[0] = Math.round(a[0])
+  out[1] = Math.round(a[1])
+  out[2] = Math.round(a[2])
+  return out
+}
diff --git a/test/index.js b/test/index.js
index ac0ecba..bcb8698 100644
--- a/test/index.js
+++ b/test/index.js
@@ -14,6 +14,12 @@ test('angle', function (t) {
   t.end()
 })
 
+test('ceil', function (t) {
+  var result = vec3.ceil([], [5.2, 6.5, 7.9])
+  t.deepEqual(result, [6, 7, 8])
+  t.end()
+})
+
 test('clone', function (t) {
   var result = vec3.clone([5, 6, 7])
   t.deepEqual(result, [5, 6, 7])
@@ -78,6 +84,12 @@ test('exactEquals', function (t) {
   t.end()
 })
 
+test('floor', function (t) {
+  var result = vec3.floor([], [5.2, 6.6, 7.9])
+  t.deepEqual(result, [5, 6, 7])
+  t.end()
+})
+
 test('forEach', function (t) {
   var a = [null,
     0, 1, 2, null,
@@ -204,6 +216,12 @@ test('scaleAndAdd', function (t) {
   t.end()
 })
 
+test('round', function (t) {
+  var result = vec3.round([], [5.2, 6.6, 8.5])
+  t.deepEqual(result, [5, 7, 9])
+  t.end()
+})
+
 test('set', function (t) {
   var result = vec3.set([], 3, 4, 5)
   t.deepEqual(result, [3, 4, 5])

From fb103953e8c0bd7ae31ddd43bd82a285303900db Mon Sep 17 00:00:00 2001
From: Ricky Reusser <rsreusser@gmail.com>
Date: Thu, 8 Feb 2018 09:54:25 -0800
Subject: [PATCH 6/9] Fix incorrect jsdoc types

---
 equals.js      | 4 ++--
 exactEquals.js | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/equals.js b/equals.js
index c392ee1..2afdfe1 100644
--- a/equals.js
+++ b/equals.js
@@ -5,8 +5,8 @@ var EPSILON = require('./epsilon')
 /**
  * Returns whether or not the vectors have approximately the same elements in the same position.
  *
- * @param {vec2} a The first vector.
- * @param {vec2} b The second vector.
+ * @param {vec3} a The first vector.
+ * @param {vec3} b The second vector.
  * @returns {Boolean} True if the vectors are equal, false otherwise.
  */
 function equals(a, b) {
diff --git a/exactEquals.js b/exactEquals.js
index f7f1b5f..d8deae6 100644
--- a/exactEquals.js
+++ b/exactEquals.js
@@ -3,8 +3,8 @@ module.exports = exactEquals
 /**
  * Returns whether or not the vectors exactly have the same elements in the same position (when compared with ===)
  *
- * @param {vec2} a The first vector.
- * @param {vec2} b The second vector.
+ * @param {vec3} a The first vector.
+ * @param {vec3} b The second vector.
  * @returns {Boolean} True if the vectors are equal, false otherwise.
  */
 function exactEquals(a, b) {

From 4b733ff50e2e3fc104e5a341b0599a7ef82ab133 Mon Sep 17 00:00:00 2001
From: Ricky Reusser <rsreusser@gmail.com>
Date: Thu, 8 Feb 2018 09:57:39 -0800
Subject: [PATCH 7/9] Add missing dist test

---
 test/index.js | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/test/index.js b/test/index.js
index bcb8698..bc81170 100644
--- a/test/index.js
+++ b/test/index.js
@@ -50,6 +50,12 @@ test('distance', function (t) {
   t.end()
 })
 
+test('dist', function (t) {
+  var result = vec3.dist([1, 2, 3], [4, 6, 7])
+  t.ok(Math.abs(result - 6.4031242374328485) < EPSILON)
+  t.end()
+})
+
 test('divide', function (t) {
   var result = vec3.divide([], [8, 4, 2], [2, 1, 0.5])
   t.deepEqual(result, [4, 4, 4])

From ec01fa1e863bdeebd598480c5bfd921200e29dd9 Mon Sep 17 00:00:00 2001
From: Ricky Reusser <rsreusser@gmail.com>
Date: Thu, 8 Feb 2018 10:01:33 -0800
Subject: [PATCH 8/9] Fix vector length in exactEquals tests

---
 test/index.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/index.js b/test/index.js
index bc81170..b48f006 100644
--- a/test/index.js
+++ b/test/index.js
@@ -83,7 +83,7 @@ test('equals', function (t) {
 })
 
 test('exactEquals', function (t) {
-  t.ok(vec3.exactEquals([3, 5], [3, 5]))
+  t.ok(vec3.exactEquals([3, 5, 4], [3, 5, 4]))
   t.notOk(vec3.exactEquals([3 + EPSILON, 5, 4], [3, 5, 4]))
   t.notOk(vec3.exactEquals([3, 5 + EPSILON, 4], [3, 5, 4]))
   t.notOk(vec3.exactEquals([3, 5, 4 + EPSILON], [3, 5, 4]))

From e882a5be78bcfb552af7bfa895726a1dfc3424b6 Mon Sep 17 00:00:00 2001
From: Ricky Reusser <rsreusser@gmail.com>
Date: Thu, 8 Feb 2018 10:10:38 -0800
Subject: [PATCH 9/9] Fix alphabetical order in docs

---
 README.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/README.md b/README.md
index 700bbcf..2b63f13 100644
--- a/README.md
+++ b/README.md
@@ -114,14 +114,14 @@ var scale = require('gl-vec3/scale')
 
   Returns whether or not the vectors have approximately the same elements in the same position.
 
-## floor(out:vec3, a:vec3)
-
-  `Math.floor` the components of a vec3
-
 ## exactEquals(a:vec3, b:vec3)
 
   Returns whether or not the vectors exactly have the same elements in the same position (when compared with ===)
 
+## floor(out:vec3, a:vec3)
+
+  `Math.floor` the components of a vec3
+
 ## forEach(a:Array, stride:Number, offset:Number, count:Number, fn:Function, [arg]:Object)
 
   Perform some operation over an array of vec3s.