mathjs 10.5.3 → 10.6.2

package/types/index.ts

@@ -8,6 +8,27 @@ import {
   divideDependencies,
   formatDependencies,
   MathNode,
+  MathJsChain,
+  BigNumber,
+  MathCollection,
+  Complex,
+  Unit,
+  Fraction,
+  MathArray,
+  Index,
+  Matrix,
+  EvalFunction,
+  LUDecomposition,
+  QRDecomposition,
+  SLUDecomposition,
+  MathType,
+  MathNumericType,
+  ConstantNode,
+  OperatorNode,
+  OperatorNodeFn,
+  OperatorNodeOp,
+  SymbolNode,
+  ParenthesisNode,
 } from 'mathjs'
 import * as assert from 'assert'
 import { expectTypeOf } from 'expect-type'
@@ -65,6 +86,8 @@ Basic usage examples
   math.chain(m2by3).variance(0, 'biased')
   math.chain(m2by3).variance(1, 'uncorrected').variance('unbiased')
 
+  math.variance(math.variance(m2by3, 'uncorrected'))
+
   // expressions
   math.evaluate('1.2 * (2 + 4.5)')
 
@@ -151,14 +174,598 @@ Chaining examples
   )
 
   const r = math.chain(-0.483).round([0, 1, 2]).floor().add(0.52).fix(1).done()
+
   assert.deepStrictEqual(r, [0.5, -0.4, -0.4])
 
-  expectTypeOf(math.chain('x + y').parse().resolve({ x: 1 }).done())
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    .toMatchTypeOf<any>()
-  expectTypeOf(math.chain('x + y').parse().resolve().done())
+  expectTypeOf(
+    math.chain('x + y').parse().resolve({ x: 1 }).done()
+  ).toMatchTypeOf<MathNode>()
+  expectTypeOf(
+    math.chain('x + y').parse().resolve().done()
+  ).toMatchTypeOf<MathNode>()
+
+  // bignum
+  expectTypeOf(math.chain(math.bignumber(12))).toMatchTypeOf<
+    MathJsChain<BigNumber>
+  >()
+  expectTypeOf(math.chain(12).bignumber()).toMatchTypeOf<
+    MathJsChain<BigNumber>
+  >()
+  expectTypeOf(math.chain([12, 13, 14]).bignumber()).toMatchTypeOf<
+    MathJsChain<MathCollection>
+  >()
+
+  // chain
+  expectTypeOf(math.chain(12).bignumber().clone()).toMatchTypeOf<
+    MathJsChain<BigNumber>
+  >()
+
+  // boolean
+  expectTypeOf(math.chain(math.boolean(true))).toMatchTypeOf<
+    MathJsChain<boolean>
+  >()
+  expectTypeOf(math.chain(true).boolean()).toMatchTypeOf<MathJsChain<boolean>>()
+  expectTypeOf(math.chain([12, 13, 14]).boolean()).toMatchTypeOf<
+    MathJsChain<MathCollection>
+  >()
+
+  // complex
+  expectTypeOf(math.chain(math.complex('123'))).toMatchTypeOf<
+    MathJsChain<Complex>
+  >()
+  expectTypeOf(math.chain('123').complex()).toMatchTypeOf<
+    MathJsChain<Complex>
+  >()
+  expectTypeOf(math.chain('123').complex(1)).toMatchTypeOf<
+    MathJsChain<Complex>
+  >()
+  expectTypeOf(math.chain([12, 13, 14]).complex()).toMatchTypeOf<
+    MathJsChain<MathCollection>
+  >()
+
+  // createUnit
+  expectTypeOf(math.chain(math.createUnit('furlong'))).toMatchTypeOf<
+    MathJsChain<Unit>
+  >()
+  expectTypeOf(
+    math.chain(
+      math.createUnit({
+        fresnel: '1234',
+      })
+    )
+  ).toMatchTypeOf<MathJsChain<Unit>>()
+
+  // fraction
+  expectTypeOf(math.chain(math.fraction('123'))).toMatchTypeOf<
+    MathJsChain<Fraction>
+  >()
+  expectTypeOf(math.chain('123').fraction()).toMatchTypeOf<
+    MathJsChain<Fraction>
+  >()
+  expectTypeOf(math.chain('123').fraction(2)).toMatchTypeOf<
+    MathJsChain<Fraction>
+  >()
+  expectTypeOf(math.chain([12, 13, 14]).fraction()).toMatchTypeOf<
+    MathJsChain<MathCollection>
+  >()
+  expectTypeOf(math.chain([12, 13, 14]).fraction()).toMatchTypeOf<
+    MathJsChain<MathCollection>
+  >()
+
+  // index
+  expectTypeOf(math.chain([12, 13, 14]).index()).toMatchTypeOf<
+    MathJsChain<Index>
+  >()
+
+  // matrix
+  expectTypeOf(math.chain([12, 13, 14, 15]).matrix()).toMatchTypeOf<
+    MathJsChain<Matrix>
+  >()
+
+  // number
+  expectTypeOf(math.chain('12').number()).toMatchTypeOf<MathJsChain<number>>()
+  expectTypeOf(math.chain([12, 13, 14]).number()).toMatchTypeOf<
+    MathJsChain<MathCollection>
+  >()
+
+  // sparse
+  expectTypeOf(math.chain([12, 13, 14, 15]).sparse()).toMatchTypeOf<
+    MathJsChain<Matrix>
+  >()
+
+  // split unit
+  expectTypeOf(math.chain(math.unit('furlong')).splitUnit([])).toMatchTypeOf<
+    MathJsChain<Unit[]>
+  >()
+
+  // string
+  expectTypeOf(math.chain('test').string()).toMatchTypeOf<MathJsChain<string>>()
+  expectTypeOf(math.chain([1, 2, 3]).string()).toMatchTypeOf<
+    MathJsChain<MathCollection>
+  >()
+
+  // unit
+  expectTypeOf(math.chain(12).unit()).toMatchTypeOf<MathJsChain<Unit>>()
+  expectTypeOf(math.chain([1, 2, 3]).unit()).toMatchTypeOf<
+    MathJsChain<Unit[]>
+  >()
+
+  // compile
+  expectTypeOf(math.chain('a + b').compile()).toMatchTypeOf<
+    MathJsChain<EvalFunction>
+  >()
+
+  // evaluate
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  expectTypeOf(math.chain('1 + 1').evaluate()).toMatchTypeOf<MathJsChain<any>>()
+  expectTypeOf(math.chain(['1 + 1', '2 + 2']).evaluate()).toMatchTypeOf<
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    .toMatchTypeOf<any>()
+    MathJsChain<any[]>
+  >()
+
+  // parse
+  expectTypeOf(math.chain('1 + 1').parse()).toMatchTypeOf<
+    MathJsChain<MathNode>
+  >()
+  expectTypeOf(math.chain(['1 + 1', '2 + 2']).parse()).toMatchTypeOf<
+    MathJsChain<MathNode[]>
+  >()
+
+  // resolve
+  expectTypeOf(math.chain(math.parse('1 + 1')).resolve({})).toMatchTypeOf<
+    MathJsChain<MathNode>
+  >()
+  expectTypeOf(
+    math.chain([math.parse('1 + 1'), math.parse('1 + 1')]).resolve({})
+  ).toMatchTypeOf<MathJsChain<MathNode[]>>()
+
+  // derivative
+  expectTypeOf(math.chain(math.parse('x^2')).derivative('x')).toMatchTypeOf<
+    MathJsChain<MathNode>
+  >()
+
+  // lsolve
+  expectTypeOf(
+    math
+      .chain([
+        [1, 2],
+        [3, 4],
+      ])
+      .lsolve([1, 2])
+  ).toMatchTypeOf<MathJsChain<MathArray>>()
+  expectTypeOf(
+    math
+      .chain(
+        math.matrix([
+          [1, 2],
+          [3, 4],
+        ])
+      )
+      .lsolve([1, 2])
+  ).toMatchTypeOf<MathJsChain<Matrix>>()
+
+  // lup
+  expectTypeOf(
+    math
+      .chain([
+        [1, 2],
+        [3, 4],
+      ])
+      .lup()
+  ).toMatchTypeOf<MathJsChain<LUDecomposition>>()
+  expectTypeOf(
+    math
+      .chain(
+        math.matrix([
+          [1, 2],
+          [3, 4],
+        ])
+      )
+      .lup()
+  ).toMatchTypeOf<MathJsChain<LUDecomposition>>()
+
+  // lusolve
+  expectTypeOf(
+    math
+      .chain(
+        math.matrix([
+          [1, 2],
+          [3, 4],
+        ])
+      )
+      .lusolve(math.matrix([1, 2]))
+  ).toMatchTypeOf<MathJsChain<Matrix>>()
+
+  expectTypeOf(
+    math
+      .chain(
+        math.matrix([
+          [1, 2],
+          [3, 4],
+        ])
+      )
+      .lusolve([1, 2])
+  ).toMatchTypeOf<MathJsChain<Matrix>>()
+
+  expectTypeOf(
+    math
+      .chain([
+        [1, 2],
+        [3, 4],
+      ])
+      .lusolve(math.matrix([1, 2]))
+  ).toMatchTypeOf<MathJsChain<MathArray>>()
+
+  expectTypeOf(
+    math
+      .chain([
+        [1, 2],
+        [3, 4],
+      ])
+      .lusolve([1, 2])
+  ).toMatchTypeOf<MathJsChain<MathArray>>()
+
+  // qr
+  expectTypeOf(
+    math
+      .chain([
+        [1, 2],
+        [3, 4],
+      ])
+      .qr()
+  ).toMatchTypeOf<MathJsChain<QRDecomposition>>()
+  expectTypeOf(
+    math
+      .chain(
+        math.matrix([
+          [1, 2],
+          [3, 4],
+        ])
+      )
+      .qr()
+  ).toMatchTypeOf<MathJsChain<QRDecomposition>>()
+
+  // rationalize
+  expectTypeOf(math.chain('1.23').rationalize()).toMatchTypeOf<
+    MathJsChain<MathNode>
+  >()
+  expectTypeOf(math.chain(math.parse('1.23')).rationalize()).toMatchTypeOf<
+    MathJsChain<MathNode>
+  >()
+
+  // simplify
+  expectTypeOf(math.chain('a + a + b').simplify()).toMatchTypeOf<
+    MathJsChain<MathNode>
+  >()
+  expectTypeOf(math.chain(math.parse('a + a + b')).simplify()).toMatchTypeOf<
+    MathJsChain<MathNode>
+  >()
+
+  // slu
+  expectTypeOf(
+    math
+      .chain(
+        math.sparse([
+          [1, 2],
+          [3, 4],
+        ])
+      )
+      .slu(2, 0.5)
+  ).toMatchTypeOf<MathJsChain<SLUDecomposition>>()
+
+  // usolve
+  expectTypeOf(
+    math
+      .chain([
+        [1, 2],
+        [3, 4],
+      ])
+      .usolve([1, 2])
+  ).toMatchTypeOf<MathJsChain<MathArray>>()
+  expectTypeOf(
+    math
+      .chain(
+        math.matrix([
+          [1, 2],
+          [3, 4],
+        ])
+      )
+      .usolve([1, 2])
+  ).toMatchTypeOf<MathJsChain<Matrix>>()
+
+  // abs
+  expectTypeOf(math.chain(1).abs()).toMatchTypeOf<MathJsChain<number>>()
+  expectTypeOf(math.chain(math.bignumber(1)).abs()).toMatchTypeOf<
+    MathJsChain<BigNumber>
+  >()
+  expectTypeOf(math.chain(math.fraction(1, 2)).abs()).toMatchTypeOf<
+    MathJsChain<Fraction>
+  >()
+  expectTypeOf(math.chain(math.complex(1, 2)).abs()).toMatchTypeOf<
+    MathJsChain<Complex>
+  >()
+  expectTypeOf(math.chain([1, 2]).abs()).toMatchTypeOf<MathJsChain<MathArray>>()
+  expectTypeOf(
+    math
+      .chain(
+        math.matrix([
+          [1, 2],
+          [3, 4],
+        ])
+      )
+      .abs()
+  ).toMatchTypeOf<MathJsChain<Matrix>>()
+  expectTypeOf(math.chain(math.unit('furlong')).abs()).toMatchTypeOf<
+    MathJsChain<Unit>
+  >()
+
+  // add
+  expectTypeOf(math.chain(1).add(2)).toMatchTypeOf<MathJsChain<MathType>>()
+  expectTypeOf(math.chain([1]).add(2)).toMatchTypeOf<MathJsChain<MathType>>()
+  expectTypeOf(
+    math.chain(
+      math.matrix([
+        [1, 2],
+        [3, 4],
+      ])
+    )
+  ).toMatchTypeOf<MathJsChain<Matrix>>()
+
+  // apply
+  expectTypeOf(math.chain([1, 2, 3]).apply(0, () => 1)).toMatchTypeOf<
+    MathJsChain<number[]>
+  >()
+
+  // cbrt
+  expectTypeOf(math.chain(1).cbrt()).toMatchTypeOf<MathJsChain<number>>()
+  expectTypeOf(math.chain(math.bignumber(1)).cbrt()).toMatchTypeOf<
+    MathJsChain<BigNumber>
+  >()
+  expectTypeOf(math.chain(math.complex(1, 2)).cbrt()).toMatchTypeOf<
+    MathJsChain<Complex>
+  >()
+  expectTypeOf(math.chain([1, 2]).cbrt()).toMatchTypeOf<
+    MathJsChain<MathArray>
+  >()
+  expectTypeOf(
+    math
+      .chain(
+        math.matrix([
+          [1, 2],
+          [3, 4],
+        ])
+      )
+      .cbrt()
+  ).toMatchTypeOf<MathJsChain<Matrix>>()
+
+  // cbrt
+  expectTypeOf(math.chain(1).ceil()).toMatchTypeOf<
+    MathJsChain<MathNumericType>
+  >()
+  expectTypeOf(math.chain([1]).ceil()).toMatchTypeOf<
+    MathJsChain<MathCollection>
+  >()
+
+  // fix
+  expectTypeOf(math.chain(1).fix()).toMatchTypeOf<
+    MathJsChain<MathNumericType>
+  >()
+  expectTypeOf(math.chain([1]).fix()).toMatchTypeOf<
+    MathJsChain<MathCollection>
+  >()
+
+  // floor
+  expectTypeOf(math.chain(1).floor()).toMatchTypeOf<
+    MathJsChain<MathNumericType>
+  >()
+  expectTypeOf(math.chain([1]).floor()).toMatchTypeOf<
+    MathJsChain<MathCollection>
+  >()
+
+  // round
+  expectTypeOf(math.chain(1).round()).toMatchTypeOf<
+    MathJsChain<MathNumericType>
+  >()
+  expectTypeOf(math.chain([1]).round()).toMatchTypeOf<
+    MathJsChain<MathCollection>
+  >()
+
+  // cube
+  expectTypeOf(math.chain(1).cube()).toMatchTypeOf<MathJsChain<number>>()
+  expectTypeOf(math.chain(math.bignumber(1)).cube()).toMatchTypeOf<
+    MathJsChain<BigNumber>
+  >()
+  expectTypeOf(math.chain(math.fraction(1, 2)).cube()).toMatchTypeOf<
+    MathJsChain<Fraction>
+  >()
+  expectTypeOf(math.chain(math.complex(1, 2)).cube()).toMatchTypeOf<
+    MathJsChain<Complex>
+  >()
+  expectTypeOf(math.chain([1, 2]).cube()).toMatchTypeOf<
+    MathJsChain<MathArray>
+  >()
+  expectTypeOf(
+    math
+      .chain(
+        math.matrix([
+          [1, 2],
+          [3, 4],
+        ])
+      )
+      .cube()
+  ).toMatchTypeOf<MathJsChain<Matrix>>()
+  expectTypeOf(math.chain(math.unit('furlong')).cube()).toMatchTypeOf<
+    MathJsChain<Unit>
+  >()
+
+  // divide
+  expectTypeOf(
+    math.chain(math.unit('furlong')).divide(math.unit('femtosecond'))
+  ).toMatchTypeOf<MathJsChain<number | Unit>>()
+  expectTypeOf(math.chain(math.unit('furlong')).divide(6)).toMatchTypeOf<
+    MathJsChain<Unit>
+  >()
+  expectTypeOf(math.chain(2).divide(6)).toMatchTypeOf<MathJsChain<number>>()
+  expectTypeOf(math.chain([1, 2, 3]).divide(6)).toMatchTypeOf<
+    MathJsChain<MathType>
+  >()
+
+  // dotDivide
+  expectTypeOf(math.chain(1).dotDivide(2)).toMatchTypeOf<
+    MathJsChain<MathType>
+  >()
+  expectTypeOf(
+    math
+      .chain(
+        math.matrix([
+          [1, 2],
+          [3, 4],
+        ])
+      )
+      .dotDivide(2)
+  ).toMatchTypeOf<MathJsChain<MathType>>()
+
+  // dotMultiply
+  expectTypeOf(math.chain(1).dotMultiply(2)).toMatchTypeOf<
+    MathJsChain<MathType>
+  >()
+  expectTypeOf(
+    math
+      .chain(
+        math.matrix([
+          [1, 2],
+          [3, 4],
+        ])
+      )
+      .dotMultiply(2)
+  ).toMatchTypeOf<MathJsChain<MathType>>()
+
+  // dotPow
+  expectTypeOf(math.chain(1).dotPow(2)).toMatchTypeOf<MathJsChain<MathType>>()
+  expectTypeOf(
+    math
+      .chain(
+        math.matrix([
+          [1, 2],
+          [3, 4],
+        ])
+      )
+      .dotPow(2)
+  ).toMatchTypeOf<MathJsChain<MathType>>()
+
+  // exp
+  expectTypeOf(math.chain(1).exp()).toMatchTypeOf<MathJsChain<MathType>>()
+  expectTypeOf(math.chain([1, 2]).exp()).toMatchTypeOf<MathJsChain<MathArray>>()
+  expectTypeOf(
+    math
+      .chain(
+        math.matrix([
+          [1, 2],
+          [3, 4],
+        ])
+      )
+      .exp()
+  ).toMatchTypeOf<MathJsChain<Matrix>>()
+
+  // expm1
+  expectTypeOf(math.chain(1).expm1()).toMatchTypeOf<MathJsChain<MathType>>()
+  expectTypeOf(math.chain([1, 2]).expm1()).toMatchTypeOf<
+    MathJsChain<MathArray>
+  >()
+  expectTypeOf(
+    math
+      .chain(
+        math.matrix([
+          [1, 2],
+          [3, 4],
+        ])
+      )
+      .expm1()
+  ).toMatchTypeOf<MathJsChain<Matrix>>()
+
+  // gcd
+  expectTypeOf(math.chain([1, 2]).gcd(3)).toMatchTypeOf<MathJsChain<number>>()
+  expectTypeOf(math.chain([1, 2]).gcd(3, 4)).toMatchTypeOf<
+    MathJsChain<number>
+  >()
+  // TODO make gcd() work in the following cases
+  // expectTypeOf(math.chain([1, 2]).gcd()).toMatchTypeOf<MathJsChain<number>>()
+  // expectTypeOf(math.chain([[1], [2]]).gcd()).toMatchTypeOf<
+  //   MathJsChain<MathArray>
+  // >()
+  // expectTypeOf(
+  //   math.chain([math.bignumber(1), math.bignumber(1)]).gcd()
+  // ).toMatchTypeOf<MathJsChain<BigNumber>>()
+  // expectTypeOf(
+  //   math.chain([math.complex(1, 2), math.complex(1, 2)]).gcd()
+  // ).toMatchTypeOf<MathJsChain<Complex>>()
+  // expectTypeOf(
+  //   math
+  //     .chain(
+  //       math.matrix([
+  //         [1, 2],
+  //         [3, 4],
+  //       ])
+  //     )
+  //     .expm1()
+  // ).toMatchTypeOf<MathJsChain<Matrix>>()
+
+  // hypot
+  expectTypeOf(math.chain([1, 2]).hypot()).toMatchTypeOf<MathJsChain<number>>()
+  expectTypeOf(
+    math.chain([math.bignumber(1), math.bignumber(1)]).hypot()
+  ).toMatchTypeOf<MathJsChain<BigNumber>>()
+
+  // lcm
+  expectTypeOf(math.chain(1).lcm(2)).toMatchTypeOf<MathJsChain<number>>()
+  expectTypeOf(
+    math.chain(math.bignumber(1)).lcm(math.bignumber(2))
+  ).toMatchTypeOf<MathJsChain<BigNumber>>()
+  expectTypeOf(math.chain([1, 2]).lcm([3, 4])).toMatchTypeOf<
+    MathJsChain<MathArray>
+  >()
+  expectTypeOf(
+    math
+      .chain(
+        math.matrix([
+          [1, 2],
+          [3, 4],
+        ])
+      )
+      .lcm(
+        math.matrix([
+          [1, 2],
+          [3, 4],
+        ])
+      )
+  ).toMatchTypeOf<MathJsChain<Matrix>>()
+
+  // log
+  expectTypeOf(math.chain(1).log(2)).toMatchTypeOf<MathJsChain<number>>()
+  expectTypeOf(
+    math.chain(math.bignumber(1)).log(math.bignumber(2))
+  ).toMatchTypeOf<MathJsChain<BigNumber>>()
+
+  // log10
+  expectTypeOf(math.chain(1).log10()).toMatchTypeOf<MathJsChain<number>>()
+  expectTypeOf(math.chain(math.bignumber(1)).log10()).toMatchTypeOf<
+    MathJsChain<BigNumber>
+  >()
+  expectTypeOf(math.chain([1, 2]).log10()).toMatchTypeOf<
+    MathJsChain<MathArray>
+  >()
+  expectTypeOf(
+    math
+      .chain(
+        math.matrix([
+          [1, 2],
+          [3, 4],
+        ])
+      )
+      .log10()
+  ).toMatchTypeOf<MathJsChain<Matrix>>()
+
+  // TODO complete the rest of these...
 }
 
 /*
@@ -219,6 +826,17 @@ Complex numbers examples
   }
 }
 
+/*
+Parenthesis examples
+*/
+{
+  const math = create(all, {})
+
+  expectTypeOf(
+    new math.ParenthesisNode(new math.ConstantNode(3))
+  ).toMatchTypeOf<ParenthesisNode<ConstantNode>>()
+}
+
 /*
 Expressions examples
 */
@@ -318,6 +936,46 @@ Fractions examples
   const _a = math.fraction('2/3')
 }
 
+/*
+Transform examples
+*/
+{
+  const math = create(all, {})
+  {
+    const myTransform1 = (node: MathNode): OperatorNode<'+', 'add'> =>
+      new OperatorNode('+', 'add', [node, new ConstantNode(1)])
+    const myTransform2 = (
+      node: OperatorNode<'+', 'add'>
+    ): OperatorNode<'-', 'subtract'> =>
+      new OperatorNode('-', 'subtract', [node, new ConstantNode(5)])
+
+    expectTypeOf(
+      math.parse('sqrt(3^2 + 4^2)').transform(myTransform1)
+    ).toMatchTypeOf<OperatorNode<'+', 'add', MathNode[]>>()
+
+    assert.deepStrictEqual(
+      math.parse('sqrt(3^2 + 4^2)').transform(myTransform1).toString(),
+      'sqrt(3 ^ 2 + 4 ^ 2) + 1'
+    )
+
+    expectTypeOf(
+      math
+        .parse('sqrt(3^2 + 4^2)')
+        .transform(myTransform1)
+        .transform(myTransform2)
+    ).toMatchTypeOf<OperatorNode<'-', 'subtract', MathNode[]>>()
+
+    assert.deepStrictEqual(
+      math
+        .parse('sqrt(3^2 + 4^2)')
+        .transform(myTransform1)
+        .transform(myTransform2)
+        .toString(),
+      'sqrt(3 ^ 2 + 4 ^ 2) + 1 - 5'
+    )
+  }
+}
+
 /*
 Matrices examples
 */
@@ -427,6 +1085,62 @@ Matrices examples
   {
     assert.strictEqual(math.matrix([1, 2, 3]) instanceof math.Matrix, true)
   }
+
+  // Fourier transform and inverse
+  {
+    assert.ok(
+      math.deepEqual(
+        math.fft([
+          [1, 0],
+          [1, 0],
+        ]),
+        [
+          [math.complex(2, 0), math.complex(2, 0)],
+          [math.complex(0, 0), math.complex(0, 0)],
+        ]
+      )
+    )
+    assert.ok(
+      math.deepEqual(
+        math.fft(
+          math.matrix([
+            [1, 0],
+            [1, 0],
+          ])
+        ),
+        math.matrix([
+          [math.complex(2, 0), math.complex(2, 0)],
+          [math.complex(0, 0), math.complex(0, 0)],
+        ])
+      )
+    )
+    assert.ok(
+      math.deepEqual(
+        math.ifft([
+          [2, 2],
+          [0, 0],
+        ]),
+        [
+          [math.complex(1, 0), math.complex(0, 0)],
+          [math.complex(1, 0), math.complex(0, 0)],
+        ]
+      )
+    )
+    assert.ok(
+      math.deepEqual(
+        math.ifft(
+          math.matrix([
+            [2, 2],
+            [0, 0],
+          ])
+        ),
+        math.matrix([
+          [math.complex(1, 0), math.complex(0, 0)],
+          [math.complex(1, 0), math.complex(0, 0)],
+        ])
+      )
+    )
+  }
 }
 
 /*
@@ -863,6 +1577,45 @@ Function round examples
   assert.throws(() => math.round([3.21, 3.82], [1, 2]), TypeError)
 }
 
+/*
+ Clone examples
+  */
+{
+  const math = create(all, {})
+  expectTypeOf(
+    new math.OperatorNode('/', 'divide', [
+      new math.ConstantNode(3),
+      new math.SymbolNode('x'),
+    ])
+  ).toMatchTypeOf<OperatorNode<'/', 'divide', (ConstantNode | SymbolNode)[]>>()
+
+  expectTypeOf(new math.ConstantNode(1).clone()).toMatchTypeOf<ConstantNode>()
+  expectTypeOf(
+    new math.OperatorNode('*', 'multiply', [
+      new math.ConstantNode(3),
+      new math.SymbolNode('x'),
+    ]).clone()
+  ).toMatchTypeOf<
+    OperatorNode<'*', 'multiply', (ConstantNode | SymbolNode)[]>
+  >()
+
+  expectTypeOf(
+    new math.ConstantNode(1).cloneDeep()
+  ).toMatchTypeOf<ConstantNode>()
+  expectTypeOf(
+    new math.OperatorNode('+', 'unaryPlus', [
+      new math.ConstantNode(3),
+      new math.SymbolNode('x'),
+    ]).cloneDeep()
+  ).toMatchTypeOf<
+    OperatorNode<'+', 'unaryPlus', (ConstantNode | SymbolNode)[]>
+  >()
+
+  expectTypeOf(
+    math.clone(new math.ConstantNode(1))
+  ).toMatchTypeOf<ConstantNode>()
+}
+
 /*
 JSON serialization/deserialization
 */
@@ -1213,7 +1966,9 @@ Factory Test
     expectTypeOf(x).toMatchTypeOf<math.ObjectNode>()
   }
   if (math.isOperatorNode(x)) {
-    expectTypeOf(x).toMatchTypeOf<math.OperatorNode>()
+    expectTypeOf(x).toMatchTypeOf<
+      OperatorNode<OperatorNodeOp, OperatorNodeFn, MathNode[]>
+    >()
   }
   if (math.isParenthesisNode(x)) {
     expectTypeOf(x).toMatchTypeOf<math.ParenthesisNode>()
@@ -1225,7 +1980,8 @@ Factory Test
     expectTypeOf(x).toMatchTypeOf<math.SymbolNode>()
   }
   if (math.isChain(x)) {
-    expectTypeOf(x).toMatchTypeOf<math.MathJsChain>()
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    expectTypeOf(x).toMatchTypeOf<math.MathJsChain<any>>()
   }
 }