* added subtractScaler
* added subtractScaler missing entries
* added test cases for 2 or more parameters, test for subtractScalar instead fo subtract
* replaced subtract with subtractScalar whereever possible
---------
Co-authored-by: Jos de Jong <wjosdejong@gmail.com>
* fixed matrix issue in correlation function + error handling
* fixed syntax error in correlation function documentation
* changed error to syntax error
* added test cases for error handling
* added test cases for error handling v2
* fixed issue in test cases for error handling v2
* fixed issue in test cases for error handling v2.1
* fixed issue in test cases for error handling v2.2
* removed math.matrix examples
* removed redundant code
* changes made to the following files:
- mod.js
- gcd.js
* updated BigNumber implementation and added validating tests
* added validating test cases
* updated test cases
* formatted code
* Made updates according to requirement
used mathjs floor in mod.js
imported mod in gcd.js
made mod work for negative divisors
wrote and updated tests to validate new behavior
* updated mod in arithmetic.js
* added tests for modNumber function
---------
Co-authored-by: Jos de Jong <wjosdejong@gmail.com>
* broadcasting
* Simplified broadcasting
* Updated for broadcasting
* Changed to camel case
* Camel case and auto formating
* Added comments
* Skip if matrices have the same size
* Fixed issue with undefined variable
missing dot in `A._size`
* Implemented broadcasting in all functions
* Added helper functions
* Added function to check for broadcasting rules
* Tests for broadcasted arithmetic
* Fixed issue with matrix the size of a vector
* Documented and updated broadcasting
* Included broadcast.test
* Included math to syntax when missing
* Added print transform and tests
* Simplify conditional
* Included regex in an util
---------
Co-authored-by: David Contreras <david.contreras@guentner.com>
Co-authored-by: Jos de Jong <wjosdejong@gmail.com>
* added correlation function to statistics
* added implemenation for signature Matrix, Matrix and support for BigNumbers
* reverted changes to default for version numbers of devDepenencies
* reverted changes to default for version numbers of devDepenencies in package-lock.json
* change variable name from xArray, yArray to x and y
* added Matrix as param in index.d.ts
* corrected the file and function names for correlation function
* renamed createCorrelation to createCorr in factoriesNumber.js
* fixed failing test case for matrix and added params and return in corr
* Riemann Zeta Function
* Big Number zeta and added docs
* Original algorithm paper credited
* Update index.d.ts
* Update riemannZeta.js
* Update index.d.ts
* Renamed files to reflect zeta
* chore: make all the tests pass
* chore: refactor `zeta` (WIP)
* chore: reuse the validation logic of both number and BigNumber
* fix: type definitions of `zeta`
* fix: test the accuracy with numbers and BigNumbers (WIP)
* chore: make linter happy
* docs: fix example outputs
* docs: update history
* docs: update history
* docs: describe the limited precision of `zeta`
---------
Co-authored-by: BuildTools <anikpatel1322@gmail.com>
Co-authored-by: Anik Patel <74193405+Bobingstern@users.noreply.github.com>
* Included math to syntax when missing
* Included solveODE
* renamed initialStep as firstStep
* Included tests for solveODE
* Test the full state instead of the final state
* Fixed issue with tolerance
* Added unit signature for y0
* Included units test also for y0
* Included embedded docs and more tests
* Included error for tspan
* It works with bignumbers
* reduced calling bignumber
* extended the search for bignumbers
* The jsdocs is less ambiguous
* included tests for step options
* Allowed for 0 minStep
* Optimization to avoid checking the sign every step
* added dim to quantile
* Included transform
* Removed modification of the docs
I made an unwanted modification
---------
Co-authored-by: David Contreras <david.contreras@guentner.com>
Co-authored-by: Jos de Jong <wjosdejong@gmail.com>
* Included math to syntax when missing
* Included solveODE
* renamed initialStep as firstStep
* Included tests for solveODE
* Test the full state instead of the final state
* Fixed issue with tolerance
* Indexing with an array of booleans
* Indexing with booleans and with empty
* Changed index embedded docs
* removed solveODE
* typos on tests
* included config.predictable
* Throws an error if the size doesn't match
* Included config predictable to get subset
* Can do replacement by broadcasting
* DenseMatrix set can broadcast first
* Added tests for broadcasted subset in the parser
* Faster cloning of deep arrays
* Included docs and better test coverage
* Test coverage for `subset`
* Removed config predictable from subset
* Removed config from index and sparseMatrix
* Redaction and typos
* Cleanup unnecesary changes
* fixed issue when there is no need to broadcast
* Inline ifs
* Included specific broadcasting test
* Reduced repetition
---------
Co-authored-by: David Contreras <david.contreras@guentner.com>
Co-authored-by: Jos de Jong <wjosdejong@gmail.com>
* fix: #2990 DenseMatrix can mutate input arrays
* chore: simplify internal function `preprocess`
* chore: document ugly workaround of using `matrix.subset` to mutate a nested Array
* chore: better solution for `assign`
* chore: fix linting issue
* chore: add a unit test for `multiply` testing whether the operation is immutable
* chore: fix linting issue
---------
Co-authored-by: Glen Whitney <glen@studioinfinity.org>
* reange refactoring
* update authors
* Made _range to work also for _bigNumbers
* Range with units
* Included some Unit type in _range
* Included TypeScript types for function range
* Formatting
---------
Co-authored-by: David Contreras <david.contreras@guentner.com>
* Add Zpk2tf function
* Add zpk2tf function documentation
* Fix
* Add freqz function implementation
* Fix format
* Add freqz function documentation
* Fix
* Fix format
* Update index.d.ts
* Fix Dependency error
* Fix
* Fix index.d.ts
* Fix Documentation
* Fix Lint
* Fix index.d.ts
* Fix The Matrix parameter support and index.d.ts
* Fix Format
* Add Unit Tests for Matrix cases
* Fix Docs and Lint
* Add tests for coverage
* Fix Format
* Update AUTHORS
---------
Co-authored-by: Jos de Jong <wjosdejong@gmail.com>
* Included math to syntax when missing
* Included solveODE
* renamed initialStep as firstStep
* Included tests for solveODE
* Test the full state instead of the final state
* Fixed issue with tolerance
* Added unit signature for y0
* Included units test also for y0
* Included embedded docs and more tests
* Included error for tspan
* It works with bignumbers
* reduced calling bignumber
* extended the search for bignumbers
* The jsdocs is less ambiguous
* included tests for step options
* Allowed for 0 minStep
* Optimization to avoid checking the sign every step
---------
Co-authored-by: David Contreras <david.contreras@guentner.com>
Co-authored-by: Jos de Jong <wjosdejong@gmail.com>
* test: format bignumber to engineering bug
Add tests for correctly handling starting with more then 3 sig figs and targeting 1 or 2 sig figs
* lint:
* lint: reduce number literal sig figs
* fix: engineering notation for bignumber input
Corrects handling of cases where the input has 3 or more sig figs and the output is set to 1 or 2 sig figs.
* test: add negative format bignumber precision test
* fix: use BigNumber for all branches in toEngineering
Also, remove string type option from JSDoc for toEngineering since string does support the required interface for the function (the .e property, .mul member function, and the .constructor property would not be correct after this change)
* fix: precision 0 for fixed notation and bignumber
This fix differentiates precision === 0 and precision === undefined to.
After fix, format bignumber for precision 0 matches format number for precision 0.
Tests added as well
---------
Co-authored-by: Jos de Jong <wjosdejong@gmail.com>
* #2567: accept array as parameter for gcd()
* #2567: accept 1d matrix as gcd() argument
* #2567: support nested 1d array in gcd
* #2567: simplify matrix signature
* [fix] intersect method parameter type (#2897)
* Update history and authors (see #2897)
* feat: added chirp-z transform to calculate non-power-of-2 fft (#2900)
* added chirp-z transform to calculate non-power-of-2 fft
* simplify/remove _ifft function inside _czt function
* chore: remove an unused dependency from `simplifyConstant`
* fix: quantileSeq not accepting a matrix as second argument `prob` (see #2902)
* fix a broken example of function `to`
* fix a typo in the examples functions `distance`, `getMatrixDataType`, `subset`, and `max` (see #2902)
* fix linting issue
* Broadcasting (#2895)
* broadcasting
* Simplified broadcasting
* Updated for broadcasting
* Changed to camel case
* Camel case and auto formating
* Added comments
* Skip if matrices have the same size
* Fixed issue with undefined variable
missing dot in `A._size`
* Implemented broadcasting in all functions
* Added helper functions
* Added function to check for broadcasting rules
* Tests for broadcasted arithmetic
* Fixed issue with matrix the size of a vector
* Documented and updated broadcasting
* Included broadcast.test
---------
Co-authored-by: David Contreras <david.contreras@guentner.com>
Co-authored-by: Jos de Jong <wjosdejong@gmail.com>
* Update history and authors
* Update devDependencies
* publish v11.6.0
* fix#2906: improve description of the behavior of `subset` for scalar values in the docs
* fix#2907: determinant of empty matrix should be 1
* chore: add a few more unit tests to `det`
---------
Co-authored-by: Jos de Jong <wjosdejong@gmail.com>
Co-authored-by: Jaeu Jeong <wodndb@gmail.com>
Co-authored-by: cyavictor88 <100557319+cyavictor88@users.noreply.github.com>
Co-authored-by: David Contreras <dvd.cnt@gmail.com>
Co-authored-by: David Contreras <david.contreras@guentner.com>
* broadcasting
* Simplified broadcasting
* Updated for broadcasting
* Changed to camel case
* Camel case and auto formating
* Added comments
* Skip if matrices have the same size
* Fixed issue with undefined variable
missing dot in `A._size`
* Implemented broadcasting in all functions
* Added helper functions
* Added function to check for broadcasting rules
* Tests for broadcasted arithmetic
* Fixed issue with matrix the size of a vector
* Documented and updated broadcasting
* Included broadcast.test
---------
Co-authored-by: David Contreras <david.contreras@guentner.com>
Co-authored-by: Jos de Jong <wjosdejong@gmail.com>
* 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>
* Fix#46
Draft Implementations
* Add docs
* Fixup
* Add type declaration and test
* Fixup tests
* Fixup test
* Format
* Add examples in docs
* Update fft.js
Edit example in docs (`math.fft` returns complex matrix).
* Update ifft.js
Edit example in docs (`math.ffti` returns complex matrix).
* Update fft.js
Edit docs examples, representation of complex number from `a+bi` to `{re:a, im:b}`
* Update ifft.js
Edit docs examples, representation of complex number from `a+bi` to `{re:a, im:b}`
* Update index.ts
Edit test.
Add test for `math.ifft`
`math.fft` returns complex matrix.
* Update index.ts
Use `approx.deepEqual` instead off `assert.deepStrictEqual`.
* Update index.ts
Format code
* Update index.ts
Use `assert.ok(math.deepEqual(...))` instead of `approx.deepEqual`.
* Update index.ts
Format
* Update index.ts
Typo: replace `approx` with `assert`.
Co-authored-by: Jos de Jong <wjosdejong@gmail.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
This is a sequel to #2531. Uniformizes the signatures of ceil, fix, floor,
and round, and updates the TypeScript declarations to match. Adds the
optional "number of places" argument to the chain versions of ceil, fix,
and floor. Adds TypeScript tests for all rounding functions.
Also corrects the TypeScript declaration for `bignumber()` and introduces
a couple more common abbreviations for TypeScript types.
Fixes the number-only implementations of floor, ceil, fix, and nthRoot
to match the full implementation behavior on numbers, and tests this for
floor.
Includes some minor documentation updates and additional unit tests for
the rounding functions.
Reverts inclusion in AUTHORS of incorrect email for one contributor,
that occurred in #2531.
Resolves#2526.
Resolves#2529.
* Optimize `det`
Use Bareiss algorithm.
The performance is preserved but lessen the round-off errors.
* Optimize `det`
Use index mapping instead of swapping the rows directly.
Run the benchmark to compare the performance.
* Edit test file
Replace `approx.equal` with `assert.strictEqual`.
The test will fail with the previously implemented LU decomposition.
Co-authored-by: Glen Whitney <glen@studioinfinity.org>
