@danielsimonjr/mathts-functions 0.76.0 → 0.77.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.
|
@@ -11,6 +11,8 @@
|
|
|
11
11
|
*
|
|
12
12
|
* @packageDocumentation
|
|
13
13
|
*/
|
|
14
|
+
import { BigNumber } from '@danielsimonjr/mathts-core';
|
|
15
|
+
import type { TypedFunction } from '@danielsimonjr/mathts-core';
|
|
14
16
|
import { ComputePool } from '@danielsimonjr/mathts-parallel';
|
|
15
17
|
/** 32-bit signed integer */
|
|
16
18
|
type i32 = number;
|
|
@@ -28,161 +30,169 @@ type i32 = number;
|
|
|
28
30
|
* await add(float64A, float64B); // Parallel array add
|
|
29
31
|
* ```
|
|
30
32
|
*/
|
|
31
|
-
export declare const add:
|
|
33
|
+
export declare const add: TypedFunction;
|
|
32
34
|
/**
|
|
33
35
|
* Polymorphic subtraction function with parallel execution for arrays
|
|
34
36
|
*/
|
|
35
|
-
export declare const subtract:
|
|
37
|
+
export declare const subtract: TypedFunction;
|
|
36
38
|
/**
|
|
37
39
|
* Polymorphic multiplication function with parallel execution for arrays
|
|
38
40
|
*/
|
|
39
|
-
export declare const multiply:
|
|
41
|
+
export declare const multiply: TypedFunction;
|
|
40
42
|
/**
|
|
41
43
|
* Polymorphic division function with parallel execution for arrays
|
|
42
44
|
*/
|
|
43
|
-
export declare const divide:
|
|
45
|
+
export declare const divide: TypedFunction;
|
|
44
46
|
/**
|
|
45
47
|
* Unary negation with parallel array support
|
|
46
48
|
*/
|
|
47
|
-
export declare const unaryMinus:
|
|
49
|
+
export declare const unaryMinus: TypedFunction;
|
|
48
50
|
/**
|
|
49
51
|
* Unary plus (identity)
|
|
50
52
|
*/
|
|
51
|
-
export declare const unaryPlus:
|
|
53
|
+
export declare const unaryPlus: TypedFunction;
|
|
52
54
|
/**
|
|
53
55
|
* Absolute value with parallel array support
|
|
54
56
|
*/
|
|
55
|
-
export declare const abs:
|
|
57
|
+
export declare const abs: TypedFunction;
|
|
56
58
|
/**
|
|
57
59
|
* Sign function
|
|
58
60
|
*/
|
|
59
|
-
export declare const sign:
|
|
61
|
+
export declare const sign: TypedFunction;
|
|
60
62
|
/**
|
|
61
63
|
* Power function
|
|
62
64
|
*/
|
|
63
|
-
export declare const pow:
|
|
65
|
+
export declare const pow: TypedFunction;
|
|
64
66
|
/**
|
|
65
67
|
* Square root with parallel array support
|
|
66
68
|
*/
|
|
67
|
-
export declare const sqrt:
|
|
69
|
+
export declare const sqrt: TypedFunction;
|
|
68
70
|
/**
|
|
69
71
|
* Square with parallel array support
|
|
70
72
|
*/
|
|
71
|
-
export declare const square:
|
|
73
|
+
export declare const square: TypedFunction;
|
|
72
74
|
/**
|
|
73
75
|
* Cube
|
|
74
76
|
*/
|
|
75
|
-
export declare const cube:
|
|
77
|
+
export declare const cube: TypedFunction;
|
|
76
78
|
/**
|
|
77
79
|
* Cube root
|
|
78
80
|
*/
|
|
79
|
-
export declare const cbrt:
|
|
81
|
+
export declare const cbrt: TypedFunction;
|
|
80
82
|
/**
|
|
81
83
|
* N-th root
|
|
82
84
|
*/
|
|
83
|
-
export declare const nthRoot:
|
|
85
|
+
export declare const nthRoot: TypedFunction;
|
|
84
86
|
/**
|
|
85
87
|
* Exponential function (e^x) with parallel array support
|
|
86
88
|
*/
|
|
87
|
-
export declare const exp:
|
|
89
|
+
export declare const exp: TypedFunction;
|
|
88
90
|
/**
|
|
89
91
|
* Natural logarithm (ln x) with parallel array support
|
|
90
92
|
*/
|
|
91
|
-
export declare const log:
|
|
93
|
+
export declare const log: TypedFunction;
|
|
92
94
|
/**
|
|
93
95
|
* Base-10 logarithm
|
|
94
96
|
*/
|
|
95
|
-
export declare const log10:
|
|
97
|
+
export declare const log10: TypedFunction;
|
|
96
98
|
/**
|
|
97
99
|
* Base-2 logarithm
|
|
98
100
|
*/
|
|
99
|
-
export declare const log2:
|
|
101
|
+
export declare const log2: TypedFunction;
|
|
100
102
|
/**
|
|
101
103
|
* log(1 + x) with higher precision for small x
|
|
102
104
|
*/
|
|
103
|
-
export declare const log1p:
|
|
105
|
+
export declare const log1p: TypedFunction;
|
|
104
106
|
/**
|
|
105
107
|
* exp(x) - 1 with higher precision for small x
|
|
106
108
|
*/
|
|
107
|
-
export declare const expm1:
|
|
109
|
+
export declare const expm1: TypedFunction;
|
|
108
110
|
/**
|
|
109
111
|
* Round to nearest integer
|
|
110
112
|
*/
|
|
111
|
-
export declare const round:
|
|
113
|
+
export declare const round: TypedFunction;
|
|
112
114
|
/**
|
|
113
115
|
* Floor (round down)
|
|
114
116
|
*/
|
|
115
|
-
export declare const floor:
|
|
117
|
+
export declare const floor: TypedFunction;
|
|
116
118
|
/**
|
|
117
119
|
* Ceiling (round up)
|
|
118
120
|
*/
|
|
119
|
-
export declare const ceil:
|
|
121
|
+
export declare const ceil: TypedFunction;
|
|
120
122
|
/**
|
|
121
123
|
* Truncate (round toward zero)
|
|
122
124
|
*/
|
|
123
|
-
export declare const fix:
|
|
125
|
+
export declare const fix: TypedFunction;
|
|
124
126
|
/**
|
|
125
127
|
* Modulo operation
|
|
126
128
|
*/
|
|
127
|
-
export declare const mod:
|
|
129
|
+
export declare const mod: TypedFunction;
|
|
130
|
+
/** These are the call signatures of `gcd`. Each signature returns the type of its two arguments. */
|
|
131
|
+
interface GcdOverloads {
|
|
132
|
+
(a: number, b: number): number;
|
|
133
|
+
(a: bigint, b: bigint): bigint;
|
|
134
|
+
(a: BigNumber, b: BigNumber): BigNumber;
|
|
135
|
+
}
|
|
136
|
+
/** `gcd` with its precise call signatures. `gcd` is still a `TypedFunction`. */
|
|
137
|
+
export type GcdFunction = GcdOverloads & TypedFunction;
|
|
128
138
|
/**
|
|
129
139
|
* Greatest common divisor
|
|
130
140
|
*/
|
|
131
|
-
export declare const gcd:
|
|
141
|
+
export declare const gcd: GcdFunction;
|
|
132
142
|
/**
|
|
133
143
|
* Least common multiple
|
|
134
144
|
*/
|
|
135
|
-
export declare const lcm:
|
|
145
|
+
export declare const lcm: TypedFunction;
|
|
136
146
|
/**
|
|
137
147
|
* Extended greatest common divisor
|
|
138
148
|
* Returns [gcd, x, y] where gcd = a*x + b*y (Bezout coefficients)
|
|
139
149
|
*/
|
|
140
|
-
export declare const xgcd:
|
|
141
|
-
export declare const norm:
|
|
150
|
+
export declare const xgcd: TypedFunction;
|
|
151
|
+
export declare const norm: TypedFunction;
|
|
142
152
|
/**
|
|
143
153
|
* Hyperbolic sine
|
|
144
154
|
*/
|
|
145
|
-
export declare const sinh:
|
|
155
|
+
export declare const sinh: TypedFunction;
|
|
146
156
|
/**
|
|
147
157
|
* Hyperbolic cosine
|
|
148
158
|
*/
|
|
149
|
-
export declare const cosh:
|
|
159
|
+
export declare const cosh: TypedFunction;
|
|
150
160
|
/**
|
|
151
161
|
* Hyperbolic tangent
|
|
152
162
|
*/
|
|
153
|
-
export declare const tanh:
|
|
163
|
+
export declare const tanh: TypedFunction;
|
|
154
164
|
/**
|
|
155
165
|
* Check if values are equal
|
|
156
166
|
*/
|
|
157
|
-
export declare const equal:
|
|
167
|
+
export declare const equal: TypedFunction;
|
|
158
168
|
/**
|
|
159
169
|
* Check if a < b
|
|
160
170
|
*/
|
|
161
|
-
export declare const smaller:
|
|
171
|
+
export declare const smaller: TypedFunction;
|
|
162
172
|
/**
|
|
163
173
|
* Check if a > b
|
|
164
174
|
*/
|
|
165
|
-
export declare const larger:
|
|
175
|
+
export declare const larger: TypedFunction;
|
|
166
176
|
/**
|
|
167
177
|
* Check if a <= b
|
|
168
178
|
*/
|
|
169
|
-
export declare const smallerEq:
|
|
179
|
+
export declare const smallerEq: TypedFunction;
|
|
170
180
|
/**
|
|
171
181
|
* Check if a >= b
|
|
172
182
|
*/
|
|
173
|
-
export declare const largerEq:
|
|
183
|
+
export declare const largerEq: TypedFunction;
|
|
174
184
|
/**
|
|
175
185
|
* Compare two values: -1, 0, or 1
|
|
176
186
|
*/
|
|
177
|
-
export declare const compare:
|
|
187
|
+
export declare const compare: TypedFunction;
|
|
178
188
|
/**
|
|
179
189
|
* Minimum of values with parallel array support
|
|
180
190
|
*/
|
|
181
|
-
export declare const min:
|
|
191
|
+
export declare const min: TypedFunction;
|
|
182
192
|
/**
|
|
183
193
|
* Maximum of values with parallel array support
|
|
184
194
|
*/
|
|
185
|
-
export declare const max:
|
|
195
|
+
export declare const max: TypedFunction;
|
|
186
196
|
/**
|
|
187
197
|
* Sum with parallel array support
|
|
188
198
|
*/
|
|
@@ -199,13 +209,13 @@ export declare const max: import("@danielsimonjr/mathts-core").TypedFunction;
|
|
|
199
209
|
* ~2-4x slower than `sum`, so it is opt-in. Reach for it when the result is a small difference of
|
|
200
210
|
* large terms: conservation checks, residuals, long-running accumulators.
|
|
201
211
|
*/
|
|
202
|
-
export declare const fsum:
|
|
203
|
-
export declare const sum:
|
|
212
|
+
export declare const fsum: TypedFunction;
|
|
213
|
+
export declare const sum: TypedFunction;
|
|
204
214
|
/**
|
|
205
215
|
* Synchronous pairwise mean. Returns a number for `number[]`, `Float32Array` and `Float64Array`.
|
|
206
216
|
* The worker-pool mean is `parallelStatMean` and returns a Promise.
|
|
207
217
|
*/
|
|
208
|
-
export declare const mean:
|
|
218
|
+
export declare const mean: TypedFunction;
|
|
209
219
|
/**
|
|
210
220
|
* Variance normalization, matching mathjs's `variance(array, normalization)`:
|
|
211
221
|
* - 'unbiased' → sum2 / (n - 1) (sample variance; mathjs DEFAULT)
|
|
@@ -220,16 +230,16 @@ export type VarNormalization = 'unbiased' | 'uncorrected' | 'biased';
|
|
|
220
230
|
* `parallelStatVariance` variant. An optional normalization argument selects
|
|
221
231
|
* 'unbiased' | 'uncorrected' (population) | 'biased'. See VarNormalization.
|
|
222
232
|
*/
|
|
223
|
-
export declare const variance:
|
|
233
|
+
export declare const variance: TypedFunction;
|
|
224
234
|
/**
|
|
225
235
|
* Standard deviation with parallel array support — sqrt of {@link variance};
|
|
226
236
|
* defaults to **unbiased** and accepts the same normalization argument.
|
|
227
237
|
*/
|
|
228
|
-
export declare const std:
|
|
238
|
+
export declare const std: TypedFunction;
|
|
229
239
|
/**
|
|
230
240
|
* Dot product with parallel array support
|
|
231
241
|
*/
|
|
232
|
-
export declare const dot:
|
|
242
|
+
export declare const dot: TypedFunction;
|
|
233
243
|
/**
|
|
234
244
|
* Parallel matrix multiplication
|
|
235
245
|
* @param a First matrix as flat Float64Array (row-major)
|
|
@@ -268,51 +278,51 @@ export declare function shouldParallelize(elementCount: i32): boolean;
|
|
|
268
278
|
*/
|
|
269
279
|
export declare function getComputePool(): ComputePool;
|
|
270
280
|
export declare const typedArithmetic: {
|
|
271
|
-
add:
|
|
272
|
-
subtract:
|
|
273
|
-
multiply:
|
|
274
|
-
divide:
|
|
275
|
-
unaryMinus:
|
|
276
|
-
unaryPlus:
|
|
277
|
-
abs:
|
|
278
|
-
sign:
|
|
279
|
-
pow:
|
|
280
|
-
sqrt:
|
|
281
|
-
square:
|
|
282
|
-
cube:
|
|
283
|
-
cbrt:
|
|
284
|
-
nthRoot:
|
|
285
|
-
exp:
|
|
286
|
-
log:
|
|
287
|
-
log10:
|
|
288
|
-
log2:
|
|
289
|
-
log1p:
|
|
290
|
-
expm1:
|
|
291
|
-
round:
|
|
292
|
-
floor:
|
|
293
|
-
ceil:
|
|
294
|
-
fix:
|
|
295
|
-
mod:
|
|
296
|
-
gcd:
|
|
297
|
-
lcm:
|
|
298
|
-
xgcd:
|
|
299
|
-
norm:
|
|
300
|
-
sinh:
|
|
301
|
-
cosh:
|
|
302
|
-
tanh:
|
|
303
|
-
equal:
|
|
304
|
-
smaller:
|
|
305
|
-
larger:
|
|
306
|
-
smallerEq:
|
|
307
|
-
largerEq:
|
|
308
|
-
compare:
|
|
309
|
-
min:
|
|
310
|
-
max:
|
|
311
|
-
sum:
|
|
312
|
-
mean:
|
|
313
|
-
variance:
|
|
314
|
-
std:
|
|
315
|
-
dot:
|
|
281
|
+
add: TypedFunction;
|
|
282
|
+
subtract: TypedFunction;
|
|
283
|
+
multiply: TypedFunction;
|
|
284
|
+
divide: TypedFunction;
|
|
285
|
+
unaryMinus: TypedFunction;
|
|
286
|
+
unaryPlus: TypedFunction;
|
|
287
|
+
abs: TypedFunction;
|
|
288
|
+
sign: TypedFunction;
|
|
289
|
+
pow: TypedFunction;
|
|
290
|
+
sqrt: TypedFunction;
|
|
291
|
+
square: TypedFunction;
|
|
292
|
+
cube: TypedFunction;
|
|
293
|
+
cbrt: TypedFunction;
|
|
294
|
+
nthRoot: TypedFunction;
|
|
295
|
+
exp: TypedFunction;
|
|
296
|
+
log: TypedFunction;
|
|
297
|
+
log10: TypedFunction;
|
|
298
|
+
log2: TypedFunction;
|
|
299
|
+
log1p: TypedFunction;
|
|
300
|
+
expm1: TypedFunction;
|
|
301
|
+
round: TypedFunction;
|
|
302
|
+
floor: TypedFunction;
|
|
303
|
+
ceil: TypedFunction;
|
|
304
|
+
fix: TypedFunction;
|
|
305
|
+
mod: TypedFunction;
|
|
306
|
+
gcd: GcdFunction;
|
|
307
|
+
lcm: TypedFunction;
|
|
308
|
+
xgcd: TypedFunction;
|
|
309
|
+
norm: TypedFunction;
|
|
310
|
+
sinh: TypedFunction;
|
|
311
|
+
cosh: TypedFunction;
|
|
312
|
+
tanh: TypedFunction;
|
|
313
|
+
equal: TypedFunction;
|
|
314
|
+
smaller: TypedFunction;
|
|
315
|
+
larger: TypedFunction;
|
|
316
|
+
smallerEq: TypedFunction;
|
|
317
|
+
largerEq: TypedFunction;
|
|
318
|
+
compare: TypedFunction;
|
|
319
|
+
min: TypedFunction;
|
|
320
|
+
max: TypedFunction;
|
|
321
|
+
sum: TypedFunction;
|
|
322
|
+
mean: TypedFunction;
|
|
323
|
+
variance: TypedFunction;
|
|
324
|
+
std: TypedFunction;
|
|
325
|
+
dot: TypedFunction;
|
|
316
326
|
matmul: typeof matmul;
|
|
317
327
|
transpose: typeof transpose;
|
|
318
328
|
matvec: typeof matvec;
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"arithmetic.d.ts","sourceRoot":"","sources":["../../src/typed/arithmetic.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;
|
|
1
|
+
{"version":3,"file":"arithmetic.d.ts","sourceRoot":"","sources":["../../src/typed/arithmetic.ts"],"names":[],"mappings":"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"}
|
package/dist/typed/index.d.ts
CHANGED
|
@@ -89,7 +89,7 @@ export declare const typedFunctions: {
|
|
|
89
89
|
ceil: import("typed-function").TypedFunction;
|
|
90
90
|
fix: import("typed-function").TypedFunction;
|
|
91
91
|
mod: import("typed-function").TypedFunction;
|
|
92
|
-
gcd: import("
|
|
92
|
+
gcd: import("./arithmetic.js").GcdFunction;
|
|
93
93
|
lcm: import("typed-function").TypedFunction;
|
|
94
94
|
xgcd: import("typed-function").TypedFunction;
|
|
95
95
|
sinh: import("typed-function").TypedFunction;
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@danielsimonjr/mathts-functions",
|
|
3
|
-
"version": "0.
|
|
3
|
+
"version": "0.77.1",
|
|
4
4
|
"description": "Mathematical functions for MathTS - arithmetic, algebra, trigonometry, statistics, and more",
|
|
5
5
|
"author": "Daniel Simon Jr.",
|
|
6
6
|
"license": "MIT",
|
|
@@ -45,11 +45,11 @@
|
|
|
45
45
|
}
|
|
46
46
|
},
|
|
47
47
|
"dependencies": {
|
|
48
|
-
"@danielsimonjr/mathts-core": "^0.
|
|
49
|
-
"@danielsimonjr/mathts-expression": "^0.12.
|
|
48
|
+
"@danielsimonjr/mathts-core": "^0.23.0",
|
|
49
|
+
"@danielsimonjr/mathts-expression": "^0.12.3",
|
|
50
50
|
"@danielsimonjr/mathts-gpu": "^0.2.1",
|
|
51
|
-
"@danielsimonjr/mathts-matrix": "^0.9.
|
|
52
|
-
"@danielsimonjr/mathts-parallel": "^0.8.
|
|
51
|
+
"@danielsimonjr/mathts-matrix": "^0.9.2",
|
|
52
|
+
"@danielsimonjr/mathts-parallel": "^0.8.2",
|
|
53
53
|
"bignumber.js": "^11.1.5",
|
|
54
54
|
"complex.js": "^2.2.5",
|
|
55
55
|
"decimal.js": "^10.4.3",
|