nerdamer 1.1.13 → 2.0.0-rc.2

package/output/core/classes/matrix/Sylvester.d.ts

@@ -0,0 +1,11 @@
+import { Expression } from '../expression/Expression';
+/**
+ * Constructs a Sylvester matrix from the coefficient of two polynomials
+ * Ideals, Varieties, and Algorithms 4th edition p. 163
+ */
+export declare class Syl {
+    private M;
+    constructor(f: Expression, g: Expression, variable: string);
+    Res(): Expression;
+    text(): string;
+}

package/output/core/classes/matrix/Sylvester.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Syl = void 0;
+const expand_1 = require("../../functions/expand/expand");
+const Expression_1 = require("../expression/Expression");
+const Matrix_1 = require("./Matrix");
+/**
+ * Constructs a Sylvester matrix from the coefficient of two polynomials
+ * Ideals, Varieties, and Algorithms 4th edition p. 163
+ */
+class Syl {
+    M;
+    constructor(f, g, variable) {
+        const M = (this.M = new Matrix_1.Matrix([]));
+        function addCoefficients(coeffs, d, m) {
+            const cols = M.cols();
+            let c = 0;
+            // Populate the rows first with the coefficients of f and then g
+            for (let col = cols; col < m + cols; col++) {
+                for (let row = 0; row < d; row++) {
+                    const max = coeffs.length - 1 + c;
+                    const outOfRange = row < c || row > max;
+                    const value = outOfRange ? Expression_1.Expression.Number('0') : coeffs[row - c];
+                    // const i = m + c;
+                    // const value = i < c || i > row? Expression.Number('0') : fCoeffs[row];
+                    M.elements[row][col] = value;
+                    // console.log('i: '+i, 'max: '+max, 'row: '+row, 'col: '+col, 'value: '+value.toString())
+                }
+                c++;
+            }
+        }
+        // Get the coefficients wrt the variable
+        const fCoeffs = f.coeffs(variable).toArray().reverse();
+        const gCoeffs = g.coeffs(variable).toArray().reverse();
+        // The columns for the matrix
+        const l = fCoeffs.length - 1;
+        const m = gCoeffs.length - 1;
+        // The matrix will be an (l+m) x (l+m) matrix so we store the dimension in d
+        const d = l + m;
+        // Create the rows
+        for (let i = 0; i < d; i++) {
+            M.elements.push([]);
+        }
+        addCoefficients(fCoeffs, d, m);
+        addCoefficients(gCoeffs, d, l);
+    }
+    Res() {
+        return (0, expand_1.expand)(this.M.determinant());
+    }
+    text() {
+        return this.M.text();
+    }
+}
+exports.Syl = Syl;

package/output/core/classes/matrix/dispatch.d.ts

@@ -0,0 +1 @@
+export declare function loadMatrixFunctions(): void;

package/output/core/classes/matrix/dispatch.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadMatrixFunctions = loadMatrixFunctions;
+const dispatch_1 = require("../../dispatch");
+const functions_1 = require("./functions");
+const utils_1 = require("./utils");
+const math_1 = require("../../../math/math");
+function loadMatrixFunctions() {
+    Object.assign(dispatch_1.mathFunctionRegistry, {
+        matrix: (0, dispatch_1.systemFunction)({ fn: math_1.matrix, minArgs: 1, maxArgs: -1, distElWise: false }),
+        imatrix: (0, dispatch_1.systemFunction)({ fn: utils_1.imatrix, minArgs: 1, maxArgs: 1, distElWise: false }),
+        determinant: (0, dispatch_1.systemFunction)({ fn: functions_1.determinant, minArgs: 1, maxArgs: 1, distElWise: false }),
+        invert: (0, dispatch_1.systemFunction)({ fn: functions_1.invert, minArgs: 1, maxArgs: 1, distElWise: false }),
+        transpose: (0, dispatch_1.systemFunction)({ fn: (M) => M.transpose(), minArgs: 1, maxArgs: 1, distElWise: false }),
+        augment: (0, dispatch_1.systemFunction)({ fn: (M, N) => M.augment(N), minArgs: 2, maxArgs: 2, distElWise: false }),
+        rref: (0, dispatch_1.systemFunction)({ fn: (M, prime) => M.rref(prime), minArgs: 1, maxArgs: 2, distElWise: false }),
+        nullspace: (0, dispatch_1.systemFunction)({ fn: functions_1.nullspace, minArgs: 1, maxArgs: 2, distElWise: false }),
+    });
+}

package/output/core/classes/matrix/functions.d.ts

@@ -0,0 +1,28 @@
+import { Expression } from '../expression/Expression';
+import { Polynomial } from '../polynomial/Polynomial';
+import { Vector } from '../vector/Vector';
+import { Matrix } from './Matrix';
+/**
+ * Computes the determinant without mutating the supplied Matrix.
+ * @throws {@link core!UnsupportedOperationError} If `M` is not square.
+ */
+export declare function determinant(M: Matrix): Expression;
+/** Returns the inverse without modifying the supplied Matrix. */
+export declare function invert(M: Matrix): Matrix;
+/** Returns the nullspace basis as a Vector of basis vectors. */
+export declare function nullspace(M: Matrix, prime?: string | number | Expression): Vector;
+/**
+ * Computes the monic characteristic polynomial `det(variable*I - M)`.
+ *
+ * @remarks
+ * The spectral variable is explicit so callers can choose a name that does not collide with
+ * symbols already present in a symbolic matrix. The Faddeev-LeVerrier recurrence reuses exact
+ * Matrix multiplication, trace, scalar arithmetic, and identity construction without introducing
+ * symbolic pivot denominators from Gaussian determinant elimination.
+ *
+ * @param M - Square matrix whose characteristic polynomial is requested.
+ * @param variable - Variable name used for the polynomial indeterminate.
+ * @returns The exact characteristic polynomial in `variable`.
+ * @throws {@link core!UnsupportedOperationError} If `M` is not square.
+ */
+export declare function characteristicPolynomial(M: Matrix, variable: string): Polynomial;

package/output/core/classes/matrix/functions.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.determinant = determinant;
+exports.invert = invert;
+exports.nullspace = nullspace;
+exports.characteristicPolynomial = characteristicPolynomial;
+const errors_1 = require("../../errors");
+const Expression_1 = require("../expression/Expression");
+const Polynomial_1 = require("../polynomial/Polynomial");
+const Vector_1 = require("../vector/Vector");
+const Matrix_1 = require("./Matrix");
+/**
+ * Computes the determinant without mutating the supplied Matrix.
+ * @throws {@link core!UnsupportedOperationError} If `M` is not square.
+ */
+function determinant(M) {
+    return M.copy().determinant();
+}
+/** Returns the inverse without modifying the supplied Matrix. */
+function invert(M) {
+    return M.inverse();
+}
+/** Returns the nullspace basis as a Vector of basis vectors. */
+function nullspace(M, prime) {
+    return new Vector_1.Vector(M.nullspace(prime).map(vector => new Vector_1.Vector(vector)));
+}
+/**
+ * Computes the monic characteristic polynomial `det(variable*I - M)`.
+ *
+ * @remarks
+ * The spectral variable is explicit so callers can choose a name that does not collide with
+ * symbols already present in a symbolic matrix. The Faddeev-LeVerrier recurrence reuses exact
+ * Matrix multiplication, trace, scalar arithmetic, and identity construction without introducing
+ * symbolic pivot denominators from Gaussian determinant elimination.
+ *
+ * @param M - Square matrix whose characteristic polynomial is requested.
+ * @param variable - Variable name used for the polynomial indeterminate.
+ * @returns The exact characteristic polynomial in `variable`.
+ * @throws {@link core!UnsupportedOperationError} If `M` is not square.
+ */
+function characteristicPolynomial(M, variable) {
+    if (!M.isSquare()) {
+        throw new errors_1.UnsupportedOperationError((0, errors_1.message)('squareMatrixRequired'));
+    }
+    const n = M.rows();
+    const spectralParameter = Expression_1.Expression.Variable(variable);
+    const identity = Matrix_1.Matrix.identity(n);
+    let recurrenceMatrix = identity;
+    let characteristicExpression = spectralParameter.pow(n);
+    for (let k = 1; k <= n; k++) {
+        const product = M.times(recurrenceMatrix);
+        const coefficient = product.trace().neg().div(k);
+        characteristicExpression = characteristicExpression.plus(coefficient.times(spectralParameter.pow(n - k)));
+        recurrenceMatrix = product.plus(identity.times(coefficient));
+    }
+    return new Polynomial_1.Polynomial(characteristicExpression, [variable]);
+}

package/output/core/classes/matrix/utils.d.ts

@@ -0,0 +1,9 @@
+import { Expression } from '../expression/Expression';
+import { Matrix } from './Matrix';
+/**
+ * Creates an identity matrix of integer size.
+ *
+ * @returns A Matrix for an integer argument, or an unevaluated `imatrix(x)`
+ * Expression when the size is not an integer.
+ */
+export declare function imatrix(x: Expression): Expression | Matrix;

package/output/core/classes/matrix/utils.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.imatrix = imatrix;
+const Expression_1 = require("../expression/Expression");
+const constants_1 = require("../parser/constants");
+const Matrix_1 = require("./Matrix");
+/**
+ * Creates an identity matrix of integer size.
+ *
+ * @returns A Matrix for an integer argument, or an unevaluated `imatrix(x)`
+ * Expression when the size is not an integer.
+ */
+function imatrix(x) {
+    let retval;
+    if (!x.isInteger()) {
+        retval = Expression_1.Expression.toFunction(constants_1.IMATRIX, [x]);
+    }
+    else {
+        retval = Matrix_1.Matrix.identity(Number(x));
+    }
+    return retval;
+}