@jrc03c/js-math-tools/src/inverse.test.mjs

some math tools for JS

import { DataFrame, Series } from "./dataframe/index.mjs"
import { distance } from "./distance.mjs"
import { expect, test } from "@jrc03c/fake-jest"
import { forEach } from "./for-each.mjs"
import { inverse } from "./inverse.mjs"
import { isEqual } from "./is-equal.mjs"
import { map } from "./map.mjs"
import { normal } from "./normal.mjs"

test("tests that matrix inverses can be computed correctly", () => {
  const a = [
    [
      -0.12127276865371786, 0.350462020751606, 2.033820010116211,
      -1.5906820964850246, 0.9549990962633509, 1.0563472041311566,
      -0.2838203403742434, 1.3707782253300411, 1.622606915732567,
      -0.2894553459667626,
    ],
    [
      0.6283567655683346, -0.05378083885120789, -0.4068512848445372,
      0.47085164587108475, -0.18004479675949386, -0.8656953167443983,
      -0.8829266076364897, 1.220685541538935, -0.8370283632775997,
      2.1034565085174255,
    ],
    [
      -0.5169550447562502, 1.250244032193986, -1.7193827264638923,
      1.7345740827112006, 1.5008300276140447, -0.36408750244467775,
      0.8200130544380111, 0.7369631380671903, 0.42753301164014545,
      -0.3871003831307085,
    ],
    [
      -0.35932354896169616, 0.5944291074936798, -1.226075745336058,
      0.6365940303639955, -0.43775496238171835, -1.0754867555875103,
      0.036225355429846985, 1.2892733156165652, -1.050613498967157,
      0.5479986993411962,
    ],
    [
      0.07675268157861377, -0.5947571933685282, -0.7445428503374395,
      1.9918774121138052, 0.8453612367911146, 0.5671564099506075,
      0.25408316803207387, -0.786789988085405, -0.10642522081882128,
      -0.5122874181637658,
    ],
    [
      -0.4542872493007708, -0.1966076324526236, 0.6566951039753979,
      1.1068215956457024, 1.478039754461216, 1.6325934409933445,
      0.7974690373746759, 0.15528201251718243, 1.0369245833921903,
      -0.5097058275773475,
    ],
    [
      2.672109271681275, 1.0202962476005109, 0.5272862020609522,
      -0.2253713609530309, -0.8495805729937016, 0.07121190328203315,
      1.4152871040010053, 1.9802771690721999, -1.3232293410716363,
      0.5060073574777028,
    ],
    [
      -0.7348482740158297, -0.5380235120402064, -1.6514784051899483,
      0.7052050455353287, 0.3107375402680251, -2.1899390745543257,
      -0.2879162593417391, -0.49670215279419466, 0.9042017864093781,
      -1.17046261457406,
    ],
    [
      -0.2001541441202924, -0.5874975349760433, -0.08904725577125114,
      -0.7383950722849536, -1.3494249031948142, 1.2072461978342148,
      -2.225978278957183, -0.8192352487136791, -2.7226689915552145,
      0.6197074179150885,
    ],
    [
      2.242537205158909, 0.8280458021148995, -0.33741721482649684,
      0.6642282182682274, 0.10317388406934891, 0.46255680799966753,
      1.2027817044785476, -0.9380607605534776, -0.5821876054057862,
      0.6688264916524803,
    ],
  ]

  const bTrue = [
    [
      -3.330734918728712, 1.6246884433654796, 4.336844501137978,
      -8.270256745441682, -0.43267180133720645, -2.567772346071238,
      2.3060566295119926, -2.0314137142936373, -0.4126521119816963,
      -4.470500407595614,
    ],
    [
      -0.695441286723933, 0.13754698886349223, 2.6991262803694585,
      -3.638629590136261, 2.667630925712928, -4.921436245402135,
      0.4524011694942488, -3.354061273027393, -1.32501838048097,
      -2.8816369179718904,
    ],
    [
      11.302573070463922, -4.853423636642639, -12.841640841230252,
      23.973715007850647, 4.681747117533911, 4.244997566949547,
      -6.5693173397022475, 4.878382502768662, 0.4239324849683974,
      13.016021933985343,
    ],
    [
      -3.0081220404528146, 1.2634265339463673, 4.9236314870785405,
      -8.477849917161295, 2.9384551300761217, -6.282905413755231,
      1.8452017649214887, -4.750738410741077, -1.8289529547544807,
      -6.032089081721212,
    ],
    [
      16.661315124388643, -6.809806981277019, -20.971138422991714,
      38.53680997033632, 0.48475022638373955, 14.744308780934743,
      -9.802191821939534, 12.970136181454945, 3.5311342754103916,
      23.365019808719502,
    ],
    [
      -11.17650990278, 4.704298628492781, 13.473701352917564,
      -24.954500426052455, -2.624921243208278, -6.671761046190921,
      6.583278134453461, -6.8125898214912075, -1.2126449161556494,
      -14.261714995887775,
    ],
    [
      4.546154161491146, -2.2076852912248697, -7.06720975048238,
      12.528071239994203, -1.4322549457320386, 6.456554841914442,
      -2.9420910205361297, 4.808647098386483, 1.318201007412577,
      7.798692478049673,
    ],
    [
      -4.024737907440915, 1.8458772588483001, 4.8408874472337855,
      -8.931359378529827, -1.1741863105071253, -2.0410090768084643,
      2.6529997325969683, -2.1493488607174345, -0.3564019038046241,
      -5.320605321870062,
    ],
    [
      -15.131894278191274, 6.5440048946550595, 19.041174248938542,
      -35.17974097968441, -1.6390308470210209, -11.999903293554787,
      8.894043126844627, -10.774440435815743, -2.8224089602315137,
      -20.654501788075436,
    ],
    [
      -1.1144989395418734, 0.7314067216624279, 0.739015756598578,
      -1.6167697136054344, -1.1655797199752465, 0.5043869115263531,
      0.274058273300666, -0.18723218337165703, 0.020989025284069398,
      -0.5978719935960377,
    ],
  ]

  const bPred = inverse(a)
  expect(distance(bPred, bTrue)).toBeLessThan(1e-5)

  const c = new DataFrame(a)
  c.columns = map(c.columns, (v, i) => "cCol" + i)
  c.index = map(c.index, (v, i) => "cRow" + i)
  const dTrue = c.copy()
  dTrue.values = bTrue
  const dPred = inverse(c)
  expect(isEqual(dPred.columns, dTrue.columns)).toBe(true)
  expect(isEqual(dPred.index, dTrue.index)).toBe(true)
  expect(distance(dPred.values, dTrue.values)).toBeLessThan(1e-5)

  expect(
    isEqual(
      inverse([
        [2n, 3n],
        [4n, 5n],
      ]),
      inverse([
        [2, 3],
        [4, 5],
      ]),
    ),
  ).toBe(true)

  const wrongs = [
    0,
    1,
    2.3,
    -2.3,
    Infinity,
    -Infinity,
    NaN,
    "foo",
    true,
    false,
    null,
    undefined,
    Symbol.for("Hello, world!"),
    x => x,
    function (x) {
      return x
    },
    { hello: "world" },
    normal(100),
    normal([2, 3, 4, 5]),
    normal([10, 20]),
    normal([20, 10]),
    // non-invertible matrix:
    [
      [2, 3],
      [4, 6],
    ],
    new Series(normal(100)),
  ]

  forEach(wrongs, item => {
    expect(() => inverse(item)).toThrow()
  })
})