@nodef/extra-array.web 0.0.0-stage → 4.5.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +21 -0
- package/README.md +486 -2
- package/deno.lock +54 -0
- package/index.d.ts +1421 -0
- package/index.js +2 -0
- package/index.js.map +7 -0
- package/index.test.ts +2054 -0
- package/package.json +13 -3
package/index.d.ts
ADDED
|
@@ -0,0 +1,1421 @@
|
|
|
1
|
+
/** Entries is an array of index-value pairs, with unique indices. */ export type Entries<T> = [number, T][];
|
|
2
|
+
/** IEntries is a list of index-value pairs, with unique indices. */ export type IEntries<T> = Iterable<[number, T]>;
|
|
3
|
+
/** Lists is a pair of index array and value array, with unique indices. */ export type Lists<T> = [number[], T[]];
|
|
4
|
+
/** ILists is a pair of index iterable list and value iterable list, with unique indices. */ export type ILists<T> = [Iterable<number>, Iterable<T>];
|
|
5
|
+
/**
|
|
6
|
+
* Handle reading of a single value.
|
|
7
|
+
* @returns value
|
|
8
|
+
*/ export type ReadFunction<T> = () => T;
|
|
9
|
+
/**
|
|
10
|
+
* Handle combining of two values.
|
|
11
|
+
* @param a a value
|
|
12
|
+
* @param b another value
|
|
13
|
+
* @returns combined value
|
|
14
|
+
*/ export type CombineFunction<T> = (a: T, b: T) => T;
|
|
15
|
+
/**
|
|
16
|
+
* Handle comparison of two values.
|
|
17
|
+
* @param a a value
|
|
18
|
+
* @param b another value
|
|
19
|
+
* @returns a<b: -ve, a=b: 0, a>b: +ve
|
|
20
|
+
*/ export type CompareFunction<T> = (a: T, b: T) => number;
|
|
21
|
+
/**
|
|
22
|
+
* Handle processing of values in an array.
|
|
23
|
+
* @param v value in array
|
|
24
|
+
* @param i index of value in array
|
|
25
|
+
* @param x array containing the value
|
|
26
|
+
*/ export type ProcessFunction<T> = (v: T, i: number, x: T[] | null) => void;
|
|
27
|
+
/**
|
|
28
|
+
* Handle selection of values in an array.
|
|
29
|
+
* @param v value in array
|
|
30
|
+
* @param i index of value in array
|
|
31
|
+
* @param x array containing the value
|
|
32
|
+
* @returns selected?
|
|
33
|
+
*/ export type TestFunction<T> = (v: T, i: number, x: T[] | null) => boolean;
|
|
34
|
+
/**
|
|
35
|
+
* Handle transformation of a value to another.
|
|
36
|
+
* @param v value in array
|
|
37
|
+
* @param i index of value in array
|
|
38
|
+
* @param x array containing the value
|
|
39
|
+
* @returns transformed value
|
|
40
|
+
*/ export type MapFunction<T, U> = (v: T, i: number, x: T[] | null) => U;
|
|
41
|
+
/**
|
|
42
|
+
* Handle reduction of multiple values into a single value.
|
|
43
|
+
* @param acc accumulator (temporary result)
|
|
44
|
+
* @param v value in array
|
|
45
|
+
* @param i index of value in array
|
|
46
|
+
* @param x array containing the value
|
|
47
|
+
* @returns reduced value
|
|
48
|
+
*/ export type ReduceFunction<T, U> = (acc: U, v: T, i: number, x: T[] | null) => U;
|
|
49
|
+
/**
|
|
50
|
+
* Handle ending of a combined array.
|
|
51
|
+
* @param dones iᵗʰ array done?
|
|
52
|
+
* @returns combined array done?
|
|
53
|
+
*/ export type EndFunction = (dones: boolean[]) => boolean;
|
|
54
|
+
/**
|
|
55
|
+
* Handle swapping of two values in an array.
|
|
56
|
+
* @param x an array (updated!)
|
|
57
|
+
* @param i an index
|
|
58
|
+
* @param j another index
|
|
59
|
+
* @returns x | x[i] ⇔ x[j]
|
|
60
|
+
*/ export type SwapFunction<T> = (x: T[], i: number, j: number) => T[];
|
|
61
|
+
/**
|
|
62
|
+
* Generate array from given number range.
|
|
63
|
+
* @param v start number
|
|
64
|
+
* @param V end number, excluding
|
|
65
|
+
* @param dv step size [1]
|
|
66
|
+
* @returns [v, v+dv, v+2dv, ...]
|
|
67
|
+
*/ export declare function fromRange(v: number, V: number, dv?: number): number[];
|
|
68
|
+
/**
|
|
69
|
+
* Generate array from repeated function invocation.
|
|
70
|
+
* @param fn function
|
|
71
|
+
* @param n number of values
|
|
72
|
+
* @returns [fn(), fn(), ...]
|
|
73
|
+
*/ export declare function fromInvocation<T>(fn: () => T, n: number): T[];
|
|
74
|
+
export { fromInvocation as fromCall };
|
|
75
|
+
/**
|
|
76
|
+
* Generate array from repeated function application.
|
|
77
|
+
* @param fm map function (v, i)
|
|
78
|
+
* @param v start value
|
|
79
|
+
* @param n number of values
|
|
80
|
+
* @returns [v, fm(v), fm(fm(v)), ...]
|
|
81
|
+
*/ export declare function fromApplication<T>(fm: MapFunction<T, T>, v: T, n: number): T[];
|
|
82
|
+
export { fromApplication as fromApply };
|
|
83
|
+
/**
|
|
84
|
+
* Convert an iterable to array.
|
|
85
|
+
* @param x an iterable
|
|
86
|
+
* @returns x as array
|
|
87
|
+
*/ export declare function fromIterable<T>(x: Iterable<T>): T[];
|
|
88
|
+
export { fromIterable as from };
|
|
89
|
+
/**
|
|
90
|
+
* Convert an iterable to array!
|
|
91
|
+
* @param x an iterable (updatable if array!)
|
|
92
|
+
* @returns x as array
|
|
93
|
+
*/ export declare function fromIterable$<T>(x: Iterable<T>): T[];
|
|
94
|
+
export { fromIterable$ as from$ };
|
|
95
|
+
/**
|
|
96
|
+
* Shallow clone an array.
|
|
97
|
+
* @param x an array
|
|
98
|
+
* @returns shallow clone of x
|
|
99
|
+
*/ export declare function shallowClone<T>(x: T[]): T[];
|
|
100
|
+
export { shallowClone as clone };
|
|
101
|
+
/**
|
|
102
|
+
* Deep clone an array.
|
|
103
|
+
* @param x an array
|
|
104
|
+
* @returns deep clone of x
|
|
105
|
+
*/ export declare function deepClone<T>(x: T[]): T[];
|
|
106
|
+
/**
|
|
107
|
+
* Check if value is an array.
|
|
108
|
+
* @param v a value
|
|
109
|
+
* @returns v is an array?
|
|
110
|
+
*/ export declare function is(v: unknown): v is unknown[];
|
|
111
|
+
/**
|
|
112
|
+
* Obtain all indices.
|
|
113
|
+
* @param x an array
|
|
114
|
+
* @returns [0, 1, ..., |x|-1]
|
|
115
|
+
*/ export declare function keys<T>(x: T[]): number[];
|
|
116
|
+
/**
|
|
117
|
+
* List all indices.
|
|
118
|
+
* @param x an array
|
|
119
|
+
* @returns 0, 1, ..., |x|-1
|
|
120
|
+
*/ export declare function ikeys<T>(x: T[]): IterableIterator<number>;
|
|
121
|
+
/**
|
|
122
|
+
* Get all values.
|
|
123
|
+
* @param x an array
|
|
124
|
+
* @returns [v₀, v₁, ...] | vᵢ = x[i]
|
|
125
|
+
*/ export declare function values<T>(x: T[]): T[];
|
|
126
|
+
/**
|
|
127
|
+
* List all values.
|
|
128
|
+
* @param x an array
|
|
129
|
+
* @returns v₀, v₁, ... | vᵢ = x[i]
|
|
130
|
+
*/ export declare function ivalues<T>(x: T[]): IterableIterator<T>;
|
|
131
|
+
/**
|
|
132
|
+
* Obtain all index-value pairs.
|
|
133
|
+
* @param x an array
|
|
134
|
+
* @returns [[0, v₀], [1, v₁], ...] | vᵢ = x[i]
|
|
135
|
+
*/ export declare function entries<T>(x: T[]): Entries<T>;
|
|
136
|
+
/**
|
|
137
|
+
* List all index-value pairs.
|
|
138
|
+
* @param x an array
|
|
139
|
+
* @returns [0, v₀], [1, v₁], ... | vᵢ = x[i]
|
|
140
|
+
*/ export declare function ientries<T>(x: T[]): IEntries<T>;
|
|
141
|
+
/**
|
|
142
|
+
* Get zero-based index for an element in array.
|
|
143
|
+
* @param x an array
|
|
144
|
+
* @param i ±index
|
|
145
|
+
* @returns i' | x[i'] = x[i]; i' ∈ [0, |x|]
|
|
146
|
+
*/ export declare function index<T>(x: T[], i: number): number;
|
|
147
|
+
/**
|
|
148
|
+
* Get zero-based index range for part of array.
|
|
149
|
+
* @param x an array
|
|
150
|
+
* @param i begin ±index [0]
|
|
151
|
+
* @param I end ±index (exclusive) [|x|]
|
|
152
|
+
* @returns [i', I'] | i' ≤ I'; i', I' ∈ [0, |x|]
|
|
153
|
+
*/ export declare function indexRange<T>(x: T[], i?: number, I?: number): [number, number];
|
|
154
|
+
/**
|
|
155
|
+
* Check if an array is empty.
|
|
156
|
+
* @param x an array
|
|
157
|
+
* @returns |x| = 0?
|
|
158
|
+
*/ export declare function isEmpty<T>(x: T[]): boolean;
|
|
159
|
+
/**
|
|
160
|
+
* Find the length of an array.
|
|
161
|
+
* @param x an array
|
|
162
|
+
* @param i begin ±index [0]
|
|
163
|
+
* @param I end ±index (exclusive) [X]
|
|
164
|
+
* @returns |x[i..I]|
|
|
165
|
+
*/ export declare function length<T>(x: T[], i?: number, I?: number): number;
|
|
166
|
+
export { length as size };
|
|
167
|
+
/**
|
|
168
|
+
* Resize an array to given length!
|
|
169
|
+
* @param x an array
|
|
170
|
+
* @param n new length
|
|
171
|
+
* @param vd default value
|
|
172
|
+
* @returns resized x
|
|
173
|
+
*/ export declare function resize$<T>(x: T[], n: number, vd: T): T[];
|
|
174
|
+
/**
|
|
175
|
+
* Remove all elements from an array!
|
|
176
|
+
* @param x an array (updated!)
|
|
177
|
+
* @returns cleared x
|
|
178
|
+
*/ export declare function clear$<T>(x: T[]): T[];
|
|
179
|
+
/**
|
|
180
|
+
* Get value at index.
|
|
181
|
+
* @param x an array
|
|
182
|
+
* @param i index
|
|
183
|
+
* @returns x[i]
|
|
184
|
+
*/ export declare function get<T>(x: T[], i: number): T;
|
|
185
|
+
export { get as at };
|
|
186
|
+
/**
|
|
187
|
+
* Get values at indices.
|
|
188
|
+
* @param x an array
|
|
189
|
+
* @param is indices
|
|
190
|
+
* @returns [x[i₀], x[i₁], ...] | [i₀, i₁, ...] = is
|
|
191
|
+
*/ export declare function getAll<T>(x: T[], is: number[]): T[];
|
|
192
|
+
/**
|
|
193
|
+
* Get value at path in a nested array.
|
|
194
|
+
* @param x a nested array
|
|
195
|
+
* @param p path
|
|
196
|
+
* @returns x[i₀][i₁][...] | [i₀, i₁, ...] = p
|
|
197
|
+
*/ export declare function getPath(x: unknown[], p: number[]): unknown;
|
|
198
|
+
/**
|
|
199
|
+
* Check if nested array has a path.
|
|
200
|
+
* @param x a nested array
|
|
201
|
+
* @param p path
|
|
202
|
+
* @returns x[i₀][i₁][...] exists? | [i₀, i₁, ...] = p
|
|
203
|
+
*/ export declare function hasPath(x: unknown[], p: number[]): boolean;
|
|
204
|
+
/**
|
|
205
|
+
* Set value at index.
|
|
206
|
+
* @param x an array
|
|
207
|
+
* @param i index
|
|
208
|
+
* @param v value
|
|
209
|
+
* @returns x' | x' = x; x'[i] = v
|
|
210
|
+
*/ export declare function set<T>(x: T[], i: number, v: T): T[];
|
|
211
|
+
export { set as with };
|
|
212
|
+
/**
|
|
213
|
+
* Set value at index!
|
|
214
|
+
* @param x an array (updated!)
|
|
215
|
+
* @param i index
|
|
216
|
+
* @param v value
|
|
217
|
+
* @returns x | x[i] = v
|
|
218
|
+
*/ export declare function set$<T>(x: T[], i: number, v: T): T[];
|
|
219
|
+
/**
|
|
220
|
+
* Set value at path in a nested array!
|
|
221
|
+
* @param x a nested array (updated!)
|
|
222
|
+
* @param p path
|
|
223
|
+
* @param v value
|
|
224
|
+
* @returns x | x[i₀][i₁][...] = v; [i₀, i₁, ...] = p
|
|
225
|
+
*/ export declare function setPath$(x: unknown[], p: number[], v: unknown): unknown[];
|
|
226
|
+
/**
|
|
227
|
+
* Exchange two values.
|
|
228
|
+
* @param x an array
|
|
229
|
+
* @param i an index
|
|
230
|
+
* @param j another index
|
|
231
|
+
* @returns x' | x' = x; x'[i] = x[j]; x'[j] = x[i]
|
|
232
|
+
*/ export declare function swap<T>(x: T[], i: number, j: number): T[];
|
|
233
|
+
/**
|
|
234
|
+
* Exchange two values!
|
|
235
|
+
* @param x an array (updated!)
|
|
236
|
+
* @param i an index
|
|
237
|
+
* @param j another index
|
|
238
|
+
* @returns x | x[i] ⇔ x[j]
|
|
239
|
+
*/ export declare function swap$<T>(x: T[], i: number, j: number): T[];
|
|
240
|
+
/**
|
|
241
|
+
* Exchange two ranges of values.
|
|
242
|
+
* @param x an array
|
|
243
|
+
* @param i begin index of first range
|
|
244
|
+
* @param I end index of first range (exclusive)
|
|
245
|
+
* @param j begin index of second range
|
|
246
|
+
* @param J end index of second range (exclusive)
|
|
247
|
+
* @returns x' | x' = x; x'[i..I] = x[j..J]; x'[j..J] = x[i..I]
|
|
248
|
+
*/ export declare function swapRanges<T>(x: T[], i: number, I: number, j: number, J: number): T[];
|
|
249
|
+
/**
|
|
250
|
+
* Exchange two ranges of values!
|
|
251
|
+
* @param x an array (updated!)
|
|
252
|
+
* @param i begin index of first range
|
|
253
|
+
* @param I end index of first range (exclusive)
|
|
254
|
+
* @param j begin index of second range
|
|
255
|
+
* @param J end index of second range (exclusive)
|
|
256
|
+
* @returns x | x[i..I] ⇔ x[j..J]
|
|
257
|
+
*/ export declare function swapRanges$<T>(x: T[], i: number, I: number, j: number, J: number): T[];
|
|
258
|
+
/**
|
|
259
|
+
* Remove value at index.
|
|
260
|
+
* @param x an array
|
|
261
|
+
* @param i index
|
|
262
|
+
* @returns x[0..i] ⧺ x[i+1..]
|
|
263
|
+
*/ export declare function remove<T>(x: T[], i: number): T[];
|
|
264
|
+
/**
|
|
265
|
+
* Remove value at index!
|
|
266
|
+
* @param x an array (updated!)
|
|
267
|
+
* @param i index
|
|
268
|
+
* @returns x \\: [i]
|
|
269
|
+
*/ export declare function remove$<T>(x: T[], i: number): T[];
|
|
270
|
+
/**
|
|
271
|
+
* Remove value at path in a nested array!
|
|
272
|
+
* @param x a nested array (updated!)
|
|
273
|
+
* @param p path
|
|
274
|
+
* @returns x \\: [i₀][i₁][...] | [i₀, i₁, ...] = p
|
|
275
|
+
*/ export declare function removePath$(x: unknown[], p: number[]): unknown[];
|
|
276
|
+
/**
|
|
277
|
+
* Examine if array is sorted.
|
|
278
|
+
* @param x an array
|
|
279
|
+
* @param fc compare function (a, b)
|
|
280
|
+
* @param fm map function (v, i, x)
|
|
281
|
+
* @returns x is sorted?
|
|
282
|
+
*/ export declare function isSorted<T, U = T>(x: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): boolean;
|
|
283
|
+
/**
|
|
284
|
+
* Examine if array has an unsorted value.
|
|
285
|
+
* @param x an array
|
|
286
|
+
* @param fc compare function (a, b)
|
|
287
|
+
* @param fm map function (v, i, x)
|
|
288
|
+
* @returns x is not sorted?
|
|
289
|
+
*/ export declare function hasUnsortedValue<T, U = T>(x: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): boolean;
|
|
290
|
+
/**
|
|
291
|
+
* Find first index of an unsorted value.
|
|
292
|
+
* @param x an array
|
|
293
|
+
* @param fc compare function (a, b)
|
|
294
|
+
* @param fm map function (v, i, x)
|
|
295
|
+
* @returns index of first unsorted value, -1 if sorted
|
|
296
|
+
*/ export declare function searchUnsortedValue<T, U = T>(x: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): number;
|
|
297
|
+
/**
|
|
298
|
+
* Arrange values in order.
|
|
299
|
+
* @param x an array
|
|
300
|
+
* @param fc compare function (a, b)
|
|
301
|
+
* @param fm map function (v, i, x)
|
|
302
|
+
* @param fs swap function (x, i, j)
|
|
303
|
+
* @returns x' | x' = x; x'[i] ≤ x'[j] ∀ i ≤ j
|
|
304
|
+
*/ export declare function sort<T, U = T>(x: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null, fs?: SwapFunction<T> | null): T[];
|
|
305
|
+
export { sort as toSorted };
|
|
306
|
+
/**
|
|
307
|
+
* Arrange values in order!
|
|
308
|
+
* @param x an array (updated!)
|
|
309
|
+
* @param fc compare function (a, b)
|
|
310
|
+
* @param fm map function (v, i, x)
|
|
311
|
+
* @param fs swap function (x, i, j)
|
|
312
|
+
* @returns x | x[i] ≤ x[j] ∀ i ≤ j
|
|
313
|
+
*/ export declare function sort$<T, U = T>(x: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null, fs?: SwapFunction<T> | null): T[];
|
|
314
|
+
/**
|
|
315
|
+
* Arrange a range of values in order.
|
|
316
|
+
* @param x an array
|
|
317
|
+
* @param i begin index
|
|
318
|
+
* @param I end index (exclusive)
|
|
319
|
+
* @param fc compare function (a, b)
|
|
320
|
+
* @param fm map function (v, i, x)
|
|
321
|
+
* @param fs swap function (x, i, j)
|
|
322
|
+
* @returns x' | x' = x; x'[i] ≤ x'[j] ∀ i ≤ j
|
|
323
|
+
*/ export declare function rangedSort<T, U = T>(x: T[], i: number, I: number, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null, fs?: SwapFunction<T> | null): T[];
|
|
324
|
+
/**
|
|
325
|
+
* Arrange a range of values in order!
|
|
326
|
+
* @param x an array (updated!)
|
|
327
|
+
* @param i begin index
|
|
328
|
+
* @param I end index (exclusive)
|
|
329
|
+
* @param fc compare function (a, b)
|
|
330
|
+
* @param fm map function (v, i, x)
|
|
331
|
+
* @param fs swap function (x, i, j)
|
|
332
|
+
* @returns x | x[i] ≤ x[j] ∀ i ≤ j
|
|
333
|
+
*/ export declare function rangedSort$<T, U = T>(x: T[], i: number, I: number, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null, fs?: SwapFunction<T> | null): T[];
|
|
334
|
+
/**
|
|
335
|
+
* Partially arrange values in order.
|
|
336
|
+
* @param x an array
|
|
337
|
+
* @param n minimum number of values to sort
|
|
338
|
+
* @param fc compare function (a, b)
|
|
339
|
+
* @param fm map function (v, i, x)
|
|
340
|
+
* @param fs swap function (x, i, j)
|
|
341
|
+
* @returns x' | x' = x; x'[i] ≤ x'[j] ∀ i ≤ j
|
|
342
|
+
*/ export declare function partialSort<T, U = T>(x: T[], n: number, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null, fs?: SwapFunction<T> | null): T[];
|
|
343
|
+
/**
|
|
344
|
+
* Partially arrange values in order!
|
|
345
|
+
* @param x an array (updated!)
|
|
346
|
+
* @param n minimum number of values to sort
|
|
347
|
+
* @param fc compare function (a, b)
|
|
348
|
+
* @param fm map function (v, i, x)
|
|
349
|
+
* @param fs swap function (x, i, j)
|
|
350
|
+
* @returns x | x[i] ≤ x[j] ∀ i ≤ j
|
|
351
|
+
*/ export declare function partialSort$<T, U = T>(x: T[], n: number, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null, fs?: SwapFunction<T> | null): T[];
|
|
352
|
+
/**
|
|
353
|
+
* Partially arrange a range of values in order.
|
|
354
|
+
* @param x an array
|
|
355
|
+
* @param i begin index
|
|
356
|
+
* @param I end index (exclusive)
|
|
357
|
+
* @param n minimum number of values to sort
|
|
358
|
+
* @param fc compare function (a, b)
|
|
359
|
+
* @param fm map function (v, i, x)
|
|
360
|
+
* @param fs swap function (x, i, j)
|
|
361
|
+
* @returns x' | x' = x; x'[i] ≤ x'[j] ∀ i ≤ j
|
|
362
|
+
*/ export declare function rangedPartialSort<T, U = T>(x: T[], i: number, I: number, n: number, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null, fs?: SwapFunction<T> | null): T[];
|
|
363
|
+
/**
|
|
364
|
+
* Partially arrange a range of values in order!
|
|
365
|
+
* @param x an array (updated!)
|
|
366
|
+
* @param i begin index
|
|
367
|
+
* @param I end index (exclusive)
|
|
368
|
+
* @param n minimum number of values to sort
|
|
369
|
+
* @param fc compare function (a, b)
|
|
370
|
+
* @param fm map function (v, i, x)
|
|
371
|
+
* @param fs swap function (x, i, j)
|
|
372
|
+
* @returns x | x[i] ≤ x[j] ∀ i ≤ j
|
|
373
|
+
*/ export declare function rangedPartialSort$<T, U = T>(x: T[], i: number, I: number, n: number, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null, fs?: SwapFunction<T> | null): T[];
|
|
374
|
+
/**
|
|
375
|
+
* Find first smallest value.
|
|
376
|
+
* @param x an array
|
|
377
|
+
* @param fc compare function (a, b)
|
|
378
|
+
* @param fm map function (v, i, x)
|
|
379
|
+
* @returns v | v ≤ vᵢ; vᵢ ∈ x
|
|
380
|
+
*/ export declare function minimum<T, U = T>(x: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): T;
|
|
381
|
+
export { minimum as min };
|
|
382
|
+
/**
|
|
383
|
+
* Find first smallest entry.
|
|
384
|
+
* @param x an array
|
|
385
|
+
* @param fc compare function (a, b)
|
|
386
|
+
* @param fm map function (v, i, x)
|
|
387
|
+
* @returns [min_index, min_value]
|
|
388
|
+
*/ export declare function minimumEntry<T, U = T>(x: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): [number, T];
|
|
389
|
+
export { minimumEntry as minEntry };
|
|
390
|
+
/**
|
|
391
|
+
* Find first largest value.
|
|
392
|
+
* @param x an array
|
|
393
|
+
* @param fc compare function (a, b)
|
|
394
|
+
* @param fm map function (v, i, x)
|
|
395
|
+
* @returns v | v ≥ vᵢ; vᵢ ∈ x
|
|
396
|
+
*/ export declare function maximum<T, U = T>(x: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): T;
|
|
397
|
+
export { maximum as max };
|
|
398
|
+
/**
|
|
399
|
+
* Find first largest entry.
|
|
400
|
+
* @param x an array
|
|
401
|
+
* @param fc compare function (a, b)
|
|
402
|
+
* @param fm map function (v, i, x)
|
|
403
|
+
* @returns [max_index, max_value]
|
|
404
|
+
*/ export declare function maximumEntry<T, U = T>(x: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): [number, T];
|
|
405
|
+
export { maximumEntry as maxEntry };
|
|
406
|
+
/**
|
|
407
|
+
* Find smallest and largest values.
|
|
408
|
+
* @param x an array
|
|
409
|
+
* @param fc compare function (a, b)
|
|
410
|
+
* @param fm map function (v, i, x)
|
|
411
|
+
* @returns [min_value, max_value]
|
|
412
|
+
*/ export declare function range<T, U = T>(x: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): [T | undefined, T | undefined];
|
|
413
|
+
/**
|
|
414
|
+
* Find smallest and largest entries.
|
|
415
|
+
* @param x an array
|
|
416
|
+
* @param fc compare function (a, b)
|
|
417
|
+
* @param fm map function (v, i, x)
|
|
418
|
+
* @returns [min_entry, max_entry]
|
|
419
|
+
*/ export declare function rangeEntries<T, U = T>(x: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): [[number, T | undefined], [number, T | undefined]];
|
|
420
|
+
/**
|
|
421
|
+
* Find smallest values.
|
|
422
|
+
* @param x an array
|
|
423
|
+
* @param n number of values
|
|
424
|
+
* @param fc compare function (a, b)
|
|
425
|
+
* @param fm map function (v, i, x)
|
|
426
|
+
* @returns n smallest values in ascending order
|
|
427
|
+
*/ export declare function minimums<T, U = T>(x: T[], n: number, fc?: CompareFunction<number | T | U> | null, fm?: MapFunction<T, T | U> | null): T[];
|
|
428
|
+
/**
|
|
429
|
+
* Find smallest entries.
|
|
430
|
+
* @param x an array
|
|
431
|
+
* @param n number of values
|
|
432
|
+
* @param fc compare function (a, b)
|
|
433
|
+
* @param fm map function (v, i, x)
|
|
434
|
+
* @returns n smallest entries in ascending order
|
|
435
|
+
*/ export declare function minimumEntries<T, U = T>(x: T[], n: number, fc?: CompareFunction<number | T | U> | null, fm?: MapFunction<T, T | U> | null): [number, T][];
|
|
436
|
+
/**
|
|
437
|
+
* Find largest values.
|
|
438
|
+
* @param x an array
|
|
439
|
+
* @param n number of values
|
|
440
|
+
* @param fc compare function (a, b)
|
|
441
|
+
* @param fm map function (v, i, x)
|
|
442
|
+
* @returns n largest values in descending order
|
|
443
|
+
*/ export declare function maximums<T, U = T>(x: T[], n: number, fc?: CompareFunction<number | T | U> | null, fm?: MapFunction<T, T | U> | null): T[];
|
|
444
|
+
/**
|
|
445
|
+
* Find largest entries.
|
|
446
|
+
* @param x an array
|
|
447
|
+
* @param n number of values
|
|
448
|
+
* @param fc compare function (a, b)
|
|
449
|
+
* @param fm map function (v, i, x)
|
|
450
|
+
* @returns n largest entries in descending order
|
|
451
|
+
*/ export declare function maximumEntries<T, U = T>(x: T[], n: number, fc?: CompareFunction<number | T | U> | null, fm?: MapFunction<T, T | U> | null): [number, T][];
|
|
452
|
+
/**
|
|
453
|
+
* Find first index of minimum value.
|
|
454
|
+
* @param x an array
|
|
455
|
+
* @param fc compare function (a, b)
|
|
456
|
+
* @param fm map function (v, i, x)
|
|
457
|
+
* @returns first index of minimum value, -1 if empty
|
|
458
|
+
*/ export declare function searchMinimumValue<T, U = T>(x: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): number;
|
|
459
|
+
/**
|
|
460
|
+
* Find first index of maximum value.
|
|
461
|
+
* @param x an array
|
|
462
|
+
* @param fc compare function (a, b)
|
|
463
|
+
* @param fm map function (v, i, x)
|
|
464
|
+
* @returns first index of maximum value, -1 if empty
|
|
465
|
+
*/ export declare function searchMaximumValue<T, U = T>(x: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): number;
|
|
466
|
+
/**
|
|
467
|
+
* Find indices of minimum values.
|
|
468
|
+
* @param x an array
|
|
469
|
+
* @param n number of values
|
|
470
|
+
* @param fc compare function (a, b)
|
|
471
|
+
* @param fm map function (v, i, x)
|
|
472
|
+
* @returns indices of minimum values in ascending order
|
|
473
|
+
*/ export declare function searchMinimumValues<T, U = T>(x: T[], n: number, fc?: CompareFunction<number | T | U> | null, fm?: MapFunction<T, T | U> | null): number[];
|
|
474
|
+
/**
|
|
475
|
+
* Find indices of maximum values.
|
|
476
|
+
* @param x an array
|
|
477
|
+
* @param n number of values
|
|
478
|
+
* @param fc compare function (a, b)
|
|
479
|
+
* @param fm map function (v, i, x)
|
|
480
|
+
* @returns indices of maximum values in descending order
|
|
481
|
+
*/ export declare function searchMaximumValues<T, U = T>(x: T[], n: number, fc?: CompareFunction<number | T | U> | null, fm?: MapFunction<T, T | U> | null): number[];
|
|
482
|
+
/**
|
|
483
|
+
* Examine if two arrays are equal.
|
|
484
|
+
* @param x an array
|
|
485
|
+
* @param y another array
|
|
486
|
+
* @param fc compare function (a, b)
|
|
487
|
+
* @param fm map function (v, i, x)
|
|
488
|
+
* @returns x = y?
|
|
489
|
+
*/ export declare function isEqual<T, U = T>(x: T[], y: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): boolean;
|
|
490
|
+
/**
|
|
491
|
+
* Compare two arrays (lexicographically).
|
|
492
|
+
* @param x an array
|
|
493
|
+
* @param y another array
|
|
494
|
+
* @param fc compare function (a, b)
|
|
495
|
+
* @param fm map function (v, i, x)
|
|
496
|
+
* @returns x<y: -ve, x=y: 0, x>y: +ve
|
|
497
|
+
*/ export declare function compare<T, U = T>(x: T[], y: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): number;
|
|
498
|
+
/**
|
|
499
|
+
* Get first value.
|
|
500
|
+
* @param x an array
|
|
501
|
+
* @param vd default value
|
|
502
|
+
* @returns x[0] || vd
|
|
503
|
+
*/ export declare function head<T>(x: T[], vd?: T): T | undefined;
|
|
504
|
+
export { head as front };
|
|
505
|
+
export { head as first };
|
|
506
|
+
/**
|
|
507
|
+
* Get values except first.
|
|
508
|
+
* @param x an array
|
|
509
|
+
* @returns x[1..|x|]
|
|
510
|
+
*/ export declare function tail<T>(x: T[]): T[];
|
|
511
|
+
/**
|
|
512
|
+
* Get values except last.
|
|
513
|
+
* @param x an array
|
|
514
|
+
* @returns x[0..|x|-1]
|
|
515
|
+
*/ export declare function init<T>(x: T[]): T[];
|
|
516
|
+
/**
|
|
517
|
+
* Get last value.
|
|
518
|
+
* @param x an array
|
|
519
|
+
* @param vd default value
|
|
520
|
+
* @returns x[|x|-1] || vd
|
|
521
|
+
*/ export declare function last<T>(x: T[], vd?: T): T | undefined;
|
|
522
|
+
export { last as back };
|
|
523
|
+
/**
|
|
524
|
+
* Get values from middle.
|
|
525
|
+
* @param x an array
|
|
526
|
+
* @param i begin index
|
|
527
|
+
* @param n number of values [1]
|
|
528
|
+
* @returns x[i..i+n]
|
|
529
|
+
*/ export declare function middle<T>(x: T[], i: number, n?: number): T[];
|
|
530
|
+
/**
|
|
531
|
+
* Get part of an array.
|
|
532
|
+
* @param x an array
|
|
533
|
+
* @param i begin index [0]
|
|
534
|
+
* @param I end index [|x|]
|
|
535
|
+
* @returns x[i..I]
|
|
536
|
+
*/ export declare function slice<T>(x: T[], i?: number, I?: number): T[];
|
|
537
|
+
/**
|
|
538
|
+
* Get part of an array!
|
|
539
|
+
* @param x an array (updated!)
|
|
540
|
+
* @param i begin index [0]
|
|
541
|
+
* @param I end index [|x|]
|
|
542
|
+
* @returns x = x[i..I]
|
|
543
|
+
*/ export declare function slice$<T>(x: T[], i?: number, I?: number): T[];
|
|
544
|
+
/**
|
|
545
|
+
* Check if array has a value.
|
|
546
|
+
* @param x an array
|
|
547
|
+
* @param v search value
|
|
548
|
+
* @param i begin index [0]
|
|
549
|
+
* @returns v ∈ x[i..]?
|
|
550
|
+
*/ export declare function includes<T>(x: T[], v: T, i?: number): boolean;
|
|
551
|
+
/**
|
|
552
|
+
* Examine if array has a value.
|
|
553
|
+
* @param x an array
|
|
554
|
+
* @param v search value
|
|
555
|
+
* @param fc compare function (a, b)
|
|
556
|
+
* @param fm map function (v, i, x)
|
|
557
|
+
* @returns v ∈ x?
|
|
558
|
+
*/ export declare function hasValue<T, U = T>(x: T[], v: T, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): boolean;
|
|
559
|
+
/**
|
|
560
|
+
* Find first index of a value.
|
|
561
|
+
* @param x an array
|
|
562
|
+
* @param v search value
|
|
563
|
+
* @param fc compare function (a, b)
|
|
564
|
+
* @param fm map function (v, i, x)
|
|
565
|
+
* @returns first index of value, -1 if not found
|
|
566
|
+
*/ export declare function searchValue<T, U = T>(x: T[], v: T, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): number;
|
|
567
|
+
/**
|
|
568
|
+
* Find last index of a value.
|
|
569
|
+
* @param x an array
|
|
570
|
+
* @param v search value
|
|
571
|
+
* @param fc compare function (a, b)
|
|
572
|
+
* @param fm map function (v, i, x)
|
|
573
|
+
* @returns last index of value, -1 if not found
|
|
574
|
+
*/ export declare function searchValueRight<T, U = T>(x: T[], v: T, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): number;
|
|
575
|
+
/**
|
|
576
|
+
* Find indices of value.
|
|
577
|
+
* @param x an array
|
|
578
|
+
* @param v search value
|
|
579
|
+
* @param fc compare function (a, b)
|
|
580
|
+
* @param fm map function (v, i, x)
|
|
581
|
+
* @returns indices of value
|
|
582
|
+
*/ export declare function searchValueAll<T, U = T>(x: T[], v: T, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): number[];
|
|
583
|
+
/**
|
|
584
|
+
* Find first index of an adjacent duplicate value.
|
|
585
|
+
* @param x an array
|
|
586
|
+
* @param fc compare function (a, b)
|
|
587
|
+
* @param fm map function (v, i, x)
|
|
588
|
+
* @returns index of first adjacent duplicate value, -1 if none
|
|
589
|
+
*/ export declare function searchAdjacentDuplicateValue<T, U = T>(x: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): number;
|
|
590
|
+
export { searchAdjacentDuplicateValue as searchAdjacentDuplicate };
|
|
591
|
+
/**
|
|
592
|
+
* Find first index where two arrays differ.
|
|
593
|
+
* @param x an array
|
|
594
|
+
* @param y another array
|
|
595
|
+
* @param fc compare function (a, b)
|
|
596
|
+
* @param fm map function (v, i, x)
|
|
597
|
+
* @returns first index where x[i] ≠ y[i], or -1
|
|
598
|
+
*/ export declare function searchMismatchedValue<T, U = T>(x: T[], y: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): number;
|
|
599
|
+
export { searchMismatchedValue as searchMismatch };
|
|
600
|
+
/**
|
|
601
|
+
* Examine if array starts with a prefix.
|
|
602
|
+
* @param x an array
|
|
603
|
+
* @param y search prefix
|
|
604
|
+
* @param fc compare function (a, b)
|
|
605
|
+
* @param fm map function (v, i, x)
|
|
606
|
+
* @returns x[0..|y|] = y?
|
|
607
|
+
*/ export declare function hasPrefix<T, U = T>(x: T[], y: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): boolean;
|
|
608
|
+
export { hasPrefix as startsWith };
|
|
609
|
+
/**
|
|
610
|
+
* Examine if array ends with a suffix.
|
|
611
|
+
* @param x an array
|
|
612
|
+
* @param y search suffix
|
|
613
|
+
* @param fc compare function (a, b)
|
|
614
|
+
* @param fm map function (v, i, x)
|
|
615
|
+
* @returns x[|x|-|y|..] = y?
|
|
616
|
+
*/ export declare function hasSuffix<T, U = T>(x: T[], y: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): boolean;
|
|
617
|
+
export { hasSuffix as endsWith };
|
|
618
|
+
/**
|
|
619
|
+
* Examine if array contains an infix.
|
|
620
|
+
* @param x an array
|
|
621
|
+
* @param y search infix
|
|
622
|
+
* @param fc compare function (a, b)
|
|
623
|
+
* @param fm map function (v, i, x)
|
|
624
|
+
* @returns x[i..I] = y for some i, I?
|
|
625
|
+
*/ export declare function hasInfix<T, U = T>(x: T[], y: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): boolean;
|
|
626
|
+
/**
|
|
627
|
+
* Examine if array has a subsequence.
|
|
628
|
+
* @param x an array
|
|
629
|
+
* @param y search subsequence
|
|
630
|
+
* @param fc compare function (a, b)
|
|
631
|
+
* @param fm map function (v, i, x)
|
|
632
|
+
* @returns x[i₀] ⧺ x[i₁] ⧺ ... = y, for some i₀, i₁, ...? | i₀ < i₁ < ...
|
|
633
|
+
*/ export declare function hasSubsequence<T, U = T>(x: T[], y: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): boolean;
|
|
634
|
+
/**
|
|
635
|
+
* Examine if array has a permutation.
|
|
636
|
+
* @param x an array
|
|
637
|
+
* @param y search permutation
|
|
638
|
+
* @param fc map function (v, i, x)
|
|
639
|
+
* @param fm compare function (a, b)
|
|
640
|
+
* @returns x contains a shuffled version of y?
|
|
641
|
+
*/ export declare function hasPermutation<T, U = T>(x: T[], y: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): boolean;
|
|
642
|
+
/**
|
|
643
|
+
* Obtain all possible prefixes.
|
|
644
|
+
* @param x an array
|
|
645
|
+
* @param n number of values [-1 ⇒ any]
|
|
646
|
+
* @returns [[], x[..1], x[..2], ...] if n<0; [x[..n]] otherwise
|
|
647
|
+
*/ export declare function prefixes<T>(x: T[], n?: number): T[][];
|
|
648
|
+
/**
|
|
649
|
+
* List all possible prefixes.
|
|
650
|
+
* @param x an array
|
|
651
|
+
* @param n number of values [-1 ⇒ any]
|
|
652
|
+
* @returns [], x[..1], x[..2], ... if n<0; x[..n] otherwise
|
|
653
|
+
*/ export declare function iprefixes<T>(x: T[], n?: number): IterableIterator<T[]>;
|
|
654
|
+
/**
|
|
655
|
+
* Obtain all possible suffixes.
|
|
656
|
+
* @param x an array
|
|
657
|
+
* @param n number of values [-1 ⇒ any]
|
|
658
|
+
* @returns [x[0..], x[1..], x[2..], ...] if n<0; [x[-n..]] otherwise
|
|
659
|
+
*/ export declare function suffixes<T>(x: T[], n?: number): T[][];
|
|
660
|
+
/**
|
|
661
|
+
* List all possible suffixes.
|
|
662
|
+
* @param x an array
|
|
663
|
+
* @param n number of values [-1 ⇒ any]
|
|
664
|
+
* @returns x[0..], x[1..], x[2..], ... if n<0; x[-n..] otherwise
|
|
665
|
+
*/ export declare function isuffixes<T>(x: T[], n?: number): IterableIterator<T[]>;
|
|
666
|
+
/**
|
|
667
|
+
* Obtain all possible infixes.
|
|
668
|
+
* @param x an array
|
|
669
|
+
* @param n number of values [-1 ⇒ any]
|
|
670
|
+
* @returns [[], x[0..1], x[0..2], ..., x[1..2], ...] if n<0; [only of length n] otherwise
|
|
671
|
+
*/ export declare function infixes<T>(x: T[], n?: number): T[][];
|
|
672
|
+
/**
|
|
673
|
+
* List all possible infixes.
|
|
674
|
+
* @param x an array
|
|
675
|
+
* @param n number of values [-1 ⇒ any]
|
|
676
|
+
* @returns [], x[0..1], x[0..2], ..., x[1..2], ... if n<0; only of length n otherwise
|
|
677
|
+
*/ export declare function iinfixes<T>(x: T[], n?: number): IterableIterator<T[]>;
|
|
678
|
+
/**
|
|
679
|
+
* Obtain all possible subsequences.
|
|
680
|
+
* @param x an array
|
|
681
|
+
* @param n number of values [-1 ⇒ any]
|
|
682
|
+
* @returns [elements selected by bit from 0..2^|x|] if n<0; [only of length n] otherwise
|
|
683
|
+
*/ export declare function subsequences<T>(x: T[], n?: number): T[][];
|
|
684
|
+
/**
|
|
685
|
+
* List all possible subsequences.
|
|
686
|
+
* @param x an array
|
|
687
|
+
* @param n number of values [-1 ⇒ any]
|
|
688
|
+
* @returns elements selected by bit from 0..2^|x| if n<0; only of length n otherwise
|
|
689
|
+
*/ export declare function isubsequences<T>(x: T[], n?: number): IterableIterator<T[]>;
|
|
690
|
+
/**
|
|
691
|
+
* Obtain all possible permutations.
|
|
692
|
+
* @param x an array
|
|
693
|
+
* @param n number of values [-1 ⇒ any]
|
|
694
|
+
* @returns [[], arrangements of length 1, of length 2, ...] if n<0; [only of length n] otherwise
|
|
695
|
+
*/ export declare function permutations<T>(x: T[], n?: number): T[][];
|
|
696
|
+
/**
|
|
697
|
+
* List all possible permutations.
|
|
698
|
+
* @param x an array
|
|
699
|
+
* @param n number of values [-1 ⇒ any]
|
|
700
|
+
* @returns [], arrangements of length 1, of length 2, ... if n<0; only of length n otherwise
|
|
701
|
+
*/ export declare function ipermutations<T>(x: T[], n?: number): IterableIterator<T[]>;
|
|
702
|
+
/**
|
|
703
|
+
* Find first index of an infix.
|
|
704
|
+
* @param x an array
|
|
705
|
+
* @param y search infix
|
|
706
|
+
* @param fc compare function (a, b)
|
|
707
|
+
* @param fm map function (v, i, x)
|
|
708
|
+
* @returns first i | x[i..i+|y|] = y else -1
|
|
709
|
+
*/ export declare function searchInfix<T, U = T>(x: T[], y: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): number;
|
|
710
|
+
/**
|
|
711
|
+
* Find last index of an infix.
|
|
712
|
+
* @param x an array
|
|
713
|
+
* @param y search infix
|
|
714
|
+
* @param fc compare function (a, b)
|
|
715
|
+
* @param fm map function (v, i, x)
|
|
716
|
+
* @returns first i | x[i..i+|y|] = y else -1
|
|
717
|
+
*/ export declare function searchInfixRight<T, U = T>(x: T[], y: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): number;
|
|
718
|
+
/**
|
|
719
|
+
* Find indices of an infix.
|
|
720
|
+
* @param x an array
|
|
721
|
+
* @param y search infix
|
|
722
|
+
* @param fc compare function (a, b)
|
|
723
|
+
* @param fm map function (v, i, x)
|
|
724
|
+
* @returns i₀, i₁, ... | x[j..j+|y|] = y; j ∈ [i₀, i₁, ...]
|
|
725
|
+
*/ export declare function searchInfixAll<T, U = T>(x: T[], y: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): number[];
|
|
726
|
+
/**
|
|
727
|
+
* Find first index of a subsequence.
|
|
728
|
+
* @param x an array
|
|
729
|
+
* @param y search subsequence
|
|
730
|
+
* @param fc compare function (a, b)
|
|
731
|
+
* @param fm map function (v, i, x)
|
|
732
|
+
* @returns begin index of subsequence, -1 if not found
|
|
733
|
+
*/ export declare function searchSubsequence<T, U = T>(x: T[], y: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): number;
|
|
734
|
+
/**
|
|
735
|
+
* Pick an arbitrary value.
|
|
736
|
+
* @param x an array
|
|
737
|
+
* @param fr random number generator ([0, 1))
|
|
738
|
+
* @returns x[i] | i ∈ 0..|x|
|
|
739
|
+
*/ export declare function randomValue<T>(x: T[], fr?: ReadFunction<number> | null): T;
|
|
740
|
+
export { randomValue as value };
|
|
741
|
+
/**
|
|
742
|
+
* Pick an arbitrary prefix.
|
|
743
|
+
* @param x an array
|
|
744
|
+
* @param n number of values [-1 ⇒ any]
|
|
745
|
+
* @param fr random number generator ([0, 1))
|
|
746
|
+
* @returns x[..i] if n<0; x[..n] otherwise | i ∈ 0..|x|
|
|
747
|
+
*/ export declare function randomPrefix<T>(x: T[], n?: number, fr?: ReadFunction<number> | null): T[] | null;
|
|
748
|
+
export { randomPrefix as prefix };
|
|
749
|
+
/**
|
|
750
|
+
* Pick an arbitrary suffix.
|
|
751
|
+
* @param x an array
|
|
752
|
+
* @param n number of values [-1 ⇒ any]
|
|
753
|
+
* @param fr random number generator ([0, 1))
|
|
754
|
+
* @returns x[|x|-i..] if n<0; x[|x|-n..] otherwise | i ∈ 0..|x|
|
|
755
|
+
*/ export declare function randomSuffix<T>(x: T[], n?: number, fr?: ReadFunction<number> | null): T[] | null;
|
|
756
|
+
export { randomSuffix as suffix };
|
|
757
|
+
/**
|
|
758
|
+
* Pick an arbitrary infix.
|
|
759
|
+
* @param x an array
|
|
760
|
+
* @param n number of values [-1 ⇒ any]
|
|
761
|
+
* @param fr random number generator ([0, 1))
|
|
762
|
+
* @returns x[i..j] if n<0; x[i..i+n] otherwise | i, j ∈ 0..|x|
|
|
763
|
+
*/ export declare function randomInfix<T>(x: T[], n?: number, fr?: ReadFunction<number> | null): T[] | null;
|
|
764
|
+
export { randomInfix as infix };
|
|
765
|
+
/**
|
|
766
|
+
* Pick an arbitrary subsequence.
|
|
767
|
+
* @param x an array
|
|
768
|
+
* @param n number of values [-1 ⇒ any]
|
|
769
|
+
* @param fr random number generator ([0, 1))
|
|
770
|
+
* @returns x[i, j, ...] | [i, j, ...] = is; |is| = |x| if n<0 else n
|
|
771
|
+
*/ export declare function randomSubsequence<T>(x: T[], n?: number, fr?: ReadFunction<number> | null): T[] | null;
|
|
772
|
+
export { randomSubsequence as subsequence };
|
|
773
|
+
/**
|
|
774
|
+
* Pick an arbitrary permutation.
|
|
775
|
+
* @param x an array
|
|
776
|
+
* @param n number of values [-1 ⇒ any]
|
|
777
|
+
* @param fr random number generator ([0, 1))
|
|
778
|
+
* @returns x' | x' = x; values are randomly shuffled
|
|
779
|
+
*/ export declare function randomPermutation<T>(x: T[], n?: number, fr?: ReadFunction<number> | null): T[] | null;
|
|
780
|
+
export { randomPermutation as permutation };
|
|
781
|
+
/**
|
|
782
|
+
* Pick an arbitrary permutation!
|
|
783
|
+
* @param x an array (updated!)
|
|
784
|
+
* @param n number of values [-1 ⇒ any]
|
|
785
|
+
* @param fr random number generator ([0, 1))
|
|
786
|
+
* @returns x | values are randomly shuffled
|
|
787
|
+
*/ export declare function randomPermutation$<T>(x: T[], n?: number, fr?: ReadFunction<number> | null): T[];
|
|
788
|
+
export { randomPermutation$ as permutation$ };
|
|
789
|
+
export { randomPermutation$ as permute$ };
|
|
790
|
+
export { randomPermutation$ as shuffle$ };
|
|
791
|
+
/**
|
|
792
|
+
* Find first value passing a test.
|
|
793
|
+
* @param x an array
|
|
794
|
+
* @param ft test function (v, i, x)
|
|
795
|
+
* @returns first v | ft(v) = true; v ∈ x
|
|
796
|
+
*/ export declare function find<T>(x: T[], ft: TestFunction<T>): T;
|
|
797
|
+
/**
|
|
798
|
+
* Find last value passing a test.
|
|
799
|
+
* @param x an array
|
|
800
|
+
* @param ft test function (v, i, x)
|
|
801
|
+
* @returns last v | ft(v) = true; v ∈ x
|
|
802
|
+
*/ export declare function findRight<T>(x: T[], ft: TestFunction<T>): T;
|
|
803
|
+
/**
|
|
804
|
+
* Keep first n values only.
|
|
805
|
+
* @param x an array
|
|
806
|
+
* @param n number of values [1]
|
|
807
|
+
* @returns x[0..n]
|
|
808
|
+
*/ export declare function take<T>(x: T[], n?: number): T[];
|
|
809
|
+
export { take as left };
|
|
810
|
+
/**
|
|
811
|
+
* Keep last n values only.
|
|
812
|
+
* @param x an array
|
|
813
|
+
* @param n number of values [1]
|
|
814
|
+
* @returns x[0..n]
|
|
815
|
+
*/ export declare function takeRight<T>(x: T[], n?: number): T[];
|
|
816
|
+
export { takeRight as right };
|
|
817
|
+
/**
|
|
818
|
+
* Keep values from left, while a test passes.
|
|
819
|
+
* @param x an array
|
|
820
|
+
* @param ft test function (v, i, x)
|
|
821
|
+
* @returns x[0..T-1] | ft(x[i]) = true ∀ i ∈ [0, T-1] & ft(x[T]) = false
|
|
822
|
+
*/ export declare function takeWhile<T>(x: T[], ft: TestFunction<T>): T[];
|
|
823
|
+
/**
|
|
824
|
+
* Keep values from right, while a test passes.
|
|
825
|
+
* @param x an array
|
|
826
|
+
* @param ft test function (v, i, x)
|
|
827
|
+
* @returns x[T..] | ft(x[i]) = true ∀ i ∈ [T, |x|-1] & ft(x[T-1]) = false
|
|
828
|
+
*/ export declare function takeWhileRight<T>(x: T[], ft: TestFunction<T>): T[];
|
|
829
|
+
/**
|
|
830
|
+
* Discard first n values only.
|
|
831
|
+
* @param x an array
|
|
832
|
+
* @param n number of values [1]
|
|
833
|
+
* @returns x[n..]
|
|
834
|
+
*/ export declare function drop<T>(x: T[], n?: number): T[];
|
|
835
|
+
/**
|
|
836
|
+
* Discard last n values only.
|
|
837
|
+
* @param x an array
|
|
838
|
+
* @param n number of values [1]
|
|
839
|
+
* @returns x[0..-n]
|
|
840
|
+
*/ export declare function dropRight<T>(x: T[], n?: number): T[];
|
|
841
|
+
/**
|
|
842
|
+
* Discard values from left, while a test passes.
|
|
843
|
+
* @param x an array
|
|
844
|
+
* @param ft test function (v, i, x)
|
|
845
|
+
* @returns x[T..] | ft(x[i]) = true ∀ i ∈ [0, T-1] & ft(x[T]) = false
|
|
846
|
+
*/ export declare function dropWhile<T>(x: T[], ft: TestFunction<T>): T[];
|
|
847
|
+
/**
|
|
848
|
+
* Discard values from right, while a test passes.
|
|
849
|
+
* @param x an array
|
|
850
|
+
* @param ft test function (v, i, x)
|
|
851
|
+
* @returns x[0..T-1] | ft(x[i]) = true ∀ i ∈ [T, |x|-1] & ft(x[T-1]) = false
|
|
852
|
+
*/ export declare function dropWhileRight<T>(x: T[], ft: TestFunction<T>): T[];
|
|
853
|
+
/**
|
|
854
|
+
* Scan from left, while a test passes.
|
|
855
|
+
* @param x an array
|
|
856
|
+
* @param ft test function (v, i, x)
|
|
857
|
+
* @returns first index where test fails
|
|
858
|
+
*/ export declare function scanWhile<T>(x: T[], ft: TestFunction<T>): number;
|
|
859
|
+
/**
|
|
860
|
+
* Scan from right, while a test passes.
|
|
861
|
+
* @param x an array
|
|
862
|
+
* @param ft test function (v, i, x)
|
|
863
|
+
* @returns first index where test passes till end
|
|
864
|
+
*/ export declare function scanWhileRight<T>(x: T[], ft: TestFunction<T>): number;
|
|
865
|
+
/**
|
|
866
|
+
* Scan from left, until a test passes.
|
|
867
|
+
* @param x an array
|
|
868
|
+
* @param ft test function (v, i, x)
|
|
869
|
+
* @returns first index where test passes
|
|
870
|
+
*/ export declare function scanUntil<T>(x: T[], ft: TestFunction<T>): number;
|
|
871
|
+
/**
|
|
872
|
+
* Scan from right, until a test passes.
|
|
873
|
+
* @param x an array
|
|
874
|
+
* @param ft test function (v, i, x)
|
|
875
|
+
* @returns first index where test fails till end
|
|
876
|
+
*/ export declare function scanUntilRight<T>(x: T[], ft: TestFunction<T>): number;
|
|
877
|
+
/**
|
|
878
|
+
* Find first index of a value.
|
|
879
|
+
* @param x an array
|
|
880
|
+
* @param v search value
|
|
881
|
+
* @param i begin index [0]
|
|
882
|
+
* @returns index of v in x[i..] if found else -1
|
|
883
|
+
*/ export declare function indexOf<T>(x: T[], v: T, i?: number): number;
|
|
884
|
+
/**
|
|
885
|
+
* Find last index of a value.
|
|
886
|
+
* @param x an array
|
|
887
|
+
* @param v search value
|
|
888
|
+
* @param i begin index [|x|-1]
|
|
889
|
+
* @returns last index of v in x[0..i] if found else -1
|
|
890
|
+
*/ export declare function lastIndexOf<T>(x: T[], v: T, i?: number): number;
|
|
891
|
+
/**
|
|
892
|
+
* Find index of first value passing a test.
|
|
893
|
+
* @param x an array
|
|
894
|
+
* @param ft test function (v, i, x)
|
|
895
|
+
* @returns first index of value, -1 if not found
|
|
896
|
+
*/ export declare function search<T>(x: T[], ft: TestFunction<T>): number;
|
|
897
|
+
export { search as findIndex };
|
|
898
|
+
/**
|
|
899
|
+
* Find index of last value passing a test.
|
|
900
|
+
* @param x an array
|
|
901
|
+
* @param ft test function (v, i, x)
|
|
902
|
+
* @returns last index of value, -1 if not found
|
|
903
|
+
*/ export declare function searchRight<T>(x: T[], ft: TestFunction<T>): number;
|
|
904
|
+
export { searchRight as findLastIndex };
|
|
905
|
+
/**
|
|
906
|
+
* Find indices of values passing a test.
|
|
907
|
+
* @param x an array
|
|
908
|
+
* @param ft test function (v, i, x)
|
|
909
|
+
* @returns indices of value
|
|
910
|
+
*/ export declare function searchAll<T>(x: T[], ft: TestFunction<T>): number[];
|
|
911
|
+
/**
|
|
912
|
+
* Call a function for each value.
|
|
913
|
+
* @param x an array
|
|
914
|
+
* @param fp process function (v, i, x)
|
|
915
|
+
*/ export declare function forEach<T>(x: T[], fp: ProcessFunction<T>): void;
|
|
916
|
+
/**
|
|
917
|
+
* Examine if any value satisfies a test.
|
|
918
|
+
* @param x an array
|
|
919
|
+
* @param ft test function (v, i, x)
|
|
920
|
+
* @returns true if ft(vᵢ) = true for some vᵢ ∈ x
|
|
921
|
+
*/ export declare function some<T>(x: T[], ft?: TestFunction<T> | null): boolean;
|
|
922
|
+
export { some as anyOf };
|
|
923
|
+
/**
|
|
924
|
+
* Examine if all values satisfy a test.
|
|
925
|
+
* @param x an array
|
|
926
|
+
* @param ft test function (v, i, x)
|
|
927
|
+
* @returns true if ft(vᵢ) = true for all vᵢ ∈ x
|
|
928
|
+
*/ export declare function every<T>(x: T[], ft?: TestFunction<T> | null): boolean;
|
|
929
|
+
export { every as allOf };
|
|
930
|
+
/**
|
|
931
|
+
* Transform values of an array.
|
|
932
|
+
* @param x an array
|
|
933
|
+
* @param fm map function (v, i, x)
|
|
934
|
+
* @returns [fm(v₀), fm(v₁), ...] | vᵢ ∈ x
|
|
935
|
+
*/ export declare function map<T, U = T>(x: T[], fm: MapFunction<T, T | U>): (T | U)[];
|
|
936
|
+
/**
|
|
937
|
+
* Transform values of an array!
|
|
938
|
+
* @param x an array (updated!)
|
|
939
|
+
* @param fm map function (v, i, x)
|
|
940
|
+
* @returns x = [fm(v₀), fm(v₁), ...]; vᵢ ∈ x
|
|
941
|
+
*/ export declare function map$<T>(x: T[], fm: MapFunction<T, T>): T[];
|
|
942
|
+
/**
|
|
943
|
+
* Reduce values of array to a single value.
|
|
944
|
+
* @param x an array
|
|
945
|
+
* @param fr reduce function (acc, v, i, x)
|
|
946
|
+
* @param acc initial value
|
|
947
|
+
* @returns fr(fr(acc, v₀), v₁)... | fr(acc, v₀) = v₀ if acc not given
|
|
948
|
+
*/ export declare function reduce<T, U = T>(x: T[], fr: ReduceFunction<T, T | U>, acc?: T | U): T | U;
|
|
949
|
+
/**
|
|
950
|
+
* Reduce values from right, to a single value.
|
|
951
|
+
* @param x an array
|
|
952
|
+
* @param fr reduce function (acc, v, i, x)
|
|
953
|
+
* @param acc initial value
|
|
954
|
+
* @returns fr(fr(acc, vₓ₋₀), vₓ₋₁)... | fr(acc, vₓ₋₀) = vₓ₋₀ if acc not given
|
|
955
|
+
*/ export declare function reduceRight<T, U = T>(x: T[], fr: ReduceFunction<T, T | U>, acc?: T | U): T | U;
|
|
956
|
+
/**
|
|
957
|
+
* Keep values which pass a test.
|
|
958
|
+
* @param x an array
|
|
959
|
+
* @param ft test function (v, i, x)
|
|
960
|
+
* @returns [v₀, v₁, ...] | ft(vᵢ) = true; vᵢ ∈ x
|
|
961
|
+
*/ export declare function filter<T>(x: T[], ft: TestFunction<T>): T[];
|
|
962
|
+
export { filter as findAll };
|
|
963
|
+
/**
|
|
964
|
+
* Keep values which pass a test!
|
|
965
|
+
* @param x an array (updated!)
|
|
966
|
+
* @param ft test function (v, i, x)
|
|
967
|
+
* @returns x = [v₀, v₁, ...] | ft(vᵢ) = true; vᵢ ∈ x
|
|
968
|
+
*/ export declare function filter$<T>(x: T[], ft: TestFunction<T>): T[];
|
|
969
|
+
/**
|
|
970
|
+
* Keep values at given indices.
|
|
971
|
+
* @param x an array
|
|
972
|
+
* @param is indices
|
|
973
|
+
* @returns v₀, v₁, ... | vᵢ = x[i]; i ∈ is
|
|
974
|
+
*/ export declare function filterAt<T>(x: T[], is: number[]): T[];
|
|
975
|
+
/**
|
|
976
|
+
* Discard values which pass a test.
|
|
977
|
+
* @param x an array
|
|
978
|
+
* @param ft test function (v, i, x)
|
|
979
|
+
* @returns [v₀, v₁, ...] | ft(vᵢ) = false; vᵢ ∈ x
|
|
980
|
+
*/ export declare function reject<T>(x: T[], ft: TestFunction<T>): T[];
|
|
981
|
+
/**
|
|
982
|
+
* Discard values which pass a test!
|
|
983
|
+
* @param x an array (updated!)
|
|
984
|
+
* @param ft test function (v, i, x)
|
|
985
|
+
* @returns x = [v₀, v₁, ...] | ft(vᵢ) = false; vᵢ ∈ x
|
|
986
|
+
*/ export declare function reject$<T>(x: T[], ft: TestFunction<T>): T[];
|
|
987
|
+
/**
|
|
988
|
+
* Discard values at given indices.
|
|
989
|
+
* @param x an array
|
|
990
|
+
* @param is indices
|
|
991
|
+
* @returns [v₀, v₁, ...] | vᵢ = x[i]; i ∉ is
|
|
992
|
+
*/ export declare function rejectAt<T>(x: T[], is: number[]): T[];
|
|
993
|
+
/**
|
|
994
|
+
* Flatten nested array to given depth.
|
|
995
|
+
* @param x a nested array
|
|
996
|
+
* @param n maximum depth [-1 ⇒ all]
|
|
997
|
+
* @param fm map function (v, i, x)
|
|
998
|
+
* @param ft flatten test function (v, i, x) [is]
|
|
999
|
+
* @returns flat iterable
|
|
1000
|
+
*/ export declare function flat(x: unknown[], n?: number, fm?: MapFunction<unknown, unknown> | null, ft?: TestFunction<unknown> | null): unknown[];
|
|
1001
|
+
/**
|
|
1002
|
+
* Flatten nested array, based on map function.
|
|
1003
|
+
* @param x an array
|
|
1004
|
+
* @param fm map function (v, i, x)
|
|
1005
|
+
* @param ft flatten test function (v, i, x) [is]
|
|
1006
|
+
* @returns flat iterable
|
|
1007
|
+
*/ export declare function flatMap(x: unknown[], fm?: MapFunction<unknown, unknown> | null, ft?: TestFunction<unknown> | null): unknown[];
|
|
1008
|
+
/**
|
|
1009
|
+
* Perform exclusive prefix scan from left to right.
|
|
1010
|
+
* @param x an array
|
|
1011
|
+
* @param fr reduce function (acc, v, i, x)
|
|
1012
|
+
* @param acc initial value
|
|
1013
|
+
* @returns [acc, fr(acc, v₀), fr(fr(acc, v₀), v₁)...]
|
|
1014
|
+
*/ export declare function exclusiveScan<T, U = T>(x: T[], fr: ReduceFunction<T, T | U>, acc: T | U): (T | U)[];
|
|
1015
|
+
/**
|
|
1016
|
+
* Perform exclusive prefix scan from left to right!
|
|
1017
|
+
* @param x an array (updated!)
|
|
1018
|
+
* @param fr reduce function (acc, v, i, x)
|
|
1019
|
+
* @param acc initial value
|
|
1020
|
+
* @returns x = [acc, fr(acc, v₀), fr(fr(acc, v₀), v₁)...]
|
|
1021
|
+
*/ export declare function exclusiveScan$<T>(x: T[], fr: ReduceFunction<T, T>, acc: T): T[];
|
|
1022
|
+
/**
|
|
1023
|
+
* Perform inclusive prefix scan from left to right.
|
|
1024
|
+
* @param x an array
|
|
1025
|
+
* @param fr reduce function (acc, v, i, x)
|
|
1026
|
+
* @param acc initial value
|
|
1027
|
+
* @returns [fr(acc, v₀), fr(fr(acc, v₀), v₁)...]
|
|
1028
|
+
*/ export declare function inclusiveScan<T, U = T>(x: T[], fr: ReduceFunction<T, T | U>, acc?: T | U): (T | U)[];
|
|
1029
|
+
export { inclusiveScan as accumulate };
|
|
1030
|
+
/**
|
|
1031
|
+
* Perform inclusive prefix scan from left to right!
|
|
1032
|
+
* @param x an array (updated!)
|
|
1033
|
+
* @param fr reduce function (acc, v, i, x)
|
|
1034
|
+
* @param acc initial value
|
|
1035
|
+
* @returns x = [fr(acc, v₀), fr(fr(acc, v₀), v₁)...]
|
|
1036
|
+
*/ export declare function inclusiveScan$<T>(x: T[], fr: ReduceFunction<T, T>, acc: T): T[];
|
|
1037
|
+
/**
|
|
1038
|
+
* Combine adjacent values of an array.
|
|
1039
|
+
* @param x an array
|
|
1040
|
+
* @param fc combine function (u, v)
|
|
1041
|
+
* @param acc initial value
|
|
1042
|
+
* @returns [fc(acc, v₀), fc(v₀, v₁)...] | vᵢ ∈ x
|
|
1043
|
+
*/ export declare function adjacentCombine<T>(x: T[], fc: CombineFunction<T>, acc: T): T[];
|
|
1044
|
+
/**
|
|
1045
|
+
* Combine adjacent values of an array!
|
|
1046
|
+
* @param x an array (updated!)
|
|
1047
|
+
* @param fc combine function (u, v)
|
|
1048
|
+
* @param acc initial value
|
|
1049
|
+
* @returns x = [fc(acc, v₀), fc(v₀, v₁)...] | vᵢ ∈ x
|
|
1050
|
+
*/ export declare function adjacentCombine$<T>(x: T[], fc: CombineFunction<T>, acc: T): T[];
|
|
1051
|
+
/**
|
|
1052
|
+
* Place a separator between every value.
|
|
1053
|
+
* @param x an array
|
|
1054
|
+
* @param v separator
|
|
1055
|
+
* @returns [x[0], v, x[1], v, ..., x[|x|-1]]
|
|
1056
|
+
*/ export declare function intersperse<T>(x: T[], v: T): T[];
|
|
1057
|
+
/**
|
|
1058
|
+
* Estimate new values between existing ones.
|
|
1059
|
+
* @param x an array
|
|
1060
|
+
* @param fc combine function (a, b)
|
|
1061
|
+
* @returns [x[0], fc(x[0], x[1]), x[1], fc(x[1], x[2]), ..., x[|x|-1]]
|
|
1062
|
+
*/ export declare function interpolate<T>(x: T[], fc: CombineFunction<T>): T[];
|
|
1063
|
+
/**
|
|
1064
|
+
* Place values of an array between another.
|
|
1065
|
+
* @param x an array
|
|
1066
|
+
* @param y another array
|
|
1067
|
+
* @param m number of values from x [1]
|
|
1068
|
+
* @param n number of values from y [1]
|
|
1069
|
+
* @param s step size for x [m]
|
|
1070
|
+
* @param t step size for y [n]
|
|
1071
|
+
* @returns x[0..m] ⧺ y[0..n] ⧺ x[s..s+m] ⧺ y[t..t+n] ⧺ ... ⧺ x[k*s..|x|-1] | k ∈ W
|
|
1072
|
+
*/ export declare function intermix<T>(x: T[], y: T[], m?: number, n?: number, s?: number, t?: number): T[];
|
|
1073
|
+
/**
|
|
1074
|
+
* Place values from iterables alternately.
|
|
1075
|
+
* @param xs arrays
|
|
1076
|
+
* @returns [x₀[0], x₁[0], ..., x₀[1], x₁[0], ...] | [x₀, x₁, ...] = xs
|
|
1077
|
+
*/ export declare function interleave<T>(xs: T[][]): T[];
|
|
1078
|
+
/**
|
|
1079
|
+
* Combine values from arrays.
|
|
1080
|
+
* @param xs arrays
|
|
1081
|
+
* @param fm map function (vs, i)
|
|
1082
|
+
* @param fe end function (dones) [some]
|
|
1083
|
+
* @param vd default value
|
|
1084
|
+
* @returns [fm([x₀[0], x₁[0], ...]), fm([x₀[1], x₁[1], ...]), ...]
|
|
1085
|
+
*/ export declare function zip<T, U = T[]>(xs: T[][], fm?: MapFunction<T[], T[] | U> | null, fe?: EndFunction | null, vd?: T): (T[] | U)[];
|
|
1086
|
+
/**
|
|
1087
|
+
* Fill with given value.
|
|
1088
|
+
* @param x an array
|
|
1089
|
+
* @param v value
|
|
1090
|
+
* @param i begin index [0]
|
|
1091
|
+
* @param I end index [|x|]
|
|
1092
|
+
* @returns x' | x' = x; x'[i..I] = v
|
|
1093
|
+
*/ export declare function fill<T>(x: T[], v: T, i?: number, I?: number): T[];
|
|
1094
|
+
/**
|
|
1095
|
+
* Fill with given value!
|
|
1096
|
+
* @param x an array (updated!)
|
|
1097
|
+
* @param v value
|
|
1098
|
+
* @param i begin index [0]
|
|
1099
|
+
* @param I end index [|x|]
|
|
1100
|
+
* @returns x | x[i..I] = v
|
|
1101
|
+
*/ export declare function fill$<T>(x: T[], v: T, i?: number, I?: number): T[];
|
|
1102
|
+
/**
|
|
1103
|
+
* Add value to the end.
|
|
1104
|
+
* @param x an array
|
|
1105
|
+
* @param vs values to add
|
|
1106
|
+
* @returns x ⧺ vs
|
|
1107
|
+
*/ export declare function push<T>(x: T[], ...vs: T[]): T[];
|
|
1108
|
+
export { push as pushBack };
|
|
1109
|
+
export { push as append };
|
|
1110
|
+
/**
|
|
1111
|
+
* Add values to the end!
|
|
1112
|
+
* @param x an array (updated!)
|
|
1113
|
+
* @param vs values to add
|
|
1114
|
+
* @returns x = x ⧺ vs
|
|
1115
|
+
*/ export declare function push$<T>(x: T[], ...vs: T[]): T[];
|
|
1116
|
+
export { push$ as pushBack$ };
|
|
1117
|
+
export { push$ as append$ };
|
|
1118
|
+
/**
|
|
1119
|
+
* Remove last value.
|
|
1120
|
+
* @param x an array
|
|
1121
|
+
* @returns x[0..|x|-1]
|
|
1122
|
+
*/ export declare function pop<T>(x: T[]): T[];
|
|
1123
|
+
export { pop as popBack };
|
|
1124
|
+
/**
|
|
1125
|
+
* Remove last value!
|
|
1126
|
+
* @param x an array (updated!)
|
|
1127
|
+
* @returns x = x[0..|x|-1]
|
|
1128
|
+
*/ export declare function pop$<T>(x: T[]): T[];
|
|
1129
|
+
export { pop as popBack$ };
|
|
1130
|
+
/**
|
|
1131
|
+
* Remove first value.
|
|
1132
|
+
* @param x an array
|
|
1133
|
+
* @returns x[1..]
|
|
1134
|
+
*/ export declare function shift<T>(x: T[]): T[];
|
|
1135
|
+
export { shift as popFront };
|
|
1136
|
+
/**
|
|
1137
|
+
* Remove first value!
|
|
1138
|
+
* @param x an array (updated!)
|
|
1139
|
+
* @returns x = x[1..]
|
|
1140
|
+
*/ export declare function shift$<T>(x: T[]): T[];
|
|
1141
|
+
export { shift$ as popFront$ };
|
|
1142
|
+
/**
|
|
1143
|
+
* Add values to the start.
|
|
1144
|
+
* @param x an array
|
|
1145
|
+
* @param vs values to add
|
|
1146
|
+
* @returns vs ⧺ x
|
|
1147
|
+
*/ export declare function unshift<T>(x: Iterable<T>, ...vs: T[]): T[];
|
|
1148
|
+
export { unshift as pushFront };
|
|
1149
|
+
export { unshift as prepend };
|
|
1150
|
+
/**
|
|
1151
|
+
* Add values to the start!
|
|
1152
|
+
* @param x an array (updated!)
|
|
1153
|
+
* @param vs values to add
|
|
1154
|
+
* @returns x = vs ⧺ x
|
|
1155
|
+
*/ export declare function unshift$<T>(x: T[], ...vs: T[]): T[];
|
|
1156
|
+
export { unshift$ as pushFront$ };
|
|
1157
|
+
export { unshift$ as prepend$ };
|
|
1158
|
+
/**
|
|
1159
|
+
* Copy part of array to another.
|
|
1160
|
+
* @param x target array
|
|
1161
|
+
* @param y source array
|
|
1162
|
+
* @param j write index [0]
|
|
1163
|
+
* @param i read begin index [0]
|
|
1164
|
+
* @param I read end index [|x|]
|
|
1165
|
+
* @returns x[0..j] ⧺ y[i..I] ⧺ x[j+I-i..]
|
|
1166
|
+
*/ export declare function copy<T>(x: T[], y: T[], j?: number, i?: number, I?: number): T[];
|
|
1167
|
+
/**
|
|
1168
|
+
* Copy part of array to another!
|
|
1169
|
+
* @param x target array (updated!)
|
|
1170
|
+
* @param y source array
|
|
1171
|
+
* @param j write index [0]
|
|
1172
|
+
* @param i read begin index [0]
|
|
1173
|
+
* @param I read end index [|x|]
|
|
1174
|
+
* @returns x = x[0..j] ⧺ y[i..I] ⧺ x[j+I-i..]
|
|
1175
|
+
*/ export declare function copy$<T>(x: T[], y: T[], j?: number, i?: number, I?: number): T[];
|
|
1176
|
+
/**
|
|
1177
|
+
* Copy part of array within.
|
|
1178
|
+
* @param x an array
|
|
1179
|
+
* @param j write index [0]
|
|
1180
|
+
* @param i read begin index [0]
|
|
1181
|
+
* @param I read end index [|x|]
|
|
1182
|
+
* @returns x[0..j] ⧺ x[i..I] ⧺ x[j+I-i..]
|
|
1183
|
+
*/ export declare function copyWithin<T>(x: T[], j?: number, i?: number, I?: number): T[];
|
|
1184
|
+
/**
|
|
1185
|
+
* Copy part of array within!
|
|
1186
|
+
* @param x an array (updated!)
|
|
1187
|
+
* @param j write index [0]
|
|
1188
|
+
* @param i read begin index [0]
|
|
1189
|
+
* @param I read end index [|x|]
|
|
1190
|
+
* @returns x = x[0..j] ⧺ x[i..I] ⧺ x[j+I-i..]
|
|
1191
|
+
*/ export declare function copyWithin$<T>(x: T[], j?: number, i?: number, I?: number): T[];
|
|
1192
|
+
/**
|
|
1193
|
+
* Move part of array within.
|
|
1194
|
+
* @param x an array
|
|
1195
|
+
* @param j write index [0]
|
|
1196
|
+
* @param i read begin index [0]
|
|
1197
|
+
* @param I read end index [|x|]
|
|
1198
|
+
* @returns x[0..j] ⧺ x[i..I] ⧺ x[j..i] ⧺ x[I..]
|
|
1199
|
+
*/ export declare function moveWithin<T>(x: T[], j?: number, i?: number, I?: number): T[];
|
|
1200
|
+
/**
|
|
1201
|
+
* Move part of array within!
|
|
1202
|
+
* @param x an array (updated!)
|
|
1203
|
+
* @param j write ±index [0]
|
|
1204
|
+
* @param i read begin ±index [0]
|
|
1205
|
+
* @param I read end ±index [|x|]
|
|
1206
|
+
* @returns x = x[0..j] ⧺ x[i..I] ⧺ x[j..i] ⧺ x[I..]
|
|
1207
|
+
*/ export declare function moveWithin$<T>(x: T[], j?: number, i?: number, I?: number): T[];
|
|
1208
|
+
/**
|
|
1209
|
+
* Remove or replace existing values.
|
|
1210
|
+
* @param x an array
|
|
1211
|
+
* @param i remove ±index
|
|
1212
|
+
* @param n number of values to remove [rest]
|
|
1213
|
+
* @param vs values to insert
|
|
1214
|
+
* @returns x[0..i] ⧺ vs ⧺ x[i+n..]
|
|
1215
|
+
*/ export declare function splice<T>(x: T[], i: number, n?: number, ...vs: T[]): T[];
|
|
1216
|
+
export { splice as toSpliced };
|
|
1217
|
+
/**
|
|
1218
|
+
* Remove or replace existing values!
|
|
1219
|
+
* @param x an array (updated!)
|
|
1220
|
+
* @param i remove ±index
|
|
1221
|
+
* @param n number of values to remove [rest]
|
|
1222
|
+
* @param vs values to insert
|
|
1223
|
+
* @returns x = x[0..i] ⧺ vs ⧺ x[i+n..]
|
|
1224
|
+
*/ export declare function splice$<T>(x: T[], i: number, n?: number, ...vs: T[]): T[];
|
|
1225
|
+
/**
|
|
1226
|
+
* Count values which satisfy a test.
|
|
1227
|
+
* @param x an array
|
|
1228
|
+
* @param ft test function (v, i, x)
|
|
1229
|
+
* @returns Σtᵢ | tᵢ = 1 if ft(vᵢ) else 0; vᵢ ∈ x
|
|
1230
|
+
*/ export declare function count<T>(x: T[], ft: TestFunction<T>): number;
|
|
1231
|
+
/**
|
|
1232
|
+
* Count occurrences of each distinct value.
|
|
1233
|
+
* @param x an array
|
|
1234
|
+
* @param fm map function (v, i, x)
|
|
1235
|
+
* @returns Map \{value ⇒ count\}
|
|
1236
|
+
*/ export declare function countEach<T, U = T>(x: T[], fm?: MapFunction<T, T | U> | null): Map<T | U, number>;
|
|
1237
|
+
export { countEach as countAs };
|
|
1238
|
+
/**
|
|
1239
|
+
* Segregate values by test result.
|
|
1240
|
+
* @param x an array
|
|
1241
|
+
* @param ft test function (v, i, x)
|
|
1242
|
+
* @returns [satisfies, doesnt]
|
|
1243
|
+
*/ export declare function partition<T>(x: T[], ft: TestFunction<T>): [T[], T[]];
|
|
1244
|
+
/**
|
|
1245
|
+
* Segregate each distinct value.
|
|
1246
|
+
* @param x an array
|
|
1247
|
+
* @param fm map function (v, i, x)
|
|
1248
|
+
* @returns Map \{key ⇒ values\}
|
|
1249
|
+
*/ export declare function partitionEach<T, U = T>(x: T[], fm?: MapFunction<T, T | U> | null): Map<T | U, T[]>;
|
|
1250
|
+
export { partitionEach as groupToMap };
|
|
1251
|
+
export { partitionEach as partitionAs };
|
|
1252
|
+
/**
|
|
1253
|
+
* Break array considering test as separator.
|
|
1254
|
+
* @param x an array
|
|
1255
|
+
* @param ft test function (v, i, x)
|
|
1256
|
+
* @returns [x[j..k], x[l..m], ...] | ft(x[i]) = true; i = 0..j / k..l / ...
|
|
1257
|
+
*/ export declare function split<T>(x: T[], ft: TestFunction<T>): T[][];
|
|
1258
|
+
/**
|
|
1259
|
+
* Break array considering indices as separator.
|
|
1260
|
+
* @param x an array
|
|
1261
|
+
* @param is indices (sorted)
|
|
1262
|
+
* @returns [x[j..k], x[l..m], ...] | ft(x[i]) = true; i = 0..j / k..l / ...; i ∈ is
|
|
1263
|
+
*/ export declare function splitAt<T>(x: T[], is: number[]): T[][];
|
|
1264
|
+
/**
|
|
1265
|
+
* Break array when test passes.
|
|
1266
|
+
* @param x an array
|
|
1267
|
+
* @param ft test function (v, i, x)
|
|
1268
|
+
* @returns [x[0..j], x[j..k], ...] | ft(x[i]) = true; i = j, k, ...
|
|
1269
|
+
*/ export declare function cut<T>(x: T[], ft: TestFunction<T>): T[][];
|
|
1270
|
+
/**
|
|
1271
|
+
* Break array after test passes.
|
|
1272
|
+
* @param x an array
|
|
1273
|
+
* @param ft test function (v, i, x)
|
|
1274
|
+
* @returns [x[0..j+1], x[j+1..k], ...] | ft(x[i]) = true; i = j, k, ...
|
|
1275
|
+
*/ export declare function cutRight<T>(x: T[], ft: TestFunction<T>): T[][];
|
|
1276
|
+
/**
|
|
1277
|
+
* Break array at given indices.
|
|
1278
|
+
* @param x an array
|
|
1279
|
+
* @param is split ±indices (left to right)
|
|
1280
|
+
* @returns [x[0..j], x[j..k], ...] | ft(x[i]) = true; i = j, k, ...; i ∈ is
|
|
1281
|
+
*/ export declare function cutAt<T>(x: T[], is: number[]): T[][];
|
|
1282
|
+
/**
|
|
1283
|
+
* Break array after given indices.
|
|
1284
|
+
* @param x an array
|
|
1285
|
+
* @param is split ±indices (left to right)
|
|
1286
|
+
* @returns [x[0..j+1], x[j+1..k], ...] | ft(x[i]) = true; i = j, k, ...; i ∈ is
|
|
1287
|
+
*/ export declare function cutAtRight<T>(x: T[], is: number[]): T[][];
|
|
1288
|
+
/**
|
|
1289
|
+
* Keep similar values together and in order.
|
|
1290
|
+
* @param x an array
|
|
1291
|
+
* @param fc compare function (a, b)
|
|
1292
|
+
* @param fm map function (v, i, x)
|
|
1293
|
+
* @returns [x[0..k], x[k..l], ...] | fc(x[i], x[j]) = 0; i, j = 0..k / k..l / ...
|
|
1294
|
+
*/ export declare function group<T, U = T>(x: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): T[][];
|
|
1295
|
+
/**
|
|
1296
|
+
* Break array into chunks of given size.
|
|
1297
|
+
* @param x an array
|
|
1298
|
+
* @param n chunk size [1]
|
|
1299
|
+
* @param s chunk step [n]
|
|
1300
|
+
* @returns x[0..n] ⧺ x[s..s+n] ⧺ x[2s..2s+n] ⧺ ...
|
|
1301
|
+
*/ export declare function chunk<T>(x: T[], n?: number, s?: number): T[][];
|
|
1302
|
+
/**
|
|
1303
|
+
* Append values from arrays.
|
|
1304
|
+
* @param xs arrays
|
|
1305
|
+
* @returns x₀ ⧺ x₁ ⧺ ... | [x₀, x₁, ...] = xs
|
|
1306
|
+
*/ export declare function concat<T>(...xs: T[][]): T[];
|
|
1307
|
+
/**
|
|
1308
|
+
* Append values from arrays!
|
|
1309
|
+
* @param x an array (updated!)
|
|
1310
|
+
* @param ys arrays to append
|
|
1311
|
+
* @returns x = x ⧺ y₀ ⧺ y₁ ⧺ ...] | [y₀, y₁, ...] = ys
|
|
1312
|
+
*/ export declare function concat$<T>(x: T[], ...ys: Iterable<T>[]): T[];
|
|
1313
|
+
/**
|
|
1314
|
+
* Join values together into a string.
|
|
1315
|
+
* @param x an array
|
|
1316
|
+
* @param sep separator [,]
|
|
1317
|
+
* @returns "$\{v₀\}$\{sep\}$\{v₁\}..." | vᵢ ∈ x
|
|
1318
|
+
*/ export declare function join<T>(x: T[], sep?: string): string;
|
|
1319
|
+
/**
|
|
1320
|
+
* Obtain values that cycle through array.
|
|
1321
|
+
* @param x an array
|
|
1322
|
+
* @param i begin ±index [0]
|
|
1323
|
+
* @param n number of values [|x|]
|
|
1324
|
+
*/ export declare function cycle<T>(x: T[], i?: number, n?: number): T[];
|
|
1325
|
+
/**
|
|
1326
|
+
* Repeat an array given times.
|
|
1327
|
+
* @param x an array
|
|
1328
|
+
* @param n times [1]
|
|
1329
|
+
* @returns x ⧺ x ⧺ ...(n times)
|
|
1330
|
+
*/ export declare function repeat<T>(x: T[], n?: number): T[];
|
|
1331
|
+
/**
|
|
1332
|
+
* Reverse the values.
|
|
1333
|
+
* @param x an array
|
|
1334
|
+
* @returns [x[|x|-1], x[|x|-2], ..., x[1], x[0]]
|
|
1335
|
+
*/ export declare function reverse<T>(x: T[]): T[];
|
|
1336
|
+
export { reverse as toReversed };
|
|
1337
|
+
/**
|
|
1338
|
+
* Reverse the values!
|
|
1339
|
+
* @param x an array (updated!)
|
|
1340
|
+
* @returns x = [x[|x|-1], x[|x|-2], ..., x[1], x[0]]
|
|
1341
|
+
*/ export declare function reverse$<T>(x: T[]): T[];
|
|
1342
|
+
/**
|
|
1343
|
+
* Rotate values in array.
|
|
1344
|
+
* @param x an array
|
|
1345
|
+
* @param n rotate amount (+ve: left, -ve: right) [0]
|
|
1346
|
+
* @returns x[n..] ⧺ x[0..n]
|
|
1347
|
+
*/ export declare function rotate<T>(x: T[], n?: number): T[];
|
|
1348
|
+
/**
|
|
1349
|
+
* Rotate values in array!
|
|
1350
|
+
* @param x an array (updated!)
|
|
1351
|
+
* @param n rotate amount (+ve: left, -ve: right) [0]
|
|
1352
|
+
* @returns x = x[n..] ⧺ x[0..n]
|
|
1353
|
+
*/ export declare function rotate$<T>(x: T[], n?: number): T[];
|
|
1354
|
+
/**
|
|
1355
|
+
* Examine if there are no duplicate values.
|
|
1356
|
+
* @param x an array
|
|
1357
|
+
* @param fc compare function (a, b)
|
|
1358
|
+
* @param fm map function (v, i, x)
|
|
1359
|
+
* @returns ∀ vᵢ, vⱼ ∈ x, is vᵢ ≠ vⱼ?
|
|
1360
|
+
*/ export declare function isUnique<T, U = T>(x: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): boolean;
|
|
1361
|
+
/**
|
|
1362
|
+
* Examine if arrays have no value in common.
|
|
1363
|
+
* @param x an array
|
|
1364
|
+
* @param y another array
|
|
1365
|
+
* @param fc compare function (a, b)
|
|
1366
|
+
* @param fm map function (v, i, x)
|
|
1367
|
+
* @returns x ∩ y = Φ?
|
|
1368
|
+
*/ export declare function isDisjoint<T, U = T>(x: T[], y: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): boolean;
|
|
1369
|
+
/**
|
|
1370
|
+
* Remove duplicate values.
|
|
1371
|
+
* @param x an array
|
|
1372
|
+
* @param fc compare function (a, b)
|
|
1373
|
+
* @param fm map function (v, i, x)
|
|
1374
|
+
* @returns v₀, v₁, ... | vᵢ ∈ x; vᵢ ≠ vⱼ ∀ i, j
|
|
1375
|
+
*/ export declare function unique<T, U = T>(x: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): T[];
|
|
1376
|
+
/**
|
|
1377
|
+
* Obtain values present in any array.
|
|
1378
|
+
* @param x an array
|
|
1379
|
+
* @param y another array
|
|
1380
|
+
* @param fc compare function (a, b)
|
|
1381
|
+
* @param fm map function (v, i, x)
|
|
1382
|
+
* @returns x ∪ y = \{v | v ∈ x or v ∈ y\}
|
|
1383
|
+
*/ export declare function union<T, U = T>(x: T[], y: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): T[];
|
|
1384
|
+
/**
|
|
1385
|
+
* Obtain values present in any array!
|
|
1386
|
+
* @param x an array (updated!)
|
|
1387
|
+
* @param y another array
|
|
1388
|
+
* @param fc compare function (a, b)
|
|
1389
|
+
* @param fm map function (v, i, x)
|
|
1390
|
+
* @returns x = x ∪ y = \{v | v ∈ x or v ∈ y\}
|
|
1391
|
+
*/ export declare function union$<T, U = T>(x: T[], y: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): T[];
|
|
1392
|
+
/**
|
|
1393
|
+
* Obtain values present in both arrays.
|
|
1394
|
+
* @param x an array
|
|
1395
|
+
* @param y another array
|
|
1396
|
+
* @param fc compare function (a, b)
|
|
1397
|
+
* @param fm map function (v, i, x)
|
|
1398
|
+
* @returns x ∩ y = \{v | v ∈ x, v ∈ y\}
|
|
1399
|
+
*/ export declare function intersection<T, U = T>(x: T[], y: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): T[];
|
|
1400
|
+
/**
|
|
1401
|
+
* Obtain values not present in another array.
|
|
1402
|
+
* @param x an array
|
|
1403
|
+
* @param y another array
|
|
1404
|
+
* @param fc compare function (a, b)
|
|
1405
|
+
* @param fm map function (v, i, x)
|
|
1406
|
+
* @returns x - y = \{v | v ∈ x, v ∉ y\}
|
|
1407
|
+
*/ export declare function difference<T, U = T>(x: T[], y: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): T[];
|
|
1408
|
+
/**
|
|
1409
|
+
* Obtain values not present in both arrays.
|
|
1410
|
+
* @param x an array
|
|
1411
|
+
* @param y another array
|
|
1412
|
+
* @param fc compare function (a, b)
|
|
1413
|
+
* @param fm map function (v, i, x)
|
|
1414
|
+
* @returns x-y ∪ y-x
|
|
1415
|
+
*/ export declare function symmetricDifference<T, U = T>(x: T[], y: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): T[];
|
|
1416
|
+
/**
|
|
1417
|
+
* Obtain cartesian product of arrays.
|
|
1418
|
+
* @param xs arrays
|
|
1419
|
+
* @param fm map function (vs, i)
|
|
1420
|
+
* @returns x₀ × x₁ × ... = \{[v₀, v₁, ...] | v₀ ∈ x₀, v₁ ∈ x₁, ...] \}
|
|
1421
|
+
*/ export declare function cartesianProduct<T, U = T>(xs: T[][], fm?: MapFunction<T[], T[] | U> | null): (T[] | U)[];
|