@wemap/geo 9.0.0-alpha.4 → 9.0.0

package/index.d.ts

@@ -13,7 +13,7 @@ declare module '@wemap/geo' {
         static union(first: Level_t, second: Level_t): Level_t;
         static multiplyBy(level: Level_t, factor: number): Level_t;
         static toString(level: Level_t): string;
-        static equalsTo(first: Level_t, second: Level_t): boolean;
+        static equals(first: Level_t, second: Level_t): boolean;
         static diff(first: Level_t, second: Level_t): null | number;
 
         /** @deprecated */
@@ -36,8 +36,8 @@ declare module '@wemap/geo' {
 
         clone(): Coordinates;
         wrap(): void;
-        static equalsTo(pos1: Coordinates, pos2: Coordinates, eps?: number, epsAlt?: number): boolean;
-        equalsTo(other: Coordinates): boolean;
+        static equals(pos1: Coordinates, pos2: Coordinates, eps?: number, epsAlt?: number): boolean;
+        equals(other: Coordinates): boolean;
 
         destinationPoint(distance: number, bearing: number, elevation?: number): Coordinates;
         move(distance: number, bearing: number, elevation?: number): void;

package/package.json

@@ -13,7 +13,7 @@
         "directory": "packages/geo"
     },
     "name": "@wemap/geo",
-    "version": "9.0.0-alpha.4",
+    "version": "9.0.0",
     "bugs": {
         "url": "https://github.com/wemap/wemap-modules-js/issues"
     },
@@ -28,8 +28,8 @@
     ],
     "license": "ISC",
     "dependencies": {
-        "@wemap/logger": "^9.0.0-alpha.1",
-        "@wemap/maths": "^8.1.0"
+        "@wemap/logger": "^9.0.0",
+        "@wemap/maths": "^9.0.0"
     },
-    "gitHead": "f3e01640197d58e16362feff33b9a02c36144e31"
+    "gitHead": "9f16c3cebf6f0e6d03a83835607528f5c37707cf"
 }

package/src/Utils.js

@@ -94,14 +94,14 @@ export function trimRoute(route, startPosition = route[0], length = Number.MAX_V
         const p1 = route[currentPointIndex - 1];
         const p2 = route[currentPointIndex];
 
-        if (Coordinates.equalsTo(startPosition, p1)) {
+        if (Coordinates.equals(startPosition, p1)) {
             newRoute.push(p1);
             previousPoint = p1;
             break;
         }
 
         const proj = startPosition.getSegmentProjection(p1, p2);
-        if (proj && Coordinates.equalsTo(startPosition, proj) && !proj.equalsTo(p2)) {
+        if (proj && Coordinates.equals(startPosition, proj) && !proj.equals(p2)) {
             newRoute.push(proj);
             previousPoint = proj;
             break;
@@ -139,7 +139,7 @@ export function trimRoute(route, startPosition = route[0], length = Number.MAX_V
  */
 export function simplifyRoute(coords, precisionAngle = deg2rad(5)) {
 
-    const isClosed = (coords[0].equalsTo(coords[coords.length - 1]));
+    const isClosed = (coords[0].equals(coords[coords.length - 1]));
 
     let newRoute = coords.slice(0, coords.length - (isClosed ? 1 : 0));
 

package/src/Utils.spec.js

@@ -66,43 +66,43 @@ describe('Geo Utils', () => {
         newRoute = trimRoute(route);
         expect(newRoute.length).equals(3);
         for (let i = 0; i < newRoute.length - 1; i++) {
-            expect(newRoute[i].equalsTo(route[i])).true;
+            expect(newRoute[i].equals(route[i])).true;
         }
 
         newRoute = trimRoute(route, p1, 100);
         expect(newRoute.length).equals(2);
-        expect(newRoute[0].equalsTo(p1)).true;
-        expect(newRoute[1].equalsTo(p2)).true;
+        expect(newRoute[0].equals(p1)).true;
+        expect(newRoute[1].equals(p2)).true;
 
         newRoute = trimRoute(route, p1, 90);
         expect(newRoute.length).equals(2);
-        expect(newRoute[0].equalsTo(p1)).true;
-        expect(newRoute[1].equalsTo(p1.destinationPoint(90, Math.PI / 4))).true;
+        expect(newRoute[0].equals(p1)).true;
+        expect(newRoute[1].equals(p1.destinationPoint(90, Math.PI / 4))).true;
 
         newRoute = trimRoute(route, p2, 10);
         expect(newRoute.length).equals(2);
-        expect(newRoute[0].equalsTo(p2)).true;
-        expect(newRoute[1].equalsTo(p2.destinationPoint(10, Math.PI / 2))).true;
+        expect(newRoute[0].equals(p2)).true;
+        expect(newRoute[1].equals(p2.destinationPoint(10, Math.PI / 2))).true;
 
         const p4 = p1.destinationPoint(20, Math.PI / 4);
         newRoute = trimRoute(route, p4);
         expect(newRoute.length).equals(3);
-        expect(newRoute[0].equalsTo(p4)).true;
-        expect(newRoute[1].equalsTo(p2)).true;
-        expect(newRoute[2].equalsTo(p3)).true;
+        expect(newRoute[0].equals(p4)).true;
+        expect(newRoute[1].equals(p2)).true;
+        expect(newRoute[2].equals(p3)).true;
 
         const p5 = p2.destinationPoint(20, Math.PI / 2);
         newRoute = trimRoute(route, p4, 100);
         expect(newRoute.length).equals(3);
-        expect(newRoute[0].equalsTo(p4)).true;
-        expect(newRoute[1].equalsTo(p2)).true;
-        expect(newRoute[2].equalsTo(p5)).true;
+        expect(newRoute[0].equals(p4)).true;
+        expect(newRoute[1].equals(p2)).true;
+        expect(newRoute[2].equals(p5)).true;
 
         newRoute = trimRoute(route, p4, 200);
         expect(newRoute.length).equals(3);
-        expect(newRoute[0].equalsTo(p4)).true;
-        expect(newRoute[1].equalsTo(p2)).true;
-        expect(newRoute[2].equalsTo(p3)).true;
+        expect(newRoute[0].equals(p4)).true;
+        expect(newRoute[1].equals(p2)).true;
+        expect(newRoute[2].equals(p3)).true;
     });
 
     it('simplifyRoute', () => {

package/src/coordinates/BoundingBox.js

@@ -195,13 +195,13 @@ class BoundingBox {
         return this.northEast.lat;
     }
 
-    static equalsTo(bb1, bb2) {
-        return Coordinates.equalsTo(bb1.northEast, bb2.northEast)
-            && Coordinates.equalsTo(bb1.southWest, bb2.southWest);
+    static equals(bb1, bb2) {
+        return Coordinates.equals(bb1.northEast, bb2.northEast)
+            && Coordinates.equals(bb1.southWest, bb2.southWest);
     }
 
-    equalsTo(other) {
-        return BoundingBox.equalsTo(this, other);
+    equals(other) {
+        return BoundingBox.equals(this, other);
     }
 
     /**

package/src/coordinates/BoundingBox.spec.js

@@ -34,22 +34,22 @@ describe('Bounding Box', () => {
         expect(boundingBox.southWest).equals(southWest);
 
         const boundingBox2 = BoundingBox.fromArray([-20, -5, 40, 10]);
-        expect(boundingBox2.equalsTo(boundingBox)).is.true;
+        expect(boundingBox2.equals(boundingBox)).is.true;
     });
 
 
-    it('equalsTo', () => {
+    it('equals', () => {
         boundingBox = new BoundingBox(northEast, southWest);
-        expect(boundingBox.equalsTo(new BoundingBox(
+        expect(boundingBox.equals(new BoundingBox(
             new Coordinates(10, 40), new Coordinates(-5, -20)
         ))).true;
-        expect(BoundingBox.equalsTo(boundingBox, new BoundingBox(
+        expect(BoundingBox.equals(boundingBox, new BoundingBox(
             new Coordinates(10, 40), new Coordinates(-5, -20)
         ))).true;
-        expect(BoundingBox.equalsTo(boundingBox, new BoundingBox(
+        expect(BoundingBox.equals(boundingBox, new BoundingBox(
             new Coordinates(10, 10), new Coordinates(-5, -20)
         ))).false;
-        expect(BoundingBox.equalsTo(boundingBox, new BoundingBox(
+        expect(BoundingBox.equals(boundingBox, new BoundingBox(
             new Coordinates(10, 40), new Coordinates(-15, -20)
         ))).false;
     });
@@ -60,11 +60,11 @@ describe('Bounding Box', () => {
         expect(boundingBox.getEast()).equals(northEast.lng);
         expect(boundingBox.getSouth()).equals(southWest.lat);
         expect(boundingBox.getWest()).equals(southWest.lng);
-        expect(Coordinates.equalsTo(boundingBox.getNorthEast(), northEast)).true;
-        expect(Coordinates.equalsTo(boundingBox.getSouthWest(), southWest)).true;
-        expect(Coordinates.equalsTo(boundingBox.getNorthWest(),
+        expect(Coordinates.equals(boundingBox.getNorthEast(), northEast)).true;
+        expect(Coordinates.equals(boundingBox.getSouthWest(), southWest)).true;
+        expect(Coordinates.equals(boundingBox.getNorthWest(),
             new Coordinates(northEast.lat, southWest.lng))).true;
-        expect(Coordinates.equalsTo(boundingBox.getSouthEast(),
+        expect(Coordinates.equals(boundingBox.getSouthEast(),
             new Coordinates(southWest.lat, northEast.lng))).true;
     });
 

package/src/coordinates/Coordinates.js

@@ -162,7 +162,7 @@ class Coordinates {
      * @param {Number} eps latitude and longitude epsilon in degrees (default: 1e-8 [~1mm at lat=0])
      * @param {Number} epsAlt altitude epsilon in meters (default: 1e-3 [= 1mm])
      */
-    static equalsTo(pos1, pos2, eps = Constants.EPS_DEG_MM, epsAlt = Constants.EPS_MM) {
+    static equals(pos1, pos2, eps = Constants.EPS_DEG_MM, epsAlt = Constants.EPS_MM) {
 
         // Handle null comparison
         if (pos1 === null && pos1 === pos2) {
@@ -178,15 +178,15 @@ class Coordinates {
             && (pos1.alt === pos2.alt
                 || pos1.alt !== null && pos2.alt !== null
                 && Math.abs(pos2.alt - pos1.alt) < epsAlt)
-            && Level.equalsTo(pos1.level, pos2.level);
+            && Level.equals(pos1.level, pos2.level);
     }
 
     /**
      * @param {Coordinates} other
      * @returns {!Boolean}
      */
-    equalsTo(other) {
-        return Coordinates.equalsTo(this, other);
+    equals(other) {
+        return Coordinates.equals(this, other);
     }
 
     /**

package/src/coordinates/Coordinates.spec.js

@@ -74,34 +74,34 @@ describe('Coordinates', () => {
         expect(clonePosition.level).not.equals(level);
     });
 
-    it('equalsTo', () => {
+    it('equals', () => {
         let position;
 
         position = new Coordinates(0, 0);
-        expect(Coordinates.equalsTo(position, new Coordinates(0, 0))).true;
-        expect(Coordinates.equalsTo(position, new Coordinates(0, 0, 0))).false;
-        expect(Coordinates.equalsTo(position, new Coordinates(0, 0, null, 0))).false;
-        expect(Coordinates.equalsTo(position, new Coordinates(0, 0, null, null))).true;
+        expect(Coordinates.equals(position, new Coordinates(0, 0))).true;
+        expect(Coordinates.equals(position, new Coordinates(0, 0, 0))).false;
+        expect(Coordinates.equals(position, new Coordinates(0, 0, null, 0))).false;
+        expect(Coordinates.equals(position, new Coordinates(0, 0, null, null))).true;
 
 
         position = new Coordinates(45, 5, 0, 0);
-        expect(Coordinates.equalsTo(position, new Coordinates(45, 5, 0, 0))).true;
-        expect(Coordinates.equalsTo(position, new Coordinates(45, 5, 1, 0))).false;
-        expect(Coordinates.equalsTo(position, new Coordinates(45, 5, 0, 1))).false;
-        expect(Coordinates.equalsTo(position, {
+        expect(Coordinates.equals(position, new Coordinates(45, 5, 0, 0))).true;
+        expect(Coordinates.equals(position, new Coordinates(45, 5, 1, 0))).false;
+        expect(Coordinates.equals(position, new Coordinates(45, 5, 0, 1))).false;
+        expect(Coordinates.equals(position, {
             lat: 45,
             lng: 5
         })).false;
-        expect(Coordinates.equalsTo({
+        expect(Coordinates.equals({
             lat: 45,
             lng: 5
         }, position)).false;
-        expect(Coordinates.equalsTo(position, null)).false;
-        expect(Coordinates.equalsTo(null, position)).false;
-        expect(Coordinates.equalsTo(null, null)).true;
+        expect(Coordinates.equals(position, null)).false;
+        expect(Coordinates.equals(null, position)).false;
+        expect(Coordinates.equals(null, null)).true;
 
-        expect(position.equalsTo(new Coordinates(45, 5, 0, 0))).true;
-        expect(position.equalsTo(new Coordinates(45, 5, 0, 1))).false;
+        expect(position.equals(new Coordinates(45, 5, 0, 0))).true;
+        expect(position.equals(new Coordinates(45, 5, 0, 1))).false;
     });
 
     it('toString', () => {
@@ -123,13 +123,13 @@ describe('Coordinates', () => {
         let position;
 
         position = new Coordinates(0, 0, 0, 0).move(100000, 0);
-        expect(Coordinates.equalsTo(position, new Coordinates(0.8983152841195214, 0, 0, 0))).true;
+        expect(Coordinates.equals(position, new Coordinates(0.8983152841195214, 0, 0, 0))).true;
 
         position = new Coordinates(0, 0, 0, 0).move(100000, Math.PI / 2);
-        expect(Coordinates.equalsTo(position, new Coordinates(0, 0.8983152841195212, 0, 0))).true;
+        expect(Coordinates.equals(position, new Coordinates(0, 0.8983152841195212, 0, 0))).true;
 
         position = new Coordinates(0, 0, 0).move(100000, 0, 10);
-        expect(Coordinates.equalsTo(position, new Coordinates(0.8983152841195214, 0, 10))).true;
+        expect(Coordinates.equals(position, new Coordinates(0.8983152841195214, 0, 10))).true;
 
         expect(() => new Coordinates(0, 0).move(100000, 0, 10)).throw(Error);
 
@@ -138,7 +138,7 @@ describe('Coordinates', () => {
         const newPosition = position.destinationPoint(100000, 0);
         expect(newPosition).not.equals(position);
         expect(newPosition.level).not.equal(position.level);
-        expect(Coordinates.equalsTo(newPosition, new Coordinates(0.8983152841195214, 0, null, level))).true;
+        expect(Coordinates.equals(newPosition, new Coordinates(0.8983152841195214, 0, null, level))).true;
     });
 
 
@@ -149,7 +149,7 @@ describe('Coordinates', () => {
         expect(position.ecef).deep.equals(
             [4492868.9655526765, 393075.10119330435, 4510030.995104634]
         );
-        expect(Coordinates.equalsTo(Coordinates.fromECEF(position.ecef), position)).true;
+        expect(Coordinates.equals(Coordinates.fromECEF(position.ecef), position)).true;
         expect(position.enuToEcefRotation).deep.equals(
             [0.6241639651811595, 0.2585371795226045, 0.2821438218554906, 0.6811554412633039]
         );
@@ -159,7 +159,7 @@ describe('Coordinates', () => {
 
         position = new Coordinates(-15, 25, 1200);
         expect(position.ecef).deep.equals([5584638.098155466, 2604159.5131940604, -1651093.9107271794]);
-        expect(Coordinates.equalsTo(Coordinates.fromECEF(position.ecef), position)).true;
+        expect(Coordinates.equals(Coordinates.fromECEF(position.ecef), position)).true;
         expect(position.enuToEcefRotation).deep.equals(
             [0.32708727738303844, 0.42626843901912514, 0.6691074207087071, 0.5134241817667833]
         );
@@ -181,10 +181,10 @@ describe('Coordinates', () => {
         p2 = new Coordinates(0, 30);
 
         projection = new Coordinates(45, 5).getSegmentProjection(p1, p2);
-        expect(Coordinates.equalsTo(projection, new Coordinates(0, 5))).true;
+        expect(Coordinates.equals(projection, new Coordinates(0, 5))).true;
 
         projection = new Coordinates(-10, 30).getSegmentProjection(p1, p2);
-        expect(Coordinates.equalsTo(projection, new Coordinates(0, 30))).true;
+        expect(Coordinates.equals(projection, new Coordinates(0, 30))).true;
 
         projection = new Coordinates(10, 50).getSegmentProjection(p1, p2);
         expect(projection).is.null;
@@ -193,10 +193,10 @@ describe('Coordinates', () => {
         p2 = new Coordinates(30, 10);
 
         projection = new Coordinates(10, -30).getSegmentProjection(p1, p2);
-        expect(Coordinates.equalsTo(projection, new Coordinates(1.5735557770204767, 0.473398796436419))).true;
+        expect(Coordinates.equals(projection, new Coordinates(1.5735557770204767, 0.473398796436419))).true;
 
         projection = new Coordinates(0, 10).getSegmentProjection(p1, p2);
-        expect(Coordinates.equalsTo(projection, new Coordinates(2.7840283663153627, 0.8380346611000419))).true;
+        expect(Coordinates.equals(projection, new Coordinates(2.7840283663153627, 0.8380346611000419))).true;
 
         projection = new Coordinates(45, 5).getSegmentProjection(p1, p2);
         expect(projection).is.null;
@@ -205,7 +205,7 @@ describe('Coordinates', () => {
         p2 = new Coordinates(0, 30, 15);
 
         projection = new Coordinates(45, 5, 0).getSegmentProjection(p1, p2);
-        expect(Coordinates.equalsTo(projection, new Coordinates(0, 5, 12.5))).true;
+        expect(Coordinates.equals(projection, new Coordinates(0, 5, 12.5))).true;
 
     });
 
@@ -273,39 +273,39 @@ describe('Coordinates', () => {
         let position;
 
         position = new Coordinates(0, 0);
-        expect(Coordinates.equalsTo(Coordinates.fromJson(position.toJson()), position)).true;
+        expect(Coordinates.equals(Coordinates.fromJson(position.toJson()), position)).true;
 
         position = new Coordinates(5, -10, 2);
-        expect(Coordinates.equalsTo(Coordinates.fromJson(position.toJson()), position)).true;
+        expect(Coordinates.equals(Coordinates.fromJson(position.toJson()), position)).true;
 
         position = new Coordinates(5, -10, null, [1, 2]);
-        expect(Coordinates.equalsTo(Coordinates.fromJson(position.toJson()), position)).true;
+        expect(Coordinates.equals(Coordinates.fromJson(position.toJson()), position)).true;
 
         position = new Coordinates(5, -10, 3, [1, 2]);
-        expect(Coordinates.equalsTo(Coordinates.fromJson(position.toJson()), position)).true;
+        expect(Coordinates.equals(Coordinates.fromJson(position.toJson()), position)).true;
 
 
-        expect(Coordinates.equalsTo(
+        expect(Coordinates.equals(
             Coordinates.fromCompressedJson([5, -10, null, 0]),
             new Coordinates(5, -10, null, 0))
         ).true;
 
-        expect(Coordinates.equalsTo(
+        expect(Coordinates.equals(
             Coordinates.fromCompressedJson([5, -10, null, 1]),
             new Coordinates(5, -10, null, 1))
         ).true;
 
-        expect(Coordinates.equalsTo(
+        expect(Coordinates.equals(
             Coordinates.fromCompressedJson([5, -10, null, '1']),
             new Coordinates(5, -10, null, 1))
         ).true;
 
-        expect(Coordinates.equalsTo(
+        expect(Coordinates.equals(
             Coordinates.fromCompressedJson([5, -10, null, '1;2']),
             new Coordinates(5, -10, null, [1, 2]))
         ).true;
 
-        expect(Coordinates.equalsTo(
+        expect(Coordinates.equals(
             Coordinates.fromCompressedJson([5, -10, 10, '2;3']),
             new Coordinates(5, -10, 10, [2, 3]))
         ).true;

package/src/coordinates/Level.js

@@ -137,7 +137,7 @@ class Level {
             return null;
         }
 
-        if (this.equalsTo(first, second)) {
+        if (this.equals(first, second)) {
             return this.clone(first);
         }
 
@@ -247,7 +247,7 @@ class Level {
      * @param {null|number|[number, number]} second
      * @returns {boolean}
      */
-    static equalsTo(first, second) {
+    static equals(first, second) {
 
         if (this.VERIFY_TYPING) {
             this.checkType(first);
@@ -305,7 +305,7 @@ class Level {
             return null;
         }
 
-        if (Level.equalsTo(first, second)) {
+        if (Level.equals(first, second)) {
             return 0;
         }
 

package/src/coordinates/Level.spec.js

@@ -44,12 +44,13 @@ describe('Level', () => {
 
     it('fromString', () => {
         const listOfInvalidLevel = ['toto', 'toto;toto', '1;toto', 'toto;1',
-            true, false, NaN, null];
+            true, false, NaN];
 
         listOfInvalidLevel.forEach(value1 => {
             expect(() => Level.fromString(value1)).throw(Error);
         });
 
+        expect(Level.fromString(null)).is.null;
         expect(Level.fromString('0')).equal(0);
         expect(Level.fromString('1')).equal(1);
         expect(Level.fromString('-1')).equal(-1);
@@ -65,6 +66,7 @@ describe('Level', () => {
 
 
     it('toString', () => {
+        expect(Level.toString(null)).is.null;
         expect(Level.toString(0)).equals('0');
         expect(Level.toString(1)).equals('1');
         expect(Level.toString(-1)).equals('-1');
@@ -78,12 +80,12 @@ describe('Level', () => {
         expect(Level.toString([-1.5, 1.5])).equals('-1.5;1.5');
     });
 
-    it('equalsTo', () => {
-        expect(Level.equalsTo(1, 1)).true;
-        expect(Level.equalsTo(-1, 1)).false;
-        expect(Level.equalsTo(1, [0, 1])).false;
-        expect(Level.equalsTo([0, 1], 1)).false;
-        expect(Level.equalsTo([0, 1], [0, 1])).true;
+    it('equals', () => {
+        expect(Level.equals(1, 1)).true;
+        expect(Level.equals(-1, 1)).false;
+        expect(Level.equals(1, [0, 1])).false;
+        expect(Level.equals([0, 1], 1)).false;
+        expect(Level.equals([0, 1], [0, 1])).true;
     });
 
     it('clone', () => {

package/src/coordinates/RelativePosition.js

@@ -112,7 +112,7 @@ class RelativePosition {
      * @param {RelativePosition} pos2 position 2
      * @param {Number} eps x, y, z epsilon in meters (default: 1e-3 [= 1mm])
      */
-    static equalsTo(pos1, pos2, eps = Constants.EPS_MM) {
+    static equals(pos1, pos2, eps = Constants.EPS_MM) {
 
         // Handle null comparison
         if (pos1 === null && pos1 === pos2) {
@@ -131,8 +131,8 @@ class RelativePosition {
             && pos1.bearing === pos2.bearing;
     }
 
-    equalsTo(other) {
-        return RelativePosition.equalsTo(this, other);
+    equals(other) {
+        return RelativePosition.equals(this, other);
     }
 
 

package/src/coordinates/RelativePosition.spec.js

@@ -69,47 +69,47 @@ describe('RelativePosition', () => {
     });
 
 
-    it('equalsTo', () => {
+    it('equals', () => {
         let position, position2;
 
-        expect(RelativePosition.equalsTo(null, null)).true;
+        expect(RelativePosition.equals(null, null)).true;
 
         position = new RelativePosition(1, 2, 3);
-        expect(RelativePosition.equalsTo(position, new RelativePosition(1, 2, 3))).true;
-        expect(RelativePosition.equalsTo(position, {})).false;
-        expect(RelativePosition.equalsTo({}, position)).false;
+        expect(RelativePosition.equals(position, new RelativePosition(1, 2, 3))).true;
+        expect(RelativePosition.equals(position, {})).false;
+        expect(RelativePosition.equals({}, position)).false;
 
         position = new RelativePosition(1, 2, 3, 123456, 10, Math.PI);
-        expect(RelativePosition.equalsTo(position,
+        expect(RelativePosition.equals(position,
             new RelativePosition(1, 2, 3, 123456, 10, Math.PI)
         )).true;
 
         position2 = position.clone();
         position2.x = 0;
-        expect(RelativePosition.equalsTo(position, position2)).false;
+        expect(RelativePosition.equals(position, position2)).false;
 
         position2 = position.clone();
         position2.y = 0;
-        expect(RelativePosition.equalsTo(position, position2)).false;
+        expect(RelativePosition.equals(position, position2)).false;
 
         position2 = position.clone();
         position2.z = 0;
-        expect(RelativePosition.equalsTo(position, position2)).false;
+        expect(RelativePosition.equals(position, position2)).false;
 
         position2 = position.clone();
         position2.time = 0;
-        expect(RelativePosition.equalsTo(position, position2)).false;
+        expect(RelativePosition.equals(position, position2)).false;
 
         position2 = position.clone();
         position2.accuracy = 0;
-        expect(RelativePosition.equalsTo(position, position2)).false;
+        expect(RelativePosition.equals(position, position2)).false;
 
         position2 = position.clone();
         position2.bearing = 0;
-        expect(RelativePosition.equalsTo(position, position2)).false;
+        expect(RelativePosition.equals(position, position2)).false;
 
-        expect(position.equalsTo(new RelativePosition(1, 2, 3, 123456, 10, Math.PI))).true;
-        expect(position.equalsTo(new RelativePosition(1, 2, 3, 123456, 0, Math.PI))).false;
+        expect(position.equals(new RelativePosition(1, 2, 3, 123456, 10, Math.PI))).true;
+        expect(position.equals(new RelativePosition(1, 2, 3, 123456, 0, Math.PI))).false;
     });
 
     it('json', () => {
@@ -150,13 +150,13 @@ describe('RelativePosition', () => {
         });
 
         position = new RelativePosition(1, 2, 3);
-        expect(RelativePosition.equalsTo(
+        expect(RelativePosition.equals(
             RelativePosition.fromJson(position.toJson()),
             position)
         ).true;
 
         position = new RelativePosition(1, 2, 3, 123456, 10, Math.PI);
-        expect(RelativePosition.equalsTo(
+        expect(RelativePosition.equals(
             RelativePosition.fromJson(position.toJson()),
             position)
         ).true;

package/src/coordinates/UserPosition.js

@@ -88,7 +88,7 @@ class UserPosition extends Coordinates {
      * @param {Number} eps latitude and longitude epsilon in degrees (default: 1e-8 [~1mm at lat=0])
      * @param {Number} epsAlt altitude epsilon in meters (default: 1e-3 [= 1mm])
      */
-    static equalsTo(pos1, pos2, eps = Constants.EPS_DEG_MM, epsAlt = Constants.EPS_MM) {
+    static equals(pos1, pos2, eps = Constants.EPS_DEG_MM, epsAlt = Constants.EPS_MM) {
 
         // Handle null comparison
         if (pos1 === null && pos1 === pos2) {
@@ -99,7 +99,7 @@ class UserPosition extends Coordinates {
             return false;
         }
 
-        if (!super.equalsTo(pos1, pos2, eps, epsAlt)) {
+        if (!super.equals(pos1, pos2, eps, epsAlt)) {
             return false;
         }
 
@@ -108,8 +108,8 @@ class UserPosition extends Coordinates {
             && pos1.bearing === pos2.bearing;
     }
 
-    equalsTo(other) {
-        return UserPosition.equalsTo(this, other);
+    equals(other) {
+        return UserPosition.equals(this, other);
     }
 
 

package/src/coordinates/UserPosition.spec.js

@@ -47,7 +47,7 @@ describe('UserPosition', () => {
         expect(position.lat).equals(45);
         expect(position.lng).equals(5);
         expect(position.alt).equals(0);
-        expect(Level.equalsTo(position.level, 2)).true;
+        expect(Level.equals(position.level, 2)).true;
         expect(position.time).equals(123456);
         expect(position.accuracy).equals(10);
         expect(position.bearing).equals(Math.PI);
@@ -66,7 +66,7 @@ describe('UserPosition', () => {
         expect(position.lat).equals(45);
         expect(position.lng).equals(5);
         expect(position.alt).equals(0);
-        expect(Level.equalsTo(position.level, 2)).true;
+        expect(Level.equals(position.level, 2)).true;
         expect(position.time).equals(123456);
         expect(position.accuracy).equals(10);
         expect(position.bearing).equals(Math.PI);
@@ -81,7 +81,7 @@ describe('UserPosition', () => {
         expect(position.lat).equals(45);
         expect(position.lng).equals(5);
         expect(position.alt).equals(0);
-        expect(Level.equalsTo(position.level, level)).true;
+        expect(Level.equals(position.level, level)).true;
         expect(position.time).is.null;
         expect(position.accuracy).is.null;
         expect(position.bearing).is.null;
@@ -96,7 +96,7 @@ describe('UserPosition', () => {
         expect(clonePosition.lat).equals(45);
         expect(clonePosition.lng).equals(5);
         expect(clonePosition.alt).equals(0);
-        expect(Level.equalsTo(clonePosition.level, level)).true;
+        expect(Level.equals(clonePosition.level, level)).true;
         expect(clonePosition.level).not.equals(level);
         expect(clonePosition.time).equals(123456);
         expect(clonePosition.accuracy).equals(10);
@@ -104,52 +104,52 @@ describe('UserPosition', () => {
     });
 
 
-    it('equalsTo', () => {
+    it('equals', () => {
         let position, position2;
 
-        expect(UserPosition.equalsTo(null, null)).true;
+        expect(UserPosition.equals(null, null)).true;
 
         position = new UserPosition(0, 0);
-        expect(UserPosition.equalsTo(position, new UserPosition(0, 0))).true;
-        expect(UserPosition.equalsTo(position, new Coordinates(0, 0))).false;
+        expect(UserPosition.equals(position, new UserPosition(0, 0))).true;
+        expect(UserPosition.equals(position, new Coordinates(0, 0))).false;
 
         position = new UserPosition(45, 5, 0, 2, 123456, 10, Math.PI);
-        expect(UserPosition.equalsTo(position,
+        expect(UserPosition.equals(position,
             new UserPosition(45, 5, 0, 2, 123456, 10, Math.PI)
         )).true;
 
         position2 = position.clone();
         position2.lat = 0;
-        expect(UserPosition.equalsTo(position, position2)).false;
+        expect(UserPosition.equals(position, position2)).false;
 
         position2 = position.clone();
         position2.lng = 0;
-        expect(UserPosition.equalsTo(position, position2)).false;
+        expect(UserPosition.equals(position, position2)).false;
 
         position2 = position.clone();
         position2.alt = 10;
-        expect(UserPosition.equalsTo(position, position2)).false;
+        expect(UserPosition.equals(position, position2)).false;
 
         position2 = position.clone();
         position2.level = null;
-        expect(UserPosition.equalsTo(position, position2)).false;
+        expect(UserPosition.equals(position, position2)).false;
 
         position2 = position.clone();
         position2.time = 0;
-        expect(UserPosition.equalsTo(position, position2)).false;
+        expect(UserPosition.equals(position, position2)).false;
 
         position2 = position.clone();
         position2.accuracy = 0;
-        expect(UserPosition.equalsTo(position, position2)).false;
+        expect(UserPosition.equals(position, position2)).false;
 
         position2 = position.clone();
         position2.bearing = 0;
-        expect(UserPosition.equalsTo(position, position2)).false;
+        expect(UserPosition.equals(position, position2)).false;
 
-        expect(position.equalsTo(
+        expect(position.equals(
             new UserPosition(45, 5, 0, 2, 123456, 10, Math.PI)
         )).true;
-        expect(position.equalsTo(
+        expect(position.equals(
             new UserPosition(45, 5, 0, 2, 123456, 0, Math.PI)
         )).false;
     });
@@ -204,13 +204,13 @@ describe('UserPosition', () => {
         });
 
         position = new UserPosition(5, -10);
-        expect(UserPosition.equalsTo(
+        expect(UserPosition.equals(
             UserPosition.fromJson(position.toJson()),
             position)
         ).true;
 
         position = new UserPosition(45, 5, 0, 2, 123456, 10, Math.PI);
-        expect(UserPosition.equalsTo(
+        expect(UserPosition.equals(
             UserPosition.fromJson(position.toJson()),
             position)
         ).true;

package/src/graph/GraphEdge.js

@@ -135,7 +135,7 @@ class GraphEdge {
      * @param {GraphEdge<T>} other
      * @returns {boolean}
      */
-    equalsTo(other) {
+    equals(other) {
 
         if (this === other) {
             return true;
@@ -145,9 +145,9 @@ class GraphEdge {
             return false;
         }
 
-        return other.node1.equalsTo(this.node1)
-            && other.node2.equalsTo(this.node2)
-            && Level.equalsTo(other.level, this.level)
+        return other.node1.equals(this.node1)
+            && other.node2.equals(this.node2)
+            && Level.equals(other.level, this.level)
             && other.isOneway === this.isOneway
             && other.builtFrom === this.builtFrom;
     }

package/src/graph/GraphEdge.spec.js

@@ -56,34 +56,34 @@ describe('GraphEdge', () => {
         expect(newEdge.length).equals(node1.distanceTo(node2));
     });
 
-    it('equalsTo', () => {
+    it('equals', () => {
 
         const testedEdge = new GraphEdge(node1, node2);
 
-        expect(edge.equalsTo({})).false;
+        expect(edge.equals({})).false;
 
-        expect(edge.equalsTo(testedEdge)).true;
-        expect(fullEdge.equalsTo(testedEdge)).false;
+        expect(edge.equals(testedEdge)).true;
+        expect(fullEdge.equals(testedEdge)).false;
 
         testedEdge.level = 1;
-        expect(edge.equalsTo(testedEdge)).false;
-        expect(fullEdge.equalsTo(testedEdge)).false;
+        expect(edge.equals(testedEdge)).false;
+        expect(fullEdge.equals(testedEdge)).false;
 
         testedEdge.isOneway = true;
-        expect(edge.equalsTo(testedEdge)).false;
-        expect(fullEdge.equalsTo(testedEdge)).false;
+        expect(edge.equals(testedEdge)).false;
+        expect(fullEdge.equals(testedEdge)).false;
 
         testedEdge.builtFrom = 'w1';
-        expect(edge.equalsTo(testedEdge)).false;
-        expect(fullEdge.equalsTo(testedEdge)).true;
+        expect(edge.equals(testedEdge)).false;
+        expect(fullEdge.equals(testedEdge)).true;
 
     });
 
     it('clone', () => {
         let edgeBis = edge.clone();
-        expect(edgeBis.equalsTo(edge)).true;
+        expect(edgeBis.equals(edge)).true;
 
         edgeBis = fullEdge.clone();
-        expect(edgeBis.equalsTo(fullEdge)).true;
+        expect(edgeBis.equals(fullEdge)).true;
     });
 });

package/src/graph/GraphNode.js

@@ -65,8 +65,8 @@ class GraphNode {
      * @param {GraphNode} other
      * @returns {boolean}
      */
-    equalsTo(other) {
-        return this.coords.equalsTo(other.coords)
+    equals(other) {
+        return this.coords.equals(other.coords)
             && this.builtFrom === other.builtFrom;
     }
 

package/src/graph/GraphNode.spec.js

@@ -41,10 +41,10 @@ describe('GraphNode', () => {
         expect(node1.bearingTo(node2)).equals(pos1.bearingTo(pos2));
     });
 
-    it('equalsTo', () => {
-        expect(node1.equalsTo(node2)).false;
-        expect(node1.equalsTo(node1)).true;
-        expect(new GraphNode(pos1).equalsTo(node1)).true;
+    it('equals', () => {
+        expect(node1.equals(node2)).false;
+        expect(node1.equals(node1)).true;
+        expect(new GraphNode(pos1).equals(node1)).true;
     });
 
     it('clone', () => {
@@ -66,7 +66,7 @@ describe('GraphNode', () => {
         expect(jsonNode).deep.equals([45, 5]);
 
         const nodeBis = GraphNode.fromJson(jsonNode);
-        expect(nodeBis.coords.equalsTo(node.coords)).true;
+        expect(nodeBis.coords.equals(node.coords)).true;
     });
 
     // eslint-disable-next-line max-statements
@@ -91,19 +91,19 @@ describe('GraphNode', () => {
 
         nodes = cleanNodesWithAdjEdges(1, 1);
         expect(GraphNode.generateNodesLevels(nodes)).true;
-        expect(Level.equalsTo(nodes[0].coords.level, 1)).true;
+        expect(Level.equals(nodes[0].coords.level, 1)).true;
 
         nodes = cleanNodesWithAdjEdges(1, [1, 2]);
         expect(GraphNode.generateNodesLevels(nodes)).true;
-        expect(Level.equalsTo(nodes[0].coords.level, 1)).true;
+        expect(Level.equals(nodes[0].coords.level, 1)).true;
 
         nodes = cleanNodesWithAdjEdges([0, 1], [1, 2]);
         expect(GraphNode.generateNodesLevels(nodes)).true;
-        expect(Level.equalsTo(nodes[0].coords.level, 1)).true;
+        expect(Level.equals(nodes[0].coords.level, 1)).true;
 
         nodes = cleanNodesWithAdjEdges([0, 1]);
         expect(GraphNode.generateNodesLevels(nodes)).true;
-        expect(Level.equalsTo(nodes[0].coords.level, [0, 1])).true;
+        expect(Level.equals(nodes[0].coords.level, [0, 1])).true;
 
         /**
          * More complex cases with no adjacent edges
@@ -114,10 +114,10 @@ describe('GraphNode', () => {
         new GraphEdge(nodes[1], nodes[2], [1, 2], 'e1');
         new GraphEdge(nodes[2], nodes[3], [1, 2], 'e2');
         expect(GraphNode.generateNodesLevels(nodes)).true;
-        expect(Level.equalsTo(nodes[0].coords.level, 1)).true;
-        expect(Level.equalsTo(nodes[1].coords.level, 1)).true;
-        expect(Level.equalsTo(nodes[2].coords.level, [1, 2])).true;
-        expect(Level.equalsTo(nodes[3].coords.level, 2)).true;
+        expect(Level.equals(nodes[0].coords.level, 1)).true;
+        expect(Level.equals(nodes[1].coords.level, 1)).true;
+        expect(Level.equals(nodes[2].coords.level, [1, 2])).true;
+        expect(Level.equals(nodes[3].coords.level, 2)).true;
 
 
         nodes = cleanNodes(5);
@@ -133,10 +133,10 @@ describe('GraphNode', () => {
         new GraphEdge(nodes[1], nodes[2], [0, 1], 'e1');
         new GraphEdge(nodes[2], nodes[3], [0, 1], 'e2');
         expect(GraphNode.generateNodesLevels(nodes)).true;
-        expect(Level.equalsTo(nodes[0].coords.level, 1)).true;
-        expect(Level.equalsTo(nodes[1].coords.level, 1)).true;
-        expect(Level.equalsTo(nodes[2].coords.level, [0, 1])).true;
-        expect(Level.equalsTo(nodes[3].coords.level, 0)).true;
+        expect(Level.equals(nodes[0].coords.level, 1)).true;
+        expect(Level.equals(nodes[1].coords.level, 1)).true;
+        expect(Level.equals(nodes[2].coords.level, [0, 1])).true;
+        expect(Level.equals(nodes[3].coords.level, 0)).true;
 
 
         nodes = cleanNodes(4);
@@ -145,10 +145,10 @@ describe('GraphNode', () => {
         new GraphEdge(nodes[2], nodes[3], [1, 2], 'e2');
         new GraphEdge(nodes[1], nodes[3], 1, 'e3');
         expect(GraphNode.generateNodesLevels(nodes)).true;
-        expect(Level.equalsTo(nodes[0].coords.level, 1)).true;
-        expect(Level.equalsTo(nodes[1].coords.level, 1)).true;
-        expect(Level.equalsTo(nodes[2].coords.level, 2)).true;
-        expect(Level.equalsTo(nodes[3].coords.level, 1)).true;
+        expect(Level.equals(nodes[0].coords.level, 1)).true;
+        expect(Level.equals(nodes[1].coords.level, 1)).true;
+        expect(Level.equals(nodes[2].coords.level, 2)).true;
+        expect(Level.equals(nodes[3].coords.level, 1)).true;
 
 
         nodes = cleanNodes(4);
@@ -157,10 +157,10 @@ describe('GraphNode', () => {
         new GraphEdge(nodes[2], nodes[3], [0, 1], 'e2');
         new GraphEdge(nodes[1], nodes[3], 1, 'e3');
         expect(GraphNode.generateNodesLevels(nodes)).true;
-        expect(Level.equalsTo(nodes[0].coords.level, 1)).true;
-        expect(Level.equalsTo(nodes[1].coords.level, 1)).true;
-        expect(Level.equalsTo(nodes[2].coords.level, 0)).true;
-        expect(Level.equalsTo(nodes[3].coords.level, 1)).true;
+        expect(Level.equals(nodes[0].coords.level, 1)).true;
+        expect(Level.equals(nodes[1].coords.level, 1)).true;
+        expect(Level.equals(nodes[2].coords.level, 0)).true;
+        expect(Level.equals(nodes[3].coords.level, 1)).true;
 
 
         nodes = cleanNodes(6);
@@ -178,11 +178,11 @@ describe('GraphNode', () => {
         new GraphEdge(nodes[2], nodes[3], [1, 2]);
         new GraphEdge(nodes[3], nodes[4], 1);
         expect(GraphNode.generateNodesLevels(nodes)).true;
-        expect(Level.equalsTo(nodes[0].coords.level, 2)).true;
-        expect(Level.equalsTo(nodes[1].coords.level, [1, 2])).true;
-        expect(Level.equalsTo(nodes[2].coords.level, [1, 2])).true;
-        expect(Level.equalsTo(nodes[3].coords.level, 1)).true;
-        expect(Level.equalsTo(nodes[4].coords.level, 1)).true;
+        expect(Level.equals(nodes[0].coords.level, 2)).true;
+        expect(Level.equals(nodes[1].coords.level, [1, 2])).true;
+        expect(Level.equals(nodes[2].coords.level, [1, 2])).true;
+        expect(Level.equals(nodes[3].coords.level, 1)).true;
+        expect(Level.equals(nodes[4].coords.level, 1)).true;
 
 
         nodes = cleanNodes(6);
@@ -192,12 +192,12 @@ describe('GraphNode', () => {
         new GraphEdge(nodes[3], nodes[4], [0, 1], 'e3');
         new GraphEdge(nodes[4], nodes[5], 1, 'e4');
         expect(GraphNode.generateNodesLevels(nodes)).true;
-        expect(Level.equalsTo(nodes[1].coords.level, 0)).true;
-        expect(Level.equalsTo(nodes[1].coords.level, 0)).true;
-        expect(Level.equalsTo(nodes[2].coords.level, [0, 1])).true;
-        expect(Level.equalsTo(nodes[3].coords.level, [0, 1])).true;
-        expect(Level.equalsTo(nodes[4].coords.level, 1)).true;
-        expect(Level.equalsTo(nodes[5].coords.level, 1)).true;
+        expect(Level.equals(nodes[1].coords.level, 0)).true;
+        expect(Level.equals(nodes[1].coords.level, 0)).true;
+        expect(Level.equals(nodes[2].coords.level, [0, 1])).true;
+        expect(Level.equals(nodes[3].coords.level, [0, 1])).true;
+        expect(Level.equals(nodes[4].coords.level, 1)).true;
+        expect(Level.equals(nodes[5].coords.level, 1)).true;
     });
 
 });

package/src/graph/MapMatching.js

@@ -102,11 +102,11 @@ class MapMatching {
             checkEdge = false;
         }
 
-        if (!Level.equalsTo(location.level, edge.node1.coords.level) && !(edge.node1.io && location.level === null)) {
+        if (!Level.equals(location.level, edge.node1.coords.level) && !(edge.node1.io && location.level === null)) {
             checkNode1 = false;
         }
 
-        if (!Level.equalsTo(location.level, edge.node2.coords.level) && !(edge.node2.io && location.level === null)) {
+        if (!Level.equals(location.level, edge.node2.coords.level) && !(edge.node2.io && location.level === null)) {
             checkNode2 = false;
         }
 

package/src/graph/MapMatching.spec.js

@@ -73,7 +73,7 @@ describe('MapMatching', () => {
         expect(result.nearestElement).instanceOf(GraphEdge);
         expect(result.nearestElement.builtFrom).equal('e0');
         expect(result.projection.distanceTo(expected)).to.below(Constants.EPS_MM);
-        expect(Level.equalsTo(expected.level, result.projection.level)).true;
+        expect(Level.equals(expected.level, result.projection.level)).true;
 
         const owNodes = [
             new GraphNode(new Coordinates(43.6091194, 3.884099, 5)),
@@ -98,7 +98,7 @@ describe('MapMatching', () => {
         expect(result.nearestElement).instanceOf(GraphEdge);
         expect(result.nearestElement.builtFrom).equal('e1');
         expect(result.projection.distanceTo(expected)).to.below(Constants.EPS_MM);
-        expect(Level.equalsTo(expected.level, result.projection.level)).true;
+        expect(Level.equals(expected.level, result.projection.level)).true;
     });
 
     it('with epsilon', () => {
@@ -141,7 +141,7 @@ describe('MapMatching - multilevels', () => {
         const result = mapMatching.getProjection(location).projection;
         const expected = new Coordinates(43.609176387963934, 3.884122673088027, null, 2);
         expect(result.distanceTo(expected)).to.below(Constants.EPS_MM);
-        expect(Level.equalsTo(expected.level, result.level)).true;
+        expect(Level.equals(expected.level, result.level)).true;
     });
 
     it('with bearing', () => {
@@ -150,7 +150,7 @@ describe('MapMatching - multilevels', () => {
         const result = mapMatching.getProjection(location, true, true).projection;
         const expected = new Coordinates(43.609188614172005, 3.8841275169229754, null, 2);
         expect(result.distanceTo(expected)).to.below(Constants.EPS_MM);
-        expect(Level.equalsTo(expected.level, result.level)).true;
+        expect(Level.equals(expected.level, result.level)).true;
     });
 
     it('matching node levels', () => {

package/src/graph/Network.js

@@ -35,7 +35,7 @@ class Network {
      * @returns {?GraphNode<T>}
      */
     getNodeByCoords(coords) {
-        return this.nodes.find(node => node.coords.equalsTo(coords));
+        return this.nodes.find(node => node.coords.equals(coords));
     }
 
     /**
@@ -162,7 +162,7 @@ class Network {
         const network = new Network();
 
         const getOrCreateNode = coords =>
-            network.nodes.find(_coords => _coords.equalsTo(coords)) || new GraphNode(coords);
+            network.nodes.find(_coords => _coords.equals(coords)) || new GraphNode(coords);
 
 
         const createEdgeFromNodes = (node1, node2) =>

package/src/graph/Network.spec.js

@@ -76,12 +76,12 @@ describe('Network', () => {
         const networkBis = Network.fromCompressedJson(networkJson);
 
         networkBis.nodes.forEach((node, i) => {
-            expect(node.coords.equalsTo(network.nodes[i].coords)).is.true;
+            expect(node.coords.equals(network.nodes[i].coords)).is.true;
         });
 
         networkBis.edges.forEach((edge, i) => {
-            expect(edge.node1.coords.equalsTo(network.edges[i].node1.coords)).is.true;
-            expect(edge.node2.coords.equalsTo(network.edges[i].node2.coords)).is.true;
+            expect(edge.node1.coords.equals(network.edges[i].node1.coords)).is.true;
+            expect(edge.node2.coords.equals(network.edges[i].node2.coords)).is.true;
             expect(edge.isOneway).equals(network.edges[i].isOneway);
         });
     });

package/src/rotations/AbsoluteHeading.js

@@ -101,7 +101,7 @@ class AbsoluteHeading {
      * @param {AbsoluteHeading} heading1 heading 1
      * @param {AbsoluteHeading} heading2 heading 2
      */
-    static equalsTo(heading1, heading2) {
+    static equals(heading1, heading2) {
 
         // Handle null comparison
         if (heading1 === null && heading1 === heading2) {
@@ -115,8 +115,8 @@ class AbsoluteHeading {
         return Math.abs(heading1.heading - heading2.heading) < 1e-8;
     }
 
-    equalsTo(other) {
-        return AbsoluteHeading.equalsTo(this, other);
+    equals(other) {
+        return AbsoluteHeading.equals(this, other);
     }
 
     toJson() {

package/src/rotations/AbsoluteHeading.spec.js

@@ -68,16 +68,16 @@ describe('AbsoluteHeading', () => {
     });
 
 
-    it('equalsTo', () => {
+    it('equals', () => {
 
-        expect(AbsoluteHeading.equalsTo(null, null)).true;
-        expect(AbsoluteHeading.equalsTo({}, new AbsoluteHeading(Math.PI))).false;
-        expect(AbsoluteHeading.equalsTo(new AbsoluteHeading(Math.PI), {})).false;
+        expect(AbsoluteHeading.equals(null, null)).true;
+        expect(AbsoluteHeading.equals({}, new AbsoluteHeading(Math.PI))).false;
+        expect(AbsoluteHeading.equals(new AbsoluteHeading(Math.PI), {})).false;
 
-        expect(AbsoluteHeading.equalsTo(new AbsoluteHeading(Math.PI), new AbsoluteHeading(Math.PI))).true;
-        expect(AbsoluteHeading.equalsTo(new AbsoluteHeading(0), new AbsoluteHeading(Math.PI))).false;
+        expect(AbsoluteHeading.equals(new AbsoluteHeading(Math.PI), new AbsoluteHeading(Math.PI))).true;
+        expect(AbsoluteHeading.equals(new AbsoluteHeading(0), new AbsoluteHeading(Math.PI))).false;
 
-        expect(new AbsoluteHeading(Math.PI).equalsTo(new AbsoluteHeading(Math.PI))).true;
+        expect(new AbsoluteHeading(Math.PI).equals(new AbsoluteHeading(Math.PI))).true;
     });
 
 
@@ -87,7 +87,7 @@ describe('AbsoluteHeading', () => {
 
         absoluteHeading = new AbsoluteHeading(Math.PI);
         expect(absoluteHeading.toJson()).deep.equals({ heading: Math.PI });
-        expect(absoluteHeading.equalsTo(AbsoluteHeading.fromJson(absoluteHeading.toJson()))).true;
+        expect(absoluteHeading.equals(AbsoluteHeading.fromJson(absoluteHeading.toJson()))).true;
 
         absoluteHeading = new AbsoluteHeading(Math.PI, 123456, Math.PI / 4);
         expect(absoluteHeading.toJson()).deep.equals({
@@ -95,14 +95,14 @@ describe('AbsoluteHeading', () => {
             time: 123456,
             accuracy: Math.PI / 4
         });
-        expect(absoluteHeading.equalsTo(AbsoluteHeading.fromJson(absoluteHeading.toJson()))).true;
+        expect(absoluteHeading.equals(AbsoluteHeading.fromJson(absoluteHeading.toJson()))).true;
     });
 
 
     it('toAttitude', () => {
-        expect(new AbsoluteHeading(0).toAttitude().equalsTo(new Attitude([1, 0, 0, 0]))).true;
-        expect(new AbsoluteHeading(Math.PI / 2).toAttitude().equalsTo(new Attitude([Math.SQRT1_2, 0, 0, -Math.SQRT1_2]))).true;
-        expect(new AbsoluteHeading(Math.PI).toAttitude().equalsTo(new Attitude([0, 0, 0, 1]))).true;
-        expect(new AbsoluteHeading(3 * Math.PI / 2).toAttitude().equalsTo(new Attitude([Math.SQRT1_2, 0, 0, Math.SQRT1_2]))).true;
+        expect(new AbsoluteHeading(0).toAttitude().equals(new Attitude([1, 0, 0, 0]))).true;
+        expect(new AbsoluteHeading(Math.PI / 2).toAttitude().equals(new Attitude([Math.SQRT1_2, 0, 0, -Math.SQRT1_2]))).true;
+        expect(new AbsoluteHeading(Math.PI).toAttitude().equals(new Attitude([0, 0, 0, 1]))).true;
+        expect(new AbsoluteHeading(3 * Math.PI / 2).toAttitude().equals(new Attitude([Math.SQRT1_2, 0, 0, Math.SQRT1_2]))).true;
     });
 });

package/src/rotations/Attitude.js

@@ -124,7 +124,7 @@ class Attitude {
      * @param {Attitude} att1 attitude 1
      * @param {Attitude} att2 attitude 2
      */
-    static equalsTo(att1, att2) {
+    static equals(att1, att2) {
 
         // Handle null comparison
         if (att1 === null && att1 === att2) {
@@ -140,15 +140,15 @@ class Attitude {
             return true;
         }
 
-        return Quaternion.equalsTo(att1.quaternion, att2.quaternion);
+        return Quaternion.equals(att1.quaternion, att2.quaternion);
     }
 
     /**
      * @param {Attitude} other
      * @returns {boolean}
      */
-    equalsTo(other) {
-        return Attitude.equalsTo(this, other);
+    equals(other) {
+        return Attitude.equals(this, other);
     }
 
     /**

package/src/rotations/Attitude.spec.js

@@ -131,7 +131,7 @@ describe('Attitude', () => {
 
         expect(clonedAttitude).not.equal(attitude);
         expect(clonedAttitude.quaternion).not.equal(attitude.quaternion);
-        expect(clonedAttitude.equalsTo(attitude));
+        expect(clonedAttitude.equals(attitude));
         expect(clonedAttitude.time).equal(attitude.time);
         expect(clonedAttitude.accuracy).equal(attitude.accuracy);
     });
@@ -204,14 +204,14 @@ describe('Attitude', () => {
 
     });
 
-    it('equalsTo', () => {
+    it('equals', () => {
 
-        expect(Attitude.equalsTo(null, null)).true;
-        expect(Attitude.equalsTo(new Attitude([-0.5, 0.5, 0.5, 0.5]), new Attitude([1, 0, 0, 0]))).false;
-        expect(Attitude.equalsTo([-0.5, 0.5, 0.5, 0.5], new Attitude([1, 0, 0, 0]))).false;
-        expect(Attitude.equalsTo(new Attitude([1, 0, 0, 0]), [-0.5, 0.5, 0.5, 0.5])).false;
-        expect(new Attitude([1, 0, 0, 0]).equalsTo(new Attitude([1, 0, 0, 0]))).true;
-        expect(new Attitude([-0.5, 0.5, 0.5, 0.5]).equalsTo(new Attitude([-0.5, 0.5, 0.5, 0.5]))).true;
+        expect(Attitude.equals(null, null)).true;
+        expect(Attitude.equals(new Attitude([-0.5, 0.5, 0.5, 0.5]), new Attitude([1, 0, 0, 0]))).false;
+        expect(Attitude.equals([-0.5, 0.5, 0.5, 0.5], new Attitude([1, 0, 0, 0]))).false;
+        expect(Attitude.equals(new Attitude([1, 0, 0, 0]), [-0.5, 0.5, 0.5, 0.5])).false;
+        expect(new Attitude([1, 0, 0, 0]).equals(new Attitude([1, 0, 0, 0]))).true;
+        expect(new Attitude([-0.5, 0.5, 0.5, 0.5]).equals(new Attitude([-0.5, 0.5, 0.5, 0.5]))).true;
 
     });
 
@@ -222,11 +222,11 @@ describe('Attitude', () => {
 
         attitude = new Attitude([1, 0, 0, 0]);
         expect(attitude.toJson()).deep.equals([1, 0, 0, 0]);
-        expect(attitude.equalsTo(Attitude.fromJson(attitude.toJson()))).true;
+        expect(attitude.equals(Attitude.fromJson(attitude.toJson()))).true;
 
         attitude = new Attitude([-0.5, 0.5, 0.5, 0.5]);
         expect(attitude.toJson()).deep.equals([-0.5, 0.5, 0.5, 0.5]);
-        expect(attitude.equalsTo(Attitude.fromJson(attitude.toJson()))).true;
+        expect(attitude.equals(Attitude.fromJson(attitude.toJson()))).true;
     });
 
 });