diff-grok 1.0.8

package/src/solver-tools/ros3prw-method.ts

@@ -0,0 +1,304 @@
+/* The ROS3PRw method implementation
+
+   References:
+     [1] https://doi.org/10.1016/j.cam.2015.03.010 */
+
+import {ODEs, max, abs, SAFETY, PSHRNK, PSGROW, REDUCE_COEF, GROW_COEF,
+  ERR_CONTR, TINY, EPS, tDerivative, jacobian, ERROR_MSG} from './solver-defs';
+import {Callback} from './callbacks/callback-base';
+import {luDecomp, luSolve, solve1d2d} from './lin-alg-tools';
+
+// The method specific constants (see Table 2 [1])
+const GAMMA = 0.78867513459481287;
+
+const GAMMA_21 = -2.3660254037844388;
+const GAMMA_21_SCALED = GAMMA_21 / GAMMA;
+const GAMMA_2 = GAMMA_21 + GAMMA;
+
+const GAMMA_31 = -0.86791218280355165;
+const GAMMA_31_SCALED = GAMMA_31 / GAMMA;
+const GAMMA_32 = -0.87306695894642317;
+const GAMMA_32_SCALED = GAMMA_32 / GAMMA;
+const GAMMA_3 = GAMMA_31 + GAMMA_32 + GAMMA;
+
+const ALPHA_21 = 2.3660254037844388;
+const ALPHA_2 = ALPHA_21;
+const ALPHA_31 = 0.5;
+const ALPHA_32 = 0.76794919243112270;
+const ALPHA_3 = ALPHA_31 + ALPHA_32;
+
+const B_1 = 0.50544867840851759;
+const B_2 = -0.11571687603637559;
+const B_3 = 0.610268197627858;
+
+const B_HAT_1 = 0.28973180237214197;
+const B_HAT_2 = 0.10000000000000001;
+const B_HAT_3 = 0.610268197627858;
+
+const R_1 = B_1 - B_HAT_1;
+const R_2 = B_2 - B_HAT_2;
+const R_3 = B_3 - B_HAT_3;
+
+
+/** Solve initial value problem using the ROS3Pw method [1]
+ * @param odes initial value problem for ordinary differential equations
+ * @param callback computations control callback
+ * @returns solution of the problem
+*/
+export function ros3prw(odes: ODEs, callback?: Callback): Float64Array[] {
+  /** right-hand side of the IVP solved */
+  const f = odes.func;
+
+  // operating variables
+  const t0 = odes.arg.start;
+  const t1 = odes.arg.finish;
+  let h = odes.arg.step;
+  const hDataframe = h;
+  const tolerance = odes.tolerance;
+
+  /** number of solution dataframe rows */
+  const rowCount = Math.trunc((t1 - t0) / h) + 1;
+
+  /** dimension of the problem */
+  const dim = odes.initial.length;
+  const dimSquared = dim * dim;
+
+  /** independent variable values */
+  const tArr = new Float64Array(rowCount);
+
+  /** arrays of solution values */
+  const yArrs = Array<Float64Array>(dim);
+
+  for (let i = 0; i < dim; ++i)
+    yArrs[i] = new Float64Array(rowCount);
+
+  // method routine
+  let timeDataframe = t0 + hDataframe;
+  let t = t0;
+  let tPrev = t0;
+  let flag = true;
+  let index = 1;
+  let errmax = 0;
+  let hTemp = 0;
+  let tNew = 0;
+  let hNext = 0.0;
+
+  // 0 BUFFERS & TEMP STRUCTURES
+
+  /** identity matrix */
+  const I = new Float64Array(dim * dim);
+
+  // compute identity matrix
+  for (let i = 0; i < dim; ++i) {
+    for (let j = 0; j < dim; ++j)
+      I[j + i * dim] = (i === j) ? 1 : 0;
+  }
+
+  const y = new Float64Array(odes.initial);
+  const yPrev = new Float64Array(odes.initial);
+  const dydt = new Float64Array(dim);
+  const yScale = new Float64Array(dim);
+  const yTemp = new Float64Array(dim);
+  const yErr = new Float64Array(dim);
+
+  const W = new Float64Array(dimSquared);
+
+  const k1 = new Float64Array(dim);
+  const k2 = new Float64Array(dim);
+  const k3 = new Float64Array(dim);
+  const HT = new Float64Array(dim);
+
+  const f0Buf = new Float64Array(dim);
+  const f1Buf = new Float64Array(dim);
+
+  let hByGamma = 0;
+  const fBuf = new Float64Array(dim);
+  const kBuf = new Float64Array(dim);
+
+  const L = new Float64Array(dimSquared);
+  const U = new Float64Array(dimSquared);
+  const luBuf = new Float64Array(dim);
+  const bBuf = new Float64Array(dim);
+  const toUseLU = dim > 2;
+
+  // 1. SOLUTION AT THE POINT t0
+  tArr[0] = t0;
+  for (let i = 0; i < dim; ++i)
+    yArrs[i][0] = y[i];
+
+  // 2. COMPUTE NUMERICAL SOLUTION FOR THE POINTS FROM THE INTERVAL (t0, t1)
+  while (flag) {
+    // compute derivative
+    f(t, y, dydt);
+
+    // check whether to go on computations
+    if (callback)
+      callback.onIterationStart();
+
+    // compute scale vector
+    for (let i = 0; i < dim; ++i)
+      yScale[i] = abs(y[i]) + h * abs(dydt[i]) + TINY;
+
+    // check end point
+    if (t + h > t1) {
+      h = t1 - t;
+      flag = false;
+    }
+
+    // call of adaptive step the ROS3Pw [1] method
+    // computation of solution (y), time (t) and next step (hNext)
+    while (true) {
+      hByGamma = h * GAMMA;
+
+      // one stage of the ROS3Pw method
+
+      // 1) Jacobian & dF/dt matrices
+      jacobian(t, y, f, EPS, f0Buf, f1Buf, W);
+      tDerivative(t, y, f, EPS, f0Buf, f1Buf, HT);
+
+      // 2) W & LU-decomposition
+      for (let i = 0; i < dimSquared; ++i)
+        W[i] = I[i] - hByGamma * W[i];
+
+      if (toUseLU)
+        luDecomp(W, L, U, dim);
+
+      // 3) Scale dF/dt: HT = j * T
+      for (let i = 0; i < dim; ++i)
+        HT[i] *= h;
+
+      // 4) F1 = F(t, y)  <-- Fbuf
+      f(t, y, fBuf);
+
+      // 5) k1 = W_inv * (F1 + gamma * HT)
+      for (let i = 0; i < dim; ++i)
+        bBuf[i] = fBuf[i] + GAMMA * HT[i];
+
+      if (toUseLU)
+        luSolve(L, U, bBuf, luBuf, k1, dim);
+      else
+        solve1d2d(W, bBuf, k1);
+
+      // 6) F2 = F(t + alpha2 * h, y + alpha21 * k1)   <-- Fbuf
+      for (let i = 0; i < dim; ++i)
+        kBuf[i] = y[i] + ALPHA_21 * h * k1[i];
+
+      f(t + ALPHA_2 * h, kBuf, fBuf);
+
+      // 7) kBuf = gamma21 / gamma * k1
+      for (let i = 0; i < dim; ++i)
+        kBuf[i] = GAMMA_21_SCALED * k1[i];
+
+      // 8) k2 = W_inv * [Fbuf + kBuf + gamma2 * HT] - kBuf
+      for (let i = 0; i < dim; ++i)
+        bBuf[i] = fBuf[i] + kBuf[i] + GAMMA_2 * HT[i];
+
+      if (toUseLU)
+        luSolve(L, U, bBuf, luBuf, k2, dim);
+      else
+        solve1d2d(W, bBuf, k2);
+
+      for (let i = 0; i < dim; ++i)
+        k2[i] -= kBuf[i];
+
+      // 9) F3 = F(t + alpha3 * h, y + h * (alpha31 * k1 + alpha32 * k2))  <-- Fbuf
+      for (let i = 0; i < dim; ++i)
+        kBuf[i] = y[i] + h * (ALPHA_31 * k1[i] + ALPHA_32 * k2[i]);
+
+      f(t + ALPHA_3 * h, kBuf, fBuf);
+
+      // 10) kBuf = gamma31 / gamma * k1 + gamma32 / gamma * k2
+      for (let i = 0; i < dim; ++i)
+        kBuf[i] = GAMMA_31_SCALED * k1[i] + GAMMA_32_SCALED * k2[i];
+
+      // 11) k3 = W_inv * (F3 + kBuf + gamma3 * HT) - kBuf
+      for (let i = 0; i < dim; ++i)
+        bBuf[i] = fBuf[i] + kBuf[i] + GAMMA_3 * HT[i];
+
+      if (toUseLU)
+        luSolve(L, U, bBuf, luBuf, k3, dim);
+      else
+        solve1d2d(W, bBuf, k3);
+
+      for (let i = 0; i < dim; ++i)
+        k3[i] -= kBuf[i];
+
+      // 12) yNext = y + h * (b1 * k1 + b2 * k2 + b3 * k3)   <-- yTemp
+      for (let i = 0; i < dim; ++i)
+        yTemp[i] = y[i] + h * (B_1 * k1[i] + B_2 * k2[i] + B_3 * k3[i]);
+
+      // 13) yErr = h * (r1 * k1 + r2 * k2 + r3 * k3)
+      for (let i = 0; i < dim; ++i)
+        yErr[i] = h * (R_1 * k1[i] + R_2 * k2[i] + R_3 * k3[i]);
+
+      // estimating error
+      errmax = 0;
+      for (let i = 0; i < dim; ++i)
+        errmax = max(errmax, abs(yErr[i] / yScale[i]));
+      errmax /= tolerance;
+
+      // processing the error obtained
+      if (errmax > 1) {
+        hTemp = SAFETY * h * errmax**PSHRNK;
+        h = max(hTemp, REDUCE_COEF * h);
+        tNew = t + h;
+        if (tNew == t)
+          throw new Error(ERROR_MSG.ROS3PRW_FAILS);
+      } else {
+        if (errmax > ERR_CONTR)
+          hNext = SAFETY * h * errmax**PSGROW;
+        else
+          hNext = GROW_COEF * h;
+        t = t + h;
+
+        for (let i = 0; i < dim; ++i)
+          y[i] = yTemp[i];
+
+        break;
+      }
+    } // while (true)
+
+    // compute lineraly interpolated results and store them in dataframe
+    while (timeDataframe < t) {
+      const cLeft = (t - timeDataframe) / (t - tPrev);
+      const cRight = 1.0 - cLeft;
+
+      tArr[index] = timeDataframe;
+
+      for (let j = 0; j < dim; ++j)
+        yArrs[j][index] = cRight * y[j] + cLeft * yPrev[j];
+
+      timeDataframe += hDataframe;
+      ++index;
+    }
+
+    h = hNext;
+    tPrev = t;
+
+    for (let i = 0; i < dim; ++i)
+      yPrev[i] = y[i];
+  } // while (flag)
+
+  // perform final callback actions
+  if (callback)
+    callback.onComputationsCompleted();
+
+  // 3. solution at the point t1
+  tArr[rowCount - 1] = t1;
+
+  for (let i = 0; i < dim; ++i)
+    yArrs[i][rowCount - 1] = y[i];
+
+  // 4. prepare output
+  const solution = Array<Float64Array>(dim);
+
+  // independent variable
+  solution[0] = tArr;
+
+  // functions
+  for (let i = 0; i < dim; ++i)
+    solution[i + 1] = yArrs[i];
+
+  return solution;
+  //return [tArr].concat(yArrs);
+} // ros3prw

package/src/solver-tools/solver-defs.js

@@ -0,0 +1,58 @@
+// Solver definitions
+/** The abs function */
+export const abs = (x) => (x > 0) ? x : -x;
+/** The max function */
+export const max = (x, y) => (x > y) ? x : y;
+/** The max function */
+export const min = (x, y) => (x < y) ? x : y;
+/** Routine constants of adaptive step method */
+export const SAFETY = 0.9;
+export const PSHRNK = -0.25;
+export const PSGROW = -0.2;
+export const REDUCE_COEF = 0.25;
+export const GROW_COEF = 4.0;
+export const ERR_CONTR = 1.89e-4;
+/** Misc */
+export const TINY = 1e-20;
+export const EPS = 1.0e-10;
+/** Returns derivative with respect to t. */
+export function tDerivative(t, y, f, eps, f0Buf, f1Buf, output) {
+    const size = y.length;
+    f(t, y, f0Buf);
+    f(t + eps, y, f1Buf);
+    for (let i = 0; i < size; ++i)
+        output[i] = (f1Buf[i] - f0Buf[i]) / eps;
+}
+/** Returns Jacobian. */
+export function jacobian(t, y, f, eps, f0Buf, f1Buf, output) {
+    const size = y.length;
+    f(t, y, f0Buf);
+    for (let j = 0; j < size; ++j) {
+        y[j] += eps;
+        f(t, y, f1Buf);
+        for (let i = 0; i < size; ++i)
+            output[j + i * size] = (f1Buf[i] - f0Buf[i]) / eps;
+        y[j] -= eps;
+    }
+}
+/** Error messeges */
+export var ERROR_MSG;
+(function (ERROR_MSG) {
+    ERROR_MSG["MRT_FAILS"] = "The modified Rosenbrock triple method fails";
+    ERROR_MSG["ROS3PRW_FAILS"] = "The ROS3PRw method fails";
+    ERROR_MSG["ROS34PRW_FAILS"] = "The ROS34PRw method fails";
+})(ERROR_MSG || (ERROR_MSG = {}));
+;
+/** Callback action */
+export class CallbackAction extends Error {
+    constructor(msg) {
+        super(msg);
+    }
+}
+/** Default options of the solver */
+export var DEFAULT_OPTIONS;
+(function (DEFAULT_OPTIONS) {
+    DEFAULT_OPTIONS["SCRIPTING"] = "{maxIterations: 1}";
+    DEFAULT_OPTIONS["NO_CHECKS"] = "{ }";
+})(DEFAULT_OPTIONS || (DEFAULT_OPTIONS = {}));
+//# sourceMappingURL=solver-defs.js.map

package/src/solver-tools/solver-defs.js.map

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

package/src/solver-tools/solver-defs.ts

@@ -0,0 +1,100 @@
+// Solver definitions
+
+import {Callback} from './callbacks/callback-base';
+
+/** Right-hand side of IVP */
+export type Func = (t: number, y: Float64Array, output: Float64Array) => void;
+
+/** Solver optional settings */
+export type SolverOptions = {
+  maxIterations: number,
+  maxTimeMs: number,
+  method: string,
+};
+
+/** Initial Value Problem (IVP) type */
+export type ODEs = {
+  name: string,
+  arg: {
+    name: string,
+    start: number,
+    finish: number,
+    step: number
+  },
+  initial: number[] | Float32Array | Float64Array | Int32Array,
+  func: Func,
+  tolerance: number,
+  solutionColNames: string[],
+};
+
+/** The abs function */
+export const abs = (x: number) => (x > 0) ? x : -x;
+
+/** The max function */
+export const max = (x: number, y: number) => (x > y) ? x : y;
+
+/** The max function */
+export const min = (x: number, y: number) => (x < y) ? x : y;
+
+/** Routine constants of adaptive step method */
+export const SAFETY = 0.9;
+export const PSHRNK = -0.25;
+export const PSGROW = -0.2;
+export const REDUCE_COEF = 0.25;
+export const GROW_COEF = 4.0;
+export const ERR_CONTR = 1.89e-4;
+
+/** Misc */
+export const TINY = 1e-20;
+export const EPS = 1.0e-10;
+
+/** Returns derivative with respect to t. */
+export function tDerivative(t: number, y: Float64Array, f: Func, eps: number,
+  f0Buf: Float64Array, f1Buf: Float64Array, output: Float64Array): void {
+  const size = y.length;
+  f(t, y, f0Buf);
+  f(t + eps, y, f1Buf);
+
+  for (let i = 0; i < size; ++i)
+    output[i] = (f1Buf[i] - f0Buf[i]) / eps;
+}
+
+/** Returns Jacobian. */
+export function jacobian(t: number, y: Float64Array, f: Func, eps: number,
+  f0Buf: Float64Array, f1Buf: Float64Array, output: Float64Array): void {
+  const size = y.length;
+  f(t, y, f0Buf);
+
+  for (let j = 0; j < size; ++j) {
+    y[j] += eps;
+    f(t, y, f1Buf);
+
+    for (let i = 0; i < size; ++i)
+      output[j + i * size] = (f1Buf[i] - f0Buf[i]) / eps;
+
+    y[j] -= eps;
+  }
+}
+
+/** Error messeges */
+export enum ERROR_MSG {
+  MRT_FAILS = 'The modified Rosenbrock triple method fails',
+  ROS3PRW_FAILS = 'The ROS3PRw method fails',
+  ROS34PRW_FAILS = 'The ROS34PRw method fails',
+};
+
+/** Callback action */
+export class CallbackAction extends Error {
+  constructor(msg: string) {
+    super(msg);
+  }
+}
+
+/** Default options of the solver */
+export enum DEFAULT_OPTIONS {
+  SCRIPTING = '{maxIterations: 1}',
+  NO_CHECKS = '{ }',
+}
+
+/** IVP solving method */
+export type SolverMethod = (odes: ODEs, callback?: Callback) => Float64Array[];

package/src/worker-tools/index.js

@@ -0,0 +1,3 @@
+export { getIvp2WebWorker } from './scripting';
+export { solveIvp } from './solving';
+//# sourceMappingURL=index.js.map

package/src/worker-tools/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,gBAAgB,EAAC,MAAM,aAAa,CAAC;AAC5D,OAAO,EAAC,QAAQ,EAAC,MAAM,WAAW,CAAC"}

package/src/worker-tools/index.ts

@@ -0,0 +1,2 @@
+export {IVP2WebWorker, getIvp2WebWorker} from './scripting';
+export {solveIvp} from './solving';

package/src/worker-tools/scripting.js

@@ -0,0 +1,68 @@
+// Scripting tools for solving IVPs in web-workers
+import { MATH_CONSTS, POW_IDX, MATH_FUNCS } from '../scripting-tools/scripting-tools';
+const DEFAULT_METHOD = 'ros34prw';
+const DEFAULT_MAX_TIME_MS = 50000;
+/** Return solver options */
+function getSolverOpts(opts) {
+    try {
+        const json = JSON.parse(opts
+            .replaceAll(`'`, `"`)
+            .replace('method', '"method"')
+            .replace('maxTimeMs', '"maxTimeMs"')
+            .replace('maxIterations', '"maxIterations"')
+            .replace(';', ','));
+        return json;
+    }
+    catch (e) {
+        return {
+            method: DEFAULT_METHOD,
+            maxTimeMs: DEFAULT_MAX_TIME_MS,
+        };
+    }
+}
+/** Return main body of a right-hand side function of IVP */
+function getFuncMainBody(ivp) {
+    const lines = [];
+    // Used math funcs
+    ivp.usedMathFuncs.forEach((idx) => {
+        if (idx !== POW_IDX)
+            lines.push(`const ${MATH_FUNCS[idx]} = (x) => Math.${MATH_FUNCS[idx]}(x);`);
+        else
+            lines.push(`const pow = (x, y) => Math.pow(x, y);`);
+    });
+    // Used math consts
+    ivp.usedMathConsts.forEach((idx) => lines.push(`const ${MATH_CONSTS[idx]} = Math.${MATH_CONSTS[idx]};`));
+    // Model constants
+    if (ivp.consts !== null)
+        ivp.consts.forEach((input, name) => lines.push(`const ${name} = ${input.value};`));
+    // extract arg & function values
+    lines.push(`const ${ivp.arg.name} = arguments[0];`);
+    ivp.deqs.solutionNames.forEach((name, idx) => lines.push(`const ${name} = arguments[1][${idx}];`));
+    // evaluate expressions
+    if (ivp.exprs !== null)
+        ivp.exprs.forEach(((expr, name) => lines.push(`const ${name} = ${expr};`)));
+    // compute output
+    ivp.deqs.solutionNames.forEach((name, idx) => lines.push(`arguments[2][${idx}] = ${ivp.deqs.equations.get(name)};`));
+    return lines.join('\n');
+}
+/** Return IVP-structure to be passed to web-worker */
+export function getIvp2WebWorker(ivp) {
+    const paramNames = [];
+    if (ivp.params !== null)
+        ivp.params.forEach((_, name) => paramNames.push(name));
+    const ivpWW = {
+        tolerance: Number(ivp.tolerance),
+        solverOpts: getSolverOpts(ivp.solverSettings),
+        funcMainBody: getFuncMainBody(ivp),
+        paramNames: paramNames,
+        deqsCount: ivp.deqs.solutionNames.length,
+    };
+    return ivpWW;
+}
+/** Return a right-hand side function of IVP with the specified values of parameters */
+export function getFunc(ivp, paramVals) {
+    const lines = [];
+    ivp.paramNames.forEach((name, idx) => lines.push(`const ${name} = ${paramVals[idx]};`));
+    return lines.concat(ivp.funcMainBody).join('\n');
+}
+//# sourceMappingURL=scripting.js.map

package/src/worker-tools/scripting.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scripting.js","sourceRoot":"","sources":["scripting.ts"],"names":[],"mappings":"AAAA,kDAAkD;AAElD,OAAO,EAAM,WAAW,EAAE,OAAO,EAAE,UAAU,EAAC,MAAM,oCAAoC,CAAC;AAYzF,MAAM,cAAc,GAAG,UAAU,CAAC;AAClC,MAAM,mBAAmB,GAAG,KAAK,CAAC;AAElC,4BAA4B;AAC5B,SAAS,aAAa,CAAC,IAAY;IACjC,IAAI,CAAC;QACH,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI;aACzB,UAAU,CAAC,GAAG,EAAE,GAAG,CAAC;aACpB,OAAO,CAAC,QAAQ,EAAE,UAAU,CAAC;aAC7B,OAAO,CAAC,WAAW,EAAE,aAAa,CAAC;aACnC,OAAO,CAAC,eAAe,EAAE,iBAAiB,CAAC;aAC3C,OAAO,CAAC,GAAG,EAAE,GAAG,CAAC,CACnB,CAAC;QAEF,OAAO,IAAI,CAAC;IACd,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,OAAO;YACL,MAAM,EAAE,cAAc;YACtB,SAAS,EAAE,mBAAmB;SAC/B,CAAC;IACJ,CAAC;AACH,CAAC;AAED,4DAA4D;AAC5D,SAAS,eAAe,CAAC,GAAQ;IAC/B,MAAM,KAAK,GAAa,EAAE,CAAC;IAE3B,kBAAkB;IAClB,GAAG,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,EAAE;QAChC,IAAI,GAAG,KAAK,OAAO;YACjB,KAAK,CAAC,IAAI,CAAC,SAAS,UAAU,CAAC,GAAG,CAAC,kBAAkB,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;;YAE5E,KAAK,CAAC,IAAI,CAAC,uCAAuC,CAAC,CAAC;IACxD,CAAC,CAAC,CAAC;IAEH,mBAAmB;IACnB,GAAG,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,WAAW,CAAC,GAAG,CAAC,WAAW,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;IAEzG,kBAAkB;IAClB,IAAI,GAAG,CAAC,MAAM,KAAK,IAAI;QACrB,GAAG,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,IAAI,MAAM,KAAK,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC;IAErF,gCAAgC;IAChC,KAAK,CAAC,IAAI,CAAC,SAAS,GAAG,CAAC,GAAG,CAAC,IAAI,kBAAkB,CAAC,CAAC;IACpD,GAAG,CAAC,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,IAAI,mBAAmB,GAAG,IAAI,CAAC,CAAC,CAAC;IAEnG,uBAAuB;IACvB,IAAI,GAAG,CAAC,KAAK,KAAK,IAAI;QACpB,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,EAAE,IAAI,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,IAAI,MAAM,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC;IAE9E,iBAAiB;IACjB,GAAG,CAAC,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,gBAAgB,GAAG,OAAO,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;IAErH,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAC1B,CAAC;AAED,sDAAsD;AACtD,MAAM,UAAU,gBAAgB,CAAC,GAAQ;IACvC,MAAM,UAAU,GAAa,EAAE,CAAC;IAChC,IAAI,GAAG,CAAC,MAAM,KAAK,IAAI;QACrB,GAAG,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;IAEzD,MAAM,KAAK,GAAkB;QAC3B,SAAS,EAAE,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC;QAChC,UAAU,EAAE,aAAa,CAAC,GAAG,CAAC,cAAc,CAAC;QAC7C,YAAY,EAAE,eAAe,CAAC,GAAG,CAAC;QAClC,UAAU,EAAE,UAAU;QACtB,SAAS,EAAE,GAAG,CAAC,IAAI,CAAC,aAAa,CAAC,MAAM;KACzC,CAAC;IAEF,OAAO,KAAK,CAAC;AACf,CAAC;AAED,uFAAuF;AACvF,MAAM,UAAU,OAAO,CAAC,GAAkB,EAAE,SAAuB;IACjE,MAAM,KAAK,GAAa,EAAE,CAAC;IAE3B,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,IAAI,MAAM,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;IAExF,OAAO,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACnD,CAAC"}

package/src/worker-tools/scripting.ts

@@ -0,0 +1,95 @@
+// Scripting tools for solving IVPs in web-workers
+
+import {IVP, MATH_CONSTS, POW_IDX, MATH_FUNCS} from '../scripting-tools/scripting-tools';
+import {SolverOptions} from '../solver-tools/solver-defs';
+
+/** Initial value problem structure to be passed to web-worker */
+export type IVP2WebWorker = {
+    tolerance: number,
+    solverOpts: Partial<SolverOptions>,
+    funcMainBody: string,
+    paramNames: string[],
+    deqsCount: number,
+};
+
+const DEFAULT_METHOD = 'ros34prw';
+const DEFAULT_MAX_TIME_MS = 50000;
+
+/** Return solver options */
+function getSolverOpts(opts: string): Partial<SolverOptions> {
+  try {
+    const json = JSON.parse(opts
+      .replaceAll(`'`, `"`)
+      .replace('method', '"method"')
+      .replace('maxTimeMs', '"maxTimeMs"')
+      .replace('maxIterations', '"maxIterations"')
+      .replace(';', ','),
+    );
+
+    return json;
+  } catch (e) {
+    return {
+      method: DEFAULT_METHOD,
+      maxTimeMs: DEFAULT_MAX_TIME_MS,
+    };
+  }
+}
+
+/** Return main body of a right-hand side function of IVP */
+function getFuncMainBody(ivp: IVP): string {
+  const lines: string[] = [];
+
+  // Used math funcs
+  ivp.usedMathFuncs.forEach((idx) => {
+    if (idx !== POW_IDX)
+      lines.push(`const ${MATH_FUNCS[idx]} = (x) => Math.${MATH_FUNCS[idx]}(x);`);
+    else
+      lines.push(`const pow = (x, y) => Math.pow(x, y);`);
+  });
+
+  // Used math consts
+  ivp.usedMathConsts.forEach((idx) => lines.push(`const ${MATH_CONSTS[idx]} = Math.${MATH_CONSTS[idx]};`));
+
+  // Model constants
+  if (ivp.consts !== null)
+    ivp.consts.forEach((input, name) => lines.push(`const ${name} = ${input.value};`));
+
+  // extract arg & function values
+  lines.push(`const ${ivp.arg.name} = arguments[0];`);
+  ivp.deqs.solutionNames.forEach((name, idx) => lines.push(`const ${name} = arguments[1][${idx}];`));
+
+  // evaluate expressions
+  if (ivp.exprs !== null)
+    ivp.exprs.forEach(((expr, name) => lines.push(`const ${name} = ${expr};`)));
+
+  // compute output
+  ivp.deqs.solutionNames.forEach((name, idx) => lines.push(`arguments[2][${idx}] = ${ivp.deqs.equations.get(name)};`));
+
+  return lines.join('\n');
+}
+
+/** Return IVP-structure to be passed to web-worker */
+export function getIvp2WebWorker(ivp: IVP): IVP2WebWorker {
+  const paramNames: string[] = [];
+  if (ivp.params !== null)
+    ivp.params.forEach((_, name) => paramNames.push(name));
+
+  const ivpWW: IVP2WebWorker = {
+    tolerance: Number(ivp.tolerance),
+    solverOpts: getSolverOpts(ivp.solverSettings),
+    funcMainBody: getFuncMainBody(ivp),
+    paramNames: paramNames,
+    deqsCount: ivp.deqs.solutionNames.length,
+  };
+
+  return ivpWW;
+}
+
+/** Return a right-hand side function of IVP with the specified values of parameters */
+export function getFunc(ivp: IVP2WebWorker, paramVals: Float64Array): string {
+  const lines: string[] = [];
+
+  ivp.paramNames.forEach((name, idx) => lines.push(`const ${name} = ${paramVals[idx]};`));
+
+  return lines.concat(ivp.funcMainBody).join('\n');
+}