Math.js

Element-wise operations between two SparseMatrix objects can vary in complexity and output type. The choice of algorithm affects whether the result remains sparse or becomes dense.

Available Algorithms

Algorithm Details

Algorithm 04 (SidSid)

• Logic: Cij = x(Aij, Bij) if Aij != 0 && Bij != 0. If only one is non-zero, the result is that non-zero value.
• Complexity: Invokes x() NZ times (number of overlapping nonzero items).

Algorithm 05 (SfSf)

• Logic: Cij = x(Aij, Bij) if Aij != 0 || Bij != 0, else 0.
• Complexity: Invokes x() for all nonzero values in A, B, and their intersection.

Algorithm 06 (S0S0)

• Logic: Cij = x(Aij, Bij) if Aij != 0 && Bij != 0, else 0.
• Complexity: Invokes x() NZ times (overlapping nonzero items).

Algorithm 07 (SSf)

• Logic: Cij = x(Aij, Bij) for all indices.
• Complexity: Invokes x() M*N times.

Algorithm 08 (S0Sid)

• Logic: Cij = x(Aij, Bij) if Aij != 0 && Bij != 0. If Aij != 0 and Bij == 0, Cij = Aij.
• Complexity: Invokes x() NZ times (overlapping nonzero items).

Algorithm 09 (S0Sf)

• Logic: Cij = x(Aij, Bij) if Aij != 0, else 0.
• Complexity: Invokes x() NZA times (nonzero items in A).

When performing element-wise operations between a DenseMatrix and a SparseMatrix, the implementation follows one of several algorithms depending on the desired output type and efficiency requirements. These algorithms are identified by mnemonics in the source code using the format numberxmnemonic (e.g., 01xDSid).

Available Algorithms

Algorithm Details

Algorithm 01 (DSid)

• Logic: Cij = x(Dij, Sij) if Sij != 0, else Cij = Dij.
• Complexity: Invokes x() NZ times (number of nonzero items in SparseMatrix).

Algorithm 02 (DS0)

• Logic: Cij = x(Dij, Sij) if Sij != 0, else Cij = 0.
• Complexity: Invokes x() NZ times.

Algorithm 03 (DSf)

• Logic: Cij = x(Dij, Sij) if Sij != 0, else Cij = x(Dij, 0).
• Complexity: Invokes x() M*N times (total elements).

When importing functions from separate files, they may not have access to the specific math.js instance they are being imported into. Factory functions solve this by allowing you to inject dependencies (like multiply or unaryMinus) at creation time.

This pattern ensures your functions work correctly across different math.js configurations (e.g., when switching between standard numbers and BigNumber or Decimal).

Syntax

factory(name: string, dependencies: string[], create: function, meta?: Object)

• name: The name of the created function.
• dependencies: An array of names of the functions/values to inject.
• create: A function that receives an object containing the dependencies as its first argument.
• meta: An optional object for configuration:
  • isClass: If true, the function is treated as a class (not exposed in the expression parser).
  • lazy: If true (default), the function is only constructed when used. Set lazy: false to force immediate creation.
  • isTransformFunction: If true, it is imported only in the internal mathWithTransform namespace for the parser.
  • recreateOnConfigChange: If true, the factory is re-run when math.js configuration changes (useful for constants like pi).
  • formerly: A string providing a deprecated synonym for the function name.

import { factory, create, all } from 'mathjs'

// Define the factory
const name = 'negativeSquare'
const dependencies = ['multiply', 'unaryMinus']
const createNegativeSquare = factory(name, dependencies, function ({ multiply, unaryMinus }) {
    return function negativeSquare (x) {
      return unaryMinus(multiply(x, x))
    }
  })

// Import the factory into a mathjs instance
const math = create(all)
math.import(createNegativeSquare)

console.log(math.negativeSquare(4)) // -16
console.log(math.evaluate('negativeSquare(5)')) // -25

Mathjs is written in JavaScript, but provides TypeScript definitions for its core patterns. The library operates through three primary interfaces:

1. MathJsInstance: The core interface returned by the create function. It contains all mathjs functions and constants as standard methods.
2. MathJsChain: An interface returned by the chain function. It allows for method chaining (e.g., chain(2).add(3).done()). In this interface, methods are defined with the chain instance this as the first argument.
3. Static Exports: The library also provides a static instance where functions can be imported directly (e.g., import { add } from 'mathjs').

Additionally, the library exports collections of factory functions. You can create a custom instance by passing dependencies to create, such as create(addDependencies) or create(all) to import everything.

// Using the core instance
import { create, all } from 'mathjs';
const math = create(all);
const result = math.add(2, 3);

// Using the chain interface
const chainedResult = math.chain(2).add(3).done();

// Using static imports
import { add } from 'mathjs';
const staticResult = add(2, 3);