Skip to content
Ubiquev1.0.4
functionmldivide
mldivide(
y: number,
x: number
): number

Matrix left division X \ Y.

Matrix left division X \ Y. If X is NxN and Y is NxM, then returns a matrix NxM. Solves X * result = Y using LU factorization. X must be square.

Examples

Divide two scalars

import { assertEquals } from "jsr:@std/assert";

assertEquals(mldivide(5, 6), 6 / 5);

Matrix left division

import { assertEquals, assertAlmostEquals } from "jsr:@std/assert";

const actual = mldivide([[9, 5], [6, 1]], [[3, 2], [5, 2]]);
const expected = [[1.0476190476190477, 0.380952380952381], [-1.285714285714286, -0.2857142857142857]];
assertEquals(actual.map(row => row.length), expected.map(row => row.length));
actual.forEach((row, i) => row.forEach((v, j) => assertAlmostEquals(v, expected[i][j], 1e-12)));

Scalar left divides a matrix

import { assertEquals } from "jsr:@std/assert";

assertEquals(mldivide(5, [[9, 5], [6, 1]]), [[9 / 5, 5 / 5], [6 / 5, 1 / 5]]);

Matrix left division with non-square matrix

import { assertEquals, assertAlmostEquals } from "jsr:@std/assert";

const actual = mldivide([[9, 5], [6, 1]], [[5, 6, 5], [7, 8, -1]]);
const expected = [[1.4285714285714288, 1.6190476190476193, -0.4761904761904764],
 [-1.5714285714285712, -1.7142857142857144, 1.8571428571428574]];
assertEquals(actual.map(row => row.length), expected.map(row => row.length));
actual.forEach((row, i) => row.forEach((v, j) => assertAlmostEquals(v, expected[i][j], 1e-12)));

Parameters

y: number

The left matrix or scalar (denominator)

x: number

The right matrix or scalar (numerator)

Return Type

number

The result of the division

Throws

If insufficient arguments are provided or if the matrix dimensions do not match

mldivide(
y: number,
): array

Matrix left division X \ Y.

Matrix left division X \ Y. If X is NxN and Y is NxM, then returns a matrix NxM. Solves X * result = Y using LU factorization. X must be square.

Examples

Divide two scalars

import { assertEquals } from "jsr:@std/assert";

assertEquals(mldivide(5, 6), 6 / 5);

Matrix left division

import { assertEquals, assertAlmostEquals } from "jsr:@std/assert";

const actual = mldivide([[9, 5], [6, 1]], [[3, 2], [5, 2]]);
const expected = [[1.0476190476190477, 0.380952380952381], [-1.285714285714286, -0.2857142857142857]];
assertEquals(actual.map(row => row.length), expected.map(row => row.length));
actual.forEach((row, i) => row.forEach((v, j) => assertAlmostEquals(v, expected[i][j], 1e-12)));

Scalar left divides a matrix

import { assertEquals } from "jsr:@std/assert";

assertEquals(mldivide(5, [[9, 5], [6, 1]]), [[9 / 5, 5 / 5], [6 / 5, 1 / 5]]);

Matrix left division with non-square matrix

import { assertEquals, assertAlmostEquals } from "jsr:@std/assert";

const actual = mldivide([[9, 5], [6, 1]], [[5, 6, 5], [7, 8, -1]]);
const expected = [[1.4285714285714288, 1.6190476190476193, -0.4761904761904764],
 [-1.5714285714285712, -1.7142857142857144, 1.8571428571428574]];
assertEquals(actual.map(row => row.length), expected.map(row => row.length));
actual.forEach((row, i) => row.forEach((v, j) => assertAlmostEquals(v, expected[i][j], 1e-12)));

Parameters

y: number

The left matrix or scalar (denominator)

The right matrix or scalar (numerator)

Return Type

The result of the division

Throws

If insufficient arguments are provided or if the matrix dimensions do not match

mldivide(
y: number,
): matrix

Matrix left division X \ Y.

Matrix left division X \ Y. If X is NxN and Y is NxM, then returns a matrix NxM. Solves X * result = Y using LU factorization. X must be square.

Examples

Divide two scalars

import { assertEquals } from "jsr:@std/assert";

assertEquals(mldivide(5, 6), 6 / 5);

Matrix left division

import { assertEquals, assertAlmostEquals } from "jsr:@std/assert";

const actual = mldivide([[9, 5], [6, 1]], [[3, 2], [5, 2]]);
const expected = [[1.0476190476190477, 0.380952380952381], [-1.285714285714286, -0.2857142857142857]];
assertEquals(actual.map(row => row.length), expected.map(row => row.length));
actual.forEach((row, i) => row.forEach((v, j) => assertAlmostEquals(v, expected[i][j], 1e-12)));

Scalar left divides a matrix

import { assertEquals } from "jsr:@std/assert";

assertEquals(mldivide(5, [[9, 5], [6, 1]]), [[9 / 5, 5 / 5], [6 / 5, 1 / 5]]);

Matrix left division with non-square matrix

import { assertEquals, assertAlmostEquals } from "jsr:@std/assert";

const actual = mldivide([[9, 5], [6, 1]], [[5, 6, 5], [7, 8, -1]]);
const expected = [[1.4285714285714288, 1.6190476190476193, -0.4761904761904764],
 [-1.5714285714285712, -1.7142857142857144, 1.8571428571428574]];
assertEquals(actual.map(row => row.length), expected.map(row => row.length));
actual.forEach((row, i) => row.forEach((v, j) => assertAlmostEquals(v, expected[i][j], 1e-12)));

Parameters

y: number

The left matrix or scalar (denominator)

The right matrix or scalar (numerator)

Return Type

The result of the division

Throws

If insufficient arguments are provided or if the matrix dimensions do not match

mldivide(
y: array,
): array

Matrix left division X \ Y.

Matrix left division X \ Y. If X is NxN and Y is NxM, then returns a matrix NxM. Solves X * result = Y using LU factorization. X must be square.

Examples

Divide two scalars

import { assertEquals } from "jsr:@std/assert";

assertEquals(mldivide(5, 6), 6 / 5);

Matrix left division

import { assertEquals, assertAlmostEquals } from "jsr:@std/assert";

const actual = mldivide([[9, 5], [6, 1]], [[3, 2], [5, 2]]);
const expected = [[1.0476190476190477, 0.380952380952381], [-1.285714285714286, -0.2857142857142857]];
assertEquals(actual.map(row => row.length), expected.map(row => row.length));
actual.forEach((row, i) => row.forEach((v, j) => assertAlmostEquals(v, expected[i][j], 1e-12)));

Scalar left divides a matrix

import { assertEquals } from "jsr:@std/assert";

assertEquals(mldivide(5, [[9, 5], [6, 1]]), [[9 / 5, 5 / 5], [6 / 5, 1 / 5]]);

Matrix left division with non-square matrix

import { assertEquals, assertAlmostEquals } from "jsr:@std/assert";

const actual = mldivide([[9, 5], [6, 1]], [[5, 6, 5], [7, 8, -1]]);
const expected = [[1.4285714285714288, 1.6190476190476193, -0.4761904761904764],
 [-1.5714285714285712, -1.7142857142857144, 1.8571428571428574]];
assertEquals(actual.map(row => row.length), expected.map(row => row.length));
actual.forEach((row, i) => row.forEach((v, j) => assertAlmostEquals(v, expected[i][j], 1e-12)));

Parameters

The left matrix or scalar (denominator)

The right matrix or scalar (numerator)

Return Type

The result of the division

Throws

If insufficient arguments are provided or if the matrix dimensions do not match

mldivide(): matrix

Matrix left division X \ Y.

Matrix left division X \ Y. If X is NxN and Y is NxM, then returns a matrix NxM. Solves X * result = Y using LU factorization. X must be square.

Examples

Divide two scalars

import { assertEquals } from "jsr:@std/assert";

assertEquals(mldivide(5, 6), 6 / 5);

Matrix left division

import { assertEquals, assertAlmostEquals } from "jsr:@std/assert";

const actual = mldivide([[9, 5], [6, 1]], [[3, 2], [5, 2]]);
const expected = [[1.0476190476190477, 0.380952380952381], [-1.285714285714286, -0.2857142857142857]];
assertEquals(actual.map(row => row.length), expected.map(row => row.length));
actual.forEach((row, i) => row.forEach((v, j) => assertAlmostEquals(v, expected[i][j], 1e-12)));

Scalar left divides a matrix

import { assertEquals } from "jsr:@std/assert";

assertEquals(mldivide(5, [[9, 5], [6, 1]]), [[9 / 5, 5 / 5], [6 / 5, 1 / 5]]);

Matrix left division with non-square matrix

import { assertEquals, assertAlmostEquals } from "jsr:@std/assert";

const actual = mldivide([[9, 5], [6, 1]], [[5, 6, 5], [7, 8, -1]]);
const expected = [[1.4285714285714288, 1.6190476190476193, -0.4761904761904764],
 [-1.5714285714285712, -1.7142857142857144, 1.8571428571428574]];
assertEquals(actual.map(row => row.length), expected.map(row => row.length));
actual.forEach((row, i) => row.forEach((v, j) => assertAlmostEquals(v, expected[i][j], 1e-12)));

Parameters

The left matrix or scalar (denominator)

The right matrix or scalar (numerator)

Return Type

The result of the division

Throws

If insufficient arguments are provided or if the matrix dimensions do not match