diff-grok 1.1.0 → 1.3.0

package/src/tests/lsoda-lib-correctness.test.ts

@@ -1,283 +0,0 @@
-import {Lsoda} from '../solver-tools/lsoda';
-import {ODEs} from '../../index';
-import {corrProbs} from '../examples/corr-probs';
-
-// ─── Robertson chemical kinetics (original test) ────────────────────────────
-
-function fex(t: number, y: Float64Array, ydot: Float64Array): number {
-  ydot[0] = 1.0e4 * y[1] * y[2] - 0.04 * y[0];
-  ydot[2] = 3.0e7 * y[1] * y[1];
-  ydot[1] = -(ydot[0] + ydot[2]);
-  return 0;
-}
-
-const expected = [
-  {t: 4.0000e-01, y: [9.851712e-01, 3.386380e-05, 1.479493e-02]},
-  {t: 4.0000e+00, y: [9.055333e-01, 2.240655e-05, 9.444430e-02]},
-  {t: 4.0000e+01, y: [7.158403e-01, 9.186334e-06, 2.841505e-01]},
-  {t: 4.0000e+02, y: [4.505250e-01, 3.222964e-06, 5.494717e-01]},
-  {t: 4.0000e+03, y: [1.831976e-01, 8.941773e-07, 8.168015e-01]},
-  {t: 4.0000e+04, y: [3.898729e-02, 1.621940e-07, 9.610125e-01]},
-  {t: 4.0000e+05, y: [4.936362e-03, 1.984221e-08, 9.950636e-01]},
-  {t: 4.0000e+06, y: [5.161833e-04, 2.065787e-09, 9.994838e-01]},
-  {t: 4.0000e+07, y: [5.179804e-05, 2.072027e-10, 9.999482e-01]},
-  {t: 4.0000e+08, y: [5.283675e-06, 2.113481e-11, 9.999947e-01]},
-  {t: 4.0000e+09, y: [4.658667e-07, 1.863468e-12, 9.999995e-01]},
-  {t: 4.0000e+10, y: [1.431100e-08, 5.724404e-14, 1.000000e+00]},
-];
-
-// ─── Helpers ─────────────────────────────────────────────────────────────────
-
-function relError(computed: number, reference: number): number {
-  if (reference === 0) return Math.abs(computed);
-  return Math.abs((computed - reference) / reference);
-}
-
-/** Wraps an ODEs func into an OdeFunction compatible with Lsoda (returns 0). */
-function wrapFunc(ode: ODEs): (t: number, y: Float64Array, ydot: Float64Array) => number {
-  return (t, y, ydot) => {
-    ode.func(t, y, ydot);
-    return 0;
-  };
-}
-
-/**
- * Solves an ODE problem and checks against the exact solution at the final time point.
- * Uses combined absolute + relative tolerance: |computed - exact| < checkTol * |exact| + checkAbsTol.
- */
-function solveAndCheck(
-  ode: ODEs,
-  exactSolution: (t: number) => Float64Array,
-  checkTol: number = 1e-3,
-  checkAbsTol: number = 1e-6,
-) {
-  const neq = ode.initial.length;
-  const tol = ode.tolerance;
-  const rtol = new Float64Array(neq).fill(tol);
-  const atol = new Float64Array(neq).fill(tol);
-
-  const solver = new Lsoda(wrapFunc(ode), neq, {rtol, atol, itask: 1});
-
-  let y: ArrayLike<number> = [...ode.initial];
-  let t = ode.arg.start;
-  const step = ode.arg.step;
-  const finish = ode.arg.finish;
-
-  let tout = t + step;
-  while (tout <= finish + step / 2) {
-    const result = solver.solve(y, t, tout);
-    y = result.y;
-    t = result.t;
-
-    expect(solver.state).toBeGreaterThan(0);
-    tout += step;
-  }
-
-  // Check final solution against exact using combined abs + rel tolerance
-  const exact = exactSolution(t);
-  for (let j = 0; j < neq; j++) {
-    const absErr = Math.abs(y[j] - exact[j]);
-    const allowed = checkTol * Math.abs(exact[j]) + checkAbsTol;
-    expect(absErr).toBeLessThan(allowed);
-  }
-}
-
-// ─── Tests ───────────────────────────────────────────────────────────────────
-
-const nonStiffProbs = corrProbs.filter((p) => p.odes.name.startsWith('non-stiff'));
-const stiffProbs = corrProbs.filter((p) => p.odes.name.startsWith('stiff'));
-
-describe('LSODA LIB', () => {
-  it('should solve Robertson chemical kinetics with expected accuracy', () => {
-    const neq = 3;
-    const rtol = new Float64Array([1.0e-4, 1.0e-4, 1.0e-4]);
-    const atol = new Float64Array([1.0e-6, 1.0e-10, 1.0e-6]);
-
-    const solver = new Lsoda(fex, neq, {
-      rtol,
-      atol,
-      itask: 1,
-    });
-
-    let y: ArrayLike<number> = [1.0, 0.0, 0.0];
-    let t = 0.0;
-    let tout = 0.4;
-
-    for (let iout = 0; iout < 12; iout++) {
-      const result = solver.solve(y, t, tout);
-      y = result.y;
-      t = result.t;
-
-      expect(solver.state).toBeGreaterThan(0);
-
-      const exp = expected[iout];
-      for (let j = 0; j < 3; j++) {
-        const err = relError(y[j], exp.y[j]);
-        expect(err).toBeLessThanOrEqual(5e-3);
-      }
-
-      tout *= 10.0;
-    }
-  });
-
-  describe('non-stiff problems', () => {
-    nonStiffProbs.forEach(({odes, exact}) => {
-      it(`should solve ${odes.name} problem`, () => {
-        solveAndCheck(odes, exact);
-      });
-    });
-  });
-
-  describe('stiff problems', () => {
-    stiffProbs.forEach(({odes, exact}) => {
-      it(`should solve ${odes.name} problem`, () => {
-        solveAndCheck(odes, exact);
-      });
-    });
-  });
-
-  // ─── Dense output tests ───────────────────────────────────────────────────
-
-  describe('dense output', () => {
-    // Helper: run Robertson to completion with dense output enabled
-    function solveRobertsonDense() {
-      const neq = 3;
-      const rtol = new Float64Array([1.0e-4, 1.0e-4, 1.0e-4]);
-      const atol = new Float64Array([1.0e-6, 1.0e-10, 1.0e-6]);
-
-      const solver = new Lsoda(fex, neq, {rtol, atol, itask: 1, dense: true});
-
-      let y: ArrayLike<number> = [1.0, 0.0, 0.0];
-      let t = 0.0;
-      let tout = 0.4;
-
-      for (let iout = 0; iout < 12; iout++) {
-        const result = solver.solve(y, t, tout);
-        y = result.y;
-        t = result.t;
-        tout *= 10.0;
-      }
-
-      return solver.getDenseOutput();
-    }
-
-    it('consistency: dense output should match direct solver results (Robertson)', () => {
-      const dense = solveRobertsonDense();
-
-      // Query dense output at the same tout points used in the reference test
-      const tPoints = Float64Array.from(expected.map((e) => e.t));
-      const results = dense.solveAtTimes(tPoints);
-
-      for (let i = 0; i < expected.length; i++) {
-        for (let j = 0; j < 3; j++) {
-          const err = relError(results[j][i], expected[i].y[j]);
-          expect(err).toBeLessThanOrEqual(5e-3);
-        }
-      }
-    });
-
-    it('monotonicity: uniform query should have increasing t and finite y', () => {
-      const dense = solveRobertsonDense();
-
-      // Query at 1000 uniform points across the full range
-      const tMin = dense.tMin;
-      const tMax = dense.tMax;
-      const n = 1000;
-      const tArray = new Float64Array(n);
-      for (let i = 0; i < n; i++)
-        tArray[i] = tMin + (tMax - tMin) * i / (n - 1);
-
-      const results = dense.solveAtTimes(tArray);
-      expect(results.length).toBe(3);
-      for (let j = 0; j < 3; j++)
-        expect(results[j].length).toBe(n);
-
-      for (let i = 1; i < n; i++)
-        expect(tArray[i]).toBeGreaterThan(tArray[i - 1]);
-
-      for (let i = 0; i < n; i++) {
-        for (let j = 0; j < 3; j++)
-          expect(Number.isFinite(results[j][i])).toBe(true);
-      }
-    });
-
-    it('boundary: query at tMin and tMax should succeed', () => {
-      const dense = solveRobertsonDense();
-
-      const yMin = dense.evaluateAt(dense.tMin);
-      const yMax = dense.evaluateAt(dense.tMax);
-
-      expect(yMin.length).toBe(3);
-      expect(yMax.length).toBe(3);
-      for (let j = 0; j < 3; j++) {
-        expect(Number.isFinite(yMin[j])).toBe(true);
-        expect(Number.isFinite(yMax[j])).toBe(true);
-      }
-    });
-
-    it('solveOnGrid: should return correct grid dimensions and quality', () => {
-      const dense = solveRobertsonDense();
-
-      const {t, y} = dense.solveOnGrid(0, 4e10, 1e9);
-
-      expect(t.length).toBe(41);
-      expect(y.length).toBe(3);
-      for (let j = 0; j < 3; j++)
-        expect(y[j].length).toBe(41);
-      expect(t[0]).toBeCloseTo(0, 10);
-      expect(t[t.length - 1]).toBeCloseTo(4e10, 0);
-
-      // Check solution quality at a sampled point (t=4e10)
-      const refLast = expected[expected.length - 1].y;
-      for (let j = 0; j < 3; j++) {
-        const err = relError(y[j][t.length - 1], refLast[j]);
-        expect(err).toBeLessThanOrEqual(5e-3);
-      }
-    });
-
-    function denseExactCheck(
-      ode: ODEs,
-      exactSolution: (t: number) => Float64Array,
-      checkTol: number = 1e-3,
-      checkAbsTol: number = 1e-6,
-    ) {
-      const neq = ode.initial.length;
-      const tol = ode.tolerance;
-      const rtol = new Float64Array(neq).fill(tol);
-      const atol = new Float64Array(neq).fill(tol);
-
-      const solver = new Lsoda(wrapFunc(ode), neq, {rtol, atol, itask: 1, dense: true});
-
-      let y: ArrayLike<number> = [...ode.initial];
-      let t = ode.arg.start;
-      const finish = ode.arg.finish;
-      const result = solver.solve(y, t, finish);
-      y = result.y;
-      t = result.t;
-
-      const dense = solver.getDenseOutput();
-
-      // Query at 100 points and compare against exact solution
-      const nPts = 100;
-      const tArr = new Float64Array(nPts + 1);
-      for (let i = 0; i <= nPts; i++)
-        tArr[i] = ode.arg.start + (finish - ode.arg.start) * i / nPts;
-
-      const results = dense.solveAtTimes(tArr);
-      for (let i = 0; i < tArr.length; i++) {
-        const exact = exactSolution(tArr[i]);
-        for (let j = 0; j < neq; j++) {
-          const absErr = Math.abs(results[j][i] - exact[j]);
-          const allowed = checkTol * Math.abs(exact[j]) + checkAbsTol;
-          expect(absErr).toBeLessThan(allowed);
-        }
-      }
-    }
-
-    corrProbs.forEach(({odes, exact}) => {
-      it(`dense output on ${odes.name} problem should match exact solution`, () => {
-        denseExactCheck(odes, exact);
-      });
-    });
-  });
-});

package/src/tests/lsoda-lib-performance.test.js

@@ -1,95 +0,0 @@
-import { Lsoda } from '../solver-tools/lsoda';
-import { robertson, robertsonReferencePoint } from '../examples/robertson';
-import { hires, hiresReferencePoint } from '../examples/hires';
-import { vdpol, vdpolReferencePoint } from '../examples/vdpol';
-import { orego, oregoReferencePoint } from '../examples/orego';
-import { e5, e5ReferencePoint } from '../examples/e5';
-import { pollution, pollutionReferencePoint } from '../examples/pollution';
-// ─── Helpers ─────────────────────────────────────────────────────────────────
-/** Wraps an ODEs func into an OdeFunction compatible with Lsoda (returns 0). */
-function wrapFunc(ode) {
-    return (t, y, ydot) => {
-        ode.func(t, y, ydot);
-        return 0;
-    };
-}
-/** Solves a benchmark problem, checks accuracy against the reference point, and verifies solver health. */
-function solveBenchmarkAndCheck(ode, referencePoint, relTol, absTol, opts) {
-    var _a, _b;
-    const neq = ode.initial.length;
-    const tol = ode.tolerance;
-    const rtol = (_a = opts === null || opts === void 0 ? void 0 : opts.rtol) !== null && _a !== void 0 ? _a : new Float64Array(neq).fill(tol);
-    const atol = (_b = opts === null || opts === void 0 ? void 0 : opts.atol) !== null && _b !== void 0 ? _b : new Float64Array(neq).fill(tol);
-    const solver = new Lsoda(wrapFunc(ode), neq, Object.assign(Object.assign({ rtol, atol, itask: 1 }, ((opts === null || opts === void 0 ? void 0 : opts.mxstep) ? { mxstep: opts.mxstep } : {})), ((opts === null || opts === void 0 ? void 0 : opts.hmax) ? { hmax: opts.hmax } : {})));
-    let y = [...ode.initial];
-    let t = ode.arg.start;
-    const step = ode.arg.step;
-    const finish = ode.arg.finish;
-    // Warmup phase: bootstrap very stiff problems with a small initial tout
-    if ((opts === null || opts === void 0 ? void 0 : opts.warmupTout) !== undefined) {
-        const result = solver.solve(y, t, opts.warmupTout);
-        y = result.y;
-        t = result.t;
-        expect(solver.state).toBeGreaterThan(0);
-    }
-    let tout = t + step;
-    while (tout <= finish + step / 2) {
-        const result = solver.solve(y, t, tout);
-        y = result.y;
-        t = result.t;
-        if (solver.state <= 0)
-            throw new Error(`${ode.name}: solver failed at t=${t} with state=${solver.state}, error: ${solver.error}`);
-        tout += step;
-    }
-    // Check final solution against reference point
-    for (let j = 0; j < neq; j++) {
-        const absErr = Math.abs(y[j] - referencePoint[j]);
-        const allowed = relTol * Math.abs(referencePoint[j]) + absTol;
-        expect(absErr).toBeLessThan(allowed);
-    }
-}
-// ─── Performance tests ──────────────────────────────────────────────────────
-// Robertson: components span many orders of magnitude; use component-wise atol
-describe('Robertson', () => {
-    it('should solve correctly', () => {
-        solveBenchmarkAndCheck(robertson, robertsonReferencePoint, 1e-2, 1e-7, {
-            mxstep: 50000,
-            atol: new Float64Array([1e-8, 1e-14, 1e-8]),
-            rtol: new Float64Array([1e-7, 1e-7, 1e-7]),
-        });
-    }, 60000);
-});
-describe('HIRES', () => {
-    it('should solve correctly', () => {
-        solveBenchmarkAndCheck(hires, hiresReferencePoint, 1e-3, 1e-12);
-    }, 60000);
-});
-// Van der Pol (mu=1000): very stiff, needs many internal steps
-describe('van der Pol', () => {
-    it('should solve correctly', () => {
-        solveBenchmarkAndCheck(vdpol, vdpolReferencePoint, 1e-3, 1e-6, {
-            mxstep: 50000,
-        });
-    }, 60000);
-});
-describe('OREGO', () => {
-    it('should solve correctly', () => {
-        solveBenchmarkAndCheck(orego, oregoReferencePoint, 1e-2, 1e-6);
-    }, 60000);
-});
-// E5: extremely stiff (rate constants span 20 orders), needs warmup and many steps.
-// Reference values are near-zero (y1~1e-290, y2~1e-22), so absTol must be generous.
-describe('E5', () => {
-    it('should solve correctly', () => {
-        solveBenchmarkAndCheck(e5, e5ReferencePoint, 1, 1e-6, {
-            mxstep: 50000,
-            warmupTout: 1e-5,
-        });
-    }, 60000);
-});
-describe('Pollution', () => {
-    it('should solve correctly', () => {
-        solveBenchmarkAndCheck(pollution, pollutionReferencePoint, 1e-2, 1e-10);
-    }, 60000);
-});
-//# sourceMappingURL=lsoda-lib-performance.test.js.map

package/src/tests/lsoda-lib-performance.test.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"lsoda-lib-performance.test.js","sourceRoot":"","sources":["lsoda-lib-performance.test.ts"],"names":[],"mappings":"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"}

package/src/tests/lsoda-lib-performance.test.ts

@@ -1,126 +0,0 @@
-import {Lsoda} from '../solver-tools/lsoda';
-import {ODEs} from '../../index';
-import {robertson, robertsonReferencePoint} from '../examples/robertson';
-import {hires, hiresReferencePoint} from '../examples/hires';
-import {vdpol, vdpolReferencePoint} from '../examples/vdpol';
-import {orego, oregoReferencePoint} from '../examples/orego';
-import {e5, e5ReferencePoint} from '../examples/e5';
-import {pollution, pollutionReferencePoint} from '../examples/pollution';
-
-// ─── Helpers ─────────────────────────────────────────────────────────────────
-
-/** Wraps an ODEs func into an OdeFunction compatible with Lsoda (returns 0). */
-function wrapFunc(ode: ODEs): (t: number, y: Float64Array, ydot: Float64Array) => number {
-  return (t, y, ydot) => {
-    ode.func(t, y, ydot);
-    return 0;
-  };
-}
-
-interface SolverOpts {
-  mxstep?: number;
-  hmax?: number;
-  rtol?: Float64Array;
-  atol?: Float64Array;
-  /** Small initial tout to bootstrap very stiff problems before the main loop. */
-  warmupTout?: number;
-}
-
-/** Solves a benchmark problem, checks accuracy against the reference point, and verifies solver health. */
-function solveBenchmarkAndCheck(
-  ode: ODEs, referencePoint: Float64Array, relTol: number, absTol: number, opts?: SolverOpts,
-): void {
-  const neq = ode.initial.length;
-  const tol = ode.tolerance;
-  const rtol = opts?.rtol ?? new Float64Array(neq).fill(tol);
-  const atol = opts?.atol ?? new Float64Array(neq).fill(tol);
-
-  const solver = new Lsoda(wrapFunc(ode), neq, {
-    rtol, atol, itask: 1,
-    ...(opts?.mxstep ? {mxstep: opts.mxstep} : {}),
-    ...(opts?.hmax ? {hmax: opts.hmax} : {}),
-  });
-
-  let y: ArrayLike<number> = [...ode.initial];
-  let t = ode.arg.start;
-  const step = ode.arg.step;
-  const finish = ode.arg.finish;
-
-  // Warmup phase: bootstrap very stiff problems with a small initial tout
-  if (opts?.warmupTout !== undefined) {
-    const result = solver.solve(y, t, opts.warmupTout);
-    y = result.y;
-    t = result.t;
-    expect(solver.state).toBeGreaterThan(0);
-  }
-
-  let tout = t + step;
-  while (tout <= finish + step / 2) {
-    const result = solver.solve(y, t, tout);
-    y = result.y;
-    t = result.t;
-
-    if (solver.state <= 0)
-      throw new Error(`${ode.name}: solver failed at t=${t} with state=${solver.state}, error: ${solver.error}`);
-
-    tout += step;
-  }
-
-  // Check final solution against reference point
-  for (let j = 0; j < neq; j++) {
-    const absErr = Math.abs(y[j] - referencePoint[j]);
-    const allowed = relTol * Math.abs(referencePoint[j]) + absTol;
-    expect(absErr).toBeLessThan(allowed);
-  }
-}
-
-// ─── Performance tests ──────────────────────────────────────────────────────
-
-// Robertson: components span many orders of magnitude; use component-wise atol
-describe('Robertson', () => {
-  it('should solve correctly', () => {
-    solveBenchmarkAndCheck(robertson, robertsonReferencePoint, 1e-2, 1e-7, {
-      mxstep: 50000,
-      atol: new Float64Array([1e-8, 1e-14, 1e-8]),
-      rtol: new Float64Array([1e-7, 1e-7, 1e-7]),
-    });
-  }, 60000);
-});
-
-describe('HIRES', () => {
-  it('should solve correctly', () => {
-    solveBenchmarkAndCheck(hires, hiresReferencePoint, 1e-3, 1e-12);
-  }, 60000);
-});
-
-// Van der Pol (mu=1000): very stiff, needs many internal steps
-describe('van der Pol', () => {
-  it('should solve correctly', () => {
-    solveBenchmarkAndCheck(vdpol, vdpolReferencePoint, 1e-3, 1e-6, {
-      mxstep: 50000,
-    });
-  }, 60000);
-});
-
-describe('OREGO', () => {
-  it('should solve correctly', () => {
-    solveBenchmarkAndCheck(orego, oregoReferencePoint, 1e-2, 1e-6);
-  }, 60000);
-});
-
-// E5: extremely stiff (rate constants span 20 orders), needs warmup and many steps.
-// Reference values are near-zero (y1~1e-290, y2~1e-22), so absTol must be generous.
-describe('E5', () => {
-  it('should solve correctly', () => {
-    solveBenchmarkAndCheck(e5, e5ReferencePoint, 1, 1e-6, {
-      mxstep: 50000,
-      warmupTout: 1e-5,
-    });
-  }, 60000);
-});
-
-describe('Pollution', () => {
-  it('should solve correctly', () => {
-    solveBenchmarkAndCheck(pollution, pollutionReferencePoint, 1e-2, 1e-10);
-  }, 60000);
-});

package/src/tests/performance.test.js

@@ -1,16 +0,0 @@
-// Performance tests
-import { perfProbs } from '../../index';
-import { implicitMethods, TIMEOUT_MS } from './test-defs';
-implicitMethods.forEach((method, name) => {
-    describe(`${name}`, () => {
-        perfProbs.forEach((odes) => {
-            test(`${odes.name}`, () => {
-                const start = performance.now();
-                method(odes);
-                const elapsed = performance.now() - start;
-                expect(elapsed).toBeLessThan(TIMEOUT_MS);
-            });
-        });
-    });
-});
-//# sourceMappingURL=performance.test.js.map

package/src/tests/performance.test.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"performance.test.js","sourceRoot":"","sources":["performance.test.ts"],"names":[],"mappings":"AAAA,oBAAoB;AAEpB,OAAO,EAAC,SAAS,EAAC,MAAM,aAAa,CAAC;AACtC,OAAO,EAAC,eAAe,EAAE,UAAU,EAAC,MAAM,aAAa,CAAC;AAExD,eAAe,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,IAAI,EAAE,EAAE;IACvC,QAAQ,CAAC,GAAG,IAAI,EAAE,EAAE,GAAG,EAAE;QACvB,SAAS,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE;YACzB,IAAI,CAAC,GAAG,IAAI,CAAC,IAAI,EAAE,EAAE,GAAG,EAAE;gBACxB,MAAM,KAAK,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC;gBAChC,MAAM,CAAC,IAAI,CAAC,CAAC;gBACb,MAAM,OAAO,GAAG,WAAW,CAAC,GAAG,EAAE,GAAG,KAAK,CAAC;gBAC1C,MAAM,CAAC,OAAO,CAAC,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC;YAC3C,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}

package/src/tests/performance.test.ts

@@ -1,17 +0,0 @@
-// Performance tests
-
-import {perfProbs} from '../../index';
-import {implicitMethods, TIMEOUT_MS} from './test-defs';
-
-implicitMethods.forEach((method, name) => {
-  describe(`${name}`, () => {
-    perfProbs.forEach((odes) => {
-      test(`${odes.name}`, () => {
-        const start = performance.now();
-        method(odes);
-        const elapsed = performance.now() - start;
-        expect(elapsed).toBeLessThan(TIMEOUT_MS);
-      });
-    });
-  });
-});

package/src/tests/pipeline.test.js

@@ -1,10 +0,0 @@
-// Pipeline tests
-import { problems } from './test-defs';
-import { evalModel } from './test-utils';
-problems.forEach((task, name) => {
-    test(`Pipeline: model - ${name}`, () => {
-        const solution = evalModel(task.model, task.inputs);
-        expect(solution.length).toBe(task.outputsCount);
-    });
-});
-//# sourceMappingURL=pipeline.test.js.map

package/src/tests/pipeline.test.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"pipeline.test.js","sourceRoot":"","sources":["pipeline.test.ts"],"names":[],"mappings":"AAAA,iBAAiB;AAEjB,OAAO,EAAC,QAAQ,EAAC,MAAM,aAAa,CAAC;AACrC,OAAO,EAAC,SAAS,EAAC,MAAM,cAAc,CAAC;AAEvC,QAAQ,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,IAAI,EAAE,EAAE;IAC9B,IAAI,CAAC,qBAAqB,IAAI,EAAE,EAAE,GAAG,EAAE;QACrC,MAAM,QAAQ,GAAG,SAAS,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;QACpD,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;IAClD,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}

package/src/tests/pipeline.test.ts

@@ -1,11 +0,0 @@
-// Pipeline tests
-
-import {problems} from './test-defs';
-import {evalModel} from './test-utils';
-
-problems.forEach((task, name) => {
-  test(`Pipeline: model - ${name}`, () => {
-    const solution = evalModel(task.model, task.inputs);
-    expect(solution.length).toBe(task.outputsCount);
-  });
-});