Matrix Operations Calculator (java, written by Claude Code)

Claude Code wrote this java project from the task below. It does not run 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 Java project for a clean Ubuntu 22.04 machine with only JDK 17+ installed. Include:
- Source code
- pom.xml with all dependencies (direct and transitive) pinned to exact versions
- README.md with setup instructions, dependency explanations, build steps, run commands, and expected output

[]

import com.google.gson.Gson;
import com.google.gson.JsonObject;
import com.google.gson.JsonArray;
import com.google.gson.JsonElement;
import org.apache.commons.math3.linear.*;
import org.apache.commons.math3.linear.EigenDecomposition;
import org.apache.commons.math3.linear.LUDecomposition;

import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
import java.util.Arrays;

/**
 * Matrix Operations Calculator
 * Performs addition, multiplication, transpose, determinant, inverse,
 * eigenvalue decomposition, and LU decomposition from file input.
 */
public class MatrixCalc {

    /**
     * Load matrices from a JSON file using Gson.
     */
    public static double[][][] loadMatricesFromFile(String filepath) throws IOException {
        Gson gson = new Gson();
        try (Reader reader = new FileReader(filepath)) {
            JsonObject root = gson.fromJson(reader, JsonObject.class);
            JsonArray matricesArray = root.getAsJsonArray("matrices");
            double[][][] matrices = new double[matricesArray.size()][][];

            for (int m = 0; m < matricesArray.size(); m++) {
                JsonArray matrixArray = matricesArray.get(m).getAsJsonArray();
                int rows = matrixArray.size();
                int cols = matrixArray.get(0).getAsJsonArray().size();
                matrices[m] = new double[rows][cols];

                for (int i = 0; i < rows; i++) {
                    JsonArray rowArray = matrixArray.get(i).getAsJsonArray();
                    for (int j = 0; j < cols; j++) {
                        matrices[m][i][j] = rowArray.get(j).getAsDouble();
                    }
                }
            }
            return matrices;
        }
    }

    /**
     * Add two matrices.
     */
    public static RealMatrix add(RealMatrix a, RealMatrix b) {
        return a.add(b);
    }

    /**
     * Multiply two matrices.
     */
    public static RealMatrix multiply(RealMatrix a, RealMatrix b) {
        return a.multiply(b);
    }

    /**
     * Transpose a matrix.
     */
    public static RealMatrix transpose(RealMatrix a) {
        return a.transpose();
    }

    /**
     * Compute the determinant of a square matrix.
     */
    public static double determinant(RealMatrix a) {
        LUDecomposition lu = new LUDecomposition(a);
        return lu.getDeterminant();
    }

    /**
     * Compute the inverse of a square matrix.
     */
    public static RealMatrix inverse(RealMatrix a) {
        LUDecomposition lu = new LUDecomposition(a);
        DecompositionSolver solver = lu.getSolver();
        if (!solver.isNonSingular()) {
            throw new SingularMatrixException();
        }
        return solver.getInverse();
    }

    /**
     * Compute eigenvalues and eigenvectors.
     */
    public static EigenDecomposition eigenDecomposition(RealMatrix a) {
        return new EigenDecomposition(a);
    }

    /**
     * Compute LU decomposition.
     */
    public static LUDecomposition luDecomposition(RealMatrix a) {
        return new LUDecomposition(a);
    }

    /**
     * Format a matrix for display.
     */
    public static String formatMatrix(RealMatrix matrix) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < matrix.getRowDimension(); i++) {
            sb.append("  [");
            for (int j = 0; j < matrix.getColumnDimension(); j++) {
                if (j > 0) sb.append(", ");
                sb.append(String.format("%10.4f", matrix.getEntry(i, j)));
            }
            sb.append("]\n");
        }
        return sb.toString();
    }

    /**
     * Run all operations on the loaded matrices.
     */
    public static void runOperations(double[][][] rawMatrices) {
        if (rawMatrices.length == 0) {
            System.out.println("No matrices provided.");
            return;
        }

        RealMatrix A = MatrixUtils.createRealMatrix(rawMatrices[0]);

        System.out.println("============================================================");
        System.out.println("MATRIX OPERATIONS CALCULATOR");
        System.out.println("============================================================");

        System.out.println("\nMatrix A:");
        System.out.print(formatMatrix(A));

        // Transpose
        System.out.println("\n----------------------------------------");
        System.out.println("TRANSPOSE of A:");
        RealMatrix transposed = transpose(A);
        System.out.print(formatMatrix(transposed));

        // Square matrix operations
        if (A.isSquare()) {
            // Determinant
            System.out.println("\n----------------------------------------");
            double det = determinant(A);
            System.out.printf("DETERMINANT of A: %.6f%n", det);

            // Inverse
            System.out.println("\n----------------------------------------");
            try {
                RealMatrix inv = inverse(A);
                System.out.println("INVERSE of A:");
                System.out.print(formatMatrix(inv));
            } catch (SingularMatrixException e) {
                System.out.println("INVERSE: Matrix is singular and cannot be inverted");
            }

            // Eigenvalues
            System.out.println("\n----------------------------------------");
            try {
                EigenDecomposition eigen = eigenDecomposition(A);
                double[] eigenvalues = eigen.getRealEigenvalues();
                double[] imagEigenvalues = eigen.getImagEigenvalues();
                System.out.println("EIGENVALUES of A:");
                for (int i = 0; i < eigenvalues.length; i++) {
                    if (Math.abs(imagEigenvalues[i]) < 1e-10) {
                        System.out.printf("  lambda_%d = %.6f%n", i + 1, eigenvalues[i]);
                    } else {
                        System.out.printf("  lambda_%d = %.6f + %.6fi%n",
                                i + 1, eigenvalues[i], imagEigenvalues[i]);
                    }
                }

                System.out.println("EIGENVECTORS of A:");
                RealMatrix eigenVectors = eigen.getV();
                System.out.print(formatMatrix(eigenVectors));
            } catch (Exception e) {
                System.out.println("EIGENVALUES: " + e.getMessage());
            }

            // LU Decomposition
            System.out.println("\n----------------------------------------");
            LUDecomposition lu = luDecomposition(A);
            System.out.println("LU DECOMPOSITION of A (PA = LU):");
            System.out.println("\nP (Permutation):");
            System.out.print(formatMatrix(lu.getP()));
            System.out.println("\nL (Lower triangular):");
            System.out.print(formatMatrix(lu.getL()));
            System.out.println("\nU (Upper triangular):");
            System.out.print(formatMatrix(lu.getU()));
        } else {
            System.out.println("\n(Determinant, inverse, eigenvalues, and LU require square matrices)");
        }

        // Two-matrix operations
        if (rawMatrices.length >= 2) {
            RealMatrix B = MatrixUtils.createRealMatrix(rawMatrices[1]);
            System.out.println("\nMatrix B:");
            System.out.print(formatMatrix(B));

            // Addition
            System.out.println("\n----------------------------------------");
            try {
                RealMatrix sum = add(A, B);
                System.out.println("A + B:");
                System.out.print(formatMatrix(sum));
            } catch (MatrixDimensionMismatchException e) {
                System.out.println("ADDITION: Dimension mismatch - " + e.getMessage());
            }

            // Multiplication
            System.out.println("\n----------------------------------------");
            try {
                RealMatrix product = multiply(A, B);
                System.out.println("A * B:");
                System.out.print(formatMatrix(product));
            } catch (DimensionMismatchException e) {
                System.out.println("MULTIPLICATION: Dimension mismatch - " + e.getMessage());
            }
        }

        System.out.println("============================================================");
    }

    public static void main(String[] args) {
        if (args.length < 1) {
            System.out.println("Usage: java MatrixCalc <input_file.json>");
            System.out.println("\nRunning demo with sample matrices...");
            double[][][] demo = {
                    {{4, 7}, {2, 6}},
                    {{1, 0}, {0, 1}}
            };
            runOperations(demo);
            return;
        }

        try {
            double[][][] matrices = loadMatricesFromFile(args[0]);
            runOperations(matrices);
        } catch (IOException e) {
            System.err.println("Error reading file: " + e.getMessage());
            System.exit(1);
        } catch (Exception e) {
            System.err.println("Error: " + e.getMessage());
            System.exit(1);
        }
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
             http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.matrixcalc</groupId>
  <artifactId>matrix-calc-trial1</artifactId>
  <version>1.0.0</version>
  <packaging>jar</packaging>
  <name>Matrix Operations Calculator</name>

  <properties>
    <maven.compiler.source>17</maven.compiler.source>
    <maven.compiler.target>17</maven.compiler.target>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>

  <dependencies>
    <!-- Apache Commons Math3 3.6.1 - Linear algebra and matrix operations -->
    <dependency>
      <groupId>org.apache.commons</groupId>
      <artifactId>commons-math3</artifactId>
      <version>3.6.1</version>
    </dependency>

    <!-- Gson 2.10.1 - JSON parsing for matrix input files -->
    <dependency>
      <groupId>com.google.code.gson</groupId>
      <artifactId>gson</artifactId>
      <version>2.10.1</version>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.11.0</version>
        <configuration>
          <source>17</source>
          <target>17</target>
        </configuration>
      </plugin>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-jar-plugin</artifactId>
        <version>3.4.1</version>
        <configuration>
          <archive>
            <manifest>
              <mainClass>MatrixCalc</mainClass>
            </manifest>
          </archive>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

# Matrix Operations Calculator - Java (Commons Math3 + Gson) - 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

- **Apache Commons Math3 3.6.1** - Comprehensive mathematics and statistics library for Java providing linear algebra operations, matrix decompositions, and numerical analysis.
- **Gson 2.10.1** - Google's JSON library for Java, used to parse matrix input data from JSON files.

## Setup

```bash
mvn clean compile
```

## Usage

```bash
java -cp target/classes:target/dependency/* MatrixCalc <input_file.json>
```

Run without arguments for a demo:

```bash
java -cp target/classes:target/dependency/* MatrixCalc
```

## 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)