mathjs-min 11.7.2

package/lib/esm/function/string/format.js

@@ -0,0 +1,131 @@
+import { format as formatString } from '../../utils/string.js';
+import { factory } from '../../utils/factory.js';
+var name = 'format';
+var dependencies = ['typed'];
+export var createFormat = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed
+  } = _ref;
+  /**
+   * Format a value of any type into a string.
+   *
+   * Syntax:
+   *
+   *    math.format(value)
+   *    math.format(value, options)
+   *    math.format(value, precision)
+   *    math.format(value, callback)
+   *
+   * Where:
+   *
+   *  - `value: *`
+   *    The value to be formatted
+   *  - `options: Object`
+   *    An object with formatting options. Available options:
+   *    - `notation: string`
+   *      Number notation. Choose from:
+   *      - `'fixed'`
+   *        Always use regular number notation.
+   *        For example `'123.40'` and `'14000000'`
+   *      - `'exponential'`
+   *        Always use exponential notation.
+   *        For example `'1.234e+2'` and `'1.4e+7'`
+   *      - `'engineering'`
+   *        Always use engineering notation: always have exponential notation,
+   *        and select the exponent to be a multiple of `3`.
+   *        For example `'123.4e+0'` and `'14.0e+6'`
+   *      - `'auto'` (default)
+   *        Regular number notation for numbers having an absolute value between
+   *        `lower` and `upper` bounds, and uses exponential notation elsewhere.
+   *        Lower bound is included, upper bound is excluded.
+   *        For example `'123.4'` and `'1.4e7'`.
+   *      - `'bin'`, `'oct'`, or `'hex'`
+   *        Format the number using binary, octal, or hexadecimal notation.
+   *        For example `'0b1101'` and `'0x10fe'`.
+   *    - `wordSize: number`
+   *      The word size in bits to use for formatting in binary, octal, or
+   *      hexadecimal notation. To be used only with `'bin'`, `'oct'`, or `'hex'`
+   *      values for `notation` option. When this option is defined the value
+   *      is formatted as a signed twos complement integer of the given word
+   *      size and the size suffix is appended to the output.
+   *      For example `format(-1, {notation: 'hex', wordSize: 8}) === '0xffi8'`.
+   *      Default value is undefined.
+   *    - `precision: number`
+   *      Limit the number of digits of the formatted value.
+   *      For regular numbers, must be a number between `0` and `16`.
+   *      For bignumbers, the maximum depends on the configured precision,
+   *      see function `config()`.
+   *      In case of notations `'exponential'`, `'engineering'`, and `'auto'`,
+   *      `precision` defines the total number of significant digits returned.
+   *      In case of notation `'fixed'`, `precision` defines the number of
+   *      significant digits after the decimal point.
+   *      `precision` is undefined by default.
+   *    - `lowerExp: number`
+   *      Exponent determining the lower boundary for formatting a value with
+   *      an exponent when `notation='auto'`. Default value is `-3`.
+   *    - `upperExp: number`
+   *      Exponent determining the upper boundary for formatting a value with
+   *      an exponent when `notation='auto'`. Default value is `5`.
+   *    - `fraction: string`. Available values: `'ratio'` (default) or `'decimal'`.
+   *      For example `format(fraction(1, 3))` will output `'1/3'` when `'ratio'`
+   *      is configured, and will output `'0.(3)'` when `'decimal'` is configured.
+   *    - `truncate: number`. Specifies the maximum allowed length of the
+   *      returned string. If it had been longer, the excess characters
+   *      are deleted and replaced with `'...'`.
+   * - `callback: function`
+   *   A custom formatting function, invoked for all numeric elements in `value`,
+   *   for example all elements of a matrix, or the real and imaginary
+   *   parts of a complex number. This callback can be used to override the
+   *   built-in numeric notation with any type of formatting. Function `callback`
+   *   is called with `value` as parameter and must return a string.
+   *
+   * When `value` is an Object:
+   *
+   * - When the object contains a property `format` being a function, this function
+   *   is invoked as `value.format(options)` and the result is returned.
+   * - When the object has its own `toString` method, this method is invoked
+   *   and the result is returned.
+   * - In other cases the function will loop over all object properties and
+   *   return JSON object notation like '{"a": 2, "b": 3}'.
+   *
+   * When value is a function:
+   *
+   * - When the function has a property `syntax`, it returns this
+   *   syntax description.
+   * - In other cases, a string `'function'` is returned.
+   *
+   * Examples:
+   *
+   *    math.format(6.4)                                        // returns '6.4'
+   *    math.format(1240000)                                    // returns '1.24e+6'
+   *    math.format(1/3)                                        // returns '0.3333333333333333'
+   *    math.format(1/3, 3)                                     // returns '0.333'
+   *    math.format(21385, 2)                                   // returns '21000'
+   *    math.format(12e8, {notation: 'fixed'})                  // returns '1200000000'
+   *    math.format(2.3,  {notation: 'fixed', precision: 4})    // returns '2.3000'
+   *    math.format(52.8, {notation: 'exponential'})            // returns '5.28e+1'
+   *    math.format(12400, {notation: 'engineering'})           // returns '12.4e+3'
+   *    math.format(2000, {lowerExp: -2, upperExp: 2})          // returns '2e+3'
+   *
+   *    function formatCurrency(value) {
+   *      // return currency notation with two digits:
+   *      return '$' + value.toFixed(2)
+   *
+   *      // you could also use math.format inside the callback:
+   *      // return '$' + math.format(value, {notation: 'fixed', precision: 2})
+   *    }
+   *    math.format([2.1, 3, 0.016], formatCurrency)            // returns '[$2.10, $3.00, $0.02]'
+   *
+   * See also:
+   *
+   *    print
+   *
+   * @param {*} value                               Value to be stringified
+   * @param {Object | Function | number} [options]  Formatting options
+   * @return {string} The formatted value
+   */
+  return typed(name, {
+    any: formatString,
+    'any, Object | function | number': formatString
+  });
+});

package/lib/esm/function/string/hex.js

@@ -0,0 +1,43 @@
+import { factory } from '../../utils/factory.js';
+var name = 'hex';
+var dependencies = ['typed', 'format'];
+
+/**
+ * Format a number as hexadecimal.
+ *
+ * Syntax:
+ *
+ *    math.hex(value)
+ *
+ * Examples:
+ *
+ *    math.hex(240) // returns "0xF0"
+ *
+ * See also:
+ *
+ *    oct
+ *    bin
+ *
+ * @param {number} value    Value to be stringified
+ * @param {number} wordSize Optional word size (see `format`)
+ * @return {string}         The formatted value
+ */
+export var createHex = factory(name, dependencies, _ref => {
+  var {
+    typed,
+    format
+  } = _ref;
+  return typed(name, {
+    'number | BigNumber': function numberBigNumber(n) {
+      return format(n, {
+        notation: 'hex'
+      });
+    },
+    'number | BigNumber, number': function numberBigNumberNumber(n, wordSize) {
+      return format(n, {
+        notation: 'hex',
+        wordSize
+      });
+    }
+  });
+});

package/lib/esm/function/string/oct.js

@@ -0,0 +1,45 @@
+import { factory } from '../../utils/factory.js';
+var name = 'oct';
+var dependencies = ['typed', 'format'];
+
+/**
+ * Format a number as octal.
+ *
+ * Syntax:
+ *
+ *    math.oct(value)
+ *
+ * Examples:
+ *
+ *    //the following outputs "0o70"
+ *    math.oct(56)
+ *
+ * See also:
+ *
+ *    bin
+ *    hex
+ *
+ * @param {number} value    Value to be stringified
+ * @param {number} wordSize Optional word size (see `format`)
+ * @return {string}         The formatted value
+ */
+
+export var createOct = factory(name, dependencies, _ref => {
+  var {
+    typed,
+    format
+  } = _ref;
+  return typed(name, {
+    'number | BigNumber': function numberBigNumber(n) {
+      return format(n, {
+        notation: 'oct'
+      });
+    },
+    'number | BigNumber, number': function numberBigNumberNumber(n, wordSize) {
+      return format(n, {
+        notation: 'oct',
+        wordSize
+      });
+    }
+  });
+});

package/lib/esm/function/string/print.js

@@ -0,0 +1,86 @@
+import { format } from '../../utils/string.js';
+import { isString } from '../../utils/is.js';
+import { factory } from '../../utils/factory.js';
+var name = 'print';
+var dependencies = ['typed'];
+export var createPrint = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed
+  } = _ref;
+  /**
+   * Interpolate values into a string template.
+   *
+   * Syntax:
+   *
+   *     math.print(template, values)
+   *     math.print(template, values, precision)
+   *     math.print(template, values, options)
+   *
+   * Example usage:
+   *
+   *     // the following outputs: 'Lucy is 5 years old'
+   *     math.print('Lucy is $age years old', {age: 5})
+   *
+   *     // the following outputs: 'The value of pi is 3.141592654'
+   *     math.print('The value of pi is $pi', {pi: math.pi}, 10)
+   *
+   *     // the following outputs: 'hello Mary! The date is 2013-03-23'
+   *     math.print('Hello $user.name! The date is $date', {
+   *       user: {
+   *         name: 'Mary',
+   *       },
+   *       date: new Date(2013, 2, 23).toISOString().substring(0, 10)
+   *     })
+   *
+   *     // the following outputs: 'My favorite fruits are apples and bananas !'
+   *     math.print('My favorite fruits are $0 and $1 !', [
+   *       'apples',
+   *       'bananas'
+   *     ])
+   *
+   * See also:
+   *
+   *     format
+   *
+   * @param {string} template           A string containing variable placeholders.
+   * @param {Object | Array | Matrix}   values An object or array containing variables
+   *                                    which will be filled in in the template.
+   * @param {number | Object} [options] Formatting options,
+   *                                    or the number of digits to format numbers.
+   *                                    See function math.format for a description
+   *                                    of all options.
+   * @return {string} Interpolated string
+   */
+  return typed(name, {
+    // note: Matrix will be converted automatically to an Array
+    'string, Object | Array': _print,
+    'string, Object | Array, number | Object': _print
+  });
+});
+
+/**
+ * Interpolate values into a string template.
+ * @param {string} template
+ * @param {Object} values
+ * @param {number | Object} [options]
+ * @returns {string} Interpolated string
+ * @private
+ */
+function _print(template, values, options) {
+  return template.replace(/\$([\w.]+)/g, function (original, key) {
+    var keys = key.split('.');
+    var value = values[keys.shift()];
+    while (keys.length && value !== undefined) {
+      var k = keys.shift();
+      value = k ? value[k] : value + '.';
+    }
+    if (value !== undefined) {
+      if (!isString(value)) {
+        return format(value, options);
+      } else {
+        return value;
+      }
+    }
+    return original;
+  });
+}

package/lib/esm/function/trigonometry/acos.js

@@ -0,0 +1,49 @@
+import { factory } from '../../utils/factory.js';
+var name = 'acos';
+var dependencies = ['typed', 'config', 'Complex'];
+export var createAcos = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    config,
+    Complex
+  } = _ref;
+  /**
+   * Calculate the inverse cosine of a value.
+   *
+   * To avoid confusion with the matrix arccosine, this function does not
+   * apply to matrices.
+   *
+   * Syntax:
+   *
+   *    math.acos(x)
+   *
+   * Examples:
+   *
+   *    math.acos(0.5)           // returns number 1.0471975511965979
+   *    math.acos(math.cos(1.5)) // returns number 1.5
+   *
+   *    math.acos(2)             // returns Complex 0 + 1.3169578969248166 i
+   *
+   * See also:
+   *
+   *    cos, atan, asin
+   *
+   * @param {number | BigNumber | Complex} x  Function input
+   * @return {number | BigNumber | Complex} The arc cosine of x
+   */
+  return typed(name, {
+    number: function number(x) {
+      if (x >= -1 && x <= 1 || config.predictable) {
+        return Math.acos(x);
+      } else {
+        return new Complex(x, 0).acos();
+      }
+    },
+    Complex: function Complex(x) {
+      return x.acos();
+    },
+    BigNumber: function BigNumber(x) {
+      return x.acos();
+    }
+  });
+});

package/lib/esm/function/trigonometry/acosh.js

@@ -0,0 +1,49 @@
+import { factory } from '../../utils/factory.js';
+import { acoshNumber } from '../../plain/number/index.js';
+var name = 'acosh';
+var dependencies = ['typed', 'config', 'Complex'];
+export var createAcosh = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    config,
+    Complex
+  } = _ref;
+  /**
+   * Calculate the hyperbolic arccos of a value,
+   * defined as `acosh(x) = ln(sqrt(x^2 - 1) + x)`.
+   *
+   * For matrices, the function is evaluated element wise.
+   *
+   * Syntax:
+   *
+   *    math.acosh(x)
+   *
+   * Examples:
+   *
+   *    math.acosh(1.5)       // returns 0.9624236501192069
+   *
+   * See also:
+   *
+   *    cosh, asinh, atanh
+   *
+   * @param {number | BigNumber | Complex} x  Function input
+   * @return {number | BigNumber | Complex} Hyperbolic arccosine of x
+   */
+  return typed(name, {
+    number: function number(x) {
+      if (x >= 1 || config.predictable) {
+        return acoshNumber(x);
+      }
+      if (x <= -1) {
+        return new Complex(Math.log(Math.sqrt(x * x - 1) - x), Math.PI);
+      }
+      return new Complex(x, 0).acosh();
+    },
+    Complex: function Complex(x) {
+      return x.acosh();
+    },
+    BigNumber: function BigNumber(x) {
+      return x.acosh();
+    }
+  });
+});

package/lib/esm/function/trigonometry/acot.js

@@ -0,0 +1,42 @@
+import { factory } from '../../utils/factory.js';
+import { acotNumber } from '../../plain/number/index.js';
+var name = 'acot';
+var dependencies = ['typed', 'BigNumber'];
+export var createAcot = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    BigNumber: _BigNumber
+  } = _ref;
+  /**
+   * Calculate the inverse cotangent of a value, defined as `acot(x) = atan(1/x)`.
+   *
+   * To avoid confusion with the matrix arccotanget, this function does not
+   * apply to matrices.
+   *
+   * Syntax:
+   *
+   *    math.acot(x)
+   *
+   * Examples:
+   *
+   *    math.acot(0.5)           // returns number 1.1071487177940904
+   *    math.acot(2)             // returns number 0.4636476090008061
+   *    math.acot(math.cot(1.5)) // returns number 1.5
+   *
+   * See also:
+   *
+   *    cot, atan
+   *
+   * @param {number | BigNumber| Complex} x   Function input
+   * @return {number | BigNumber| Complex} The arc cotangent of x
+   */
+  return typed(name, {
+    number: acotNumber,
+    Complex: function Complex(x) {
+      return x.acot();
+    },
+    BigNumber: function BigNumber(x) {
+      return new _BigNumber(1).div(x).atan();
+    }
+  });
+});

package/lib/esm/function/trigonometry/acoth.js

@@ -0,0 +1,48 @@
+import { factory } from '../../utils/factory.js';
+import { acothNumber } from '../../plain/number/index.js';
+var name = 'acoth';
+var dependencies = ['typed', 'config', 'Complex', 'BigNumber'];
+export var createAcoth = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    config,
+    Complex,
+    BigNumber: _BigNumber
+  } = _ref;
+  /**
+   * Calculate the hyperbolic arccotangent of a value,
+   * defined as `acoth(x) = atanh(1/x) = (ln((x+1)/x) + ln(x/(x-1))) / 2`.
+   *
+   * To avoid confusion with the matrix hyperbolic arccotangent, this
+   * function does not apply to matrices.
+   *
+   * Syntax:
+   *
+   *    math.acoth(x)
+   *
+   * Examples:
+   *
+   *    math.acoth(0.5)       // returns 0.8047189562170503
+   *
+   * See also:
+   *
+   *    acsch, asech
+   *
+   * @param {number | BigNumber | Complex} x  Function input
+   * @return {number | BigNumber | Complex} Hyperbolic arccotangent of x
+   */
+  return typed(name, {
+    number: function number(x) {
+      if (x >= 1 || x <= -1 || config.predictable) {
+        return acothNumber(x);
+      }
+      return new Complex(x, 0).acoth();
+    },
+    Complex: function Complex(x) {
+      return x.acoth();
+    },
+    BigNumber: function BigNumber(x) {
+      return new _BigNumber(1).div(x).atanh();
+    }
+  });
+});

package/lib/esm/function/trigonometry/acsc.js

@@ -0,0 +1,49 @@
+import { factory } from '../../utils/factory.js';
+import { acscNumber } from '../../plain/number/index.js';
+var name = 'acsc';
+var dependencies = ['typed', 'config', 'Complex', 'BigNumber'];
+export var createAcsc = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    config,
+    Complex,
+    BigNumber: _BigNumber
+  } = _ref;
+  /**
+   * Calculate the inverse cosecant of a value, defined as `acsc(x) = asin(1/x)`.
+   *
+   * To avoid confusion with the matrix arccosecant, this function does not
+   * apply to matrices.
+   *
+   * Syntax:
+   *
+   *    math.acsc(x)
+   *
+   * Examples:
+   *
+   *    math.acsc(2)             // returns 0.5235987755982989
+   *    math.acsc(0.5)           // returns Complex 1.5707963267948966 -1.3169578969248166i
+   *    math.acsc(math.csc(1.5)) // returns number ~1.5
+   *
+   * See also:
+   *
+   *    csc, asin, asec
+   *
+   * @param {number | BigNumber | Complex} x   Function input
+   * @return {number | BigNumber | Complex} The arc cosecant of x
+   */
+  return typed(name, {
+    number: function number(x) {
+      if (x <= -1 || x >= 1 || config.predictable) {
+        return acscNumber(x);
+      }
+      return new Complex(x, 0).acsc();
+    },
+    Complex: function Complex(x) {
+      return x.acsc();
+    },
+    BigNumber: function BigNumber(x) {
+      return new _BigNumber(1).div(x).asin();
+    }
+  });
+});

package/lib/esm/function/trigonometry/acsch.js

@@ -0,0 +1,41 @@
+import { factory } from '../../utils/factory.js';
+import { acschNumber } from '../../plain/number/index.js';
+var name = 'acsch';
+var dependencies = ['typed', 'BigNumber'];
+export var createAcsch = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    BigNumber: _BigNumber
+  } = _ref;
+  /**
+   * Calculate the hyperbolic arccosecant of a value,
+   * defined as `acsch(x) = asinh(1/x) = ln(1/x + sqrt(1/x^2 + 1))`.
+   *
+   * To avoid confusion with the matrix hyperbolic arccosecant, this function
+   * does not apply to matrices.
+   *
+   * Syntax:
+   *
+   *    math.acsch(x)
+   *
+   * Examples:
+   *
+   *    math.acsch(0.5)       // returns 1.4436354751788103
+   *
+   * See also:
+   *
+   *    asech, acoth
+   *
+   * @param {number | BigNumber | Complex} x  Function input
+   * @return {number | BigNumber | Complex} Hyperbolic arccosecant of x
+   */
+  return typed(name, {
+    number: acschNumber,
+    Complex: function Complex(x) {
+      return x.acsch();
+    },
+    BigNumber: function BigNumber(x) {
+      return new _BigNumber(1).div(x).asinh();
+    }
+  });
+});

package/lib/esm/function/trigonometry/asec.js

@@ -0,0 +1,50 @@
+import { factory } from '../../utils/factory.js';
+import { asecNumber } from '../../plain/number/index.js';
+var name = 'asec';
+var dependencies = ['typed', 'config', 'Complex', 'BigNumber'];
+export var createAsec = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    config,
+    Complex,
+    BigNumber: _BigNumber
+  } = _ref;
+  /**
+   * Calculate the inverse secant of a value. Defined as `asec(x) = acos(1/x)`.
+   *
+   * To avoid confusion with the matrix arcsecant, this function does not
+   * apply to matrices.
+   *
+   * Syntax:
+   *
+   *    math.asec(x)
+   *
+   * Examples:
+   *
+   *    math.asec(2)             // returns 1.0471975511965979
+   *    math.asec(math.sec(1.5)) // returns 1.5
+   *
+   *    math.asec(0.5)           // returns Complex 0 + 1.3169578969248166i
+   *
+   * See also:
+   *
+   *    acos, acot, acsc
+   *
+   * @param {number | BigNumber | Complex} x  Function input
+   * @return {number | BigNumber | Complex} The arc secant of x
+   */
+  return typed(name, {
+    number: function number(x) {
+      if (x <= -1 || x >= 1 || config.predictable) {
+        return asecNumber(x);
+      }
+      return new Complex(x, 0).asec();
+    },
+    Complex: function Complex(x) {
+      return x.asec();
+    },
+    BigNumber: function BigNumber(x) {
+      return new _BigNumber(1).div(x).acos();
+    }
+  });
+});

package/lib/esm/function/trigonometry/asech.js

@@ -0,0 +1,53 @@
+import { factory } from '../../utils/factory.js';
+import { asechNumber } from '../../plain/number/index.js';
+var name = 'asech';
+var dependencies = ['typed', 'config', 'Complex', 'BigNumber'];
+export var createAsech = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    config,
+    Complex,
+    BigNumber: _BigNumber
+  } = _ref;
+  /**
+   * Calculate the hyperbolic arcsecant of a value,
+   * defined as `asech(x) = acosh(1/x) = ln(sqrt(1/x^2 - 1) + 1/x)`.
+   *
+   * To avoid confusion with the matrix hyperbolic arcsecant, this function
+   * does not apply to matrices.
+   *
+   * Syntax:
+   *
+   *    math.asech(x)
+   *
+   * Examples:
+   *
+   *    math.asech(0.5)       // returns 1.3169578969248166
+   *
+   * See also:
+   *
+   *    acsch, acoth
+   *
+   * @param {number | BigNumber | Complex} x  Function input
+   * @return {number | BigNumber | Complex} Hyperbolic arcsecant of x
+   */
+  return typed(name, {
+    number: function number(x) {
+      if (x <= 1 && x >= -1 || config.predictable) {
+        var xInv = 1 / x;
+        if (xInv > 0 || config.predictable) {
+          return asechNumber(x);
+        }
+        var ret = Math.sqrt(xInv * xInv - 1);
+        return new Complex(Math.log(ret - xInv), Math.PI);
+      }
+      return new Complex(x, 0).asech();
+    },
+    Complex: function Complex(x) {
+      return x.asech();
+    },
+    BigNumber: function BigNumber(x) {
+      return new _BigNumber(1).div(x).acosh();
+    }
+  });
+});