geometric-library 1.3.0

package/dist/esm/utilities/Calculator.js

@@ -0,0 +1,149 @@
+import { Decimal } from 'decimal.js';
+export class Calculator {
+    _instance;
+    constructor(arg) {
+        this._instance = new Decimal(arg);
+    }
+    // STATIC METHODS
+    static abs(arg) {
+        return Calculator.computeUnaryOperation('abs', arg);
+    }
+    static acos(arg) {
+        return Calculator.computeUnaryOperation('acos', arg);
+    }
+    static add(first, second) {
+        return Calculator.computeBinaryOperation('add', [first, second]);
+    }
+    static atan(arg) {
+        return Calculator.computeUnaryOperation('atan', arg);
+    }
+    static atan2(first, second) {
+        return Calculator.computeBinaryOperation('atan2', [first, second]);
+    }
+    static cos(arg) {
+        return Calculator.computeUnaryOperation('cos', arg);
+    }
+    static div(first, second) {
+        return Calculator.computeBinaryOperation('div', [first, second]);
+    }
+    static max(args) {
+        return Calculator.computeIndefiniteOperation('max', args);
+    }
+    static min(args) {
+        return Calculator.computeIndefiniteOperation('min', args);
+    }
+    static mod(first, second) {
+        return Calculator.computeBinaryOperation('mod', [first, second]);
+    }
+    static mul(first, second) {
+        return Calculator.computeBinaryOperation('mul', [first, second]);
+    }
+    static neg(arg) {
+        return Calculator.computeUnaryOperation('neg', arg);
+    }
+    static pow(first, second) {
+        return Calculator.computeBinaryOperation('pow', [first, second]);
+    }
+    static sin(arg) {
+        return Calculator.computeUnaryOperation('sin', arg);
+    }
+    static sqrt(arg) {
+        return Calculator.computeUnaryOperation('sqrt', arg);
+    }
+    static sub(first, second) {
+        return Calculator.computeBinaryOperation('sub', [first, second]);
+    }
+    static tan(arg) {
+        return Calculator.computeUnaryOperation('tan', arg);
+    }
+    // PRIVATE METHODS
+    static computeBinaryOperation(operation, args) {
+        const [a, b] = Calculator.toDecimalArgs(args);
+        const result = Decimal[operation](a, b);
+        const roundedResult = this.roundDecimalWithPrecision(result);
+        return new Calculator(roundedResult);
+    }
+    static computeIndefiniteOperation(operation, args) {
+        const nargs = Calculator.toDecimalArgs(args);
+        const result = Decimal[operation](...nargs);
+        const roundedResult = this.roundDecimalWithPrecision(result);
+        return new Calculator(roundedResult);
+    }
+    static computeUnaryOperation(operation, arg) {
+        const [a] = Calculator.toDecimalArgs([arg]);
+        const result = new Decimal(a)[operation]();
+        const roundedResult = this.roundDecimalWithPrecision(result);
+        return new Calculator(roundedResult);
+    }
+    /**
+     * @todo The precision calculation could be improved to test at what decimal point is the distance less
+     * than epsilon, and then to round up to that point instead of choosing an arbitrary precision.
+     */
+    static roundDecimalWithPrecision(value) {
+        const epsilon = new Decimal('1e-8');
+        const distanceToLowerInt = value.sub(value.floor());
+        const distanceToUpperInt = value.ceil().sub(value);
+        if (distanceToLowerInt.lte(epsilon)) {
+            return value.floor().toNumber();
+        }
+        if (distanceToUpperInt.lte(epsilon)) {
+            return value.ceil().toNumber();
+        }
+        return value.toNumber();
+    }
+    static toDecimalArgs(args) {
+        return args.map((arg) => +arg);
+    }
+    // INSTANCE METHODS
+    abs() {
+        return Calculator.computeUnaryOperation('abs', this);
+    }
+    acos() {
+        return Calculator.computeUnaryOperation('acos', this);
+    }
+    add(second) {
+        return Calculator.computeBinaryOperation('add', [this, second]);
+    }
+    atan() {
+        return Calculator.computeUnaryOperation('atan', this);
+    }
+    atan2(second) {
+        return Calculator.computeBinaryOperation('atan2', [this, second]);
+    }
+    cos() {
+        return Calculator.computeUnaryOperation('cos', this);
+    }
+    div(second) {
+        return Calculator.computeBinaryOperation('div', [this, second]);
+    }
+    isFinite() {
+        return this._instance.isFinite();
+    }
+    mod(second) {
+        return Calculator.computeBinaryOperation('mod', [this, second]);
+    }
+    mul(second) {
+        return Calculator.computeBinaryOperation('mul', [this, second]);
+    }
+    neg() {
+        return Calculator.computeUnaryOperation('neg', this);
+    }
+    pow(second) {
+        return Calculator.computeBinaryOperation('pow', [this, second]);
+    }
+    sin() {
+        return Calculator.computeUnaryOperation('sin', this);
+    }
+    sqrt() {
+        return Calculator.computeUnaryOperation('sqrt', this);
+    }
+    sub(second) {
+        return Calculator.computeBinaryOperation('sub', [this, second]);
+    }
+    tan() {
+        return Calculator.computeUnaryOperation('tan', this);
+    }
+    valueOf() {
+        return this._instance.toNumber();
+    }
+}

package/dist/esm/utilities/index.js

@@ -0,0 +1,7 @@
+import { Calculator } from './Calculator';
+import { Point } from '../abstracts/Point';
+import { Line } from '../figures/Line';
+export const coordinateOrigin = new Point([0, 0]);
+export const xAxis = new Line([coordinateOrigin, new Point([1, 0])]);
+export const yAxis = new Line([coordinateOrigin, new Point([0, 1])]);
+export const PI2 = +Calculator.mul(Math.PI, 2); // 360 degrees

package/dist/types/abstracts/Angle.d.ts

@@ -0,0 +1,18 @@
+import { IAngle, TAngleUnit } from '../types';
+export declare class Angle implements IAngle {
+    private _radians;
+    constructor(value: number, unit: TAngleUnit);
+    get cos(): number;
+    get cot(): number;
+    get degrees(): number;
+    get radians(): number;
+    get sin(): number;
+    get tan(): number;
+    static toDegrees(radians: number): number;
+    static toRadians(degrees: number): number;
+    clone(): IAngle;
+    normalize(): this;
+    replace(value: number, unit: TAngleUnit): this;
+    scale(factor: number): this;
+    valueOf(): number;
+}

package/dist/types/abstracts/Figure.d.ts

@@ -0,0 +1,22 @@
+import { IAngle, IBoundingBox, IFigure, ILine, IMagnitude, IPoint, IVector, TFigureValues } from '../types';
+export declare abstract class Figure implements IFigure {
+    protected angles: IAngle[];
+    protected isRelative: boolean;
+    protected magnitudes: IMagnitude[];
+    protected points: IPoint[];
+    protected vectors: IVector[];
+    private _values;
+    constructor(values: TFigureValues);
+    get boundingBox(): IBoundingBox;
+    get values(): TFigureValues;
+    /**
+     * @todo Figure out a better way to type narrow than iterating again.
+     */
+    protected set values(values: TFigureValues);
+    protected static computeBoundingBox(points: IPoint[]): IBoundingBox;
+    private static getNoPointsErrorMessage;
+    reflect(about: IPoint | ILine): this;
+    rotate(phi: IAngle, about?: IPoint): this;
+    scale(factor: number, about?: IPoint): this;
+    translate(vector: IVector): this;
+}

package/dist/types/abstracts/Flag.d.ts

@@ -0,0 +1,10 @@
+import { IFlag } from '../types';
+export declare class Flag implements IFlag {
+    private _value;
+    constructor(value: boolean);
+    get value(): boolean;
+    clone(): IFlag;
+    invert(): this;
+    replace(value: boolean): this;
+    valueOf(): number;
+}

package/dist/types/abstracts/Magnitude.d.ts

@@ -0,0 +1,9 @@
+import { IMagnitude } from '../types';
+export declare class Magnitude implements IMagnitude {
+    private _value;
+    constructor(value: number);
+    clone(): IMagnitude;
+    replace(value: number): this;
+    scale(factor: number): this;
+    valueOf(): number;
+}

package/dist/types/abstracts/Point.d.ts

@@ -0,0 +1,14 @@
+import { IAngle, IPoint, IVector, TPointValues } from '../types';
+export declare class Point implements IPoint {
+    private _x;
+    private _y;
+    constructor([x, y]: TPointValues);
+    get values(): TPointValues;
+    get x(): number;
+    get y(): number;
+    clone(): Point;
+    reflect(about: IPoint): this;
+    replace(point: Point): this;
+    rotate(phi: IAngle, about?: IPoint): this;
+    translate(vector: IVector): this;
+}

package/dist/types/abstracts/Vector.d.ts

@@ -0,0 +1,20 @@
+import { IVector, TVectorValues, TSegment, IAngle } from '../types';
+export declare class Vector implements IVector {
+    private _dx;
+    private _dy;
+    constructor(values: TVectorValues | TSegment);
+    get dx(): number;
+    get dy(): number;
+    get magnitude(): number;
+    get values(): TVectorValues;
+    angleTo(vector: Vector): IAngle;
+    clone(): Vector;
+    dotProduct(vector: Vector): number;
+    reflect({ x, y }: {
+        x: boolean;
+        y: boolean;
+    }): this;
+    replace(vector: Vector): this;
+    rotate(phi: IAngle): this;
+    scale(factor: number): this;
+}

package/dist/types/figures/ArcCurve.d.ts

@@ -0,0 +1,23 @@
+import { IArcCurve, IBoundingBox, ILine, IPoint, TArcValues } from '../types';
+import { Figure } from '../abstracts/Figure';
+export declare class ArcCurve extends Figure implements IArcCurve {
+    private ellipse;
+    private largeArcFlag;
+    private phi;
+    private rx;
+    private ry;
+    private sweepFlag;
+    constructor(values: TArcValues);
+    get boundingBox(): IBoundingBox;
+    get center(): IPoint;
+    get criticalPoints(): IPoint[];
+    private get P0();
+    private get P1();
+    clone(): ArcCurve;
+    reflect(about: IPoint | ILine): this;
+    private adjustRadii;
+    private computeCenter;
+    private computeCenterPrime;
+    private computeP0Prime;
+    private computeThetaRange;
+}

package/dist/types/figures/Circle.d.ts

@@ -0,0 +1,12 @@
+import { ICircle, IEllipse, IMagnitude, TCircleValues, TEllipseCriticalPoints, TFigureValues } from '../types';
+import { Ellipse } from './Ellipse';
+export declare class Circle extends Ellipse implements ICircle {
+    private _radius;
+    constructor(values: TCircleValues);
+    get isCircle(): boolean;
+    get radius(): IMagnitude;
+    get values(): TFigureValues;
+    set values(values: TFigureValues);
+    clone(): Circle;
+    protected computeCriticalPoints(ellipse?: IEllipse): TEllipseCriticalPoints;
+}

package/dist/types/figures/CubicBezierCurve.d.ts

@@ -0,0 +1,23 @@
+import { IAngle, IBoundingBox, ICubicBezierCurve, ILine, IPoint, IVector, TCubicBezierValues } from '../types';
+import { Figure } from '../abstracts/Figure';
+export declare class CubicBezierCurve extends Figure implements ICubicBezierCurve {
+    private _criticalPoints;
+    constructor(values: TCubicBezierValues);
+    get boundingBox(): IBoundingBox;
+    get criticalPoints(): IPoint[];
+    private get P0();
+    private get P1();
+    private get P2();
+    private get P3();
+    clone(): CubicBezierCurve;
+    recompute(): void;
+    reflect(about: IPoint | ILine): this;
+    rotate(phi: IAngle, about?: IPoint | undefined): this;
+    scale(factor: number, about?: IPoint): this;
+    translate(vector: IVector): this;
+    private computeCriticalPoints;
+    private computeCriticalPointsTValues;
+    private getCoordinateAtParameter;
+    private getPointAtParameter;
+    private isValidParameter;
+}

package/dist/types/figures/Ellipse.d.ts

@@ -0,0 +1,26 @@
+import { TEllipseValues, IBoundingBox, IPoint, IEllipse, TEllipseCriticalPoints, IMagnitude, IVector, ILine, IAngle } from '../types';
+import { Figure } from '../abstracts/Figure';
+export declare class Ellipse extends Figure implements IEllipse {
+    private _center;
+    private _criticalPoints;
+    private _phi;
+    private _rx;
+    private _ry;
+    constructor(values: TEllipseValues);
+    get boundingBox(): IBoundingBox;
+    get center(): IPoint;
+    get criticalPoints(): TEllipseCriticalPoints;
+    get isCircle(): boolean;
+    get phi(): IAngle;
+    get rx(): IMagnitude;
+    get ry(): IMagnitude;
+    clone(): IEllipse;
+    computePointForTheta(theta: IAngle, ellipse?: IEllipse): IPoint;
+    computeThetaForPoint({ x, y }: IPoint): IAngle;
+    reflect(about: IPoint | ILine): this;
+    rotate(alpha: IAngle, about?: IPoint | undefined): this;
+    scale(factor: number, about?: IPoint): this;
+    translate(vector: IVector): this;
+    protected computeCriticalPoints(ellipse?: IEllipse): TEllipseCriticalPoints;
+    private recompute;
+}

package/dist/types/figures/Line.d.ts

@@ -0,0 +1,44 @@
+import { IAngle, ILine, IPoint, IVector, TLineValues } from '../types';
+import { Figure } from '../abstracts/Figure';
+export declare class Line extends Figure implements ILine {
+    private _P0;
+    private _P1;
+    private _V;
+    private _reciprocal;
+    private _slope;
+    private _xIntercept;
+    private _yIntercept;
+    constructor(values: TLineValues);
+    get P0(): IPoint;
+    get P1(): IPoint;
+    get V(): IVector;
+    get a(): number;
+    get b(): 1 | 0 | -1;
+    get c(): number;
+    get isHorizontal(): boolean;
+    get isVertical(): boolean;
+    get reciprocal(): number | undefined;
+    get slope(): number | undefined;
+    get xIntercept(): number | undefined;
+    get yIntercept(): number | undefined;
+    angleTo(line: ILine): IAngle;
+    clone(): Line;
+    getIntersectionPoint(line: ILine): IPoint | undefined;
+    getPerpendicularProjection(point: IPoint): IPoint;
+    getPerpendicularThrough(point: IPoint): ILine;
+    getPointAtParameter(t: number): IPoint;
+    getXValueAtY(y: number): number | undefined;
+    getYValueAtX(x: number): number | undefined;
+    hasPoint(P: IPoint): boolean;
+    isParallelTo(line: ILine): boolean;
+    isPerpendicularTo(line: ILine): boolean;
+    reflect(about: ILine | IPoint): this;
+    rotate(phi: IAngle, about?: IPoint | undefined): this;
+    scale(factor: number, about?: IPoint): this;
+    translate(vector: IVector): this;
+    private computeReciprocal;
+    private computeSlope;
+    private computeXIntercept;
+    private computeYIntercept;
+    private recompute;
+}

package/dist/types/figures/Polygon.d.ts

@@ -0,0 +1,7 @@
+import { IPolygon, TPolygonValues } from '../types';
+import { Figure } from '../abstracts/Figure';
+export declare class Polygon extends Figure implements IPolygon {
+    constructor(values: TPolygonValues);
+    get sides(): number;
+    clone(): Polygon;
+}

package/dist/types/figures/QuadraticBezierCurve.d.ts

@@ -0,0 +1,21 @@
+import { IAngle, IBoundingBox, ILine, IPoint, IQuadraticBezierCurve, IVector, TQuadraticBezierValues } from '../types';
+import { Figure } from '../abstracts/Figure';
+export declare class QuadraticBezierCurve extends Figure implements IQuadraticBezierCurve {
+    private _criticalPoints;
+    constructor(values: TQuadraticBezierValues);
+    get boundingBox(): IBoundingBox;
+    get criticalPoints(): IPoint[];
+    private get P0();
+    private get P1();
+    private get P2();
+    clone(): QuadraticBezierCurve;
+    recompute(): void;
+    reflect(about: IPoint | ILine): this;
+    rotate(phi: IAngle, about?: IPoint | undefined): this;
+    scale(factor: number, about?: IPoint): this;
+    translate(vector: IVector): this;
+    private computeCriticalPoints;
+    private getCoordinateAtParameter;
+    private getCriticalPointTValue;
+    private getPointAtParameter;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,16 @@
+export { Angle } from './abstracts/Angle';
+export { Figure } from './abstracts/Figure';
+export { Flag } from './abstracts/Flag';
+export { Magnitude } from './abstracts/Magnitude';
+export { Point } from './abstracts/Point';
+export { Vector } from './abstracts/Vector.js';
+export { ArcCurve } from './figures/ArcCurve';
+export { Circle } from './figures/Circle';
+export { CubicBezierCurve } from './figures/CubicBezierCurve';
+export { Ellipse } from './figures/Ellipse';
+export { Line } from './figures/Line';
+export { Polygon } from './figures/Polygon';
+export { QuadraticBezierCurve } from './figures/QuadraticBezierCurve';
+export { Calculator } from './utilities/Calculator';
+export * from './utilities';
+export * from './types';

package/dist/types/types/index.d.ts

@@ -0,0 +1,144 @@
+export type TSegment = [IPoint, IPoint];
+export type TAxis = 'x' | 'y';
+export type TAxii = ['x', 'y'];
+export interface IBoundingBox {
+    xMax: number;
+    xMin: number;
+    yMax: number;
+    yMin: number;
+}
+export interface ISize {
+    height: number;
+    width: number;
+}
+export interface IClonable<T> {
+    clone(): T;
+}
+export interface IFlag extends IClonable<IFlag> {
+    readonly value: boolean;
+    invert(): this;
+    replace(value: boolean): this;
+    valueOf(): number;
+}
+export type TAngleUnit = 'radians' | 'degrees';
+export interface IAngle extends IClonable<IAngle> {
+    readonly cos: number;
+    readonly cot: number;
+    readonly degrees: number;
+    readonly radians: number;
+    readonly sin: number;
+    readonly tan: number;
+    normalize(): this;
+    replace(value: number, unit: TAngleUnit): this;
+    scale(factor: number): this;
+    valueOf(): number;
+}
+export type TAngleRange = [IAngle, IAngle];
+export interface IMagnitude extends IClonable<IMagnitude> {
+    replace(value: number): this;
+    scale(factor: number): this;
+    valueOf(): number;
+}
+export type TPointValues = [number, number];
+export interface IPoint extends IClonable<IPoint> {
+    readonly values: TPointValues;
+    readonly x: number;
+    readonly y: number;
+    reflect(about: IPoint): this;
+    replace(point: IPoint): this;
+    rotate(phi: IAngle, about?: IPoint): this;
+    translate(vector: IVector): this;
+}
+export type TVectorValues = [number, number];
+export interface IVector extends IClonable<IVector> {
+    readonly dx: number;
+    readonly dy: number;
+    readonly values: TVectorValues;
+    angleTo(vector: IVector): IAngle;
+    dotProduct(vector: IVector): number;
+    reflect(about: {
+        x: boolean;
+        y: boolean;
+    }): this;
+    replace(vector: IVector): this;
+    rotate(phi: IAngle): this;
+    scale(factor: number): this;
+}
+export type TFigureValue = IFlag | IMagnitude | IAngle | IPoint | IVector;
+export type TFigureValues = [IPoint, ...TFigureValue[]];
+export interface IFigure {
+    readonly boundingBox: IBoundingBox;
+    readonly values: TFigureValues;
+    reflect(about: IPoint | ILine): this;
+    rotate(phi: IAngle, about?: IPoint): this;
+    scale(factor: number, about?: IPoint): this;
+    translate(vector: IVector): this;
+}
+export type TLineRelativeValues = [IPoint, IVector];
+export type TLineAbsoluteValues = [IPoint, IPoint];
+export type TLineValues = TLineAbsoluteValues | TLineRelativeValues;
+export interface ILine extends IFigure, IClonable<ILine> {
+    readonly P0: IPoint;
+    readonly P1: IPoint;
+    readonly V: IVector;
+    readonly a: number;
+    readonly b: number;
+    readonly c: number;
+    readonly isHorizontal: boolean;
+    readonly isVertical: boolean;
+    readonly reciprocal: number | undefined;
+    readonly slope: number | undefined;
+    readonly xIntercept: number | undefined;
+    readonly yIntercept: number | undefined;
+    angleTo(reference: ILine | IVector): IAngle;
+    getIntersectionPoint(line: ILine): IPoint | undefined;
+    getPerpendicularProjection(point: IPoint): IPoint;
+    getPerpendicularThrough(point: IPoint): ILine;
+    getPointAtParameter(t: number): IPoint | undefined;
+    getXValueAtY(y: number): number | undefined;
+    getYValueAtX(x: number): number | undefined;
+    hasPoint(point: IPoint): boolean;
+    isParallelTo(line: ILine): boolean;
+    isPerpendicularTo(line: ILine): boolean;
+}
+export type TEllipseValues = [IPoint, IMagnitude, IMagnitude, IAngle];
+export type TEllipseCriticalPoints = [IPoint, IPoint, IPoint, IPoint];
+export interface IEllipse extends IFigure, IClonable<IEllipse> {
+    readonly center: IPoint;
+    readonly criticalPoints: TEllipseCriticalPoints;
+    readonly phi: IAngle;
+    readonly rx: IMagnitude;
+    readonly ry: IMagnitude;
+    computePointForTheta(theta: IAngle): IPoint;
+    computeThetaForPoint(point: IPoint): IAngle;
+}
+export type TCircleValues = [IPoint, IMagnitude];
+export interface ICircle extends IFigure, IClonable<ICircle> {
+    readonly center: IPoint;
+    readonly criticalPoints: TEllipseCriticalPoints;
+    readonly phi: IAngle;
+    readonly radius: IMagnitude;
+}
+export type TArcAbsoluteValues = [IPoint, IMagnitude, IMagnitude, IAngle, IFlag, IFlag, IPoint];
+export type TArcRelativeValues = [IPoint, IMagnitude, IMagnitude, IAngle, IFlag, IFlag, IVector];
+export type TArcValues = TArcAbsoluteValues | TArcRelativeValues;
+export interface IArcCurve extends IFigure, IClonable<IArcCurve> {
+    readonly center: IPoint;
+    readonly criticalPoints: IPoint[];
+}
+export type TCubicBezierAbsoluteValues = [IPoint, IPoint, IPoint, IPoint];
+export type TCubicBezierRelativeValues = [IPoint, IVector, IVector, IVector];
+export type TCubicBezierValues = TCubicBezierAbsoluteValues | TCubicBezierRelativeValues;
+export interface ICubicBezierCurve extends IFigure, IClonable<ICubicBezierCurve> {
+    readonly criticalPoints: IPoint[];
+}
+export type TQuadraticBezierAbsoluteValues = [IPoint, IPoint, IPoint];
+export type TQuadraticBezierRelativeValues = [IPoint, IVector, IVector];
+export type TQuadraticBezierValues = TQuadraticBezierAbsoluteValues | TQuadraticBezierRelativeValues;
+export interface IQuadraticBezierCurve extends IFigure, IClonable<IQuadraticBezierCurve> {
+    readonly criticalPoints: IPoint[];
+}
+export type TPolygonValues = [IPoint, IPoint, IPoint, ...IPoint[]];
+export interface IPolygon extends IClonable<IPolygon> {
+    readonly sides: number;
+}

package/dist/types/utilities/Calculator.d.ts

@@ -0,0 +1,49 @@
+type TInput = Calculator | number;
+export declare class Calculator {
+    private _instance;
+    constructor(arg: number);
+    static abs(arg: TInput): Calculator;
+    static acos(arg: TInput): Calculator;
+    static add(first: TInput, second: TInput): Calculator;
+    static atan(arg: TInput): Calculator;
+    static atan2(first: TInput, second: TInput): Calculator;
+    static cos(arg: TInput): Calculator;
+    static div(first: TInput, second: TInput): Calculator;
+    static max(args: TInput[]): Calculator;
+    static min(args: TInput[]): Calculator;
+    static mod(first: TInput, second: TInput): Calculator;
+    static mul(first: TInput, second: TInput): Calculator;
+    static neg(arg: TInput): Calculator;
+    static pow(first: TInput, second: TInput): Calculator;
+    static sin(arg: TInput): Calculator;
+    static sqrt(arg: TInput): Calculator;
+    static sub(first: TInput, second: TInput): Calculator;
+    static tan(arg: TInput): Calculator;
+    private static computeBinaryOperation;
+    private static computeIndefiniteOperation;
+    private static computeUnaryOperation;
+    /**
+     * @todo The precision calculation could be improved to test at what decimal point is the distance less
+     * than epsilon, and then to round up to that point instead of choosing an arbitrary precision.
+     */
+    private static roundDecimalWithPrecision;
+    private static toDecimalArgs;
+    abs(): Calculator;
+    acos(): Calculator;
+    add(second: TInput): Calculator;
+    atan(): Calculator;
+    atan2(second: TInput): Calculator;
+    cos(): Calculator;
+    div(second: TInput): Calculator;
+    isFinite(): boolean;
+    mod(second: TInput): Calculator;
+    mul(second: TInput): Calculator;
+    neg(): Calculator;
+    pow(second: TInput): Calculator;
+    sin(): Calculator;
+    sqrt(): Calculator;
+    sub(second: TInput): Calculator;
+    tan(): Calculator;
+    valueOf(): number;
+}
+export {};

package/dist/types/utilities/index.d.ts

@@ -0,0 +1,6 @@
+import { Point } from '../abstracts/Point';
+import { Line } from '../figures/Line';
+export declare const coordinateOrigin: Point;
+export declare const xAxis: Line;
+export declare const yAxis: Line;
+export declare const PI2: number;