mirror of
https://github.com/josdejong/mathjs.git
synced 2026-01-18 14:59:29 +00:00
59320053fd
* refactor: Remove the automatic conversion from number to string. (#2482) This is a breaking change. However, nothing in the unit tests or examples actually depended on such a conversion, and it's difficult to construct situations in which it's necessary. The best such example is e.g. `count(57)` which formerly gave the number of digits in its numeric argument. Of course, after this commit, that behavior can still be obtained by the just slightly longer expression `count(string(57))` The change is proposed in preparation for an addition of new facilities/ handlers to allow symbolic computation in a couple of different ways (see #2475 and #2470). * feat(simplifyCore): convert equivalent function calls into operators (#2466) * feat(simplifyCore): convert equivalent function calls into operators Resolves #2415. * docs: Every operator has a function form Also documents the new behavior of simplifyCore to convert function calls into any equivalent operator form they may have. Also fixes the syntax errors so that simplifyCore will successfully doctest. * docs: Fix table syntax for operator->function correspondence * fix(parse): Implement amended "Rule 2" As per the discussion in #2370, the amended "Rule 2" is "when having a division followed by an implicit multiplication, the division gets higher precedence over the implicit multiplication when (a) the numerator is a constant with optionally a prefix operator (-, +, ~), and (b) the denominator is a constant." This commit implements that behavior and adds tests for it. Resolves #2370. * fix: OperatorNode.toString() outputs match implicit multiplication parsing Also greatly extends the tests on OperatorNode.toString() and .toTex(), and ensures that all tests are performed on both. (toHTML() is still a testing stepchild.) Also fixes other small bugs in .toString() and .toTex() revealed by the new tests. Resolves #1431. * test(parse): More cases of implicit multiplication * refactor: Alter the precedence of implicit multiplication This greatly simplifies OperatorNode:calculateNecessaryParentheses, as opposed to trying to correct for the change in precedence after the fact. * Fix broken unit test * Replace `options && options.implicit` with `options?.implicit` * Replace `options?.implicit` with `options && options.implicit` again, it breaks the Node 12 tests * chore: Prevent confusion with standard matrix functions. (#2465) * chore: Prevent consfusion with standard matrix functions. Prior to this commit, many functions operated elementwise on matrices even though in standard mathematical usage they have a different meaning on square matrices. Since the elementwise operation is easily recoverable using `math.map`, this commit removes the elementwise operation on arrays and matrices from these functions. Affected functions include all trigonometric functions, exp, log, gamma, square, sqrt, cube, and cbrt. Resolves #2440. * chore(typescript): Revise usages in light of changes sqrt() is now correctly typed as `number | Complex` and so must be explicitly cast to number when called on a positive and used where a Complex is disallowed; sqrt() no longer applies to matrices at all. * feat: Provide better error messages for v10 -> v11 transition Uses new `typed.onMismatch` handler so that matrix calls that used to work will suggest a replacement. * Fix #2412: let function diff return an empty matrix when the input contains only one element (#2422) * Fix #2412: let function diff return an empty matrix when the input has only one element * Undo changes in History in this fixme * Add TypeScript definitions for src/utils/is.js (#2432) This is a first step toward full publication of these functions, that were already being exported by mathjs but had not yet had the associated actions (documentation/available in parser/typed, etc.) Also, makes most of them into TypeScript type guards, and adds Matrix as a constructor type. Resolved #2431. Co-authored-by: Glen Whitney <glen@studioinfinity.org> * test: add two-dimensional test cases for diff of length 1 Co-authored-by: Chris Chudzicki <christopher.chudzicki@gmail.com> Co-authored-by: Glen Whitney <glen@studioinfinity.org> * Refactor/simplify core cleanup (#2490) * refactor: don't simplify constants in simplifyCore Keeps the operation of simplifyCore cleanly separate from simplifyConstant. * fix; handle multiple consecutive operations in simplifyCore() Also adds support for logical operators. Resolves #2484. * feat: export simplifyConstant Now that simplifyCore does not do any constant folding, clients may wish to access that behavior via simplifyConstant. Moreover, exporting it makes it easier to use in custom rule lists for simplify(). Also adds docs, embedded docs, and tests for simplifyConstant(). Also fixes simplifyCore() on logical functions (they always return boolean, rather than "short-circuiting"). Resolves #2459. * refactor: Rename matrix algorithms to stay sane in next refactor * refactor: Create a generator for boilerplate matrix versions of operations This reduces code length and duplication, and significantly reduces the number of instances of 'this' that will require replacement when moving on top of typed-function v3. * refactor: add automatic conversion from string to Node Eliminates many `this` calls in src/function/algebra, which will help conversion to typed-function v3a. Also make `resolve` into a typed function so that it will now work on strings as well, and adds a test that it does. * refactor: Use temporary conversions to simplify typed-function definitions Specifically, temporarily converting Object to Map eases the definition of 'simplify' and a new, generally ignored type 'identifier' (a subtype of 'string') with a temporary conversion to 'SymbolNode' simplifies the definition of 'derivative'. These refactors eliminate multiple instances of this, which will ease conversion to typed-function v3a. * refactor: Speed up utils/is.js typeOf function In preparation for using it as the function selector for the Unit class. Also fixes the inconsistency between the `typed` type hierarchy 'function' and typeOf returning 'Function' in favor of 'function', again to minimize the special cases in typeOf * feat(Unit): Add a method giving the (string name of the) type of the value E.g. `math.unit('5cm').valType()` returns `number`. Also uses this for an internal method that directly gives the number converter for a Unit. Also fixes lint errors from previous commit (not clean, I know, I forgot that build-and-test does not run lint). Adds tests for unit.valType() * refactor: Eliminate hyperbolic functions operating on angles There is no mathematical meaning to a hyperbolic function operating on an angle (the proper units of its argument is actually area), and it eliminates a number of uses of `this`, so remove such arguments. * refactor: Remove miscellaneous unnecessary typed-function this refs * refactor: Adapt to typed-function v3a Mostly this involves replaceing instances of 'this' with used of (preferably) typed.referTo() or typed.referToSelf(). Some repeated batterns of boilerpolate signatures within different divisions of functions (bitwise, relational, trigonometry) were factored out into their own files and reused in several of the individual functions. * tests: Only require that derivative tests mention the proper node type * refactor: remove typed.ignore * chore: Update to typed-function 3.0 Also had to deal with new typing for `resolve()` in that it now accepts strings and Matrices; added tests for the new possibilities for `resolve()`, and eliminated empty comments from the Node representation of parsed strings as they can't really be doing anyone any good and they are a pain for testing. Also updates the TypeScript declarations and tests for `resolve()` * chore: Object.hasOwn not supported in Node 14 Also removes 'resolve' from the known failing doc tests, now that it handles strings. * chore: Drop ES5 / IE 11 support. * fix(types): Remove no-longer-implementd matrix overloads * test(identifier): As requested in review item 2 * refactor(Unit): valType => valueType as per review item 3 * test(hasNumericValue): Test boolean arguments as per review item 4 * refactor(Node): Use class syntax rather than assigning prototypes This change simplifies the typeOf() function, because now all subclasses of Node have the expected constructor name. Also, reformats the documentation of the typeOf() function so that the doc test of that function will serve as an exhaustive test that the bundle returns the proper types. * Prevent chain functions from matching stored value with a rest parameter (#2559) * chore: Prevent confusion with standard matrix functions. (#2465) * chore: Prevent consfusion with standard matrix functions. Prior to this commit, many functions operated elementwise on matrices even though in standard mathematical usage they have a different meaning on square matrices. Since the elementwise operation is easily recoverable using `math.map`, this commit removes the elementwise operation on arrays and matrices from these functions. Affected functions include all trigonometric functions, exp, log, gamma, square, sqrt, cube, and cbrt. Resolves #2440. * chore(typescript): Revise usages in light of changes sqrt() is now correctly typed as `number | Complex` and so must be explicitly cast to number when called on a positive and used where a Complex is disallowed; sqrt() no longer applies to matrices at all. * feat: Provide better error messages for v10 -> v11 transition Uses new `typed.onMismatch` handler so that matrix calls that used to work will suggest a replacement. * fix: prevent chain from matching rest parameter with stored value Since the revised code needs the isTypedFunction predicate, switch to using the typed-function implementation for that throughout mathjs, rather than rolling our own here. Also adds a test that chain() no longer allows this kind of usage. Removes the two type declarations in types/index.d.ts that were allowing this sort of "split rest" call and added tests that such calls are forbidden. Adds to the chaining documentation page that such "split" calls are not allowed. * chore: Refresh this PR to reflect underlying changes Also addresses the review request with a detailed comment on the correctness of a new code section. Note that it reverts some changes to the TypeScript signatures of the matrix functions ones() and zeros() -- they do not actually have a typed-function signature of two numbers and an optional format specifically for two dimensions. What they have is a single rest parameter, from which the format is extracted if present. Hence, due to the ban on breaking rest parameters, it is not valid to call math.chain(3).zeros(2) to make a 3-by-2 matrix of zeros, which seems like a perfectly valid ban as the division of the dimensions is very confusing; this should be written as math.chain([3,2]).zeros(). The TypeScript signatures are fixed accordingly, along with the edge case of no arguments to ones() and zeros() at all, which does work to produce the "empty matrix". * Unit test `typeOf` on the minified bundle (currently failing) * Update AUTHORS * Improve testing of typeOf on browser bundle (WIP) * fix #2621: Module "mathjs" has no exported member "count" .ts(2305) (#2622) * fix #2621: Module "mathjs" has no exported member "count" .ts(2305) * feat: Update comments of count * feat: update the signature for count * feat: add usage example for count and sum * chore: Ensure type info remains in bundling Co-authored-by: Glen Whitney <glen@studioinfinity.org> Co-authored-by: Chris Chudzicki <christopher.chudzicki@gmail.com> Co-authored-by: Hansuku <1556207795@qq.com>
288 lines
16 KiB
JavaScript
288 lines
16 KiB
JavaScript
// test derivative
|
|
import assert from 'assert'
|
|
|
|
import math from '../../../../src/defaultInstance.js'
|
|
const OperatorNode = math.OperatorNode
|
|
const ConstantNode = math.ConstantNode
|
|
const SymbolNode = math.SymbolNode
|
|
const derivative = math.derivative
|
|
|
|
describe('derivative', function () {
|
|
function derivativeWithoutSimplify (expr, value) {
|
|
return math.derivative(expr, value, { simplify: false })
|
|
}
|
|
|
|
function compareString (left, right) {
|
|
assert.strictEqual(left.toString(), right.toString())
|
|
}
|
|
|
|
it('should take the derivative of a constant', function () {
|
|
compareString(derivativeWithoutSimplify('1', 'x'), '0')
|
|
compareString(derivativeWithoutSimplify('10000000', 'x'), '0')
|
|
})
|
|
|
|
it('should reckon with option simplify', function () {
|
|
compareString(derivative('2x', 'x'), '2') // default of simplify is true
|
|
compareString(derivative('2x', 'x', { simplify: true }), '2')
|
|
compareString(derivative('2x', 'x', { simplify: false }), '2 * 1')
|
|
})
|
|
|
|
it('should create a function node', function () {
|
|
compareString(derivative('sin(2x)', 'x'), '2 * cos(2 x)')
|
|
})
|
|
|
|
it('should take the derivative of a SymbolNodes', function () {
|
|
compareString(derivativeWithoutSimplify('x', 'x'), '1')
|
|
})
|
|
|
|
it('should maintain parenthesis of ParenthesisNodes', function () {
|
|
compareString(derivativeWithoutSimplify('(1)', 'x'), '(0)')
|
|
compareString(derivativeWithoutSimplify('(x)', 'x'), '(1)')
|
|
})
|
|
|
|
it('should take the derivative of FunctionAssignmentNodes', function () {
|
|
compareString(derivativeWithoutSimplify('f(x) = 5x + x + 2', 'x'), '5 * 1 + 1 + 0')
|
|
compareString(derivativeWithoutSimplify('f(x) = 5 + 2', 'x'), '0')
|
|
compareString(derivativeWithoutSimplify('f(y) = 5y + 2', 'x'), '0')
|
|
|
|
// non-embedded example
|
|
const f = math.parse('f(x) = x + 2')
|
|
const newFunc = new OperatorNode('+', 'add', [math.parse('5x'), f])
|
|
compareString(derivativeWithoutSimplify(newFunc, 'x'), '5 * 1 + 1 + 0')
|
|
})
|
|
|
|
it('should take the derivative of a OperatorNodes with ConstantNodes', function () {
|
|
compareString(derivativeWithoutSimplify('1 + 2', 'x'), '0')
|
|
compareString(derivativeWithoutSimplify('-100^2 + 3*3/2 - 12', 'x'), '0')
|
|
const threeArgMultiplyConstant = new OperatorNode('*', 'multiply', [math.parse('3'), math.parse('7^4'), math.parse('123.124')])
|
|
compareString(derivativeWithoutSimplify(threeArgMultiplyConstant, 'x'), 0)
|
|
})
|
|
|
|
it('should take the derivative of a OperatorNodes with SymbolNodes', function () {
|
|
// d/dx(-4x) = -4*1 = -4
|
|
compareString(derivativeWithoutSimplify('-4x', 'x'), '-4 * 1')
|
|
// d/dx(+4x) = +4*1 = +4
|
|
compareString(derivativeWithoutSimplify('+4x', 'x'), '+4 * 1')
|
|
|
|
const threeArgMultiplyConstant = new OperatorNode('*', 'multiply', [math.parse('3'), math.parse('x'), math.parse('sin(x)')])
|
|
compareString(derivativeWithoutSimplify(threeArgMultiplyConstant, 'x'), '3 * (1 * sin(x) + x * 1 * cos(x))')
|
|
|
|
// Linearity of differentiation
|
|
// With '+': d/dx(5x + x + 2) = 5*1 + 1 + 0 = 6
|
|
compareString(derivativeWithoutSimplify('5x + x + 2', 'x'), '5 * 1 + 1 + 0')
|
|
// With '-': d/dx(5x - x - 2) = 5*1 - 1 - 0 = 4
|
|
compareString(derivativeWithoutSimplify('5x - x - 2', 'x'), '5 * 1 - 1 - 0')
|
|
|
|
const threeArgAddition = new OperatorNode('+', 'add', [math.parse('x'), math.parse('sin(x)'), math.parse('5x')])
|
|
compareString(derivativeWithoutSimplify(threeArgAddition, 'x'), '1 + 1 * cos(x) + 5 * 1')
|
|
|
|
const threeArgMultiplication = new OperatorNode('*', 'multiply', [math.parse('x'), math.parse('sin(x)'), math.parse('5x')])
|
|
compareString(derivativeWithoutSimplify(threeArgMultiplication, 'x'), '1 * sin(x) * 5 x + x * 1 * cos(x) * 5 x + x * sin(x) * 5 * 1')
|
|
|
|
// d/dx(2*(x + x)) = 2*(1 + 1)
|
|
compareString(derivativeWithoutSimplify('2(x + x)', 'x'), '2 * (1 + 1)')
|
|
compareString(derivativeWithoutSimplify('(x + x)*2', 'x'), '2 * (1 + 1)')
|
|
|
|
// Product Rule, d/dx(5x*3x) = 5 * 1 * 3 x + 5 x * 3 * 1 = 30x
|
|
compareString(derivativeWithoutSimplify('5x*3x', 'x'), '5 * 1 * 3 x + 5 x * 3 * 1')
|
|
|
|
// Basic division, d/dx(7x / 2) = 7 * 1 / 2 = 7 / 2
|
|
compareString(derivativeWithoutSimplify('7x / 2', 'x'), '7 * 1 / 2')
|
|
|
|
// Reciprocal Rule, d/dx(5 / (3x)) = -5 * (3 * 1) / (3 * x) ^ 2 = -5 / 3x^2
|
|
compareString(derivativeWithoutSimplify('5 / (3x)', 'x'), '-5 * (3 * 1) / (3 x) ^ 2')
|
|
|
|
// Quotient rule, d/dx((2x) / (3x + 2)) = ((2*1)(3x + 2) - (2x)(3*1 + 0)) / (3x + 2)^2 = 4 / (3x + 2)^2
|
|
compareString(derivativeWithoutSimplify('(2x) / (3x + 2)', 'x'), '((2 * 1) * (3 x + 2) - (2 x) * (3 * 1 + 0)) / (3 x + 2) ^ 2')
|
|
|
|
// Secret constant; 0^f(x) = 1 (in JS), 1^f(x) = 1, d/dx(1) = 0
|
|
compareString(derivativeWithoutSimplify('0^(2^x + x^3 + 2)', 'x'), '0')
|
|
compareString(derivativeWithoutSimplify('1^(2^x + x^3 + 2)', 'x'), '0')
|
|
// d/dx(10^(2x + 2)) = 10^(2x + 2)*ln(10)*(2*1 + 0)
|
|
compareString(derivativeWithoutSimplify('10^(2x + 2)', 'x'), '10 ^ (2 x + 2) * log(10) * (2 * 1 + 0)')
|
|
|
|
// Secret constant, f(x)^0 = 1 -> d/dx(f(x)^0) = 1
|
|
compareString(derivativeWithoutSimplify('(x^x^x^x)^0', 'x'), '0')
|
|
// Ignore powers of 1, d/dx((x + 2)^1) -> d/dx(x+2) = (1 + 0) = 1
|
|
compareString(derivativeWithoutSimplify('(x+2)^1', 'x'), '(1 + 0)')
|
|
// Elementary Power Rule, d/dx(2x^2) = 2*2*1*x^(2-1) = 4x
|
|
compareString(derivativeWithoutSimplify('2x^2', 'x'), '2 * 2 * 1 * x ^ (2 - 1)')
|
|
|
|
// Elementary Power Rule, d/dx(2x^-2) = 2*-2*1*x^(-2-1) = -4x^-3
|
|
compareString(derivativeWithoutSimplify('2x^-2', 'x'), '2 * -2 * 1 * x ^ (-2 - 1)')
|
|
|
|
// Functional Power Rule, d/dx((x^3 + x)^(5x + 2)) = (x^3 + x)^(5x + 2) * [(((3*1*x)^(3-1)+1) * ((5x + 2) / (x^3 + x))) + (5*1 + 0)log((x^3 + x))]
|
|
// = (x^3 + x)^(5x + 2) * [((3x^2 + 1)*(5x + 2) / (x^3 + x)) + 5log(x^3 + x)]
|
|
compareString(derivativeWithoutSimplify('(x^3 + x)^(5x + 2)', 'x'), '(x ^ 3 + x) ^ (5 x + 2) * ((3 * 1 * x ^ (3 - 1) + 1) * (5 x + 2) / (x ^ 3 + x) + (5 * 1 + 0) * log((x ^ 3 + x)))')
|
|
|
|
// https://github.com/josdejong/mathjs/issues/1063
|
|
compareString(derivativeWithoutSimplify('-x', 'x'), '-1')
|
|
compareString(derivativeWithoutSimplify('1 - (-x)', 'x'), '0 - (-1)')
|
|
})
|
|
|
|
it('should properly take the derivative of mathematical functions', function () {
|
|
compareString(derivativeWithoutSimplify('cbrt(6x)', 'x'), '6 * 1 / (3 * (6 x) ^ (2 / 3))')
|
|
compareString(derivativeWithoutSimplify('sqrt(6x)', 'x'), '6 * 1 / (2 * sqrt(6 x))')
|
|
compareString(derivativeWithoutSimplify('nthRoot(6x)', 'x'), '6 * 1 / (2 * sqrt(6 x))')
|
|
compareString(derivativeWithoutSimplify('nthRoot(6x, 3)', 'x'), '1 / 3 * 6 * 1 * (6 x) ^ (1 / 3 - 1)')
|
|
|
|
compareString(derivativeWithoutSimplify('nthRoot((6x), (2x))', 'x'), '(6 x) ^ (1 / (2 x)) * ((6 * 1) * 1 / (2 x) / (6 x) + (0 * (2 x) - 1 * (2 * 1)) / (2 x) ^ 2 * log((6 x)))')
|
|
compareString(derivativeWithoutSimplify('log((6*x))', 'x'), '(6 * 1) / (6 * x)')
|
|
compareString(derivativeWithoutSimplify('log10((6x))', 'x'), '(6 * 1) / ((6 x) * log(10))')
|
|
compareString(derivativeWithoutSimplify('log((6x), 10)', 'x'), '(6 * 1) / ((6 x) * log(10))')
|
|
// d/dx(log(2x, 3x)) = ((2 * 1) / (2 * x) * log(3 * x) - log(2 * x) * (3 * 1) / (3 * x)) / log(3 * x) ^ 2 = (log(3x) - log(2x)) / (xlog(3x)^2)
|
|
compareString(derivativeWithoutSimplify('log((2x), (3x))', 'x'), '((2 * 1) / (2 x) * log((3 x)) - log((2 x)) * (3 * 1) / (3 x)) / log((3 x)) ^ 2')
|
|
|
|
compareString(derivativeWithoutSimplify('log(x)', 'x'), '1 / x')
|
|
|
|
compareString(derivativeWithoutSimplify('sin(2x)', 'x'), '2 * 1 * cos(2 x)')
|
|
compareString(derivativeWithoutSimplify('cos(2x)', 'x'), '2 * 1 * -sin(2 x)')
|
|
compareString(derivativeWithoutSimplify('tan(2x)', 'x'), '2 * 1 * sec(2 x) ^ 2')
|
|
compareString(derivativeWithoutSimplify('sec(2x)', 'x'), '2 * 1 * sec(2 x) * tan(2 x)')
|
|
compareString(derivativeWithoutSimplify('csc(2x)', 'x'), '-(2 * 1) * csc(2 x) * cot(2 x)')
|
|
compareString(derivativeWithoutSimplify('cot((2x))', 'x'), '-(2 * 1) * csc((2 x)) ^ 2')
|
|
compareString(derivativeWithoutSimplify('asin((2x))', 'x'), '(2 * 1) / sqrt(1 - (2 x) ^ 2)')
|
|
compareString(derivativeWithoutSimplify('acos((2x))', 'x'), '-(2 * 1) / sqrt(1 - (2 x) ^ 2)')
|
|
compareString(derivativeWithoutSimplify('atan((2x))', 'x'), '(2 * 1) / ((2 x) ^ 2 + 1)')
|
|
compareString(derivativeWithoutSimplify('asec((2x))', 'x'), '(2 * 1) / (abs((2 x)) * sqrt((2 x) ^ 2 - 1))')
|
|
compareString(derivativeWithoutSimplify('acsc((2x))', 'x'), '-(2 * 1) / (abs((2 x)) * sqrt((2 x) ^ 2 - 1))')
|
|
compareString(derivativeWithoutSimplify('acot((2x))', 'x'), '-(2 * 1) / ((2 x) ^ 2 + 1)')
|
|
compareString(derivativeWithoutSimplify('sinh(2x)', 'x'), '2 * 1 * cosh(2 x)')
|
|
compareString(derivativeWithoutSimplify('cosh(2x)', 'x'), '2 * 1 * sinh(2 x)')
|
|
compareString(derivativeWithoutSimplify('tanh(2x)', 'x'), '2 * 1 * sech(2 x) ^ 2')
|
|
compareString(derivativeWithoutSimplify('sech(2x)', 'x'), '-(2 * 1) * sech(2 x) * tanh(2 x)')
|
|
compareString(derivativeWithoutSimplify('csch(2x)', 'x'), '-(2 * 1) * csch(2 x) * coth(2 x)')
|
|
compareString(derivativeWithoutSimplify('coth(2x)', 'x'), '-(2 * 1) * csch(2 x) ^ 2')
|
|
compareString(derivativeWithoutSimplify('asinh((2x))', 'x'), '(2 * 1) / sqrt((2 x) ^ 2 + 1)')
|
|
compareString(derivativeWithoutSimplify('acosh((2x))', 'x'), '(2 * 1) / sqrt((2 x) ^ 2 - 1)')
|
|
compareString(derivativeWithoutSimplify('atanh((2x))', 'x'), '(2 * 1) / (1 - (2 x) ^ 2)')
|
|
compareString(derivativeWithoutSimplify('asech((2x))', 'x'), '-(2 * 1) / ((2 x) * sqrt(1 - (2 x) ^ 2))')
|
|
compareString(derivativeWithoutSimplify('acsch((2x))', 'x'), '-(2 * 1) / (abs((2 x)) * sqrt((2 x) ^ 2 + 1))')
|
|
compareString(derivativeWithoutSimplify('acoth((2x))', 'x'), '-(2 * 1) / (1 - (2 x) ^ 2)')
|
|
compareString(derivativeWithoutSimplify('abs(2x)', 'x'), '2 * 1 * abs(2 x) / 2 x')
|
|
|
|
// See power operator tests above
|
|
compareString(derivativeWithoutSimplify('pow(0, 2^x + x^3 + 2)', 'x'), '0')
|
|
compareString(derivativeWithoutSimplify('pow(1, 2^x + x^3 + 2)', 'x'), '0')
|
|
compareString(derivativeWithoutSimplify('pow(10, 2x + 2)', 'x'), '10 ^ (2 x + 2) * log(10) * (2 * 1 + 0)')
|
|
compareString(derivativeWithoutSimplify('pow(x^x^x^x, 0)', 'x'), '0')
|
|
compareString(derivativeWithoutSimplify('pow(x + 2, 1)', 'x'), '1 + 0')
|
|
compareString(derivativeWithoutSimplify('2 * pow(x, 2)', 'x'), '2 * 2 * 1 * x ^ (2 - 1)')
|
|
compareString(derivativeWithoutSimplify('2 * pow(x, -2)', 'x'), '2 * -2 * 1 * x ^ (-2 - 1)')
|
|
compareString(derivativeWithoutSimplify('pow(x^3 + x, 5x + 2)', 'x'), '(x ^ 3 + x) ^ (5 x + 2) * ((3 * 1 * x ^ (3 - 1) + 1) * (5 x + 2) / (x ^ 3 + x) + (5 * 1 + 0) * log(x ^ 3 + x))')
|
|
|
|
compareString(derivativeWithoutSimplify('exp(2x)', 'x'), '2 * 1 * exp(2 x)')
|
|
})
|
|
|
|
it('should take the partial derivative of an expression', function () {
|
|
compareString(derivativeWithoutSimplify('x + y', 'x'), '1 + 0')
|
|
compareString(derivativeWithoutSimplify('x + log(y)*y', 'x'), '1 + 0')
|
|
|
|
compareString(derivativeWithoutSimplify('x + y + z', 'x'), '1 + 0 + 0')
|
|
compareString(derivativeWithoutSimplify('x + log(y)*z', 'x'), '1 + 0')
|
|
|
|
compareString(derivativeWithoutSimplify('x + log(y)*x', 'x'), '1 + log(y) * 1')
|
|
|
|
// 2 * 1 * x ^ (2 - 1) + y * 1 + 0 = 2x + y
|
|
compareString(derivativeWithoutSimplify('x^2 + x*y + y^2', 'x'), '2 * 1 * x ^ (2 - 1) + y * 1 + 0')
|
|
})
|
|
|
|
it('should function properly even without being called within an evaluate', function () {
|
|
const f = math.parse('2x^3')
|
|
|
|
// 2*3*1*x^(3-1) = 6x^2
|
|
compareString(derivativeWithoutSimplify(f, 'x').toString(), '2 * 3 * 1 * x ^ (3 - 1)')
|
|
})
|
|
|
|
it('should accept string and Node input', function () {
|
|
// NOTE: we use `parse` here on purpose to see whether derivative accepts it
|
|
compareString(derivative('x^2', 'x'), '2 * x')
|
|
compareString(derivative(math.parse('x^2'), 'x'), '2 * x')
|
|
compareString(derivative('x^2', math.parse('x')), '2 * x')
|
|
compareString(derivative(math.parse('x^2'), math.parse('x')), '2 * x')
|
|
})
|
|
|
|
describe('expression parser', function () {
|
|
it('should evaluate a derivative containing string value', function () {
|
|
const res = math.evaluate('derivative("x^2", "x")')
|
|
assert.ok(res && res.isNode)
|
|
|
|
assert.strictEqual(res.toString(), '2 * x')
|
|
})
|
|
|
|
it('should evaluate a derivative containing nodes', function () {
|
|
const res = math.evaluate('derivative(parse("x^2"), parse("x"))')
|
|
assert.ok(res && res.isNode)
|
|
|
|
assert.strictEqual(res.toString(), '2 * x')
|
|
})
|
|
})
|
|
|
|
it('should not drop any additional operator arguments', function () {
|
|
// This case cannot happen when parsing via the expression parser,
|
|
// but it can when you create your own operator nodes. See #1014
|
|
|
|
const c12 = new ConstantNode(12)
|
|
const c4 = new ConstantNode(4)
|
|
const x = new SymbolNode('x')
|
|
|
|
assert.throws(function () {
|
|
const node = new OperatorNode('/', 'myDivide', [c12, c4, x])
|
|
derivative(node, 'x')
|
|
}, /Error: Operator "\/" is not supported by derivative, or a wrong number of arguments is passed/)
|
|
|
|
assert.throws(function () {
|
|
const node = new OperatorNode('^', 'myPow', [c12, c4, x])
|
|
derivative(node, 'x')
|
|
}, /Error: Operator "\^" is not supported by derivative, or a wrong number of arguments is passed/)
|
|
})
|
|
|
|
it('should throw error if expressions contain unsupported operators or functions', function () {
|
|
assert.throws(function () { derivative('x << 2', 'x') }, /Error: Operator "<<" is not supported by derivative/)
|
|
assert.throws(function () { derivative('subset(x)', 'x') }, /Error: Function "subset" is not supported by derivative/)
|
|
})
|
|
|
|
it('should have controlled behavior on arguments errors', function () {
|
|
assert.throws(function () {
|
|
derivative('sqrt()', 'x')
|
|
}, /TypeError: Too few arguments in function sqrt \(expected: number or Complex or BigNumber or Unit or Fraction or string or boolean, index: 0\)/)
|
|
assert.throws(function () {
|
|
derivative('sqrt(12, 2x)', 'x')
|
|
}, /TypeError: Too many arguments in function sqrt \(expected: 1, actual: 2\)/)
|
|
})
|
|
|
|
it('should throw error for incorrect argument types', function () {
|
|
assert.throws(function () {
|
|
derivative('42', '42')
|
|
}, /TypeError: Unexpected type of argument in function derivative \(expected: SymbolNode or identifier, actual: string, index: 1\)/)
|
|
|
|
assert.throws(function () {
|
|
derivative('[1, 2; 3, 4]', 'x')
|
|
}, /TypeError: Unexpected type of argument in function constTag \(expected: ConstantNode or FunctionNode or FunctionAssignmentNode or OperatorNode or ParenthesisNode or SymbolNode, actual:.*ArrayNode.*, index: 1\)/)
|
|
|
|
assert.throws(function () {
|
|
derivative('x + [1, 2; 3, 4]', 'x')
|
|
}, /TypeError: Unexpected type of argument in function constTag \(expected: ConstantNode or FunctionNode or FunctionAssignmentNode or OperatorNode or ParenthesisNode or SymbolNode, actual:.*ArrayNode.*, index: 1\)/)
|
|
})
|
|
|
|
it('should throw error if incorrect number of arguments', function () {
|
|
assert.throws(function () {
|
|
derivative('x + 2')
|
|
}, /TypeError: Too few arguments in function derivative \(expected: SymbolNode or identifier, index: 1\)/)
|
|
|
|
assert.throws(function () {
|
|
derivative('x + 2', 'x', {}, true, 42)
|
|
}, /TypeError: Too many arguments in function derivative \(expected: 3, actual: 5\)/)
|
|
})
|
|
|
|
it('should LaTeX expressions involving derivative', function () {
|
|
compareString(math.parse('derivative(x*y,x)').toTex(), '{d\\over dx}\\left[ x\\cdot y\\right]')
|
|
compareString(math.parse('derivative("x*y",x)').toTex(), '{d\\over dx}\\left[x * y\\right]')
|
|
compareString(math.parse('derivative(x*y,"x")').toTex(), '{d\\over dx}\\left[ x\\cdot y\\right]')
|
|
compareString(math.parse('derivative("x*y","x")').toTex(), '{d\\over dx}\\left[x * y\\right]')
|
|
|
|
// FIXME: handle toTex of derivative with options as third argument
|
|
// compareString(math.parse('derivative("x*y","x", { simplify: false })').toTex(), '{d\\over dx}\\left[x * y\\right]')
|
|
})
|
|
})
|