שתי התמונות של משוואות לינאריות

function analyze2x2([[a, b], [c, d]], [u, v], relativeTolerance=1e-12) {
  const determinant = a*d - b*c;
  const determinantScale = Math.abs(a*d) + Math.abs(b*c);
  if (determinant !== 0) {
    const x = (u*d - b*v) / determinant;
    const y = (a*v - u*c) / determinant;
    const Ax = [a*x + b*y, c*x + d*y];
    return {
      determinant,
      type: "unique",
      numericallyReliable:
        Math.abs(determinant) > relativeTolerance*determinantScale,
      solution: [x, y],
      rowResidual: [Ax[0] - u, Ax[1] - v],
      columnCombination: Ax,
    };
  }

  const firstMinorScale = Math.abs(a*v) + Math.abs(c*u);
  const secondMinorScale = Math.abs(b*v) + Math.abs(d*u);
  const zeroMatrix = a === 0 && b === 0 && c === 0 && d === 0;
  const consistent = zeroMatrix
    ? u === 0 && v === 0
    : Math.abs(a*v - c*u) <= relativeTolerance*firstMinorScale &&
      Math.abs(b*v - d*u) <= relativeTolerance*secondMinorScale;
  return {
    determinant,
    type: consistent ? "infinitely many solutions" : "no solution",
    numericallyReliable: true,
  };
}

const result = analyze2x2([[2, 1], [1, -1]], [7, 1]);
console.log(result);
console.log(analyze2x2([[1, 1], [2, 2]], [3, 6]));
console.log(analyze2x2([[1, 1], [2, 2]], [3, 7]));
console.log(analyze2x2([[1, 0], [0, 1e-13]], [1, 2e-13]));
console.log(analyze2x2([[1, 1], [1, 1 + 1e-13]], [2, 2 + 1e-13]));

def analyze_2x2(A, target, relative_tolerance=1e-12):
    (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
        Ax = [a*x + b*y, c*x + d*y]
        return {
            "determinant": determinant,
            "type": "unique",
            "numerically_reliable": (
                abs(determinant)
                > relative_tolerance*determinant_scale
            ),
            "solution": [x, y],
            "row_residual": [Ax[0] - u, Ax[1] - v],
            "column_combination": Ax,
        }

    first_minor_scale = abs(a*v) + abs(c*u)
    second_minor_scale = abs(b*v) + abs(d*u)
    zero_matrix = a == b == c == d == 0
    consistent = (
        u == v == 0
        if zero_matrix
        else (
            abs(a*v - c*u) <= relative_tolerance*first_minor_scale
            and abs(b*v - d*u) <= relative_tolerance*second_minor_scale
        )
    )
    return {
        "determinant": determinant,
        "type": ("infinitely many solutions"
                 if consistent else "no solution"),
        "numerically_reliable": True,
    }

result = analyze_2x2([[2, 1], [1, -1]], [7, 1])
print(result)
print(analyze_2x2([[1, 1], [2, 2]], [3, 6]))
print(analyze_2x2([[1, 1], [2, 2]], [3, 7]))
print(analyze_2x2([[1, 0], [0, 1e-13]], [1, 2e-13]))
print(analyze_2x2([[1, 1], [1, 1 + 1e-13]], [2, 2 + 1e-13]))