mathjs 11.8.2 → 11.9.0

package/lib/esm/expression/embeddedDocs/function/expression/evaluate.js

@@ -1,8 +1,8 @@
 export var evaluateDocs = {
   name: 'evaluate',
   category: 'Expression',
-  syntax: ['evaluate(expression)', 'evaluate([expr1, expr2, expr3, ...])'],
+  syntax: ['evaluate(expression)', 'evaluate(expression, scope)', 'evaluate([expr1, expr2, expr3, ...])', 'evaluate([expr1, expr2, expr3, ...], scope)'],
   description: 'Evaluate an expression or an array with expressions.',
-  examples: ['evaluate("2 + 3")', 'evaluate("sqrt(" + 4 + ")")'],
+  examples: ['evaluate("2 + 3")', 'evaluate("sqrt(16)")', 'evaluate("2 inch to cm")', 'evaluate("sin(x * pi)", { "x": 1/2 })', 'evaluate(["width=2", "height=4","width*height"])'],
   seealso: []
 };

package/lib/esm/expression/embeddedDocs/function/matrix/diff.js

@@ -3,6 +3,6 @@ export var diffDocs = {
   category: 'Matrix',
   syntax: ['diff(arr)', 'diff(arr, dim)'],
   description: ['Create a new matrix or array with the difference of the passed matrix or array.', 'Dim parameter is optional and used to indicant the dimension of the array/matrix to apply the difference', 'If no dimension parameter is passed it is assumed as dimension 0', 'Dimension is zero-based in javascript and one-based in the parser', 'Arrays must be \'rectangular\' meaning arrays like [1, 2]', 'If something is passed as a matrix it will be returned as a matrix but other than that all matrices are converted to arrays'],
-  examples: ['diff([1, 2, 4, 7, 0])', 'diff([1, 2, 4, 7, 0], 0)', 'diff(matrix([1, 2, 4, 7, 0]))', 'diff([[1, 2], [3, 4]])', 'diff([[1, 2], [3, 4]], 0)', 'diff([[1, 2], [3, 4]], 1)', 'diff([[1, 2], [3, 4]], bignumber(1))', 'diff(matrix([[1, 2], [3, 4]]), 1)', 'diff([[1, 2], matrix([3, 4])], 1)'],
+  examples: ['A = [1, 2, 4, 7, 0]', 'diff(A)', 'diff(A, 1)', 'B = [[1, 2], [3, 4]]', 'diff(B)', 'diff(B, 1)', 'diff(B, 2)', 'diff(B, bignumber(2))', 'diff([[1, 2], matrix([3, 4])], 2)'],
   seealso: ['subtract', 'partitionSelect']
 };

package/lib/esm/expression/embeddedDocs/function/matrix/range.js

@@ -3,6 +3,6 @@ export var rangeDocs = {
   category: 'Type',
   syntax: ['start:end', 'start:step:end', 'range(start, end)', 'range(start, end, step)', 'range(string)'],
   description: 'Create a range. Lower bound of the range is included, upper bound is excluded.',
-  examples: ['1:5', '3:-1:-3', 'range(3, 7)', 'range(0, 12, 2)', 'range("4:10")', 'a = [1, 2, 3, 4; 5, 6, 7, 8]', 'a[1:2, 1:2]'],
+  examples: ['1:5', '3:-1:-3', 'range(3, 7)', 'range(0, 12, 2)', 'range("4:10")', 'range(1m, 1m, 3m)', 'a = [1, 2, 3, 4; 5, 6, 7, 8]', 'a[1:2, 1:2]'],
   seealso: ['concat', 'det', 'diag', 'identity', 'inv', 'ones', 'size', 'squeeze', 'subset', 'trace', 'transpose', 'zeros']
 };

package/lib/esm/expression/embeddedDocs/function/numeric/solveODE.js

@@ -0,0 +1,8 @@
+export var solveODEDocs = {
+  name: 'solveODE',
+  category: 'Numeric',
+  syntax: ['solveODE(func, tspan, y0)', 'solveODE(func, tspan, y0, options)'],
+  description: 'Numerical Integration of Ordinary Differential Equations.',
+  examples: ['f(t,y) = y', 'tspan = [0, 4]', 'solveODE(f, tspan, 1)', 'solveODE(f, tspan, [1, 2])', 'solveODE(f, tspan, 1, { method:"RK23", maxStep:0.1 })'],
+  seealso: ['derivative', 'simplifyCore']
+};

package/lib/esm/expression/embeddedDocs/function/signal/freqz.js

@@ -0,0 +1,8 @@
+export var freqzDocs = {
+  name: 'freqz',
+  category: 'Signal',
+  syntax: ['freqz(b, a)', 'freqz(b, a, w)'],
+  description: 'Calculates the frequency response of a filter given its numerator and denominator coefficients.',
+  examples: ['freqz([1, 2], [1, 2, 3])', 'freqz([1, 2], [1, 2, 3], [0, 1])', 'freqz([1, 2], [1, 2, 3], 512)'],
+  seealso: []
+};

package/lib/esm/expression/embeddedDocs/function/signal/zpk2tf.js

@@ -0,0 +1,8 @@
+export var zpk2tfDocs = {
+  name: 'zpk2tf',
+  category: 'Signal',
+  syntax: ['zpk2tf(z, p, k)'],
+  description: 'Compute the transfer function of a zero-pole-gain model.',
+  examples: ['zpk2tf([1, 2], [-1, -2], 1)', 'zpk2tf([1, 2], [-1, -2])', 'zpk2tf([1 - 3i, 2 + 2i], [-1, -2])'],
+  seealso: []
+};

package/lib/esm/expression/embeddedDocs/function/utils/numeric.js

@@ -3,6 +3,6 @@ export var numericDocs = {
   category: 'Utils',
   syntax: ['numeric(x)'],
   description: 'Convert a numeric input to a specific numeric type: number, BigNumber, or Fraction.',
-  examples: ['numeric("4")', 'numeric("4", "number")', 'numeric("4", "BigNumber")', 'numeric("4", "Fraction)', 'numeric(4, "Fraction")', 'numeric(fraction(2, 5), "number)'],
+  examples: ['numeric("4")', 'numeric("4", "number")', 'numeric("4", "BigNumber")', 'numeric("4", "Fraction")', 'numeric(4, "Fraction")', 'numeric(fraction(2, 5), "number")'],
   seealso: ['number', 'fraction', 'bignumber', 'string', 'format']
 };

package/lib/esm/expression/transform/range.transform.js

@@ -1,7 +1,7 @@
 import { factory } from '../../utils/factory.js';
 import { createRange } from '../../function/matrix/range.js';
 var name = 'range';
-var dependencies = ['typed', 'config', '?matrix', '?bignumber', 'smaller', 'smallerEq', 'larger', 'largerEq'];
+var dependencies = ['typed', 'config', '?matrix', '?bignumber', 'smaller', 'smallerEq', 'larger', 'largerEq', 'add', 'isPositive'];
 export var createRangeTransform = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
@@ -11,7 +11,9 @@ export var createRangeTransform = /* #__PURE__ */factory(name, dependencies, _re
     smaller,
     smallerEq,
     larger,
-    largerEq
+    largerEq,
+    add,
+    isPositive
   } = _ref;
   var range = createRange({
     typed,
@@ -21,7 +23,9 @@ export var createRangeTransform = /* #__PURE__ */factory(name, dependencies, _re
     smaller,
     smallerEq,
     larger,
-    largerEq
+    largerEq,
+    add,
+    isPositive
   });
 
   /**

package/lib/esm/factoriesAny.js

@@ -94,6 +94,7 @@ export { createCtranspose } from './function/matrix/ctranspose.js';
 export { createZeros } from './function/matrix/zeros.js';
 export { createFft } from './function/matrix/fft.js';
 export { createIfft } from './function/matrix/ifft.js';
+export { createSolveODE } from './function/numeric/solveODE.js';
 export { createErf } from './function/special/erf.js';
 export { createMode } from './function/statistics/mode.js';
 export { createProd } from './function/statistics/prod.js';
@@ -258,6 +259,8 @@ export { createResolve } from './function/algebra/resolve.js';
 export { createSymbolicEqual } from './function/algebra/symbolicEqual.js';
 export { createDerivative } from './function/algebra/derivative.js';
 export { createRationalize } from './function/algebra/rationalize.js';
+export { createZpk2tf } from './function/signal/zpk2tf.js';
+export { createFreqz } from './function/signal/freqz.js';
 export { createReviver } from './json/reviver.js';
 export { createReplacer } from './json/replacer.js';
 export { createE, createUppercaseE, createFalse, createI, createInfinity, createLN10, createLN2, createLOG10E, createLOG2E, createNaN, createNull, createPhi, createPi, createUppercasePi, createSQRT1_2,

package/lib/esm/function/algebra/simplify.js

@@ -533,6 +533,9 @@ export var createSimplify = /* #__PURE__ */factory(name, dependencies, _ref => {
   },
   // undo replace 'subtract'
   {
+    l: 'n+-(n1)',
+    r: 'n-(n1)'
+  }, {
     s: 'n*(n1^-1) -> n/n1',
     // undo replace 'divide'; for * commutative
     assuming: {

package/lib/esm/function/matrix/range.js

@@ -1,7 +1,7 @@
 import { factory } from '../../utils/factory.js';
 import { noBignumber, noMatrix } from '../../utils/noop.js';
 var name = 'range';
-var dependencies = ['typed', 'config', '?matrix', '?bignumber', 'smaller', 'smallerEq', 'larger', 'largerEq'];
+var dependencies = ['typed', 'config', '?matrix', '?bignumber', 'smaller', 'smallerEq', 'larger', 'largerEq', 'add', 'isPositive'];
 export var createRange = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
@@ -11,7 +11,9 @@ export var createRange = /* #__PURE__ */factory(name, dependencies, _ref => {
     smaller,
     smallerEq,
     larger,
-    largerEq
+    largerEq,
+    add,
+    isPositive
   } = _ref;
   /**
    * Create an array from a range.
@@ -33,11 +35,11 @@ export var createRange = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    * - `str: string`
    *   A string 'start:end' or 'start:step:end'
-   * - `start: {number | BigNumber}`
+   * - `start: {number | BigNumber | Unit}`
    *   Start of the range
-   * - `end: number | BigNumber`
+   * - `end: number | BigNumber | Unit`
    *   End of the range, excluded by default, included when parameter includeEnd=true
-   * - `step: number | BigNumber`
+   * - `step: number | BigNumber | Unit`
    *   Step size. Default value is 1.
    * - `includeEnd: boolean`
    *   Option to specify whether to include the end or not. False by default.
@@ -48,6 +50,7 @@ export var createRange = /* #__PURE__ */factory(name, dependencies, _ref => {
    *     math.range(2, -3, -1)   // [2, 1, 0, -1, -2]
    *     math.range('2:1:6')     // [2, 3, 4, 5]
    *     math.range(2, 6, true)  // [2, 3, 4, 5, 6]
+   *     math.range(math.unit(2, 'm'), math.unit(-3, 'm'), math.unit(-1, 'm')) // [2 m, 1 m, 0 m , -1 m, -2 m]
    *
    * See also:
    *
@@ -63,30 +66,36 @@ export var createRange = /* #__PURE__ */factory(name, dependencies, _ref => {
     string: _strRange,
     'string, boolean': _strRange,
     'number, number': function numberNumber(start, end) {
-      return _out(_rangeEx(start, end, 1));
+      return _out(_range(start, end, 1, false));
     },
     'number, number, number': function numberNumberNumber(start, end, step) {
-      return _out(_rangeEx(start, end, step));
+      return _out(_range(start, end, step, false));
     },
     'number, number, boolean': function numberNumberBoolean(start, end, includeEnd) {
-      return includeEnd ? _out(_rangeInc(start, end, 1)) : _out(_rangeEx(start, end, 1));
+      return _out(_range(start, end, 1, includeEnd));
     },
     'number, number, number, boolean': function numberNumberNumberBoolean(start, end, step, includeEnd) {
-      return includeEnd ? _out(_rangeInc(start, end, step)) : _out(_rangeEx(start, end, step));
+      return _out(_range(start, end, step, includeEnd));
     },
     'BigNumber, BigNumber': function BigNumberBigNumber(start, end) {
       var BigNumber = start.constructor;
-      return _out(_bigRangeEx(start, end, new BigNumber(1)));
+      return _out(_range(start, end, new BigNumber(1), false));
     },
     'BigNumber, BigNumber, BigNumber': function BigNumberBigNumberBigNumber(start, end, step) {
-      return _out(_bigRangeEx(start, end, step));
+      return _out(_range(start, end, step, false));
     },
     'BigNumber, BigNumber, boolean': function BigNumberBigNumberBoolean(start, end, includeEnd) {
       var BigNumber = start.constructor;
-      return includeEnd ? _out(_bigRangeInc(start, end, new BigNumber(1))) : _out(_bigRangeEx(start, end, new BigNumber(1)));
+      return _out(_range(start, end, new BigNumber(1), includeEnd));
     },
     'BigNumber, BigNumber, BigNumber, boolean': function BigNumberBigNumberBigNumberBoolean(start, end, step, includeEnd) {
-      return includeEnd ? _out(_bigRangeInc(start, end, step)) : _out(_bigRangeEx(start, end, step));
+      return _out(_range(start, end, step, includeEnd));
+    },
+    'Unit, Unit, Unit': function UnitUnitUnit(start, end, step) {
+      return _out(_range(start, end, step, false));
+    },
+    'Unit, Unit, Unit, boolean': function UnitUnitUnitBoolean(start, end, step, includeEnd) {
+      return _out(_range(start, end, step, includeEnd));
     }
   });
   function _out(arr) {
@@ -100,117 +109,32 @@ export var createRange = /* #__PURE__ */factory(name, dependencies, _ref => {
     if (!r) {
       throw new SyntaxError('String "' + str + '" is no valid range');
     }
-    var fn;
     if (config.number === 'BigNumber') {
       if (bignumber === undefined) {
         noBignumber();
       }
-      fn = includeEnd ? _bigRangeInc : _bigRangeEx;
-      return _out(fn(bignumber(r.start), bignumber(r.end), bignumber(r.step)));
+      return _out(_range(bignumber(r.start), bignumber(r.end), bignumber(r.step)), includeEnd);
     } else {
-      fn = includeEnd ? _rangeInc : _rangeEx;
-      return _out(fn(r.start, r.end, r.step));
-    }
-  }
-
-  /**
-   * Create a range with numbers. End is excluded
-   * @param {number} start
-   * @param {number} end
-   * @param {number} step
-   * @returns {Array} range
-   * @private
-   */
-  function _rangeEx(start, end, step) {
-    var array = [];
-    var x = start;
-    if (step > 0) {
-      while (smaller(x, end)) {
-        array.push(x);
-        x += step;
-      }
-    } else if (step < 0) {
-      while (larger(x, end)) {
-        array.push(x);
-        x += step;
-      }
-    }
-    return array;
-  }
-
-  /**
-   * Create a range with numbers. End is included
-   * @param {number} start
-   * @param {number} end
-   * @param {number} step
-   * @returns {Array} range
-   * @private
-   */
-  function _rangeInc(start, end, step) {
-    var array = [];
-    var x = start;
-    if (step > 0) {
-      while (smallerEq(x, end)) {
-        array.push(x);
-        x += step;
-      }
-    } else if (step < 0) {
-      while (largerEq(x, end)) {
-        array.push(x);
-        x += step;
-      }
-    }
-    return array;
-  }
-
-  /**
-   * Create a range with big numbers. End is excluded
-   * @param {BigNumber} start
-   * @param {BigNumber} end
-   * @param {BigNumber} step
-   * @returns {Array} range
-   * @private
-   */
-  function _bigRangeEx(start, end, step) {
-    var zero = bignumber(0);
-    var array = [];
-    var x = start;
-    if (step.gt(zero)) {
-      while (smaller(x, end)) {
-        array.push(x);
-        x = x.plus(step);
-      }
-    } else if (step.lt(zero)) {
-      while (larger(x, end)) {
-        array.push(x);
-        x = x.plus(step);
-      }
+      return _out(_range(r.start, r.end, r.step, includeEnd));
     }
-    return array;
   }
 
   /**
-   * Create a range with big numbers. End is included
-   * @param {BigNumber} start
-   * @param {BigNumber} end
-   * @param {BigNumber} step
+   * Create a range with numbers or BigNumbers
+   * @param {number | BigNumber | Unit} start
+   * @param {number | BigNumber | Unit} end
+   * @param {number | BigNumber | Unit} step
+   * @param {boolean} includeEnd
    * @returns {Array} range
    * @private
    */
-  function _bigRangeInc(start, end, step) {
-    var zero = bignumber(0);
+  function _range(start, end, step, includeEnd) {
     var array = [];
+    var ongoing = isPositive(step) ? includeEnd ? smallerEq : smaller : includeEnd ? largerEq : larger;
     var x = start;
-    if (step.gt(zero)) {
-      while (smallerEq(x, end)) {
-        array.push(x);
-        x = x.plus(step);
-      }
-    } else if (step.lt(zero)) {
-      while (largerEq(x, end)) {
-        array.push(x);
-        x = x.plus(step);
-      }
+    while (ongoing(x, end)) {
+      array.push(x);
+      x = add(x, step);
     }
     return array;
   }

package/lib/esm/function/numeric/solveODE.js

@@ -0,0 +1,284 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+import { isUnit, isNumber, isBigNumber } from '../../utils/is.js';
+import { factory } from '../../utils/factory.js';
+var name = 'solveODE';
+var dependencies = ['typed', 'add', 'subtract', 'multiply', 'divide', 'max', 'map', 'abs', 'isPositive', 'isNegative', 'larger', 'smaller', 'matrix', 'bignumber', 'unaryMinus'];
+export var createSolveODE = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    add,
+    subtract,
+    multiply,
+    divide,
+    max,
+    map,
+    abs,
+    isPositive,
+    isNegative,
+    larger,
+    smaller,
+    matrix,
+    bignumber,
+    unaryMinus
+  } = _ref;
+  /**
+     * Numerical Integration of Ordinary Differential Equations
+     *
+     * Two variable step methods are provided:
+     * - "RK23": Bogacki–Shampine method
+     * - "RK45": Dormand-Prince method RK5(4)7M (default)
+     *
+     * The arguments are expected as follows.
+     *
+     * - `func` should be the forcing function `f(t, y)`
+     * - `tspan` should be a vector of two numbers or units `[tStart, tEnd]`
+     * - `y0` the initial state values, should be a scalar or a flat array
+     * - `options` should be an object with the following information:
+     *   - `method` ('RK45'): ['RK23', 'RK45']
+     *   - `tol` (1e-3): Numeric tolerance of the method, the solver keeps the error estimates less than this value
+     *   - `firstStep`: Initial step size
+     *   - `minStep`: minimum step size of the method
+     *   - `maxStep`: maximum step size of the method
+     *   - `minDelta` (0.2): minimum ratio of change for the step
+     *   - `maxDelta` (5): maximum ratio of change for the step
+     *   - `maxIter` (1e4): maximum number of iterations
+     *
+     * The returned value is an object with `{t, y}` please note that even though `t` means time, it can represent any other independant variable like `x`:
+     * - `t` an array of size `[n]`
+     * - `y` the states array can be in two ways
+     *   - **if `y0` is a scalar:** returns an array-like of size `[n]`
+     *   - **if `y0` is a flat array-like of size [m]:** returns an array like of size `[n, m]`
+     *
+     * Syntax:
+     *
+     *     math.solveODE(func, tspan, y0)
+     *     math.solveODE(func, tspan, y0, options)
+     *
+     * Examples:
+     *
+     *     function func(t, y) {return y}
+     *     const tspan = [0, 4]
+     *     const y0 = 1
+     *     math.solveODE(func, tspan, y0)
+     *     math.solveODE(func, tspan, [1, 2])
+     *     math.solveODE(func, tspan, y0, { method:"RK23", maxStep:0.1 })
+     *
+     * See also:
+     *
+     *     derivative, simplifyCore
+     *
+     * @param {function} func The forcing function f(t,y)
+     * @param {Array | Matrix} tspan The time span
+     * @param {number | BigNumber | Unit | Array | Matrix} y0 The initial value
+     * @param {Object} [options] Optional configuration options
+     * @return {Object} Return an object with t and y values as arrays
+     */
+
+  function _rk(butcherTableau) {
+    // generates an adaptive runge kutta method from it's butcher tableau
+
+    return function (f, tspan, y0, options) {
+      // adaptive runge kutta methods
+      var wrongTSpan = !(tspan.length === 2 && (tspan.every(isNumOrBig) || tspan.every(isUnit)));
+      if (wrongTSpan) {
+        throw new Error('"tspan" must be an Array of two numeric values or two units [tStart, tEnd]');
+      }
+      var t0 = tspan[0]; // initial time
+      var tf = tspan[1]; // final time
+      var isForwards = larger(tf, t0);
+      var firstStep = options.firstStep;
+      if (firstStep !== undefined && !isPositive(firstStep)) {
+        throw new Error('"firstStep" must be positive');
+      }
+      var maxStep = options.maxStep;
+      if (maxStep !== undefined && !isPositive(maxStep)) {
+        throw new Error('"maxStep" must be positive');
+      }
+      var minStep = options.minStep;
+      if (minStep && isNegative(minStep)) {
+        throw new Error('"minStep" must be positive or zero');
+      }
+      var timeVars = [t0, tf, firstStep, minStep, maxStep].filter(x => x !== undefined);
+      if (!(timeVars.every(isNumOrBig) || timeVars.every(isUnit))) {
+        throw new Error('Inconsistent type of "t" dependant variables');
+      }
+      var steps = 1; // divide time in this number of steps
+      var tol = options.tol ? options.tol : 1e-4; // define a tolerance (must be an option)
+      var minDelta = options.minDelta ? options.minDelta : 0.2;
+      var maxDelta = options.maxDelta ? options.maxDelta : 5;
+      var maxIter = options.maxIter ? options.maxIter : 10000; // stop inifite evaluation if something goes wrong
+      var hasBigNumbers = [t0, tf, ...y0, maxStep, minStep].some(isBigNumber);
+      var [a, c, b, bp] = hasBigNumbers ? [bignumber(butcherTableau.a), bignumber(butcherTableau.c), bignumber(butcherTableau.b), bignumber(butcherTableau.bp)] : [butcherTableau.a, butcherTableau.c, butcherTableau.b, butcherTableau.bp];
+      var h = firstStep ? isForwards ? firstStep : unaryMinus(firstStep) : divide(subtract(tf, t0), steps); // define the first step size
+      var t = [t0]; // start the time array
+      var y = [y0]; // start the solution array
+
+      var deltaB = subtract(b, bp); // b - bp
+
+      var n = 0;
+      var iter = 0;
+      var ongoing = _createOngoing(isForwards);
+      var trimStep = _createTrimStep(isForwards);
+      // iterate unitil it reaches either the final time or maximum iterations
+      while (ongoing(t[n], tf)) {
+        var k = [];
+
+        // trim the time step so that it doesn't overshoot
+        h = trimStep(t[n], tf, h);
+
+        // calculate the first value of k
+        k.push(f(t[n], y[n]));
+
+        // calculate the rest of the values of k
+        for (var i = 1; i < c.length; ++i) {
+          k.push(f(add(t[n], multiply(c[i], h)), add(y[n], multiply(h, a[i], k))));
+        }
+
+        // estimate the error by comparing solutions of different orders
+        var TE = max(abs(map(multiply(deltaB, k), X => isUnit(X) ? X.value : X)));
+        if (TE < tol && tol / TE > 1 / 4) {
+          // push solution if within tol
+          t.push(add(t[n], h));
+          y.push(add(y[n], multiply(h, b, k)));
+          n++;
+        }
+
+        // estimate the delta value that will affect the step size
+        var delta = 0.84 * (tol / TE) ** (1 / 5);
+        if (smaller(delta, minDelta)) {
+          delta = minDelta;
+        } else if (larger(delta, maxDelta)) {
+          delta = maxDelta;
+        }
+        delta = hasBigNumbers ? bignumber(delta) : delta;
+        h = multiply(h, delta);
+        if (maxStep && larger(abs(h), maxStep)) {
+          h = isForwards ? maxStep : unaryMinus(maxStep);
+        } else if (minStep && smaller(abs(h), minStep)) {
+          h = isForwards ? minStep : unaryMinus(minStep);
+        }
+        iter++;
+        if (iter > maxIter) {
+          throw new Error('Maximum number of iterations reached, try changing options');
+        }
+      }
+      return {
+        t,
+        y
+      };
+    };
+  }
+  function _rk23(f, tspan, y0, options) {
+    // Bogacki–Shampine method
+
+    // Define the butcher table
+    var a = [[], [1 / 2], [0, 3 / 4], [2 / 9, 1 / 3, 4 / 9]];
+    var c = [null, 1 / 2, 3 / 4, 1];
+    var b = [2 / 9, 1 / 3, 4 / 9, 0];
+    var bp = [7 / 24, 1 / 4, 1 / 3, 1 / 8];
+    var butcherTableau = {
+      a,
+      c,
+      b,
+      bp
+    };
+
+    // Solve an adaptive step size rk method
+    return _rk(butcherTableau)(f, tspan, y0, options);
+  }
+  function _rk45(f, tspan, y0, options) {
+    // Dormand Prince method
+
+    // Define the butcher tableau
+    var a = [[], [1 / 5], [3 / 40, 9 / 40], [44 / 45, -56 / 15, 32 / 9], [19372 / 6561, -25360 / 2187, 64448 / 6561, -212 / 729], [9017 / 3168, -355 / 33, 46732 / 5247, 49 / 176, -5103 / 18656], [35 / 384, 0, 500 / 1113, 125 / 192, -2187 / 6784, 11 / 84]];
+    var c = [null, 1 / 5, 3 / 10, 4 / 5, 8 / 9, 1, 1];
+    var b = [35 / 384, 0, 500 / 1113, 125 / 192, -2187 / 6784, 11 / 84, 0];
+    var bp = [5179 / 57600, 0, 7571 / 16695, 393 / 640, -92097 / 339200, 187 / 2100, 1 / 40];
+    var butcherTableau = {
+      a,
+      c,
+      b,
+      bp
+    };
+
+    // Solve an adaptive step size rk method
+    return _rk(butcherTableau)(f, tspan, y0, options);
+  }
+  function _solveODE(f, tspan, y0, opt) {
+    var method = opt.method ? opt.method : 'RK45';
+    var methods = {
+      RK23: _rk23,
+      RK45: _rk45
+    };
+    if (method.toUpperCase() in methods) {
+      var methodOptions = _objectSpread({}, opt); // clone the options object
+      delete methodOptions.method; // delete the method as it won't be needed
+      return methods[method.toUpperCase()](f, tspan, y0, methodOptions);
+    } else {
+      // throw an error indicating there is no such method
+      var methodsWithQuotes = Object.keys(methods).map(x => "\"".concat(x, "\""));
+      // generates a string of methods like: "BDF", "RK23" and "RK45"
+      var availableMethodsString = "".concat(methodsWithQuotes.slice(0, -1).join(', '), " and ").concat(methodsWithQuotes.slice(-1));
+      throw new Error("Unavailable method \"".concat(method, "\". Available methods are ").concat(availableMethodsString));
+    }
+  }
+  function _createOngoing(isForwards) {
+    // returns the correct function to test if it's still iterating
+    return isForwards ? smaller : larger;
+  }
+  function _createTrimStep(isForwards) {
+    var outOfBounds = isForwards ? larger : smaller;
+    return function (t, tf, h) {
+      var next = add(t, h);
+      return outOfBounds(next, tf) ? subtract(tf, t) : h;
+    };
+  }
+  function isNumOrBig(x) {
+    // checks if it's a number or bignumber
+    return isBigNumber(x) || isNumber(x);
+  }
+  function _matrixSolveODE(f, T, y0, options) {
+    // receives matrices and returns matrices
+    var sol = _solveODE(f, T.toArray(), y0.toArray(), options);
+    return {
+      t: matrix(sol.t),
+      y: matrix(sol.y)
+    };
+  }
+  return typed('solveODE', {
+    'function, Array, Array, Object': _solveODE,
+    'function, Matrix, Matrix, Object': _matrixSolveODE,
+    'function, Array, Array': (f, T, y0) => _solveODE(f, T, y0, {}),
+    'function, Matrix, Matrix': (f, T, y0) => _matrixSolveODE(f, T, y0, {}),
+    'function, Array, number | BigNumber | Unit': (f, T, y0) => {
+      var sol = _solveODE(f, T, [y0], {});
+      return {
+        t: sol.t,
+        y: sol.y.map(Y => Y[0])
+      };
+    },
+    'function, Matrix, number | BigNumber | Unit': (f, T, y0) => {
+      var sol = _solveODE(f, T.toArray(), [y0], {});
+      return {
+        t: matrix(sol.t),
+        y: matrix(sol.y.map(Y => Y[0]))
+      };
+    },
+    'function, Array, number | BigNumber | Unit, Object': (f, T, y0, options) => {
+      var sol = _solveODE(f, T, [y0], options);
+      return {
+        t: sol.t,
+        y: sol.y.map(Y => Y[0])
+      };
+    },
+    'function, Matrix, number | BigNumber | Unit, Object': (f, T, y0, options) => {
+      var sol = _solveODE(f, T.toArray(), [y0], options);
+      return {
+        t: matrix(sol.t),
+        y: matrix(sol.y.map(Y => Y[0]))
+      };
+    }
+  });
+});