מרחב העמודות

function rref(input, relativeTolerance=1e-12, scaleColumnCount) {
  if (!input.length || !input[0].length) throw new Error("matrix is empty");
  const matrix = input.map((row) => row.map(Number));
  const rows = matrix.length;
  const columns = matrix[0].length;
  const referenceColumns = scaleColumnCount ?? columns;
  const rowScales = matrix.map((row) =>
    Math.max(0, ...row.slice(0, referenceColumns).map(Math.abs)) ||
    Math.max(0, ...row.map(Math.abs)),
  );
  const pivots = [];
  let pivotRow = 0;

  for (let column = 0; column < columns && pivotRow < rows; column += 1) {
    let best = -1;
    let bestRatio = 0;
    for (let row = pivotRow; row < rows; row += 1) {
      const ratio = rowScales[row] === 0
        ? 0
        : Math.abs(matrix[row][column])/rowScales[row];
      if (ratio > bestRatio) {
        bestRatio = ratio;
        best = row;
      }
    }
    if (best === -1 || bestRatio <= relativeTolerance) continue;
    [matrix[pivotRow], matrix[best]] = [matrix[best], matrix[pivotRow]];
    [rowScales[pivotRow], rowScales[best]] = [rowScales[best], rowScales[pivotRow]];

    const scale = matrix[pivotRow][column];
    matrix[pivotRow] = matrix[pivotRow].map((value) => value/scale);
    for (let row = 0; row < rows; row += 1) {
      if (row === pivotRow) continue;
      const factor = matrix[row][column];
      matrix[row] = matrix[row].map(
        (value, j) => value - factor*matrix[pivotRow][j],
      );
    }
    pivots.push(column);
    pivotRow += 1;
  }

  return {
    matrix: matrix.map((row) =>
      row.map((value) => Math.abs(value) <= relativeTolerance ? 0 : value),
    ),
    pivots,
  };
}

function columnSpaceInfo(A, target, relativeTolerance=1e-12) {
  const reduced = rref(A, relativeTolerance);
  const basis = reduced.pivots.map(
    (column) => A.map((row) => row[column]),
  );
  const augmented = A.map((row, i) => [...row, target[i]]);
  const augmentedRank = rref(
    augmented,
    relativeTolerance,
    A[0].length,
  ).pivots.length;
  return {
    rank: reduced.pivots.length,
    pivotColumns: reduced.pivots.map((index) => index + 1),
    basis,
    inColumnSpace: augmentedRank === reduced.pivots.length,
  };
}

const A = [[2, 4, 6, 4], [2, 5, 7, 6], [2, 3, 5, 2]];
console.log(columnSpaceInfo(A, [4, 3, 5]));
console.log(columnSpaceInfo(A, [4, 3, 4]));

def rref(source, relative_tolerance=1e-12, scale_column_count=None):
    if not source or not source[0]:
        raise ValueError("matrix is empty")
    matrix = [[float(value) for value in row] for row in source]
    rows, columns = len(matrix), len(matrix[0])
    reference_columns = columns if scale_column_count is None else scale_column_count
    row_scales = [
        max((abs(value) for value in row[:reference_columns]), default=0)
        or max((abs(value) for value in row), default=0)
        for row in matrix
    ]
    pivots = []
    pivot_row = 0

    for column in range(columns):
        if pivot_row == rows:
            break
        best = max(
            range(pivot_row, rows),
            key=lambda row: (
                abs(matrix[row][column])/row_scales[row]
                if row_scales[row] else 0.0
            ),
        )
        best_ratio = (
            abs(matrix[best][column])/row_scales[best]
            if row_scales[best] else 0.0
        )
        if best_ratio <= relative_tolerance:
            continue
        matrix[pivot_row], matrix[best] = matrix[best], matrix[pivot_row]
        row_scales[pivot_row], row_scales[best] = (
            row_scales[best], row_scales[pivot_row]
        )

        scale = matrix[pivot_row][column]
        matrix[pivot_row] = [value/scale for value in matrix[pivot_row]]
        for row in range(rows):
            if row == pivot_row:
                continue
            factor = matrix[row][column]
            matrix[row] = [
                value - factor*pivot_value
                for value, pivot_value
                in zip(matrix[row], matrix[pivot_row])
            ]
        pivots.append(column)
        pivot_row += 1

    matrix = [
        [0.0 if abs(value) <= relative_tolerance else value for value in row]
        for row in matrix
    ]
    return {"matrix": matrix, "pivots": pivots}

def column_space_info(A, target, relative_tolerance=1e-12):
    reduced = rref(A, relative_tolerance)
    basis = [
        [A[row][column] for row in range(len(A))]
        for column in reduced["pivots"]
    ]
    augmented = [row + [target[i]] for i, row in enumerate(A)]
    augmented_rank = len(rref(
        augmented,
        relative_tolerance,
        len(A[0]),
    )["pivots"])
    return {
        "rank": len(reduced["pivots"]),
        "pivot_columns": [index+1 for index in reduced["pivots"]],
        "basis": basis,
        "in_column_space": augmented_rank == len(reduced["pivots"]),
    }

A = [[2, 4, 6, 4], [2, 5, 7, 6], [2, 3, 5, 2]]
print(column_space_info(A, [4, 3, 5]))
print(column_space_info(A, [4, 3, 4]))