mathjs 13.2.3 → 14.0.0

package/lib/esm/function/relational/smallerEq.js

@@ -7,21 +7,22 @@ import { createMatAlgo12xSfs } from '../../type/matrix/utils/matAlgo12xSfs.js';
 import { createMatrixAlgorithmSuite } from '../../type/matrix/utils/matrixAlgorithmSuite.js';
 import { createCompareUnits } from './compareUnits.js';
 var name = 'smallerEq';
-var dependencies = ['typed', 'config', 'matrix', 'DenseMatrix', 'concat'];
+var dependencies = ['typed', 'config', 'matrix', 'DenseMatrix', 'concat', 'SparseMatrix'];
 export var createSmallerEq = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     config,
     matrix,
     DenseMatrix,
-    concat
+    concat,
+    SparseMatrix
   } = _ref;
   var matAlgo03xDSf = createMatAlgo03xDSf({
     typed
   });
   var matAlgo07xSSf = createMatAlgo07xSSf({
     typed,
-    DenseMatrix
+    SparseMatrix
   });
   var matAlgo12xSfs = createMatAlgo12xSfs({
     typed,

package/lib/esm/function/relational/unequal.js

@@ -4,7 +4,7 @@ import { createMatAlgo07xSSf } from '../../type/matrix/utils/matAlgo07xSSf.js';
 import { createMatAlgo12xSfs } from '../../type/matrix/utils/matAlgo12xSfs.js';
 import { createMatrixAlgorithmSuite } from '../../type/matrix/utils/matrixAlgorithmSuite.js';
 var name = 'unequal';
-var dependencies = ['typed', 'config', 'equalScalar', 'matrix', 'DenseMatrix', 'concat'];
+var dependencies = ['typed', 'config', 'equalScalar', 'matrix', 'DenseMatrix', 'concat', 'SparseMatrix'];
 export var createUnequal = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
@@ -12,14 +12,15 @@ export var createUnequal = /* #__PURE__ */factory(name, dependencies, _ref => {
     equalScalar,
     matrix,
     DenseMatrix,
-    concat
+    concat,
+    SparseMatrix
   } = _ref;
   var matAlgo03xDSf = createMatAlgo03xDSf({
     typed
   });
   var matAlgo07xSSf = createMatAlgo07xSSf({
     typed,
-    DenseMatrix
+    SparseMatrix
   });
   var matAlgo12xSfs = createMatAlgo12xSfs({
     typed,

package/lib/esm/function/utils/isInteger.js

@@ -47,7 +47,7 @@ export var createIsInteger = /* #__PURE__ */factory(name, dependencies, _ref =>
       return true;
     },
     Fraction: function Fraction(x) {
-      return x.d === 1 && isFinite(x.n);
+      return x.d === 1n;
     },
     'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self))
   });

package/lib/esm/function/utils/isNegative.js

@@ -43,7 +43,7 @@ export var createIsNegative = /* #__PURE__ */factory(name, dependencies, _ref =>
     number: x => nearlyEqual(x, 0, config.relTol, config.absTol) ? false : isNegativeNumber(x),
     BigNumber: x => bigNearlyEqual(x, new x.constructor(0), config.relTol, config.absTol) ? false : x.isNeg() && !x.isZero() && !x.isNaN(),
     bigint: x => x < 0n,
-    Fraction: x => x.s < 0,
+    Fraction: x => x.s < 0n,
     // It's enough to decide on the sign
 
     Unit: typed.referToSelf(self => x => typed.find(self, x.valueType())(x.value)),

package/lib/esm/function/utils/isPositive.js

@@ -45,7 +45,7 @@ export var createIsPositive = /* #__PURE__ */factory(name, dependencies, _ref =>
     number: x => nearlyEqual(x, 0, config.relTol, config.absTol) ? false : isPositiveNumber(x),
     BigNumber: x => bigNearlyEqual(x, new x.constructor(0), config.relTol, config.absTol) ? false : !x.isNeg() && !x.isZero() && !x.isNaN(),
     bigint: x => x > 0n,
-    Fraction: x => x.s > 0 && x.n > 0,
+    Fraction: x => x.s > 0n && x.n > 0n,
     Unit: typed.referToSelf(self => x => typed.find(self, x.valueType())(x.value)),
     'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self))
   });

package/lib/esm/type/bignumber/function/bignumber.js

@@ -72,9 +72,9 @@ export var createBignumber = /* #__PURE__ */factory(name, dependencies, _ref =>
       return clone;
     }),
     Fraction: function Fraction(x) {
-      return new BigNumber(x.n).div(x.d).times(x.s);
+      return new BigNumber(String(x.n)).div(String(x.d)).times(String(x.s));
     },
-    null: function _null(x) {
+    null: function _null(_x) {
       return new BigNumber(0);
     },
     'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self))

package/lib/esm/type/fraction/Fraction.js

@@ -16,20 +16,20 @@ export var createFractionClass = /* #__PURE__ */factory(name, dependencies, () =
   /**
    * Get a JSON representation of a Fraction containing type information
    * @returns {Object} Returns a JSON object structured as:
-   *                   `{"mathjs": "Fraction", "n": 3, "d": 8}`
+   *                   `{"mathjs": "Fraction", "n": "3", "d": "8"}`
    */
   Fraction.prototype.toJSON = function () {
     return {
       mathjs: 'Fraction',
-      n: this.s * this.n,
-      d: this.d
+      n: String(this.s * this.n),
+      d: String(this.d)
     };
   };
 
   /**
    * Instantiate a Fraction from a JSON object
    * @param {Object} json  a JSON object structured as:
-   *                       `{"mathjs": "Fraction", "n": 3, "d": 8}`
+   *                       `{"mathjs": "Fraction", "n": "3", "d": "8"}`
    * @return {BigNumber}
    */
   Fraction.fromJSON = function (json) {

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

@@ -57,6 +57,9 @@ export var createFraction = /* #__PURE__ */factory(name, dependencies, _ref => {
     'number, number': function number_number(numerator, denominator) {
       return new Fraction(numerator, denominator);
     },
+    'bigint, bigint': function bigint_bigint(numerator, denominator) {
+      return new Fraction(numerator, denominator);
+    },
     null: function _null(x) {
       return new Fraction(0);
     },

package/lib/esm/type/matrix/utils/matAlgo07xSSf.js

@@ -1,31 +1,30 @@
 import { factory } from '../../../utils/factory.js';
 import { DimensionError } from '../../../error/DimensionError.js';
 var name = 'matAlgo07xSSf';
-var dependencies = ['typed', 'DenseMatrix'];
+var dependencies = ['typed', 'SparseMatrix'];
 export var createMatAlgo07xSSf = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
-    DenseMatrix
+    SparseMatrix
   } = _ref;
   /**
-   * Iterates over SparseMatrix A and SparseMatrix B items (zero and nonzero) and invokes the callback function f(Aij, Bij).
-   * Callback function invoked MxN times.
-   *
-   * C(i,j) = f(Aij, Bij)
-   *
-   * @param {Matrix}   a                 The SparseMatrix instance (A)
-   * @param {Matrix}   b                 The SparseMatrix instance (B)
-   * @param {Function} callback          The f(Aij,Bij) operation to invoke
-   *
-   * @return {Matrix}                    DenseMatrix (C)
-   *
-   * see https://github.com/josdejong/mathjs/pull/346#issuecomment-97620294
-   */
+  * Iterates over SparseMatrix A and SparseMatrix B items (zero and nonzero) and invokes the callback function f(Aij, Bij).
+  * Callback function invoked MxN times.
+  *
+  * C(i,j) = f(Aij, Bij)
+  *
+  * @param {Matrix}   a                 The SparseMatrix instance (A)
+  * @param {Matrix}   b                 The SparseMatrix instance (B)
+  * @param {Function} callback          The f(Aij,Bij) operation to invoke
+  *
+  * @return {Matrix}                    SparseMatrix (C)
+  *
+  * see https://github.com/josdejong/mathjs/pull/346#issuecomment-97620294
+  */
   return function matAlgo07xSSf(a, b, callback) {
     // sparse matrix arrays
     var asize = a._size;
     var adt = a._datatype || a._data === undefined ? a._datatype : a.getDataType();
-    // sparse matrix arrays
     var bsize = b._size;
     var bdt = b._datatype || b._data === undefined ? b._datatype : b.getDataType();
 
@@ -33,8 +32,6 @@ export var createMatAlgo07xSSf = /* #__PURE__ */factory(name, dependencies, _ref
     if (asize.length !== bsize.length) {
       throw new DimensionError(asize.length, bsize.length);
     }
-
-    // check rows & columns
     if (asize[0] !== bsize[0] || asize[1] !== bsize[1]) {
       throw new RangeError('Dimension mismatch. Matrix A (' + asize + ') must match Matrix B (' + bsize + ')');
     }
@@ -45,59 +42,58 @@ export var createMatAlgo07xSSf = /* #__PURE__ */factory(name, dependencies, _ref
 
     // datatype
     var dt;
-    // zero value
     var zero = 0;
-    // callback signature to use
     var cf = callback;
 
     // process data types
     if (typeof adt === 'string' && adt === bdt && adt !== 'mixed') {
-      // datatype
       dt = adt;
-      // convert 0 to the same datatype
       zero = typed.convert(0, dt);
-      // callback
       cf = typed.find(callback, [dt, dt]);
     }
 
-    // vars
-    var i, j;
-
-    // result arrays
-    var cdata = [];
-    // initialize c
-    for (i = 0; i < rows; i++) {
-      cdata[i] = [];
-    }
+    // result arrays for sparse format
+    var cvalues = [];
+    var cindex = [];
+    var cptr = new Array(columns + 1).fill(0); // Start with column pointer array
 
     // workspaces
     var xa = [];
     var xb = [];
-    // marks indicating we have a value in x for a given column
     var wa = [];
     var wb = [];
 
     // loop columns
-    for (j = 0; j < columns; j++) {
-      // columns mark
+    for (var j = 0; j < columns; j++) {
       var mark = j + 1;
-      // scatter the values of A(:,j) into workspace
+      var nonZeroCount = 0;
       _scatter(a, j, wa, xa, mark);
-      // scatter the values of B(:,j) into workspace
       _scatter(b, j, wb, xb, mark);
+
       // loop rows
-      for (i = 0; i < rows; i++) {
-        // matrix values @ i,j
+      for (var i = 0; i < rows; i++) {
         var va = wa[i] === mark ? xa[i] : zero;
         var vb = wb[i] === mark ? xb[i] : zero;
+
         // invoke callback
-        cdata[i][j] = cf(va, vb);
+        var cij = cf(va, vb);
+        // Store all non zero and true values
+        if (cij !== 0 && cij !== false) {
+          cindex.push(i); // row index
+          cvalues.push(cij); // computed value
+          nonZeroCount++;
+        }
       }
+
+      // Update column pointer with cumulative count of non-zero values
+      cptr[j + 1] = cptr[j] + nonZeroCount;
     }
 
-    // return dense matrix
-    return new DenseMatrix({
-      data: cdata,
+    // Return the result as a sparse matrix
+    return new SparseMatrix({
+      values: cvalues,
+      index: cindex,
+      ptr: cptr,
       size: [rows, columns],
       datatype: adt === a._datatype && bdt === b._datatype ? dt : undefined
     });

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

@@ -3533,7 +3533,7 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, _ref =>
    */
   Unit.typeConverters = {
     BigNumber: function BigNumber(x) {
-      if (x !== null && x !== void 0 && x.isFraction) return new _BigNumber(x.n).div(x.d).times(x.s);
+      if (x !== null && x !== void 0 && x.isFraction) return new _BigNumber(String(x.n)).div(String(x.d)).times(String(x.s));
       return new _BigNumber(x + ''); // stringify to prevent constructor error
     },
     Fraction: function Fraction(x) {

package/lib/esm/utils/string.js

@@ -71,7 +71,7 @@ function _format(value, options) {
   if (looksLikeFraction(value)) {
     if (!options || options.fraction !== 'decimal') {
       // output as ratio, like '1/3'
-      return value.s * value.n + '/' + value.d;
+      return "".concat(value.s * value.n, "/").concat(value.d);
     } else {
       // output as decimal, like '0.(3)'
       return value.toString();
@@ -173,7 +173,7 @@ function formatArray(array, options) {
  * @return {boolean}
  */
 function looksLikeFraction(value) {
-  return value && typeof value === 'object' && typeof value.s === 'number' && typeof value.n === 'number' && typeof value.d === 'number' || false;
+  return value && typeof value === 'object' && typeof value.s === 'bigint' && typeof value.n === 'bigint' && typeof value.d === 'bigint' || false;
 }
 
 /**

package/lib/esm/version.js

@@ -1,3 +1,3 @@
-export var version = '13.2.3';
+export var version = '14.0.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": "13.2.3",
+  "version": "14.0.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",
@@ -29,7 +29,7 @@
     "complex.js": "^2.2.5",
     "decimal.js": "^10.4.3",
     "escape-latex": "^1.2.0",
-    "fraction.js": "^4.3.7",
+    "fraction.js": "^5.2.1",
     "javascript-natural-sort": "^0.7.1",
     "seedrandom": "^3.0.5",
     "tiny-emitter": "^2.1.0",

package/types/index.d.ts

@@ -10,11 +10,11 @@ export type NoLiteralType<T> = T extends number
       ? boolean
       : T
 
-// TODO: introduce generics for MathCollection, MathMatrix, and MathArray
 export type MathNumericType = number | BigNumber | bigint | Fraction | Complex
 export type MathScalarType = MathNumericType | Unit
-export type MathArray = MathNumericType[] | MathNumericType[][] // TODO: MathArray can also contain Unit
-export type MathCollection = MathArray | Matrix
+export type MathGeneric<T extends MathScalarType = MathNumericType> = T
+export type MathArray<T = MathGeneric> = T[] | Array<MathArray<T>>
+export type MathCollection<T = MathGeneric> = MathArray<T> | Matrix<T>
 export type MathType = MathScalarType | MathCollection
 export type MathExpression = string | string[] | MathCollection
 
@@ -719,6 +719,7 @@ export interface MathJsInstance extends MathJsFactory {
    * fraction
    * @returns Returns a fraction
    */
+  fraction(numerator: bigint, denominator: bigint): Fraction
   fraction(numerator: number, denominator: number): Fraction
 
   /**
@@ -751,6 +752,11 @@ export interface MathJsInstance extends MathJsFactory {
     format?: 'sparse' | 'dense',
     dataType?: string
   ): Matrix
+  matrix<T extends MathScalarType>(
+    data: MathCollection<T>,
+    format?: 'sparse' | 'dense',
+    dataType?: string
+  ): Matrix<T>
 
   /**
    * Create a number or convert a string, boolean, or unit to a number.
@@ -1147,6 +1153,14 @@ export interface MathJsInstance extends MathJsFactory {
     n?: number | BigNumber
   ): NoLiteralType<T>
   ceil<U extends MathCollection>(x: MathNumericType, n: U): U
+  ceil<U extends MathCollection<Unit>>(x: U, unit: Unit): U
+  ceil(x: Unit, unit: Unit): Unit
+  ceil(x: Unit, n: number | BigNumber, unit: Unit): Unit
+  ceil<U extends MathCollection<Unit>>(
+    x: U,
+    n: number | BigNumber,
+    unit: Unit
+  ): U
 
   /**
    * Round a value towards zero. For matrices, the function is evaluated
@@ -1160,6 +1174,14 @@ export interface MathJsInstance extends MathJsFactory {
     n?: number | BigNumber
   ): NoLiteralType<T>
   fix<U extends MathCollection>(x: MathNumericType, n: U): U
+  fix<U extends MathCollection<Unit>>(x: U, unit: Unit): U
+  fix(x: Unit, unit: Unit): Unit
+  fix(x: Unit, n: number | BigNumber, unit: Unit): Unit
+  fix<U extends MathCollection<Unit>>(
+    x: U,
+    n: number | BigNumber,
+    unit: Unit
+  ): U
 
   /**
    * Round a value towards minus infinity. For matrices, the function is
@@ -1173,6 +1195,14 @@ export interface MathJsInstance extends MathJsFactory {
     n?: number | BigNumber
   ): NoLiteralType<T>
   floor<U extends MathCollection>(x: MathNumericType, n: U): U
+  floor<U extends MathCollection<Unit>>(x: U, unit: Unit): U
+  floor(x: Unit, unit: Unit): Unit
+  floor(x: Unit, n: number | BigNumber, unit: Unit): Unit
+  floor<U extends MathCollection<Unit>>(
+    x: U,
+    n: number | BigNumber,
+    unit: Unit
+  ): U
 
   /**
    * Round a value towards the nearest integer. For matrices, the function
@@ -1186,10 +1216,14 @@ export interface MathJsInstance extends MathJsFactory {
     n?: number | BigNumber
   ): NoLiteralType<T>
   round<U extends MathCollection>(x: MathNumericType, n: U): U
-  round<U extends MathCollection>(x: U, unit: Unit): U
+  round<U extends MathCollection<Unit>>(x: U, unit: Unit): U
   round(x: Unit, unit: Unit): Unit
   round(x: Unit, n: number | BigNumber, unit: Unit): Unit
-  round<U extends MathCollection>(x: U, n: number | BigNumber, unit: Unit): U
+  round<U extends MathCollection<Unit>>(
+    x: U,
+    n: number | BigNumber,
+    unit: Unit
+  ): U
 
   // End of group of rounding functions
 
@@ -1359,9 +1393,10 @@ export interface MathJsInstance extends MathJsFactory {
   multiply<T extends Matrix>(x: T, y: MathType): Matrix
   multiply<T extends Matrix>(x: MathType, y: T): Matrix
 
-  multiply<T extends MathNumericType[]>(x: T, y: T[]): T
-  multiply<T extends MathNumericType[]>(x: T[], y: T): T
-  multiply<T extends MathArray>(x: T, y: T): T
+  multiply<T extends MathArray>(x: T, y: T[]): T
+  multiply<T extends MathArray>(x: T[], y: T): T
+  multiply<T extends MathArray>(x: T[], y: T[]): T
+  multiply<T extends MathArray>(x: T, y: T): MathScalarType
   multiply(x: Unit, y: Unit): Unit
   multiply(x: number, y: number): number
   multiply(x: MathType, y: MathType): MathType
@@ -3964,7 +3999,7 @@ export const {
   varianceTransformDependencies
 }: Record<string, FactoryFunctionMap>
 
-export interface Matrix {
+export interface Matrix<T = MathGeneric> {
   type: string
   storage(): string
   datatype(): string
@@ -3981,7 +4016,7 @@ export interface Matrix {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   set(index: number[], value: any, defaultValue?: number | string): Matrix
   resize(size: MathCollection, defaultValue?: number | string): Matrix
-  clone(): Matrix
+  clone(): Matrix<T>
   size(): number[]
   map(
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -3993,8 +4028,8 @@ export interface Matrix {
     callback: (a: any, b: number[], c: Matrix) => void,
     skipZeros?: boolean
   ): void
-  toArray(): MathArray
-  valueOf(): MathArray
+  toArray(): MathArray<T>
+  valueOf(): MathArray<T>
   format(
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     options?: FormatOptions | number | BigNumber | ((value: any) => string)
@@ -4004,7 +4039,7 @@ export interface Matrix {
   toJSON(): any
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   diagonal(k?: number | BigNumber): any[]
-  swapRows(i: number, j: number): Matrix
+  swapRows(i: number, j: number): Matrix<T>
 }
 
 export interface MatrixCtor {
@@ -4015,9 +4050,9 @@ export interface MatrixCtor {
 export interface BigNumber extends Decimal {}
 
 export interface Fraction {
-  s: number
-  n: number
-  d: number
+  s: bigint
+  n: bigint
+  d: bigint
 }
 
 export interface Complex {
@@ -4994,6 +5029,25 @@ export interface MathJsChain<TValue> {
     this: MathJsChain<T>,
     n?: number | BigNumber | MathCollection
   ): MathJsChain<T>
+  ceil<U extends MathCollection>(
+    this: MathJsChain<MathNumericType | U>,
+    n: U
+  ): MathJsChain<U>
+  ceil(this: MathJsChain<Unit>, unit: Unit): MathJsChain<Unit>
+  ceil<U extends MathCollection<Unit>>(
+    this: MathJsChain<U>,
+    unit: Unit
+  ): MathJsChain<U>
+  ceil(
+    this: MathJsChain<Unit>,
+    n: number | BigNumber,
+    unit: Unit
+  ): MathJsChain<Unit>
+  ceil<U extends MathCollection<Unit>>(
+    this: MathJsChain<U>,
+    n: number | BigNumber,
+    unit: Unit
+  ): MathJsChain<U>
 
   /**
    * Round a value towards zero. For matrices, the function is evaluated
@@ -5004,6 +5058,25 @@ export interface MathJsChain<TValue> {
     this: MathJsChain<T>,
     n?: number | BigNumber | MathCollection
   ): MathJsChain<T>
+  fix<U extends MathCollection>(
+    this: MathJsChain<MathNumericType | U>,
+    n: U
+  ): MathJsChain<U>
+  fix(this: MathJsChain<Unit>, unit: Unit): MathJsChain<Unit>
+  fix<U extends MathCollection<Unit>>(
+    this: MathJsChain<U>,
+    unit: Unit
+  ): MathJsChain<U>
+  fix(
+    this: MathJsChain<Unit>,
+    n: number | BigNumber,
+    unit: Unit
+  ): MathJsChain<Unit>
+  fix<U extends MathCollection<Unit>>(
+    this: MathJsChain<U>,
+    n: number | BigNumber,
+    unit: Unit
+  ): MathJsChain<U>
 
   /**
    * Round a value towards minus infinity. For matrices, the function is
@@ -5014,6 +5087,25 @@ export interface MathJsChain<TValue> {
     this: MathJsChain<T>,
     n?: number | BigNumber | MathCollection
   ): MathJsChain<T>
+  floor<U extends MathCollection>(
+    this: MathJsChain<MathNumericType | U>,
+    n: U
+  ): MathJsChain<U>
+  floor(this: MathJsChain<Unit>, unit: Unit): MathJsChain<Unit>
+  floor<U extends MathCollection<Unit>>(
+    this: MathJsChain<U>,
+    unit: Unit
+  ): MathJsChain<U>
+  floor(
+    this: MathJsChain<Unit>,
+    n: number | BigNumber,
+    unit: Unit
+  ): MathJsChain<Unit>
+  floor<U extends MathCollection<Unit>>(
+    this: MathJsChain<U>,
+    n: number | BigNumber,
+    unit: Unit
+  ): MathJsChain<U>
 
   /**
    * Round a value towards the nearest integer. For matrices, the function
@@ -5029,7 +5121,7 @@ export interface MathJsChain<TValue> {
     n: U
   ): MathJsChain<U>
   round(this: MathJsChain<Unit>, unit: Unit): MathJsChain<Unit>
-  round<U extends MathCollection>(
+  round<U extends MathCollection<Unit>>(
     this: MathJsChain<U>,
     unit: Unit
   ): MathJsChain<U>
@@ -5038,7 +5130,7 @@ export interface MathJsChain<TValue> {
     n: number | BigNumber,
     unit: Unit
   ): MathJsChain<Unit>
-  round<U extends MathCollection>(
+  round<U extends MathCollection<Unit>>(
     this: MathJsChain<U>,
     n: number | BigNumber,
     unit: Unit