mathjs 14.0.0 → 14.0.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.
- package/HISTORY.md +6 -0
- package/lib/browser/math.js +1 -1
- package/lib/browser/math.js.LICENSE.txt +2 -2
- package/lib/browser/math.js.map +1 -1
- package/lib/cjs/function/algebra/derivative.js +64 -77
- package/lib/cjs/header.js +2 -2
- package/lib/cjs/version.js +1 -1
- package/lib/esm/function/algebra/derivative.js +64 -77
- package/lib/esm/version.js +1 -1
- package/package.json +12 -12
- package/types/index.d.ts +5 -8
@@ -66,9 +66,18 @@ const createDerivative = exports.createDerivative = /* #__PURE__ */(0, _factory.
|
|
66
66
|
let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
|
67
67
|
simplify: true
|
68
68
|
};
|
69
|
-
const
|
70
|
-
|
71
|
-
|
69
|
+
const cache = new Map();
|
70
|
+
const variableName = variable.name;
|
71
|
+
function isConstCached(node) {
|
72
|
+
const cached = cache.get(node);
|
73
|
+
if (cached !== undefined) {
|
74
|
+
return cached;
|
75
|
+
}
|
76
|
+
const res = _isConst(isConstCached, node, variableName);
|
77
|
+
cache.set(node, res);
|
78
|
+
return res;
|
79
|
+
}
|
80
|
+
const res = _derivative(expr, isConstCached);
|
72
81
|
return options.simplify ? simplify(res) : res;
|
73
82
|
}
|
74
83
|
function parseIdentifier(string) {
|
@@ -88,9 +97,8 @@ const createDerivative = exports.createDerivative = /* #__PURE__ */(0, _factory.
|
|
88
97
|
'Node, SymbolNode, ConstantNode': function (expr, variable, {order}) {
|
89
98
|
let res = expr
|
90
99
|
for (let i = 0; i < order; i++) {
|
91
|
-
|
92
|
-
|
93
|
-
res = _derivative(res, constNodes)
|
100
|
+
<create caching isConst>
|
101
|
+
res = _derivative(res, isConst)
|
94
102
|
}
|
95
103
|
return res
|
96
104
|
}
|
@@ -133,56 +141,39 @@ const createDerivative = exports.createDerivative = /* #__PURE__ */(0, _factory.
|
|
133
141
|
});
|
134
142
|
|
135
143
|
/**
|
136
|
-
*
|
137
|
-
*
|
138
|
-
*
|
144
|
+
* Checks if a node is constants (e.g. 2 + 2).
|
145
|
+
* Accepts (usually memoized) version of self as the first parameter for recursive calls.
|
146
|
+
* Classification is done as follows:
|
139
147
|
*
|
140
148
|
* 1. ConstantNodes are constants.
|
141
149
|
* 2. If there exists a SymbolNode, of which we are differentiating over,
|
142
150
|
* in the subtree it is not constant.
|
143
151
|
*
|
144
|
-
* @param {
|
152
|
+
* @param {function} isConst Function that tells whether sub-expression is a constant
|
145
153
|
* @param {ConstantNode | SymbolNode | ParenthesisNode | FunctionNode | OperatorNode} node
|
146
154
|
* @param {string} varName Variable that we are differentiating
|
147
155
|
* @return {boolean} if node is constant
|
148
156
|
*/
|
149
|
-
|
150
|
-
|
151
|
-
'Object, ConstantNode, string': function (constNodes, node) {
|
152
|
-
constNodes[node] = true;
|
157
|
+
const _isConst = typed('_isConst', {
|
158
|
+
'function, ConstantNode, string': function () {
|
153
159
|
return true;
|
154
160
|
},
|
155
|
-
'
|
161
|
+
'function, SymbolNode, string': function (isConst, node, varName) {
|
156
162
|
// Treat other variables like constants. For reasoning, see:
|
157
163
|
// https://en.wikipedia.org/wiki/Partial_derivative
|
158
|
-
|
159
|
-
constNodes[node] = true;
|
160
|
-
return true;
|
161
|
-
}
|
162
|
-
return false;
|
164
|
+
return node.name !== varName;
|
163
165
|
},
|
164
|
-
'
|
165
|
-
return
|
166
|
+
'function, ParenthesisNode, string': function (isConst, node, varName) {
|
167
|
+
return isConst(node.content, varName);
|
166
168
|
},
|
167
|
-
'
|
169
|
+
'function, FunctionAssignmentNode, string': function (isConst, node, varName) {
|
168
170
|
if (!node.params.includes(varName)) {
|
169
|
-
constNodes[node] = true;
|
170
171
|
return true;
|
171
172
|
}
|
172
|
-
return
|
173
|
+
return isConst(node.expr, varName);
|
173
174
|
},
|
174
|
-
'
|
175
|
-
|
176
|
-
let isConst = constTag(constNodes, node.args[0], varName);
|
177
|
-
for (let i = 1; i < node.args.length; ++i) {
|
178
|
-
isConst = constTag(constNodes, node.args[i], varName) && isConst;
|
179
|
-
}
|
180
|
-
if (isConst) {
|
181
|
-
constNodes[node] = true;
|
182
|
-
return true;
|
183
|
-
}
|
184
|
-
}
|
185
|
-
return false;
|
175
|
+
'function, FunctionNode | OperatorNode, string': function (isConst, node, varName) {
|
176
|
+
return node.args.every(arg => isConst(arg, varName));
|
186
177
|
}
|
187
178
|
});
|
188
179
|
|
@@ -190,30 +181,30 @@ const createDerivative = exports.createDerivative = /* #__PURE__ */(0, _factory.
|
|
190
181
|
* Applies differentiation rules.
|
191
182
|
*
|
192
183
|
* @param {ConstantNode | SymbolNode | ParenthesisNode | FunctionNode | OperatorNode} node
|
193
|
-
* @param {
|
184
|
+
* @param {function} isConst Function that tells if a node is constant
|
194
185
|
* @return {ConstantNode | SymbolNode | ParenthesisNode | FunctionNode | OperatorNode} The derivative of `expr`
|
195
186
|
*/
|
196
187
|
const _derivative = typed('_derivative', {
|
197
|
-
'ConstantNode,
|
188
|
+
'ConstantNode, function': function () {
|
198
189
|
return createConstantNode(0);
|
199
190
|
},
|
200
|
-
'SymbolNode,
|
201
|
-
if (
|
191
|
+
'SymbolNode, function': function (node, isConst) {
|
192
|
+
if (isConst(node)) {
|
202
193
|
return createConstantNode(0);
|
203
194
|
}
|
204
195
|
return createConstantNode(1);
|
205
196
|
},
|
206
|
-
'ParenthesisNode,
|
207
|
-
return new ParenthesisNode(_derivative(node.content,
|
197
|
+
'ParenthesisNode, function': function (node, isConst) {
|
198
|
+
return new ParenthesisNode(_derivative(node.content, isConst));
|
208
199
|
},
|
209
|
-
'FunctionAssignmentNode,
|
210
|
-
if (
|
200
|
+
'FunctionAssignmentNode, function': function (node, isConst) {
|
201
|
+
if (isConst(node)) {
|
211
202
|
return createConstantNode(0);
|
212
203
|
}
|
213
|
-
return _derivative(node.expr,
|
204
|
+
return _derivative(node.expr, isConst);
|
214
205
|
},
|
215
|
-
'FunctionNode,
|
216
|
-
if (
|
206
|
+
'FunctionNode, function': function (node, isConst) {
|
207
|
+
if (isConst(node)) {
|
217
208
|
return createConstantNode(0);
|
218
209
|
}
|
219
210
|
const arg0 = node.args[0];
|
@@ -237,10 +228,7 @@ const createDerivative = exports.createDerivative = /* #__PURE__ */(0, _factory.
|
|
237
228
|
} else if (node.args.length === 2) {
|
238
229
|
// Rearrange from nthRoot(x, a) -> x^(1/a)
|
239
230
|
arg1 = new OperatorNode('/', 'divide', [createConstantNode(1), node.args[1]]);
|
240
|
-
|
241
|
-
// Is a variable?
|
242
|
-
constNodes[arg1] = constNodes[node.args[1]];
|
243
|
-
return _derivative(new OperatorNode('^', 'pow', [arg0, arg1]), constNodes);
|
231
|
+
return _derivative(new OperatorNode('^', 'pow', [arg0, arg1]), isConst);
|
244
232
|
}
|
245
233
|
break;
|
246
234
|
case 'log10':
|
@@ -251,20 +239,19 @@ const createDerivative = exports.createDerivative = /* #__PURE__ */(0, _factory.
|
|
251
239
|
// d/dx(log(x)) = 1 / x
|
252
240
|
funcDerivative = arg0.clone();
|
253
241
|
div = true;
|
254
|
-
} else if (node.args.length === 1 && arg1 || node.args.length === 2 &&
|
242
|
+
} else if (node.args.length === 1 && arg1 || node.args.length === 2 && isConst(node.args[1])) {
|
255
243
|
// d/dx(log(x, c)) = 1 / (x*ln(c))
|
256
244
|
funcDerivative = new OperatorNode('*', 'multiply', [arg0.clone(), new FunctionNode('log', [arg1 || node.args[1]])]);
|
257
245
|
div = true;
|
258
246
|
} else if (node.args.length === 2) {
|
259
247
|
// d/dx(log(f(x), g(x))) = d/dx(log(f(x)) / log(g(x)))
|
260
|
-
return _derivative(new OperatorNode('/', 'divide', [new FunctionNode('log', [arg0]), new FunctionNode('log', [node.args[1]])]),
|
248
|
+
return _derivative(new OperatorNode('/', 'divide', [new FunctionNode('log', [arg0]), new FunctionNode('log', [node.args[1]])]), isConst);
|
261
249
|
}
|
262
250
|
break;
|
263
251
|
case 'pow':
|
264
252
|
if (node.args.length === 2) {
|
265
|
-
constNodes[arg1] = constNodes[node.args[1]];
|
266
253
|
// Pass to pow operator node parser
|
267
|
-
return _derivative(new OperatorNode('^', 'pow', [arg0, node.args[1]]),
|
254
|
+
return _derivative(new OperatorNode('^', 'pow', [arg0, node.args[1]]), isConst);
|
268
255
|
}
|
269
256
|
break;
|
270
257
|
case 'exp':
|
@@ -410,51 +397,51 @@ const createDerivative = exports.createDerivative = /* #__PURE__ */(0, _factory.
|
|
410
397
|
/* Apply chain rule to all functions:
|
411
398
|
F(x) = f(g(x))
|
412
399
|
F'(x) = g'(x)*f'(g(x)) */
|
413
|
-
let chainDerivative = _derivative(arg0,
|
400
|
+
let chainDerivative = _derivative(arg0, isConst);
|
414
401
|
if (negative) {
|
415
402
|
chainDerivative = new OperatorNode('-', 'unaryMinus', [chainDerivative]);
|
416
403
|
}
|
417
404
|
return new OperatorNode(op, func, [chainDerivative, funcDerivative]);
|
418
405
|
},
|
419
|
-
'OperatorNode,
|
420
|
-
if (
|
406
|
+
'OperatorNode, function': function (node, isConst) {
|
407
|
+
if (isConst(node)) {
|
421
408
|
return createConstantNode(0);
|
422
409
|
}
|
423
410
|
if (node.op === '+') {
|
424
411
|
// d/dx(sum(f(x)) = sum(f'(x))
|
425
412
|
return new OperatorNode(node.op, node.fn, node.args.map(function (arg) {
|
426
|
-
return _derivative(arg,
|
413
|
+
return _derivative(arg, isConst);
|
427
414
|
}));
|
428
415
|
}
|
429
416
|
if (node.op === '-') {
|
430
417
|
// d/dx(+/-f(x)) = +/-f'(x)
|
431
418
|
if (node.isUnary()) {
|
432
|
-
return new OperatorNode(node.op, node.fn, [_derivative(node.args[0],
|
419
|
+
return new OperatorNode(node.op, node.fn, [_derivative(node.args[0], isConst)]);
|
433
420
|
}
|
434
421
|
|
435
422
|
// Linearity of differentiation, d/dx(f(x) +/- g(x)) = f'(x) +/- g'(x)
|
436
423
|
if (node.isBinary()) {
|
437
|
-
return new OperatorNode(node.op, node.fn, [_derivative(node.args[0],
|
424
|
+
return new OperatorNode(node.op, node.fn, [_derivative(node.args[0], isConst), _derivative(node.args[1], isConst)]);
|
438
425
|
}
|
439
426
|
}
|
440
427
|
if (node.op === '*') {
|
441
428
|
// d/dx(c*f(x)) = c*f'(x)
|
442
429
|
const constantTerms = node.args.filter(function (arg) {
|
443
|
-
return
|
430
|
+
return isConst(arg);
|
444
431
|
});
|
445
432
|
if (constantTerms.length > 0) {
|
446
433
|
const nonConstantTerms = node.args.filter(function (arg) {
|
447
|
-
return
|
434
|
+
return !isConst(arg);
|
448
435
|
});
|
449
436
|
const nonConstantNode = nonConstantTerms.length === 1 ? nonConstantTerms[0] : new OperatorNode('*', 'multiply', nonConstantTerms);
|
450
|
-
const newArgs = constantTerms.concat(_derivative(nonConstantNode,
|
437
|
+
const newArgs = constantTerms.concat(_derivative(nonConstantNode, isConst));
|
451
438
|
return new OperatorNode('*', 'multiply', newArgs);
|
452
439
|
}
|
453
440
|
|
454
441
|
// Product Rule, d/dx(f(x)*g(x)) = f'(x)*g(x) + f(x)*g'(x)
|
455
442
|
return new OperatorNode('+', 'add', node.args.map(function (argOuter) {
|
456
443
|
return new OperatorNode('*', 'multiply', node.args.map(function (argInner) {
|
457
|
-
return argInner === argOuter ? _derivative(argInner,
|
444
|
+
return argInner === argOuter ? _derivative(argInner, isConst) : argInner.clone();
|
458
445
|
}));
|
459
446
|
}));
|
460
447
|
}
|
@@ -463,31 +450,31 @@ const createDerivative = exports.createDerivative = /* #__PURE__ */(0, _factory.
|
|
463
450
|
const arg1 = node.args[1];
|
464
451
|
|
465
452
|
// d/dx(f(x) / c) = f'(x) / c
|
466
|
-
if (
|
467
|
-
return new OperatorNode('/', 'divide', [_derivative(arg0,
|
453
|
+
if (isConst(arg1)) {
|
454
|
+
return new OperatorNode('/', 'divide', [_derivative(arg0, isConst), arg1]);
|
468
455
|
}
|
469
456
|
|
470
457
|
// Reciprocal Rule, d/dx(c / f(x)) = -c(f'(x)/f(x)^2)
|
471
|
-
if (
|
472
|
-
return new OperatorNode('*', 'multiply', [new OperatorNode('-', 'unaryMinus', [arg0]), new OperatorNode('/', 'divide', [_derivative(arg1,
|
458
|
+
if (isConst(arg0)) {
|
459
|
+
return new OperatorNode('*', 'multiply', [new OperatorNode('-', 'unaryMinus', [arg0]), new OperatorNode('/', 'divide', [_derivative(arg1, isConst), new OperatorNode('^', 'pow', [arg1.clone(), createConstantNode(2)])])]);
|
473
460
|
}
|
474
461
|
|
475
462
|
// Quotient rule, d/dx(f(x) / g(x)) = (f'(x)g(x) - f(x)g'(x)) / g(x)^2
|
476
|
-
return new OperatorNode('/', 'divide', [new OperatorNode('-', 'subtract', [new OperatorNode('*', 'multiply', [_derivative(arg0,
|
463
|
+
return new OperatorNode('/', 'divide', [new OperatorNode('-', 'subtract', [new OperatorNode('*', 'multiply', [_derivative(arg0, isConst), arg1.clone()]), new OperatorNode('*', 'multiply', [arg0.clone(), _derivative(arg1, isConst)])]), new OperatorNode('^', 'pow', [arg1.clone(), createConstantNode(2)])]);
|
477
464
|
}
|
478
465
|
if (node.op === '^' && node.isBinary()) {
|
479
466
|
const arg0 = node.args[0];
|
480
467
|
const arg1 = node.args[1];
|
481
|
-
if (
|
468
|
+
if (isConst(arg0)) {
|
482
469
|
// If is secretly constant; 0^f(x) = 1 (in JS), 1^f(x) = 1
|
483
470
|
if ((0, _is.isConstantNode)(arg0) && (isZero(arg0.value) || equal(arg0.value, 1))) {
|
484
471
|
return createConstantNode(0);
|
485
472
|
}
|
486
473
|
|
487
474
|
// d/dx(c^f(x)) = c^f(x)*ln(c)*f'(x)
|
488
|
-
return new OperatorNode('*', 'multiply', [node, new OperatorNode('*', 'multiply', [new FunctionNode('log', [arg0.clone()]), _derivative(arg1.clone(),
|
475
|
+
return new OperatorNode('*', 'multiply', [node, new OperatorNode('*', 'multiply', [new FunctionNode('log', [arg0.clone()]), _derivative(arg1.clone(), isConst)])]);
|
489
476
|
}
|
490
|
-
if (
|
477
|
+
if (isConst(arg1)) {
|
491
478
|
if ((0, _is.isConstantNode)(arg1)) {
|
492
479
|
// If is secretly constant; f(x)^0 = 1 -> d/dx(1) = 0
|
493
480
|
if (isZero(arg1.value)) {
|
@@ -495,17 +482,17 @@ const createDerivative = exports.createDerivative = /* #__PURE__ */(0, _factory.
|
|
495
482
|
}
|
496
483
|
// Ignore exponent; f(x)^1 = f(x)
|
497
484
|
if (equal(arg1.value, 1)) {
|
498
|
-
return _derivative(arg0,
|
485
|
+
return _derivative(arg0, isConst);
|
499
486
|
}
|
500
487
|
}
|
501
488
|
|
502
489
|
// Elementary Power Rule, d/dx(f(x)^c) = c*f'(x)*f(x)^(c-1)
|
503
490
|
const powMinusOne = new OperatorNode('^', 'pow', [arg0.clone(), new OperatorNode('-', 'subtract', [arg1, createConstantNode(1)])]);
|
504
|
-
return new OperatorNode('*', 'multiply', [arg1.clone(), new OperatorNode('*', 'multiply', [_derivative(arg0,
|
491
|
+
return new OperatorNode('*', 'multiply', [arg1.clone(), new OperatorNode('*', 'multiply', [_derivative(arg0, isConst), powMinusOne])]);
|
505
492
|
}
|
506
493
|
|
507
494
|
// Functional Power Rule, d/dx(f^g) = f^g*[f'*(g/f) + g'ln(f)]
|
508
|
-
return new OperatorNode('*', 'multiply', [new OperatorNode('^', 'pow', [arg0.clone(), arg1.clone()]), new OperatorNode('+', 'add', [new OperatorNode('*', 'multiply', [_derivative(arg0,
|
495
|
+
return new OperatorNode('*', 'multiply', [new OperatorNode('^', 'pow', [arg0.clone(), arg1.clone()]), new OperatorNode('+', 'add', [new OperatorNode('*', 'multiply', [_derivative(arg0, isConst), new OperatorNode('/', 'divide', [arg1.clone(), arg0.clone()])]), new OperatorNode('*', 'multiply', [_derivative(arg1, isConst), new FunctionNode('log', [arg0.clone()])])])]);
|
509
496
|
}
|
510
497
|
throw new Error('Cannot process operator "' + node.op + '" in derivative: ' + 'the operator is not supported, undefined, or the number of arguments passed to it are not supported');
|
511
498
|
}
|
package/lib/cjs/header.js
CHANGED
@@ -6,8 +6,8 @@
|
|
6
6
|
* It features real and complex numbers, units, matrices, a large set of
|
7
7
|
* mathematical functions, and a flexible expression parser.
|
8
8
|
*
|
9
|
-
* @version 14.0.
|
10
|
-
* @date 2024-11
|
9
|
+
* @version 14.0.1
|
10
|
+
* @date 2024-12-11
|
11
11
|
*
|
12
12
|
* @license
|
13
13
|
* Copyright (C) 2013-2024 Jos de Jong <wjosdejong@gmail.com>
|
package/lib/cjs/version.js
CHANGED
@@ -4,6 +4,6 @@ Object.defineProperty(exports, "__esModule", {
|
|
4
4
|
value: true
|
5
5
|
});
|
6
6
|
exports.version = void 0;
|
7
|
-
const version = exports.version = '14.0.
|
7
|
+
const version = exports.version = '14.0.1';
|
8
8
|
// Note: This file is automatically generated when building math.js.
|
9
9
|
// Changes made in this file will be overwritten.
|
@@ -60,9 +60,18 @@ export var createDerivative = /* #__PURE__ */factory(name, dependencies, _ref =>
|
|
60
60
|
var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
|
61
61
|
simplify: true
|
62
62
|
};
|
63
|
-
var
|
64
|
-
|
65
|
-
|
63
|
+
var cache = new Map();
|
64
|
+
var variableName = variable.name;
|
65
|
+
function isConstCached(node) {
|
66
|
+
var cached = cache.get(node);
|
67
|
+
if (cached !== undefined) {
|
68
|
+
return cached;
|
69
|
+
}
|
70
|
+
var res = _isConst(isConstCached, node, variableName);
|
71
|
+
cache.set(node, res);
|
72
|
+
return res;
|
73
|
+
}
|
74
|
+
var res = _derivative(expr, isConstCached);
|
66
75
|
return options.simplify ? simplify(res) : res;
|
67
76
|
}
|
68
77
|
function parseIdentifier(string) {
|
@@ -82,9 +91,8 @@ export var createDerivative = /* #__PURE__ */factory(name, dependencies, _ref =>
|
|
82
91
|
'Node, SymbolNode, ConstantNode': function (expr, variable, {order}) {
|
83
92
|
let res = expr
|
84
93
|
for (let i = 0; i < order; i++) {
|
85
|
-
|
86
|
-
|
87
|
-
res = _derivative(res, constNodes)
|
94
|
+
<create caching isConst>
|
95
|
+
res = _derivative(res, isConst)
|
88
96
|
}
|
89
97
|
return res
|
90
98
|
}
|
@@ -127,56 +135,39 @@ export var createDerivative = /* #__PURE__ */factory(name, dependencies, _ref =>
|
|
127
135
|
});
|
128
136
|
|
129
137
|
/**
|
130
|
-
*
|
131
|
-
*
|
132
|
-
*
|
138
|
+
* Checks if a node is constants (e.g. 2 + 2).
|
139
|
+
* Accepts (usually memoized) version of self as the first parameter for recursive calls.
|
140
|
+
* Classification is done as follows:
|
133
141
|
*
|
134
142
|
* 1. ConstantNodes are constants.
|
135
143
|
* 2. If there exists a SymbolNode, of which we are differentiating over,
|
136
144
|
* in the subtree it is not constant.
|
137
145
|
*
|
138
|
-
* @param {
|
146
|
+
* @param {function} isConst Function that tells whether sub-expression is a constant
|
139
147
|
* @param {ConstantNode | SymbolNode | ParenthesisNode | FunctionNode | OperatorNode} node
|
140
148
|
* @param {string} varName Variable that we are differentiating
|
141
149
|
* @return {boolean} if node is constant
|
142
150
|
*/
|
143
|
-
|
144
|
-
|
145
|
-
'Object, ConstantNode, string': function Object_ConstantNode_string(constNodes, node) {
|
146
|
-
constNodes[node] = true;
|
151
|
+
var _isConst = typed('_isConst', {
|
152
|
+
'function, ConstantNode, string': function function_ConstantNode_string() {
|
147
153
|
return true;
|
148
154
|
},
|
149
|
-
'
|
155
|
+
'function, SymbolNode, string': function function_SymbolNode_string(isConst, node, varName) {
|
150
156
|
// Treat other variables like constants. For reasoning, see:
|
151
157
|
// https://en.wikipedia.org/wiki/Partial_derivative
|
152
|
-
|
153
|
-
constNodes[node] = true;
|
154
|
-
return true;
|
155
|
-
}
|
156
|
-
return false;
|
158
|
+
return node.name !== varName;
|
157
159
|
},
|
158
|
-
'
|
159
|
-
return
|
160
|
+
'function, ParenthesisNode, string': function function_ParenthesisNode_string(isConst, node, varName) {
|
161
|
+
return isConst(node.content, varName);
|
160
162
|
},
|
161
|
-
'
|
163
|
+
'function, FunctionAssignmentNode, string': function function_FunctionAssignmentNode_string(isConst, node, varName) {
|
162
164
|
if (!node.params.includes(varName)) {
|
163
|
-
constNodes[node] = true;
|
164
165
|
return true;
|
165
166
|
}
|
166
|
-
return
|
167
|
+
return isConst(node.expr, varName);
|
167
168
|
},
|
168
|
-
'
|
169
|
-
|
170
|
-
var isConst = constTag(constNodes, node.args[0], varName);
|
171
|
-
for (var i = 1; i < node.args.length; ++i) {
|
172
|
-
isConst = constTag(constNodes, node.args[i], varName) && isConst;
|
173
|
-
}
|
174
|
-
if (isConst) {
|
175
|
-
constNodes[node] = true;
|
176
|
-
return true;
|
177
|
-
}
|
178
|
-
}
|
179
|
-
return false;
|
169
|
+
'function, FunctionNode | OperatorNode, string': function function_FunctionNode__OperatorNode_string(isConst, node, varName) {
|
170
|
+
return node.args.every(arg => isConst(arg, varName));
|
180
171
|
}
|
181
172
|
});
|
182
173
|
|
@@ -184,30 +175,30 @@ export var createDerivative = /* #__PURE__ */factory(name, dependencies, _ref =>
|
|
184
175
|
* Applies differentiation rules.
|
185
176
|
*
|
186
177
|
* @param {ConstantNode | SymbolNode | ParenthesisNode | FunctionNode | OperatorNode} node
|
187
|
-
* @param {
|
178
|
+
* @param {function} isConst Function that tells if a node is constant
|
188
179
|
* @return {ConstantNode | SymbolNode | ParenthesisNode | FunctionNode | OperatorNode} The derivative of `expr`
|
189
180
|
*/
|
190
181
|
var _derivative = typed('_derivative', {
|
191
|
-
'ConstantNode,
|
182
|
+
'ConstantNode, function': function ConstantNode_function() {
|
192
183
|
return createConstantNode(0);
|
193
184
|
},
|
194
|
-
'SymbolNode,
|
195
|
-
if (
|
185
|
+
'SymbolNode, function': function SymbolNode_function(node, isConst) {
|
186
|
+
if (isConst(node)) {
|
196
187
|
return createConstantNode(0);
|
197
188
|
}
|
198
189
|
return createConstantNode(1);
|
199
190
|
},
|
200
|
-
'ParenthesisNode,
|
201
|
-
return new ParenthesisNode(_derivative(node.content,
|
191
|
+
'ParenthesisNode, function': function ParenthesisNode_function(node, isConst) {
|
192
|
+
return new ParenthesisNode(_derivative(node.content, isConst));
|
202
193
|
},
|
203
|
-
'FunctionAssignmentNode,
|
204
|
-
if (
|
194
|
+
'FunctionAssignmentNode, function': function FunctionAssignmentNode_function(node, isConst) {
|
195
|
+
if (isConst(node)) {
|
205
196
|
return createConstantNode(0);
|
206
197
|
}
|
207
|
-
return _derivative(node.expr,
|
198
|
+
return _derivative(node.expr, isConst);
|
208
199
|
},
|
209
|
-
'FunctionNode,
|
210
|
-
if (
|
200
|
+
'FunctionNode, function': function FunctionNode_function(node, isConst) {
|
201
|
+
if (isConst(node)) {
|
211
202
|
return createConstantNode(0);
|
212
203
|
}
|
213
204
|
var arg0 = node.args[0];
|
@@ -231,10 +222,7 @@ export var createDerivative = /* #__PURE__ */factory(name, dependencies, _ref =>
|
|
231
222
|
} else if (node.args.length === 2) {
|
232
223
|
// Rearrange from nthRoot(x, a) -> x^(1/a)
|
233
224
|
arg1 = new OperatorNode('/', 'divide', [createConstantNode(1), node.args[1]]);
|
234
|
-
|
235
|
-
// Is a variable?
|
236
|
-
constNodes[arg1] = constNodes[node.args[1]];
|
237
|
-
return _derivative(new OperatorNode('^', 'pow', [arg0, arg1]), constNodes);
|
225
|
+
return _derivative(new OperatorNode('^', 'pow', [arg0, arg1]), isConst);
|
238
226
|
}
|
239
227
|
break;
|
240
228
|
case 'log10':
|
@@ -245,20 +233,19 @@ export var createDerivative = /* #__PURE__ */factory(name, dependencies, _ref =>
|
|
245
233
|
// d/dx(log(x)) = 1 / x
|
246
234
|
funcDerivative = arg0.clone();
|
247
235
|
div = true;
|
248
|
-
} else if (node.args.length === 1 && arg1 || node.args.length === 2 &&
|
236
|
+
} else if (node.args.length === 1 && arg1 || node.args.length === 2 && isConst(node.args[1])) {
|
249
237
|
// d/dx(log(x, c)) = 1 / (x*ln(c))
|
250
238
|
funcDerivative = new OperatorNode('*', 'multiply', [arg0.clone(), new FunctionNode('log', [arg1 || node.args[1]])]);
|
251
239
|
div = true;
|
252
240
|
} else if (node.args.length === 2) {
|
253
241
|
// d/dx(log(f(x), g(x))) = d/dx(log(f(x)) / log(g(x)))
|
254
|
-
return _derivative(new OperatorNode('/', 'divide', [new FunctionNode('log', [arg0]), new FunctionNode('log', [node.args[1]])]),
|
242
|
+
return _derivative(new OperatorNode('/', 'divide', [new FunctionNode('log', [arg0]), new FunctionNode('log', [node.args[1]])]), isConst);
|
255
243
|
}
|
256
244
|
break;
|
257
245
|
case 'pow':
|
258
246
|
if (node.args.length === 2) {
|
259
|
-
constNodes[arg1] = constNodes[node.args[1]];
|
260
247
|
// Pass to pow operator node parser
|
261
|
-
return _derivative(new OperatorNode('^', 'pow', [arg0, node.args[1]]),
|
248
|
+
return _derivative(new OperatorNode('^', 'pow', [arg0, node.args[1]]), isConst);
|
262
249
|
}
|
263
250
|
break;
|
264
251
|
case 'exp':
|
@@ -404,51 +391,51 @@ export var createDerivative = /* #__PURE__ */factory(name, dependencies, _ref =>
|
|
404
391
|
/* Apply chain rule to all functions:
|
405
392
|
F(x) = f(g(x))
|
406
393
|
F'(x) = g'(x)*f'(g(x)) */
|
407
|
-
var chainDerivative = _derivative(arg0,
|
394
|
+
var chainDerivative = _derivative(arg0, isConst);
|
408
395
|
if (negative) {
|
409
396
|
chainDerivative = new OperatorNode('-', 'unaryMinus', [chainDerivative]);
|
410
397
|
}
|
411
398
|
return new OperatorNode(op, func, [chainDerivative, funcDerivative]);
|
412
399
|
},
|
413
|
-
'OperatorNode,
|
414
|
-
if (
|
400
|
+
'OperatorNode, function': function OperatorNode_function(node, isConst) {
|
401
|
+
if (isConst(node)) {
|
415
402
|
return createConstantNode(0);
|
416
403
|
}
|
417
404
|
if (node.op === '+') {
|
418
405
|
// d/dx(sum(f(x)) = sum(f'(x))
|
419
406
|
return new OperatorNode(node.op, node.fn, node.args.map(function (arg) {
|
420
|
-
return _derivative(arg,
|
407
|
+
return _derivative(arg, isConst);
|
421
408
|
}));
|
422
409
|
}
|
423
410
|
if (node.op === '-') {
|
424
411
|
// d/dx(+/-f(x)) = +/-f'(x)
|
425
412
|
if (node.isUnary()) {
|
426
|
-
return new OperatorNode(node.op, node.fn, [_derivative(node.args[0],
|
413
|
+
return new OperatorNode(node.op, node.fn, [_derivative(node.args[0], isConst)]);
|
427
414
|
}
|
428
415
|
|
429
416
|
// Linearity of differentiation, d/dx(f(x) +/- g(x)) = f'(x) +/- g'(x)
|
430
417
|
if (node.isBinary()) {
|
431
|
-
return new OperatorNode(node.op, node.fn, [_derivative(node.args[0],
|
418
|
+
return new OperatorNode(node.op, node.fn, [_derivative(node.args[0], isConst), _derivative(node.args[1], isConst)]);
|
432
419
|
}
|
433
420
|
}
|
434
421
|
if (node.op === '*') {
|
435
422
|
// d/dx(c*f(x)) = c*f'(x)
|
436
423
|
var constantTerms = node.args.filter(function (arg) {
|
437
|
-
return
|
424
|
+
return isConst(arg);
|
438
425
|
});
|
439
426
|
if (constantTerms.length > 0) {
|
440
427
|
var nonConstantTerms = node.args.filter(function (arg) {
|
441
|
-
return
|
428
|
+
return !isConst(arg);
|
442
429
|
});
|
443
430
|
var nonConstantNode = nonConstantTerms.length === 1 ? nonConstantTerms[0] : new OperatorNode('*', 'multiply', nonConstantTerms);
|
444
|
-
var newArgs = constantTerms.concat(_derivative(nonConstantNode,
|
431
|
+
var newArgs = constantTerms.concat(_derivative(nonConstantNode, isConst));
|
445
432
|
return new OperatorNode('*', 'multiply', newArgs);
|
446
433
|
}
|
447
434
|
|
448
435
|
// Product Rule, d/dx(f(x)*g(x)) = f'(x)*g(x) + f(x)*g'(x)
|
449
436
|
return new OperatorNode('+', 'add', node.args.map(function (argOuter) {
|
450
437
|
return new OperatorNode('*', 'multiply', node.args.map(function (argInner) {
|
451
|
-
return argInner === argOuter ? _derivative(argInner,
|
438
|
+
return argInner === argOuter ? _derivative(argInner, isConst) : argInner.clone();
|
452
439
|
}));
|
453
440
|
}));
|
454
441
|
}
|
@@ -457,31 +444,31 @@ export var createDerivative = /* #__PURE__ */factory(name, dependencies, _ref =>
|
|
457
444
|
var arg1 = node.args[1];
|
458
445
|
|
459
446
|
// d/dx(f(x) / c) = f'(x) / c
|
460
|
-
if (
|
461
|
-
return new OperatorNode('/', 'divide', [_derivative(arg0,
|
447
|
+
if (isConst(arg1)) {
|
448
|
+
return new OperatorNode('/', 'divide', [_derivative(arg0, isConst), arg1]);
|
462
449
|
}
|
463
450
|
|
464
451
|
// Reciprocal Rule, d/dx(c / f(x)) = -c(f'(x)/f(x)^2)
|
465
|
-
if (
|
466
|
-
return new OperatorNode('*', 'multiply', [new OperatorNode('-', 'unaryMinus', [arg0]), new OperatorNode('/', 'divide', [_derivative(arg1,
|
452
|
+
if (isConst(arg0)) {
|
453
|
+
return new OperatorNode('*', 'multiply', [new OperatorNode('-', 'unaryMinus', [arg0]), new OperatorNode('/', 'divide', [_derivative(arg1, isConst), new OperatorNode('^', 'pow', [arg1.clone(), createConstantNode(2)])])]);
|
467
454
|
}
|
468
455
|
|
469
456
|
// Quotient rule, d/dx(f(x) / g(x)) = (f'(x)g(x) - f(x)g'(x)) / g(x)^2
|
470
|
-
return new OperatorNode('/', 'divide', [new OperatorNode('-', 'subtract', [new OperatorNode('*', 'multiply', [_derivative(arg0,
|
457
|
+
return new OperatorNode('/', 'divide', [new OperatorNode('-', 'subtract', [new OperatorNode('*', 'multiply', [_derivative(arg0, isConst), arg1.clone()]), new OperatorNode('*', 'multiply', [arg0.clone(), _derivative(arg1, isConst)])]), new OperatorNode('^', 'pow', [arg1.clone(), createConstantNode(2)])]);
|
471
458
|
}
|
472
459
|
if (node.op === '^' && node.isBinary()) {
|
473
460
|
var _arg = node.args[0];
|
474
461
|
var _arg2 = node.args[1];
|
475
|
-
if (
|
462
|
+
if (isConst(_arg)) {
|
476
463
|
// If is secretly constant; 0^f(x) = 1 (in JS), 1^f(x) = 1
|
477
464
|
if (isConstantNode(_arg) && (isZero(_arg.value) || equal(_arg.value, 1))) {
|
478
465
|
return createConstantNode(0);
|
479
466
|
}
|
480
467
|
|
481
468
|
// d/dx(c^f(x)) = c^f(x)*ln(c)*f'(x)
|
482
|
-
return new OperatorNode('*', 'multiply', [node, new OperatorNode('*', 'multiply', [new FunctionNode('log', [_arg.clone()]), _derivative(_arg2.clone(),
|
469
|
+
return new OperatorNode('*', 'multiply', [node, new OperatorNode('*', 'multiply', [new FunctionNode('log', [_arg.clone()]), _derivative(_arg2.clone(), isConst)])]);
|
483
470
|
}
|
484
|
-
if (
|
471
|
+
if (isConst(_arg2)) {
|
485
472
|
if (isConstantNode(_arg2)) {
|
486
473
|
// If is secretly constant; f(x)^0 = 1 -> d/dx(1) = 0
|
487
474
|
if (isZero(_arg2.value)) {
|
@@ -489,17 +476,17 @@ export var createDerivative = /* #__PURE__ */factory(name, dependencies, _ref =>
|
|
489
476
|
}
|
490
477
|
// Ignore exponent; f(x)^1 = f(x)
|
491
478
|
if (equal(_arg2.value, 1)) {
|
492
|
-
return _derivative(_arg,
|
479
|
+
return _derivative(_arg, isConst);
|
493
480
|
}
|
494
481
|
}
|
495
482
|
|
496
483
|
// Elementary Power Rule, d/dx(f(x)^c) = c*f'(x)*f(x)^(c-1)
|
497
484
|
var powMinusOne = new OperatorNode('^', 'pow', [_arg.clone(), new OperatorNode('-', 'subtract', [_arg2, createConstantNode(1)])]);
|
498
|
-
return new OperatorNode('*', 'multiply', [_arg2.clone(), new OperatorNode('*', 'multiply', [_derivative(_arg,
|
485
|
+
return new OperatorNode('*', 'multiply', [_arg2.clone(), new OperatorNode('*', 'multiply', [_derivative(_arg, isConst), powMinusOne])]);
|
499
486
|
}
|
500
487
|
|
501
488
|
// Functional Power Rule, d/dx(f^g) = f^g*[f'*(g/f) + g'ln(f)]
|
502
|
-
return new OperatorNode('*', 'multiply', [new OperatorNode('^', 'pow', [_arg.clone(), _arg2.clone()]), new OperatorNode('+', 'add', [new OperatorNode('*', 'multiply', [_derivative(_arg,
|
489
|
+
return new OperatorNode('*', 'multiply', [new OperatorNode('^', 'pow', [_arg.clone(), _arg2.clone()]), new OperatorNode('+', 'add', [new OperatorNode('*', 'multiply', [_derivative(_arg, isConst), new OperatorNode('/', 'divide', [_arg2.clone(), _arg.clone()])]), new OperatorNode('*', 'multiply', [_derivative(_arg2, isConst), new FunctionNode('log', [_arg.clone()])])])]);
|
503
490
|
}
|
504
491
|
throw new Error('Cannot process operator "' + node.op + '" in derivative: ' + 'the operator is not supported, undefined, or the number of arguments passed to it are not supported');
|
505
492
|
}
|
package/lib/esm/version.js
CHANGED