geometric-library 1.3.1 → 1.4.0

package/dist/cjs/figures/circle/Circle.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/figures/circle/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Circle"), exports);
+__exportStar(require("./Circle.types"), exports);

package/dist/cjs/figures/{CubicBezierCurve.js → cubic-bezier-curve/CubicBezierCurve.js}

@@ -1,10 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CubicBezierCurve = void 0;
-const Calculator_1 = require("../utilities/Calculator");
-const Point_1 = require("../abstracts/Point");
-const Figure_1 = require("../abstracts/Figure");
-class CubicBezierCurve extends Figure_1.Figure {
+const _abstracts_1 = require("../../abstracts");
+const calculator_1 = require("../../utilities/calculator");
+class CubicBezierCurve extends _abstracts_1.Figure {
     _criticalPoints;
     constructor(values) {
         super(values);
@@ -13,7 +12,7 @@ class CubicBezierCurve extends Figure_1.Figure {
     get boundingBox() {
         const [P0, , , P3] = this.values;
         const points = [P0, P3, ...this._criticalPoints];
-        return Figure_1.Figure.computeBoundingBox(points);
+        return _abstracts_1.Figure.computeBoundingBox(points);
     }
     get criticalPoints() {
         return this._criticalPoints;
@@ -61,6 +60,11 @@ class CubicBezierCurve extends Figure_1.Figure {
         this.recompute();
         return this;
     }
+    scaleXY(factorX, factorY, about) {
+        super.scaleXY(factorX, factorY, about);
+        this.recompute();
+        return this;
+    }
     translate(vector) {
         super.translate(vector);
         this.recompute();
@@ -73,7 +77,8 @@ class CubicBezierCurve extends Figure_1.Figure {
         }
         const criticalPoints = tValues.reduce((criticalPoints, t) => {
             const criticalPoint = this.getPointAtParameter(t);
-            criticalPoint && criticalPoints.push(criticalPoint);
+            if (criticalPoint)
+                criticalPoints.push(criticalPoint);
             return criticalPoints;
         }, []);
         return criticalPoints;
@@ -85,17 +90,17 @@ class CubicBezierCurve extends Figure_1.Figure {
         const tValues = [];
         for (let i = 0; i < axii.length; i++) {
             const axis = axii[i];
-            const p0 = new Calculator_1.Calculator(P0[axis]);
-            const p1 = new Calculator_1.Calculator(P1[axis]);
-            const p2 = new Calculator_1.Calculator(P2[axis]);
-            const p3 = new Calculator_1.Calculator(P3[axis]);
+            const p0 = new calculator_1.Calculator(P0[axis]);
+            const p1 = new calculator_1.Calculator(P1[axis]);
+            const p2 = new calculator_1.Calculator(P2[axis]);
+            const p3 = new calculator_1.Calculator(P3[axis]);
             const a = p3.sub(p2.mul(3)).add(p1.mul(3)).sub(p0).mul(3);
             const b = p2.sub(p1.mul(2)).add(p0).mul(6);
             const c = p1.sub(p0).mul(3);
             for (let n = 0; n < signs.length; n++) {
                 const sign = signs[n];
                 let tValue;
-                if (+a === 0) {
+                if (calculator_1.Calculator.isNearZero(+a)) {
                     // 1st degree equation to avoid n/0
                     tValue = c.neg().div(b);
                 }
@@ -103,7 +108,7 @@ class CubicBezierCurve extends Figure_1.Figure {
                     // 2nd degree equation
                     tValue = b
                         .neg()
-                        .add(Calculator_1.Calculator.mul(sign, b.pow(2).sub(a.mul(c).mul(4)).sqrt()))
+                        .add(calculator_1.Calculator.mul(sign, b.pow(2).sub(a.mul(c).mul(4)).sqrt()))
                         .div(a.mul(2));
                 }
                 if (this.isValidParameter(tValue)) {
@@ -114,7 +119,7 @@ class CubicBezierCurve extends Figure_1.Figure {
         if (!tValues.length) {
             return;
         }
-        return tValues.filter((value, index, array) => index === array.findIndex((v) => +value === +v));
+        return tValues.filter((value, index, array) => index === array.findIndex((v) => calculator_1.Calculator.isEqual(+value, +v)));
     }
     getCoordinateAtParameter(t, axis) {
         const { P0, P1, P2, P3 } = this;
@@ -123,11 +128,11 @@ class CubicBezierCurve extends Figure_1.Figure {
         const p2 = P2[axis];
         const p3 = P3[axis];
         // parametric cubic bezier equation
-        const coordinate = Calculator_1.Calculator.sub(1, t)
+        const coordinate = calculator_1.Calculator.sub(1, t)
             .pow(3)
             .mul(p0)
-            .add(Calculator_1.Calculator.sub(1, t).pow(2).mul(3).mul(t).mul(p1))
-            .add(Calculator_1.Calculator.sub(1, t).mul(3).mul(t.pow(2)).mul(p2))
+            .add(calculator_1.Calculator.sub(1, t).pow(2).mul(3).mul(t).mul(p1))
+            .add(calculator_1.Calculator.sub(1, t).mul(3).mul(t.pow(2)).mul(p2))
             .add(t.pow(3).mul(p3));
         if (!coordinate.isFinite()) {
             return;
@@ -140,7 +145,7 @@ class CubicBezierCurve extends Figure_1.Figure {
         if (typeof x === 'undefined' || typeof y === 'undefined') {
             return;
         }
-        return new Point_1.Point([+x, +y]);
+        return new _abstracts_1.Point([+x, +y]);
     }
     isValidParameter(t) {
         return t.isFinite() && +t > 0 && +t < 1;

package/dist/cjs/figures/cubic-bezier-curve/CubicBezierCurve.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/figures/cubic-bezier-curve/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./CubicBezierCurve"), exports);
+__exportStar(require("./CubicBezierCurve.types"), exports);

package/dist/cjs/figures/ellipse/Ellipse.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Ellipse = void 0;
+const _abstracts_1 = require("../../abstracts");
+const CubicBezierCurve_1 = require("../cubic-bezier-curve/CubicBezierCurve");
+const calculator_1 = require("../../utilities/calculator");
+const Line_1 = require("../line/Line");
+const KAPPA = 0.5522847498307936;
+const xAxis = new Line_1.Line([new _abstracts_1.Point([0, 0]), new _abstracts_1.Point([1, 0])]);
+const unitCircleCubicBezierCurves = [
+    new CubicBezierCurve_1.CubicBezierCurve([new _abstracts_1.Point([1, 0]), new _abstracts_1.Point([1, KAPPA]), new _abstracts_1.Point([KAPPA, 1]), new _abstracts_1.Point([0, 1])]),
+    new CubicBezierCurve_1.CubicBezierCurve([new _abstracts_1.Point([0, 1]), new _abstracts_1.Point([-KAPPA, 1]), new _abstracts_1.Point([-1, KAPPA]), new _abstracts_1.Point([-1, 0])]),
+    new CubicBezierCurve_1.CubicBezierCurve([new _abstracts_1.Point([-1, 0]), new _abstracts_1.Point([-1, -KAPPA]), new _abstracts_1.Point([-KAPPA, -1]), new _abstracts_1.Point([0, -1])]),
+    new CubicBezierCurve_1.CubicBezierCurve([new _abstracts_1.Point([0, -1]), new _abstracts_1.Point([KAPPA, -1]), new _abstracts_1.Point([1, -KAPPA]), new _abstracts_1.Point([1, 0])])
+];
+class Ellipse extends _abstracts_1.Figure {
+    _center;
+    _criticalPoints;
+    _phi;
+    _rx;
+    _ry;
+    constructor(values) {
+        super(values);
+        const [center, rx, ry, phi] = values;
+        this._center = center;
+        this._rx = rx;
+        this._ry = ry;
+        this._phi = phi;
+        this._criticalPoints = this.computeCriticalPoints({ center, rx, ry, phi });
+    }
+    get boundingBox() {
+        return _abstracts_1.Figure.computeBoundingBox(this.criticalPoints);
+    }
+    get center() {
+        return this._center;
+    }
+    get criticalPoints() {
+        return this._criticalPoints;
+    }
+    get isCircle() {
+        return calculator_1.Calculator.isEqual(+this.rx, +this.ry);
+    }
+    get phi() {
+        return this._phi;
+    }
+    get rx() {
+        return this._rx;
+    }
+    get ry() {
+        return this._ry;
+    }
+    clone() {
+        const values = this.values.map((value) => value.clone());
+        return new Ellipse(values);
+    }
+    computePointForTheta(theta, ellipse = this) {
+        const { center, rx, ry, phi } = ellipse;
+        const x = +calculator_1.Calculator.mul(+rx, phi.cos).mul(theta.cos).sub(calculator_1.Calculator.mul(+ry, phi.sin).mul(theta.sin)).add(center.x);
+        const y = +calculator_1.Calculator.mul(+rx, phi.sin).mul(theta.cos).add(calculator_1.Calculator.mul(+ry, phi.cos).mul(theta.sin)).add(center.y);
+        return new _abstracts_1.Point([x, y]);
+    }
+    computeThetaForPoint({ x, y }) {
+        const { center, phi, rx, ry } = this;
+        const { x: cx, y: cy } = center;
+        const dy = calculator_1.Calculator.sub(y, cy);
+        const dx = calculator_1.Calculator.sub(x, cx);
+        const sinTheta = dy.mul(phi.cos).sub(dx.mul(phi.sin)).div(+ry);
+        const cosTheta = dx.mul(phi.cos).add(dy.mul(phi.sin)).div(+rx);
+        const theta = new _abstracts_1.Angle(+calculator_1.Calculator.atan2(sinTheta, cosTheta), 'radians').normalize();
+        return theta;
+    }
+    reflect(about) {
+        super.reflect(about);
+        if (!this.isCircle && 'V' in about) {
+            const alpha = about.angleTo(xAxis);
+            this._phi.replace(+calculator_1.Calculator.mul(2, alpha.radians).sub(this.phi.radians), 'radians');
+            this._phi.normalize();
+        }
+        this.recompute();
+        return this;
+    }
+    rotate(alpha, about) {
+        this._center.rotate(alpha, about);
+        if (!this.isCircle) {
+            this._phi.replace(+calculator_1.Calculator.add(this.phi.radians, alpha.radians), 'radians');
+            this._phi.normalize();
+        }
+        this.recompute();
+        return this;
+    }
+    scale(factor, about = new _abstracts_1.Point([0, 0])) {
+        super.scale(factor, about);
+        this.recompute();
+        return this;
+    }
+    toCubicBezierCurves() {
+        const { rx, ry, phi, center } = this;
+        const curves = unitCircleCubicBezierCurves.map((curve) => {
+            return curve
+                .clone()
+                .scaleXY(+rx, +ry)
+                .rotate(phi)
+                .translate(new _abstracts_1.Vector([center.x, center.y]));
+        });
+        return curves;
+    }
+    translate(vector) {
+        this._center.translate(vector);
+        this.recompute();
+        return this;
+    }
+    computeCriticalPoints(ellipse = this) {
+        const { rx, ry, phi } = ellipse;
+        const { computePointForTheta } = this;
+        const xThetaPrincipal = new _abstracts_1.Angle(+calculator_1.Calculator.neg(+ry).mul(phi.tan).div(+rx).atan(), 'radians');
+        const yThetaPrincipal = new _abstracts_1.Angle(+calculator_1.Calculator.mul(+ry, phi.cot).div(+rx).atan(), 'radians');
+        const xThetaSecondary = new _abstracts_1.Angle(+calculator_1.Calculator.add(+xThetaPrincipal, Math.PI), 'radians');
+        const yThetaSecondary = new _abstracts_1.Angle(+calculator_1.Calculator.add(+yThetaPrincipal, Math.PI), 'radians');
+        const firstPoint = computePointForTheta(xThetaPrincipal, ellipse);
+        const secondPoint = computePointForTheta(yThetaPrincipal, ellipse);
+        const thirdPoint = computePointForTheta(xThetaSecondary, ellipse);
+        const fourthPoint = computePointForTheta(yThetaSecondary, ellipse);
+        return [firstPoint, secondPoint, thirdPoint, fourthPoint];
+    }
+    recompute() {
+        this._criticalPoints = this.computeCriticalPoints();
+    }
+}
+exports.Ellipse = Ellipse;

package/dist/cjs/figures/ellipse/Ellipse.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/figures/ellipse/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Ellipse"), exports);
+__exportStar(require("./Ellipse.types"), exports);

package/dist/cjs/figures/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./arc-curve"), exports);
+__exportStar(require("./circle"), exports);
+__exportStar(require("./cubic-bezier-curve"), exports);
+__exportStar(require("./ellipse"), exports);
+__exportStar(require("./line"), exports);
+__exportStar(require("./polygon"), exports);
+__exportStar(require("./quadratic-bezier-curve"), exports);

package/dist/cjs/figures/{Line.js → line/Line.js}

@@ -1,15 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Line = void 0;
-const Calculator_1 = require("../utilities/Calculator");
-const Angle_1 = require("../abstracts/Angle");
-const Point_1 = require("../abstracts/Point");
-const Vector_1 = require("../abstracts/Vector");
-const Figure_1 = require("../abstracts/Figure");
-class Line extends Figure_1.Figure {
+const _abstracts_1 = require("../../abstracts");
+const calculator_1 = require("../../utilities/calculator");
+class Line extends _abstracts_1.Figure {
     _P0;
     _P1;
     _V;
+    _dirty = true;
     _reciprocal;
     _slope;
     _xIntercept;
@@ -17,20 +15,16 @@ class Line extends Figure_1.Figure {
     constructor(values) {
         super(values);
         const [P0, anchor] = values;
-        if (anchor instanceof Vector_1.Vector) {
+        if (anchor instanceof _abstracts_1.Vector) {
             this._V = anchor;
             this._P1 = P0.clone().translate(anchor);
             // anchor instanceof Point
         }
         else {
-            this._V = new Vector_1.Vector([P0, anchor]);
+            this._V = new _abstracts_1.Vector([P0, anchor]);
             this._P1 = anchor;
         }
         this._P0 = P0;
-        this._slope = this.computeSlope();
-        this._yIntercept = this.computeYIntercept();
-        this._reciprocal = this.computeReciprocal();
-        this._xIntercept = this.computeXIntercept();
         this.points = [this.P0, this.P1];
         this.vectors = [this.V];
     }
@@ -83,33 +77,41 @@ class Line extends Figure_1.Figure {
         return typeof slope === 'undefined';
     }
     get reciprocal() {
+        this.ensureComputed();
         return this._reciprocal;
     }
     get slope() {
+        this.ensureComputed();
         return this._slope;
     }
     get xIntercept() {
+        this.ensureComputed();
         return this._xIntercept;
     }
     get yIntercept() {
+        this.ensureComputed();
         return this._yIntercept;
     }
-    angleTo(line) {
-        if (this.isParallelTo(line)) {
-            return new Angle_1.Angle(0, 'radians');
-        }
-        if (this.isPerpendicularTo(line)) {
-            return new Angle_1.Angle(+Calculator_1.Calculator.div(Math.PI, 2), 'radians');
-        }
-        if (typeof this.slope === 'undefined') {
-            return new Angle_1.Angle(+Calculator_1.Calculator.atan(line.slope), 'radians');
-        }
-        if (typeof line.slope === 'undefined') {
-            return new Angle_1.Angle(+Calculator_1.Calculator.atan(this.slope), 'radians');
-        }
-        const thisSlope = new Calculator_1.Calculator(this.slope);
-        const lineSlope = new Calculator_1.Calculator(line.slope);
-        return new Angle_1.Angle(+lineSlope.sub(thisSlope).div(thisSlope.mul(lineSlope).add(1)).abs().atan(), 'radians');
+    angleTo(reference) {
+        if ('slope' in reference) {
+            const line = reference;
+            if (this.isParallelTo(line)) {
+                return new _abstracts_1.Angle(0, 'radians');
+            }
+            if (this.isPerpendicularTo(line)) {
+                return new _abstracts_1.Angle(+calculator_1.Calculator.div(Math.PI, 2), 'radians');
+            }
+            if (typeof this.slope === 'undefined') {
+                return new _abstracts_1.Angle(+calculator_1.Calculator.atan(line.slope), 'radians');
+            }
+            if (typeof line.slope === 'undefined') {
+                return new _abstracts_1.Angle(+calculator_1.Calculator.atan(this.slope), 'radians');
+            }
+            const thisSlope = new calculator_1.Calculator(this.slope);
+            const lineSlope = new calculator_1.Calculator(line.slope);
+            return new _abstracts_1.Angle(+lineSlope.sub(thisSlope).div(thisSlope.mul(lineSlope).add(1)).abs().atan(), 'radians');
+        }
+        return this.V.angleTo(reference);
     }
     clone() {
         const values = this.values.map((value) => value.clone());
@@ -119,10 +121,10 @@ class Line extends Figure_1.Figure {
         if (this.isParallelTo(line)) {
             return;
         }
-        const denominator = Calculator_1.Calculator.mul(this.a, line.b).sub(Calculator_1.Calculator.mul(line.a, this.b));
-        const x = +Calculator_1.Calculator.mul(this.b, line.c).sub(Calculator_1.Calculator.mul(line.b, this.c)).div(denominator);
-        const y = +Calculator_1.Calculator.mul(this.c, line.a).sub(Calculator_1.Calculator.mul(line.c, this.a)).div(denominator);
-        return new Point_1.Point([x, y]);
+        const denominator = calculator_1.Calculator.mul(this.a, line.b).sub(calculator_1.Calculator.mul(line.a, this.b));
+        const x = +calculator_1.Calculator.mul(this.b, line.c).sub(calculator_1.Calculator.mul(line.b, this.c)).div(denominator);
+        const y = +calculator_1.Calculator.mul(this.c, line.a).sub(calculator_1.Calculator.mul(line.c, this.a)).div(denominator);
+        return new _abstracts_1.Point([x, y]);
     }
     getPerpendicularProjection(point) {
         const { P0, slope, isVertical, isHorizontal } = this;
@@ -131,30 +133,32 @@ class Line extends Figure_1.Figure {
             return point.clone();
         }
         if (isVertical) {
-            perpendicularProjection = new Point_1.Point([P0.x, point.y]);
+            perpendicularProjection = new _abstracts_1.Point([P0.x, point.y]);
         }
         else if (isHorizontal) {
-            perpendicularProjection = new Point_1.Point([point.x, P0.y]);
+            perpendicularProjection = new _abstracts_1.Point([point.x, P0.y]);
         }
         else {
-            const x = new Calculator_1.Calculator(1);
-            const y = x.mul(1).div(slope).neg().add(Calculator_1.Calculator.div(point.x, slope)).add(point.y);
-            perpendicularProjection = new Point_1.Point([+x, +y]);
+            const perpendicularSlope = +calculator_1.Calculator.div(-1, slope);
+            const perpendicularYIntercept = +calculator_1.Calculator.sub(point.y, calculator_1.Calculator.mul(perpendicularSlope, point.x));
+            const x = +calculator_1.Calculator.sub(perpendicularYIntercept, this.yIntercept).div(calculator_1.Calculator.sub(slope, perpendicularSlope));
+            const y = +calculator_1.Calculator.mul(slope, x).add(this.yIntercept);
+            perpendicularProjection = new _abstracts_1.Point([x, y]);
         }
         return perpendicularProjection;
     }
     getPerpendicularThrough(point) {
         if (this.hasPoint(point)) {
-            const phi = new Angle_1.Angle(+Calculator_1.Calculator.div(Math.PI, 2), 'radians');
+            const phi = new _abstracts_1.Angle(+calculator_1.Calculator.div(Math.PI, 2), 'radians');
             return this.clone().rotate(phi, point);
         }
         return new Line([point, this.getPerpendicularProjection(point)]);
     }
     getPointAtParameter(t) {
         const { P0, V } = this;
-        const x = +Calculator_1.Calculator.add(P0.x, Calculator_1.Calculator.mul(V.dx, t));
-        const y = +Calculator_1.Calculator.add(P0.y, Calculator_1.Calculator.mul(V.dy, t));
-        return new Point_1.Point([x, y]);
+        const x = +calculator_1.Calculator.add(P0.x, calculator_1.Calculator.mul(V.dx, t));
+        const y = +calculator_1.Calculator.add(P0.y, calculator_1.Calculator.mul(V.dy, t));
+        return new _abstracts_1.Point([x, y]);
     }
     getXValueAtY(y) {
         const { reciprocal, xIntercept } = this;
@@ -162,9 +166,9 @@ class Line extends Figure_1.Figure {
             return;
         }
         if (typeof xIntercept === 'undefined') {
-            return +Calculator_1.Calculator.mul(reciprocal, y);
+            return +calculator_1.Calculator.mul(reciprocal, y);
         }
-        return +Calculator_1.Calculator.mul(reciprocal, y).add(xIntercept);
+        return +calculator_1.Calculator.mul(reciprocal, y).add(xIntercept);
     }
     getYValueAtX(x) {
         const { slope, yIntercept } = this;
@@ -172,16 +176,22 @@ class Line extends Figure_1.Figure {
             return;
         }
         if (typeof yIntercept === 'undefined') {
-            return +Calculator_1.Calculator.mul(slope, x);
+            return +calculator_1.Calculator.mul(slope, x);
         }
-        return +Calculator_1.Calculator.mul(slope, x).add(yIntercept);
+        return +calculator_1.Calculator.mul(slope, x).add(yIntercept);
     }
     hasPoint(P) {
+        if (this.isVertical) {
+            return calculator_1.Calculator.isEqual(P.x, this.P0.x);
+        }
         const potentialY = this.getYValueAtX(P.x);
-        return typeof potentialY === 'number' && potentialY === P.y;
+        return typeof potentialY === 'number' && calculator_1.Calculator.isEqual(potentialY, P.y);
     }
     isParallelTo(line) {
-        return this.slope == line.slope;
+        if (typeof this.slope === 'undefined' || typeof line.slope === 'undefined') {
+            return typeof this.slope === typeof line.slope;
+        }
+        return calculator_1.Calculator.isEqual(this.slope, line.slope);
     }
     isPerpendicularTo(line) {
         if (this.isVertical) {
@@ -190,46 +200,51 @@ class Line extends Figure_1.Figure {
         if (this.isHorizontal) {
             return line.isVertical;
         }
+        /* v8 ignore next 3 */
         if (line.isVertical) {
             return this.isHorizontal;
         }
+        /* v8 ignore next 3 */
         if (line.isHorizontal) {
             return this.isVertical;
         }
-        const thisSlope = new Calculator_1.Calculator(this.slope);
-        const lineSlope = new Calculator_1.Calculator(line.slope);
-        return +thisSlope === +Calculator_1.Calculator.div(-1, lineSlope);
+        return calculator_1.Calculator.isEqual(this.slope, +calculator_1.Calculator.div(-1, line.slope));
     }
     reflect(about) {
         super.reflect(about);
-        this.recompute();
+        this._dirty = true;
         return this;
     }
     rotate(phi, about) {
         super.rotate(phi, about);
-        this.recompute();
+        this._dirty = true;
         return this;
     }
     scale(factor, about) {
         super.scale(factor, about);
-        this.recompute();
+        this._dirty = true;
+        return this;
+    }
+    scaleXY(factorX, factorY, about) {
+        super.scaleXY(factorX, factorY, about);
+        this._dirty = true;
         return this;
     }
     translate(vector) {
         super.translate(vector);
-        this.recompute();
+        this._dirty = true;
         return this;
     }
     computeReciprocal() {
         const { P0, P1 } = this;
-        const reciprocal = Calculator_1.Calculator.sub(P1.x, P0.x).div(Calculator_1.Calculator.sub(P1.y, P0.y));
+        const reciprocal = calculator_1.Calculator.sub(P1.x, P0.x).div(calculator_1.Calculator.sub(P1.y, P0.y));
         if (reciprocal.isFinite()) {
             return +reciprocal;
         }
     }
     computeSlope() {
         const { P0, P1 } = this;
-        const slope = Calculator_1.Calculator.sub(P1.y, P0.y).div(Calculator_1.Calculator.sub(P1.x, P0.x));
+        const slope = calculator_1.Calculator.sub(P1.y, P0.y).div(calculator_1.Calculator.sub(P1.x, P0.x));
         if (slope.isFinite()) {
             return +slope;
         }
@@ -242,7 +257,7 @@ class Line extends Figure_1.Figure {
         if (isHorizontal) {
             return;
         }
-        return +Calculator_1.Calculator.sub(P0.x, Calculator_1.Calculator.mul(reciprocal, P0.y));
+        return +calculator_1.Calculator.sub(P0.x, calculator_1.Calculator.mul(reciprocal, P0.y));
     }
     computeYIntercept() {
         const { P0, slope, isVertical, isHorizontal } = this;
@@ -252,9 +267,13 @@ class Line extends Figure_1.Figure {
         if (isHorizontal) {
             return P0.y;
         }
-        return +Calculator_1.Calculator.sub(P0.y, Calculator_1.Calculator.mul(slope, P0.x));
+        return +calculator_1.Calculator.sub(P0.y, calculator_1.Calculator.mul(slope, P0.x));
     }
-    recompute() {
+    ensureComputed() {
+        if (!this._dirty) {
+            return;
+        }
+        this._dirty = false;
         this._slope = this.computeSlope();
         this._yIntercept = this.computeYIntercept();
         this._reciprocal = this.computeReciprocal();

package/dist/cjs/figures/line/Line.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/figures/line/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Line"), exports);
+__exportStar(require("./Line.types"), exports);