Matrix Operations Calculator (python, written by Codex)

Codex wrote this python project from the task below. It installed and ran on a clean Ubuntu 22.04 machine as written.

Task given to the agent:

TASK: Matrix Operations Calculator

Write a program that performs common matrix operations including addition, multiplication, transposition, determinant calculation, inversion, and eigenvalue decomposition on matrices loaded from files.

FUNCTIONAL REQUIREMENTS:
- Accept a matrix data file (CSV or JSON format) as a command-line argument
- Support operations selectable via --operation flag: add, subtract, multiply, transpose, determinant, inverse, eigenvalues, rank, trace, and LU decomposition
- For binary operations (add, subtract, multiply), accept a second matrix file via --matrix2 flag
- Support scalar operations: scalar multiplication via --scalar flag applied to the matrix
- Compute matrix properties: dimensions, rank, trace, is-symmetric, is-positive-definite, condition number
- Handle matrices of arbitrary size (up to practical memory limits)
- Support sparse matrix representation for large matrices with many zeros via --sparse flag
- Display results formatted as aligned matrices to console with configurable decimal precision via --precision flag (default: 4)
- Support both integer and floating-point matrix elements
- Verify results where possible: multiplying a matrix by its inverse should yield the identity matrix (within floating-point tolerance)
- Save results as JSON or CSV with --output flag (default: result_matrix.json)
- If no input is given, generate sample matrices and demonstrate each operation: add two 3x3 matrices, multiply a 3x3 by a 3x4, compute determinant and inverse of a 4x4, find eigenvalues of a symmetric 3x3, and show LU decomposition of a 4x4
- Handle errors: dimension mismatches, singular matrices (non-invertible), non-square matrices for operations requiring square input, and malformed input files

Create a complete Python project for a clean Ubuntu 22.04 machine with only Python 3.10+ installed. Include:
- Source code
- requirements.txt with all dependencies (direct and transitive) pinned to exact versions
- README.md with setup instructions, dependency explanations, build steps, run commands, and expected output

[]

# Matrix Operations Calculator (Python)

## Requirements
- Ubuntu 22.04
- Python 3.10+

## Install
```bash
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
```

## Run
```bash
python src/main.py matrix.csv --operation inverse --precision 6
python src/main.py matrix.json --operation multiply --matrix2 matrix2.json
python src/main.py matrix.csv --operation eigenvalues --output result_matrix.json
```

If no input is provided, sample matrices are generated and demonstrated.

numpy==2.1.1
scipy==1.14.1

#!/usr/bin/env python3
import argparse
import csv
import json
import sys
from pathlib import Path

import numpy as np
from scipy import linalg


def read_matrix(path: Path) -> np.ndarray:
    text = path.read_text(encoding="utf-8").strip()
    if path.suffix.lower() == ".json":
        arr = np.array(json.loads(text), dtype=float)
    else:
        rows = [list(map(float, r)) for r in csv.reader(text.splitlines()) if r]
        arr = np.array(rows, dtype=float)
    if arr.ndim != 2:
        raise ValueError(f"Matrix must be 2D: {path}")
    return arr


def matrix_props(a: np.ndarray) -> dict:
    is_sym = a.shape[0] == a.shape[1] and np.allclose(a, a.T)
    pos_def = False
    if is_sym:
        try:
            np.linalg.cholesky(a)
            pos_def = True
        except np.linalg.LinAlgError:
            pos_def = False
    cond = float(np.linalg.cond(a)) if a.shape[0] == a.shape[1] else None
    return {
        "dimensions": [int(a.shape[0]), int(a.shape[1])],
        "rank": int(np.linalg.matrix_rank(a)),
        "trace": float(np.trace(a)) if a.shape[0] == a.shape[1] else None,
        "is_symmetric": bool(is_sym),
        "is_positive_definite": bool(pos_def),
        "condition_number": cond,
    }


def compute(op: str, a: np.ndarray, b: np.ndarray | None, scalar: float | None):
    out = {}
    if scalar is not None:
        out["scalar_multiply"] = (a * scalar).tolist()

    if op == "add":
        out["result"] = (a + b).tolist()
    elif op == "subtract":
        out["result"] = (a - b).tolist()
    elif op == "multiply":
        out["result"] = (a @ b).tolist()
    elif op == "transpose":
        out["result"] = a.T.tolist()
    elif op == "determinant":
        out["result"] = float(np.linalg.det(a))
    elif op == "inverse":
        out["result"] = np.linalg.inv(a).tolist()
    elif op == "eigenvalues":
        vals = np.linalg.eigvals(a)
        out["result"] = [{"real": float(v.real), "imag": float(v.imag)} for v in vals]
    elif op == "rank":
        out["result"] = int(np.linalg.matrix_rank(a))
    elif op == "trace":
        out["result"] = float(np.trace(a))
    elif op == "lu":
        p, l, u = linalg.lu(a)
        out["result"] = {"P": p.tolist(), "L": l.tolist(), "U": u.tolist()}
    else:
        raise ValueError(f"Unsupported operation: {op}")

    return out


def fmt_matrix(arr, precision: int) -> str:
    a = np.array(arr, dtype=float)
    rows = [[f"{v:.{precision}f}" for v in r] for r in a]
    widths = [max(len(r[i]) for r in rows) for i in range(a.shape[1])]
    return "\n".join("  ".join(v.rjust(widths[i]) for i, v in enumerate(r)) for r in rows)


def demo() -> dict:
    a = np.array([[4, 2, 1], [0, 5, 3], [2, 1, 6]], dtype=float)
    b = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=float)
    c = np.array([[2, 1, 0, 3], [1, 0, 2, 2], [3, 1, 1, 0]], dtype=float)
    d = np.array([[1, 2, 3], [0, 1, 4], [5, 6, 0], [1, 0, 2]], dtype=float)
    p, l, u = linalg.lu(a)
    return {
        "add": (a + b).tolist(),
        "multiply": (c @ d).tolist(),
        "determinant": float(np.linalg.det(a)),
        "inverse": np.linalg.inv(a).tolist(),
        "eigenvalues": [float(v) for v in np.linalg.eigvals(a).real],
        "lu": {"P": p.tolist(), "L": l.tolist(), "U": u.tolist()},
    }


def main() -> int:
    parser = argparse.ArgumentParser(description="Matrix operations calculator")
    parser.add_argument("matrix1", nargs="?")
    parser.add_argument("--operation", default="transpose")
    parser.add_argument("--matrix2")
    parser.add_argument("--scalar", type=float)
    parser.add_argument("--sparse", action="store_true")
    parser.add_argument("--precision", type=int, default=4)
    parser.add_argument("--output", default="result_matrix.json")
    args = parser.parse_args()

    try:
        if not args.matrix1:
            result = demo()
            print(json.dumps(result, indent=2))
            Path(args.output).write_text(json.dumps(result, indent=2), encoding="utf-8")
            return 0

        a = read_matrix(Path(args.matrix1))
        b = read_matrix(Path(args.matrix2)) if args.matrix2 else None

        report = {"operation": args.operation, "properties": matrix_props(a)}
        report.update(compute(args.operation, a, b, args.scalar))

        if isinstance(report.get("result"), list) and report["result"] and isinstance(report["result"][0], list):
            print(fmt_matrix(report["result"], args.precision))
        else:
            print(json.dumps(report["result"], indent=2))

        if args.operation == "inverse":
            inv = np.array(report["result"], dtype=float)
            report["inverse_verification"] = (a @ inv).tolist()

        Path(args.output).write_text(json.dumps(report, indent=2), encoding="utf-8")
        return 0
    except Exception as exc:
        print(f"Error: {exc}", file=sys.stderr)
        return 1


if __name__ == "__main__":
    raise SystemExit(main())