// Type definitions for sylvester 0.1.3

// Project: https://github.com/jcoglan/sylvester

// Definitions by: Stephane Alie <https://github.com/StephaneAlie>

// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped

// === Sylvester ===

// Vector and Matrix mathematics modules for JavaScript

// Copyright (c) 2007 James Coglan

declare module Sylvester {

    interface VectorStatic {

        /**

         * Constructor function.

         */

        create(elements: Vector|Array<number>): Vector;

        i: Vector;

        j: Vector;

        k: Vector;

        /**

         * Random vector of size n.

         *

         * @param {number} n The vector size.

         */

        Random(n: number): Vector;

        /**

         * Vector filled with zeros.

         *

         * @param {number} n The vector size.

         */

        Zero(n: number): Vector;

    }

    interface MatrixStatic {

        /**

         * Constructor function.

         *

         * @param {Array<number>|Array<Array<number>>|Vector|Matrix} elements The elements.

         */

        create(elements: Array<number>|Array<Array<number>>|Vector | Matrix): Matrix;

        /**

         * Identity matrix of size n.

         *

         * @param {number} n The size.

         */

        I(n: number): Matrix;

        /**

         * Diagonal matrix - all off-diagonal elements are zero

         *

         * @param {any} elements The elements.

         */

        Diagonal(elements: Array<number>|Array<Array<number>>|Vector | Matrix): Matrix;

        /**

         * Rotation matrix about some axis. If no axis is supplied, assume we're after a 2D transform.

         *

         * @param {number} theta The angle in radians.

         * @param {Vector} a [Optional] The axis.

         */

        Rotation(theta: number, a?: Vector): Matrix;

        RotationX(t: number): Matrix;

        RotationY(t: number): Matrix;

        RotationZ(t: number): Matrix;

        /**

         * Random matrix of n rows, m columns.

         *

         * @param {number} n The number of rows.

         * @param {number} m The number of columns.

         */

        Random(n: number, m: number): Matrix;

        /**

         * Matrix filled with zeros.

         *

         * @param {number} n The number of rows.

         * @param {number} m The number of columns.

         */

        Zero(n: number, m: number): Matrix;

    }

    interface LineStatic {

        /**

         * Constructor function.

         *

         * @param Array<number>|Vector anchor The anchor vector.

         * @param Array<number>|Vector direction The direction vector.

         */

        create(anchor: Array<number>|Vector, direction: Array<number>|Vector): Line;

        X: Line;

        Y: Line;

        Z: Line;

    }

    interface PlaneStatic {

        /**

         * Constructor function.

         */

        create(anchor: Array<number>|Vector, normal: Array<number>|Vector): Plane;

        /**

         * Constructor function.

         */

        create(anchor: Array<number>|Vector, v1: Array<number>|Vector, v2: Array<number>|Vector): Plane;

        XY: Plane;

        YZ: Plane;

        ZX: Plane;

        YX: Plane;

    }

}

interface Vector {

    /**

     * Gets an array containing the vector's elements.

     */

    elements: Array<number>;

    /**

     * Returns element i of the vector.

     */

    e(i: number): number;

    /**

     * Returns the number of elements the vector has.

     */

    dimensions(): number;

    /**

     * Returns the modulus ('length') of the vector.

     */

    modulus(): number;

    /**

     * Returns true if the vector is equal to the argument.

     *

     * @param {Vector|Array<number>} vector The vector to compare equality.

     */

    eql(vector: Vector|Array<number>): boolean;

    /**

     * Returns a copy of the vector.

     */

    dup(): Vector;

    /**

     * Maps the vector to another vector according to the given function.

     *

     * @param {Function} fn The function to apply to each element (x, i) => {}.

     */

    map(fn: (x: number, i: number) => any): Vector;

    /**

     * Calls the iterator for each element of the vector in turn.

     *

     * @param {Function} fn The function to apply to each element (x, i) => {}.

     */

    each(fn: (x: number, i: number) => any): void;

    /**

     * Returns a new vector created by normalizing the receiver.

     */

    toUnitVector(): Vector;

    /**

     * Returns the angle between the vector and the argument (also a vector).

     *

     * @param {Vector} vector The other vector to calculate the angle.

     */

    angleFrom(vector: Vector): number;

    /**

     * Returns true if the vector is parallel to the argument.

     *

     * @param {Vector} vector The other vector.

     */

    isParallelTo(vector: Vector): boolean;

    /**

     * Returns true if the vector is antiparallel to the argument.

     *

     * @param {Vector} vector The other vector.

     */

    isAntiparallelTo(vector: Vector): boolean;

    /**

     * Returns true iff the vector is perpendicular to the argument.

     *

     * @param {Vector} vector The other vector.

     */

    isPerpendicularTo(vector: Vector): boolean;

    /**

     * Returns the result of adding the argument to the vector.

     *

     * @param {Vector|Array<number>} vector The vector.

     */

    add(vector: Vector|Array<number>): Vector;

    /**

     * Returns the result of subtracting the argument from the vector.

     *

     * @param {Vector|Array<number>} vector The vector.

     */

    subtract(vector: Vector|Array<number>): Vector;

    /**

     * Returns the result of multiplying the elements of the vector by the argument.

     *

     * @param {number} k The value by which to multiply the vector.

     */

    multiply(k: number): Vector;

    /**

     * Returns the result of multiplying the elements of the vector by the argument (Alias for multiply(k)).

     *

     * @param {number} k The value by which to multiply the vector.

     */

    x(k: number): Vector;

    /**

     * Returns the scalar product of the vector with the argument. Both vectors must have equal dimensionality.

     *

     * @param: {Vector|Array<number>} vector The other vector.

     */

    dot(vector: Vector|Array<number>): number;

    /**

     * Returns the vector product of the vector with the argument. Both vectors must have dimensionality 3.

     *

     * @param {Vector|Array<number>} vector The other vector.

     */

    cross(vector: Vector|Array<number>): Vector;

    /**

     * Returns the (absolute) largest element of the vector.

     */

    max(): number;

    /**

     * Returns the index of the first match found.

     *

     * @param {number} x The value.

     */

    indexOf(x: number): number;

    /**

     * Returns a diagonal matrix with the vector's elements as its diagonal elements.

     */

    toDiagonalMatrix(): Matrix;

    /**

     * Returns the result of rounding the elements of the vector.

     */

    round(): Vector;

    /**

     * Returns a copy of the vector with elements set to the given value if they differ from

     * it by less than Sylvester.precision.

     *

     * @param {number} x The value to snap to.

     */

    snapTo(x: number): Vector;

    /**

     * Returns the vector's distance from the argument, when considered as a point in space.

     *

     * @param {Vector|Line|Plane} obj The object to calculate the distance.

     */

    distanceFrom(obj: Vector|Line|Plane): number;

    /**

     * Returns true if the vector is point on the given line.

     *

     * @param {Line} line The line.

     */

    liesOn(line: Line): boolean;

    /**

     * Return true if the vector is a point in the given plane.

     *

     * @param {Plane} plane The plane.

     */

    liesIn(plane: Plane): boolean;

    /**

     * Rotates the vector about the given object. The object should be a point if the vector is 2D,

     * and a line if it is 3D. Be careful with line directions!

     *

     * @param {number|Matrix} t The angle in radians or in rotation matrix.

     * @param {Vector|Line} obj The rotation axis.

     */

    rotate(t: number|Matrix, obj: Vector|Line): Vector;

    /**

     * Returns the result of reflecting the point in the given point, line or plane.

     *

     * @param {Vector|Line|Plane} obj The object.

     */

    reflectionIn(obj: Vector|Line|Plane): Vector;

    /**

     * Utility to make sure vectors are 3D. If they are 2D, a zero z-component is added.

     */

    to3D(): Vector;

    /**

     * Returns a string representation of the vector.

     */

    inspect(): string;

    /**

     * Set vector's elements from an array.

     *

     * @param {Vector|Array<number>} els The elements.

     */

    setElements(els: Vector|Array<number>): Vector;

}

interface Matrix {

    /**

     * Gets a nested array containing the matrix's elements.

     */

    elements: Array<Array<number>>;

    /**

     * Returns element (i,j) of the matrix.

     *

     * @param {number} i The row index.

     * @param {number} j The column index.

     */

    e(i: number, j: number): any;

    /**

     * Returns row k of the matrix as a vector.

     *

     * @param {number} i The row index.

     */

    row(i: number): Vector;

    /**

     * Returns column k of the matrix as a vector.

     *

     * @param {number} j The column index.

     */

    col(j: number): Vector;

    /**

     * Returns the number of rows/columns the matrix has.

     *

     * @return {any} An object { rows: , cols: }.

     */

    dimensions(): any;

    /**

     * Returns the number of rows in the matrix.

     */

    rows(): number;

    /**

     * Returns the number of columns in the matrix.

     */

    cols(): number;

    /**

     * Returns true if the matrix is equal to the argument. You can supply a vector as the argument,

     * in which case the receiver must be a one-column matrix equal to the vector.

     *

     * @param {Vector|Matrix} matrix The argument to compare.

     */

    eql(matrix: Vector|Matrix): boolean;

    /**

     * Returns a copy of the matrix.

     */

    dup(): Matrix;

    /**

     * Maps the matrix to another matrix (of the same dimensions) according to the given function.

     *

     * @param {Function} fn The function.

     */

    map(fn: (x: number, i: number, j: number) => any): Matrix;

    /**

     * Returns true iff the argument has the same dimensions as the matrix.

     *

     * @param {Matrix} matrix The other matrix.

     */

    isSameSizeAs(matrix: Matrix): boolean;

    /**

     * Returns the result of adding the argument to the matrix.

     *

     * @param {Matrix} matrix The matrix to add.

     */

    add(matrix: Matrix): Matrix;

    /**

     * Returns the result of subtracting the argument from the matrix.

     *

     * @param {Matrix} matrix The matrix to substract.

     */

    subtract(matrix: Matrix): Matrix;

    /**

     * Returns true iff the matrix can multiply the argument from the left.

     *

     * @param {Matrix} matrix The matrix.

     */

    canMultiplyFromLeft(matrix: Matrix): boolean;

    /**

     * Returns the result of multiplying the matrix from the right by the argument. If the argument is a scalar

     * then just multiply all the elements. If the argument is a vector, a vector is returned, which saves you

     * having to remember calling col(1) on the result.

     *

     * @param {number|Matrix} matrix The multiplier.

     */

    multiply(matrix: number|Matrix): Matrix;

    /**

     * Returns the result of multiplying the matrix from the right by the argument. If the argument is a scalar

     * then just multiply all the elements. If the argument is a vector, a vector is returned, which saves you

     * having to remember calling col(1) on the result.

     *

     * @param {Vector} vector The multiplier.

     */

    multiply(vector: Vector): Vector;

    x(matrix: number|Matrix): Matrix;

    x(vector: Vector): Vector;

    /**

     * Returns a submatrix taken from the matrix. Argument order is: start row, start col, nrows, ncols.

     * Element selection wraps if the required index is outside the matrix's bounds, so you could use

     * this to perform row/column cycling or copy-augmenting.

     *

     * @param {number} a Starting row index.

     * @param {number} b Starting column index.

     * @param {number} c Number of rows.

     * @param {number} d Number of columns.

     */

    minor(a: number, b: number, c: number, d: number): Matrix;

    /**

     * Returns the transpose of the matrix.

     */

    transpose(): Matrix;

    /**

     * Returns true if the matrix is square.

     */

    isSquare(): boolean;

    /**

     * Returns the (absolute) largest element of the matrix.

     */

    max(): number;

    /**

     * Returns the indeces of the first match found by reading row-by-row from left to right.

     *

     * @param {number} x The value.

     *

     * @return {any} The element indeces i.e: { row:1, col:1 }

     */

    indexOf(x: number): any;

    /**

     * If the matrix is square, returns the diagonal elements as a vector; otherwise, returns null.

     */

    diagonal(): Vector;

    /**

     * Make the matrix upper (right) triangular by Gaussian elimination. This method only adds multiples

     * of rows to other rows. No rows are scaled up or switched, and the determinant is preserved.

     */

    toRightTriangular(): Matrix;

    toUpperTriangular(): Matrix;

    /**

     * Returns the determinant for square matrices.

     */

    determinant(): number;

    det(): number;

    /**

     * Returns true if the matrix is singular.

     */

    isSingular(): boolean;

    /**

     * Returns the trace for square matrices.

     */

    trace(): number;

    tr(): number;

    /**

     * Returns the rank of the matrix.

     */

    rank(): number;

    rk(): number;

    /**

     * Returns the result of attaching the given argument to the right-hand side of the matrix.

     *

     * @param {Matrix|Vector} matrix The matrix or vector.

     */

    augment(matrix: Matrix|Vector): Matrix;

    /**

     * Returns the inverse (if one exists) using Gauss-Jordan.

     */

    inverse(): Matrix;

    inv(): Matrix;

    /**

     * Returns the result of rounding all the elements.

     */

    round(): Matrix;

    /**

     * Returns a copy of the matrix with elements set to the given value if they differ from it

     * by less than Sylvester.precision.

     *

     * @param {number} x The value.

     */

    snapTo(x: number): Matrix;

    /**

     * Returns a string representation of the matrix.

     */

    inspect(): string;

    /**

     * Set the matrix's elements from an array. If the argument passed is a vector, the resulting matrix

     * will be a single column.

     *

     * @param {Array<number>|Array<Array<number>>|Vector|Matrix} matrix The elements.

     */

    setElements(matrix: Array<number>|Array<Array<number>>|Vector|Matrix): Matrix;

}

interface Line {

    /**

     * Gets the 3D vector corresponding to a point on the line.

     */

    anchor: Vector;

    /**

     * Gets a normalized 3D vector representing the line's direction.

     */

    direction: Vector;

    /**

     * Returns true if the argument occupies the same space as the line.

     *

     * @param {Line} line The other line.

     */

    eql(line: Line): boolean;

    /**

     * Returns a copy of the line.

     */

    dup(): Line;

    /**

     * Returns the result of translating the line by the given vector/array.

     *

     * @param {Vector|Array<number>} vector The translation vector.

     */

    translate(vector: Vector|Array<number>): Line;

    /**

     * Returns true if the line is parallel to the argument. Here, 'parallel to' means that the argument's

     * direction is either parallel or antiparallel to the line's own direction. A line is parallel to a

     * plane if the two do not have a unique intersection.

     *

     * @param {Line|Plane} obj The object.

     */

    isParallelTo(obj: Line|Plane): boolean;

    /**

     * Returns the line's perpendicular distance from the argument, which can be a point, a line or a plane.

     *

     * @param {Vector|Line|Plane} obj The object.

     */

    distanceFrom(obj: Vector|Line|Plane): number;

    /**

     * Returns true if the argument is a point on the line.

     *

     * @param {Vector} point The point.

     */

    contains(point: Vector): boolean;

    /**

     * Returns true if the line lies in the given plane.

     *

     * @param {Plane} plane The plane.

     */

    liesIn(plane: Plane): boolean;

    /**

     * Returns true if the line has a unique point of intersection with the argument.

     *

     * @param {Line|Plane} obj The object.

     */

    intersects(obj: Line|Plane): boolean;

    /**

     * Returns the unique intersection point with the argument, if one exists.

     *

     * @param {Line|Plane} obj The object.

     */

    intersectionWith(obj: Line|Plane): Vector;

    /**

     * Returns the point on the line that is closest to the given point or line.

     *

     * @param {Vector|Line} obj The object.

     */

    pointClosestTo(obj: Vector|Line): Vector;

    /**

     * Returns a copy of the line rotated by t radians about the given line. Works by finding the argument's

     * closest point to this line's anchor point (call this C) and rotating the anchor about C. Also rotates

     * the line's direction about the argument's. Be careful with this - the rotation axis' direction

     * affects the outcome!

     *

     * @param {number} t The angle in radians.

     * @param {Vector|Line} axis The axis.

     */

    rotate(t: number, axis: Vector|Line): Line;

    /**

     * Returns the line's reflection in the given point or line.

     *

     * @param {Vector|Line|Plane} obj The object.

     */

    reflectionIn(obj: Vector|Line|Plane): Line;

    /**

     * Set the line's anchor point and direction.

     *

     * @param {Array<number>|Vector} anchor The anchor vector.

     * @param {Array<number>|Vector} direction The direction vector.

     */

    setVectors(anchor: Array<number>|Vector, direction: Array<number>|Vector): Line;

}

interface Plane {

    /**

     * Gets the 3D vector corresponding to a point in the plane.

     */

    anchor: Vector;

    /**

     * Gets a normalized 3D vector perpendicular to the plane.

     */

    normal: Vector;

    /**

     * Returns true if the plane occupies the same space as the argument.

     *

     * @param {Plane} plane The other plane.

     */

    eql(plane: Plane): boolean;

    /**

     * Returns a copy of the plane.

     */

    dup(): Plane;

    /**

     * Returns the result of translating the plane by the given vector.

     *

     * @param {Array<number>|Vector} vector The translation vector.

     */

    translate(vector: Array<number>|Vector): Plane;

    /**

     * Returns true if the plane is parallel to the argument. Will return true if the planes are equal,

     * or if you give a line and it lies in the plane.

     *

     * @param {Line|Plane} obj The object.

     */

    isParallelTo(obj: Line|Plane): boolean;

    /**

     * Returns true if the receiver is perpendicular to the argument.

     *

     * @param {Plane} plane The other plane.

     */

    isPerpendicularTo(plane: Plane): boolean;

    /**

     * Returns the plane's distance from the given object (point, line or plane).

     *

     * @parm {Vector|Line|Plane} obj The object.

     */

    distanceFrom(obj: Vector|Line|Plane): number;

    /**

     * Returns true if the plane contains the given point or line.

     *

     * @param {Vector|Line} obj The object.

     */

    contains(obj: Vector|Line): boolean;

    /**

     * Returns true if the plane has a unique point/line of intersection with the argument.

     *

     * @param {Line|Plane} obj The object.

     */

    intersects(obj: Line|Plane): boolean;

    /**

     * Returns the unique intersection with the argument, if one exists.

     *

     * @param {Line} line The line.

     */

    intersectionWith(line: Line): Vector;

    /**

     * Returns the unique intersection with the argument, if one exists.

     *

     * @param {Plane} plane The plane.

     */

    intersectionWith(plane: Plane): Line;

    /**

     * Returns the point in the plane closest to the given point.

     *

     * @param {Vector} point The point.

     */

    pointClosestTo(point: Vector): Vector;

    /**

     * Returns a copy of the plane, rotated by t radians about the given line. See notes on Line#rotate.

     *

     * @param {number} t The angle in radians.

     * @param {Line} axis The line axis.

     */

    rotate(t: number, axis: Line): Plane;

    /**

     * Returns the reflection of the plane in the given point, line or plane.

     *

     * @param {Vector|Line|Plane} obj The object.

     */

    reflectionIn(obj: Vector|Line|Plane): Plane;

    /**

     * Sets the anchor point and normal to the plane. Normal vector is normalised before storage.

     *

     * @param {Array<number>|Vector} anchor The anchor vector.

     * @param {Array<number>|Vector} normal The normal vector.

     */

    setVectors(anchor: Array<number>|Vector, normal: Array<number>|Vector): Plane;

    /**

     * Sets the anchor point and normal to the plane. The normal is calculated by assuming the three points

     * should lie in the same plane. Normal vector is normalised before storage.

     *

     * @param {Array<number>|Vector} anchor The anchor vector.

     * @param {Array<number>|Vector} v1 The first direction vector.

     * @param {Array<number>|Vector} v2 The second direction vector.

     */

    setVectors(anchor: Array<number>|Vector, v1: Array<number>|Vector, v2: Array<number>|Vector): Plane;

}

declare module Sylvester {

    export var version: string;

    export var precision: number;

}

declare var Vector: Sylvester.VectorStatic;

declare var Matrix: Sylvester.MatrixStatic;

declare var Line: Sylvester.LineStatic;

declare var Plane: Sylvester.PlaneStatic;

/**

* Constructor function.

*

* @param {Vector|Array<number} elements The elements.

*/

declare function $V(elements: Vector|Array<number>): Vector;

/**

* Constructor function.

*

* @param {Array<number>|Array<Array<number>>|Vector|Matrix} elements The elements.

*/

declare function $M(elements: Array<number>|Array<Array<number>>|Vector | Matrix): Matrix;

/**

* Constructor function.

*

* @param Array<number>|Vector anchor The anchor vector.

* @param Array<number>|Vector direction The direction vector.

*/

declare function $L(anchor: Array<number>|Vector, direction: Array<number>|Vector): Line;

/**

* Constructor function.

*

* @param {Array<number>|Vector} anchor The anchor vector.

* @param {Array<number>|Vector} normal The normal vector.

*/

declare function $P(anchor: Array<number>|Vector, normal: Array<number>|Vector): Plane;

/**

 * Constructor function.

 *

 * @param {Array<number>|Vector} anchor The anchor vector.

 * @param {Array<number>|Vector} v1 The first direction vector.

 * @param {Array<number>|Vecotr} v2 The second direction vector.

 */

declare function $P(anchor: Array<number>|Vector, v1: Array<number>|Vector, v2: Array<number>|Vector): Plane;