mathjs 10.0.0 → 10.1.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (70) hide show
  1. package/HISTORY.md +37 -0
  2. package/NOTICE +1 -1
  3. package/README.md +10 -2
  4. package/bin/cli.js +1 -1
  5. package/docs/expressions/syntax.md +1 -1
  6. package/docs/reference/constants.md +1 -1
  7. package/docs/reference/functions/invmod.md +41 -0
  8. package/docs/reference/functions/simplify.md +8 -5
  9. package/docs/reference/functions.md +1 -0
  10. package/examples/expressions.js +1 -1
  11. package/lib/browser/math.js +7 -7
  12. package/lib/browser/math.js.map +1 -1
  13. package/lib/cjs/entry/dependenciesAny/dependenciesIntersect.generated.js +6 -0
  14. package/lib/cjs/entry/dependenciesAny/dependenciesInvmod.generated.js +41 -0
  15. package/lib/cjs/entry/dependenciesAny/dependenciesRationalize.generated.js +15 -0
  16. package/lib/cjs/entry/dependenciesAny/dependenciesSimplify.generated.js +15 -0
  17. package/lib/cjs/entry/dependenciesAny.generated.js +8 -0
  18. package/lib/cjs/entry/dependenciesNumber/dependenciesRationalize.generated.js +15 -0
  19. package/lib/cjs/entry/dependenciesNumber/dependenciesSimplify.generated.js +15 -0
  20. package/lib/cjs/entry/impureFunctionsAny.generated.js +11 -0
  21. package/lib/cjs/entry/impureFunctionsNumber.generated.js +10 -0
  22. package/lib/cjs/entry/pureFunctionsAny.generated.js +16 -2
  23. package/lib/cjs/expression/embeddedDocs/embeddedDocs.js +6 -1
  24. package/lib/cjs/expression/embeddedDocs/function/arithmetic/invmod.js +15 -0
  25. package/lib/cjs/expression/embeddedDocs/function/matrix/forEach.js +1 -1
  26. package/lib/cjs/factoriesAny.js +8 -0
  27. package/lib/cjs/function/algebra/rationalize.js +18 -4
  28. package/lib/cjs/function/algebra/simplify/simplifyConstant.js +223 -29
  29. package/lib/cjs/function/algebra/simplify/simplifyCore.js +34 -6
  30. package/lib/cjs/function/algebra/simplify.js +103 -30
  31. package/lib/cjs/function/arithmetic/invmod.js +73 -0
  32. package/lib/cjs/function/arithmetic/round.js +2 -2
  33. package/lib/cjs/function/geometry/intersect.js +12 -13
  34. package/lib/cjs/function/probability/gamma.js +28 -30
  35. package/lib/cjs/header.js +3 -3
  36. package/lib/cjs/type/matrix/SparseMatrix.js +19 -15
  37. package/lib/cjs/type/unit/Unit.js +2 -2
  38. package/lib/cjs/utils/number.js +1 -1
  39. package/lib/cjs/utils/snapshot.js +2 -2
  40. package/lib/cjs/version.js +1 -1
  41. package/lib/esm/entry/dependenciesAny/dependenciesIntersect.generated.js +4 -0
  42. package/lib/esm/entry/dependenciesAny/dependenciesInvmod.generated.js +24 -0
  43. package/lib/esm/entry/dependenciesAny/dependenciesRationalize.generated.js +10 -0
  44. package/lib/esm/entry/dependenciesAny/dependenciesSimplify.generated.js +10 -0
  45. package/lib/esm/entry/dependenciesAny.generated.js +1 -0
  46. package/lib/esm/entry/dependenciesNumber/dependenciesRationalize.generated.js +10 -0
  47. package/lib/esm/entry/dependenciesNumber/dependenciesSimplify.generated.js +10 -0
  48. package/lib/esm/entry/impureFunctionsAny.generated.js +12 -1
  49. package/lib/esm/entry/impureFunctionsNumber.generated.js +10 -0
  50. package/lib/esm/entry/pureFunctionsAny.generated.js +14 -1
  51. package/lib/esm/expression/embeddedDocs/embeddedDocs.js +4 -1
  52. package/lib/esm/expression/embeddedDocs/function/arithmetic/invmod.js +8 -0
  53. package/lib/esm/expression/embeddedDocs/function/matrix/forEach.js +1 -1
  54. package/lib/esm/factoriesAny.js +1 -0
  55. package/lib/esm/function/algebra/rationalize.js +18 -4
  56. package/lib/esm/function/algebra/simplify/simplifyConstant.js +197 -29
  57. package/lib/esm/function/algebra/simplify/simplifyCore.js +35 -7
  58. package/lib/esm/function/algebra/simplify.js +103 -30
  59. package/lib/esm/function/arithmetic/invmod.js +57 -0
  60. package/lib/esm/function/arithmetic/round.js +2 -2
  61. package/lib/esm/function/geometry/intersect.js +12 -12
  62. package/lib/esm/function/probability/gamma.js +28 -30
  63. package/lib/esm/header.js +1 -1
  64. package/lib/esm/type/matrix/SparseMatrix.js +19 -15
  65. package/lib/esm/type/unit/Unit.js +2 -2
  66. package/lib/esm/utils/number.js +1 -1
  67. package/lib/esm/utils/snapshot.js +2 -2
  68. package/lib/esm/version.js +1 -1
  69. package/package.json +15 -14
  70. package/types/index.d.ts +4 -4
@@ -103,8 +103,12 @@ export var parse = createParse({
103
103
  typed
104
104
  });
105
105
  export var simplify = createSimplify({
106
+ AccessorNode,
107
+ ArrayNode,
106
108
  ConstantNode,
107
109
  FunctionNode,
110
+ IndexNode,
111
+ ObjectNode,
108
112
  OperatorNode,
109
113
  ParenthesisNode,
110
114
  SymbolNode,
@@ -114,6 +118,7 @@ export var simplify = createSimplify({
114
118
  equal,
115
119
  isZero,
116
120
  mathWithTransform,
121
+ matrix,
117
122
  multiply,
118
123
  parse,
119
124
  pow,
@@ -149,8 +154,12 @@ export var derivative = createDerivative({
149
154
  typed
150
155
  });
151
156
  export var rationalize = createRationalize({
157
+ AccessorNode,
158
+ ArrayNode,
152
159
  ConstantNode,
153
160
  FunctionNode,
161
+ IndexNode,
162
+ ObjectNode,
154
163
  OperatorNode,
155
164
  ParenthesisNode,
156
165
  SymbolNode,
@@ -160,6 +169,7 @@ export var rationalize = createRationalize({
160
169
  equal,
161
170
  isZero,
162
171
  mathWithTransform,
172
+ matrix,
163
173
  multiply,
164
174
  parse,
165
175
  pow,
@@ -4,7 +4,7 @@
4
4
  */
5
5
  import { config } from './configReadonly.js';
6
6
  import { createBigNumberClass, createComplexClass, createE, createFalse, createFineStructure, createFractionClass, createI, createInfinity, createLN10, createLOG10E, createMatrixClass, createNaN, createNull, createPhi, createRangeClass, createResultSet, createSQRT1_2, // eslint-disable-line camelcase
7
- createSackurTetrode, createTau, createTrue, createVersion, createDenseMatrixClass, createEfimovFactor, createLN2, createPi, createReplacer, createSQRT2, createTyped, createUnaryPlus, createWeakMixingAngle, createAbs, createAcos, createAcot, createAcsc, createAddScalar, createArg, createAsech, createAsinh, createAtan, createAtanh, createBignumber, createBitNot, createBoolean, createClone, createCombinations, createComplex, createConj, createCosh, createCoth, createCsc, createCube, createEqualScalar, createErf, createExp, createExpm1, createFilter, createForEach, createFormat, createGetMatrixDataType, createHex, createIm, createIsInteger, createIsNegative, createIsPositive, createIsZero, createLOG2E, createLog10, createLog2, createMap, createMultiplyScalar, createNot, createNumber, createOct, createPickRandom, createPrint, createRandom, createRe, createSec, createSign, createSin, createSparseMatrixClass, createSplitUnit, createSquare, createString, createTan, createTypeOf, createAcosh, createAcsch, createApply, createAsec, createBin, createCombinationsWithRep, createCos, createCsch, createIsNaN, createIsPrime, createRandomInt, createSech, createSinh, createSparse, createSqrt, createTanh, createUnaryMinus, createAcoth, createCot, createFraction, createIsNumeric, createMatrix, createMatrixFromFunction, createMod, createNthRoot, createNumeric, createOr, createProd, createReshape, createSize, createSmaller, createSqueeze, createSubset, createSubtract, createTo, createTranspose, createXgcd, createZeros, createAnd, createBitAnd, createBitXor, createCbrt, createCompare, createCompareText, createConcat, createCount, createCtranspose, createDiag, createDivideScalar, createDotDivide, createEqual, createFlatten, createGcd, createHasNumericValue, createHypot, createImmutableDenseMatrixClass, createIndexClass, createKron, createLargerEq, createLeftShift, createLsolve, createMatrixFromColumns, createMin, createMode, createNthRoots, createOnes, createPartitionSelect, createResize, createRightLogShift, createRound, createSmallerEq, createUnequal, createUsolve, createXor, createAdd, createAtan2, createBitOr, createCatalan, createCompareNatural, createDeepEqual, createDiff, createDot, createEqualText, createFloor, createIdentity, createLarger, createLog, createLsolveAll, createMatrixFromRows, createMultiply, createPow, createQr, createRange, createRightArithShift, createRow, createSetCartesian, createSetDistinct, createSetIsSubset, createSetPowerset, createSlu, createSum, createTrace, createUsolveAll, createAsin, createCeil, createColumn, createComposition, createCross, createDistance, createDotMultiply, createFibonacciHeapClass, createFix, createGamma, createIndex, createLcm, createMax, createQuantileSeq, createSetDifference, createSetMultiplicity, createSetSymDifference, createSort, createUnitClass, createVacuumImpedance, createWienDisplacement, createAtomicMass, createBohrMagneton, createBoltzmann, createConductanceQuantum, createCreateUnit, createDeuteronMass, createDotPow, createElectricConstant, createElementaryCharge, createFactorial, createFermiCoupling, createGasConstant, createGravity, createIntersect, createInverseConductanceQuantum, createKlitzing, createLoschmidt, createMagneticConstant, createMolarMass, createMolarPlanckConstant, createNeutronMass, createNuclearMagneton, createPermutations, createPlanckConstant, createPlanckMass, createPlanckTime, createQuantumOfCirculation, createReducedPlanckConstant, createRydberg, createSetIntersect, createSetUnion, createSpaClass, createStefanBoltzmann, createUnitFunction, createAvogadro, createBohrRadius, createCoulomb, createElectronMass, createFaraday, createHartreeEnergy, createLog1p, createMagneticFluxQuantum, createMolarMassC12, createPlanckCharge, createPlanckTemperature, createSecondRadiation, createSpeedOfLight, createStirlingS2, createBellNumbers, createFirstRadiation, createLup, createMolarVolume, createProtonMass, createSetSize, createThomsonCrossSection, createClassicalElectronRadius, createDet, createGravitationConstant, createInv, createLusolve, createSqrtm, createDivide, createExpm, createKldivergence, createMean, createMedian, createPlanckLength, createVariance, createStd, createEigs, createMultinomial, createMad, createNorm, createRotationMatrix, createRotate } from '../factoriesAny.js';
7
+ createSackurTetrode, createTau, createTrue, createVersion, createDenseMatrixClass, createEfimovFactor, createLN2, createPi, createReplacer, createSQRT2, createTyped, createUnaryPlus, createWeakMixingAngle, createAbs, createAcos, createAcot, createAcsc, createAddScalar, createArg, createAsech, createAsinh, createAtan, createAtanh, createBignumber, createBitNot, createBoolean, createClone, createCombinations, createComplex, createConj, createCosh, createCoth, createCsc, createCube, createEqualScalar, createErf, createExp, createExpm1, createFilter, createForEach, createFormat, createGetMatrixDataType, createHex, createIm, createIsInteger, createIsNegative, createIsPositive, createIsZero, createLOG2E, createLog10, createLog2, createMap, createMultiplyScalar, createNot, createNumber, createOct, createPickRandom, createPrint, createRandom, createRe, createSec, createSign, createSin, createSparseMatrixClass, createSplitUnit, createSquare, createString, createTan, createTypeOf, createAcosh, createAcsch, createApply, createAsec, createBin, createCombinationsWithRep, createCos, createCsch, createIsNaN, createIsPrime, createRandomInt, createSech, createSinh, createSparse, createSqrt, createTanh, createUnaryMinus, createAcoth, createCot, createFraction, createIsNumeric, createMatrix, createMatrixFromFunction, createMod, createNthRoot, createNumeric, createOr, createProd, createReshape, createSize, createSmaller, createSqueeze, createSubset, createSubtract, createTo, createTranspose, createXgcd, createZeros, createAnd, createBitAnd, createBitXor, createCbrt, createCompare, createCompareText, createConcat, createCount, createCtranspose, createDiag, createDivideScalar, createDotDivide, createEqual, createFlatten, createGcd, createHasNumericValue, createHypot, createImmutableDenseMatrixClass, createIndexClass, createKron, createLargerEq, createLeftShift, createLsolve, createMatrixFromColumns, createMin, createMode, createNthRoots, createOnes, createPartitionSelect, createResize, createRightLogShift, createRound, createSmallerEq, createUnequal, createUsolve, createXor, createAdd, createAtan2, createBitOr, createCatalan, createCompareNatural, createDeepEqual, createDiff, createDot, createEqualText, createFloor, createIdentity, createInvmod, createLarger, createLog, createLsolveAll, createMatrixFromRows, createMultiply, createPow, createQr, createRange, createRightArithShift, createRow, createSetCartesian, createSetDistinct, createSetIsSubset, createSetPowerset, createSlu, createSum, createTrace, createUsolveAll, createAsin, createCeil, createColumn, createComposition, createCross, createDistance, createDotMultiply, createFibonacciHeapClass, createFix, createGamma, createIndex, createLcm, createMax, createQuantileSeq, createSetDifference, createSetMultiplicity, createSetSymDifference, createSort, createUnitClass, createVacuumImpedance, createWienDisplacement, createAtomicMass, createBohrMagneton, createBoltzmann, createConductanceQuantum, createCreateUnit, createDeuteronMass, createDotPow, createElectricConstant, createElementaryCharge, createFactorial, createFermiCoupling, createGasConstant, createGravity, createIntersect, createInverseConductanceQuantum, createKlitzing, createLoschmidt, createMagneticConstant, createMolarMass, createMolarPlanckConstant, createNeutronMass, createNuclearMagneton, createPermutations, createPlanckConstant, createPlanckMass, createPlanckTime, createQuantumOfCirculation, createReducedPlanckConstant, createRydberg, createSetIntersect, createSetUnion, createSpaClass, createStefanBoltzmann, createUnitFunction, createAvogadro, createBohrRadius, createCoulomb, createElectronMass, createFaraday, createHartreeEnergy, createLog1p, createMagneticFluxQuantum, createMolarMassC12, createPlanckCharge, createPlanckTemperature, createSecondRadiation, createSpeedOfLight, createStirlingS2, createBellNumbers, createFirstRadiation, createLup, createMolarVolume, createProtonMass, createSetSize, createThomsonCrossSection, createClassicalElectronRadius, createDet, createGravitationConstant, createInv, createLusolve, createSqrtm, createDivide, createExpm, createKldivergence, createMean, createMedian, createPlanckLength, createVariance, createStd, createEigs, createMultinomial, createMad, createNorm, createRotationMatrix, createRotate } from '../factoriesAny.js';
8
8
  export var BigNumber = /* #__PURE__ */createBigNumberClass({
9
9
  config
10
10
  });
@@ -758,6 +758,17 @@ export var identity = /* #__PURE__ */createIdentity({
758
758
  matrix,
759
759
  typed
760
760
  });
761
+ export var invmod = /* #__PURE__ */createInvmod({
762
+ BigNumber,
763
+ add,
764
+ config,
765
+ equal,
766
+ isInteger,
767
+ mod,
768
+ smaller,
769
+ typed,
770
+ xgcd
771
+ });
761
772
  export var larger = /* #__PURE__ */createLarger({
762
773
  DenseMatrix,
763
774
  config,
@@ -1125,6 +1136,8 @@ export var intersect = /* #__PURE__ */createIntersect({
1125
1136
  divideScalar,
1126
1137
  equalScalar,
1127
1138
  flatten,
1139
+ isNumeric,
1140
+ isZero,
1128
1141
  matrix,
1129
1142
  multiply,
1130
1143
  multiplyScalar,
@@ -1,4 +1,5 @@
1
1
  import { bignumberDocs } from './construction/bignumber.js';
2
+ import { printDocs } from './function/utils/print.js';
2
3
  import { typeOfDocs } from './function/utils/typeOf.js';
3
4
  import { isZeroDocs } from './function/utils/isZero.js';
4
5
  import { isPrimeDocs } from './function/utils/isPrime.js';
@@ -135,6 +136,7 @@ import { bitOrDocs } from './function/bitwise/bitOr.js';
135
136
  import { bitNotDocs } from './function/bitwise/bitNot.js';
136
137
  import { bitAndDocs } from './function/bitwise/bitAnd.js';
137
138
  import { xgcdDocs } from './function/arithmetic/xgcd.js';
139
+ import { invmodDocs } from './function/arithmetic/invmod.js';
138
140
  import { unaryPlusDocs } from './function/arithmetic/unaryPlus.js';
139
141
  import { unaryMinusDocs } from './function/arithmetic/unaryMinus.js';
140
142
  import { squareDocs } from './function/arithmetic/square.js';
@@ -507,6 +509,7 @@ export var embeddedDocs = {
507
509
  unaryMinus: unaryMinusDocs,
508
510
  unaryPlus: unaryPlusDocs,
509
511
  xgcd: xgcdDocs,
512
+ invmod: invmodDocs,
510
513
  // functions - bitwise
511
514
  bitAnd: bitAndDocs,
512
515
  bitNot: bitNotDocs,
@@ -668,7 +671,7 @@ export var embeddedDocs = {
668
671
  isPositive: isPositiveDocs,
669
672
  isPrime: isPrimeDocs,
670
673
  isZero: isZeroDocs,
671
- // print: printDocs // TODO: add documentation for print as soon as the parser supports objects.
674
+ print: printDocs,
672
675
  typeOf: typeOfDocs,
673
676
  numeric: numericDocs
674
677
  };
@@ -0,0 +1,8 @@
1
+ export var invmodDocs = {
2
+ name: 'invmod',
3
+ category: 'Arithmetic',
4
+ syntax: ['invmod(a, b)'],
5
+ description: 'Calculate the (modular) multiplicative inverse of a modulo b. Solution to the equation ax ≣ 1 (mod b)',
6
+ examples: ['invmod(8, 12)=NaN', 'invmod(7, 13)=2', 'math.invmod(15151, 15122)=10429'],
7
+ seealso: ['gcd', 'xgcd']
8
+ };
@@ -3,6 +3,6 @@ export var forEachDocs = {
3
3
  category: 'Matrix',
4
4
  syntax: ['forEach(x, callback)'],
5
5
  description: 'Iterates over all elements of a matrix/array, and executes the given callback function.',
6
- examples: ['forEach([1, 2, 3], function(val) { console.log(val) })'],
6
+ examples: [],
7
7
  seealso: ['map', 'sort', 'filter']
8
8
  };
@@ -53,6 +53,7 @@ export { createSqrt } from './function/arithmetic/sqrt.js';
53
53
  export { createSquare } from './function/arithmetic/square.js';
54
54
  export { createSubtract } from './function/arithmetic/subtract.js';
55
55
  export { createXgcd } from './function/arithmetic/xgcd.js';
56
+ export { createInvmod } from './function/arithmetic/invmod.js';
56
57
  export { createDotMultiply } from './function/arithmetic/dotMultiply.js';
57
58
  export { createBitAnd } from './function/bitwise/bitAnd.js';
58
59
  export { createBitNot } from './function/bitwise/bitNot.js';
@@ -3,7 +3,7 @@ import { factory } from '../../utils/factory.js';
3
3
  import { createSimplifyConstant } from './simplify/simplifyConstant.js';
4
4
  import { createSimplifyCore } from './simplify/simplifyCore.js';
5
5
  var name = 'rationalize';
6
- var dependencies = ['config', 'typed', 'equal', 'isZero', 'add', 'subtract', 'multiply', 'divide', 'pow', 'parse', 'simplify', '?bignumber', '?fraction', 'mathWithTransform', 'ConstantNode', 'OperatorNode', 'FunctionNode', 'SymbolNode', 'ParenthesisNode'];
6
+ var dependencies = ['config', 'typed', 'equal', 'isZero', 'add', 'subtract', 'multiply', 'divide', 'pow', 'parse', 'simplify', '?bignumber', '?fraction', 'mathWithTransform', 'matrix', 'AccessorNode', 'ArrayNode', 'ConstantNode', 'FunctionNode', 'IndexNode', 'ObjectNode', 'OperatorNode', 'SymbolNode', 'ParenthesisNode'];
7
7
  export var createRationalize = /* #__PURE__ */factory(name, dependencies, _ref => {
8
8
  var {
9
9
  config,
@@ -20,9 +20,14 @@ export var createRationalize = /* #__PURE__ */factory(name, dependencies, _ref =
20
20
  fraction,
21
21
  bignumber,
22
22
  mathWithTransform,
23
+ matrix,
24
+ AccessorNode,
25
+ ArrayNode,
23
26
  ConstantNode,
24
- OperatorNode,
25
27
  FunctionNode,
28
+ IndexNode,
29
+ ObjectNode,
30
+ OperatorNode,
26
31
  SymbolNode,
27
32
  ParenthesisNode
28
33
  } = _ref;
@@ -30,11 +35,16 @@ export var createRationalize = /* #__PURE__ */factory(name, dependencies, _ref =
30
35
  typed,
31
36
  config,
32
37
  mathWithTransform,
38
+ matrix,
33
39
  fraction,
34
40
  bignumber,
41
+ AccessorNode,
42
+ ArrayNode,
35
43
  ConstantNode,
36
- OperatorNode,
37
44
  FunctionNode,
45
+ IndexNode,
46
+ ObjectNode,
47
+ OperatorNode,
38
48
  SymbolNode
39
49
  });
40
50
  var simplifyCore = createSimplifyCore({
@@ -45,9 +55,13 @@ export var createRationalize = /* #__PURE__ */factory(name, dependencies, _ref =
45
55
  multiply,
46
56
  divide,
47
57
  pow,
58
+ AccessorNode,
59
+ ArrayNode,
48
60
  ConstantNode,
49
- OperatorNode,
50
61
  FunctionNode,
62
+ IndexNode,
63
+ ObjectNode,
64
+ OperatorNode,
51
65
  ParenthesisNode
52
66
  });
53
67
  /**
@@ -1,20 +1,25 @@
1
1
  // TODO this could be improved by simplifying seperated constants under associative and commutative operators
2
- import { isFraction, isNode, isOperatorNode } from '../../../utils/is.js';
2
+ import { isFraction, isMatrix, isNode, isArrayNode, isConstantNode, isIndexNode, isObjectNode, isOperatorNode } from '../../../utils/is.js';
3
3
  import { factory } from '../../../utils/factory.js';
4
4
  import { createUtil } from './util.js';
5
5
  import { noBignumber, noFraction } from '../../../utils/noop.js';
6
6
  var name = 'simplifyConstant';
7
- var dependencies = ['typed', 'config', 'mathWithTransform', '?fraction', '?bignumber', 'ConstantNode', 'OperatorNode', 'FunctionNode', 'SymbolNode'];
7
+ var dependencies = ['typed', 'config', 'mathWithTransform', 'matrix', '?fraction', '?bignumber', 'AccessorNode', 'ArrayNode', 'ConstantNode', 'FunctionNode', 'IndexNode', 'ObjectNode', 'OperatorNode', 'SymbolNode'];
8
8
  export var createSimplifyConstant = /* #__PURE__ */factory(name, dependencies, _ref => {
9
9
  var {
10
10
  typed,
11
11
  config,
12
12
  mathWithTransform,
13
+ matrix,
13
14
  fraction,
14
15
  bignumber,
16
+ AccessorNode,
17
+ ArrayNode,
15
18
  ConstantNode,
16
- OperatorNode,
17
19
  FunctionNode,
20
+ IndexNode,
21
+ ObjectNode,
22
+ OperatorNode,
18
23
  SymbolNode
19
24
  } = _ref;
20
25
  var {
@@ -29,22 +34,31 @@ export var createSimplifyConstant = /* #__PURE__ */factory(name, dependencies, _
29
34
  });
30
35
 
31
36
  function simplifyConstant(expr, options) {
32
- var res = foldFraction(expr, options);
33
- return isNode(res) ? res : _toNode(res);
37
+ return _ensureNode(foldFraction(expr, options));
38
+ }
39
+
40
+ function _removeFractions(thing) {
41
+ if (isFraction(thing)) {
42
+ return thing.valueOf();
43
+ }
44
+
45
+ if (thing instanceof Array) {
46
+ return thing.map(_removeFractions);
47
+ }
48
+
49
+ if (isMatrix(thing)) {
50
+ return matrix(_removeFractions(thing.valueOf()));
51
+ }
52
+
53
+ return thing;
34
54
  }
35
55
 
36
56
  function _eval(fnname, args, options) {
37
57
  try {
38
- return _toNumber(mathWithTransform[fnname].apply(null, args), options);
58
+ return mathWithTransform[fnname].apply(null, args);
39
59
  } catch (ignore) {
40
60
  // sometimes the implicit type conversion causes the evaluation to fail, so we'll try again after removing Fractions
41
- args = args.map(function (x) {
42
- if (isFraction(x)) {
43
- return x.valueOf();
44
- }
45
-
46
- return x;
47
- });
61
+ args = args.map(_removeFractions);
48
62
  return _toNumber(mathWithTransform[fnname].apply(null, args), options);
49
63
  }
50
64
  }
@@ -67,8 +81,22 @@ export var createSimplifyConstant = /* #__PURE__ */factory(name, dependencies, _
67
81
  },
68
82
  Complex: function Complex(s) {
69
83
  throw new Error('Cannot convert Complex number to Node');
84
+ },
85
+ string: function string(s) {
86
+ return new ConstantNode(s);
87
+ },
88
+ Matrix: function Matrix(m) {
89
+ return new ArrayNode(m.valueOf().map(e => _toNode(e)));
90
+ }
91
+ });
92
+
93
+ function _ensureNode(thing) {
94
+ if (isNode(thing)) {
95
+ return thing;
70
96
  }
71
- }); // convert a number to a fraction only if it can be expressed exactly,
97
+
98
+ return _toNode(thing);
99
+ } // convert a number to a fraction only if it can be expressed exactly,
72
100
  // and when both numerator and denominator are small enough
73
101
 
74
102
 
@@ -125,6 +153,12 @@ export var createSimplifyConstant = /* #__PURE__ */factory(name, dependencies, _
125
153
  }
126
154
 
127
155
  return _exactFraction(s.re, options);
156
+ },
157
+ 'Matrix, Object': function MatrixObject(s, options) {
158
+ return matrix(_exactFraction(s.valueOf()));
159
+ },
160
+ 'Array, Object': function ArrayObject(s, options) {
161
+ return s.map(_exactFraction);
128
162
  }
129
163
  });
130
164
 
@@ -148,6 +182,103 @@ export var createSimplifyConstant = /* #__PURE__ */factory(name, dependencies, _
148
182
 
149
183
  return new OperatorNode('/', 'divide', [n, new ConstantNode(f.d)]);
150
184
  }
185
+ /* Handles constant indexing of ArrayNodes, matrices, and ObjectNodes */
186
+
187
+
188
+ function _foldAccessor(obj, index, options) {
189
+ if (!isIndexNode(index)) {
190
+ // don't know what to do with that...
191
+ return new AccessorNode(_ensureNode(obj), _ensureNode(index));
192
+ }
193
+
194
+ if (isArrayNode(obj) || isMatrix(obj)) {
195
+ var remainingDims = Array.from(index.dimensions);
196
+ /* We will resolve constant indices one at a time, looking
197
+ * just in the first or second dimensions because (a) arrays
198
+ * of more than two dimensions are likely rare, and (b) pulling
199
+ * out the third or higher dimension would be pretty intricate.
200
+ * The price is that we miss simplifying [..3d array][x,y,1]
201
+ */
202
+
203
+ while (remainingDims.length > 0) {
204
+ if (isConstantNode(remainingDims[0]) && typeof remainingDims[0].value !== 'string') {
205
+ var first = _toNumber(remainingDims.shift().value, options);
206
+
207
+ if (isArrayNode(obj)) {
208
+ obj = obj.items[first - 1];
209
+ } else {
210
+ // matrix
211
+ obj = obj.valueOf()[first - 1];
212
+
213
+ if (obj instanceof Array) {
214
+ obj = matrix(obj);
215
+ }
216
+ }
217
+ } else if (remainingDims.length > 1 && isConstantNode(remainingDims[1]) && typeof remainingDims[1].value !== 'string') {
218
+ var second = _toNumber(remainingDims[1].value, options);
219
+
220
+ var tryItems = [];
221
+ var fromItems = isArrayNode(obj) ? obj.items : obj.valueOf();
222
+
223
+ for (var item of fromItems) {
224
+ if (isArrayNode(item)) {
225
+ tryItems.push(item.items[second - 1]);
226
+ } else if (isMatrix(obj)) {
227
+ tryItems.push(item[second - 1]);
228
+ } else {
229
+ break;
230
+ }
231
+ }
232
+
233
+ if (tryItems.length === fromItems.length) {
234
+ if (isArrayNode(obj)) {
235
+ obj = new ArrayNode(tryItems);
236
+ } else {
237
+ // matrix
238
+ obj = matrix(tryItems);
239
+ }
240
+
241
+ remainingDims.splice(1, 1);
242
+ } else {
243
+ // extracting slice along 2nd dimension failed, give up
244
+ break;
245
+ }
246
+ } else {
247
+ // neither 1st or 2nd dimension is constant, give up
248
+ break;
249
+ }
250
+ }
251
+
252
+ if (remainingDims.length === index.dimensions.length) {
253
+ /* No successful constant indexing */
254
+ return new AccessorNode(_ensureNode(obj), index);
255
+ }
256
+
257
+ if (remainingDims.length > 0) {
258
+ /* Indexed some but not all dimensions */
259
+ index = new IndexNode(remainingDims);
260
+ return new AccessorNode(_ensureNode(obj), index);
261
+ }
262
+ /* All dimensions were constant, access completely resolved */
263
+
264
+
265
+ return obj;
266
+ }
267
+
268
+ if (isObjectNode(obj) && index.dimensions.length === 1 && isConstantNode(index.dimensions[0])) {
269
+ var key = index.dimensions[0].value;
270
+
271
+ if (key in obj.properties) {
272
+ return obj.properties[key];
273
+ }
274
+
275
+ return new ConstantNode(); // undefined
276
+ }
277
+ /* Don't know how to index this sort of obj, at least not with this index */
278
+
279
+
280
+ return new AccessorNode(_ensureNode(obj), index);
281
+ }
151
282
  /*
152
283
  * Create a binary tree from a list of Fractions and Nodes.
153
284
  * Tries to fold Fractions by evaluating them until the first Node in the list is hit, so
@@ -186,8 +317,15 @@ export var createSimplifyConstant = /* #__PURE__ */factory(name, dependencies, _
186
317
  return node;
187
318
 
188
319
  case 'ConstantNode':
189
- if (typeof node.value === 'number' || !isNaN(node.value)) {
190
- return _toNumber(node.value, options);
320
+ switch (typeof node.value) {
321
+ case 'number':
322
+ return _toNumber(node.value, options);
323
+
324
+ case 'string':
325
+ return node.value;
326
+
327
+ default:
328
+ if (!isNaN(node.value)) return _toNumber(node.value, options);
191
329
  }
192
330
 
193
331
  return node;
@@ -207,14 +345,24 @@ export var createSimplifyConstant = /* #__PURE__ */factory(name, dependencies, _
207
345
  if (!args.some(isNode)) {
208
346
  try {
209
347
  return _eval(node.name, args, options);
210
- } catch (ignoreandcontine) {}
348
+ } catch (ignoreandcontinue) {}
349
+ } // Size of a matrix does not depend on entries
350
+
351
+
352
+ if (node.name === 'size' && args.length === 1 && isArrayNode(args[0])) {
353
+ var sz = [];
354
+ var section = args[0];
355
+
356
+ while (isArrayNode(section)) {
357
+ sz.push(section.items.length);
358
+ section = section.items[0];
359
+ }
360
+
361
+ return matrix(sz);
211
362
  } // Convert all args to nodes and construct a symbolic function call
212
363
 
213
364
 
214
- args = args.map(function (arg) {
215
- return isNode(arg) ? arg : _toNode(arg);
216
- });
217
- return new FunctionNode(node.name, args);
365
+ return new FunctionNode(node.name, args.map(_ensureNode));
218
366
  } else {// treat as operator
219
367
  }
220
368
  }
@@ -281,10 +429,36 @@ export var createSimplifyConstant = /* #__PURE__ */factory(name, dependencies, _
281
429
  return foldFraction(node.content, options);
282
430
 
283
431
  case 'AccessorNode':
284
- /* falls through */
432
+ return _foldAccessor(foldFraction(node.object, options), foldFraction(node.index, options), options);
285
433
 
286
434
  case 'ArrayNode':
287
- /* falls through */
435
+ {
436
+ var foldItems = node.items.map(item => foldFraction(item, options));
437
+
438
+ if (foldItems.some(isNode)) {
439
+ return new ArrayNode(foldItems.map(_ensureNode));
440
+ }
441
+ /* All literals -- return a Matrix so we can operate on it */
442
+
443
+
444
+ return matrix(foldItems);
445
+ }
446
+
447
+ case 'IndexNode':
448
+ {
449
+ return new IndexNode(node.dimensions.map(n => simplifyConstant(n, options)));
450
+ }
451
+
452
+ case 'ObjectNode':
453
+ {
454
+ var foldProps = {};
455
+
456
+ for (var prop in node.properties) {
457
+ foldProps[prop] = simplifyConstant(node.properties[prop], options);
458
+ }
459
+
460
+ return new ObjectNode(foldProps);
461
+ }
288
462
 
289
463
  case 'AssignmentNode':
290
464
  /* falls through */
@@ -295,12 +469,6 @@ export var createSimplifyConstant = /* #__PURE__ */factory(name, dependencies, _
295
469
  case 'FunctionAssignmentNode':
296
470
  /* falls through */
297
471
 
298
- case 'IndexNode':
299
- /* falls through */
300
-
301
- case 'ObjectNode':
302
- /* falls through */
303
-
304
472
  case 'RangeNode':
305
473
  /* falls through */
306
474
 
@@ -1,7 +1,7 @@
1
- import { isConstantNode, isFunctionNode, isOperatorNode, isParenthesisNode, isSymbolNode } from '../../../utils/is.js';
1
+ import { isAccessorNode, isArrayNode, isConstantNode, isFunctionNode, isIndexNode, isObjectNode, isOperatorNode, isParenthesisNode, isSymbolNode } from '../../../utils/is.js';
2
2
  import { factory } from '../../../utils/factory.js';
3
3
  var name = 'simplifyCore';
4
- var dependencies = ['equal', 'isZero', 'add', 'subtract', 'multiply', 'divide', 'pow', 'ConstantNode', 'OperatorNode', 'FunctionNode', 'ParenthesisNode'];
4
+ var dependencies = ['equal', 'isZero', 'add', 'subtract', 'multiply', 'divide', 'pow', 'AccessorNode', 'ArrayNode', 'ConstantNode', 'FunctionNode', 'IndexNode', 'ObjectNode', 'OperatorNode', 'ParenthesisNode'];
5
5
  export var createSimplifyCore = /* #__PURE__ */factory(name, dependencies, _ref => {
6
6
  var {
7
7
  equal,
@@ -11,13 +11,23 @@ export var createSimplifyCore = /* #__PURE__ */factory(name, dependencies, _ref
11
11
  multiply,
12
12
  divide,
13
13
  pow,
14
+ AccessorNode,
15
+ ArrayNode,
14
16
  ConstantNode,
15
- OperatorNode,
16
17
  FunctionNode,
18
+ IndexNode,
19
+ ObjectNode,
20
+ OperatorNode,
17
21
  ParenthesisNode
18
22
  } = _ref;
19
23
  var node0 = new ConstantNode(0);
20
24
  var node1 = new ConstantNode(1);
25
+
26
+ function mapSimplifyCore(nodeArray) {
27
+ return nodeArray.map(simplifyCore).map(function (arg) {
28
+ return isParenthesisNode(arg) ? arg.content : arg;
29
+ });
30
+ }
21
31
  /**
22
32
  * simplifyCore() performs single pass simplification suitable for
23
33
  * applications requiring ultimate performance. In contrast, simplify()
@@ -42,6 +52,7 @@ export var createSimplifyCore = /* #__PURE__ */factory(name, dependencies, _ref
42
52
  * The expression to be simplified
43
53
  */
44
54
 
55
+
45
56
  function simplifyCore(node) {
46
57
  if (isOperatorNode(node) && node.isUnary()) {
47
58
  var a0 = simplifyCore(node.args[0]);
@@ -177,10 +188,27 @@ export var createSimplifyCore = /* #__PURE__ */factory(name, dependencies, _ref
177
188
 
178
189
  return new ParenthesisNode(c);
179
190
  } else if (isFunctionNode(node)) {
180
- var args = node.args.map(simplifyCore).map(function (arg) {
181
- return isParenthesisNode(arg) ? arg.content : arg;
182
- });
183
- return new FunctionNode(simplifyCore(node.fn), args);
191
+ return new FunctionNode(simplifyCore(node.fn), mapSimplifyCore(node.args));
192
+ } else if (isArrayNode(node)) {
193
+ return new ArrayNode(mapSimplifyCore(node.items));
194
+ } else if (isAccessorNode(node)) {
195
+ var obj = mapSimplifyCore(node.object);
196
+
197
+ if (isParenthesisNode(obj)) {
198
+ obj = obj.content;
199
+ }
200
+
201
+ return new AccessorNode(obj, simplifyCore(node.index));
202
+ } else if (isIndexNode(node)) {
203
+ return new IndexNode(mapSimplifyCore(node.dimensions));
204
+ } else if (isObjectNode(node)) {
205
+ var newProps = {};
206
+
207
+ for (var prop in node.properties) {
208
+ newProps[prop] = simplifyCore(node.properties[prop]);
209
+ }
210
+
211
+ return new ObjectNode(newProps);
184
212
  } else {// cannot simplify
185
213
  }
186
214