* Simplify: add two (term collection) noncommutative context std. rules
These additions permit the valid application of rules to exprs
including:
- For new rule 'vd + n*vd -> (1+n)*vd'
'a+2*a' -> '(1+2)*a'
- And new rule 'cd + cd*n -> cd*(1+n)'
'4+4*b' -> '4*(1+b)'
* Simplify: add non-commutative context term factoring rule
'n^n1 * n -> n^(n1+1)'
Also updates extant NC-context simplify tests which now apply this rule
successfully
* Add and restructure non-default context simplify tests
In addition to refactoring and splitting current tests into
describe/it blocks, also adds test block:
'should still validly apply (term factoring and collection) rules'
For ensuring simplify rules marked with
'context.[add/multiply].commutative: false' apply; simultaneously
validating that simplifications still occur as expected in these
contexts.
Co-authored-by: Jos de Jong <wjosdejong@gmail.com>
* Improve standard simplify rule matches in non-commutative contexts
Addresses the rule application limitation aspect as highlighted in
issue #2825; such that a broader set of successful standard replacement
rules are applied to multi-arg/associative expressions in
non-commutative contexts.
* Remove 'clone()' operations on expanded simplify rules
since original rule nodes (including expanded variations) are essentially
readonly objects, cloning of expanded rule LHS' is unnecessary during
canonicalization
* Hoist non-commutative context expanded rule app. in simplify (applyRule)
* Add two simplify non-commutative ctx. test cases
* feat: add polynomialRoot function
This is intended as a benchmark for general arithmetic/basic algebra
functionality of mathjs, but was chosen to be something of potential
independent utility as well, worth adding to mathjs in its own right.
Currently ol=nly computes the numerical roots for real or complex
polynomials of degree three or less.
As usual, adds documentation, embedded documentation, tests, TypeScript
declaration, and TypeScript tests.
Also updates doc.test.js to make it easier to specify an array of complex
numbers as the expected output, and comapres with the appropriate fuzz
in such cases.
Finally, adds a benchmark that computes the roots of all cubics with
nonnegative integer coefficients no larger than five.
* doc: fix typo in polynomialRoot embedded docs
Thanks, SamuelTLG
* style: avoid slightly cryptic Boolean flag stand-in
* Added matrix functions `schur`, `sylvester` and `lyap`
* Added docs for `schur`, `sylvester` and `lyap`
* Added unit tests for `schur`, `sylvester` and `lyap`
* Fixed lint and tests errors
* fixed typescript and added Matrix + Array tests
* lint fixed
* fixed example in sylvester.js doc
* Fixed docs and ci
* fixed definition of lyap and sylvester
* remark on diff defs for lyap
* rm a trailing space
Co-authored-by: Jos de Jong <wjosdejong@gmail.com>
* Create wildcards.js and implement basic type detections
* Remove isUnit from isConstantExpression wildcard
isUnit would never be encountered because units are stored as a part of ConstantNodes.
* Add matching for the new wildcard rules
* Add tests for the new wildcard rules
* Remove comment regarding Unit
* Seperate wildcard import into individual imports
* Update comments at top and change '*i' to '*d'
* Seperate Unit Tests
* Update simplify documentation comment
* Add unit test for #1406
* Update imports for new build system
* Update simplify test with new rules syntax
* Fix small documentation errors
* Update simplify rules to use new wildcards
* Add tests for rules updated with new wildcards
* Remove duplicated comment information
Co-authored-by: Jos de Jong <wjosdejong@gmail.com>
* Simplify: improve constant op. eval. in non-commutative contexts
Addresses the constant evaluation aspect as discussed in #2825.
Changes in simplifyConstant.js are accredited to @gwhitney
* Add simplifyConstant test for expr. with a non-evaluable constant
(uncomments a pre-existing test suggestion for an 'incomplete'
simplification example, more specifically)
Additionally adds commented TODO tests for additional expr. variations
with current incomplete simplification (non-commutative context)
* 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>
* setup linting with eslint-config-standard, prettier
* [autofix] npm run lint -- --fix with new setup
* [manual] fix types/ directory errors
* [manual] fix linting errors in test/ directory
* [manual] fix single linting error in src/
* revert ts-expect-error comment change
* error on .only in mocha tests
* fix test description typo
* move some short objects to single line
* add and gitignore eslintcache
* individually suppress ts any
* set --max-warnings to 0
* extract matrices to constants
* update ts-expect-error comments
* fix(simplify): Collect like factors in sums and cancel like terms in sums
Since polynomials like `x*(2x+x^2)` are usually written out as polynomials
`2x^2+x^3`, adds rules to be more eager to move factors into sums to
collect like factors. To complement this, adds a rule extracting
negative powers from a sum. Together, these accomplish canceling
a common factor in numerator and denominator:
(a*k + b*k^2)/k^4 -> k^-4*(a*k + b*k^2) -> a*k^-3 + b*k^-2 -> k^-3*(a + k*b)
-> (a + k*b)/k^3
Resolves#1423.
* fix(simplify): Adjust for #2394
* chore: Rebase and mark rules with assumptions
This commit should update this PR to be fully compatible with the
current development mainline. Will remove 'WIP'.
* chore(simplify): Additional test cases from PR review
Co-authored-by: Jos de Jong <wjosdejong@gmail.com>
* docs: Enhance generation to pick up functions with a prefix
For example, prior to this commit, docgenerator.js would miss
simplify.resolve because it is not a direct key of the math
object.
Also incorporates any "throws" attributes in the comments into
the generated documentation, and uses this to document the
new error-case behavior of simplify.resolve to be added in the next
commit.
* fix(resolve): Detect and throw errors for reference loops
Also extends resolve to work inside all node types. Adds tests
for both changes.
* docs: Add embedded docs for simplify.resolve et al.
To support finding the embedded doc from the `math.simplify.resolve`
function itself, required extending the search for objects with
documentation one level deeper in the `help()` function. Added test for
this search.
Also added support for documenting throws in embedded docs.
* refactor(simplify): Move resolve and simplifyCore to top-level
Also reverts changes searching for docs and embedded docs one level
down in the naming hierarchy.
Also splits tests for resolve and simplifyCore into their own files,
reflecting their new top-level status.
* fix(resolve): Remaining changes as requested
Also removed a stray blank line inadvertently introduced in
docgenerator.js
* refactor: Declare resolve and simplifyCore as dependencies of simplify
... rather than explicitly loading them, which is unnecessary now that they
are at top level.
* fix: Add dependencies to factoriesNumber
Also register simplifyCore as a dependency to rationalize
Co-authored-by: Jos de Jong <wjosdejong@gmail.com>
Note for this to work in a broad variety of contexts, has to also allow
identical expressions to cancel regardless of whether subtraction is
always defined; but this seems safe in general, that x-x is 0 even if x
does not generally have an additive inverse (for example, when working
in the positive context).
Resolves#1260.
* feat(simplify): Allow context option
If the options argument has a key 'context', it value is interpreted
as a context specifying various (non-default) properties of operators.
This context is propagated to all rules and all matching.
Adds some initial tests that the context option affects the behavior
of simplify appropriately. Not all can be activated until in a future
commit we add the ability for the application of a rule to be contingent
on aspects of the context.
Note that the enhanced rule matching necessary to support rules
constrained by non-default operator properties led to a couple of
changes to the output of rationalize() as well. Since the new output
seemed to better match what a person would typical write for the
rationalized form, this commit changed the test rather than attempted
to preserve the exact prior order of terms.
* feat(simplifyCore): strip all parentheses
Prior to this commit, simplifyCore stripped internal parentheses, but
would leave top-level ones. But top-level parentheses don't carry any
semantics, and no tests other than the ones that explicitly checked for
the retention of top-level parentheses were affected by this change.
Not making a special case for the top level also notably streamlined the
code in simplifyCore.
Adds tests for the new parenthesis-stripping behavior, as well as for
other node types that were added earlier but which did not yet have
simplifyCore tests.
* refactor(simplifyCore): Strip any node marked as trivial in context
This replaces special-case tests for unary + and parentheses, and
paves the way for example for 'abs' being marked trivial in a
putative positiveContext
* refactor(simplify): Rename 'context' parameter to rules and document it.
The new name is 'imposeContext' -- the motivation for the change is to
distinguish the parameter for 'assuming', which will be added as a new
parameter to control rule application based on context.
* feat(simplify): Allow context-based conditions on rule application.
Adds a new property of rules specified as objects: `assuming`. Its
value should be a context, and every property specified in that context
must match the incoming context, or else the rule will not be applied.
Updates the constant floating rules to require their operators be commutative,
as a test of the feature, and adds a unit test for this.
* feat(simplify): annotate rules with underlying assumptions
Also activates a number of tests of simplifications that should
or should not occur in various contexts.
To get all tests to pass, I could no longer find a rule ordering
that worked in all cases, without the ability to mark an individual
rule as applying repeatedly until just that rule stabilized. So this
commit also adds that ability, and uses it to eliminate the tricky rule
of expanding n1 + (n2 + n3)*(-1) to n1 + n2*(-1) + n3*(-1) late in the
rule ordering, in favor of the more intuitive (complete) expansion of
(n1 + n2)*(-1) to n1*(-1) + n2*(-1) early in the rule ordering, before
constant folding and gathering of like terms.
* feat(simplify): Add contexts for specific domains
In particular, adds a `simplify.realContext` and a `simplify.positiveContext`
which (attempt to) guarantee that no simplifications that change the value
of the expression, on any real number or any positive real number,
respectively, will occur.
Adds multiple tests for these contexts, including verification that the
simplification in either context does not change some example values of
any of the expressions in any simplify test.
This testing uncovered that it is unaryPlus that must be marked as trivial
for simplifyCore to work properly, so that marking is added as well.
* chore: Alter value consistency tests for browsers/older Node
The problem was NaN != NaN in some JavaScripts but not others,
so test for "both values NaN" explicitly before using deepEqual.
* fix: Implement requested changes from review
Added documentation about scope and context in top-level algebra functions
page; made variable name less abbreviated; performed suggested refactoring.
Co-authored-by: Jos de Jong <wjosdejong@gmail.com>
This function returns the number of leaves in the parse tree of an
expression. The motivation is to provide an initial complexity measure
that could be used to decide whether or not to apply some simplification
rules. Docs, embedded docs, and test cases are provided.
Resolves#2389.
* fix(simplify): Correct regression in simplify
Also adds a 'debugConsole' option to simplify() so that it is possible
to see the effect of each rule. This was critical to identifying the problem,
which was that recent changes ended up with `simplifyConstant` in the
wrong position in the list of rules. Correcting that also removed the need
for the two rules coalescing negations with constants.
Resolves#2393.
* fix(simplify): Correct another regression based on rule ordering
Disccovered that `x - (y-y+x)` had also stopped simplifying due
to recent changes, again because of re-ordering of the rules. So
added it to the tests, and fixed the rule ordering (adding a more
extensive comment about it). A big part of the reason that rule
ordering is so sensitive is that the reduction engine only checks
once in each pass for each rule whether it matches. So an alternate
fix to changing the rule ordering back would have been to re-check
each rule after it's applied (in case its application created new
instances of the rule) but since the re-ordering worked, that seemed
simpler as a fix for now.
* fix(simplify): Allow simplify to work in arrays, objects, and indexing
Mostly ArrayNode, ObjectNode, AccessorNode, and IndexNode nodes are
simply transparent to simplification -- they simply allow it to occur
within subexpressions. Then main exception is that if an array or object
is indexed by a constant, the expression can be replaced by the
corresponding subitem, e.g. `[3,4,5][2]` simplifies to `4`.
This at least partially resolves#1913 (see my latest comment there).
* fix(simplify): Resolve operations on constant arrays
This involves allowing ArrayNodes containing only constant entries
to temporarily convert to Matrix type inside of simplifyConstant, so that
function and operator calls can occur on them.
I also had to add a special case for the function `size` because
it can be computed even on symbolic arrays, since the result depends
only on the shape, not the entries.
Deals with additional cases of #1913; unclear if there are remaining
aspects of that issue on which further work is desirable.
* chore: fix alphabetization of dependencies
And restores inadvertent deletion of a blank line.
Co-authored-by: Jos de Jong <wjosdejong@gmail.com>
The key is that the rule-matching engine is optimized for finding matches
on the lefts of terms, but the central term-collection rule
`n1*n3 + n2*n3 -> (n1+n2)*n3` was written with the key common term rightmost.
Reversing this rule to `n3*n1 + n3*n2 -> n3*(n1+n2)` therefore does most
of the work of improving like-term collection. It also better corresponds
to typical mathematical presentation: common terms tend to be pulled out
to the left in common practice.
Floating constants to the right of a product initially (before they are
moved back to the left for human-preferred output) and ensuring that
negations are subsumed into constants whenever possible did the rest.
Also, rule context was not being propagated into the simplification
engine; this commit corrects that.
Resolves#1179.
Resolves#1290.
Co-authored-by: Jos de Jong <wjosdejong@gmail.com>
* fix(simplify): Leave string constants as strings.
Note that because the `size` built-in function called on a string returns
a Matrix, which is represented in math.js expressions as an Array, this
commit has to add ArrayNode as a dependency of `simplify` (and hence
also of `rationalize`).
In addition, it requires changing the handling of ArrayNodes
and AccessorNodes in `simplifyConstant` from "unimplemented" to just a
pass-through (since a full implementation of simplification in Arrays and
indexing seemed beyond the scope of this change, but `simplify` must not
throw an error on `size("foo")`). Hence, this commit also adds skipped unit
tests for some expressions with arrays and indexing that should ultimately
simplify.
It also removes the skip on the test group "should not change the value of
numbers when converting to fractions (3)" since all of those tests already
appear to pass.
Resolves#2152.
Changes the behavior in #1913 from throwing an error to allowing Arrays and
indexes but not simplifying inside them.
* chore: Fix lint and remove explanatory comment
* Add support for scopes with get and set methods
* Fix build for node v12
* Fixup cli and parser tests
* Add tests for simplify and evaluate
* Add example for a custom scope object
* Function calls need child scopes
* Transitionary step: Separate Safe and Scope Property calls
* Renamed identifiers in FunctionNode
* Evaluate with ObjectScopeWrapper
* Simplify tests passing
* Assume all scopes are map-like. Except parser
* Remove isMapLike check in customs.*SafeProperty() methods
* Change MapLike to Map
* Move keywords from an Object to a Set
* Move ScopeProperty functions in to scope.js
* Removed deprecation warning
* Rename scope.js to map.js
* Rename ScopeProperty to MapProperty
* Add tests and docs for map.js
* Put back the micro-optimization of function calls
* Use Map in the parser
* Called scope methods directly in cli.js
* Coercing of scope into a Map is done in Node, not evaluate
* Move createSubScope to its own file
* Fixup following self-review
* Add scope docs
* Final self-review changes
* Address reviewer comments
* Remove MapProperty witness marks
* Converted broken benchmark possibly lost in a rebase
* Use bare map as scope in benchmark
Co-authored-by: Jos de Jong <wjosdejong@gmail.com>
* Add `.js` extension to source file imports
* Specify package `exports` in `package.json`
Specify package type as `commonjs` (It's good to be specific)
* Move all compiled scripts into `lib` directory
Remove ./number.js (You can use the compiled ones in `./lib/*`)
Tell node that the `esm` directory is type `module` and enable tree shaking.
Remove unused files from packages `files` property
* Allow importing of package.json
* Make library ESM first
* - Fix merge conflicts
- Refactor `bundleAny` into `defaultInstance.js` and `browserBundle.cjs`
- Refactor unit tests to be able to run with plain nodejs (no transpiling)
- Fix browser examples
* Fix browser and browserstack tests
* Fix running unit tests on Node 10 (which has no support for modules)
* Fix node.js examples (those are still commonjs)
* Remove the need for `browserBundle.cjs`
* Generate minified bundle only
* [Security] Bump node-fetch from 2.6.0 to 2.6.1 (#1963)
Bumps [node-fetch](https://github.com/bitinn/node-fetch) from 2.6.0 to 2.6.1. **This update includes a security fix.**
- [Release notes](https://github.com/bitinn/node-fetch/releases)
- [Changelog](https://github.com/node-fetch/node-fetch/blob/master/docs/CHANGELOG.md)
- [Commits](https://github.com/bitinn/node-fetch/compare/v2.6.0...v2.6.1)
Signed-off-by: dependabot-preview[bot] <support@dependabot.com>
Co-authored-by: dependabot-preview[bot] <27856297+dependabot-preview[bot]@users.noreply.github.com>
* Cleanup console.log
* Add integration tests to test the entry points (commonjs/esm, full/number only)
* Create backward compatibility error messages in the files moved/removed since v8
* Describe breaking changes in HISTORY.md
* Bump karma from 5.2.1 to 5.2.2 (#1965)
Bumps [karma](https://github.com/karma-runner/karma) from 5.2.1 to 5.2.2.
- [Release notes](https://github.com/karma-runner/karma/releases)
- [Changelog](https://github.com/karma-runner/karma/blob/master/CHANGELOG.md)
- [Commits](https://github.com/karma-runner/karma/compare/v5.2.1...v5.2.2)
Signed-off-by: dependabot-preview[bot] <support@dependabot.com>
Co-authored-by: dependabot-preview[bot] <27856297+dependabot-preview[bot]@users.noreply.github.com>
Co-authored-by: Lee Langley-Rees <lee@greenimp.co.uk>
Co-authored-by: dependabot-preview[bot] <27856297+dependabot-preview[bot]@users.noreply.github.com>
* refactor solveValidation
* refactor usolve
* usolve algorithm implemented (for square mat.)
* added lsolve, consistent return type, fixed tests
* fixed lusolve and its tests, fixed linting issues
* added tests for usolve&lsolve, try-catch in lusolve
* put changes into separate files (u-/lsolveAll), revert changes to u-, l- and lusolve
* made *solveAll return [] for non-solvable, implemented sparse algorithms
* improved documentation for *solve(All)
Co-authored-by: Jos de Jong <wjosdejong@gmail.com>
* fix qr and sign edge cases
qr() was throwing an error if the pivots of a matrix were zero.
This commit fixes that and ensures that the results are consistant
with wolfram alpha.
Whilst doing this I found a bug in complex.js, I have added a work
around but we should flag this upstream.
I also addressed the long standing concerns about assert statements
within the body of the qr function.
Fixes#1669Fixes#942
* further improvements to qr and sign
mainly fixing things I got wrong in previous commit
* add array test
* fix: remove only from tests and disallow
Uses mochas `--forbid-only` flag as advised by
https://github.com/standard/standard/issues/988
