Matrix Operations Calculator (cpp, written by Claude Code)

Claude Code wrote this cpp 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 C++ project for a clean Ubuntu 22.04 machine with only G++ 12+ and CMake 3.22+ installed. Include:
- Source code
- CMakeLists.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

[]

cmake_minimum_required(VERSION 3.22)
project(matrix_calc VERSION 1.0.0 LANGUAGES CXX)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)

# ---------------------------------------------------------------------------
# Dependencies
# ---------------------------------------------------------------------------
# Eigen 3.4.0 — C++ template library for linear algebra
# nlohmann/json 3.11.3 — header-only JSON library
# ---------------------------------------------------------------------------

include(FetchContent)

FetchContent_Declare(
    eigen
    GIT_REPOSITORY https://gitlab.com/libeigen/eigen.git
    GIT_TAG        3.4.0
    GIT_SHALLOW    TRUE
)

FetchContent_Declare(
    nlohmann_json
    GIT_REPOSITORY https://github.com/nlohmann/json.git
    GIT_TAG        v3.11.3
    GIT_SHALLOW    TRUE
)

set(EIGEN_BUILD_DOC OFF CACHE BOOL "" FORCE)
set(EIGEN_BUILD_TESTING OFF CACHE BOOL "" FORCE)
set(BUILD_TESTING OFF CACHE BOOL "" FORCE)

set(JSON_BuildTests OFF CACHE BOOL "" FORCE)
set(JSON_Install OFF CACHE BOOL "" FORCE)
set(JSON_MultipleHeaders OFF CACHE BOOL "" FORCE)

FetchContent_MakeAvailable(eigen nlohmann_json)

# ---------------------------------------------------------------------------
# Executable
# ---------------------------------------------------------------------------

add_executable(matrix_calc main.cpp)

target_link_libraries(matrix_calc PRIVATE
    Eigen3::Eigen
    nlohmann_json::nlohmann_json
)

if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
    target_compile_options(matrix_calc PRIVATE -Wall -Wextra -Wpedantic)
endif()

/**
 * Matrix Operations Calculator
 * Performs addition, multiplication, transpose, determinant, inverse,
 * eigenvalue decomposition, and LU decomposition from file input.
 * Uses Eigen 3.4.0 and nlohmann/json 3.11.3.
 */

#include <iostream>
#include <fstream>
#include <vector>
#include <string>
#include <iomanip>
#include <cmath>
#include <Eigen/Dense>
#include <nlohmann/json.hpp>

using json = nlohmann::json;
using Eigen::MatrixXd;
using Eigen::VectorXcd;

/**
 * Load matrices from a JSON file.
 * Expected format: { "matrices": [ [[1,2],[3,4]], [[5,6],[7,8]] ] }
 */
std::vector<MatrixXd> loadMatricesFromFile(const std::string& filepath) {
    std::ifstream file(filepath);
    if (!file.is_open()) {
        throw std::runtime_error("Cannot open file: " + filepath);
    }

    json data = json::parse(file);
    std::vector<MatrixXd> matrices;

    for (const auto& matJson : data["matrices"]) {
        int rows = static_cast<int>(matJson.size());
        int cols = static_cast<int>(matJson[0].size());
        MatrixXd mat(rows, cols);
        for (int i = 0; i < rows; ++i) {
            for (int j = 0; j < cols; ++j) {
                mat(i, j) = matJson[i][j].get<double>();
            }
        }
        matrices.push_back(mat);
    }
    return matrices;
}

/**
 * Format a matrix for display.
 */
std::string formatMatrix(const MatrixXd& m) {
    std::ostringstream oss;
    oss << std::fixed << std::setprecision(4);
    for (int i = 0; i < m.rows(); ++i) {
        oss << "  [";
        for (int j = 0; j < m.cols(); ++j) {
            if (j > 0) oss << ", ";
            oss << std::setw(10) << m(i, j);
        }
        oss << "]\n";
    }
    return oss.str();
}

/**
 * Run all matrix operations and print results.
 */
void runOperations(const std::vector<MatrixXd>& matrices) {
    if (matrices.empty()) {
        std::cout << "No matrices provided." << std::endl;
        return;
    }

    const MatrixXd& A = matrices[0];

    std::cout << std::string(60, '=') << "\n";
    std::cout << "MATRIX OPERATIONS CALCULATOR\n";
    std::cout << std::string(60, '=') << "\n";

    std::cout << "\nMatrix A:\n" << formatMatrix(A);

    // Transpose
    std::cout << "\n" << std::string(40, '-') << "\n";
    std::cout << "TRANSPOSE of A:\n";
    std::cout << formatMatrix(A.transpose());

    // Square matrix operations
    if (A.rows() == A.cols()) {
        // Determinant
        std::cout << "\n" << std::string(40, '-') << "\n";
        double det = A.determinant();
        std::cout << std::fixed << std::setprecision(6);
        std::cout << "DETERMINANT of A: " << det << "\n";

        // Inverse
        std::cout << "\n" << std::string(40, '-') << "\n";
        if (std::abs(det) < 1e-12) {
            std::cout << "INVERSE: Matrix is singular and cannot be inverted\n";
        } else {
            std::cout << "INVERSE of A:\n";
            std::cout << formatMatrix(A.inverse());
        }

        // Eigenvalues
        std::cout << "\n" << std::string(40, '-') << "\n";
        Eigen::EigenSolver<MatrixXd> eigenSolver(A);
        VectorXcd eigenvalues = eigenSolver.eigenvalues();
        std::cout << "EIGENVALUES of A:\n";
        for (int i = 0; i < eigenvalues.size(); ++i) {
            if (std::abs(eigenvalues[i].imag()) < 1e-10) {
                std::cout << "  lambda_" << (i + 1) << " = "
                          << eigenvalues[i].real() << "\n";
            } else {
                std::cout << "  lambda_" << (i + 1) << " = "
                          << eigenvalues[i].real() << " + "
                          << eigenvalues[i].imag() << "i\n";
            }
        }

        auto eigenvectors = eigenSolver.eigenvectors();
        std::cout << "EIGENVECTORS of A:\n";
        for (int j = 0; j < eigenvectors.cols(); ++j) {
            std::cout << "  v_" << (j + 1) << " = [";
            for (int i = 0; i < eigenvectors.rows(); ++i) {
                if (i > 0) std::cout << ", ";
                if (std::abs(eigenvectors(i, j).imag()) < 1e-10) {
                    std::cout << std::fixed << std::setprecision(4) << eigenvectors(i, j).real();
                } else {
                    std::cout << std::fixed << std::setprecision(4)
                              << eigenvectors(i, j).real() << "+" << eigenvectors(i, j).imag() << "i";
                }
            }
            std::cout << "]\n";
        }

        // LU Decomposition
        std::cout << "\n" << std::string(40, '-') << "\n";
        Eigen::FullPivLU<MatrixXd> lu(A);
        std::cout << "LU DECOMPOSITION of A (PA = LU):\n";
        std::cout << "\nP (Permutation):\n";
        MatrixXd P = lu.permutationP().toDenseMatrix().cast<double>();
        std::cout << formatMatrix(P);
        std::cout << "\nL (Lower triangular):\n";
        MatrixXd L = MatrixXd::Identity(A.rows(), A.rows());
        MatrixXd LU = lu.matrixLU();
        for (int i = 0; i < A.rows(); ++i) {
            for (int j = 0; j < i && j < A.cols(); ++j) {
                L(i, j) = LU(i, j);
            }
        }
        std::cout << formatMatrix(L);
        std::cout << "\nU (Upper triangular):\n";
        MatrixXd U = MatrixXd::Zero(A.rows(), A.cols());
        for (int i = 0; i < A.rows(); ++i) {
            for (int j = i; j < A.cols(); ++j) {
                U(i, j) = LU(i, j);
            }
        }
        std::cout << formatMatrix(U);
    } else {
        std::cout << "\n(Determinant, inverse, eigenvalues, and LU require square matrices)\n";
    }

    // Two-matrix operations
    if (matrices.size() >= 2) {
        const MatrixXd& B = matrices[1];
        std::cout << "\nMatrix B:\n" << formatMatrix(B);

        // Addition
        std::cout << "\n" << std::string(40, '-') << "\n";
        if (A.rows() == B.rows() && A.cols() == B.cols()) {
            std::cout << "A + B:\n";
            std::cout << formatMatrix(A + B);
        } else {
            std::cout << "ADDITION: Shape mismatch\n";
        }

        // Multiplication
        std::cout << "\n" << std::string(40, '-') << "\n";
        if (A.cols() == B.rows()) {
            std::cout << "A * B:\n";
            std::cout << formatMatrix(A * B);
        } else {
            std::cout << "MULTIPLICATION: Shape mismatch\n";
        }
    }

    std::cout << std::string(60, '=') << "\n";
}

int main(int argc, char* argv[]) {
    if (argc < 2) {
        std::cout << "Usage: ./matrix_calc <input_file.json>\n";
        std::cout << "\nRunning demo with sample matrices...\n";

        std::vector<MatrixXd> demoMatrices;
        MatrixXd A(2, 2);
        A << 4, 7, 2, 6;
        MatrixXd B(2, 2);
        B << 1, 0, 0, 1;
        demoMatrices.push_back(A);
        demoMatrices.push_back(B);
        runOperations(demoMatrices);
        return 0;
    }

    try {
        auto matrices = loadMatricesFromFile(argv[1]);
        runOperations(matrices);
    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
        return 1;
    }
    return 0;
}