מטריצות סימטריות ואורתוגונליות

const transpose = (A) =>
  A[0].map((_, j) => A.map((row) => row[j]));

const multiply = (A, B) => A.map((row) =>
  B[0].map((_, j) =>
    row.reduce((sum, value, k) => sum + value*B[k][j], 0),
  ),
);

const matVec = (A, x) =>
  A.map((row) =>
    row.reduce((sum, value, j) => sum + value*x[j], 0),
  );

const dot = (x, y) =>
  x.reduce((sum, value, i) => sum + value*y[i], 0);

const outer = (x, y) => x.map((a) => y.map((b) => a*b));
const identity = (n) => Array.from(
  { length: n },
  (_, i) => Array.from({ length: n }, (_, j) => Number(i === j)),
);

const theta = Math.PI/5;
const Q = [
  [Math.cos(theta), -Math.sin(theta)],
  [Math.sin(theta), Math.cos(theta)],
];
const x = [2, -1];
const y = [1, 3];
const u = [3/5, 4/5];
const v = [-4/5, 3/5];
const uuT = outer(u, u);
const H = identity(2).map((row, i) =>
  row.map((value, j) => value - 2*uuT[i][j]),
);

console.table({ Q, H });
console.table(multiply(transpose(Q), Q));
console.table(multiply(transpose(H), H));
console.log({
  before: dot(x, y),
  after: dot(matVec(Q, x), matVec(Q, y)),
  Hu: matVec(H, u),
  minusU: u.map((value) => -value),
  Hv: matVec(H, v),
});

from math import cos, pi, sin

def transpose(A):
    return [list(column) for column in zip(*A)]

def multiply(A, B):
    return [
        [
            sum(a*b for a, b in zip(row, column))
            for column in zip(*B)
        ]
        for row in A
    ]

def mat_vec(A, x):
    return [sum(a*b for a, b in zip(row, x)) for row in A]

def dot(x, y):
    return sum(a*b for a, b in zip(x, y))

def outer(x, y):
    return [[a*b for b in y] for a in x]

def identity(n):
    return [[float(i == j) for j in range(n)] for i in range(n)]

theta = pi/5
Q = [[cos(theta), -sin(theta)], [sin(theta), cos(theta)]]
x, y = [2, -1], [1, 3]
u, v = [3/5, 4/5], [-4/5, 3/5]
uu_t = outer(u, u)
H = [
    [value - 2*uu_t[i][j] for j, value in enumerate(row)]
    for i, row in enumerate(identity(2))
]

print(Q, H)
print(multiply(transpose(Q), Q))
print(multiply(transpose(H), H))
print(dot(x, y), dot(mat_vec(Q, x), mat_vec(Q, y)))
print({
    "Hu": mat_vec(H, u),
    "minus_u": [-value for value in u],
    "Hv": mat_vec(H, v),
})