oakscriptjs 0.8.1 → 0.9.0

package/dist/cjs/matrix/index.d.ts

@@ -0,0 +1,1231 @@
+/**
+ * Matrix namespace
+ * Mirrors PineScript's matrix.* functions
+ */
+import type { PineMatrix, PineArray, simple_int, int, bool, float } from '../types/index.js';
+/**
+ * Creates a new matrix
+ *
+ * @param rows - Number of rows
+ * @param columns - Number of columns
+ * @param initial_value - Initial value for all elements
+ * @returns A new matrix object
+ *
+ * @example
+ * ```typescript
+ * // Create a 2x3 matrix filled with zeros
+ * const m = matrix.new_matrix(2, 3, 0);
+ *
+ * // Create a 3x3 identity-like matrix
+ * const m2 = matrix.new_matrix(3, 3, 1);
+ * ```
+ */
+export declare function new_matrix<T>(rows: simple_int, columns: simple_int, initial_value?: T): PineMatrix<T>;
+/**
+ * Get element at position
+ *
+ * The function returns the element with the specified index of the matrix.
+ *
+ * @param id - A matrix object
+ * @param row - Index of the required row
+ * @param column - Index of the required column
+ * @returns The value of the element at the row and column index
+ *
+ * @remarks
+ * Indexing of the rows and columns starts at zero.
+ *
+ * @example
+ * ```typescript
+ * // Create a 2x3 matrix with value 5
+ * const m = matrix.new_matrix(2, 3, 5);
+ *
+ * // Get element at row 0, column 0
+ * const x = matrix.get(m, 0, 0); // Returns: 5
+ * ```
+ */
+export declare function get<T>(id: PineMatrix<T>, row: simple_int, column: simple_int): T;
+/**
+ * Set element at position
+ *
+ * The function assigns value to the element at the row and column of the matrix.
+ *
+ * @param id - A matrix object
+ * @param row - The row index of the element to be modified
+ * @param column - The column index of the element to be modified
+ * @param value - The new value to be set
+ *
+ * @remarks
+ * Indexing of the rows and columns starts at zero.
+ *
+ * @example
+ * ```typescript
+ * // Create a 2x3 matrix with value 4
+ * const m = matrix.new_matrix(2, 3, 4);
+ *
+ * // Replace value at row 0, column 1 with 3
+ * matrix.set(m, 0, 1, 3);
+ *
+ * // Now m[0][1] === 3
+ * ```
+ */
+export declare function set<T>(id: PineMatrix<T>, row: simple_int, column: simple_int, value: T): void;
+/**
+ * Get number of rows
+ *
+ * The function returns the number of rows in the matrix.
+ *
+ * @param id - A matrix object
+ * @returns The number of rows in the matrix
+ *
+ * @example
+ * ```typescript
+ * // Create a 2x6 matrix
+ * const m = matrix.new_matrix(2, 6, 0);
+ *
+ * // Get the quantity of rows
+ * const x = matrix.rows(m); // Returns: 2
+ * ```
+ */
+export declare function rows<T>(id: PineMatrix<T>): int;
+/**
+ * Get number of columns
+ *
+ * The function returns the number of columns in the matrix.
+ *
+ * @param id - A matrix object
+ * @returns The number of columns in the matrix
+ *
+ * @example
+ * ```typescript
+ * // Create a 2x6 matrix
+ * const m = matrix.new_matrix(2, 6, 0);
+ *
+ * // Get the quantity of columns
+ * const x = matrix.columns(m); // Returns: 6
+ * ```
+ */
+export declare function columns<T>(id: PineMatrix<T>): int;
+/**
+ * Get total number of elements
+ *
+ * The function returns the total number of all matrix elements.
+ *
+ * @param id - A matrix object
+ * @returns The total number of elements (rows * columns)
+ *
+ * @example
+ * ```typescript
+ * // Create a 3x4 matrix
+ * const m = matrix.new_matrix(3, 4, 0);
+ *
+ * // Get total element count
+ * const count = matrix.elements_count(m); // Returns: 12
+ * ```
+ */
+export declare function elements_count<T>(id: PineMatrix<T>): int;
+/**
+ * Get row as array
+ *
+ * The function creates a one-dimensional array from the elements of a matrix row.
+ *
+ * @param id - A matrix object
+ * @param row_index - Index of the required row
+ * @returns An array containing the values of the specified row
+ *
+ * @remarks
+ * Indexing of rows starts at 0.
+ * Returns a copy of the row data.
+ *
+ * @example
+ * ```typescript
+ * // Create a 2x3 matrix
+ * const m = matrix.new_matrix(2, 3, 5);
+ * matrix.set(m, 0, 0, 1);
+ * matrix.set(m, 0, 1, 2);
+ * matrix.set(m, 0, 2, 3);
+ *
+ * // Get the first row as an array
+ * const a = matrix.row(m, 0); // Returns: [1, 2, 3]
+ * ```
+ */
+export declare function row<T>(id: PineMatrix<T>, row_index: simple_int): PineArray<T>;
+/**
+ * Get column as array
+ *
+ * The function creates a one-dimensional array from the elements of a matrix column.
+ *
+ * @param id - A matrix object
+ * @param column_index - Index of the required column
+ * @returns An array containing the values of the specified column
+ *
+ * @remarks
+ * Indexing of columns starts at 0.
+ * Returns a copy of the column data.
+ *
+ * @example
+ * ```typescript
+ * // Create a 3x2 matrix
+ * const m = matrix.new_matrix(3, 2, 0);
+ * matrix.set(m, 0, 0, 1);
+ * matrix.set(m, 1, 0, 2);
+ * matrix.set(m, 2, 0, 3);
+ *
+ * // Get the first column as an array
+ * const a = matrix.col(m, 0); // Returns: [1, 2, 3]
+ * ```
+ */
+export declare function col<T>(id: PineMatrix<T>, column_index: simple_int): PineArray<T>;
+/**
+ * Create a deep copy of a matrix
+ *
+ * The function creates a new matrix which is a copy of the original.
+ *
+ * @param id - A matrix object to copy
+ * @returns A new matrix object that is a deep copy of the original
+ *
+ * @remarks
+ * Unlike a simple assignment operation which would only copy the reference,
+ * this function creates an actual copy of the matrix data.
+ *
+ * @example
+ * ```typescript
+ * // Create a 2x3 matrix with value 1
+ * const m1 = matrix.new_matrix(2, 3, 1);
+ *
+ * // Copy the matrix
+ * const m2 = matrix.copy(m1);
+ *
+ * // Modifying m2 will not affect m1
+ * matrix.set(m2, 0, 0, 99);
+ * // m1[0][0] is still 1
+ * // m2[0][0] is now 99
+ * ```
+ */
+export declare function copy<T>(id: PineMatrix<T>): PineMatrix<T>;
+/**
+ * Fill matrix with value
+ *
+ * The function fills a rectangular area of the matrix defined by the indices
+ * from_row to to_row (not including it) and from_column to to_column (not including it)
+ * with the specified value.
+ *
+ * @param id - A matrix object
+ * @param value - The value to fill with
+ * @param from_row - Row index from which the fill will begin (inclusive). Default: 0
+ * @param to_row - Row index where the fill will end (not inclusive). Default: matrix.rows
+ * @param from_column - Column index from which the fill will begin (inclusive). Default: 0
+ * @param to_column - Column index where the fill will end (not inclusive). Default: matrix.columns
+ *
+ * @example
+ * ```typescript
+ * // Create a 4x5 matrix with value 0
+ * const m = matrix.new_matrix(4, 5, 0);
+ *
+ * // Fill rows 0-1 and columns 1-2 with value 9
+ * matrix.fill(m, 9, 0, 2, 1, 3);
+ *
+ * // Result: positions [0,1], [0,2], [1,1], [1,2] are now 9
+ * ```
+ */
+export declare function fill<T>(id: PineMatrix<T>, value: T, from_row?: simple_int, to_row?: simple_int, from_column?: simple_int, to_column?: simple_int): void;
+/**
+ * Test if matrix is square
+ *
+ * The function determines if the matrix is square (it has the same number of rows and columns).
+ *
+ * @param id - Matrix object to test
+ * @returns true if the matrix is square, false otherwise
+ *
+ * @example
+ * ```typescript
+ * // Create a 3x3 square matrix
+ * const m1 = matrix.new_matrix(3, 3, 0);
+ * const isSquare1 = matrix.is_square(m1); // Returns: true
+ *
+ * // Create a 2x3 non-square matrix
+ * const m2 = matrix.new_matrix(2, 3, 0);
+ * const isSquare2 = matrix.is_square(m2); // Returns: false
+ * ```
+ */
+export declare function is_square<T>(id: PineMatrix<T>): bool;
+/**
+ * Test if matrix is a zero matrix
+ *
+ * The function determines if all elements of the matrix are zero.
+ *
+ * @param id - Matrix object to check (int/float)
+ * @returns true if all elements are zero, false otherwise
+ *
+ * @example
+ * ```typescript
+ * // Create a 2x2 zero matrix
+ * const m1 = matrix.new_matrix(2, 2, 0);
+ * const isZero1 = matrix.is_zero(m1); // Returns: true
+ *
+ * // Create a matrix with non-zero element
+ * const m2 = matrix.new_matrix(2, 2, 0);
+ * matrix.set(m2, 0, 0, 1);
+ * const isZero2 = matrix.is_zero(m2); // Returns: false
+ * ```
+ */
+export declare function is_zero(id: PineMatrix<float>): bool;
+/**
+ * Test if matrix is binary
+ *
+ * The function determines if the matrix is binary (when all elements are 0 or 1).
+ *
+ * @param id - Matrix object to test (int/float)
+ * @returns true if the matrix is binary, false otherwise
+ *
+ * @example
+ * ```typescript
+ * // Create a binary matrix
+ * const m1 = matrix.new_matrix(2, 2, 0);
+ * matrix.set(m1, 0, 0, 1);
+ * matrix.set(m1, 1, 1, 1);
+ * const isBinary1 = matrix.is_binary(m1); // Returns: true
+ *
+ * // Create a non-binary matrix
+ * const m2 = matrix.new_matrix(2, 2, 0);
+ * matrix.set(m2, 0, 0, 2);
+ * const isBinary2 = matrix.is_binary(m2); // Returns: false
+ * ```
+ */
+export declare function is_binary(id: PineMatrix<float>): bool;
+/**
+ * Add row to matrix
+ *
+ * Inserts a new row at the specified index of the matrix.
+ *
+ * @param id - A matrix object
+ * @param row - Optional. The index of the new row. Must be a value from 0 to matrix.rows(id).
+ *              All existing rows with indices >= this value increase their index by one.
+ *              Default is matrix.rows(id) (append at end).
+ * @param array_id - Optional. An array to use as the new row. If the matrix is empty, the array
+ *                   can be of any size. Otherwise, its size must equal matrix.columns(id).
+ *                   By default, inserts a row of undefined values.
+ *
+ * @remarks
+ * Indexing of rows starts at zero.
+ * Rather than add rows to an empty matrix, it is far more efficient to declare a matrix
+ * with explicit dimensions and fill it with values.
+ *
+ * @example
+ * ```typescript
+ * // Create a 2x3 matrix with zeros
+ * const m = matrix.new_matrix(2, 3, 0);
+ *
+ * // Add a row at the end with default values
+ * matrix.add_row(m);
+ *
+ * // Add an array as the first row
+ * const arr = [1, 2, 3];
+ * matrix.add_row(m, 0, arr);
+ * ```
+ */
+export declare function add_row<T>(id: PineMatrix<T>, row?: simple_int, array_id?: PineArray<T>): void;
+/**
+ * Add column to matrix
+ *
+ * Inserts a new column at the specified index of the matrix.
+ *
+ * @param id - A matrix object
+ * @param column - Optional. The index of the new column. Must be a value from 0 to matrix.columns(id).
+ *                 All existing columns with indices >= this value increase their index by one.
+ *                 Default is matrix.columns(id) (append at end).
+ * @param array_id - Optional. An array to use as the new column. If the matrix is empty, the array
+ *                   can be of any size. Otherwise, its size must equal matrix.rows(id).
+ *                   By default, inserts a column of undefined values.
+ *
+ * @remarks
+ * Rather than add columns to an empty matrix, it is far more efficient to declare a matrix
+ * with explicit dimensions and fill it with values. Adding a column is also much slower
+ * than adding a row with matrix.add_row().
+ *
+ * @example
+ * ```typescript
+ * // Create a 2x3 matrix with zeros
+ * const m = matrix.new_matrix(2, 3, 0);
+ *
+ * // Add a column at the end with default values
+ * matrix.add_col(m);
+ *
+ * // Add an array as the first column
+ * const arr = [1, 2];
+ * matrix.add_col(m, 0, arr);
+ * ```
+ */
+export declare function add_col<T>(id: PineMatrix<T>, column?: simple_int, array_id?: PineArray<T>): void;
+/**
+ * Remove row from matrix
+ *
+ * Removes the row at the specified index and returns an array containing the removed row's values.
+ *
+ * @param id - A matrix object
+ * @param row - Optional. The index of the row to be deleted.
+ *              Default is matrix.rows(id) - 1 (last row).
+ * @returns An array containing the elements of the removed row
+ *
+ * @remarks
+ * Indexing of rows starts at zero.
+ * It is far more efficient to declare matrices with explicit dimensions than to build them
+ * by adding or removing rows.
+ *
+ * @example
+ * ```typescript
+ * // Create a 2x2 matrix
+ * const m = matrix.new_matrix(2, 2, 1);
+ * matrix.set(m, 0, 1, 2);
+ * matrix.set(m, 1, 0, 3);
+ * matrix.set(m, 1, 1, 4);
+ *
+ * // Remove the first row
+ * const arr = matrix.remove_row(m, 0); // Returns: [1, 2]
+ * // Matrix now has 1 row
+ * ```
+ */
+export declare function remove_row<T>(id: PineMatrix<T>, row?: simple_int): PineArray<T>;
+/**
+ * Remove column from matrix
+ *
+ * Removes the column at the specified index and returns an array containing the removed column's values.
+ *
+ * @param id - A matrix object
+ * @param column - Optional. The index of the column to be removed.
+ *                 Default is matrix.columns(id) - 1 (last column).
+ * @returns An array containing the elements of the removed column
+ *
+ * @remarks
+ * Indexing of columns starts at zero.
+ * It is far more efficient to declare matrices with explicit dimensions than to build them
+ * by adding or removing columns. Deleting a column is also much slower than deleting a row
+ * with matrix.remove_row().
+ *
+ * @example
+ * ```typescript
+ * // Create a 2x2 matrix
+ * const m = matrix.new_matrix(2, 2, 1);
+ * matrix.set(m, 0, 1, 2);
+ * matrix.set(m, 1, 0, 3);
+ * matrix.set(m, 1, 1, 4);
+ *
+ * // Remove the first column
+ * const arr = matrix.remove_col(m, 0); // Returns: [1, 3]
+ * // Matrix now has 1 column
+ * ```
+ */
+export declare function remove_col<T>(id: PineMatrix<T>, column?: simple_int): PineArray<T>;
+/**
+ * Swap two rows
+ *
+ * Swaps the rows at the index row1 and row2 in the matrix.
+ *
+ * @param id - A matrix object
+ * @param row1 - Index of the first row to be swapped
+ * @param row2 - Index of the second row to be swapped
+ *
+ * @remarks
+ * Indexing of rows starts at zero.
+ *
+ * @example
+ * ```typescript
+ * // Create a 3x2 matrix
+ * const m = matrix.new_matrix(3, 2, 0);
+ * matrix.set(m, 0, 0, 1); matrix.set(m, 0, 1, 2);
+ * matrix.set(m, 1, 0, 3); matrix.set(m, 1, 1, 4);
+ * matrix.set(m, 2, 0, 5); matrix.set(m, 2, 1, 6);
+ *
+ * // Swap first and second rows
+ * matrix.swap_rows(m, 0, 1);
+ * // Now row 0 is [3, 4] and row 1 is [1, 2]
+ * ```
+ */
+export declare function swap_rows<T>(id: PineMatrix<T>, row1: simple_int, row2: simple_int): void;
+/**
+ * Swap two columns
+ *
+ * Swaps the columns at the index column1 and column2 in the matrix.
+ *
+ * @param id - A matrix object
+ * @param column1 - Index of the first column to be swapped
+ * @param column2 - Index of the second column to be swapped
+ *
+ * @remarks
+ * Indexing of columns starts at zero.
+ *
+ * @example
+ * ```typescript
+ * // Create a 2x2 matrix
+ * const m = matrix.new_matrix(2, 2, 0);
+ * matrix.set(m, 0, 0, 1); matrix.set(m, 0, 1, 2);
+ * matrix.set(m, 1, 0, 3); matrix.set(m, 1, 1, 4);
+ *
+ * // Swap first and second columns
+ * matrix.swap_columns(m, 0, 1);
+ * // Now column 0 is [2, 4] and column 1 is [1, 3]
+ * ```
+ */
+export declare function swap_columns<T>(id: PineMatrix<T>, column1: simple_int, column2: simple_int): void;
+/**
+ * Matrix transpose
+ *
+ * Creates a new, transposed version of the matrix. This interchanges the row and column
+ * index of each element.
+ *
+ * @param id - A matrix object
+ * @returns A new matrix containing the transposed version
+ *
+ * @example
+ * ```typescript
+ * // Create a 2x3 matrix
+ * const m1 = matrix.new_matrix(2, 3, 0);
+ * matrix.set(m1, 0, 0, 1); matrix.set(m1, 0, 1, 2); matrix.set(m1, 0, 2, 3);
+ * matrix.set(m1, 1, 0, 4); matrix.set(m1, 1, 1, 5); matrix.set(m1, 1, 2, 6);
+ *
+ * // Transpose to get a 3x2 matrix
+ * const m2 = matrix.transpose(m1);
+ * // m2 = [[1, 4], [2, 5], [3, 6]]
+ * ```
+ */
+export declare function transpose<T>(id: PineMatrix<T>): PineMatrix<T>;
+/**
+ * Concatenate matrices
+ *
+ * Appends the rows of m2 matrix to m1 matrix (vertical concatenation).
+ *
+ * @param id1 - Matrix object to concatenate into
+ * @param id2 - Matrix object whose rows will be appended to id1
+ * @returns Returns the id1 matrix concatenated with the id2 matrix
+ *
+ * @remarks
+ * The number of columns in both matrices must be identical.
+ *
+ * @example
+ * ```typescript
+ * // Create two 2x4 matrices
+ * const m1 = matrix.new_matrix(2, 4, 0);
+ * const m2 = matrix.new_matrix(2, 4, 1);
+ *
+ * // Append m2 to m1
+ * matrix.concat(m1, m2);
+ * // m1 is now 4x4
+ * ```
+ */
+export declare function concat<T>(id1: PineMatrix<T>, id2: PineMatrix<T>): PineMatrix<T>;
+/**
+ * Extract submatrix
+ *
+ * Extracts a submatrix from the matrix within the specified indices.
+ *
+ * @param id - A matrix object
+ * @param from_row - Row index from which extraction begins (inclusive). Default: 0
+ * @param to_row - Row index where extraction ends (exclusive). Default: matrix.rows(id)
+ * @param from_column - Column index from which extraction begins (inclusive). Default: 0
+ * @param to_column - Column index where extraction ends (exclusive). Default: matrix.columns(id)
+ * @returns A new matrix object containing the submatrix
+ *
+ * @remarks
+ * Indexing of rows and columns starts at zero.
+ *
+ * @example
+ * ```typescript
+ * // Create a 2x3 matrix
+ * const m1 = matrix.new_matrix(2, 3, 0);
+ * matrix.set(m1, 0, 0, 1); matrix.set(m1, 0, 1, 2); matrix.set(m1, 0, 2, 3);
+ * matrix.set(m1, 1, 0, 4); matrix.set(m1, 1, 1, 5); matrix.set(m1, 1, 2, 6);
+ *
+ * // Extract a 2x2 submatrix (columns 1-2)
+ * const m2 = matrix.submatrix(m1, 0, 2, 1, 3);
+ * // m2 = [[2, 3], [5, 6]]
+ * ```
+ */
+export declare function submatrix<T>(id: PineMatrix<T>, from_row?: simple_int, to_row?: simple_int, from_column?: simple_int, to_column?: simple_int): PineMatrix<T>;
+/**
+ * Reshape matrix
+ *
+ * Rebuilds the matrix to new dimensions. The total number of elements must remain the same.
+ *
+ * @param id - A matrix object
+ * @param rows - The number of rows of the reshaped matrix
+ * @param columns - The number of columns of the reshaped matrix
+ *
+ * @remarks
+ * The product of rows * columns must equal the current element count.
+ * Elements are read row by row and placed in the new shape row by row.
+ *
+ * @example
+ * ```typescript
+ * // Create a 2x3 matrix
+ * const m = matrix.new_matrix(2, 3, 0);
+ * matrix.set(m, 0, 0, 1); matrix.set(m, 0, 1, 2); matrix.set(m, 0, 2, 3);
+ * matrix.set(m, 1, 0, 4); matrix.set(m, 1, 1, 5); matrix.set(m, 1, 2, 6);
+ *
+ * // Reshape to 3x2
+ * matrix.reshape(m, 3, 2);
+ * // m = [[1, 2], [3, 4], [5, 6]]
+ * ```
+ */
+export declare function reshape<T>(id: PineMatrix<T>, rows: simple_int, columns: simple_int): void;
+/**
+ * Reverse matrix
+ *
+ * Reverses the order of rows and columns in the matrix. The first row and first column
+ * become the last, and the last become the first.
+ *
+ * @param id - A matrix object
+ *
+ * @remarks
+ * This modifies the matrix in place. Both rows and columns are reversed.
+ *
+ * @example
+ * ```typescript
+ * // Create a 2x2 matrix
+ * const m = matrix.new_matrix(2, 2, 0);
+ * matrix.set(m, 0, 0, 1); matrix.set(m, 0, 1, 2);
+ * matrix.set(m, 1, 0, 3); matrix.set(m, 1, 1, 4);
+ *
+ * // Reverse the matrix
+ * matrix.reverse(m);
+ * // m = [[4, 3], [2, 1]]
+ * ```
+ */
+export declare function reverse<T>(id: PineMatrix<T>): void;
+/**
+ * Sort matrix by column
+ *
+ * Rearranges the rows in the matrix following the sorted order of values in the specified column.
+ *
+ * @param id - A matrix object to be sorted
+ * @param column - Index of the column whose values determine the new order of rows. Default: 0
+ * @param order - The sort order: 'ascending' or 'descending'. Default: 'ascending'
+ *
+ * @remarks
+ * This modifies the matrix in place.
+ *
+ * @example
+ * ```typescript
+ * // Create a 2x2 matrix
+ * const m = matrix.new_matrix(2, 2, 0);
+ * matrix.set(m, 0, 0, 3); matrix.set(m, 0, 1, 4);
+ * matrix.set(m, 1, 0, 1); matrix.set(m, 1, 1, 2);
+ *
+ * // Sort by first column (ascending)
+ * matrix.sort(m);
+ * // m = [[1, 2], [3, 4]]
+ * ```
+ */
+export declare function sort<T extends number | string>(id: PineMatrix<T>, column?: simple_int, order?: 'ascending' | 'descending'): void;
+/**
+ * Matrix addition (sum)
+ *
+ * Returns a new matrix resulting from the element-wise sum of two matrices,
+ * or of a matrix and a scalar.
+ *
+ * @param id1 - First matrix object
+ * @param id2 - Second matrix object, or scalar value
+ * @returns A new matrix containing the sum
+ *
+ * @remarks
+ * When adding two matrices, they must have the same dimensions.
+ *
+ * @example
+ * ```typescript
+ * // Sum of two matrices
+ * const m1 = matrix.new_matrix(2, 3, 5);
+ * const m2 = matrix.new_matrix(2, 3, 4);
+ * const m3 = matrix.sum(m1, m2); // All elements are 9
+ *
+ * // Sum of matrix and scalar
+ * const m4 = matrix.new_matrix(2, 3, 4);
+ * const m5 = matrix.sum(m4, 1); // All elements are 5
+ * ```
+ */
+export declare function sum(id1: PineMatrix<float>, id2: PineMatrix<float> | float): PineMatrix<float>;
+/**
+ * Matrix subtraction (diff)
+ *
+ * Returns a new matrix resulting from the element-wise subtraction between two matrices,
+ * or of a matrix and a scalar.
+ *
+ * @param id1 - Matrix to subtract from
+ * @param id2 - Matrix object or scalar value to be subtracted
+ * @returns A new matrix containing the difference
+ *
+ * @remarks
+ * When subtracting two matrices, they must have the same dimensions.
+ *
+ * @example
+ * ```typescript
+ * // Difference between two matrices
+ * const m1 = matrix.new_matrix(2, 3, 5);
+ * const m2 = matrix.new_matrix(2, 3, 4);
+ * const m3 = matrix.diff(m1, m2); // All elements are 1
+ *
+ * // Difference between matrix and scalar
+ * const m4 = matrix.new_matrix(2, 3, 4);
+ * const m5 = matrix.diff(m4, 1); // All elements are 3
+ * ```
+ */
+export declare function diff(id1: PineMatrix<float>, id2: PineMatrix<float> | float): PineMatrix<float>;
+/**
+ * Average of all elements
+ *
+ * Calculates the average of all elements in the matrix.
+ *
+ * @param id - A matrix object
+ * @returns The average value from the matrix
+ *
+ * @example
+ * ```typescript
+ * // Create a 2x2 matrix
+ * const m = matrix.new_matrix(2, 2, 0);
+ * matrix.set(m, 0, 0, 1); matrix.set(m, 0, 1, 2);
+ * matrix.set(m, 1, 0, 3); matrix.set(m, 1, 1, 4);
+ *
+ * const avg = matrix.avg(m); // Returns: 2.5
+ * ```
+ */
+export declare function avg(id: PineMatrix<float>): float;
+/**
+ * Minimum element
+ *
+ * Returns the smallest value from the matrix elements.
+ *
+ * @param id - A matrix object
+ * @returns The smallest value from the matrix
+ *
+ * @example
+ * ```typescript
+ * // Create a 2x2 matrix
+ * const m = matrix.new_matrix(2, 2, 0);
+ * matrix.set(m, 0, 0, 1); matrix.set(m, 0, 1, 2);
+ * matrix.set(m, 1, 0, 3); matrix.set(m, 1, 1, 4);
+ *
+ * const minVal = matrix.min(m); // Returns: 1
+ * ```
+ */
+export declare function min(id: PineMatrix<float>): float;
+/**
+ * Maximum element
+ *
+ * Returns the largest value from the matrix elements.
+ *
+ * @param id - A matrix object
+ * @returns The largest value from the matrix
+ *
+ * @example
+ * ```typescript
+ * // Create a 2x2 matrix
+ * const m = matrix.new_matrix(2, 2, 0);
+ * matrix.set(m, 0, 0, 1); matrix.set(m, 0, 1, 2);
+ * matrix.set(m, 1, 0, 3); matrix.set(m, 1, 1, 4);
+ *
+ * const maxVal = matrix.max(m); // Returns: 4
+ * ```
+ */
+export declare function max(id: PineMatrix<float>): float;
+/**
+ * Median element
+ *
+ * Calculates the median ("the middle" value) of matrix elements.
+ *
+ * @param id - A matrix object
+ * @returns The median value from the matrix
+ *
+ * @remarks
+ * NA elements of the matrix are not considered when calculating the median.
+ *
+ * @example
+ * ```typescript
+ * // Create a 2x2 matrix
+ * const m = matrix.new_matrix(2, 2, 0);
+ * matrix.set(m, 0, 0, 1); matrix.set(m, 0, 1, 2);
+ * matrix.set(m, 1, 0, 3); matrix.set(m, 1, 1, 4);
+ *
+ * const medianVal = matrix.median(m); // Returns: 2.5
+ * ```
+ */
+export declare function median(id: PineMatrix<float>): float;
+/**
+ * Mode (most frequent element)
+ *
+ * Calculates the mode of the matrix, which is the most frequently occurring value.
+ * When there are multiple values occurring equally frequently, returns the smallest.
+ *
+ * @param id - A matrix object
+ * @returns The most frequently occurring value, or the smallest if tie
+ *
+ * @remarks
+ * NA elements of the matrix are not considered when calculating the mode.
+ *
+ * @example
+ * ```typescript
+ * // Create a 2x2 matrix
+ * const m = matrix.new_matrix(2, 2, 0);
+ * matrix.set(m, 0, 0, 0); matrix.set(m, 0, 1, 0);
+ * matrix.set(m, 1, 0, 1); matrix.set(m, 1, 1, 1);
+ *
+ * const modeVal = matrix.mode(m); // Returns: 0 (tie, so smallest)
+ * ```
+ */
+export declare function mode(id: PineMatrix<float>): float;
+/**
+ * Matrix trace
+ *
+ * Calculates the trace of a matrix (the sum of the main diagonal's elements).
+ *
+ * @param id - A matrix object (must be square)
+ * @returns The trace of the matrix
+ *
+ * @remarks
+ * The matrix must be square. Throws an error for non-square matrices.
+ *
+ * @example
+ * ```typescript
+ * // Create a 2x2 matrix
+ * const m = matrix.new_matrix(2, 2, 0);
+ * matrix.set(m, 0, 0, 1); matrix.set(m, 0, 1, 2);
+ * matrix.set(m, 1, 0, 3); matrix.set(m, 1, 1, 4);
+ *
+ * const tr = matrix.trace(m); // Returns: 5 (1 + 4)
+ * ```
+ */
+export declare function trace(id: PineMatrix<float>): float;
+/**
+ * Test if diagonal matrix
+ *
+ * Determines if the matrix is diagonal (all elements outside the main diagonal are zero).
+ *
+ * @param id - Matrix object to test
+ * @returns true if the matrix is diagonal, false otherwise
+ *
+ * @remarks
+ * Returns false with non-square matrices.
+ *
+ * @example
+ * ```typescript
+ * // Create a diagonal matrix
+ * const m = matrix.new_matrix(3, 3, 0);
+ * matrix.set(m, 0, 0, 1);
+ * matrix.set(m, 1, 1, 2);
+ * matrix.set(m, 2, 2, 3);
+ *
+ * const isDiag = matrix.is_diagonal(m); // Returns: true
+ * ```
+ */
+export declare function is_diagonal(id: PineMatrix<float>): bool;
+/**
+ * Test if identity matrix
+ *
+ * Determines if a matrix is an identity matrix (elements with ones on the main diagonal
+ * and zeros elsewhere).
+ *
+ * @param id - Matrix object to test
+ * @returns true if id is an identity matrix, false otherwise
+ *
+ * @remarks
+ * Returns false with non-square matrices.
+ *
+ * @example
+ * ```typescript
+ * // Create an identity matrix
+ * const m = matrix.new_matrix(3, 3, 0);
+ * matrix.set(m, 0, 0, 1);
+ * matrix.set(m, 1, 1, 1);
+ * matrix.set(m, 2, 2, 1);
+ *
+ * const isIdent = matrix.is_identity(m); // Returns: true
+ * ```
+ */
+export declare function is_identity(id: PineMatrix<float>): bool;
+/**
+ * Test if symmetric matrix
+ *
+ * Determines if a square matrix is symmetric (elements are symmetric with respect
+ * to the main diagonal, i.e., matrix equals its transpose).
+ *
+ * @param id - Matrix object to test
+ * @returns true if the matrix is symmetric, false otherwise
+ *
+ * @remarks
+ * Returns false with non-square matrices.
+ *
+ * @example
+ * ```typescript
+ * // Create a symmetric matrix
+ * const m = matrix.new_matrix(3, 3, 0);
+ * matrix.set(m, 0, 0, 1); matrix.set(m, 0, 1, 2); matrix.set(m, 0, 2, 3);
+ * matrix.set(m, 1, 0, 2); matrix.set(m, 1, 1, 4); matrix.set(m, 1, 2, 5);
+ * matrix.set(m, 2, 0, 3); matrix.set(m, 2, 1, 5); matrix.set(m, 2, 2, 6);
+ *
+ * const isSym = matrix.is_symmetric(m); // Returns: true
+ * ```
+ */
+export declare function is_symmetric(id: PineMatrix<float>): bool;
+/**
+ * Test if antisymmetric (skew-symmetric) matrix
+ *
+ * Determines if a matrix is antisymmetric (its transpose equals its negative).
+ * A[i][j] = -A[j][i] for all i, j, and diagonal elements must be 0.
+ *
+ * @param id - Matrix object to test
+ * @returns true if the matrix is antisymmetric, false otherwise
+ *
+ * @remarks
+ * Returns false with non-square matrices.
+ *
+ * @example
+ * ```typescript
+ * // Create an antisymmetric matrix
+ * const m = matrix.new_matrix(3, 3, 0);
+ * matrix.set(m, 0, 1, 2);  matrix.set(m, 0, 2, -1);
+ * matrix.set(m, 1, 0, -2); matrix.set(m, 1, 2, 3);
+ * matrix.set(m, 2, 0, 1);  matrix.set(m, 2, 1, -3);
+ *
+ * const isAntiSym = matrix.is_antisymmetric(m); // Returns: true
+ * ```
+ */
+export declare function is_antisymmetric(id: PineMatrix<float>): bool;
+/**
+ * Test if triangular matrix
+ *
+ * Determines if the matrix is triangular (if all elements above or below the main
+ * diagonal are zero).
+ *
+ * @param id - Matrix object to test
+ * @returns true if the matrix is triangular (upper or lower), false otherwise
+ *
+ * @remarks
+ * Returns false with non-square matrices.
+ * Returns true if the matrix is either upper triangular or lower triangular.
+ *
+ * @example
+ * ```typescript
+ * // Create an upper triangular matrix
+ * const m = matrix.new_matrix(3, 3, 0);
+ * matrix.set(m, 0, 0, 1); matrix.set(m, 0, 1, 2); matrix.set(m, 0, 2, 3);
+ * matrix.set(m, 1, 1, 4); matrix.set(m, 1, 2, 5);
+ * matrix.set(m, 2, 2, 6);
+ *
+ * const isTri = matrix.is_triangular(m); // Returns: true
+ * ```
+ */
+export declare function is_triangular(id: PineMatrix<float>): bool;
+/**
+ * Test if antidiagonal matrix
+ *
+ * Determines if the matrix is anti-diagonal (all elements outside the secondary
+ * diagonal are zero).
+ *
+ * @param id - Matrix object to test
+ * @returns true if the matrix is anti-diagonal, false otherwise
+ *
+ * @remarks
+ * Returns false with non-square matrices.
+ * The anti-diagonal runs from top-right to bottom-left.
+ *
+ * @example
+ * ```typescript
+ * // Create an antidiagonal matrix
+ * const m = matrix.new_matrix(3, 3, 0);
+ * matrix.set(m, 0, 2, 1);
+ * matrix.set(m, 1, 1, 2);
+ * matrix.set(m, 2, 0, 3);
+ *
+ * const isAntiDiag = matrix.is_antidiagonal(m); // Returns: true
+ * ```
+ */
+export declare function is_antidiagonal(id: PineMatrix<float>): bool;
+/**
+ * Test if stochastic matrix
+ *
+ * Determines if the matrix is stochastic (all elements are non-negative and all
+ * row sums equal 1).
+ *
+ * @param id - Matrix object to test
+ * @returns true if the matrix is stochastic, false otherwise
+ *
+ * @remarks
+ * A right stochastic matrix has rows that sum to 1.
+ *
+ * @example
+ * ```typescript
+ * // Create a stochastic matrix
+ * const m = matrix.new_matrix(2, 2, 0);
+ * matrix.set(m, 0, 0, 0.5); matrix.set(m, 0, 1, 0.5);
+ * matrix.set(m, 1, 0, 0.3); matrix.set(m, 1, 1, 0.7);
+ *
+ * const isStoch = matrix.is_stochastic(m); // Returns: true
+ * ```
+ */
+export declare function is_stochastic(id: PineMatrix<float>): bool;
+/**
+ * Matrix multiplication
+ *
+ * Returns a new matrix resulting from the product between two matrices,
+ * or between a matrix and a scalar, or between a matrix and a vector (array).
+ *
+ * @param id1 - First matrix object
+ * @param id2 - Second matrix object, scalar value, or array (vector)
+ * @returns A new matrix containing the product, or array for matrix × vector
+ *
+ * @remarks
+ * For matrix × matrix: id1's columns must equal id2's rows.
+ * For matrix × vector: the array length must equal id1's columns.
+ * Time complexity: O(n³) for n×n matrices.
+ *
+ * @example
+ * ```typescript
+ * // Product of two matrices
+ * const m1 = matrix.new_matrix(6, 2, 5);
+ * const m2 = matrix.new_matrix(2, 3, 4);
+ * const m3 = matrix.mult(m1, m2); // 6x3 matrix with values 40
+ *
+ * // Product of matrix and scalar
+ * const m4 = matrix.new_matrix(2, 3, 4);
+ * const m5 = matrix.mult(m4, 5); // All elements are 20
+ *
+ * // Product of matrix and vector
+ * const m6 = matrix.new_matrix(2, 3, 4);
+ * const arr = [1, 1, 1];
+ * const result = matrix.mult(m6, arr); // [12, 12]
+ * ```
+ */
+export declare function mult(id1: PineMatrix<float>, id2: PineMatrix<float> | float | PineArray<float>): PineMatrix<float> | PineArray<float>;
+/**
+ * Matrix power
+ *
+ * Calculates the product of the matrix by itself 'power' times.
+ * Uses repeated squaring for efficiency: O(n³ log p) for n×n matrix and power p.
+ *
+ * @param id - A matrix object (must be square)
+ * @param power - The number of times the matrix will be multiplied by itself
+ * @returns A new matrix that is id raised to the specified power
+ *
+ * @remarks
+ * The matrix must be square.
+ * power=0 returns the identity matrix.
+ * Negative powers compute the inverse first, then raise to the positive power.
+ *
+ * @example
+ * ```typescript
+ * // Create a 2x2 matrix
+ * const m1 = matrix.new_matrix(2, 2, 2);
+ * // Calculate the power of three
+ * const m2 = matrix.pow(m1, 3);
+ * // m2 = m1 × m1 × m1
+ * ```
+ */
+export declare function pow(id: PineMatrix<float>, power: int): PineMatrix<float>;
+/**
+ * Matrix determinant
+ *
+ * Computes the determinant of a square matrix using LU decomposition
+ * with partial pivoting.
+ *
+ * @param id - A matrix object (must be square)
+ * @returns The determinant value
+ *
+ * @remarks
+ * Function calculation based on the LU decomposition algorithm.
+ * Time complexity: O(n³)
+ *
+ * @example
+ * ```typescript
+ * // Create a 2x2 matrix
+ * const m = matrix.new_matrix(2, 2, NaN);
+ * matrix.set(m, 0, 0, 3);
+ * matrix.set(m, 0, 1, 7);
+ * matrix.set(m, 1, 0, 1);
+ * matrix.set(m, 1, 1, -4);
+ *
+ * const d = matrix.det(m); // Returns: -19
+ * ```
+ */
+export declare function det(id: PineMatrix<float>): float;
+/**
+ * Matrix inverse
+ *
+ * Computes the inverse of a square matrix using Gauss-Jordan elimination
+ * with partial pivoting.
+ *
+ * @param id - A matrix object (must be square and non-singular)
+ * @returns A new matrix that is the inverse, or null if singular
+ *
+ * @remarks
+ * Function calculation based on the LU decomposition algorithm.
+ * Returns null for singular matrices (det = 0).
+ * Time complexity: O(n³)
+ *
+ * @example
+ * ```typescript
+ * // Create a 2x2 matrix
+ * const m1 = matrix.new_matrix(2, 2, NaN);
+ * matrix.set(m1, 0, 0, 1);
+ * matrix.set(m1, 0, 1, 2);
+ * matrix.set(m1, 1, 0, 3);
+ * matrix.set(m1, 1, 1, 4);
+ *
+ * const m2 = matrix.inv(m1);
+ * // m2 = [[-2, 1], [1.5, -0.5]]
+ * ```
+ */
+export declare function inv(id: PineMatrix<float>): PineMatrix<float> | null;
+/**
+ * Matrix pseudo-inverse (Moore-Penrose)
+ *
+ * Computes the pseudo-inverse of a matrix. For non-singular square matrices,
+ * this returns the same result as inv().
+ *
+ * @param id - A matrix object (can be any shape)
+ * @returns A new matrix containing the pseudo-inverse
+ *
+ * @remarks
+ * Uses the formula: A⁺ = (AᵀA)⁻¹Aᵀ for full column rank matrices,
+ * or Aᵀ(AAᵀ)⁻¹ for full row rank matrices.
+ * For singular matrices, uses iterative refinement approach.
+ *
+ * @example
+ * ```typescript
+ * // Create a 2x2 matrix
+ * const m1 = matrix.new_matrix(2, 2, NaN);
+ * matrix.set(m1, 0, 0, 1);
+ * matrix.set(m1, 0, 1, 2);
+ * matrix.set(m1, 1, 0, 3);
+ * matrix.set(m1, 1, 1, 4);
+ *
+ * const m2 = matrix.pinv(m1);
+ * ```
+ */
+export declare function pinv(id: PineMatrix<float>): PineMatrix<float>;
+/**
+ * Matrix rank
+ *
+ * Calculates the rank of a matrix (number of linearly independent rows/columns)
+ * using Gaussian elimination to row echelon form.
+ *
+ * @param id - A matrix object
+ * @returns The rank of the matrix
+ *
+ * @remarks
+ * Uses row reduction with partial pivoting.
+ * Time complexity: O(n³)
+ *
+ * @example
+ * ```typescript
+ * // Create a 2x2 matrix
+ * const m1 = matrix.new_matrix(2, 2, NaN);
+ * matrix.set(m1, 0, 0, 1);
+ * matrix.set(m1, 0, 1, 2);
+ * matrix.set(m1, 1, 0, 3);
+ * matrix.set(m1, 1, 1, 4);
+ *
+ * const r = matrix.rank(m1); // Returns: 2
+ * ```
+ */
+export declare function rank(id: PineMatrix<float>): int;
+/**
+ * Matrix eigenvalues
+ *
+ * Computes the eigenvalues of a square matrix using the QR algorithm.
+ *
+ * @param id - A matrix object (must be square)
+ * @returns An array containing the eigenvalues
+ *
+ * @remarks
+ * Uses the Implicit QL Algorithm with shifts.
+ * For non-symmetric matrices, only real eigenvalues are returned accurately.
+ * Complex eigenvalues return their real part for 2x2 matrices.
+ * Time complexity: O(n³) per iteration, typically converges in O(n) iterations.
+ *
+ * @example
+ * ```typescript
+ * // Create a 2x2 matrix
+ * const m1 = matrix.new_matrix(2, 2, NaN);
+ * matrix.set(m1, 0, 0, 2);
+ * matrix.set(m1, 0, 1, 4);
+ * matrix.set(m1, 1, 0, 6);
+ * matrix.set(m1, 1, 1, 8);
+ *
+ * const ev = matrix.eigenvalues(m1); // Returns eigenvalues
+ * ```
+ */
+export declare function eigenvalues(id: PineMatrix<float>): PineArray<float>;
+/**
+ * Matrix eigenvectors
+ *
+ * Returns a matrix of eigenvectors, where each column is an eigenvector
+ * corresponding to an eigenvalue.
+ *
+ * @param id - A matrix object (must be square)
+ * @returns A new matrix where columns are eigenvectors
+ *
+ * @remarks
+ * Uses inverse iteration method to compute eigenvectors from eigenvalues.
+ * Eigenvectors are normalized to unit length.
+ * Time complexity: O(n³)
+ *
+ * @example
+ * ```typescript
+ * // Create a 2x2 matrix
+ * const m1 = matrix.new_matrix(2, 2, 1);
+ * matrix.set(m1, 0, 0, 2);
+ * matrix.set(m1, 0, 1, 4);
+ * matrix.set(m1, 1, 0, 6);
+ * matrix.set(m1, 1, 1, 8);
+ *
+ * const evecs = matrix.eigenvectors(m1);
+ * // Each column is an eigenvector
+ * ```
+ */
+export declare function eigenvectors(id: PineMatrix<float>): PineMatrix<float>;
+/**
+ * Kronecker product
+ *
+ * Computes the Kronecker (tensor) product of two matrices.
+ * Each element of id1 is multiplied by the entire id2 matrix.
+ *
+ * @param id1 - First matrix object
+ * @param id2 - Second matrix object
+ * @returns A new matrix containing the Kronecker product
+ *
+ * @remarks
+ * Result size: (m₁×m₂) rows by (n₁×n₂) columns.
+ * Time complexity: O(m₁×m₂×n₁×n₂)
+ *
+ * @example
+ * ```typescript
+ * // Create two 2x2 matrices
+ * const m1 = matrix.new_matrix(2, 2, 1);
+ * const m2 = matrix.new_matrix(2, 2, 2);
+ *
+ * const m3 = matrix.kron(m1, m2);
+ * // Result is a 4x4 matrix
+ * ```
+ */
+export declare function kron(id1: PineMatrix<float>, id2: PineMatrix<float>): PineMatrix<float>;
+/**
+ * Create matrix of user-defined type
+ *
+ * Creates a new matrix that can hold user-defined types.
+ * This is a placeholder that functions identically to new_matrix() for now,
+ * as JavaScript doesn't have the same type system as PineScript.
+ *
+ * @param rows - Initial row count
+ * @param columns - Initial column count
+ * @param initial_value - Initial value for all elements
+ * @returns A new matrix object
+ *
+ * @remarks
+ * In PineScript, this is used for matrices containing user-defined types (UDTs).
+ * In JavaScript, this behaves the same as new_matrix() since type handling
+ * is done at runtime.
+ *
+ * @example
+ * ```typescript
+ * // Create a 2x2 matrix that could hold any type
+ * const m = matrix.newtype(2, 2, { name: 'default', value: 0 });
+ * ```
+ */
+export declare function newtype<T>(rows?: simple_int, columns?: simple_int, initial_value?: T): PineMatrix<T>;
+//# sourceMappingURL=index.d.ts.map