geometric-library 1.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Dante Darie
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,61 @@
+# geometric-library
+
+A Node based, visually agnostic implementation of geometric functions, both abstract and finite.
+
+## Prerequisites
+
+This library assumes you already have basic knowledge of concepts pertaining to algebra and geometry, including:
+
+- **Abstracts**: magnitude, direction, position, coordinate, vector, point, figure, angle
+- **Figures**: line, curve, ellipse, polygon
+- **Transformations**: rotation, translation, reflection, scaling
+- **Units**: radian, degree
+
+## Usage
+
+You may install this library into your JavaScript or TypeScript project using the following command:
+
+```sh
+npm install geometric-library
+```
+
+You may then `import` any of the classes listed in the **API** section and use them at your own discretion.
+
+If you're using TypeScript for your project you can also `import` types and interfaces for all the exported functionalities, which is very much recommended as it will make your life easier in terms of understading how everything works.
+
+## API
+
+The types and interfaces exported from [./src/types/index.ts](./src/types/index.ts) should give you a pretty good idea of how to use any of the functionalities included in this library.
+
+The following classes are available:
+
+(Abstracts) `Flag` `Magnitude` `Angle` `Vector` `Point` `Figure`
+
+(Figures) `Line` `Polygon` `QuadraticBezierCurve` `CubicBezierCurve` `ArcCurve` `Ellipse` `Circle`
+
+## Dependencies
+
+JavaScript is bad at math. Don't hate me for saying it, it's actually a pretty well known fact that JavaScript just struggles with algebra, especially when it involves floating point numbers. Here's one of the many articles about it if you want to learn more: [Why JavaScript is Bad At Math](https://javascript.plainenglish.io/why-javascript-is-bad-at-math-9b8247640caa) (by Alexandra Langton).
+
+Though there are ways to combat these issues natively, for this library I chose to use an abstraction of [Decimal.js](https://mikemcl.github.io/decimal.js/), which does just that pretty efficiently.
+
+As it is an intrinsic dependency so you don't have to install anything yourself.
+
+## Contributing
+
+This project is open to contribution.
+
+If you have a bug to report please open an issue so it can be tracked and addressed as soon as possible. Do include information about how to reproduce the bug, the expected result and the actual result.
+
+If there's a missing feature feel free to open an issue as well detailing the feature request and its value to the project and its users.
+
+If you already have an idea of how to fix an issue or implement a feature, please also feel free to directly contribute by opening a pull request with the changes. Though the project includes some automated scripts for linting, cleaning, building, testing and deploying the code, please do try to adhere to the existing standards in terms of naming, directory structure and SOLID principles.
+
+## TO DO
+
+- Add a complete documentation of all the functionalities made available.
+- Add examples.
+
+## License
+
+This project is published and distributed under the [MIT License](./LICENSE).

package/dist/cjs/abstracts/Angle.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Angle = void 0;
+const Calculator_1 = require("../utilities/Calculator");
+const PI2 = +Calculator_1.Calculator.mul(Math.PI, 2);
+class Angle {
+    _radians;
+    constructor(value, unit) {
+        this._radians = unit === 'radians' ? value : Angle.toRadians(value);
+    }
+    get cos() {
+        return +Calculator_1.Calculator.cos(this.radians);
+    }
+    get cot() {
+        return +Calculator_1.Calculator.div(1, this.tan);
+    }
+    get degrees() {
+        return Angle.toDegrees(this.radians);
+    }
+    get radians() {
+        return this._radians;
+    }
+    get sin() {
+        return +Calculator_1.Calculator.sin(this.radians);
+    }
+    get tan() {
+        return +Calculator_1.Calculator.tan(this.radians);
+    }
+    static toDegrees(radians) {
+        return +Calculator_1.Calculator.mul(radians, 180).div(Math.PI);
+    }
+    static toRadians(degrees) {
+        return +Calculator_1.Calculator.mul(degrees, Math.PI).div(180);
+    }
+    clone() {
+        return new Angle(this.radians, 'radians');
+    }
+    normalize() {
+        const { radians } = this;
+        if (radians < 0) {
+            this._radians = +Calculator_1.Calculator.add(radians, PI2);
+        }
+        else if (radians > 0) {
+            this._radians = +Calculator_1.Calculator.mod(radians, PI2);
+        }
+        return this;
+    }
+    replace(value, unit) {
+        this._radians = unit === 'radians' ? value : Angle.toRadians(value);
+        return this;
+    }
+    scale(factor) {
+        this._radians = +Calculator_1.Calculator.mul(this.radians, factor);
+        return this;
+    }
+    valueOf() {
+        return this.radians;
+    }
+}
+exports.Angle = Angle;

package/dist/cjs/abstracts/Figure.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Figure = void 0;
+const Calculator_1 = require("../utilities/Calculator");
+const Magnitude_1 = require("./Magnitude");
+const Point_1 = require("./Point");
+const Vector_1 = require("./Vector");
+class Figure {
+    angles = [];
+    isRelative = false;
+    magnitudes = [];
+    points = [];
+    vectors = [];
+    _values;
+    constructor(values) {
+        this.values = this._values = values;
+    }
+    get boundingBox() {
+        const { points } = this;
+        return Figure.computeBoundingBox(points);
+    }
+    get values() {
+        return this._values;
+    }
+    /**
+     * @todo Figure out a better way to type narrow than iterating again.
+     */
+    set values(values) {
+        this._values = values;
+        const [points, vectors, magnitudes, angles] = values.reduce((result, value) => {
+            if (value instanceof Point_1.Point) {
+                result[0].push(value);
+            }
+            if (value instanceof Vector_1.Vector) {
+                result[1].push(value);
+            }
+            if (value instanceof Magnitude_1.Magnitude) {
+                result[2].push(value);
+            }
+            if (typeof value === 'object' && 'radians' in value) {
+                result[3].push(value);
+            }
+            return result;
+        }, [[], [], [], []]);
+        this.magnitudes = magnitudes;
+        this.points = points;
+        this.vectors = vectors;
+        this.angles = angles;
+        this.isRelative = !!vectors.length;
+    }
+    static computeBoundingBox(points) {
+        if (!points) {
+            throw new Error(this.getNoPointsErrorMessage('boundingBox', true));
+        }
+        const [xValues, yValues] = points.reduce((values, point) => {
+            values[0].push(point.x);
+            values[1].push(point.y);
+            return values;
+        }, [[], []]);
+        const xMax = +Calculator_1.Calculator.max(xValues);
+        const xMin = +Calculator_1.Calculator.min(xValues);
+        const yMax = +Calculator_1.Calculator.max(yValues);
+        const yMin = +Calculator_1.Calculator.min(yValues);
+        return { xMax, xMin, yMax, yMin };
+    }
+    static getNoPointsErrorMessage(name, property = false) {
+        return `Attempting to ${property ? 'get' : 'call'} ${name} of Figure with no points assigned. Assign 'this.points' from the child class and try again.`;
+    }
+    reflect(about) {
+        const { points, vectors } = this;
+        if (!points) {
+            throw new Error(Figure.getNoPointsErrorMessage('reflect'));
+        }
+        if ('getPerpendicularProjection' in about) {
+            points.forEach((point) => {
+                const perpendicularRoot = about.getPerpendicularProjection(point);
+                point.reflect(perpendicularRoot);
+            });
+            vectors.forEach((vector) => {
+                vector.reflect({
+                    x: !about.isHorizontal,
+                    y: !about.isVertical
+                });
+            });
+            return this;
+        }
+        points.forEach((point) => {
+            point.reflect(about);
+        });
+        vectors.forEach((vector) => {
+            vector.reflect({
+                x: true,
+                y: true
+            });
+        });
+        return this;
+    }
+    rotate(phi, about) {
+        const { points, vectors, angles } = this;
+        if (!points) {
+            throw new Error(Figure.getNoPointsErrorMessage('rotate'));
+        }
+        points.forEach((point) => {
+            point.rotate(phi, about);
+        });
+        vectors.forEach((vector) => {
+            const referencePoint = points[0].clone().rotate(phi, about);
+            const positionalPoint = points[0].clone().translate(vector).rotate(phi, about);
+            const rotatedVector = new Vector_1.Vector([referencePoint, positionalPoint]);
+            vector.replace(rotatedVector);
+        });
+        angles.forEach((angle) => {
+            angle.replace(+Calculator_1.Calculator.add(+angle, +phi), 'radians').normalize();
+        });
+        return this;
+    }
+    scale(factor, about = new Point_1.Point([0, 0])) {
+        const { points, vectors, magnitudes } = this;
+        if (!points) {
+            throw new Error(Figure.getNoPointsErrorMessage('scale'));
+        }
+        points.forEach((point) => {
+            const positionalVector = new Vector_1.Vector([about, point]);
+            const scaledPositionalVector = positionalVector.clone().scale(factor);
+            const scaledPoint = about.clone().translate(scaledPositionalVector);
+            point.replace(scaledPoint);
+        });
+        vectors.forEach((vector) => {
+            vector.scale(factor);
+        });
+        magnitudes.forEach((magnitude) => {
+            magnitude.scale(factor);
+        });
+        return this;
+    }
+    translate(vector) {
+        const { points } = this;
+        if (!points) {
+            throw new Error(Figure.getNoPointsErrorMessage('translate'));
+        }
+        points.forEach((point) => {
+            point.translate(vector);
+        });
+        return this;
+    }
+}
+exports.Figure = Figure;

package/dist/cjs/abstracts/Flag.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Flag = void 0;
+class Flag {
+    _value;
+    constructor(value) {
+        this._value = value;
+    }
+    get value() {
+        return this._value;
+    }
+    clone() {
+        return new Flag(this._value);
+    }
+    invert() {
+        this._value = !this._value;
+        return this;
+    }
+    replace(value) {
+        this._value = value;
+        return this;
+    }
+    valueOf() {
+        return +this._value;
+    }
+}
+exports.Flag = Flag;

package/dist/cjs/abstracts/Magnitude.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Magnitude = void 0;
+const Calculator_1 = require("../utilities/Calculator");
+class Magnitude {
+    _value;
+    constructor(value) {
+        this._value = value;
+    }
+    clone() {
+        return new Magnitude(+this);
+    }
+    replace(value) {
+        this._value = value;
+        return this;
+    }
+    scale(factor) {
+        this._value = +Calculator_1.Calculator.mul(+this, factor);
+        return this;
+    }
+    valueOf() {
+        return this._value;
+    }
+}
+exports.Magnitude = Magnitude;

package/dist/cjs/abstracts/Point.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Point = void 0;
+const Calculator_1 = require("../utilities/Calculator");
+class Point {
+    _x;
+    _y;
+    constructor([x, y]) {
+        this._x = x;
+        this._y = y;
+    }
+    get values() {
+        return [this.x, this.y];
+    }
+    get x() {
+        return +this._x;
+    }
+    get y() {
+        return +this._y;
+    }
+    clone() {
+        const { x, y } = this;
+        return new Point([x, y]);
+    }
+    reflect(about) {
+        const { x, y } = this;
+        this._x = +Calculator_1.Calculator.sub(about.x, x).mul(2).add(x);
+        this._y = +Calculator_1.Calculator.sub(about.y, y).mul(2).add(y);
+        return this;
+    }
+    replace(point) {
+        this._x = point.x;
+        this._y = point.y;
+        return this;
+    }
+    rotate(phi, about = new Point([0, 0])) {
+        const dx = Calculator_1.Calculator.sub(this.x, about.x);
+        const dy = Calculator_1.Calculator.sub(this.y, about.y);
+        this._x = +dx.mul(phi.cos).sub(dy.mul(phi.sin)).add(about.x);
+        this._y = +dy.mul(phi.cos).add(dx.mul(phi.sin)).add(about.y);
+        return this;
+    }
+    translate(vector) {
+        const { x, y } = this;
+        this._x = +Calculator_1.Calculator.add(x, vector.dx);
+        this._y = +Calculator_1.Calculator.add(y, vector.dy);
+        return this;
+    }
+}
+exports.Point = Point;

package/dist/cjs/abstracts/Vector.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Vector = void 0;
+const Calculator_1 = require("../utilities/Calculator");
+const Angle_1 = require("./Angle");
+class Vector {
+    _dx;
+    _dy;
+    constructor(values) {
+        const fromPoints = values.some((value) => typeof value !== 'number');
+        if (fromPoints) {
+            const [P1, P2] = values;
+            this._dx = +Calculator_1.Calculator.sub(P2.x, P1.x);
+            this._dy = +Calculator_1.Calculator.sub(P2.y, P1.y);
+            return;
+        }
+        const [dx, dy] = values;
+        this._dx = dx;
+        this._dy = dy;
+    }
+    get dx() {
+        return this._dx;
+    }
+    get dy() {
+        return this._dy;
+    }
+    get magnitude() {
+        const { dx, dy } = this;
+        return +Calculator_1.Calculator.pow(dx, 2).add(Calculator_1.Calculator.pow(dy, 2)).sqrt();
+    }
+    get values() {
+        return [this.dx, this.dy];
+    }
+    angleTo(vector) {
+        const dotProd = this.dotProduct(vector);
+        const magV1 = this.magnitude;
+        const magV2 = vector.magnitude;
+        const magProd = Calculator_1.Calculator.mul(magV1, magV2);
+        const cosAngle = Calculator_1.Calculator.div(dotProd, magProd);
+        const angle = cosAngle.acos();
+        return new Angle_1.Angle(+angle, 'radians');
+    }
+    clone() {
+        const { dx, dy } = this;
+        return new Vector([dx, dy]);
+    }
+    dotProduct(vector) {
+        const { dx, dy } = this;
+        return +Calculator_1.Calculator.mul(dx, vector.dx).add(Calculator_1.Calculator.mul(dy, vector.dy));
+    }
+    reflect({ x, y }) {
+        this._dx = x ? +Calculator_1.Calculator.neg(this.dx) : this.dx;
+        this._dy = y ? +Calculator_1.Calculator.neg(this.dy) : this.dy;
+        return this;
+    }
+    replace(vector) {
+        this._dx = vector.dx;
+        this._dy = vector.dy;
+        return this;
+    }
+    rotate(phi) {
+        const { dx, dy } = this;
+        this._dx = +Calculator_1.Calculator.mul(phi.cos, dx).sub(Calculator_1.Calculator.mul(phi.sin, dy));
+        this._dy = +Calculator_1.Calculator.mul(phi.sin, dx).add(Calculator_1.Calculator.mul(phi.cos, dy));
+        return this;
+    }
+    scale(factor) {
+        const { dx, dy } = this;
+        this._dx = +Calculator_1.Calculator.mul(dx, factor);
+        this._dy = +Calculator_1.Calculator.mul(dy, factor);
+        return this;
+    }
+}
+exports.Vector = Vector;

package/dist/cjs/figures/ArcCurve.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArcCurve = void 0;
+const Calculator_1 = require("../utilities/Calculator");
+const Point_1 = require("../abstracts/Point");
+const Figure_1 = require("../abstracts/Figure");
+const Ellipse_1 = require("./Ellipse");
+class ArcCurve extends Figure_1.Figure {
+    ellipse;
+    largeArcFlag;
+    phi;
+    rx;
+    ry;
+    sweepFlag;
+    constructor(values) {
+        super(values);
+        const [, rx, ry, phi, largeArcFlag, sweepFlag] = values;
+        this.rx = rx;
+        this.ry = ry;
+        this.phi = phi;
+        this.largeArcFlag = largeArcFlag;
+        this.sweepFlag = sweepFlag;
+        this.adjustRadii();
+        const center = this.computeCenter();
+        this.ellipse = new Ellipse_1.Ellipse([center, rx, ry, phi]);
+    }
+    get boundingBox() {
+        const { P0, P1 } = this;
+        const points = [P0, P1, ...this.criticalPoints];
+        return Figure_1.Figure.computeBoundingBox(points);
+    }
+    get center() {
+        return this.ellipse.center;
+    }
+    get criticalPoints() {
+        const { ellipse } = this;
+        const [minTheta, maxTheta] = this.computeThetaRange();
+        return ellipse.criticalPoints.filter((point) => {
+            const { P0, P1 } = this;
+            if ((point.x === P0.x && point.y === P0.y) || (point.x === P1.x && point.y === P1.y)) {
+                return false;
+            }
+            const theta = ellipse.computeThetaForPoint(point);
+            return +theta >= +minTheta && +theta <= +maxTheta;
+        });
+    }
+    get P0() {
+        return this.points[0];
+    }
+    get P1() {
+        if (this.isRelative) {
+            return this.P0.clone().translate(this.vectors[0]);
+        }
+        return this.points[1];
+    }
+    clone() {
+        const values = this.values.map((value) => (typeof value === 'object' && 'clone' in value ? value.clone() : value));
+        return new ArcCurve(values);
+    }
+    reflect(about) {
+        super.reflect(about);
+        this.sweepFlag.invert();
+        return this;
+    }
+    adjustRadii() {
+        const { rx, ry } = this;
+        const P0_prime = this.computeP0Prime();
+        const { x: x1_prime, y: y1_prime } = P0_prime;
+        const rx_sq = Calculator_1.Calculator.pow(+rx, 2);
+        const ry_sq = Calculator_1.Calculator.pow(+ry, 2);
+        const x1_prime_sq = Calculator_1.Calculator.pow(x1_prime, 2);
+        const y1_prime_sq = Calculator_1.Calculator.pow(y1_prime, 2);
+        const radii_check = x1_prime_sq.div(rx_sq).add(y1_prime_sq.div(ry_sq));
+        if (+radii_check > 1) {
+            rx.replace(+Calculator_1.Calculator.mul(+rx, radii_check.sqrt()));
+            ry.replace(+Calculator_1.Calculator.mul(+ry, radii_check.sqrt()));
+        }
+    }
+    computeCenter() {
+        const { P0, P1, phi } = this;
+        const center_prime = this.computeCenterPrime();
+        const { x: x1, y: y1 } = P0;
+        const { x: x2, y: y2 } = P1;
+        const { x: cx_prime, y: cy_prime } = center_prime;
+        const dx = Calculator_1.Calculator.add(x1, x2).div(2);
+        const dy = Calculator_1.Calculator.add(y1, y2).div(2);
+        const cx = Calculator_1.Calculator.mul(phi.cos, cx_prime).sub(Calculator_1.Calculator.mul(phi.sin, cy_prime)).add(dx);
+        const cy = Calculator_1.Calculator.mul(phi.sin, cx_prime).add(Calculator_1.Calculator.mul(phi.cos, cy_prime)).add(dy);
+        return new Point_1.Point([+cx, +cy]);
+    }
+    computeCenterPrime() {
+        const { largeArcFlag, sweepFlag, rx, ry } = this;
+        const P0_prime = this.computeP0Prime();
+        const { x: x1_prime, y: y1_prime } = P0_prime;
+        const rx_sq = Calculator_1.Calculator.pow(+rx, 2);
+        const ry_sq = Calculator_1.Calculator.pow(+ry, 2);
+        const x1_prime_sq = Calculator_1.Calculator.pow(x1_prime, 2);
+        const y1_prime_sq = Calculator_1.Calculator.pow(y1_prime, 2);
+        const sign = new Calculator_1.Calculator(+largeArcFlag === +sweepFlag ? -1 : 1);
+        let sq = rx_sq
+            .mul(ry_sq)
+            .sub(rx_sq.mul(y1_prime_sq))
+            .sub(ry_sq.mul(x1_prime_sq))
+            .div(rx_sq.mul(y1_prime_sq).add(ry_sq.mul(x1_prime_sq)));
+        sq = +sq < 0 ? new Calculator_1.Calculator(0) : sq;
+        const coef = sign.mul(sq.sqrt());
+        const cx_prime = coef.mul(Calculator_1.Calculator.mul(+rx, y1_prime).div(+ry));
+        const cy_prime = coef.mul(Calculator_1.Calculator.mul(+ry, x1_prime).div(+rx).neg());
+        return new Point_1.Point([+cx_prime, +cy_prime]);
+    }
+    computeP0Prime() {
+        const { P0, P1, phi } = this;
+        const { x: x1, y: y1 } = P0;
+        const { x: x2, y: y2 } = P1;
+        const mx = Calculator_1.Calculator.sub(x1, x2).div(2);
+        const my = Calculator_1.Calculator.sub(y1, y2).div(2);
+        const x1_prime = Calculator_1.Calculator.mul(phi.cos, mx).add(Calculator_1.Calculator.mul(phi.sin, my));
+        const y1_prime = Calculator_1.Calculator.mul(phi.sin, mx).neg().add(Calculator_1.Calculator.mul(phi.cos, my));
+        return new Point_1.Point([+x1_prime, +y1_prime]);
+    }
+    computeThetaRange() {
+        const { P0, P1, ellipse, sweepFlag } = this;
+        const theta1 = ellipse.computeThetaForPoint(P0);
+        const theta2 = ellipse.computeThetaForPoint(P1);
+        if (+theta2 === 0 && !sweepFlag.value) {
+            theta2.replace(360, 'degrees');
+        }
+        const thetaRange = [theta1, theta2].sort((a, b) => +Calculator_1.Calculator.sub(a.radians, b.radians));
+        return thetaRange;
+    }
+}
+exports.ArcCurve = ArcCurve;

package/dist/cjs/figures/Circle.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Circle = void 0;
+const Calculator_1 = require("../utilities/Calculator");
+const Ellipse_1 = require("./Ellipse");
+const Point_1 = require("../abstracts/Point");
+const Angle_1 = require("../abstracts/Angle");
+class Circle extends Ellipse_1.Ellipse {
+    _radius;
+    constructor(values) {
+        const [center, radius] = values;
+        const phi = new Angle_1.Angle(0, 'radians'); // Always 0 since circles don't change with rotation.
+        super([center, radius, radius.clone(), phi]);
+        this._radius = radius;
+    }
+    get isCircle() {
+        return true;
+    }
+    get radius() {
+        return this._radius;
+    }
+    get values() {
+        const [center, radius] = super.values;
+        return [center, radius];
+    }
+    set values(values) {
+        super.values = values;
+    }
+    clone() {
+        const values = this.values.map((value) => value.clone());
+        return new Circle(values);
+    }
+    computeCriticalPoints(ellipse = this) {
+        const { center, rx } = ellipse;
+        const radius = rx;
+        const first = new Point_1.Point([center.x, +Calculator_1.Calculator.add(center.y, +radius)]);
+        const second = new Point_1.Point([+Calculator_1.Calculator.add(center.x, +radius), center.y]);
+        const third = new Point_1.Point([center.x, +Calculator_1.Calculator.sub(center.y, +radius)]);
+        const fourth = new Point_1.Point([+Calculator_1.Calculator.sub(center.x, +radius), center.y]);
+        return [first, second, third, fourth];
+    }
+}
+exports.Circle = Circle;