Matrix Operations Calculator (python, written by Claude Code)

Claude Code 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
Performs addition, multiplication, transpose, determinant, inverse,
eigenvalue decomposition, and LU decomposition from file input.
Uses numpy and scipy.
"""

import sys
import json
import numpy as np
from scipy import linalg as scipy_linalg


def load_matrices_from_file(filepath):
    """Load matrices from a JSON file.

    Expected format:
    {
        "matrices": [
            [[1, 2], [3, 4]],
            [[5, 6], [7, 8]]
        ]
    }
    """
    with open(filepath, "r") as f:
        data = json.load(f)
    matrices = [np.array(m, dtype=float) for m in data["matrices"]]
    return matrices


def matrix_add(a, b):
    """Add two matrices."""
    if a.shape != b.shape:
        raise ValueError(
            f"Shape mismatch for addition: {a.shape} vs {b.shape}"
        )
    return a + b


def matrix_multiply(a, b):
    """Multiply two matrices."""
    if a.shape[1] != b.shape[0]:
        raise ValueError(
            f"Shape mismatch for multiplication: {a.shape} vs {b.shape}"
        )
    return np.matmul(a, b)


def matrix_transpose(a):
    """Transpose a matrix."""
    return a.T


def matrix_determinant(a):
    """Compute the determinant of a square matrix."""
    if a.shape[0] != a.shape[1]:
        raise ValueError(f"Matrix must be square, got shape {a.shape}")
    return np.linalg.det(a)


def matrix_inverse(a):
    """Compute the inverse of a square matrix."""
    if a.shape[0] != a.shape[1]:
        raise ValueError(f"Matrix must be square, got shape {a.shape}")
    det = np.linalg.det(a)
    if np.isclose(det, 0):
        raise ValueError("Matrix is singular and cannot be inverted")
    return np.linalg.inv(a)


def matrix_eigenvalues(a):
    """Compute eigenvalues and eigenvectors of a square matrix."""
    if a.shape[0] != a.shape[1]:
        raise ValueError(f"Matrix must be square, got shape {a.shape}")
    eigenvalues, eigenvectors = np.linalg.eig(a)
    return eigenvalues, eigenvectors


def matrix_lu_decomposition(a):
    """Compute LU decomposition using scipy (PA = LU)."""
    if a.shape[0] != a.shape[1]:
        raise ValueError(f"Matrix must be square, got shape {a.shape}")
    P, L, U = scipy_linalg.lu(a)
    return P, L, U


def format_matrix(matrix, label=""):
    """Format a matrix for display."""
    header = f"\n{label}:" if label else ""
    return f"{header}\n{matrix}\n"


def run_operations(matrices):
    """Run all matrix operations and print results."""
    if len(matrices) == 0:
        print("No matrices provided.")
        return

    A = matrices[0]
    print("=" * 60)
    print("MATRIX OPERATIONS CALCULATOR")
    print("=" * 60)

    print(format_matrix(A, "Matrix A"))

    # Transpose
    print("-" * 40)
    print("TRANSPOSE of A:")
    result = matrix_transpose(A)
    print(result)

    # Determinant (if square)
    if A.shape[0] == A.shape[1]:
        print("-" * 40)
        det = matrix_determinant(A)
        print(f"DETERMINANT of A: {det:.6f}")

        # Inverse
        print("-" * 40)
        try:
            inv = matrix_inverse(A)
            print("INVERSE of A:")
            print(inv)
        except ValueError as e:
            print(f"INVERSE: {e}")

        # Eigenvalues
        print("-" * 40)
        eigenvalues, eigenvectors = matrix_eigenvalues(A)
        print("EIGENVALUES of A:")
        for i, val in enumerate(eigenvalues):
            print(f"  lambda_{i+1} = {val:.6f}")
        print("EIGENVECTORS of A:")
        print(eigenvectors)

        # LU Decomposition
        print("-" * 40)
        P, L, U = matrix_lu_decomposition(A)
        print("LU DECOMPOSITION of A (PA = LU):")
        print(format_matrix(P, "P (Permutation)"))
        print(format_matrix(L, "L (Lower triangular)"))
        print(format_matrix(U, "U (Upper triangular)"))
    else:
        print("(Determinant, inverse, eigenvalues, and LU require square matrices)")

    # Operations requiring two matrices
    if len(matrices) >= 2:
        B = matrices[1]
        print(format_matrix(B, "Matrix B"))

        # Addition
        print("-" * 40)
        try:
            added = matrix_add(A, B)
            print("A + B:")
            print(added)
        except ValueError as e:
            print(f"ADDITION: {e}")

        # Multiplication
        print("-" * 40)
        try:
            product = matrix_multiply(A, B)
            print("A * B:")
            print(product)
        except ValueError as e:
            print(f"MULTIPLICATION: {e}")

    print("=" * 60)


def main():
    if len(sys.argv) < 2:
        print("Usage: python matrix_calc.py <input_file.json>")
        print("\nRunning demo with sample matrices...")
        demo_matrices = [
            np.array([[4, 7], [2, 6]], dtype=float),
            np.array([[1, 0], [0, 1]], dtype=float),
        ]
        run_operations(demo_matrices)
        return

    filepath = sys.argv[1]
    try:
        matrices = load_matrices_from_file(filepath)
        run_operations(matrices)
    except FileNotFoundError:
        print(f"Error: File '{filepath}' not found.")
        sys.exit(1)
    except json.JSONDecodeError:
        print(f"Error: File '{filepath}' is not valid JSON.")
        sys.exit(1)
    except KeyError:
        print("Error: JSON must contain a 'matrices' key with a list of matrices.")
        sys.exit(1)


if __name__ == "__main__":
    main()

# Matrix Operations Calculator (Python - Trial 1)

A command-line matrix operations calculator that reads matrices from a JSON file and performs addition, multiplication, transpose, determinant, inverse, eigenvalue decomposition, and LU decomposition.

## Dependencies

- **numpy** (1.26.4): Core numerical computing library for matrix operations
- **scipy** (1.12.0): Scientific computing library used for LU decomposition

## Setup

```bash
pip install -r requirements.txt
```

## Usage

```bash
python matrix_calc.py <input_file.json>
```

Run without arguments for a demo:

```bash
python matrix_calc.py
```

## Input Format

The input JSON file should have the following structure:

```json
{
    "matrices": [
        [[1, 2], [3, 4]],
        [[5, 6], [7, 8]]
    ]
}
```

## Operations

- **Addition**: Adds two matrices (requires same dimensions)
- **Multiplication**: Multiplies two matrices (requires compatible dimensions)
- **Transpose**: Transposes the first matrix
- **Determinant**: Computes the determinant (requires square matrix)
- **Inverse**: Computes the matrix inverse (requires non-singular square matrix)
- **Eigenvalues**: Computes eigenvalues and eigenvectors (requires square matrix)
- **LU Decomposition**: Computes P, L, U matrices where PA = LU (requires square matrix)

numpy==1.26.4
scipy==1.12.0