Add functions

README.md

@@ -26,35 +26,52 @@ var scale = require('gl-vec4/scale')
 ## API
 
   - [add()](#addoutvec4-avec4-bvec4)
+  - [ceil()](#ceiloutvec4-avec4)
   - [clone()](#cloneavec4)
   - [copy()](#copyoutvec4-avec4)
   - [create()](#create)
   - [distance()](#distanceavec4-bvec4)
+  - [dist()](#distanceavec4-bvec4)
   - [divide()](#divideoutvec4-avec4-bvec4)
+  - [div()](#divideoutvec4-avec4-bvec4)
   - [dot()](#dotavec4-bvec4)
+  - [equals()](#equalsavec4-bvec4)
+  - [exactEquals()](#exactequalsavec4-bvec4)
+  - [floor()](#flooroutvec4-avec4)
+  - [forEach()](#foreachaarraystridenumberoffsetnumbercountnumberfnfunctionargobject)
   - [fromValues()](#fromvaluesxnumber-ynumber-znumber-wnumber)
   - [inverse()](#inverseoutvec4-avec4)
   - [length()](#lengthavec4)
+  - [len()](#lengthavec4)
   - [lerp()](#lerpoutvec4-avec4-bvec4-tnumber)
   - [max()](#maxoutvec4-avec4-bvec4)
   - [min()](#minoutvec4-avec4-bvec4)
   - [multiply()](#multiplyoutvec4-avec4-bvec4)
+  - [mul()](#multiplyoutvec4-avec4-bvec4)
   - [negate()](#negateoutvec4-avec4)
   - [normalize()](#normalizeoutvec4-avec4)
   - [random()](#randomoutvec4-scalenumber)
+  - [round()](#roundoutvec4-avec4)
   - [scale()](#scaleoutvec4-avec4-bnumber)
   - [scaleAndAdd()](#scaleandaddoutvec4-avec4-bvec4-scalenumber)
   - [set()](#setoutvec4-xnumber-ynumber-znumber-wnumber)
   - [squaredDistance()](#squareddistanceavec4-bvec4)
+  - [sqrDist()](#squareddistanceavec4-bvec4)
   - [squaredLength()](#squaredlengthavec4)
+  - [sqrLen()](#squaredlengthavec4)
   - [subtract()](#subtractoutvec4-avec4-bvec4)
+  - [sub()](#subtractoutvec4-avec4-bvec4)
   - [transformMat4()](#transformmat4outvec4-avec4-mmat4)
   - [transformQuat()](#transformquatoutvec4-avec4-qquat)
 
 ## add(out:vec4, a:vec4, b:vec4)
 
   Adds two vec4's
 
+## ceil(out:vec4, a:vec4)
+
+  `Math.ceil` the components of a vec4
+
 ## clone(a:vec4)
 
   Creates a new vec4 initialized with values from an existing vector
@@ -73,12 +90,24 @@ var scale = require('gl-vec4/scale')
 
 ## divide(out:vec4, a:vec4, b:vec4)
 
-  Divides two vec4's
+  Divides two vec4's. Aliased as `div`.
 
 ## dot(a:vec4, b:vec4)
 
   Calculates the dot product of two vec4's
 
+## equals(a:vec4, b:vec4)
+
+  Returns whether or not the vectors have approximately the same elements in the same position.
+
+## exactEquals(a:vec4, b:vec4)
+
+  Returns whether or not the vectors exactly have the same elements in the same position (when compared with ===)
+
+## floor(out:vec4, a:vec4)
+
+  `Math.floor` the components of a vec4
+
 ## fromValues(x:Number, y:Number, z:Number, w:Number)
 
   Creates a new vec4 initialized with the given values
@@ -89,7 +118,7 @@ var scale = require('gl-vec4/scale')
 
 ## length(a:vec4)
 
-  Calculates the length of a vec4
+  Calculates the length of a vec4. Aliased as `len`.
 
 ## lerp(out:vec4, a:vec4, b:vec4, t:Number)
 
@@ -105,7 +134,7 @@ var scale = require('gl-vec4/scale')
 
 ## multiply(out:vec4, a:vec4, b:vec4)
 
-  Multiplies two vec4's
+  Multiplies two vec4's. Aliased as `mul`.
 
 ## negate(out:vec4, a:vec4)
 
@@ -119,6 +148,10 @@ var scale = require('gl-vec4/scale')
 
   Generates a random vector with the given scale
 
+## round(out:vec4, a:vec4)
+
+  `Math.round` the components of a vec4
+
 ## scale(out:vec4, a:vec4, b:Number)
 
   Scales a vec4 by a scalar number
@@ -133,15 +166,15 @@ var scale = require('gl-vec4/scale')
 
 ## squaredDistance(a:vec4, b:vec4)
 
-  Calculates the squared euclidian distance between two vec4's
+  Calculates the squared euclidian distance between two vec4's. Aliased as `sqrDist`.
 
 ## squaredLength(a:vec4)
 
-  Calculates the squared length of a vec4
+  Calculates the squared length of a vec4. Aliased as `sqrLen`.
 
 ## subtract(out:vec4, a:vec4, b:vec4)
 
-  Subtracts vector b from vector a
+  Subtracts vector b from vector a. Aliased as `sub`
 
 ## transformMat4(out:vec4, a:vec4, m:mat4)
 

ceil.js

@@ -0,0 +1,16 @@
+module.exports = ceil
+
+/**
+ * Math.ceil the components of a vec4
+ *
+ * @param {vec4} out the receiving vector
+ * @param {vec4} a vector to ceil
+ * @returns {vec4} out
+ */
+function ceil(out, a) {
+  out[0] = Math.ceil(a[0])
+  out[1] = Math.ceil(a[1])
+  out[2] = Math.ceil(a[2])
+  out[3] = Math.ceil(a[3])
+  return out
+}

dist.js

@@ -0,0 +1 @@
+module.exports = require('./distance')

div.js

@@ -0,0 +1 @@
+module.exports = require('./divide')

epsilon.js

@@ -0,0 +1 @@
+module.exports = 0.000001

equals.js

@@ -0,0 +1,25 @@
+module.exports = equals
+
+var EPSILON = require('./epsilon')
+
+/**
+ * Returns whether or not the vectors have approximately the same elements in the same position.
+ *
+ * @param {vec4} a The first vector.
+ * @param {vec4} 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 a3 = a[3]
+  var b0 = b[0]
+  var b1 = b[1]
+  var b2 = b[2]
+  var b3 = b[3]
+  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)) &&
+          Math.abs(a3 - b3) <= EPSILON * Math.max(1.0, Math.abs(a3), Math.abs(b3)))
+}

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 {vec4} a The first vector.
+ * @param {vec4} 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] && a[3] === b[3]
+}

floor.js

@@ -0,0 +1,16 @@
+module.exports = floor
+
+/**
+ * Math.floor the components of a vec4
+ *
+ * @param {vec4} out the receiving vector
+ * @param {vec4} a vector to floor
+ * @returns {vec4} out
+ */
+function floor(out, a) {
+  out[0] = Math.floor(a[0])
+  out[1] = Math.floor(a[1])
+  out[2] = Math.floor(a[2])
+  out[3] = Math.floor(a[3])
+  return out
+}

forEach.js

@@ -0,0 +1,46 @@
+module.exports = forEach;
+
+var vec = require('./create')()
+
+/**
+ * Perform some operation over an array of vec4.
+ *
+ * @param {Array} a the array of vectors to iterate over
+ * @param {Number} stride Number of elements between the start of each vec4. If 0 assumes tightly packed
+ * @param {Number} offset Number of elements to skip at the beginning of the array
+ * @param {Number} count Number of vec4 to iterate over. If 0 iterates over entire array
+ * @param {Function} fn Function to call for each vector in the array
+ * @param {Object} [arg] additional argument to pass to fn
+ * @returns {Array} a
+ * @function
+ */
+function forEach(a, stride, offset, count, fn, arg) {
+        var i, l
+        if(!stride) {
+            stride = 4
+        }
+
+        if(!offset) {
+            offset = 0
+        }
+
+        if(count) {
+            l = Math.min((count * stride) + offset, a.length)
+        } else {
+            l = a.length
+        }
+
+        for(i = offset; i < l; i += stride) {
+            vec[0] = a[i]
+            vec[1] = a[i+1]
+            vec[2] = a[i+2]
+            vec[3] = a[i+3]
+            fn(vec, vec, arg)
+            a[i] = vec[0]
+            a[i+1] = vec[1]
+            a[i+2] = vec[2]
+            a[i+3] = vec[3]
+        }
+
+        return a
+}

index.js

@@ -1,21 +1,35 @@
 module.exports = {
+  epsilon: require('./epsilon'),
   create: require('./create'),
   clone: require('./clone'),
   fromValues: require('./fromValues'),
   copy: require('./copy'),
   set: require('./set'),
+  equals: require('./equals'),
+  exactEquals: require('./exactEquals'),
   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'),
+  floor: require('./floor'),
+  ceil: require('./ceil'),
+  round: require('./round'),
+  forEach: require('./forEach'),
   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'),

len.js

@@ -0,0 +1 @@
+module.exports = require('./length')

mul.js

@@ -0,0 +1 @@
+module.exports = require('./multiply')

package.json

@@ -4,7 +4,8 @@
   "description": "gl-matrix's vec4, split into smaller pieces",
   "main": "index.js",
   "scripts": {
-    "get-docs": "cat *.js | dox --api"
+    "get-docs": "cat *.js | dox --api",
+    "test": "node test/index.js"
   },
   "dependencies": {},
   "devDependencies": {

round.js

@@ -0,0 +1,16 @@
+module.exports = round
+
+/**
+ * Math.round the components of a vec4
+ *
+ * @param {vec4} out the receiving vector
+ * @param {vec4} a vector to round
+ * @returns {vec4} out
+ */
+function round(out, a) {
+  out[0] = Math.round(a[0])
+  out[1] = Math.round(a[1])
+  out[2] = Math.round(a[2])
+  out[3] = Math.round(a[3])
+  return out
+}

sqrDist.js

@@ -0,0 +1 @@
+module.exports = require('./squaredDistance')

sqrLen.js

@@ -0,0 +1 @@
+module.exports = require('./squaredLength')

sub.js

@@ -0,0 +1 @@
+module.exports = require('./subtract')