mathjs 15.1.1 → 15.2.0

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

@@ -88,6 +88,8 @@ import { subtractDocs } from './function/arithmetic/subtract.js';
 import { unaryMinusDocs } from './function/arithmetic/unaryMinus.js';
 import { unaryPlusDocs } from './function/arithmetic/unaryPlus.js';
 import { xgcdDocs } from './function/arithmetic/xgcd.js';
+import { numDocs } from './function/fraction/num.js';
+import { denDocs } from './function/fraction/den.js';
 import { bitAndDocs } from './function/bitwise/bitAnd.js';
 import { bitNotDocs } from './function/bitwise/bitNot.js';
 import { bitOrDocs } from './function/bitwise/bitOr.js';
@@ -551,6 +553,8 @@ export var embeddedDocs = {
   unaryPlus: unaryPlusDocs,
   xgcd: xgcdDocs,
   invmod: invmodDocs,
+  num: numDocs,
+  den: denDocs,
   // functions - bitwise
   bitAnd: bitAndDocs,
   bitNot: bitNotDocs,

package/lib/esm/expression/embeddedDocs/function/fraction/den.js

@@ -0,0 +1,8 @@
+export var denDocs = {
+  name: 'den',
+  category: 'Fraction',
+  syntax: ['den(x)'],
+  description: 'Get the denominator of a fraction.',
+  examples: ['den(fraction(2, 3))', 'den(fraction(5, 8))'],
+  seealso: ['num', 'fraction']
+};

package/lib/esm/expression/embeddedDocs/function/fraction/num.js

@@ -0,0 +1,8 @@
+export var numDocs = {
+  name: 'num',
+  category: 'Fraction',
+  syntax: ['num(x)'],
+  description: 'Get the numerator of a fraction.',
+  examples: ['num(fraction(2, 3))', 'num(fraction(5, 8))'],
+  seealso: ['den', 'fraction']
+};

package/lib/esm/factoriesAny.js

@@ -300,4 +300,6 @@ export { createAndTransform } from './expression/transform/and.transform.js';
 export { createOrTransform } from './expression/transform/or.transform.js';
 export { createNullishTransform } from './expression/transform/nullish.transform.js';
 export { createBitAndTransform } from './expression/transform/bitAnd.transform.js';
-export { createBitOrTransform } from './expression/transform/bitOr.transform.js';
+export { createBitOrTransform } from './expression/transform/bitOr.transform.js';
+export { createNum } from './function/fraction/num.js';
+export { createDen } from './function/fraction/den.js';

package/lib/esm/function/fraction/den.js

@@ -0,0 +1,54 @@
+import { factory } from '../../utils/factory.js';
+import { deepMap } from '../../utils/collection.js';
+var name = 'den';
+var dependencies = ['typed', 'fraction'];
+export var createDen = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    fraction
+  } = _ref;
+  /**
+   * Get the denominator of a fraction.
+   * For a fraction `a/b`, the function returns `b`.
+   *
+   * The result is always in lowest terms. For example, `den(fraction(8, 6))`
+   * returns `3n` because 8/6 simplifies to 4/3.
+   *
+   * For negative fractions like `-a/b` or `a/-b`, the denominator is
+   * always returned as a positive bigint. The sign is stored in the
+   * numerator. So `den(fraction(-2, 3))` and `den(fraction(2, -3))`
+   * both return `3n`.
+   *
+   * For matrices, the function is evaluated element wise.
+   *
+   * Syntax:
+   *
+   *    math.den(x)
+   *
+   * Examples:
+   *
+   *    math.den(math.fraction(2, 3))   // returns 3n
+   *    math.den(math.fraction(8, 6))   // returns 3n
+   *    math.den(math.fraction('5/8'))  // returns 8n
+   *    math.den(math.fraction(-2, 3))  // returns 3n
+   *    math.den(math.fraction(2, -3))  // returns 3n
+   *    math.den(math.bignumber('0.5'))  // returns 2n
+   *
+   * See also:
+   *
+   *    num, fraction
+   *
+   * History:
+   *
+   *    v15.2.0      Created
+   *
+   * @param {Fraction | BigNumber | Array | Matrix} x
+   *            A fraction, BigNumber, or array with fractions
+   * @return {bigint | Array | Matrix} The denominator of x (in lowest terms)
+   */
+  return typed(name, {
+    Fraction: x => x.d,
+    BigNumber: x => fraction(x).d,
+    'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self))
+  });
+});

package/lib/esm/function/fraction/num.js

@@ -0,0 +1,56 @@
+import { factory } from '../../utils/factory.js';
+import { deepMap } from '../../utils/collection.js';
+var name = 'num';
+var dependencies = ['typed', 'fraction'];
+export var createNum = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    fraction
+  } = _ref;
+  /**
+   * Get the numerator of a fraction.
+   * For a fraction `a/b`, the function returns `a`.
+   *
+   * The result is always in lowest terms. For example, `num(fraction(8, 6))`
+   * returns `4n` because 8/6 simplifies to 4/3.
+   *
+   * For negative fractions like `-a/b` or `a/-b`, the sign is always
+   * included in the numerator. Both forms are normalized internally, so
+   * `num(fraction(-2, 3))` and `num(fraction(2, -3))` both return `-2`.
+   *
+   * For matrices, the function is evaluated element wise.
+   *
+   * Syntax:
+   *
+   *    math.num(x)
+   *
+   * Examples:
+   *
+   *    math.num(math.fraction(2, 3))   // returns 2n
+   *    math.num(math.fraction(8, 6))   // returns 4n
+   *    math.num(math.fraction('5/8'))  // returns 5n
+   *    math.num(math.fraction(-2, 3))  // returns -2n
+   *    math.num(math.fraction(2, -3))  // returns -2n
+   *    math.num(math.bignumber('0.5'))  // returns 1n
+   *
+   * See also:
+   *
+   *    den, fraction
+   *
+   * History:
+   *
+   *    v15.2.0      Created
+   *
+   * @param {Fraction | BigNumber | Array | Matrix} x
+   *            A fraction, BigNumber, or array with fractions
+   * @return {bigint | Array | Matrix} The numerator of x (in lowest terms)
+   */
+  return typed(name, {
+    Fraction: x => x.s * x.n,
+    BigNumber: x => {
+      var f = fraction(x);
+      return f.s * f.n;
+    },
+    'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self))
+  });
+});

package/lib/esm/type/unit/Unit.js

@@ -3159,6 +3159,13 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, _ref =>
       value: 1,
       offset: 0
     },
+    Ah: {
+      name: 'Ah',
+      base: BASE_UNITS.ELECTRIC_CHARGE,
+      prefixes: PREFIXES.SHORT,
+      value: 3600,
+      offset: 0
+    },
     // Electric capacitance
     farad: {
       name: 'farad',

package/lib/esm/utils/array.js

@@ -820,6 +820,9 @@ export function get(array, index) {
   if (!Array.isArray(array)) {
     throw new Error('Array expected');
   }
+  if (!Array.isArray(index)) {
+    throw new Error('Array expected for index');
+  }
   var size = arraySize(array);
   if (index.length !== size.length) {
     throw new DimensionError(index.length, size.length);

package/lib/esm/utils/customs.js

@@ -1,26 +1,28 @@
 import { hasOwnProperty } from './object.js';
 
 /**
- * Get a property of a plain object
+ * Get a property of a plain object or array
  * Throws an error in case the object is not a plain object or the
  * property is not defined on the object itself
  * @param {Object} object
  * @param {string} prop
  * @return {*} Returns the property value when safe
  */
-function getSafeProperty(object, prop) {
-  // only allow getting safe properties of a plain object
-  if (isSafeProperty(object, prop)) {
+export function getSafeProperty(object, prop) {
+  if (isSafeObjectProperty(object, prop) || isSafeArrayProperty(object, prop)) {
     return object[prop];
   }
-  if (typeof object[prop] === 'function' && isSafeMethod(object, prop)) {
-    throw new Error('Cannot access method "' + prop + '" as a property');
+  if (isSafeMethod(object, prop)) {
+    throw new Error("Cannot access method \"".concat(prop, "\" as a property"));
+  }
+  if (object === null || object === undefined) {
+    throw new TypeError("Cannot access property \"".concat(prop, "\": object is ").concat(object));
   }
   throw new Error('No access to property "' + prop + '"');
 }
 
 /**
- * Set a property on a plain object.
+ * Set a property on a plain object or array.
  * Throws an error in case the object is not a plain object or the
  * property would override an inherited property like .constructor or .toString
  * @param {Object} object
@@ -28,49 +30,43 @@ function getSafeProperty(object, prop) {
  * @param {*} value
  * @return {*} Returns the value
  */
-// TODO: merge this function into access.js?
-function setSafeProperty(object, prop, value) {
-  // only allow setting safe properties of a plain object
-  if (isSafeProperty(object, prop)) {
+export function setSafeProperty(object, prop, value) {
+  if (isSafeObjectProperty(object, prop) || isSafeArrayProperty(object, prop)) {
     object[prop] = value;
     return value;
   }
-  throw new Error('No access to property "' + prop + '"');
+  throw new Error("No access to property \"".concat(prop, "\""));
 }
 
 /**
- * Test whether a property is safe to use on an object or Array.
- * For example .toString and .constructor are not safe
- * @param {Object | Array} object
+ * Test whether a property is safe for reading and writing on an object
+ * For example .constructor and .__proto__ are not safe
+ * @param {Object} object
  * @param {string} prop
  * @return {boolean} Returns true when safe
  */
-function isSafeProperty(object, prop) {
-  if (!isPlainObject(object) && !Array.isArray(object)) {
+export function isSafeObjectProperty(object, prop) {
+  if (!isPlainObject(object)) {
     return false;
   }
-  // SAFE: whitelisted
-  // e.g length
-  if (hasOwnProperty(safeNativeProperties, prop)) {
-    return true;
-  }
-  // UNSAFE: inherited from Object prototype
-  // e.g constructor
-  if (prop in Object.prototype) {
-    // 'in' is used instead of hasOwnProperty for nodejs v0.10
-    // which is inconsistent on root prototypes. It is safe
-    // here because Object.prototype is a root object
-    return false;
-  }
-  // UNSAFE: inherited from Function prototype
-  // e.g call, apply
-  if (prop in Function.prototype) {
-    // 'in' is used instead of hasOwnProperty for nodejs v0.10
-    // which is inconsistent on root prototypes. It is safe
-    // here because Function.prototype is a root object
+  return !(prop in Object.prototype);
+}
+
+/**
+ * Test whether a property is safe for reading and writing on an Array
+ * For example .__proto__ and .constructor are not safe
+ * @param {unknown} array
+ * @param {string | number} prop
+ * @return {boolean} Returns true when safe
+ */
+export function isSafeArrayProperty(array, prop) {
+  if (!Array.isArray(array)) {
     return false;
   }
-  return true;
+  return typeof prop === 'number' || typeof prop === 'string' && isInteger(prop) || prop === 'length';
+}
+function isInteger(prop) {
+  return /^\d+$/.test(prop);
 }
 
 /**
@@ -80,7 +76,7 @@ function isSafeProperty(object, prop) {
  * @param {string} method
  * @return {function} Returns the method when valid
  */
-function getSafeMethod(object, method) {
+export function getSafeMethod(object, method) {
   if (!isSafeMethod(object, method)) {
     throw new Error('No access to method "' + method + '"');
   }
@@ -94,21 +90,24 @@ function getSafeMethod(object, method) {
  * @param {string} method
  * @return {boolean} Returns true when safe, false otherwise
  */
-function isSafeMethod(object, method) {
+export function isSafeMethod(object, method) {
   if (object === null || object === undefined || typeof object[method] !== 'function') {
     return false;
   }
+
   // UNSAFE: ghosted
   // e.g overridden toString
   // Note that IE10 doesn't support __proto__ and we can't do this check there.
   if (hasOwnProperty(object, method) && Object.getPrototypeOf && method in Object.getPrototypeOf(object)) {
     return false;
   }
+
   // SAFE: whitelisted
   // e.g toString
-  if (hasOwnProperty(safeNativeMethods, method)) {
+  if (safeNativeMethods.has(method)) {
     return true;
   }
+
   // UNSAFE: inherited from Object prototype
   // e.g constructor
   if (method in Object.prototype) {
@@ -117,6 +116,7 @@ function isSafeMethod(object, method) {
     // here because Object.prototype is a root object
     return false;
   }
+
   // UNSAFE: inherited from Function prototype
   // e.g call, apply
   if (method in Function.prototype) {
@@ -127,21 +127,7 @@ function isSafeMethod(object, method) {
   }
   return true;
 }
-function isPlainObject(object) {
+export function isPlainObject(object) {
   return typeof object === 'object' && object && object.constructor === Object;
 }
-var safeNativeProperties = {
-  length: true,
-  name: true
-};
-var safeNativeMethods = {
-  toString: true,
-  valueOf: true,
-  toLocaleString: true
-};
-export { getSafeProperty };
-export { setSafeProperty };
-export { isSafeProperty };
-export { getSafeMethod };
-export { isSafeMethod };
-export { isPlainObject };
+var safeNativeMethods = new Set(['toString', 'valueOf', 'toLocaleString']);

package/lib/esm/utils/map.js

@@ -1,4 +1,4 @@
-import { getSafeProperty, isSafeProperty, setSafeProperty } from './customs.js';
+import { getSafeProperty, isSafeObjectProperty, setSafeProperty } from './customs.js';
 import { isMap, isObject } from './is.js';
 
 /**
@@ -25,7 +25,7 @@ export class ObjectWrappingMap {
     return this;
   }
   has(key) {
-    return isSafeProperty(this.wrappedObject, key) && key in this.wrappedObject;
+    return isSafeObjectProperty(this.wrappedObject, key) && key in this.wrappedObject;
   }
   entries() {
     return mapIterator(this.keys(), key => [key, this.get(key)]);
@@ -36,7 +36,7 @@ export class ObjectWrappingMap {
     }
   }
   delete(key) {
-    if (isSafeProperty(this.wrappedObject, key)) {
+    if (isSafeObjectProperty(this.wrappedObject, key)) {
       delete this.wrappedObject[key];
     }
   }

package/lib/esm/version.js

@@ -1,3 +1,3 @@
-export var version = '15.1.1';
+export var version = '15.2.0';
 // Note: This file is automatically generated when building math.js.
 // Changes made in this file will be overwritten.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mathjs",
-  "version": "15.1.1",
+  "version": "15.2.0",
   "description": "Math.js is an extensive math library for JavaScript and Node.js. It features a flexible expression parser with support for symbolic computation, comes with a large set of built-in functions and constants, and offers an integrated solution to work with different data types like numbers, big numbers, complex numbers, fractions, units, and matrices.",
   "author": "Jos de Jong <wjosdejong@gmail.com> (https://github.com/josdejong)",
   "homepage": "https://mathjs.org",

package/types/index.d.ts

@@ -1823,6 +1823,26 @@ export interface MathJsInstance extends MathJsFactory {
   re(x: MathJsChain<number | Complex>): MathJsChain<number>
   re<T extends BigNumber | MathCollection>(x: MathJsChain<T>): MathJsChain<T>
 
+  /**
+   * Get the numerator of a fraction. For a fraction a/b, the function
+   * returns a. For matrices, the function is evaluated element wise.
+   * @param x A fraction, BigNumber, or array with fractions
+   * @returns The numerator of x
+   */
+  num(x: number | BigNumber | bigint | Fraction): bigint
+  num(x: MathArray<MathScalarType>): MathArray<bigint>
+  num(x: Matrix<MathScalarType>): Matrix<bigint>
+
+  /**
+   * Get the denominator of a fraction. For a fraction a/b, the function
+   * returns b. For matrices, the function is evaluated element wise.
+   * @param x A fraction, BigNumber, or array with fractions
+   * @returns The denominator of x
+   */
+  den(x: number | BigNumber | bigint | Fraction): bigint
+  den(x: MathArray<MathScalarType>): MathArray<bigint>
+  den(x: Matrix<MathScalarType>): Matrix<bigint>
+
   /*************************************************************************
    * Geometry functions
    ************************************************************************/
@@ -4320,7 +4340,9 @@ export const {
   stdTransformDependencies,
   sumTransformDependencies,
   varianceTransformDependencies,
-  printTransformDependencies
+  printTransformDependencies,
+  andTransformDependencies,
+  orTransformDependencies
 }: Record<string, FactoryFunctionMap>
 
 export interface Matrix<T = MathGeneric> {
@@ -5942,6 +5964,30 @@ export interface MathJsChain<TValue> {
   re(this: MathJsChain<BigNumber>): MathJsChain<BigNumber>
   re(this: MathJsChain<MathCollection>): MathJsChain<MathCollection>
 
+  /**
+   * Get the numerator of a fraction. For a fraction a/b, the function
+   * returns a. For matrices, the function is evaluated element wise.
+   */
+  num(
+    this: MathJsChain<number | BigNumber | bigint | Fraction>
+  ): MathJsChain<bigint>
+  num(
+    this: MathJsChain<MathArray<MathScalarType>>
+  ): MathJsChain<MathArray<bigint>>
+  num(this: MathJsChain<Matrix<MathScalarType>>): MathJsChain<Matrix<bigint>>
+
+  /**
+   * Get the denominator of a fraction. For a fraction a/b, the function
+   * returns b. For matrices, the function is evaluated element wise.
+   */
+  den(
+    this: MathJsChain<number | BigNumber | bigint | Fraction>
+  ): MathJsChain<bigint>
+  den(
+    this: MathJsChain<MathArray<MathScalarType>>
+  ): MathJsChain<MathArray<bigint>>
+  den(this: MathJsChain<Matrix<MathScalarType>>): MathJsChain<Matrix<bigint>>
+
   /*************************************************************************
    * Geometry functions
    ************************************************************************/
@@ -7633,6 +7679,10 @@ export const {
   im,
   re,
 
+  // fraction
+  num,
+  den,
+
   // geometry
   distance,
   intersect,