Matrix Operations Calculator (java, written by Claude Code)

--- /dev/null
+++ b/src/main/java/MatrixCalc.java
@@ -0,0 +1,268 @@
+import org.ejml.simple.SimpleMatrix;
+import org.ejml.dense.row.factory.DecompositionFactory_DDRM;
+import org.ejml.interfaces.decomposition.EigenDecomposition_F64;
+import org.ejml.interfaces.decomposition.LUDecomposition;
+import org.ejml.data.DMatrixRMaj;
+import org.ejml.dense.row.CommonOps_DDRM;
+import org.ejml.dense.row.NormOps_DDRM;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.JsonNode;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Matrix Operations Calculator
+ * Performs addition, multiplication, transpose, determinant, inverse,
+ * eigenvalue decomposition, and LU decomposition from file input.
+ * Uses EJML 0.43.1 and Jackson 2.16.1.
+ */
+public class MatrixCalc {
+
+    /**
+     * Load matrices from a JSON file using Jackson.
+     */
+    public static List<SimpleMatrix> loadMatricesFromFile(String filepath) throws IOException {
+        ObjectMapper mapper = new ObjectMapper();
+        JsonNode root = mapper.readTree(new File(filepath));
+        JsonNode matricesNode = root.get("matrices");
+        List<SimpleMatrix> matrices = new ArrayList<>();
+
+        for (JsonNode matNode : matricesNode) {
+            int rows = matNode.size();
+            int cols = matNode.get(0).size();
+            SimpleMatrix mat = new SimpleMatrix(rows, cols);
+            for (int i = 0; i < rows; i++) {
+                JsonNode rowNode = matNode.get(i);
+                for (int j = 0; j < cols; j++) {
+                    mat.set(i, j, rowNode.get(j).asDouble());
+                }
+            }
+            matrices.add(mat);
+        }
+        return matrices;
+    }
+
+    /**
+     * Add two matrices.
+     */
+    public static SimpleMatrix add(SimpleMatrix a, SimpleMatrix b) {
+        return a.plus(b);
+    }
+
+    /**
+     * Multiply two matrices.
+     */
+    public static SimpleMatrix multiply(SimpleMatrix a, SimpleMatrix b) {
+        return a.mult(b);
+    }
+
+    /**
+     * Transpose a matrix.
+     */
+    public static SimpleMatrix transpose(SimpleMatrix a) {
+        return a.transpose();
+    }
+
+    /**
+     * Compute the determinant of a square matrix.
+     */
+    public static double determinant(SimpleMatrix a) {
+        return a.determinant();
+    }
+
+    /**
+     * Compute the inverse of a square matrix.
+     */
+    public static SimpleMatrix inverse(SimpleMatrix a) {
+        double det = a.determinant();
+        if (Math.abs(det) < 1e-12) {
+            throw new ArithmeticException("Matrix is singular and cannot be inverted");
+        }
+        return a.invert();
+    }
+
+    /**
+     * Format a matrix for display.
+     */
+    public static String formatMatrix(SimpleMatrix matrix) {
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < matrix.getNumRows(); i++) {
+            sb.append("  [");
+            for (int j = 0; j < matrix.getNumCols(); j++) {
+                if (j > 0) sb.append(", ");
+                sb.append(String.format("%10.4f", matrix.get(i, j)));
+            }
+            sb.append("]\n");
+        }
+        return sb.toString();
+    }
+
+    /**
+     * Run all operations on the loaded matrices.
+     */
+    public static void runOperations(List<SimpleMatrix> matrices) {
+        if (matrices.isEmpty()) {
+            System.out.println("No matrices provided.");
+            return;
+        }
+
+        SimpleMatrix A = matrices.get(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:");
+        System.out.print(formatMatrix(transpose(A)));
+
+        // Square matrix operations
+        if (A.getNumRows() == A.getNumCols()) {
+            int n = A.getNumRows();
+
+            // Determinant
+            System.out.println("\n----------------------------------------");
+            double det = determinant(A);
+            System.out.printf("DETERMINANT of A: %.6f%n", det);
+
+            // Inverse
+            System.out.println("\n----------------------------------------");
+            try {
+                SimpleMatrix inv = inverse(A);
+                System.out.println("INVERSE of A:");
+                System.out.print(formatMatrix(inv));
+            } catch (ArithmeticException e) {
+                System.out.println("INVERSE: " + e.getMessage());
+            }
+
+            // Eigenvalues using EJML decomposition
+            System.out.println("\n----------------------------------------");
+            try {
+                DMatrixRMaj aMat = A.getMatrix().copy();
+                EigenDecomposition_F64<DMatrixRMaj> eigenDecomp =
+                    DecompositionFactory_DDRM.eig(n, true);
+                if (eigenDecomp.decompose(aMat)) {
+                    System.out.println("EIGENVALUES of A:");
+                    for (int i = 0; i < eigenDecomp.getNumberOfEigenvalues(); i++) {
+                        var eigenvalue = eigenDecomp.getEigenvalue(i);
+                        if (Math.abs(eigenvalue.getImaginary()) < 1e-10) {
+                            System.out.printf("  lambda_%d = %.6f%n", i + 1, eigenvalue.getReal());
+                        } else {
+                            System.out.printf("  lambda_%d = %.6f + %.6fi%n",
+                                i + 1, eigenvalue.getReal(), eigenvalue.getImaginary());
+                        }
+                    }
+                    System.out.println("EIGENVECTORS of A:");
+                    for (int i = 0; i < eigenDecomp.getNumberOfEigenvalues(); i++) {
+                        DMatrixRMaj eigVec = eigenDecomp.getEigenVector(i);
+                        if (eigVec != null) {
+                            StringBuilder vecStr = new StringBuilder("  v_" + (i + 1) + " = [");
+                            for (int j = 0; j < eigVec.getNumRows(); j++) {
+                                if (j > 0) vecStr.append(", ");
+                                vecStr.append(String.format("%.4f", eigVec.get(j, 0)));
+                            }
+                            vecStr.append("]");
+                            System.out.println(vecStr);
+                        }
+                    }
+                } else {
+                    System.out.println("EIGENVALUES: Decomposition failed");
+                }
+            } catch (Exception e) {
+                System.out.println("EIGENVALUES: " + e.getMessage());
+            }
+
+            // LU Decomposition
+            System.out.println("\n----------------------------------------");
+            try {
+                DMatrixRMaj aMat = A.getMatrix().copy();
+                LUDecomposition<DMatrixRMaj> luDecomp =
+                    DecompositionFactory_DDRM.lu(n, n);
+                if (luDecomp.decompose(aMat)) {
+                    System.out.println("LU DECOMPOSITION of A (PA = LU):");
+
+                    DMatrixRMaj lower = new DMatrixRMaj(n, n);
+                    DMatrixRMaj upper = new DMatrixRMaj(n, n);
+                    DMatrixRMaj pivot = new DMatrixRMaj(n, n);
+
+                    luDecomp.getLower(lower);
+                    luDecomp.getUpper(upper);
+                    luDecomp.getRowPivot(pivot);
+
+                    System.out.println("\nP (Permutation):");
+                    System.out.print(formatMatrix(SimpleMatrix.wrap(pivot)));
+                    System.out.println("\nL (Lower triangular):");
+                    System.out.print(formatMatrix(SimpleMatrix.wrap(lower)));
+                    System.out.println("\nU (Upper triangular):");
+                    System.out.print(formatMatrix(SimpleMatrix.wrap(upper)));
+                } else {
+                    System.out.println("LU DECOMPOSITION: Decomposition failed");
+                }
+            } catch (Exception e) {
+                System.out.println("LU DECOMPOSITION: " + e.getMessage());
+            }
+        } else {
+            System.out.println("\n(Determinant, inverse, eigenvalues, and LU require square matrices)");
+        }
+
+        // Two-matrix operations
+        if (matrices.size() >= 2) {
+            SimpleMatrix B = matrices.get(1);
+            System.out.println("\nMatrix B:");
+            System.out.print(formatMatrix(B));
+
+            // Addition
+            System.out.println("\n----------------------------------------");
+            try {
+                SimpleMatrix sum = add(A, B);
+                System.out.println("A + B:");
+                System.out.print(formatMatrix(sum));
+            } catch (Exception e) {
+                System.out.println("ADDITION: Dimension mismatch - " + e.getMessage());
+            }
+
+            // Multiplication
+            System.out.println("\n----------------------------------------");
+            try {
+                SimpleMatrix product = multiply(A, B);
+                System.out.println("A * B:");
+                System.out.print(formatMatrix(product));
+            } catch (Exception 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...");
+            List<SimpleMatrix> demo = new ArrayList<>();
+            demo.add(new SimpleMatrix(new double[][]{{4, 7}, {2, 6}}));
+            demo.add(new SimpleMatrix(new double[][]{{1, 0}, {0, 1}}));
+            runOperations(demo);
+            return;
+        }
+
+        try {
+            List<SimpleMatrix> 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);
+        }
+    }
+}

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

[
  {
    "category": "misspecification",
    "rule": "signature.build_layout_mismatch",
    "source": "failure_signature",
    "excerpt": "error: no classes were compiled"
  }
]

import org.ejml.simple.SimpleMatrix;
import org.ejml.dense.row.factory.DecompositionFactory_DDRM;
import org.ejml.interfaces.decomposition.EigenDecomposition_F64;
import org.ejml.interfaces.decomposition.LUDecomposition;
import org.ejml.data.DMatrixRMaj;
import org.ejml.dense.row.CommonOps_DDRM;
import org.ejml.dense.row.NormOps_DDRM;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.JsonNode;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

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

    /**
     * Load matrices from a JSON file using Jackson.
     */
    public static List<SimpleMatrix> loadMatricesFromFile(String filepath) throws IOException {
        ObjectMapper mapper = new ObjectMapper();
        JsonNode root = mapper.readTree(new File(filepath));
        JsonNode matricesNode = root.get("matrices");
        List<SimpleMatrix> matrices = new ArrayList<>();

        for (JsonNode matNode : matricesNode) {
            int rows = matNode.size();
            int cols = matNode.get(0).size();
            SimpleMatrix mat = new SimpleMatrix(rows, cols);
            for (int i = 0; i < rows; i++) {
                JsonNode rowNode = matNode.get(i);
                for (int j = 0; j < cols; j++) {
                    mat.set(i, j, rowNode.get(j).asDouble());
                }
            }
            matrices.add(mat);
        }
        return matrices;
    }

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

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

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

    /**
     * Compute the determinant of a square matrix.
     */
    public static double determinant(SimpleMatrix a) {
        return a.determinant();
    }

    /**
     * Compute the inverse of a square matrix.
     */
    public static SimpleMatrix inverse(SimpleMatrix a) {
        double det = a.determinant();
        if (Math.abs(det) < 1e-12) {
            throw new ArithmeticException("Matrix is singular and cannot be inverted");
        }
        return a.invert();
    }

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

    /**
     * Run all operations on the loaded matrices.
     */
    public static void runOperations(List<SimpleMatrix> matrices) {
        if (matrices.isEmpty()) {
            System.out.println("No matrices provided.");
            return;
        }

        SimpleMatrix A = matrices.get(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:");
        System.out.print(formatMatrix(transpose(A)));

        // Square matrix operations
        if (A.getNumRows() == A.getNumCols()) {
            int n = A.getNumRows();

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

            // Inverse
            System.out.println("\n----------------------------------------");
            try {
                SimpleMatrix inv = inverse(A);
                System.out.println("INVERSE of A:");
                System.out.print(formatMatrix(inv));
            } catch (ArithmeticException e) {
                System.out.println("INVERSE: " + e.getMessage());
            }

            // Eigenvalues using EJML decomposition
            System.out.println("\n----------------------------------------");
            try {
                DMatrixRMaj aMat = A.getMatrix().copy();
                EigenDecomposition_F64<DMatrixRMaj> eigenDecomp =
                    DecompositionFactory_DDRM.eig(n, true);
                if (eigenDecomp.decompose(aMat)) {
                    System.out.println("EIGENVALUES of A:");
                    for (int i = 0; i < eigenDecomp.getNumberOfEigenvalues(); i++) {
                        var eigenvalue = eigenDecomp.getEigenvalue(i);
                        if (Math.abs(eigenvalue.getImaginary()) < 1e-10) {
                            System.out.printf("  lambda_%d = %.6f%n", i + 1, eigenvalue.getReal());
                        } else {
                            System.out.printf("  lambda_%d = %.6f + %.6fi%n",
                                i + 1, eigenvalue.getReal(), eigenvalue.getImaginary());
                        }
                    }
                    System.out.println("EIGENVECTORS of A:");
                    for (int i = 0; i < eigenDecomp.getNumberOfEigenvalues(); i++) {
                        DMatrixRMaj eigVec = eigenDecomp.getEigenVector(i);
                        if (eigVec != null) {
                            StringBuilder vecStr = new StringBuilder("  v_" + (i + 1) + " = [");
                            for (int j = 0; j < eigVec.getNumRows(); j++) {
                                if (j > 0) vecStr.append(", ");
                                vecStr.append(String.format("%.4f", eigVec.get(j, 0)));
                            }
                            vecStr.append("]");
                            System.out.println(vecStr);
                        }
                    }
                } else {
                    System.out.println("EIGENVALUES: Decomposition failed");
                }
            } catch (Exception e) {
                System.out.println("EIGENVALUES: " + e.getMessage());
            }

            // LU Decomposition
            System.out.println("\n----------------------------------------");
            try {
                DMatrixRMaj aMat = A.getMatrix().copy();
                LUDecomposition<DMatrixRMaj> luDecomp =
                    DecompositionFactory_DDRM.lu(n, n);
                if (luDecomp.decompose(aMat)) {
                    System.out.println("LU DECOMPOSITION of A (PA = LU):");

                    DMatrixRMaj lower = new DMatrixRMaj(n, n);
                    DMatrixRMaj upper = new DMatrixRMaj(n, n);
                    DMatrixRMaj pivot = new DMatrixRMaj(n, n);

                    luDecomp.getLower(lower);
                    luDecomp.getUpper(upper);
                    luDecomp.getRowPivot(pivot);

                    System.out.println("\nP (Permutation):");
                    System.out.print(formatMatrix(SimpleMatrix.wrap(pivot)));
                    System.out.println("\nL (Lower triangular):");
                    System.out.print(formatMatrix(SimpleMatrix.wrap(lower)));
                    System.out.println("\nU (Upper triangular):");
                    System.out.print(formatMatrix(SimpleMatrix.wrap(upper)));
                } else {
                    System.out.println("LU DECOMPOSITION: Decomposition failed");
                }
            } catch (Exception e) {
                System.out.println("LU DECOMPOSITION: " + e.getMessage());
            }
        } else {
            System.out.println("\n(Determinant, inverse, eigenvalues, and LU require square matrices)");
        }

        // Two-matrix operations
        if (matrices.size() >= 2) {
            SimpleMatrix B = matrices.get(1);
            System.out.println("\nMatrix B:");
            System.out.print(formatMatrix(B));

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

            // Multiplication
            System.out.println("\n----------------------------------------");
            try {
                SimpleMatrix product = multiply(A, B);
                System.out.println("A * B:");
                System.out.print(formatMatrix(product));
            } catch (Exception 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...");
            List<SimpleMatrix> demo = new ArrayList<>();
            demo.add(new SimpleMatrix(new double[][]{{4, 7}, {2, 6}}));
            demo.add(new SimpleMatrix(new double[][]{{1, 0}, {0, 1}}));
            runOperations(demo);
            return;
        }

        try {
            List<SimpleMatrix> 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-trial2</artifactId>
    <version>1.0.0</version>
    <packaging>jar</packaging>

    <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>
        <dependency>
            <groupId>org.ejml</groupId>
            <artifactId>ejml-all</artifactId>
            <version>0.43.1</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.16.1</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <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>