iapws-if97 2.1.5 → 2.2.0

package/dist/solvers/damped-newton-2d.js

@@ -0,0 +1,68 @@
+/** Damped Newton solver for two coupled nonlinear equations. */
+import { ConvergenceError, IF97Error } from '../types.js';
+function maxNorm([a, b]) {
+    return Math.max(Math.abs(a), Math.abs(b));
+}
+function isFiniteEvaluation(value) {
+    return value.residual.every(Number.isFinite) &&
+        value.jacobian.every((row) => row.every(Number.isFinite));
+}
+export function dampedNewton2D(evaluate, initial, options) {
+    const tolerance = options?.tolerance ?? 1e-10;
+    const maxIterations = options?.maxIterations ?? 20;
+    const maxBacktracks = options?.maxBacktracks ?? 20;
+    const isValid = (point) => point.every(Number.isFinite) && (options?.isValid?.(point) ?? true);
+    const tryEvaluate = (point) => {
+        if (!isValid(point))
+            return null;
+        try {
+            const value = evaluate(point);
+            return isFiniteEvaluation(value) ? value : null;
+        }
+        catch (error) {
+            if (error instanceof IF97Error)
+                return null;
+            throw error;
+        }
+    };
+    let point = [...initial];
+    let value = tryEvaluate(point);
+    if (value === null)
+        throw new ConvergenceError('dampedNewton2D', 1);
+    for (let iteration = 0; iteration < maxIterations; iteration += 1) {
+        const norm = maxNorm(value.residual);
+        if (norm <= tolerance)
+            return point;
+        const [[a, b], [c, d]] = value.jacobian;
+        const determinant = a * d - b * c;
+        const determinantScale = Math.abs(a * d) + Math.abs(b * c);
+        if (!Number.isFinite(determinant) || determinantScale === 0 ||
+            Math.abs(determinant) <= Number.EPSILON * determinantScale) {
+            throw new ConvergenceError('dampedNewton2D', iteration + 1);
+        }
+        const [r1, r2] = value.residual;
+        const step = [
+            (d * r1 - b * r2) / determinant,
+            (a * r2 - c * r1) / determinant,
+        ];
+        let damping = 1;
+        let accepted = false;
+        for (let backtrack = 0; backtrack <= maxBacktracks; backtrack += 1) {
+            const candidate = [
+                point[0] - damping * step[0],
+                point[1] - damping * step[1],
+            ];
+            const candidateValue = tryEvaluate(candidate);
+            if (candidateValue !== null && maxNorm(candidateValue.residual) < norm) {
+                point = candidate;
+                value = candidateValue;
+                accepted = true;
+                break;
+            }
+            damping /= 2;
+        }
+        if (!accepted)
+            throw new ConvergenceError('dampedNewton2D', iteration + 1);
+    }
+    throw new ConvergenceError('dampedNewton2D', maxIterations);
+}

package/dist/solvers/newton-raphson.d.ts

@@ -19,4 +19,3 @@ export interface NewtonRaphsonOptions {
  * @throws {ConvergenceError} if the iteration diverges or does not converge
  */
 export declare function newtonRaphson(f: (x: number) => number, x0: number, fp?: ((x: number) => number) | null, options?: NewtonRaphsonOptions): number;
-//# sourceMappingURL=newton-raphson.d.ts.map

package/dist/solvers/newton-raphson.js

@@ -52,4 +52,3 @@ export function newtonRaphson(f, x0, fp, options) {
     }
     throw new ConvergenceError('newtonRaphson', maxIter);
 }
-//# sourceMappingURL=newton-raphson.js.map

package/dist/transport/properties.d.ts

@@ -46,4 +46,3 @@ export declare function dielectricConstant(T: number, rho: number): number;
  * @param rho Density [kg/m³]
  */
 export declare function ionizationConstant(T: number, rho: number): number | null;
-//# sourceMappingURL=properties.d.ts.map

package/dist/transport/properties.js

@@ -249,4 +249,3 @@ export function ionizationConstant(T, rho) {
     return -2 * n * (log10(1 + Z)
         - Z / (Z + 1) * density * beta) + pKwG + 2 * log10(molarMass / 1000);
 }
-//# sourceMappingURL=properties.js.map

package/dist/transport.d.ts

@@ -2,4 +2,3 @@
  * Public transport-property exports.
  */
 export { viscosity, thermalConductivity, surfaceTension, dielectricConstant, ionizationConstant, } from './transport/properties.js';
-//# sourceMappingURL=transport.d.ts.map

package/dist/transport.js

@@ -2,4 +2,3 @@
  * Public transport-property exports.
  */
 export { viscosity, thermalConductivity, surfaceTension, dielectricConstant, ionizationConstant, } from './transport/properties.js';
-//# sourceMappingURL=transport.js.map

package/dist/types.d.ts

@@ -152,4 +152,3 @@ export declare class ConvergenceError extends IF97Error {
     constructor(solver: string, iterations: number);
 }
 export {};
-//# sourceMappingURL=types.d.ts.map

package/dist/types.js

@@ -53,4 +53,3 @@ export class ConvergenceError extends IF97Error {
         this.name = 'ConvergenceError';
     }
 }
-//# sourceMappingURL=types.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "iapws-if97",
-  "version": "2.1.5",
+  "version": "2.2.0",
   "description": "TypeScript implementation of IAPWS-IF97 for water and steam properties, including forward/backward solvers, saturation states, and transport properties.",
   "author": "jltonghui",
   "repository": {
@@ -16,28 +16,34 @@
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
+      "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
+      "default": "./dist/index.js"
     },
     "./transport": {
+      "types": "./dist/transport.d.ts",
       "import": "./dist/transport.js",
-      "types": "./dist/transport.d.ts"
+      "default": "./dist/transport.js"
     },
     "./regions": {
+      "types": "./dist/regions.d.ts",
       "import": "./dist/regions.js",
-      "types": "./dist/regions.d.ts"
+      "default": "./dist/regions.js"
     },
     "./saturation": {
+      "types": "./dist/saturation.d.ts",
       "import": "./dist/saturation.js",
-      "types": "./dist/saturation.d.ts"
+      "default": "./dist/saturation.js"
     },
     "./boundaries": {
+      "types": "./dist/boundaries.d.ts",
       "import": "./dist/boundaries.js",
-      "types": "./dist/boundaries.d.ts"
+      "default": "./dist/boundaries.js"
     },
     "./detect": {
+      "types": "./dist/detect.d.ts",
       "import": "./dist/detect.js",
-      "types": "./dist/detect.d.ts"
+      "default": "./dist/detect.js"
     },
     "./package.json": "./package.json"
   },
@@ -49,21 +55,23 @@
     "README.md"
   ],
   "engines": {
-    "node": ">=18"
+    "node": ">=20.19.0"
   },
   "publishConfig": {
     "access": "public"
   },
   "sideEffects": false,
   "scripts": {
+    "prebuild": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\"",
     "build": "tsc",
     "test": "vitest run",
+    "test:package": "npm run build && node scripts/check-package.mjs",
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage",
     "test:standards": "vitest run tests/standards-asme tests/standards-cn",
     "test:standards:asme": "vitest run tests/standards-asme",
     "test:standards:cn": "vitest run tests/standards-cn",
-    "prepack": "npm run build && npm test",
+    "prepack": "npm run test:package && npm test",
     "prepublishOnly": "npm run build && npm test"
   },
   "devDependencies": {

package/dist/backward/objective-normalization.d.ts

@@ -1,7 +0,0 @@
-export interface NormalizedResidual {
-    actual: number;
-    expected: number;
-    tolerance: number;
-}
-export declare function sumNormalizedResiduals(terms: readonly NormalizedResidual[]): number;
-//# sourceMappingURL=objective-normalization.d.ts.map

package/dist/backward/objective-normalization.js

@@ -1,8 +0,0 @@
-export function sumNormalizedResiduals(terms) {
-    let sum = 0;
-    for (const term of terms) {
-        sum += Math.abs(term.actual - term.expected) / term.tolerance;
-    }
-    return sum;
-}
-//# sourceMappingURL=objective-normalization.js.map

package/dist/solvers/nelder-mead.d.ts

@@ -1,17 +0,0 @@
-export interface NelderMeadOptions {
-    maxIterations?: number;
-    nonZeroDelta?: number;
-    zeroDelta?: number;
-    minErrorDelta?: number;
-    minTolerance?: number;
-    rho?: number;
-    chi?: number;
-    psi?: number;
-    sigma?: number;
-}
-export interface NelderMeadResult {
-    x: number[];
-    fx: number;
-}
-export declare function nelderMead(f: (x: number[]) => number, x0: number[], opts?: NelderMeadOptions): NelderMeadResult;
-//# sourceMappingURL=nelder-mead.d.ts.map

package/dist/solvers/nelder-mead.js

@@ -1,116 +0,0 @@
-/**
- * Nelder-Mead (downhill simplex) minimizer.
- * Minimizes f(x) where x is an array of numbers.
- */
-import { ConvergenceError } from '../types.js';
-export function nelderMead(f, x0, opts) {
-    const maxIter = opts?.maxIterations ?? x0.length * 200;
-    const nonZeroDelta = opts?.nonZeroDelta ?? 1.05;
-    const zeroDelta = opts?.zeroDelta ?? 0.001;
-    const minErrDelta = opts?.minErrorDelta ?? 1e-11;
-    const minTol = opts?.minTolerance ?? 1e-11;
-    const rho = opts?.rho ?? 1;
-    const chi = opts?.chi ?? 2;
-    const psi = opts?.psi ?? -0.5;
-    const sigma = opts?.sigma ?? 0.5;
-    const N = x0.length;
-    let converged = false;
-    function evaluate(point, iteration) {
-        const value = f(point);
-        if (!Number.isFinite(value)) {
-            throw new ConvergenceError('nelderMead', iteration);
-        }
-        return value;
-    }
-    const simplex = new Array(N + 1);
-    // Initialize simplex
-    const v0 = [...x0];
-    v0.fx = evaluate(x0, 1);
-    simplex[0] = v0;
-    for (let i = 0; i < N; i++) {
-        const pt = [...x0];
-        pt[i] = pt[i] ? pt[i] * nonZeroDelta : zeroDelta;
-        pt.fx = evaluate(pt, 1);
-        simplex[i + 1] = pt;
-    }
-    const sortOrder = (a, b) => a.fx - b.fx;
-    function weightedSum(ret, w1, v1, w2, v2) {
-        for (let j = 0; j < ret.length; j++) {
-            ret[j] = w1 * v1[j] + w2 * v2[j];
-        }
-        return ret;
-    }
-    const centroid = [...x0];
-    const reflected = [...x0];
-    const contracted = [...x0];
-    const expanded = [...x0];
-    function updateSimplex(value) {
-        for (let i = 0; i < N; i++)
-            simplex[N][i] = value[i];
-        simplex[N].fx = value.fx;
-    }
-    for (let iter = 0; iter < maxIter; iter++) {
-        simplex.sort(sortOrder);
-        let maxDiff = 0;
-        for (let i = 1; i < simplex.length; i++) {
-            for (let j = 0; j < N; j++) {
-                maxDiff = Math.max(maxDiff, Math.abs(simplex[0][j] - simplex[i][j]));
-            }
-        }
-        if (Math.abs(simplex[0].fx - simplex[N].fx) < minErrDelta && maxDiff < minTol) {
-            converged = true;
-            break;
-        }
-        for (let i = 0; i < N; i++) {
-            centroid[i] = 0;
-            for (let j = 0; j < N; j++)
-                centroid[i] += simplex[j][i];
-            centroid[i] /= N;
-        }
-        const worst = simplex[N];
-        weightedSum(reflected, 1 + rho, centroid, -rho, worst);
-        reflected.fx = evaluate(reflected, iter + 1);
-        if (reflected.fx < simplex[0].fx) {
-            weightedSum(expanded, 1 + chi, centroid, -chi, worst);
-            expanded.fx = evaluate(expanded, iter + 1);
-            updateSimplex(expanded.fx < reflected.fx ? expanded : reflected);
-        }
-        else if (reflected.fx >= simplex[N - 1].fx) {
-            let shouldReduce = false;
-            if (reflected.fx > worst.fx) {
-                weightedSum(contracted, 1 + psi, centroid, -psi, worst);
-                contracted.fx = evaluate(contracted, iter + 1);
-                if (contracted.fx < worst.fx)
-                    updateSimplex(contracted);
-                else
-                    shouldReduce = true;
-            }
-            else {
-                weightedSum(contracted, 1 - psi * rho, centroid, psi * rho, worst);
-                contracted.fx = evaluate(contracted, iter + 1);
-                if (contracted.fx < reflected.fx)
-                    updateSimplex(contracted);
-                else
-                    shouldReduce = true;
-            }
-            if (shouldReduce) {
-                if (sigma >= 1) {
-                    throw new ConvergenceError('nelderMead', iter + 1);
-                }
-                for (let i = 1; i < simplex.length; i++) {
-                    weightedSum(simplex[i], 1 - sigma, simplex[0], sigma, simplex[i]);
-                    simplex[i].fx = evaluate(simplex[i], iter + 1);
-                }
-            }
-        }
-        else {
-            updateSimplex(reflected);
-        }
-    }
-    if (!converged) {
-        throw new ConvergenceError('nelderMead', maxIter);
-    }
-    simplex.sort(sortOrder);
-    return { fx: simplex[0].fx, x: simplex[0].slice(0, N) };
-}
-//# sourceMappingURL=nelder-mead.js.map