kld-affine - npm Package Compare versions

Comparing version 2.0.0 to 2.0.1

lib/Matrix2D.js

 /**
  *   Matrix2D.js
  *
- *   copyright 2001-2002, 2013 Kevin Lindsey
+ *   copyright 2001-2002, 2013, 2017 Kevin Lindsey
  */
@@ -251,14 +251,19 @@
 Matrix2D.prototype.rotateAt = function(radians, center) {
-    var c = Math.cos(radians);
-    var s = Math.sin(radians);
-    var t1 = -center.x + center.x * c - center.y * s;
-    var t2 = -center.y + center.y * c + center.x * s;
+    var cos = Math.cos(radians);
+    var sin = Math.sin(radians);
+    var cx = center.x;
+    var cy = center.y;
 
+    var a = this.a * cos + this.c * sin;
+    var b = this.b * cos + this.d * sin;
+    var c = this.c * cos - this.a * sin;
+    var d = this.d * cos - this.b * sin;
+
     return new this.constructor(
-        this.a *  c + this.c * s,
-        this.b *  c + this.d * s,
-        this.a * -s + this.c * c,
-        this.b * -s + this.d * c,
-        this.a * t1 + this.c * t2 + this.e,
-        this.b * t1 + this.d * t2 + this.f
+        a,
+        b,
+        c,
+        d,
+        (this.a - a) * cx + (this.c - c) * cy + this.e,
+        (this.b - b) * cx + (this.d - d) * cy + this.f
     );
@@ -457,2 +462,20 @@ };
 /**
+ *  precisionEquals
+ *
+ *  @param {Matrix2D} that
+ *  @param {Number} precision
+ *  @returns {Boolean}
+ */
+Matrix2D.prototype.precisionEquals = function(that, precision) {
+    return (
+        Math.abs(this.a - that.a) < precision &&
+        Math.abs(this.b - that.b) < precision &&
+        Math.abs(this.c - that.c) < precision &&
+        Math.abs(this.d - that.d) < precision &&
+        Math.abs(this.e - that.e) < precision &&
+        Math.abs(this.f - that.f) < precision
+    );
+};
+
+/**
  *  toString
@@ -459,0 +482,0 @@ *

lib/Point2D.js

@@ -5,3 +5,3 @@ /**
  *
- *   copyright 2001-2002, 2013 Kevin Lindsey
+ *   copyright 2001-2002, 2013, 2017 Kevin Lindsey
  *
@@ -32,4 +32,2 @@ */
     });
-    // this.x = x;
-    // this.y = y;
 }
@@ -96,2 +94,16 @@
 
+/**
+ *  precisionEquals
+ *
+ *  @param {Point2D} that
+ *  @param {Number} precision
+ *  @returns {Boolean}
+ */
+Point2D.prototype.precisionEquals = function(that, precision) {
+    return (
+        Math.abs(this.x - that.x) < precision &&
+        Math.abs(this.y - that.y) < precision
+    );
+};
+
 // utility methods
@@ -98,0 +110,0 @@

lib/Vector2D.js

@@ -5,3 +5,3 @@ /**
  *
- *   copyright 2001-2002, 2013 Kevin Lindsey
+ *   copyright 2001-2002, 2013, 2017 Kevin Lindsey
  *
@@ -32,4 +32,2 @@ */
     });
-    // this.x = x;
-    // this.y = y;
 }
@@ -221,2 +219,16 @@
 /**
+ *  precisionEquals
+ *
+ *  @param {Vector2D} that
+ *  @param {Number} precision
+ *  @returns {Boolean}
+ */
+Vector2D.prototype.precisionEquals = function(that, precision) {
+    return (
+        Math.abs(this.x - that.x) < precision &&
+        Math.abs(this.y - that.y) < precision
+    );
+};
+
+/**
  *  toString
@@ -223,0 +235,0 @@ *

package.json

 {
   "name": "kld-affine",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "description": "A collection of classes used in affine geometry",
@@ -16,3 +16,3 @@ "author": {
   "scripts": {
-    "test": "expresso"
+    "test": "mocha"
   },
@@ -26,7 +26,7 @@ "keywords": [
   "devDependencies": {
-    "expresso": "0.9.2"
+    "mocha": "^3.4.2"
   },
   "engines": {
-    "node": ">= 0.10.4"
+    "node": ">= 6.4.0"
   }
 }

README.md

@@ -1,5 +0,4 @@
-kld-affine
-==========
+# kld-affine
 
-A collection of classes used for affine geometry. This currently consists of the following:
+A collection of classes used for affine geometry. This currently consists of the following classes:
 
@@ -12,10 +11,7 @@ * Point2D
 
-Please note that as of version 0.0.7, all of the self-modifying functions (like addEquals, subtractEquals, etc.) have been removed.
+## Install
 
-Install
--------
     npm install kld-affine
 
-Point2D
--------
+## Point2D
 
@@ -30,2 +26,3 @@ A class used to represent two-dimensional points on a plane. This currently supports the following methods:
 * equals
+* precisionEquals
 * lerp
@@ -38,4 +35,4 @@ * distanceFrom
 
-Vector2D
---------
+## Vector2D
+
 A class used to represent a two-dimensional vector. This currently supports the following methods:
@@ -60,6 +57,7 @@
 * equals
+* precisionEquals
 * toString
 
-Matrix2D
---------
+## Matrix2D
+
 A class used to represent affine transformations. This current supports the following methods:
@@ -85,3 +83,5 @@
 * getScale
+* getDecomposition
 * equals
+* precisionEquals
 * toString

test/matrix_tests.js

@@ -1,101 +0,52 @@
-var Matrix2D = require('./../lib/Matrix2D');
+let assert   = require('assert'),
+    Matrix2D = require('./../lib/Matrix2D');
 
-exports.newMatrix = function(beforeExit, assert) {
-    var m = new Matrix2D();
+describe('Matrix2D', () => {
+    it("new matrix", () => {
+        let m = new Matrix2D();
 
-    assert.equal(m.a, 1);
-    assert.equal(m.b, 0);
-    assert.equal(m.c, 0);
-    assert.equal(m.d, 1);
-    assert.equal(m.e, 0);
-    assert.equal(m.f, 0);
-};
+        assert.equal(m.a, 1);
+        assert.equal(m.b, 0);
+        assert.equal(m.c, 0);
+        assert.equal(m.d, 1);
+        assert.equal(m.e, 0);
+        assert.equal(m.f, 0);
+    });
 
-exports.IDENTITY = function(beforeExit, assert) {
-    var m = Matrix2D.IDENTITY;
+    it("IDENTITY", () => {
+        let m = Matrix2D.IDENTITY;
 
-    assert.equal(m.a, 1);
-    assert.equal(m.b, 0);
-    assert.equal(m.c, 0);
-    assert.equal(m.d, 1);
-    assert.equal(m.e, 0);
-    assert.equal(m.f, 0);
-};
+        assert.equal(m.a, 1);
+        assert.equal(m.b, 0);
+        assert.equal(m.c, 0);
+        assert.equal(m.d, 1);
+        assert.equal(m.e, 0);
+        assert.equal(m.f, 0);
+    });
 
-exports.multiply = function(beforeExit, assert) {
+    it("to string", () => {
+        let m = new Matrix2D();
 
-};
-
-exports.inverse = function(beforeExit, assert) {
-
-};
-
-exports.translate = function(beforeExit, assert) {
-
-};
-
-exports.scale = function(beforeExit, assert) {
-
-};
-
-exports.scaleAt = function(beforeExit, assert) {
-
-};
-
-exports.scaleNonUniform = function(beforeExit, assert) {
-
-};
-
-exports.scaleNonUniformAt = function(beforeExit, assert) {
-
-};
-
-exports.rotate = function(beforeExit, assert) {
-
-};
-
-exports.rotateAt = function(beforeExit, assert) {
-
-};
-
-exports.rotateFromVector = function(beforeExit, assert) {
-
-};
-
-exports.flipX = function(beforeExit, assert) {
-
-};
-
-exports.flipY = function(beforeExit, assert) {
-
-};
-
-exports.skewX = function(beforeExit, assert) {
-
-};
-
-exports.skewY = function(beforeExit, assert) {
-
-};
-
-exports.isIdentity = function(beforeExit, assert) {
-
-};
-
-exports.isInvertible = function(beforeExit, assert) {
-
-};
-
-exports.getScale = function(beforeExit, assert) {
-
-};
-
-exports.equals = function(beforeExit, assert) {
-
-};
-
-exports.toString = function(beforeExit, assert) {
-    var m = new Matrix2D();
-
-    assert.equal(m.toString(), "matrix(1,0,0,1,0,0)");
-};
+        assert.equal(m.toString(), "matrix(1,0,0,1,0,0)");
+    });
+    /*
+    it("multiply", () => {});
+    it("inverse", () => {});
+    it("translate", () => {});
+    it("scale", () => {});
+    it("scaleAt", () => {});
+    it("scaleNonUniform", () => {});
+    it("scaleNonUniformAt", () => {});
+    it("rotate", () => {});
+    it("rotateAt", () => {});
+    it("rotateFromVector", () => {});
+    it("flipX", () => {});
+    it("flipY", () => {});
+    it("skewX", () => {});
+    it("skewY", () => {});
+    it("isIdentity", () => {});
+    it("isInvertible", () => {});
+    it("getScale", () => {});
+    it("equals", () => {});
+    */
+});

test/point_tests.js

@@ -1,212 +0,185 @@
-var Point2D = require('../lib/Point2D'),
+var assert   = require('assert'),
+    Point2D  = require('../lib/Point2D'),
     Vector2D = require('../lib/Vector2D'),
     Matrix2D = require('../lib/Matrix2D');
 
-exports.newPoint = function(beforeExit, assert) {
-    var p = new Point2D(10, 20);
+describe('Point2D', () => {
+    it("new point", () => {
+        let p = new Point2D(10, 20);
 
-    assert.equal(p.x, 10);
-    assert.equal(p.y, 20);
-};
+        assert.equal(p.x, 10);
+        assert.equal(p.y, 20);
+    });
 
-exports.clone = function(beforeExit, assert) {
-    var p = new Point2D(10, 20);
-    var c = p.clone();
+    it("clone", () => {
+        let p = new Point2D(10, 20);
+        let c = p.clone();
 
-    assert.equal(p.x, c.x);
-    assert.equal(p.y, c.y);
-    assert.equal(c.x, 10);
-    assert.equal(c.y, 20);
-};
+        assert.equal(p.x, c.x);
+        assert.equal(p.y, c.y);
+        assert.equal(c.x, 10);
+        assert.equal(c.y, 20);
+    });
 
-exports.addPoint = function(beforeExit, assert) {
-    var p1 = new Point2D(10, 20);
-    var p2 = new Point2D(20, 30);
-    var p3 = p1.add(p2);
+    it("add", () => {
+        let p1 = new Point2D(10, 20);
+        let p2 = new Point2D(20, 30);
+        let p3 = p1.add(p2);
 
-    assert.equal(p3.x, 30);
-    assert.equal(p3.y, 50);
-};
+        assert.equal(p3.x, 30);
+        assert.equal(p3.y, 50);
+    });
 
-exports.addVector = function(beforeExit, assert) {
-    var p1 = new Point2D(10, 20);
-    var v1 = new Vector2D(20, 30);
-    var p2 = p1.add(v1);
+    it("subtract", () => {
+        let p1 = new Point2D(10, 20);
+        let p2 = new Point2D(20, 40);
+        let p3 = p1.subtract(p2);
 
-    assert.equal(p2.x, 30);
-    assert.equal(p2.y, 50);
-};
+        assert.equal(p3.x, -10);
+        assert.equal(p3.y, -20);
+    });
 
-exports.subtractPoint = function(beforeExit, assert) {
-    var p1 = new Point2D(10, 20);
-    var p2 = new Point2D(20, 40);
-    var p3 = p1.subtract(p2);
+    it("multiply", () => {
+        let p1 = new Point2D(10, 20);
+        let p2 = p1.multiply(0.5);
 
-    assert.equal(p3.x, -10);
-    assert.equal(p3.y, -20);
-};
+        assert.equal(p2.x, 5);
+        assert.equal(p2.y, 10);
+    });
 
-exports.subtractVector = function(beforeExit, assert) {
-    var p1 = new Point2D(10, 20);
-    var v1 = new Vector2D(20, 40);
-    var p2 = p1.subtract(v1);
+    it("divide", () => {
+        let p1 = new Point2D(10, 20);
+        let p2 = p1.divide(2);
 
-    assert.equal(p2.x, -10);
-    assert.equal(p2.y, -20);
-};
+        assert.equal(p2.x, 5);
+        assert.equal(p2.y, 10);
+    });
 
-exports.multiply = function(beforeExit, assert) {
-    var p1 = new Point2D(10, 20);
-    var p2 = p1.multiply(0.5);
+    it("equal", () => {
+        let p1 = new Point2D(10, 20);
+        let p2 = new Point2D(10, 20);
 
-    assert.equal(p2.x, 5);
-    assert.equal(p2.y, 10);
-};
+        assert.equal(p1.equals(p2), true);
+    });
 
-exports.divide = function(beforeExit, assert) {
-    var p1 = new Point2D(10, 20);
-    var p2 = p1.divide(2);
+    it("not equal", () => {
+        let p1 = new Point2D(10, 20);
+        let p2 = new Point2D(10, 21);
 
-    assert.equal(p2.x, 5);
-    assert.equal(p2.y, 10);
-};
+        assert.equal(p1.equals(p2), false);
+    });
 
-exports.equals = function(beforeExit, assert) {
-    var p1 = new Point2D(10, 20);
-    var p2 = new Point2D(10, 20);
-    var p3 = new Point2D(10, 21);
+    it("interpolate between two points", () => {
+        let p1 = new Point2D(10, 20);
+        let p2 = new Point2D(30, 40);
+        let p3 = p1.lerp(p2, 0.25);
 
-    assert.equal(p1.equals(p2), true);
-    assert.equal(p1.equals(p3), false);
-};
+        assert.equal(p3.x, 15);
+        assert.equal(p3.y, 25);
+    });
 
-exports.lerpPoint = function(beforeExit, assert) {
-    var p1 = new Point2D(10, 20);
-    var p2 = new Point2D(30, 40);
-    var p3 = p1.lerp(p2, 0.25);
+    it("distance between two points", () => {
+        let p1 = new Point2D(10, 20);
+        let p2 = new Point2D(13, 24);
+        let dist = p1.distanceFrom(p2);
 
-    assert.equal(p3.x, 15);
-    assert.equal(p3.y, 25);
-};
+        assert.equal(dist, 5);
+    });
 
-exports.lerpVector = function(beforeExit, assert) {
-    var p1 = new Point2D(10, 20);
-    var v1 = new Vector2D(30, 40);
-    var p2 = p1.lerp(v1, 0.25);
+    it("min", () => {
+        let p1 = new Point2D(30, 5);
+        let p2 = new Point2D(10, 50);
+        let p3 = p1.min(p2);
 
-    assert.equal(p2.x, 15);
-    assert.equal(p2.y, 25);
-};
+        assert.equal(p3.x, 10);
+        assert.equal(p3.y, 5);
+    });
 
-exports.distanceFrom = function(beforeExit, assert) {
-    var p1 = new Point2D(10, 20);
-    var p2 = new Point2D(13, 24);
-    var dist = p1.distanceFrom(p2);
+    it("max", () => {
+        let p1 = new Point2D(30, 5);
+        let p2 = new Point2D(10, 50);
+        let p3 = p1.max(p2);
 
-    assert.equal(dist, 5);
-};
+        assert.equal(p3.x, 30);
+        assert.equal(p3.y, 50);
+    });
 
-exports.min = function(beforeExit, assert) {
-    var p1 = new Point2D(30, 5);
-    var p2 = new Point2D(10, 50);
-    var p3 = p1.min(p2);
+    it("translate", () => {
+        var p1 = new Point2D(10, 20);
+        var m = new Matrix2D().translate(20, 30);
+        var p2 = p1.transform(m);
 
-    assert.equal(p3.x, 10);
-    assert.equal(p3.y, 5);
-};
+        assert.equal(p2.x, 30);
+        assert.equal(p2.y, 50);
+    });
 
-exports.max = function(beforeExit, assert) {
-    var p1 = new Point2D(30, 5);
-    var p2 = new Point2D(10, 50);
-    var p3 = p1.max(p2);
+    it("scale", () => {
+        var p1 = new Point2D(10, 20);
+        var m = new Matrix2D().scale(2);
+        var p2 = p1.transform(m);
 
-    assert.equal(p3.x, 30);
-    assert.equal(p3.y, 50);
-};
+        assert.equal(p2.x, 20);
+        assert.equal(p2.y, 40);
+    });
 
-exports.translateTransform = function(beforeExit, assert) {
-    var p1 = new Point2D(10, 20);
-    var m = new Matrix2D().translate(20, 30);
-    var p2 = p1.transform(m);
+    it("scale non-uniform", () => {
+        var p1 = new Point2D(10, 20);
+        var m = new Matrix2D().scaleNonUniform(2, 3);
+        var p2 = p1.transform(m);
 
-    assert.equal(p2.x, 30);
-    assert.equal(p2.y, 50);
-};
+        assert.equal(p2.x, 20);
+        assert.equal(p2.y, 60);
+    });
 
-exports.scaleTransform = function(beforeExit, assert) {
-    var p1 = new Point2D(10, 20);
-    var m = new Matrix2D().scale(2);
-    var p2 = p1.transform(m);
+    it("rotate", () => {
+        var p1 = new Point2D(10, 0);
+        var m = new Matrix2D().rotate(Math.PI / 4.0);
+        var p2 = p1.transform(m);
 
-    assert.equal(p2.x, 20);
-    assert.equal(p2.y, 40);
-};
+        assert.equal(p2.x, 7.0710678118654755);
+        assert.equal(p2.y, 7.071067811865475);
+    });
 
-exports.scaleNonUniformTransform = function(beforeExit, assert) {
-    var p1 = new Point2D(10, 20);
-    var m = new Matrix2D().scaleNonUniform(2, 3);
-    var p2 = p1.transform(m);
+    it("rotate from vector", () => {
+        var p1 = new Point2D(10, 0);
+        var v = new Vector2D(Math.PI / 4.0, Math.PI / 4.0);
+        var m = new Matrix2D().rotateFromVector(v);
+        var p2 = p1.transform(m);
 
-    assert.equal(p2.x, 20);
-    assert.equal(p2.y, 60);
-};
+        assert.equal(p2.x, 7.0710678118654755);
+        assert.equal(p2.y, 7.0710678118654755);
+    });
 
-exports.rotateTransform = function(beforeExit, assert) {
-    var p1 = new Point2D(10, 0);
-    var m = new Matrix2D().rotate(Math.PI / 4.0);
-    var p2 = p1.transform(m);
+    it("flip x", () => {
+        var p1 = new Point2D(10, 20);
+        var m = new Matrix2D().flipX();
+        var p2 = p1.transform(m);
 
-    assert.equal(p2.x, 7.0710678118654755);
-    assert.equal(p2.y, 7.071067811865475);
-};
+        assert.equal(p2.x, -10);
+        assert.equal(p2.y, 20);
+    });
 
-exports.rotateFromVectorTransform = function(beforeExit, assert) {
-    var p1 = new Point2D(10, 0);
-    var v = new Vector2D(Math.PI / 4.0, Math.PI / 4.0);
-    var m = new Matrix2D().rotateFromVector(v);
-    var p2 = p1.transform(m);
+    it("flip y", () => {
+        var p1 = new Point2D(10, 20);
+        var m = new Matrix2D().flipY();
+        var p2 = p1.transform(m);
 
-    assert.equal(p2.x, 7.0710678118654755);
-    assert.equal(p2.y, 7.0710678118654755);
-};
+        assert.equal(p2.x, 10);
+        assert.equal(p2.y, -20);
+    });
 
-exports.flipXTransform = function(beforeExit, assert) {
-    var p1 = new Point2D(10, 20);
-    var m = new Matrix2D().flipX();
-    var p2 = p1.transform(m);
+    it("inverse transform", () => {
+        var p1 = new Point2D(10, 20);
+        var m = new Matrix2D().translate(30, 50).inverse();
+        var p2 = p1.transform(m);
 
-    assert.equal(p2.x, -10);
-    assert.equal(p2.y, 20);
-};
+        assert.equal(p2.x, -20);
+        assert.equal(p2.y, -30);
+    });
 
-exports.flipYTransform = function(beforeExit, assert) {
-    var p1 = new Point2D(10, 20);
-    var m = new Matrix2D().flipY();
-    var p2 = p1.transform(m);
+    it("to string", () => {
+        var p = new Point2D(10, 20);
 
-    assert.equal(p2.x, 10);
-    assert.equal(p2.y, -20);
-};
-
-exports.inverseTransform = function(beforeExit, assert) {
-    var p1 = new Point2D(10, 20);
-    var m = new Matrix2D().translate(30, 50).inverse();
-    var p2 = p1.transform(m);
-
-    assert.equal(p2.x, -20);
-    assert.equal(p2.y, -30);
-};
-
-exports.toString = function(beforeExit, assert) {
-    var p = new Point2D(10, 20);
-
-    assert.equal("point(10,20)", p.toString());
-};
-
-// exports.setX = function(beforeExit, assert) {
-//     var p = new Point2D(10, 20);
-
-//     p.x = 20;
-
-//     console.log(p.toString());
-// };
+        assert.equal("point(10,20)", p.toString());
+    });
+});

test/vector_tests.js

@@ -1,77 +0,152 @@
-var Vector2D = require('../lib/Vector2D');
+let assert   = require('assert'),
+    Vector2D = require('../lib/Vector2D'),
+    Point2D  = require('../lib/Point2D'),
+    Matrix2D = require('../lib/Matrix2D'),
+    origin   = new Point2D(0, 0),
+    p1       = new Point2D(3, 4),
+    p2       = new Point2D(6, 8),
+    v1       = new Vector2D(3, 4),
+    v2       = new Vector2D(2, 2);
 
-exports.newVector = function(beforeExit, assert) {
-    var v = new Vector2D(10, 20);
 
-    assert.equal(v.x, 10);
-    assert.equal(v.y, 20);
-};
+describe("Vector2D", () => {
+    it("new vector", () => {
+        let v = new Vector2D(10, 20);
 
-exports.vectorFromPoints = function(beforeExit, assert) {
-    var v = Vector2D.fromPoints({ x : 0, y : 0 }, { x : 10, y : 20 });
+        assert.equal(v.x, 10);
+        assert.equal(v.y, 20);
+    });
 
-    assert.equal(v.x, 10);
-    assert.equal(v.y, 20);
-};
+    it("vector from two points", () => {
+        let v = Vector2D.fromPoints(p1, p2);
 
-exports.fromPoints = function(beforeExit, assert) {
-};
+        assert.equal(v.x, 3);
+        assert.equal(v.y, 4);
+    });
 
-exports.length = function(beforeExit, assert) {
-};
+    it("length", () => {
+        let v = new Vector2D(3, 4),
+            length = v.length();
 
-exports.magnitude = function(beforeExit, assert) {
-};
+        assert.equal(length, 5);
+    });
 
-exports.dot = function(beforeExit, assert) {
-};
+    it("magnitude", () => {
+        let magnitude = v1.magnitude();
 
-exports.cross = function(beforeExit, assert) {
-};
+        assert.equal(magnitude, 25);
+    });
 
-exports.determinant = function(beforeExit, assert) {
-};
+    it("dot", () => {
+        let dot = v1.dot(v2);
 
-exports.unit = function(beforeExit, assert) {
-};
+        assert.equal(dot, 14);
+    });
 
-exports.add = function(beforeExit, assert) {
-};
+    it("cross", () => {
+        let cross = v1.cross(v2);
 
-exports.subtract = function(beforeExit, assert) {
-};
+        assert.equal(cross, -2);
+    });
 
-exports.multiply = function(beforeExit, assert) {
-};
+    it("determinant", () => {
+        let determinant = v1.determinant(v2);
 
-exports.divide = function(beforeExit, assert) {
-};
+        assert.equal(determinant, -2);
+    });
 
-exports.angleBetween = function(beforeExit, assert) {
-};
+    it("unit", () => {
+        let unit = v1.unit();
 
-exports.perp = function(beforeExit, assert) {
-};
+        assert.equal(unit.x, 0.6);
+        assert.equal(unit.y, 0.8);
+    });
 
-exports.perpendicular = function(beforeExit, assert) {
-};
+    it("add", () => {
+        let newv = v1.add(v2);
 
-exports.project = function(beforeExit, assert) {
-};
+        assert.equal(newv.x, 5);
+        assert.equal(newv.y, 6);
+    });
 
-exports.transform = function(beforeExit, assert) {
-};
+    it("subtract", () => {
+        let newv = v1.subtract(v2);
 
-exports.equals = function(beforeExit, assert) {
-};
+        assert.equal(newv.x, 1);
+        assert.equal(newv.y, 2);
+    });
 
-exports.toString = function(beforeExit, assert) {
-};
+    it("multiply", () => {
+        let newv = v1.multiply(2);
 
-// exports.setX = function(beforeExit, assert) {
-//     var v = new Vector2D(10, 20);
+        assert.equal(newv.x, 6);
+        assert.equal(newv.y, 8);
+    });
 
-//     v.x = 20;
+    it("divide", () => {
+        let newv = v2.divide(2);
 
-//     console.log(v.toString());
-// };
+        assert.equal(newv.x, 1);
+        assert.equal(newv.y, 1);
+    });
+
+    it("angleBetween", () => {
+        let v1 = new Vector2D(1, 0),
+            v2 = new Vector2D(0, 1),
+            perp1 = v1.angleBetween(v2),
+            perp2 = v2.angleBetween(v1);
+
+        assert.equal(perp1, -perp2);
+        assert.equal(perp1, Math.PI/2);
+
+    });
+
+    it("perp", () => {
+        let perp = v1.perp(),
+            phi = v1.angleBetween(perp);
+
+        assert.equal(perp.x, -v1.y);
+        assert.equal(perp.y, v1.x);
+        assert.equal(phi, Math.PI/2);
+    });
+
+    it("perpendicular", () => {
+        let perpendicular = v1.perpendicular(v2);
+
+        assert.equal(perpendicular.x, -0.5);
+        assert.equal(perpendicular.y, 0.5);
+    });
+
+    it("project", () => {
+        let project = v1.project(v2);
+
+        assert.equal(project.x, 3.5);
+        assert.equal(project.y, 3.5);
+    });
+
+    it("transform", () => {
+        let m = new Matrix2D(1, 1, 1, 1, 1, 1),
+            a = v1.transform(Matrix2D.IDENTITY),
+            b = v1.transform(m);
+
+        assert.equal(a.x, v1.x);
+        assert.equal(a.y, v1.y);
+
+        assert.equal(b.x, b.y);
+        assert.equal(b.x, 7);
+    });
+
+    it("equals", () => {
+        let t = v1.equals(v1),
+            f = v1.equals(v2);
+
+        assert.equal(t, true);
+        assert.equal(f, false);
+    });
+
+    it("to string", () => {
+        let str = v1.toString();
+
+        assert.equal(str, 'vector(3,4)');
+    });
+});

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

43587

increased by41.53%

Number of package files

27

increased by107.69%

Lines of code

1135

increased by6.37%

No dependency changes