משוואות לינאריות ומטריצות הפוכות

function solve2x2([[a, b], [c, d]], [u, v], eps = 1e-10) {
  const det = a * d - b * c;
  const detScale = Math.abs(a * d) + Math.abs(b * c);
  if (det !== 0) {
    return {
      determinant: det,
      status: "unique",
      numericallyReliable: Math.abs(det) > eps * detScale,
      solution: [(u * d - b * v) / det, (a * v - u * c) / det],
    };
  }
  const coefficientsAreZero = a === 0 && b === 0 && c === 0 && d === 0;
  const firstMinorScale = Math.abs(a * v) + Math.abs(c * u);
  const secondMinorScale = Math.abs(b * v) + Math.abs(d * u);
  const consistent = coefficientsAreZero
    ? u === 0 && v === 0
    : Math.abs(a * v - c * u) <= eps * firstMinorScale
      && Math.abs(b * v - d * u) <= eps * secondMinorScale;
  return {
    determinant: det,
    status: consistent ? "infinite" : "none",
    numericallyReliable: true,
  };
}

const examples = [
  { A: [[2, 1], [1, -1]], b: [7, 1] },
  { A: [[1, 1], [2, 2]], b: [3, 6] },
  { A: [[1, 1], [2, 2]], b: [3, 7] },
];
console.table(examples.map(({ A, b }) => ({ b: b.join(","), ...solve2x2(A, b) })));

def solve_2x2(A, target, eps=1e-10):
    (a, b), (c, d) = A
    u, v = target
    determinant = a*d-b*c
    determinant_scale = abs(a*d)+abs(b*c)
    if determinant != 0:
        x = (u*d-b*v)/determinant
        y = (a*v-u*c)/determinant
        return {"determinant": determinant,
                "status": "unique",
                "numerically_reliable": abs(determinant) > eps*determinant_scale,
                "solution": [x, y]}

    coefficients_are_zero = a == b == c == d == 0
    first_minor_scale = abs(a*v)+abs(c*u)
    second_minor_scale = abs(b*v)+abs(d*u)
    consistent = ((u == 0 and v == 0) if coefficients_are_zero
                  else abs(a*v-c*u) <= eps*first_minor_scale
                  and abs(b*v-d*u) <= eps*second_minor_scale)
    return {"determinant": determinant,
            "status": "infinite" if consistent else "none",
            "numerically_reliable": True}

examples = [
    ([[2, 1], [1, -1]], [7, 1]),
    ([[1, 1], [2, 2]], [3, 6]),
    ([[1, 1], [2, 2]], [3, 7]),
]
for A, b in examples:
    print(solve_2x2(A, b))