Numerical Integration Calculator (javascript, written by Codex)

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

Task given to the agent:

TASK: Numerical Integration Calculator

Write a program that computes definite integrals of mathematical functions using multiple numerical methods, comparing accuracy and convergence across methods.

FUNCTIONAL REQUIREMENTS:
- Accept a mathematical expression as a command-line argument via --function flag (e.g., --function "sin(x)*exp(-x)")
- Accept integration bounds via --lower and --upper flags
- Support multiple numerical integration methods selectable via --method flag: trapezoidal rule, Simpson's rule, Simpson's 3/8 rule, Gaussian quadrature, and Romberg integration
- Support a configurable number of subintervals via --intervals flag (default: 1000) for methods that use subdivision
- Run all methods and compare results via --compare flag, showing each method's result, estimated error, and computation time
- Support adaptive integration: automatically refine the interval count until the result converges within a specified tolerance via --tolerance flag (default: 1e-10)
- Parse mathematical expressions supporting: basic operators (+, -, *, /, ^), standard functions (sin, cos, tan, exp, log, sqrt, abs), constants (pi, e), and nested parentheses
- Support improper integrals with infinite bounds via --infinite flag using appropriate limit-based techniques
- Support tabulated data integration: read (x, y) pairs from a CSV file via --data flag and integrate using the available methods
- Print results to console: integral value, estimated error, method used, intervals used, and computation time
- Save results as JSON with --output flag (default: integration_result.json)
- If no input is given, compute several well-known integrals (integral of sin(x) from 0 to pi = 2, integral of exp(-x^2) from 0 to infinity = sqrt(pi)/2, integral of 1/x from 1 to e = 1) using all methods and display a comparison table with exact vs computed values and relative errors
- Handle errors: division by zero within the integration range, non-convergent integrals, invalid mathematical expressions, and bounds where lower > upper

Create a complete JavaScript project for a clean Ubuntu 22.04 machine with only Node.js 20+ (LTS) installed. Include:
- Source code
- package.json with all dependencies (direct and transitive) pinned to exact versions
- README.md with setup instructions, dependency explanations, build steps, run commands, and expected output

[]

{
  "name": "numerical-integration-calculator",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "numerical-integration-calculator",
      "version": "1.0.0",
      "license": "MIT",
      "dependencies": {
        "mathjs": "13.2.2"
      },
      "engines": {
        "node": ">=20.0.0"
      }
    },
    "node_modules/@babel/runtime": {
      "version": "7.28.6",
      "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.28.6.tgz",
      "integrity": "sha512-05WQkdpL9COIMz4LjTxGpPNCdlpyimKppYNoJ5Di5EUObifl8t4tuLuUBBZEpoLYOmfvIWrsp9fCl0HoPRVTdA==",
      "license": "MIT",
      "engines": {
        "node": ">=6.9.0"
      }
    },
    "node_modules/complex.js": {
      "version": "2.4.3",
      "resolved": "https://registry.npmjs.org/complex.js/-/complex.js-2.4.3.tgz",
      "integrity": "sha512-UrQVSUur14tNX6tiP4y8T4w4FeJAX3bi2cIv0pu/DTLFNxoq7z2Yh83Vfzztj6Px3X/lubqQ9IrPp7Bpn6p4MQ==",
      "license": "MIT",
      "engines": {
        "node": "*"
      },
      "funding": {
        "type": "github",
        "url": "https://github.com/sponsors/rawify"
      }
    },
    "node_modules/decimal.js": {
      "version": "10.6.0",
      "resolved": "https://registry.npmjs.org/decimal.js/-/decimal.js-10.6.0.tgz",
      "integrity": "sha512-YpgQiITW3JXGntzdUmyUR1V812Hn8T1YVXhCu+wO3OpS4eU9l4YdD3qjyiKdV6mvV29zapkMeD390UVEf2lkUg==",
      "license": "MIT"
    },
    "node_modules/escape-latex": {
      "version": "1.2.0",
      "resolved": "https://registry.npmjs.org/escape-latex/-/escape-latex-1.2.0.tgz",
      "integrity": "sha512-nV5aVWW1K0wEiUIEdZ4erkGGH8mDxGyxSeqPzRNtWP7ataw+/olFObw7hujFWlVjNsaDFw5VZ5NzVSIqRgfTiw==",
      "license": "MIT"
    },
    "node_modules/fraction.js": {
      "version": "4.3.7",
      "resolved": "https://registry.npmjs.org/fraction.js/-/fraction.js-4.3.7.tgz",
      "integrity": "sha512-ZsDfxO51wGAXREY55a7la9LScWpwv9RxIrYABrlvOFBlH/ShPnrtsXeuUIfXKKOVicNxQ+o8JTbJvjS4M89yew==",
      "license": "MIT",
      "engines": {
        "node": "*"
      },
      "funding": {
        "type": "patreon",
        "url": "https://github.com/sponsors/rawify"
      }
    },
    "node_modules/javascript-natural-sort": {
      "version": "0.7.1",
      "resolved": "https://registry.npmjs.org/javascript-natural-sort/-/javascript-natural-sort-0.7.1.tgz",
      "integrity": "sha512-nO6jcEfZWQXDhOiBtG2KvKyEptz7RVbpGP4vTD2hLBdmNQSsCiicO2Ioinv6UI4y9ukqnBpy+XZ9H6uLNgJTlw==",
      "license": "MIT"
    },
    "node_modules/mathjs": {
      "version": "13.2.2",
      "resolved": "https://registry.npmjs.org/mathjs/-/mathjs-13.2.2.tgz",
      "integrity": "sha512-tBNMmwNsLMjD7xGHSF9IEuuzNVG8xPDgshDBY1eQ5ZS1HQr5O+bY8eG2peZYSkIsw79y2QcPkGMcQL5ZqtLu5A==",
      "license": "Apache-2.0",
      "dependencies": {
        "@babel/runtime": "^7.25.7",
        "complex.js": "^2.2.5",
        "decimal.js": "^10.4.3",
        "escape-latex": "^1.2.0",
        "fraction.js": "^4.3.7",
        "javascript-natural-sort": "^0.7.1",
        "seedrandom": "^3.0.5",
        "tiny-emitter": "^2.1.0",
        "typed-function": "^4.2.1"
      },
      "bin": {
        "mathjs": "bin/cli.js"
      },
      "engines": {
        "node": ">= 18"
      }
    },
    "node_modules/seedrandom": {
      "version": "3.0.5",
      "resolved": "https://registry.npmjs.org/seedrandom/-/seedrandom-3.0.5.tgz",
      "integrity": "sha512-8OwmbklUNzwezjGInmZ+2clQmExQPvomqjL7LFqOYqtmuxRgQYqOD3mHaU+MvZn5FLUeVxVfQjwLZW/n/JFuqg==",
      "license": "MIT"
    },
    "node_modules/tiny-emitter": {
      "version": "2.1.0",
      "resolved": "https://registry.npmjs.org/tiny-emitter/-/tiny-emitter-2.1.0.tgz",
      "integrity": "sha512-NB6Dk1A9xgQPMoGqC5CVXn123gWyte215ONT5Pp5a0yt4nlEoO1ZWeCwpncaekPHXO60i47ihFnZPiRPjRMq4Q==",
      "license": "MIT"
    },
    "node_modules/typed-function": {
      "version": "4.2.2",
      "resolved": "https://registry.npmjs.org/typed-function/-/typed-function-4.2.2.tgz",
      "integrity": "sha512-VwaXim9Gp1bngi/q3do8hgttYn2uC3MoT/gfuMWylnj1IeZBUAyPddHZlo1K05BDoj8DYPpMdiHqH1dDYdJf2A==",
      "license": "MIT",
      "engines": {
        "node": ">= 18"
      }
    }
  }
}

{
  "name": "numerical-integration-calculator",
  "version": "1.0.0",
  "description": "Numerical integration with multiple methods",
  "type": "module",
  "main": "src/index.js",
  "scripts": { "start": "node src/index.js" },
  "engines": { "node": ">=20.0.0" },
  "dependencies": {
    "mathjs": "13.2.2"
  },
  "license": "MIT"
}

# Numerical Integration Calculator (JavaScript)

## Requirements
- Ubuntu 22.04
- Node.js 20+

## Install
```bash
npm install
```

## Run
```bash
node src/index.js --function "sin(x)*exp(-x)" --lower 0 --upper 10 --method simpson
node src/index.js --function "exp(-x^2)" --lower 0 --upper inf --method romberg --infinite
node src/index.js --function "1/x" --lower 1 --upper 2 --compare
node src/index.js --data points.csv --method trapezoidal
```

If no input is provided, well-known integrals are computed and compared across methods.

import fs from "node:fs";
import path from "node:path";
import process from "node:process";
import { create, all } from "mathjs";

const math = create(all, {});

function parseArgs(argv) {
  const cfg = {
    fn: null,
    lower: null,
    upper: null,
    method: "trapezoidal",
    intervals: 1000,
    compare: false,
    tolerance: 1e-10,
    infinite: false,
    data: null,
    output: "integration_result.json"
  };
  for (let i = 0; i < argv.length; i += 1) {
    const a = argv[i];
    if (a === "--function") cfg.fn = argv[++i];
    else if (a === "--lower") cfg.lower = argv[++i];
    else if (a === "--upper") cfg.upper = argv[++i];
    else if (a === "--method") cfg.method = argv[++i];
    else if (a === "--intervals") cfg.intervals = Number.parseInt(argv[++i], 10);
    else if (a === "--compare") cfg.compare = true;
    else if (a === "--tolerance") cfg.tolerance = Number(argv[++i]);
    else if (a === "--infinite") cfg.infinite = true;
    else if (a === "--data") cfg.data = argv[++i];
    else if (a === "--output") cfg.output = argv[++i];
    else throw new Error(`Unknown option: ${a}`);
  }
  return cfg;
}

function parseBound(v) {
  if (v === null || v === undefined) return null;
  const s = String(v).toLowerCase();
  if (s === "inf" || s === "+inf" || s === "infinity" || s === "+infinity") return Infinity;
  if (s === "-inf" || s === "-infinity") return -Infinity;
  return Number(v);
}

function compileFn(expr) {
  const node = math.parse(expr);
  return (x) => {
    const v = node.evaluate({ x, pi: Math.PI, e: Math.E });
    if (!Number.isFinite(v)) throw new Error(`Function evaluation invalid at x=${x}`);
    return v;
  };
}

function trapezoidal(f, a, b, n) {
  const h = (b - a) / n;
  let s = 0.5 * (f(a) + f(b));
  for (let i = 1; i < n; i += 1) s += f(a + i * h);
  return s * h;
}

function simpson(f, a, b, n) {
  if (n % 2 !== 0) n += 1;
  const h = (b - a) / n;
  let s = f(a) + f(b);
  for (let i = 1; i < n; i += 1) s += (i % 2 === 0 ? 2 : 4) * f(a + i * h);
  return (s * h) / 3;
}

function simpson38(f, a, b, n) {
  while (n % 3 !== 0) n += 1;
  const h = (b - a) / n;
  let s = f(a) + f(b);
  for (let i = 1; i < n; i += 1) s += (i % 3 === 0 ? 2 : 3) * f(a + i * h);
  return (3 * h * s) / 8;
}

function gauss5(f, a, b) {
  const xs = [0, -0.5384693101056831, 0.5384693101056831, -0.9061798459386640, 0.9061798459386640];
  const ws = [0.5688888888888889, 0.4786286704993665, 0.4786286704993665, 0.2369268850561891, 0.2369268850561891];
  const c1 = (b - a) / 2;
  const c2 = (b + a) / 2;
  let s = 0;
  for (let i = 0; i < xs.length; i += 1) s += ws[i] * f(c1 * xs[i] + c2);
  return c1 * s;
}

function romberg(f, a, b, maxK = 6) {
  const R = Array.from({ length: maxK }, () => Array(maxK).fill(0));
  for (let k = 0; k < maxK; k += 1) {
    const n = 2 ** k;
    R[k][0] = trapezoidal(f, a, b, n);
    for (let j = 1; j <= k; j += 1) {
      R[k][j] = R[k][j - 1] + (R[k][j - 1] - R[k - 1][j - 1]) / (4 ** j - 1);
    }
  }
  return R[maxK - 1][maxK - 1];
}

function integrateMethod(name, f, a, b, n) {
  if (name === "trapezoidal") return trapezoidal(f, a, b, n);
  if (name === "simpson") return simpson(f, a, b, n);
  if (name === "simpson38") return simpson38(f, a, b, n);
  if (name === "gaussian") return gauss5(f, a, b);
  if (name === "romberg") return romberg(f, a, b);
  throw new Error(`Unsupported method: ${name}`);
}

function adaptive(name, f, a, b, n0, tol) {
  let n = n0;
  let prev = integrateMethod(name, f, a, b, n);
  for (let i = 0; i < 20; i += 1) {
    n *= 2;
    const cur = integrateMethod(name, f, a, b, n);
    if (Math.abs(cur - prev) < tol) return { value: cur, intervals: n, estimatedError: Math.abs(cur - prev) };
    prev = cur;
  }
  return { value: prev, intervals: n, estimatedError: NaN };
}

function handleInfinite(f, a, b, method, n, tol) {
  if (Number.isFinite(a) && Number.isFinite(b)) return adaptive(method, f, a, b, n, tol);

  if (!Number.isFinite(b) && Number.isFinite(a)) {
    const g = (t) => {
      const x = a + t / (1 - t);
      return f(x) / ((1 - t) ** 2);
    };
    return adaptive(method, g, 0, 1 - 1e-8, n, tol);
  }
  if (!Number.isFinite(a) && Number.isFinite(b)) {
    const g = (t) => {
      const x = b - t / (1 - t);
      return f(x) / ((1 - t) ** 2);
    };
    return adaptive(method, g, 0, 1 - 1e-8, n, tol);
  }

  const g = (t) => {
    const x = Math.tan(Math.PI * (t - 0.5));
    return f(x) * Math.PI / (Math.cos(Math.PI * (t - 0.5)) ** 2);
  };
  return adaptive(method, g, 1e-8, 1 - 1e-8, n, tol);
}

function integrateFromData(file, method) {
  const rows = fs.readFileSync(file, "utf8").trim().split(/\r?\n/).map((l) => l.split(",").map(Number));
  const x = rows.map((r) => r[0]);
  const y = rows.map((r) => r[1]);
  if (x.length < 2) throw new Error("Tabulated data needs at least 2 points");

  if (method === "trapezoidal") {
    let s = 0;
    for (let i = 0; i < x.length - 1; i += 1) s += 0.5 * (x[i + 1] - x[i]) * (y[i] + y[i + 1]);
    return s;
  }

  const f = (xp) => {
    if (xp <= x[0]) return y[0];
    if (xp >= x[x.length - 1]) return y[y.length - 1];
    for (let i = 0; i < x.length - 1; i += 1) {
      if (xp >= x[i] && xp <= x[i + 1]) {
        const t = (xp - x[i]) / (x[i + 1] - x[i]);
        return y[i] * (1 - t) + y[i + 1] * t;
      }
    }
    return 0;
  };
  return simpson(f, x[0], x[x.length - 1], 1000);
}

function compareAll(f, a, b, n, tol) {
  const methods = ["trapezoidal", "simpson", "simpson38", "gaussian", "romberg"];
  const out = [];
  for (const m of methods) {
    const t0 = Date.now();
    const r = handleInfinite(f, a, b, m, n, tol);
    const t1 = Date.now();
    out.push({ method: m, value: r.value, estimatedError: r.estimatedError, intervals: r.intervals, timeMs: t1 - t0 });
  }
  return out;
}

function runKnownIntegrals() {
  const cases = [
    { name: "integral sin(x) [0,pi]", expr: "sin(x)", a: 0, b: Math.PI, exact: 2 },
    { name: "integral exp(-x^2) [0,inf]", expr: "exp(-x^2)", a: 0, b: Infinity, exact: Math.sqrt(Math.PI) / 2 },
    { name: "integral 1/x [1,e]", expr: "1/x", a: 1, b: Math.E, exact: 1 }
  ];

  const methods = ["trapezoidal", "simpson", "simpson38", "gaussian", "romberg"];
  const results = [];
  for (const c of cases) {
    const f = compileFn(c.expr);
    for (const m of methods) {
      const r = handleInfinite(f, c.a, c.b, m, 1000, 1e-10);
      results.push({
        case: c.name,
        method: m,
        computed: r.value,
        exact: c.exact,
        relativeError: Math.abs((r.value - c.exact) / c.exact)
      });
    }
  }
  return results;
}

function main() {
  try {
    const cfg = parseArgs(process.argv.slice(2));

    if (!cfg.fn && !cfg.data) {
      const demo = runKnownIntegrals();
      console.table(demo.map((r) => ({ Case: r.case, Method: r.method, Computed: r.computed, Exact: r.exact, RelErr: r.relativeError })));
      fs.writeFileSync(cfg.output, JSON.stringify({ config: cfg, comparison: demo }, null, 2), "utf8");
      return;
    }

    if (cfg.data) {
      const t0 = Date.now();
      const value = integrateFromData(cfg.data, cfg.method);
      const result = { mode: "tabulated", method: cfg.method, value, timeMs: Date.now() - t0 };
      console.log(JSON.stringify(result, null, 2));
      fs.writeFileSync(cfg.output, JSON.stringify({ config: cfg, result }, null, 2), "utf8");
      return;
    }

    const a = parseBound(cfg.lower);
    const b = parseBound(cfg.upper);
    if (a === null || b === null) throw new Error("--lower and --upper are required for function integration");
    if (Number.isFinite(a) && Number.isFinite(b) && a > b) throw new Error("Lower bound cannot exceed upper bound");

    const f = compileFn(cfg.fn);

    if (cfg.compare) {
      const comp = compareAll(f, a, b, cfg.intervals, cfg.tolerance);
      console.table(comp.map((r) => ({ Method: r.method, Value: r.value, EstErr: r.estimatedError, Intervals: r.intervals, TimeMs: r.timeMs })));
      fs.writeFileSync(cfg.output, JSON.stringify({ config: cfg, comparison: comp }, null, 2), "utf8");
      return;
    }

    const t0 = Date.now();
    const r = handleInfinite(f, a, b, cfg.method, cfg.intervals, cfg.tolerance);
    const result = {
      method: cfg.method,
      value: r.value,
      estimatedError: r.estimatedError,
      intervals: r.intervals,
      timeMs: Date.now() - t0
    };

    console.log(JSON.stringify(result, null, 2));
    fs.writeFileSync(cfg.output, JSON.stringify({ config: cfg, result }, null, 2), "utf8");
  } catch (err) {
    console.error(`Error: ${err.message}`);
    process.exit(1);
  }
}

main();