אי־תלות, בסיס וממד

function rref(input, relativeTolerance=1e-12) {
  const matrix = input.map((row) => row.map(Number));
  const rowScales = matrix.map((row) => Math.max(...row.map(Math.abs)));
  const pivots = [];
  let pivotRow = 0;

  for (let column = 0;
       column < matrix[0].length && pivotRow < matrix.length;
       column += 1) {
    let best = -1;
    let bestRatio = 0;
    for (let row = pivotRow; row < matrix.length; 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 < matrix.length; 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 analyzeBasis(A, relativeTolerance=1e-12) {
  const { matrix, pivots } = rref(A, relativeTolerance);
  const columns = A[0].length;
  const free = Array.from({ length: columns }, (_, j) => j)
    .filter((j) => !pivots.includes(j));
  const nullspaceBasis = free.map((freeColumn) => {
    const vector = Array(columns).fill(0);
    vector[freeColumn] = 1;
    pivots.forEach((pivot, row) => {
      vector[pivot] = -matrix[row][freeColumn];
    });
    return vector;
  });

  return {
    rank: pivots.length,
    pivotColumns: pivots.map((index) => index + 1),
    columnBasis: pivots.map(
      (column) => A.map((row) => row[column]),
    ),
    rowBasis: matrix.slice(0, pivots.length),
    nullspaceBasis,
    independentColumns: pivots.length === columns,
    spansAmbientSpace: pivots.length === A.length,
  };
}

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

def rref(source, relative_tolerance=1e-12):
    matrix = [[float(value) for value in row] for row in source]
    row_scales = [max(abs(value) for value in row) for row in matrix]
    pivots = []
    pivot_row = 0

    for column in range(len(matrix[0])):
        if pivot_row == len(matrix):
            break
        best = max(
            range(pivot_row, len(matrix)),
            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(len(matrix)):
            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, pivots

def analyze_basis(A, relative_tolerance=1e-12):
    matrix, pivots = rref(A, relative_tolerance)
    columns = len(A[0])
    free = [j for j in range(columns) if j not in pivots]
    nullspace_basis = []
    for free_column in free:
        vector = [0.0]*columns
        vector[free_column] = 1.0
        for row, pivot in enumerate(pivots):
            vector[pivot] = -matrix[row][free_column]
        nullspace_basis.append(vector)

    return {
        "rank": len(pivots),
        "pivot_columns": [index+1 for index in pivots],
        "column_basis": [
            [A[row][column] for row in range(len(A))]
            for column in pivots
        ],
        "row_basis": matrix[:len(pivots)],
        "nullspace_basis": nullspace_basis,
        "independent_columns": len(pivots) == columns,
        "spans_ambient_space": len(pivots) == len(A),
    }

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