כפל מטריצות

function shape(M, name="matrix") {
  if (!Array.isArray(M) || !M.length || !Array.isArray(M[0]) || !M[0].length) {
    throw new TypeError(name + " must be a nonempty matrix");
  }
  const columns = M[0].length;
  if (!M.every((row) =>
    Array.isArray(row) &&
    row.length === columns &&
    row.every(Number.isFinite))) {
    throw new TypeError(name + " must be rectangular and numeric");
  }
  return [M.length, columns];
}

function matmul(A, B) {
  const [m, n] = shape(A, "A");
  const [rows, p] = shape(B, "B");
  if (n !== rows) {
    throw new RangeError(
      "inner dimensions differ: " + m + "x" + n +
      " times " + rows + "x" + p,
    );
  }
  return A.map((row) =>
    Array.from({ length: p }, (_, j) =>
      row.reduce((sum, value, k) => sum + value*B[k][j], 0),
    ),
  );
}

function outer(u, v) {
  return u.map((x) => v.map((y) => x*y));
}

function multiplicationViews(A, B) {
  const [m, n] = shape(A, "A");
  const [rows, p] = shape(B, "B");
  if (n !== rows) throw new RangeError("inner dimensions must agree");

  const byEntries = matmul(A, B);
  const productColumns = Array.from({ length: p }, (_, j) =>
    matmul(A, B.map((row) => [row[j]])).map((row) => row[0]),
  );
  const byColumns = Array.from(
    { length: m },
    (_, i) => productColumns.map((column) => column[i]),
  );
  const byRows = A.map((row) => matmul([row], B)[0]);
  const byOuter = Array.from({ length: m }, () => Array(p).fill(0));

  for (let k = 0; k < n; k += 1) {
    const piece = outer(A.map((row) => row[k]), B[k]);
    for (let i = 0; i < m; i += 1) {
      for (let j = 0; j < p; j += 1) byOuter[i][j] += piece[i][j];
    }
  }
  return { byEntries, byColumns, byRows, byOuter };
}

const A = [[1, 2, 0], [-1, 1, 3]];
const B = [[2, 0], [1, 1], [0, -2]];
const views = multiplicationViews(A, B);
const expected = JSON.stringify(views.byEntries);
if (!Object.values(views).every((view) => JSON.stringify(view) === expected)) {
  throw new Error("the four multiplication views must agree");
}
console.log(views);

const x = [[3], [-1]];
console.log({
  direct: matmul(matmul(A, B), x),
  composed: matmul(A, matmul(B, x)),
});

def shape(M, name="matrix"):
    if not isinstance(M, list) or not M or not M[0]:
        raise ValueError(f"{name} must be a nonempty matrix")
    columns = len(M[0])
    if any(not isinstance(row, list) or len(row) != columns for row in M):
        raise ValueError(f"{name} must be rectangular")
    return len(M), columns

def matmul(A, B):
    m, n = shape(A, "A")
    rows, p = shape(B, "B")
    if n != rows:
        raise ValueError(
            f"inner dimensions differ: {m}x{n} times {rows}x{p}"
        )
    return [
        [
            sum(A[i][k]*B[k][j] for k in range(n))
            for j in range(p)
        ]
        for i in range(m)
    ]

def outer(u, v):
    return [[x*y for y in v] for x in u]

def multiplication_views(A, B):
    m, n = shape(A, "A")
    rows, p = shape(B, "B")
    if n != rows:
        raise ValueError("inner dimensions must agree")

    by_entries = matmul(A, B)
    product_columns = [
        [row[0] for row in matmul(A, [[B[k][j]] for k in range(n)])]
        for j in range(p)
    ]
    by_columns = [
        [product_columns[j][i] for j in range(p)]
        for i in range(m)
    ]
    by_rows = [matmul([row], B)[0] for row in A]
    by_outer = [[0 for _ in range(p)] for _ in range(m)]
    for k in range(n):
        piece = outer([A[i][k] for i in range(m)], B[k])
        for i in range(m):
            for j in range(p):
                by_outer[i][j] += piece[i][j]
    return {
        "by_entries": by_entries,
        "by_columns": by_columns,
        "by_rows": by_rows,
        "by_outer": by_outer,
    }

A = [[1, 2, 0], [-1, 1, 3]]
B = [[2, 0], [1, 1], [0, -2]]
views = multiplication_views(A, B)
assert all(view == views["by_entries"] for view in views.values())
print(views)

x = [[3], [-1]]
print({
    "direct": matmul(matmul(A, B), x),
    "composed": matmul(A, matmul(B, x)),
})