@pacem/pacem-numerical 1.0.0-abel

package/typings/index.d.ts

@@ -0,0 +1,763 @@
+import { Point } from '@pacem/pacem-foundation';
+import { Rect } from '@pacem/pacem-foundation';
+
+declare interface Complex {
+    readonly real: number;
+    readonly img: number;
+}
+
+declare class Complex {
+    static build(z: Complex | number): Complex;
+    static build(real: number, img: number): Complex;
+    static add(a: Complex | number, b: Complex | number): Complex;
+    static subtract(from: Complex | number, what: Complex | number): Complex;
+    static multiply(a: Complex | number, b: Complex | number): Complex;
+    static divide(a: Complex | number, b: Complex | number): Complex;
+    static absSquare(c: Complex | number): number;
+    static modulus(c: Complex | number): number;
+    static isComplex(c: any): c is Complex;
+    static conjugate(a: Complex | number): Complex;
+    static equals(c1: Complex | number, c2: Complex | number): boolean;
+    static get NaC(): Complex;
+}
+
+export declare namespace DataAnalysis {
+    export {
+        Fourier,
+        Gaussian,
+        Interpolator,
+        Lagrange,
+        Lagrangian,
+        Pchip,
+        Newton,
+        Utils_2 as Utils,
+        SearchFunction,
+        SearchFunctions
+    }
+}
+
+declare class Fourier {
+    /**
+     * Checks the input vector and outputs a frequency vector using the best performing algo.
+     * @param data Input vector of any size
+     * @param normalize Whether to normalize the signal or not (default true)
+     */
+    static transform(data: (Complex | number)[], normalize?: boolean): Complex[];
+    /**
+     * Checks the input vector and applies inverted fourier transform's best performing algo.
+     * @param data Input frequency vector
+     */
+    static invert(data: Complex[], normalize?: boolean): Complex[];
+    /**
+     * Naive Discrete Fourier Transform implementation (O(n^2) algo).
+     * @param data Input vector of any size
+     * @param normalize Whether to normalize the signal or not (default true)
+     */
+    static dft(data: (Complex | number)[], normalize?: boolean): Complex[];
+    /**
+     * Inverse Discrete Fourier Transform.
+     * @param data Input vector data of any size
+     */
+    static idft(data: Complex[], normalize?: boolean): Complex[];
+    /**
+     * FFT processing using Cooley-Tukey.
+     * @param data Input vector (size MUST be power of 2)
+     */
+    static fft(data: (Complex | number)[], normalize?: boolean): Complex[];
+}
+
+declare class Gaussian {
+    constructor(mean: number, stdev: number);
+    readonly mean: number;
+    readonly stdev: number;
+    readonly variance: number;
+    static get normal(): Gaussian;
+    /**
+     * Un-normalized probability density function.
+     * Can be useful as a weight function without requiring the integral w(x)dx to be 1.
+     * @param x Input value
+     */
+    weight(x: number): number;
+    /**
+     * Probability density function (PDF).
+     * @param x Input value
+     */
+    probabilityDensity(x: number): number;
+    private _z;
+    /**
+     * Returns the area under the PDF from -∞ to x
+     * @param x Input value
+     */
+    probability(x: number): number;
+}
+
+export declare namespace Geometry {
+    export {
+        LinearAlgebra,
+        Segment,
+        Utils,
+        Polygon,
+        Ray,
+        Utils3D
+    }
+}
+
+declare interface Interpolator {
+    interpolate(x: number): number;
+}
+
+declare class Lagrange implements Interpolator {
+    #private;
+    protected constructor(points: Point[]);
+    private _prepareBarycentric;
+    private _computeBarycentric;
+    interpolate(x: number): number;
+    static create(...values: number[]): Lagrange;
+    static create(...points: Point[]): Lagrange;
+    static create(points: Point[]): Lagrange;
+    static create(values: number[]): Lagrange;
+}
+
+/**
+ * @deprecated Use Lagrange instead. This alias is kept for backward compatibility.
+ */
+declare const Lagrangian: {
+    create: typeof Lagrange.create;
+};
+
+export declare namespace LinearAlgebra {
+    export {
+        Vector,
+        Point3D,
+        Vector3D,
+        Spherical,
+        Matrix3D,
+        Quaternion
+    }
+}
+
+export declare namespace Mathematics {
+    export {
+        DataAnalysis,
+        NumberTheory,
+        Complex
+    }
+}
+
+declare interface Matrix3D {
+    m11: number;
+    m12: number;
+    m13: number;
+    m14: number;
+    m21: number;
+    m22: number;
+    m23: number;
+    m24: number;
+    m31: number;
+    m32: number;
+    m33: number;
+    m34: number;
+    offsetX: number;
+    offsetY: number;
+    offsetZ: number;
+    m44: number;
+}
+
+declare class Matrix3D {
+    /**
+     * Identity 4x4 matrix.
+     * @returns
+     */
+    static identity(): Matrix3D;
+    static from(...args: number[]): Matrix3D;
+    static transpose(m: Matrix3D): Matrix3D;
+    static toArray(m: Matrix3D): number[];
+    static clone(m: Matrix3D): Matrix3D;
+    static clone(m: Matrix3D, modifier: (m: Matrix3D) => void): Matrix3D;
+    static scale(m: Matrix3D, v: Vector3D): Matrix3D;
+    static scale(m: Matrix3D, scale: number): Matrix3D;
+    static scale(m: Matrix3D, sx: number, sy: number, sz: number): Matrix3D;
+    static translate(m: Matrix3D, offset: Vector3D): Matrix3D;
+    static parse(input: string): Matrix3D;
+    static isIdentity(m: Matrix3D): boolean;
+    static isAffine(m: Matrix3D): boolean;
+    static determinant(m: Matrix3D): number;
+    /**
+     * Multiplies two matrices in the provided order (i.e.: applies {@link m2} to {@link m1}).
+     * @param matrices Matrices to apply one to the other, sequentially.
+     * @returns Combination matrix.
+     */
+    static multiply(...matrices: Matrix3D[]): Matrix3D;
+    static invert(m: Matrix3D): Matrix3D;
+    /**
+     * Moves a given point in 3D space given the transformation matrix.
+     * @param point
+     * @param matrix
+     */
+    static transform(point: Point3D, matrix: Matrix3D): Point3D;
+}
+
+declare interface Mesh extends Polygon {
+    triangleIndices: number[];
+}
+
+declare class Newton implements Interpolator {
+    private xs;
+    private coeffs;
+    private constructor();
+    interpolate(x: number): number;
+    static create(...values: number[]): Newton;
+    static create(...points: Point[]): Newton;
+    static create(points: Point[]): Newton;
+    static create(values: number[]): Newton;
+}
+
+export declare namespace NumberTheory {
+    export {
+        Utils_3 as Utils
+    }
+}
+
+declare type NumericKeySelector<T> = (item: T, index?: number) => number;
+
+declare class Pchip implements Interpolator {
+    private xs;
+    private ys;
+    private ms;
+    private constructor();
+    private computeDerivatives;
+    interpolate(x: number): number;
+    static create(...values: number[]): Pchip;
+    static create(...points: Point[]): Pchip;
+    static create(points: Point[]): Pchip;
+    static create(values: number[]): Pchip;
+}
+
+declare interface Point3D {
+    x: number;
+    y: number;
+    z: number;
+}
+
+declare interface Polygon {
+    vertices: Point[];
+}
+
+declare class Polygon {
+    private static readonly _eps;
+    static isPolygon(obj: any): obj is Polygon;
+    static from(...points: Point[]): Polygon;
+    static contains(polygon: Polygon, p: Point): any;
+    static centroid(polygon: Polygon): Point;
+    static boundingBox(polygon: Polygon): Rect;
+    static sides(polygon: Polygon): Segment[];
+    static isConvex(polygon: Polygon): boolean;
+    /**
+     * Check whether a polygon is a self-intersecting one.
+     * @param polygon
+     * @returns
+     */
+    static isSelfIntersecting(polygon: Polygon): boolean;
+    /**
+     * Returns whether the vertices of the spcified polygon have been provided in counter-clockwise order.
+     * Meaningless in case of self-intersecting polygons.
+     * @param polygon
+     * @returns
+     */
+    static isCounterClockwise(polygon: Polygon): boolean;
+    /**
+     * Expands (or contracts) a polygon by a provided offset.
+     * @param polygon
+     * @param offset
+     *
+     */
+    static expand(polygon: Polygon, offset: number): Polygon;
+    /**
+     * Returns the area of a polygon using the shoelace algorithm. It's meaningless in case of self-intersecting polygons.
+     * @param polygon
+     * @returns
+     */
+    static area(polygon: Polygon): number;
+    static intersect(polygon1: Polygon, polygon2: Polygon): Polygon[];
+    /**
+     * Returns the convex hull of a polygon.
+     * @param polygon
+     * @returns
+     */
+    static convexHull(polygon: Polygon): Polygon;
+}
+
+declare type PolygonCompound = 'union' | 'intersect' | 'difference';
+
+declare interface Quaternion {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+}
+
+declare class Quaternion {
+    static identity(): Quaternion;
+    static from(...args: number[]): Quaternion;
+    static parse(input: string): Quaternion;
+    static fromVectors(from: Vector3D, to: Vector3D): Quaternion;
+    /**
+     * In-place normalizarion of the provided quaternion
+     * @param q {Quaternion}
+     */
+    static normalize(q: Quaternion): void;
+    /**
+     * Returns a normalized copy of the source quaternion.
+     * @param q {Quaternion}
+     */
+    static unit(q: Quaternion): Quaternion;
+    /**
+     * Creates a quaternion instance given the rotation axis and an angle (in degrees).
+     * @param axis
+     * @param angleDeg
+     */
+    static fromAxisAngle(axis: Vector3D, angleDeg: number): Quaternion;
+    /**
+     * Creates a quaternion instance given the rotation matrix.
+     * @param rotationMatrix
+     */
+    static fromRotationMatrix(rotationMatrix: Matrix3D): Quaternion;
+    static conjugate(q: Quaternion): Quaternion;
+    /**
+     * Returns the magnitude/length of the provided quaternion.
+     * @param q {Quaternion}
+     */
+    static mag(q: Quaternion): number;
+    static norm(q: Quaternion): number;
+    static axis(q: Quaternion): Vector3D;
+    static transform(v: Vector3D, q: Quaternion): Vector3D;
+    /**
+     * Returns the rotation angle (in degrees) of the provided quaternion.
+     * @param q
+     */
+    static angle(q: Quaternion): number;
+    static toRotationMatrix(q: Quaternion): Matrix3D;
+    static invert(q: Quaternion): Quaternion;
+    /**
+     * Combines two quaternions.
+     * @param q1
+     * @param q2
+     */
+    static multiply(q1: Quaternion, q2: Quaternion): Quaternion;
+    /**
+     * Returns the dot product of two quaternions.
+     * @param q1
+     * @param q2
+     */
+    static dot(q1: Quaternion, q2: Quaternion): number;
+}
+
+declare type Ray = [Point3D, Point3D];
+
+declare type SearchFunction = (min: number, max: number, weight: (v: number) => number, tolerance?: number) => number;
+
+declare const SearchFunctions: {
+    /**
+     * Creates a linear search function.
+     * @param segments How many segments to split the range into.
+     */
+    linear: (segments?: number) => SearchFunction;
+    /** Golden section search function. */
+    goldenRatio: SearchFunction;
+    /** Gaussian search function. */
+    gaussian: SearchFunction;
+};
+
+declare type Segment = [Point, Point];
+
+declare interface Spherical {
+    /** Azimuthal angle in degrees. */
+    theta: number;
+    /** Polar angle in degrees. */
+    phi: number;
+    /** Radial distance. */
+    rho: number;
+}
+
+declare class Spherical {
+    /**
+     * Creates a new {@link Spherical} object.
+     * @param rho radius.
+     * @param theta Azimuth angle in degrees.
+     * @param phi Polar angle in degrees.
+     * @returns
+     */
+    static from(rho: number, theta: number, phi: number): Spherical;
+    static fromVector(x: number, y: number, z: any): Spherical;
+    static fromVector(v: Vector3D): Spherical;
+    static toVector(coords: Spherical): Vector3D;
+    static toRotationMatrix(coords: Spherical): Matrix3D;
+    static toRotationMatrix(coords: {
+        theta: number;
+        phi: number;
+    }): Matrix3D;
+}
+
+declare class Utils {
+    /**
+     * Computes the slope (in radians) of the segment joining two points.
+     * @param p1 Point 1
+     * @param p2 Point 2
+     */
+    static slopeRad(p1: Point, p2: Point): number;
+    /**
+     * Computes the slope (in radians) of the segment joining two points and returns a strictly positive value (0 to 2*pi).
+     * @param p1 Point 1
+     * @param p2 Point 2
+     */
+    static slopeRad2(p1: Point, p2: Point): number;
+    /**
+     * Computes the slope (in degrees) of the segment joining two points.
+     * @param p1 Point 1
+     * @param p2 Point 2
+     */
+    static slopeDeg(p1: Point, p2: Point): number;
+    /**
+     * Computes the slope (in degrees) of the segment joining two points and returns a strictly positive value (0 to 360).
+     * @param p1 Point 1
+     * @param p2 Point 2
+     */
+    static slopeDeg2(p1: Point, p2: Point): number;
+    /**
+     * Computes the intersection rect among a set of provided rects.
+     * @param rects Rects to intersect
+     */
+    static intersect(...rects: Rect[]): Rect;
+    static intersect(polygon1: Polygon, polygon2: Polygon): Polygon[];
+    /**
+     * Computes the intersection point between two segments, if any.
+     * @param segment1
+     * @param segment2
+     */
+    static intersect(segment1: Segment, segment2: Segment): Point;
+    static boundingBox(vertices: Point[]): Rect;
+    static combinePolygons(polygon1: Polygon, polygon2: Polygon, operator: PolygonCompound): {
+        polygons: Polygon[];
+        mesh?: Mesh;
+        triangles?: Polygon[];
+    } | null;
+    private static _mergePolygons;
+    /**
+     * Returns the 2D mesh (vertices and triangle indices) of the Delaunay triangulation for the provided points.
+     * @param points
+     */
+    static mesh(...points: Point[]): any;
+    static mesh(points: Point[]): any;
+    /**
+     * Computes the intersection point between the lines whose two provided segments belong to, if any.
+     * @param segment1 First segment
+     * @param segment2 Second segment
+     */
+    static intersectLines(segment1: Segment, segment2: Segment): Point;
+    /**
+     * Computes the intersection point between the lines having the respective 'm' and 'q'.
+     * @param m1 First line's 'm'
+     * @param q1 First line's 'q'
+     * @param m2 Second line's 'm'
+     * @param q2 Second line's 'q'
+     */
+    static intersectLines(m1: number, q1: number, m2: number, q2: number): Point;
+    /**
+     * Computes the intersection point between the lines having the respective 'm' and 'q'.
+     * @param mq1 'm' and 'q' pair for line 1
+     * @param mq2 'm' and 'q' pair for line 2
+     */
+    static intersectLines(mq1: [number, number], mq2: [number, number]): Point;
+    /**
+     * Returns the eigenvalue for two given linear equations of the form ax + by + c = 0.
+     * @param l1
+     * @param l2
+     */
+    static cramer(l1: [number, number, number], l2: [number, number, number]): Point;
+    /**
+     * Returns the eigenvalue for two given linear equations of the form ax + by + c = 0.
+     * @param l1
+     * @param l2
+     */
+    static cramer(l1: {
+        a: number;
+        b: number;
+        c: number;
+    }, l2: {
+        a: number;
+        b: number;
+        c: number;
+    }): Point;
+    /**
+     * Returns the slope (m) and the y-axis intersection (q) of the line joining two given points.
+     * @param p1
+     * @param p2
+     */
+    static mq(p1: Point, p2: Point): [number, number];
+    /**
+     * Returns the slope (m) and the y-axis intersection (q) of the line containing the provided segment.
+     * @param segment
+     */
+    static mq(segment: Segment): [number, number];
+    private static _intersectSegments;
+    private static _intersectRects;
+    private static _areClose;
+    static areClose(p1: Point, p2: Point): boolean;
+    static areClose(p1: Point, p2: Point, precision: number): boolean;
+    /**
+     * Returns the dot product between two vectors/points.
+     * @param v1
+     * @param v2
+     */
+    static dot(v1: Point, v2: Point): number;
+    /**
+     * Returns the cross product between two vectors/points (magnitude along the z axis).
+     * @param v1
+     * @param v2
+     */
+    static cross(v1: Point, v2: Point): number;
+    /**
+     * Returns the distance between two given points.
+     * @param p1
+     * @param p2
+     */
+    static distance(p1: Point, p2: Point): number;
+    /**
+     * Returns the distance between a point and a line.
+     * @param p
+     * @param mq Line identified by a two-number array (slope and y-intercept).
+     */
+    static distance(p: Point, mq: [number, number]): number;
+    static distance(segment: Segment): number;
+    private static _pointSegmentDistance;
+    static isWithin(p: Point, segment: Segment, clockwise: boolean): boolean;
+    static isWithin(p: Point, segment: Segment, clockwise: boolean, precision: number): boolean;
+    static isBeyond(p: Point, segment: Segment, clockwise: boolean): boolean;
+    static isBeyond(p: Point, segment: Segment, clockwise: boolean, precision: number): boolean;
+    static inLine(p: Point, segment: Segment): boolean;
+    static inLine(p: Point, segment: Segment, precision: number): boolean;
+    static inSegment(p: Point, segment: Segment): boolean;
+    static inSegment(p: Point, segment: Segment, precision: number): boolean;
+    static inTriangle(p: Point, triangle: [Point, Point, Point]): boolean;
+    /**
+     * Checks whether a given point lies inside a polygon in the 2d plane.
+     * @param p
+     * @param vertices Ordered polygon vertices
+     */
+    static inPolygon(p: Point, vertices: Point[]): any;
+    /**
+     * Checks whether a given point lies inside a polygon in the 2d plane.
+     * @param p
+     * @param vertices Ordered polygon vertices
+     * @param precision Precision roundoff, strongly recommended in case of quasi-aligned geometries. Default value: 12)
+     */
+    static inPolygon(p: Point, vertices: Point[], precision: number): any;
+    /**
+     * Returns the area of the polygon defined by the provided points.
+     * @param points Vertices of the polygon
+     */
+    static area(...points: Point[]): number;
+    static area(points: Point[]): number;
+    /**
+     * Convex hull of a set of points using the Andrew's monotone chain algorithm. O(n log n) time complexity.
+     * @param points Points to hull
+     * @returns Convex hull vertices in counter-clockwise order, starting from the leftmost one.
+     */
+    static convexHull(...points: Point[]): Point[];
+    static convexHull(points: Point[]): Point[];
+}
+
+declare class Utils3D {
+    /**
+     * Computes the intersection between a ray and a triangle in the 3D space - if any - using the Möller–Trumbore algorithm.
+     * @param ray Array of two points identifying a ray.
+     * @param triangle Array of three points identifying a triangle.
+     * @returns Intersection point if any, otherwise null.
+     */
+    static intersect(ray: Ray, triangle: [Point3D, Point3D, Point3D]): Point3D | null;
+}
+
+/** Utility tools about statistics, probability, data analysis... */
+declare class Utils_2 {
+    static sum<T>(set: T[], selector: NumericKeySelector<T>): number;
+    static sum(set: number[]): number;
+    static mean<T>(set: T[], selector: NumericKeySelector<T>): number;
+    static mean(set: number[]): number;
+    static median<T>(set: T[], selector: NumericKeySelector<T>): number;
+    static median(set: number[]): number;
+    static mode<T>(set: T[], selector: NumericKeySelector<T>): number;
+    static mode(set: number[]): number;
+    /**
+     * Variance of a sample set.
+     */
+    static var<T>(set: T[], selector: NumericKeySelector<T>): number;
+    static var(set: number[]): number;
+    /**
+     * Variance of the population.
+     */
+    static varp<T>(set: T[], selector: NumericKeySelector<T>): number;
+    static varp(set: number[]): number;
+    /**
+     * Standard deviation of the population.
+     */
+    static stdevp<T>(population: T[], selector: NumericKeySelector<T>): number;
+    static stdevp(population: number[]): number;
+    /**
+     * Standard deviation of a sample set.
+     */
+    static stdev<T>(set: T[], selector: NumericKeySelector<T>): number;
+    static stdev(set: number[]): number;
+    /**
+     * Pearson correlation coefficient.
+     */
+    static correlation(setX: number[], setY: number[]): number;
+    static correlation<X, Y>(setX: X[], setY: Y[], selectorX: NumericKeySelector<X>, selectorY: NumericKeySelector<Y>): number;
+    static correlation<T>(set: T[], selectorX: NumericKeySelector<T>, selectorY: NumericKeySelector<T>): number;
+    /**
+     * Linear regression gradient and intercept.
+     */
+    static linearRegression(setX: number[], setY: number[]): [number, number];
+    static linearRegression<X, Y>(setX: X[], setY: Y[], selectorX: NumericKeySelector<X>, selectorY: NumericKeySelector<Y>): [number, number];
+    static linearRegression(set: Point[]): [number, number];
+    static linearRegression<T>(set: T[], selectorX: NumericKeySelector<T>, selectorY: NumericKeySelector<T>): [number, number];
+    /**
+     * Returns a set of utilities for gaussian distribution computations.
+     * @param mean
+     * @param stdev
+     */
+    static gaussian(mean: number, stdev: number): Gaussian;
+}
+
+/** Utility tools about number theory, 'diophantine' stuff... */
+declare class Utils_3 {
+    static lcd(...args: number[]): number;
+    static gcd(a: number, b: number): any;
+    static rebaseInt(v: number | string, from: number, to: number): string;
+    static rebaseFloat(v: number | string, fromRadix: number, toRadix: number, precision?: number): string | number;
+    static rebaseFloatNTo10(v: string, radix: number, precision?: number): number;
+    static rebaseFloat10ToNIntBase(v: number, radix: number, precision?: number): string;
+    static rebaseFloat10ToN(v: number, radix: number, precision?: number): string;
+}
+
+/** Represents a vector in the 2D space */
+declare interface Vector extends Point {
+}
+
+/** 2D vector utils. */
+declare class Vector {
+    /**
+     * Returns the unit (normalized) vector having the same direction and sense of the provided one.
+     * @param v
+     */
+    static unit(v: Vector): Vector;
+    static magSqr(v: Vector): number;
+    static mag(v: Vector): number;
+    /**
+     * Normalizes the provided vector in place.
+     * @param v
+     */
+    static normalize(v: Vector): void;
+    /**
+     * Returns the vector joining two points.
+     * @param p1 Start point
+     * @param p2 End point
+     */
+    static from(p1: Point, p2: Point): Vector;
+    /**
+     * Returns the dot product between two vectors/points.
+     * @param v1
+     * @param v2
+     */
+    static dot(v1: Point, v2: Point): number;
+    /**
+     * Returns the cross product between two vectors/points (magnitude along the z axis).
+     * @param v1
+     * @param v2
+     */
+    static cross(v1: Point, v2: Point): number;
+    /**
+     * Checks if the two points are effectively the same location.
+     * @param v1 The first point.
+     * @param v2 The second point.
+     * @returns True if the points are considered coincident within tolerance; otherwise, false.
+     */
+    static areClose(v1: Point, v2: Point): boolean;
+}
+
+/** Represents a vector in the 3D space */
+declare interface Vector3D extends Point3D {
+}
+
+declare class Vector3D {
+    static from(...args: number[]): Vector3D;
+    static parse(input: string): Vector3D;
+    static i(): Vector3D;
+    static j(): Vector3D;
+    static k(): Vector3D;
+    static zero(): Vector3D;
+    /**
+     * Subtracts a point p from another and returns the resulting vector.
+     * @param p Point to subtract
+     * @param from Point to be subtracted from
+     */
+    static subtract(p: Point3D, from: Point3D): Point3D;
+    /**
+     * Adds a set of points together and returns the resulting vector.
+     * @param points Points to add
+     */
+    static add(...points: Point3D[]): Point3D;
+    /**
+     * Returns the dot product between two vectors/points.
+     * @param v1
+     * @param v2
+     */
+    static dot(v1: Point3D, v2: Point3D): number;
+    /**
+     * Returns the cross product between two vectors/points (as a vector itself).
+     * @param v1
+     * @param v2
+     */
+    static cross(v1: Point3D, v2: Point3D): Vector3D;
+    static scale(v: Vector3D, f: number): Vector3D;
+    static scale(v: Vector3D, fx: number, fy: number, fz: number): Vector3D;
+    static magSqr(v: Point3D): number;
+    /**
+     * Checks if the two points are effectively the same location.
+     * @param v1 The first point.
+     * @param v2 The second point.
+     * @returns True if the points are considered coincident within tolerance; otherwise, false.
+     */
+    static areClose(v1: Point3D, v2: Point3D): boolean;
+    static mag(v: Point3D): number;
+    static negate(v: Vector3D): Vector3D;
+    /**
+     * Returns the unit (normalized) vector having the same direction and sense of the provided one.
+     * @param v
+     */
+    static unit(v: Vector3D): Vector3D;
+    /**
+     * Normalizes the provided vector in place.
+     * @param v
+     */
+    static normalize(v: Vector3D): void;
+    /**
+     * Returns the angle (in degrees) between two vectors.
+     * @param vector1
+     * @param vector2
+     */
+    static angleBetween(vector1: Vector3D, vector2: Vector3D): number;
+}
+
+
+
+declare global {
+    namespace Pacem {
+        export {
+            DataAnalysis,
+            Geometry,
+            LinearAlgebra,
+            Mathematics,
+            NumberTheory
+        };
+    }
+}