@procedures/generators 0.0.0-stage → 0.62.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.
- package/CHANGELOG.md +60 -0
- package/LICENSE +21 -0
- package/README.md +84 -2
- package/dist/index.d.ts +2 -0
- package/dist/index.d.ts.map +1 -0
- package/dist/index.js +3 -0
- package/dist/index.js.map +1 -0
- package/dist/manifest.d.ts +3 -0
- package/dist/manifest.d.ts.map +1 -0
- package/dist/manifest.js +1818 -0
- package/dist/manifest.js.map +1 -0
- package/dist/module.d.ts +19 -0
- package/dist/module.d.ts.map +1 -0
- package/dist/module.js +23 -0
- package/dist/module.js.map +1 -0
- package/dist/register.d.ts +6 -0
- package/dist/register.d.ts.map +1 -0
- package/dist/register.js +8 -0
- package/dist/register.js.map +1 -0
- package/package.json +86 -3
- package/src/index.ts +2 -0
- package/src/manifest.ts +1820 -0
- package/src/module.ts +27 -0
- package/src/register.ts +10 -0
package/src/manifest.ts
ADDED
|
@@ -0,0 +1,1820 @@
|
|
|
1
|
+
// The manifest of @mark1russell7/rigor-generators 0.2.0, made from its types by `node scripts/wraps.ts generate`. Do not edit it.
|
|
2
|
+
import type { ExportsManifest } from "@procedures/compiler";
|
|
3
|
+
|
|
4
|
+
export const manifest: ExportsManifest = {
|
|
5
|
+
"format": "procedures-exports/1",
|
|
6
|
+
"package": "@mark1russell7/rigor-generators",
|
|
7
|
+
"version": "0.2.0",
|
|
8
|
+
"entry": ".",
|
|
9
|
+
"namespace": [
|
|
10
|
+
"generators"
|
|
11
|
+
],
|
|
12
|
+
"$defs": {
|
|
13
|
+
"CanonicalOptions": {
|
|
14
|
+
"type": "object",
|
|
15
|
+
"properties": {
|
|
16
|
+
"form": {
|
|
17
|
+
"enum": [
|
|
18
|
+
"jcs",
|
|
19
|
+
"json"
|
|
20
|
+
],
|
|
21
|
+
"description": "The form of the values that JSON does not have:"
|
|
22
|
+
},
|
|
23
|
+
"bigint": {
|
|
24
|
+
"enum": [
|
|
25
|
+
"error",
|
|
26
|
+
"suffix"
|
|
27
|
+
],
|
|
28
|
+
"description": "The form of a `bigint`. `\"error\"` (the default) causes a `TypeError`, as `JSON.stringify` does. `\"suffix\"` writes the digits and the letter `n`, for example `12n`. This text is not JSON, so use it only for a key."
|
|
29
|
+
},
|
|
30
|
+
"tags": {
|
|
31
|
+
"enum": [
|
|
32
|
+
"none",
|
|
33
|
+
"typed"
|
|
34
|
+
],
|
|
35
|
+
"description": "The form of a `Date`, a `RegExp`, a `Map`, a `Set` and a `bigint`:"
|
|
36
|
+
}
|
|
37
|
+
}
|
|
38
|
+
},
|
|
39
|
+
"Coverage": {
|
|
40
|
+
"type": "object",
|
|
41
|
+
"properties": {
|
|
42
|
+
"tuples": {
|
|
43
|
+
"type": "number",
|
|
44
|
+
"description": "The count of the combinations of `t` values of `t` different dimensions."
|
|
45
|
+
},
|
|
46
|
+
"covered": {
|
|
47
|
+
"type": "number",
|
|
48
|
+
"description": "The count of the combinations that one row or more holds."
|
|
49
|
+
},
|
|
50
|
+
"share": {
|
|
51
|
+
"type": "number",
|
|
52
|
+
"description": "`covered` divided by `tuples`. Dimensions with no combination give 1."
|
|
53
|
+
},
|
|
54
|
+
"missing": {
|
|
55
|
+
"type": "array",
|
|
56
|
+
"items": {
|
|
57
|
+
"type": "string"
|
|
58
|
+
},
|
|
59
|
+
"description": "The combinations that no row holds, as `<dimension>=<value>&<dimension>=<value>`, in the order of the dimensions."
|
|
60
|
+
}
|
|
61
|
+
},
|
|
62
|
+
"required": [
|
|
63
|
+
"tuples",
|
|
64
|
+
"covered",
|
|
65
|
+
"share",
|
|
66
|
+
"missing"
|
|
67
|
+
]
|
|
68
|
+
},
|
|
69
|
+
"CoveringOptions": {
|
|
70
|
+
"type": "object",
|
|
71
|
+
"properties": {
|
|
72
|
+
"strength": {
|
|
73
|
+
"type": "number",
|
|
74
|
+
"description": "The strength `t`: each `t` values of `t` different dimensions are in one row or more. The default is 2."
|
|
75
|
+
},
|
|
76
|
+
"candidates": {
|
|
77
|
+
"type": "number",
|
|
78
|
+
"description": "The count of candidate rows for each row that the array keeps. The default is `COVERING_CANDIDATES`."
|
|
79
|
+
}
|
|
80
|
+
}
|
|
81
|
+
},
|
|
82
|
+
"Dimension": {
|
|
83
|
+
"type": "object",
|
|
84
|
+
"properties": {
|
|
85
|
+
"name": {
|
|
86
|
+
"type": "string",
|
|
87
|
+
"description": "The name of the dimension. It is a key of each point."
|
|
88
|
+
},
|
|
89
|
+
"min": {
|
|
90
|
+
"type": "number",
|
|
91
|
+
"description": "The smallest value."
|
|
92
|
+
},
|
|
93
|
+
"max": {
|
|
94
|
+
"type": "number",
|
|
95
|
+
"description": "The largest value. A uniform or log dimension that is not `integer` gets values below `max`."
|
|
96
|
+
},
|
|
97
|
+
"distribution": {
|
|
98
|
+
"anyOf": [
|
|
99
|
+
{
|
|
100
|
+
"type": "object",
|
|
101
|
+
"properties": {
|
|
102
|
+
"family": {
|
|
103
|
+
"const": "lognormal"
|
|
104
|
+
},
|
|
105
|
+
"mu": {
|
|
106
|
+
"$ref": "#/$defs/Param"
|
|
107
|
+
},
|
|
108
|
+
"sigma": {
|
|
109
|
+
"$ref": "#/$defs/Param"
|
|
110
|
+
}
|
|
111
|
+
},
|
|
112
|
+
"required": [
|
|
113
|
+
"family",
|
|
114
|
+
"mu",
|
|
115
|
+
"sigma"
|
|
116
|
+
]
|
|
117
|
+
},
|
|
118
|
+
{
|
|
119
|
+
"type": "object",
|
|
120
|
+
"properties": {
|
|
121
|
+
"family": {
|
|
122
|
+
"const": "pareto"
|
|
123
|
+
},
|
|
124
|
+
"scale": {
|
|
125
|
+
"$ref": "#/$defs/Param"
|
|
126
|
+
},
|
|
127
|
+
"shape": {
|
|
128
|
+
"$ref": "#/$defs/Param"
|
|
129
|
+
}
|
|
130
|
+
},
|
|
131
|
+
"required": [
|
|
132
|
+
"family",
|
|
133
|
+
"scale",
|
|
134
|
+
"shape"
|
|
135
|
+
]
|
|
136
|
+
},
|
|
137
|
+
{
|
|
138
|
+
"type": "object",
|
|
139
|
+
"properties": {
|
|
140
|
+
"family": {
|
|
141
|
+
"const": "zipf"
|
|
142
|
+
},
|
|
143
|
+
"n": {
|
|
144
|
+
"type": "number"
|
|
145
|
+
},
|
|
146
|
+
"exponent": {
|
|
147
|
+
"$ref": "#/$defs/Param"
|
|
148
|
+
}
|
|
149
|
+
},
|
|
150
|
+
"required": [
|
|
151
|
+
"family",
|
|
152
|
+
"n",
|
|
153
|
+
"exponent"
|
|
154
|
+
]
|
|
155
|
+
},
|
|
156
|
+
{
|
|
157
|
+
"type": "object",
|
|
158
|
+
"properties": {
|
|
159
|
+
"family": {
|
|
160
|
+
"const": "beta"
|
|
161
|
+
},
|
|
162
|
+
"a": {
|
|
163
|
+
"$ref": "#/$defs/Param"
|
|
164
|
+
},
|
|
165
|
+
"b": {
|
|
166
|
+
"$ref": "#/$defs/Param"
|
|
167
|
+
}
|
|
168
|
+
},
|
|
169
|
+
"required": [
|
|
170
|
+
"family",
|
|
171
|
+
"a",
|
|
172
|
+
"b"
|
|
173
|
+
]
|
|
174
|
+
},
|
|
175
|
+
{
|
|
176
|
+
"type": "object",
|
|
177
|
+
"properties": {
|
|
178
|
+
"family": {
|
|
179
|
+
"const": "mixture"
|
|
180
|
+
},
|
|
181
|
+
"parts": {
|
|
182
|
+
"type": "array",
|
|
183
|
+
"items": {
|
|
184
|
+
"type": "object",
|
|
185
|
+
"properties": {
|
|
186
|
+
"weight": {
|
|
187
|
+
"type": "number"
|
|
188
|
+
},
|
|
189
|
+
"part": {
|
|
190
|
+
"$ref": "#/$defs/DistributionSpec"
|
|
191
|
+
}
|
|
192
|
+
},
|
|
193
|
+
"required": [
|
|
194
|
+
"weight",
|
|
195
|
+
"part"
|
|
196
|
+
]
|
|
197
|
+
}
|
|
198
|
+
}
|
|
199
|
+
},
|
|
200
|
+
"required": [
|
|
201
|
+
"family",
|
|
202
|
+
"parts"
|
|
203
|
+
]
|
|
204
|
+
},
|
|
205
|
+
{
|
|
206
|
+
"type": "object",
|
|
207
|
+
"properties": {
|
|
208
|
+
"family": {
|
|
209
|
+
"const": "recorded"
|
|
210
|
+
},
|
|
211
|
+
"values": {
|
|
212
|
+
"type": "array",
|
|
213
|
+
"items": {
|
|
214
|
+
"type": "number"
|
|
215
|
+
}
|
|
216
|
+
}
|
|
217
|
+
},
|
|
218
|
+
"required": [
|
|
219
|
+
"family",
|
|
220
|
+
"values"
|
|
221
|
+
]
|
|
222
|
+
}
|
|
223
|
+
],
|
|
224
|
+
"description": "The distribution of the values, cut to the range. Without it, the values are uniform in the range."
|
|
225
|
+
},
|
|
226
|
+
"scale": {
|
|
227
|
+
"enum": [
|
|
228
|
+
"linear",
|
|
229
|
+
"log"
|
|
230
|
+
],
|
|
231
|
+
"description": "With `log`, the logarithm of the value is uniform. `min` must be above 0. A dimension with a distribution has no scale."
|
|
232
|
+
},
|
|
233
|
+
"integer": {
|
|
234
|
+
"type": "boolean",
|
|
235
|
+
"description": "With `true`, each value is an integer. `min` and `max` must be integers."
|
|
236
|
+
}
|
|
237
|
+
},
|
|
238
|
+
"required": [
|
|
239
|
+
"name",
|
|
240
|
+
"min",
|
|
241
|
+
"max"
|
|
242
|
+
]
|
|
243
|
+
},
|
|
244
|
+
"DistributionSpec": {
|
|
245
|
+
"anyOf": [
|
|
246
|
+
{
|
|
247
|
+
"type": "object",
|
|
248
|
+
"properties": {
|
|
249
|
+
"family": {
|
|
250
|
+
"const": "lognormal"
|
|
251
|
+
},
|
|
252
|
+
"mu": {
|
|
253
|
+
"$ref": "#/$defs/Param"
|
|
254
|
+
},
|
|
255
|
+
"sigma": {
|
|
256
|
+
"$ref": "#/$defs/Param"
|
|
257
|
+
}
|
|
258
|
+
},
|
|
259
|
+
"required": [
|
|
260
|
+
"family",
|
|
261
|
+
"mu",
|
|
262
|
+
"sigma"
|
|
263
|
+
]
|
|
264
|
+
},
|
|
265
|
+
{
|
|
266
|
+
"type": "object",
|
|
267
|
+
"properties": {
|
|
268
|
+
"family": {
|
|
269
|
+
"const": "pareto"
|
|
270
|
+
},
|
|
271
|
+
"scale": {
|
|
272
|
+
"$ref": "#/$defs/Param"
|
|
273
|
+
},
|
|
274
|
+
"shape": {
|
|
275
|
+
"$ref": "#/$defs/Param"
|
|
276
|
+
}
|
|
277
|
+
},
|
|
278
|
+
"required": [
|
|
279
|
+
"family",
|
|
280
|
+
"scale",
|
|
281
|
+
"shape"
|
|
282
|
+
]
|
|
283
|
+
},
|
|
284
|
+
{
|
|
285
|
+
"type": "object",
|
|
286
|
+
"properties": {
|
|
287
|
+
"family": {
|
|
288
|
+
"const": "zipf"
|
|
289
|
+
},
|
|
290
|
+
"n": {
|
|
291
|
+
"type": "number"
|
|
292
|
+
},
|
|
293
|
+
"exponent": {
|
|
294
|
+
"$ref": "#/$defs/Param"
|
|
295
|
+
}
|
|
296
|
+
},
|
|
297
|
+
"required": [
|
|
298
|
+
"family",
|
|
299
|
+
"n",
|
|
300
|
+
"exponent"
|
|
301
|
+
]
|
|
302
|
+
},
|
|
303
|
+
{
|
|
304
|
+
"type": "object",
|
|
305
|
+
"properties": {
|
|
306
|
+
"family": {
|
|
307
|
+
"const": "beta"
|
|
308
|
+
},
|
|
309
|
+
"a": {
|
|
310
|
+
"$ref": "#/$defs/Param"
|
|
311
|
+
},
|
|
312
|
+
"b": {
|
|
313
|
+
"$ref": "#/$defs/Param"
|
|
314
|
+
}
|
|
315
|
+
},
|
|
316
|
+
"required": [
|
|
317
|
+
"family",
|
|
318
|
+
"a",
|
|
319
|
+
"b"
|
|
320
|
+
]
|
|
321
|
+
},
|
|
322
|
+
{
|
|
323
|
+
"type": "object",
|
|
324
|
+
"properties": {
|
|
325
|
+
"family": {
|
|
326
|
+
"const": "mixture"
|
|
327
|
+
},
|
|
328
|
+
"parts": {
|
|
329
|
+
"type": "array",
|
|
330
|
+
"items": {
|
|
331
|
+
"type": "object",
|
|
332
|
+
"properties": {
|
|
333
|
+
"weight": {
|
|
334
|
+
"type": "number"
|
|
335
|
+
},
|
|
336
|
+
"part": {
|
|
337
|
+
"$ref": "#/$defs/DistributionSpec"
|
|
338
|
+
}
|
|
339
|
+
},
|
|
340
|
+
"required": [
|
|
341
|
+
"weight",
|
|
342
|
+
"part"
|
|
343
|
+
]
|
|
344
|
+
}
|
|
345
|
+
}
|
|
346
|
+
},
|
|
347
|
+
"required": [
|
|
348
|
+
"family",
|
|
349
|
+
"parts"
|
|
350
|
+
]
|
|
351
|
+
},
|
|
352
|
+
{
|
|
353
|
+
"type": "object",
|
|
354
|
+
"properties": {
|
|
355
|
+
"family": {
|
|
356
|
+
"const": "recorded"
|
|
357
|
+
},
|
|
358
|
+
"values": {
|
|
359
|
+
"type": "array",
|
|
360
|
+
"items": {
|
|
361
|
+
"type": "number"
|
|
362
|
+
}
|
|
363
|
+
}
|
|
364
|
+
},
|
|
365
|
+
"required": [
|
|
366
|
+
"family",
|
|
367
|
+
"values"
|
|
368
|
+
]
|
|
369
|
+
}
|
|
370
|
+
]
|
|
371
|
+
},
|
|
372
|
+
"InputFamily": {
|
|
373
|
+
"type": "object",
|
|
374
|
+
"properties": {
|
|
375
|
+
"name": {
|
|
376
|
+
"type": "string"
|
|
377
|
+
},
|
|
378
|
+
"dimensions": {
|
|
379
|
+
"type": "array",
|
|
380
|
+
"items": {
|
|
381
|
+
"$ref": "#/$defs/Dimension"
|
|
382
|
+
}
|
|
383
|
+
}
|
|
384
|
+
},
|
|
385
|
+
"required": [
|
|
386
|
+
"name",
|
|
387
|
+
"dimensions"
|
|
388
|
+
]
|
|
389
|
+
},
|
|
390
|
+
"Param": {
|
|
391
|
+
"anyOf": [
|
|
392
|
+
{
|
|
393
|
+
"type": "number"
|
|
394
|
+
},
|
|
395
|
+
{
|
|
396
|
+
"type": "array",
|
|
397
|
+
"prefixItems": [
|
|
398
|
+
{
|
|
399
|
+
"type": "number"
|
|
400
|
+
},
|
|
401
|
+
{
|
|
402
|
+
"type": "number"
|
|
403
|
+
}
|
|
404
|
+
],
|
|
405
|
+
"minItems": 2,
|
|
406
|
+
"maxItems": 2
|
|
407
|
+
}
|
|
408
|
+
]
|
|
409
|
+
},
|
|
410
|
+
"RecordedTable": {
|
|
411
|
+
"type": "object",
|
|
412
|
+
"properties": {
|
|
413
|
+
"name": {
|
|
414
|
+
"type": "string",
|
|
415
|
+
"description": "The name of the table."
|
|
416
|
+
},
|
|
417
|
+
"measure": {
|
|
418
|
+
"type": "string",
|
|
419
|
+
"description": "What one value measures."
|
|
420
|
+
},
|
|
421
|
+
"source": {
|
|
422
|
+
"type": "string",
|
|
423
|
+
"description": "The link to the source, with the commit of the read."
|
|
424
|
+
},
|
|
425
|
+
"license": {
|
|
426
|
+
"type": "string",
|
|
427
|
+
"description": "The license of the source."
|
|
428
|
+
},
|
|
429
|
+
"notice": {
|
|
430
|
+
"type": "string",
|
|
431
|
+
"description": "The notice of the license of the source, or an empty string when it has no notice."
|
|
432
|
+
},
|
|
433
|
+
"date": {
|
|
434
|
+
"type": "string",
|
|
435
|
+
"description": "The date of the read."
|
|
436
|
+
},
|
|
437
|
+
"count": {
|
|
438
|
+
"type": "number",
|
|
439
|
+
"description": "The count of the recorded values."
|
|
440
|
+
},
|
|
441
|
+
"median": {
|
|
442
|
+
"type": "number",
|
|
443
|
+
"description": "The median of the recorded values."
|
|
444
|
+
},
|
|
445
|
+
"quantiles": {
|
|
446
|
+
"type": "array",
|
|
447
|
+
"items": {
|
|
448
|
+
"type": "number"
|
|
449
|
+
},
|
|
450
|
+
"description": "The 100 midpoint quantiles, from the lowest to the highest. The value at index `i` has the rank `floor(count * (i + 0.5) / 100)` of the sorted values. Each value thus stands for 1 percent of the recorded values."
|
|
451
|
+
}
|
|
452
|
+
},
|
|
453
|
+
"required": [
|
|
454
|
+
"name",
|
|
455
|
+
"measure",
|
|
456
|
+
"source",
|
|
457
|
+
"license",
|
|
458
|
+
"notice",
|
|
459
|
+
"date",
|
|
460
|
+
"count",
|
|
461
|
+
"median",
|
|
462
|
+
"quantiles"
|
|
463
|
+
]
|
|
464
|
+
},
|
|
465
|
+
"SaltelliDesign": {
|
|
466
|
+
"type": "object",
|
|
467
|
+
"properties": {
|
|
468
|
+
"a": {
|
|
469
|
+
"type": "array",
|
|
470
|
+
"items": {
|
|
471
|
+
"type": "array",
|
|
472
|
+
"items": {
|
|
473
|
+
"type": "number"
|
|
474
|
+
}
|
|
475
|
+
}
|
|
476
|
+
},
|
|
477
|
+
"b": {
|
|
478
|
+
"type": "array",
|
|
479
|
+
"items": {
|
|
480
|
+
"type": "array",
|
|
481
|
+
"items": {
|
|
482
|
+
"type": "number"
|
|
483
|
+
}
|
|
484
|
+
}
|
|
485
|
+
},
|
|
486
|
+
"ab": {
|
|
487
|
+
"type": "array",
|
|
488
|
+
"items": {
|
|
489
|
+
"type": "array",
|
|
490
|
+
"items": {
|
|
491
|
+
"type": "array",
|
|
492
|
+
"items": {
|
|
493
|
+
"type": "number"
|
|
494
|
+
}
|
|
495
|
+
}
|
|
496
|
+
},
|
|
497
|
+
"description": "`ab[i]` is `a` with the column `i` of `b`."
|
|
498
|
+
}
|
|
499
|
+
},
|
|
500
|
+
"required": [
|
|
501
|
+
"a",
|
|
502
|
+
"b",
|
|
503
|
+
"ab"
|
|
504
|
+
]
|
|
505
|
+
},
|
|
506
|
+
"Sha256Options": {
|
|
507
|
+
"type": "object",
|
|
508
|
+
"properties": {
|
|
509
|
+
"input": {
|
|
510
|
+
"enum": [
|
|
511
|
+
"utf8",
|
|
512
|
+
"wtf8"
|
|
513
|
+
],
|
|
514
|
+
"description": "The bytes that the hash reads, as in `fnv1a32`:"
|
|
515
|
+
}
|
|
516
|
+
}
|
|
517
|
+
},
|
|
518
|
+
"ShrinkOptions": {
|
|
519
|
+
"type": "object",
|
|
520
|
+
"properties": {
|
|
521
|
+
"maxChecks": {
|
|
522
|
+
"type": "number",
|
|
523
|
+
"description": "The most checks of points, with the check of the first point. The default is `SHRINK_CHECKS`."
|
|
524
|
+
},
|
|
525
|
+
"tolerance": {
|
|
526
|
+
"type": "number",
|
|
527
|
+
"description": "The width of the last interval of a bisection on a dimension that is not an integer, as a share of its range. A log dimension uses the range of the logarithm. The default is `SHRINK_TOLERANCE`."
|
|
528
|
+
}
|
|
529
|
+
}
|
|
530
|
+
},
|
|
531
|
+
"ShrinkStep": {
|
|
532
|
+
"type": "object",
|
|
533
|
+
"properties": {
|
|
534
|
+
"dimension": {
|
|
535
|
+
"type": "string"
|
|
536
|
+
},
|
|
537
|
+
"from": {
|
|
538
|
+
"type": "number"
|
|
539
|
+
},
|
|
540
|
+
"to": {
|
|
541
|
+
"type": "number"
|
|
542
|
+
}
|
|
543
|
+
},
|
|
544
|
+
"required": [
|
|
545
|
+
"dimension",
|
|
546
|
+
"from",
|
|
547
|
+
"to"
|
|
548
|
+
]
|
|
549
|
+
},
|
|
550
|
+
"Shrunk": {
|
|
551
|
+
"type": "object",
|
|
552
|
+
"properties": {
|
|
553
|
+
"point": {
|
|
554
|
+
"type": "object",
|
|
555
|
+
"properties": {},
|
|
556
|
+
"additionalProperties": {
|
|
557
|
+
"type": "number"
|
|
558
|
+
},
|
|
559
|
+
"description": "The last point that failed. Each key of the first point stays."
|
|
560
|
+
},
|
|
561
|
+
"steps": {
|
|
562
|
+
"type": "array",
|
|
563
|
+
"items": {
|
|
564
|
+
"$ref": "#/$defs/ShrinkStep"
|
|
565
|
+
},
|
|
566
|
+
"description": "The moves, in their order."
|
|
567
|
+
},
|
|
568
|
+
"checks": {
|
|
569
|
+
"type": "number",
|
|
570
|
+
"description": "The count of checks, with the check of the first point."
|
|
571
|
+
},
|
|
572
|
+
"exhausted": {
|
|
573
|
+
"type": "boolean",
|
|
574
|
+
"description": "The value `true` tells that the budget of checks ended before a round with no move."
|
|
575
|
+
}
|
|
576
|
+
},
|
|
577
|
+
"required": [
|
|
578
|
+
"point",
|
|
579
|
+
"steps",
|
|
580
|
+
"checks",
|
|
581
|
+
"exhausted"
|
|
582
|
+
]
|
|
583
|
+
}
|
|
584
|
+
},
|
|
585
|
+
"procedures": [
|
|
586
|
+
{
|
|
587
|
+
"name": "betaCdf",
|
|
588
|
+
"path": [
|
|
589
|
+
"generators",
|
|
590
|
+
"betaCdf"
|
|
591
|
+
],
|
|
592
|
+
"description": "This function gives the regularized incomplete beta function: the beta cumulative distribution at `x`.",
|
|
593
|
+
"params": [
|
|
594
|
+
"x",
|
|
595
|
+
"a",
|
|
596
|
+
"b"
|
|
597
|
+
],
|
|
598
|
+
"input": {
|
|
599
|
+
"type": "object",
|
|
600
|
+
"properties": {
|
|
601
|
+
"x": {
|
|
602
|
+
"type": "number"
|
|
603
|
+
},
|
|
604
|
+
"a": {
|
|
605
|
+
"type": "number"
|
|
606
|
+
},
|
|
607
|
+
"b": {
|
|
608
|
+
"type": "number"
|
|
609
|
+
}
|
|
610
|
+
},
|
|
611
|
+
"required": [
|
|
612
|
+
"x",
|
|
613
|
+
"a",
|
|
614
|
+
"b"
|
|
615
|
+
],
|
|
616
|
+
"additionalProperties": false
|
|
617
|
+
},
|
|
618
|
+
"output": {
|
|
619
|
+
"type": "number"
|
|
620
|
+
},
|
|
621
|
+
"effects": {
|
|
622
|
+
"reads": [],
|
|
623
|
+
"writes": []
|
|
624
|
+
}
|
|
625
|
+
},
|
|
626
|
+
{
|
|
627
|
+
"name": "canonicalHash",
|
|
628
|
+
"path": [
|
|
629
|
+
"generators",
|
|
630
|
+
"canonicalHash"
|
|
631
|
+
],
|
|
632
|
+
"description": "This function gives the content hash of a value: `sha256Hex(canonicalJson(value, options))`.",
|
|
633
|
+
"params": [
|
|
634
|
+
"value",
|
|
635
|
+
"options"
|
|
636
|
+
],
|
|
637
|
+
"input": {
|
|
638
|
+
"type": "object",
|
|
639
|
+
"properties": {
|
|
640
|
+
"value": {},
|
|
641
|
+
"options": {
|
|
642
|
+
"$ref": "#/$defs/CanonicalOptions"
|
|
643
|
+
}
|
|
644
|
+
},
|
|
645
|
+
"required": [
|
|
646
|
+
"value"
|
|
647
|
+
],
|
|
648
|
+
"additionalProperties": false
|
|
649
|
+
},
|
|
650
|
+
"output": {
|
|
651
|
+
"type": "string"
|
|
652
|
+
},
|
|
653
|
+
"effects": {
|
|
654
|
+
"reads": [],
|
|
655
|
+
"writes": []
|
|
656
|
+
}
|
|
657
|
+
},
|
|
658
|
+
{
|
|
659
|
+
"name": "canonicalJson",
|
|
660
|
+
"path": [
|
|
661
|
+
"generators",
|
|
662
|
+
"canonicalJson"
|
|
663
|
+
],
|
|
664
|
+
"description": "This function gives the canonical form of a value. The default form is RFC 8785 (JCS):",
|
|
665
|
+
"params": [
|
|
666
|
+
"value",
|
|
667
|
+
"options"
|
|
668
|
+
],
|
|
669
|
+
"input": {
|
|
670
|
+
"type": "object",
|
|
671
|
+
"properties": {
|
|
672
|
+
"value": {},
|
|
673
|
+
"options": {
|
|
674
|
+
"$ref": "#/$defs/CanonicalOptions"
|
|
675
|
+
}
|
|
676
|
+
},
|
|
677
|
+
"required": [
|
|
678
|
+
"value"
|
|
679
|
+
],
|
|
680
|
+
"additionalProperties": false
|
|
681
|
+
},
|
|
682
|
+
"output": {
|
|
683
|
+
"type": "string"
|
|
684
|
+
},
|
|
685
|
+
"effects": {
|
|
686
|
+
"reads": [],
|
|
687
|
+
"writes": []
|
|
688
|
+
}
|
|
689
|
+
},
|
|
690
|
+
{
|
|
691
|
+
"name": "coveringArray",
|
|
692
|
+
"path": [
|
|
693
|
+
"generators",
|
|
694
|
+
"coveringArray"
|
|
695
|
+
],
|
|
696
|
+
"description": "This function gives a covering array of strength `t` over dimensions with `levels[i]` levels each. Each row has the index of one level of each dimension. With fewer dimensions than `t`, the array covers each combination of all the dimensions. Thus no dimensions give one empty row, as the product of no sets has one item.",
|
|
697
|
+
"params": [
|
|
698
|
+
"levels",
|
|
699
|
+
"r",
|
|
700
|
+
"options"
|
|
701
|
+
],
|
|
702
|
+
"input": {
|
|
703
|
+
"type": "object",
|
|
704
|
+
"properties": {
|
|
705
|
+
"levels": {
|
|
706
|
+
"type": "array",
|
|
707
|
+
"items": {
|
|
708
|
+
"type": "number"
|
|
709
|
+
}
|
|
710
|
+
},
|
|
711
|
+
"r": {
|
|
712
|
+
"type": "object",
|
|
713
|
+
"properties": {
|
|
714
|
+
"seed": {
|
|
715
|
+
"anyOf": [
|
|
716
|
+
{
|
|
717
|
+
"type": "string"
|
|
718
|
+
},
|
|
719
|
+
{
|
|
720
|
+
"type": "number"
|
|
721
|
+
}
|
|
722
|
+
]
|
|
723
|
+
}
|
|
724
|
+
},
|
|
725
|
+
"required": [
|
|
726
|
+
"seed"
|
|
727
|
+
],
|
|
728
|
+
"additionalProperties": false,
|
|
729
|
+
"description": "The input of random: the procedure makes the Random with random(seed) before the call.",
|
|
730
|
+
"x-procedures-construct": {
|
|
731
|
+
"function": "random",
|
|
732
|
+
"params": [
|
|
733
|
+
"seed"
|
|
734
|
+
]
|
|
735
|
+
}
|
|
736
|
+
},
|
|
737
|
+
"options": {
|
|
738
|
+
"$ref": "#/$defs/CoveringOptions"
|
|
739
|
+
}
|
|
740
|
+
},
|
|
741
|
+
"required": [
|
|
742
|
+
"levels",
|
|
743
|
+
"r"
|
|
744
|
+
],
|
|
745
|
+
"additionalProperties": false
|
|
746
|
+
},
|
|
747
|
+
"output": {
|
|
748
|
+
"type": "array",
|
|
749
|
+
"items": {
|
|
750
|
+
"type": "array",
|
|
751
|
+
"items": {
|
|
752
|
+
"type": "number"
|
|
753
|
+
}
|
|
754
|
+
}
|
|
755
|
+
},
|
|
756
|
+
"effects": {
|
|
757
|
+
"reads": [],
|
|
758
|
+
"writes": []
|
|
759
|
+
}
|
|
760
|
+
},
|
|
761
|
+
{
|
|
762
|
+
"name": "dependsOnLibm",
|
|
763
|
+
"path": [
|
|
764
|
+
"generators",
|
|
765
|
+
"dependsOnLibm"
|
|
766
|
+
],
|
|
767
|
+
"description": "This function tells if the numbers of a family use `Math.exp`, `Math.log` or `Math.pow`. The result of those functions can change between JavaScript engines. Thus such a family has the same numbers only on one platform.",
|
|
768
|
+
"params": [
|
|
769
|
+
"spec"
|
|
770
|
+
],
|
|
771
|
+
"input": {
|
|
772
|
+
"type": "object",
|
|
773
|
+
"properties": {
|
|
774
|
+
"spec": {
|
|
775
|
+
"$ref": "#/$defs/DistributionSpec"
|
|
776
|
+
}
|
|
777
|
+
},
|
|
778
|
+
"required": [
|
|
779
|
+
"spec"
|
|
780
|
+
],
|
|
781
|
+
"additionalProperties": false
|
|
782
|
+
},
|
|
783
|
+
"output": {
|
|
784
|
+
"type": "boolean"
|
|
785
|
+
},
|
|
786
|
+
"effects": {
|
|
787
|
+
"reads": [],
|
|
788
|
+
"writes": []
|
|
789
|
+
}
|
|
790
|
+
},
|
|
791
|
+
{
|
|
792
|
+
"name": "deriveSeed",
|
|
793
|
+
"path": [
|
|
794
|
+
"generators",
|
|
795
|
+
"deriveSeed"
|
|
796
|
+
],
|
|
797
|
+
"description": "The seed of the stream with the name `label` under `seed`: the hash of `\"<seed>:<label>\"`.",
|
|
798
|
+
"params": [
|
|
799
|
+
"seed",
|
|
800
|
+
"label"
|
|
801
|
+
],
|
|
802
|
+
"input": {
|
|
803
|
+
"type": "object",
|
|
804
|
+
"properties": {
|
|
805
|
+
"seed": {
|
|
806
|
+
"type": "number"
|
|
807
|
+
},
|
|
808
|
+
"label": {
|
|
809
|
+
"type": "string"
|
|
810
|
+
}
|
|
811
|
+
},
|
|
812
|
+
"required": [
|
|
813
|
+
"seed",
|
|
814
|
+
"label"
|
|
815
|
+
],
|
|
816
|
+
"additionalProperties": false
|
|
817
|
+
},
|
|
818
|
+
"output": {
|
|
819
|
+
"type": "number"
|
|
820
|
+
},
|
|
821
|
+
"effects": {
|
|
822
|
+
"reads": [],
|
|
823
|
+
"writes": []
|
|
824
|
+
}
|
|
825
|
+
},
|
|
826
|
+
{
|
|
827
|
+
"name": "familyPoints",
|
|
828
|
+
"path": [
|
|
829
|
+
"generators",
|
|
830
|
+
"familyPoints"
|
|
831
|
+
],
|
|
832
|
+
"description": "This function gives the points of the family at the points of a unit design.",
|
|
833
|
+
"params": [
|
|
834
|
+
"family",
|
|
835
|
+
"unit",
|
|
836
|
+
"r"
|
|
837
|
+
],
|
|
838
|
+
"input": {
|
|
839
|
+
"type": "object",
|
|
840
|
+
"properties": {
|
|
841
|
+
"family": {
|
|
842
|
+
"$ref": "#/$defs/InputFamily"
|
|
843
|
+
},
|
|
844
|
+
"unit": {
|
|
845
|
+
"type": "array",
|
|
846
|
+
"items": {
|
|
847
|
+
"type": "array",
|
|
848
|
+
"items": {
|
|
849
|
+
"type": "number"
|
|
850
|
+
}
|
|
851
|
+
}
|
|
852
|
+
},
|
|
853
|
+
"r": {
|
|
854
|
+
"type": "object",
|
|
855
|
+
"properties": {
|
|
856
|
+
"seed": {
|
|
857
|
+
"anyOf": [
|
|
858
|
+
{
|
|
859
|
+
"type": "string"
|
|
860
|
+
},
|
|
861
|
+
{
|
|
862
|
+
"type": "number"
|
|
863
|
+
}
|
|
864
|
+
]
|
|
865
|
+
}
|
|
866
|
+
},
|
|
867
|
+
"required": [
|
|
868
|
+
"seed"
|
|
869
|
+
],
|
|
870
|
+
"additionalProperties": false,
|
|
871
|
+
"description": "The input of random: the procedure makes the Random with random(seed) before the call.",
|
|
872
|
+
"x-procedures-construct": {
|
|
873
|
+
"function": "random",
|
|
874
|
+
"params": [
|
|
875
|
+
"seed"
|
|
876
|
+
]
|
|
877
|
+
}
|
|
878
|
+
}
|
|
879
|
+
},
|
|
880
|
+
"required": [
|
|
881
|
+
"family",
|
|
882
|
+
"unit",
|
|
883
|
+
"r"
|
|
884
|
+
],
|
|
885
|
+
"additionalProperties": false
|
|
886
|
+
},
|
|
887
|
+
"output": {
|
|
888
|
+
"type": "array",
|
|
889
|
+
"items": {
|
|
890
|
+
"type": "object",
|
|
891
|
+
"properties": {},
|
|
892
|
+
"additionalProperties": {
|
|
893
|
+
"type": "number"
|
|
894
|
+
}
|
|
895
|
+
}
|
|
896
|
+
},
|
|
897
|
+
"effects": {
|
|
898
|
+
"reads": [],
|
|
899
|
+
"writes": []
|
|
900
|
+
}
|
|
901
|
+
},
|
|
902
|
+
{
|
|
903
|
+
"name": "fnv1a32",
|
|
904
|
+
"path": [
|
|
905
|
+
"generators",
|
|
906
|
+
"fnv1a32"
|
|
907
|
+
],
|
|
908
|
+
"description": "The FNV-1a hash of 32 bits of a string. The option `input` selects the units that the hash reads:",
|
|
909
|
+
"params": [
|
|
910
|
+
"text",
|
|
911
|
+
"options"
|
|
912
|
+
],
|
|
913
|
+
"input": {
|
|
914
|
+
"type": "object",
|
|
915
|
+
"properties": {
|
|
916
|
+
"text": {
|
|
917
|
+
"type": "string"
|
|
918
|
+
},
|
|
919
|
+
"options": {
|
|
920
|
+
"type": "object",
|
|
921
|
+
"properties": {
|
|
922
|
+
"input": {
|
|
923
|
+
"enum": [
|
|
924
|
+
"utf8",
|
|
925
|
+
"utf16",
|
|
926
|
+
"wtf8"
|
|
927
|
+
]
|
|
928
|
+
}
|
|
929
|
+
}
|
|
930
|
+
}
|
|
931
|
+
},
|
|
932
|
+
"required": [
|
|
933
|
+
"text"
|
|
934
|
+
],
|
|
935
|
+
"additionalProperties": false
|
|
936
|
+
},
|
|
937
|
+
"output": {
|
|
938
|
+
"type": "number"
|
|
939
|
+
},
|
|
940
|
+
"effects": {
|
|
941
|
+
"reads": [],
|
|
942
|
+
"writes": []
|
|
943
|
+
}
|
|
944
|
+
},
|
|
945
|
+
{
|
|
946
|
+
"name": "latinHypercube",
|
|
947
|
+
"path": [
|
|
948
|
+
"generators",
|
|
949
|
+
"latinHypercube"
|
|
950
|
+
],
|
|
951
|
+
"description": "This function gives a Latin hypercube of `n` points in `d` dimensions. Each column has exactly one point in each of the `n` strata `[k/n, (k+1)/n)`. For each column, the draws are one shuffle of the strata, then one draw in each point.",
|
|
952
|
+
"params": [
|
|
953
|
+
"n",
|
|
954
|
+
"d",
|
|
955
|
+
"r"
|
|
956
|
+
],
|
|
957
|
+
"input": {
|
|
958
|
+
"type": "object",
|
|
959
|
+
"properties": {
|
|
960
|
+
"n": {
|
|
961
|
+
"type": "number"
|
|
962
|
+
},
|
|
963
|
+
"d": {
|
|
964
|
+
"type": "number"
|
|
965
|
+
},
|
|
966
|
+
"r": {
|
|
967
|
+
"type": "object",
|
|
968
|
+
"properties": {
|
|
969
|
+
"seed": {
|
|
970
|
+
"anyOf": [
|
|
971
|
+
{
|
|
972
|
+
"type": "string"
|
|
973
|
+
},
|
|
974
|
+
{
|
|
975
|
+
"type": "number"
|
|
976
|
+
}
|
|
977
|
+
]
|
|
978
|
+
}
|
|
979
|
+
},
|
|
980
|
+
"required": [
|
|
981
|
+
"seed"
|
|
982
|
+
],
|
|
983
|
+
"additionalProperties": false,
|
|
984
|
+
"description": "The input of random: the procedure makes the Random with random(seed) before the call.",
|
|
985
|
+
"x-procedures-construct": {
|
|
986
|
+
"function": "random",
|
|
987
|
+
"params": [
|
|
988
|
+
"seed"
|
|
989
|
+
]
|
|
990
|
+
}
|
|
991
|
+
}
|
|
992
|
+
},
|
|
993
|
+
"required": [
|
|
994
|
+
"n",
|
|
995
|
+
"d",
|
|
996
|
+
"r"
|
|
997
|
+
],
|
|
998
|
+
"additionalProperties": false
|
|
999
|
+
},
|
|
1000
|
+
"output": {
|
|
1001
|
+
"type": "array",
|
|
1002
|
+
"items": {
|
|
1003
|
+
"type": "array",
|
|
1004
|
+
"items": {
|
|
1005
|
+
"type": "number"
|
|
1006
|
+
}
|
|
1007
|
+
}
|
|
1008
|
+
},
|
|
1009
|
+
"effects": {
|
|
1010
|
+
"reads": [],
|
|
1011
|
+
"writes": []
|
|
1012
|
+
}
|
|
1013
|
+
},
|
|
1014
|
+
{
|
|
1015
|
+
"name": "normalCdf",
|
|
1016
|
+
"path": [
|
|
1017
|
+
"generators",
|
|
1018
|
+
"normalCdf"
|
|
1019
|
+
],
|
|
1020
|
+
"description": "This function gives the standard normal cumulative distribution, `P(Z <= x)`. Below 0.75 in size, `x` uses the series of `0.5 + phi(x) * (x + x^3/3 + x^5/15 + ...)`. The tails use the continued fraction of the Mills ratio, so a lower tail has no cancellation. On 2026-11-09 the error was at most 4.4 ulps from -38 to 9, against `mpmath`. `normalCdf(-37)` is approximately 5.7e-300, not 0.",
|
|
1021
|
+
"params": [
|
|
1022
|
+
"x"
|
|
1023
|
+
],
|
|
1024
|
+
"input": {
|
|
1025
|
+
"type": "object",
|
|
1026
|
+
"properties": {
|
|
1027
|
+
"x": {
|
|
1028
|
+
"type": "number",
|
|
1029
|
+
"description": "A number. `-Infinity` gives 0 and `Infinity` gives 1. `NaN` throws a `RangeError`."
|
|
1030
|
+
}
|
|
1031
|
+
},
|
|
1032
|
+
"required": [
|
|
1033
|
+
"x"
|
|
1034
|
+
],
|
|
1035
|
+
"additionalProperties": false
|
|
1036
|
+
},
|
|
1037
|
+
"output": {
|
|
1038
|
+
"type": "number"
|
|
1039
|
+
},
|
|
1040
|
+
"effects": {
|
|
1041
|
+
"reads": [],
|
|
1042
|
+
"writes": []
|
|
1043
|
+
}
|
|
1044
|
+
},
|
|
1045
|
+
{
|
|
1046
|
+
"name": "normalQuantile",
|
|
1047
|
+
"path": [
|
|
1048
|
+
"generators",
|
|
1049
|
+
"normalQuantile"
|
|
1050
|
+
],
|
|
1051
|
+
"description": "This function gives the quantile of the standard normal law: the `x` with `normalCdf(x) = p`. It uses PPND16 of Wichura (algorithm AS 241). Below 0.075, one step of Halley with `normalCdf` follows. Above 0.5, `p` uses the lower tail at `1 - p`. This subtraction is exact. On 2026-11-09 the error was at most 1.2 ulps in the tails and 5.5 ulps from 0.075 to 0.925, against `mpmath`.",
|
|
1052
|
+
"params": [
|
|
1053
|
+
"p"
|
|
1054
|
+
],
|
|
1055
|
+
"input": {
|
|
1056
|
+
"type": "object",
|
|
1057
|
+
"properties": {
|
|
1058
|
+
"p": {
|
|
1059
|
+
"type": "number",
|
|
1060
|
+
"description": "The share of the law below the result, from 0 to 1. A `p` of 0 gives `-Infinity` and 1 gives `Infinity`."
|
|
1061
|
+
}
|
|
1062
|
+
},
|
|
1063
|
+
"required": [
|
|
1064
|
+
"p"
|
|
1065
|
+
],
|
|
1066
|
+
"additionalProperties": false
|
|
1067
|
+
},
|
|
1068
|
+
"output": {
|
|
1069
|
+
"type": "number"
|
|
1070
|
+
},
|
|
1071
|
+
"effects": {
|
|
1072
|
+
"reads": [],
|
|
1073
|
+
"writes": []
|
|
1074
|
+
}
|
|
1075
|
+
},
|
|
1076
|
+
{
|
|
1077
|
+
"name": "plackettLuceOrder",
|
|
1078
|
+
"path": [
|
|
1079
|
+
"generators",
|
|
1080
|
+
"plackettLuceOrder"
|
|
1081
|
+
],
|
|
1082
|
+
"description": "A random order of a list with the Plackett-Luce law of the weights (the Gumbel-max method). Each item gets the sum of its log-weight and a Gumbel draw. The order goes from the largest sum to the smallest.",
|
|
1083
|
+
"params": [
|
|
1084
|
+
"seed",
|
|
1085
|
+
"items",
|
|
1086
|
+
"logWeightOf",
|
|
1087
|
+
"keyOf"
|
|
1088
|
+
],
|
|
1089
|
+
"input": {
|
|
1090
|
+
"type": "object",
|
|
1091
|
+
"properties": {
|
|
1092
|
+
"seed": {
|
|
1093
|
+
"anyOf": [
|
|
1094
|
+
{
|
|
1095
|
+
"type": "string"
|
|
1096
|
+
},
|
|
1097
|
+
{
|
|
1098
|
+
"type": "number"
|
|
1099
|
+
}
|
|
1100
|
+
]
|
|
1101
|
+
},
|
|
1102
|
+
"items": {
|
|
1103
|
+
"type": "array",
|
|
1104
|
+
"items": {}
|
|
1105
|
+
},
|
|
1106
|
+
"logWeightOf": {
|
|
1107
|
+
"type": "object",
|
|
1108
|
+
"description": "One call of a pure procedure, as data, for the function (item: T) => number. It reads each parameter as {\"$ref\": \"<name>\"}: item.",
|
|
1109
|
+
"required": [
|
|
1110
|
+
"$proc"
|
|
1111
|
+
],
|
|
1112
|
+
"properties": {
|
|
1113
|
+
"$proc": {
|
|
1114
|
+
"type": "array",
|
|
1115
|
+
"items": {
|
|
1116
|
+
"type": "string"
|
|
1117
|
+
},
|
|
1118
|
+
"minItems": 1
|
|
1119
|
+
},
|
|
1120
|
+
"input": {},
|
|
1121
|
+
"$when": {
|
|
1122
|
+
"const": "$never"
|
|
1123
|
+
}
|
|
1124
|
+
},
|
|
1125
|
+
"x-procedures-program": {
|
|
1126
|
+
"params": [
|
|
1127
|
+
"item"
|
|
1128
|
+
],
|
|
1129
|
+
"inputs": [
|
|
1130
|
+
{}
|
|
1131
|
+
],
|
|
1132
|
+
"output": {
|
|
1133
|
+
"type": "number"
|
|
1134
|
+
}
|
|
1135
|
+
}
|
|
1136
|
+
},
|
|
1137
|
+
"keyOf": {
|
|
1138
|
+
"type": "object",
|
|
1139
|
+
"description": "One call of a pure procedure, as data, for the function (item: T) => string. It reads each parameter as {\"$ref\": \"<name>\"}: item.",
|
|
1140
|
+
"required": [
|
|
1141
|
+
"$proc"
|
|
1142
|
+
],
|
|
1143
|
+
"properties": {
|
|
1144
|
+
"$proc": {
|
|
1145
|
+
"type": "array",
|
|
1146
|
+
"items": {
|
|
1147
|
+
"type": "string"
|
|
1148
|
+
},
|
|
1149
|
+
"minItems": 1
|
|
1150
|
+
},
|
|
1151
|
+
"input": {},
|
|
1152
|
+
"$when": {
|
|
1153
|
+
"const": "$never"
|
|
1154
|
+
}
|
|
1155
|
+
},
|
|
1156
|
+
"x-procedures-program": {
|
|
1157
|
+
"params": [
|
|
1158
|
+
"item"
|
|
1159
|
+
],
|
|
1160
|
+
"inputs": [
|
|
1161
|
+
{}
|
|
1162
|
+
],
|
|
1163
|
+
"output": {
|
|
1164
|
+
"type": "string"
|
|
1165
|
+
}
|
|
1166
|
+
}
|
|
1167
|
+
}
|
|
1168
|
+
},
|
|
1169
|
+
"required": [
|
|
1170
|
+
"seed",
|
|
1171
|
+
"items",
|
|
1172
|
+
"logWeightOf"
|
|
1173
|
+
],
|
|
1174
|
+
"additionalProperties": false
|
|
1175
|
+
},
|
|
1176
|
+
"output": {
|
|
1177
|
+
"type": "array",
|
|
1178
|
+
"items": {}
|
|
1179
|
+
},
|
|
1180
|
+
"generics": [
|
|
1181
|
+
"T"
|
|
1182
|
+
],
|
|
1183
|
+
"effects": {
|
|
1184
|
+
"reads": [],
|
|
1185
|
+
"writes": []
|
|
1186
|
+
}
|
|
1187
|
+
},
|
|
1188
|
+
{
|
|
1189
|
+
"name": "randomDesign",
|
|
1190
|
+
"path": [
|
|
1191
|
+
"generators",
|
|
1192
|
+
"randomDesign"
|
|
1193
|
+
],
|
|
1194
|
+
"description": "This function gives `n` independent uniform points of the unit cube in `d` dimensions. The draws go row by row.",
|
|
1195
|
+
"params": [
|
|
1196
|
+
"n",
|
|
1197
|
+
"d",
|
|
1198
|
+
"r"
|
|
1199
|
+
],
|
|
1200
|
+
"input": {
|
|
1201
|
+
"type": "object",
|
|
1202
|
+
"properties": {
|
|
1203
|
+
"n": {
|
|
1204
|
+
"type": "number"
|
|
1205
|
+
},
|
|
1206
|
+
"d": {
|
|
1207
|
+
"type": "number"
|
|
1208
|
+
},
|
|
1209
|
+
"r": {
|
|
1210
|
+
"type": "object",
|
|
1211
|
+
"properties": {
|
|
1212
|
+
"seed": {
|
|
1213
|
+
"anyOf": [
|
|
1214
|
+
{
|
|
1215
|
+
"type": "string"
|
|
1216
|
+
},
|
|
1217
|
+
{
|
|
1218
|
+
"type": "number"
|
|
1219
|
+
}
|
|
1220
|
+
]
|
|
1221
|
+
}
|
|
1222
|
+
},
|
|
1223
|
+
"required": [
|
|
1224
|
+
"seed"
|
|
1225
|
+
],
|
|
1226
|
+
"additionalProperties": false,
|
|
1227
|
+
"description": "The input of random: the procedure makes the Random with random(seed) before the call.",
|
|
1228
|
+
"x-procedures-construct": {
|
|
1229
|
+
"function": "random",
|
|
1230
|
+
"params": [
|
|
1231
|
+
"seed"
|
|
1232
|
+
]
|
|
1233
|
+
}
|
|
1234
|
+
}
|
|
1235
|
+
},
|
|
1236
|
+
"required": [
|
|
1237
|
+
"n",
|
|
1238
|
+
"d",
|
|
1239
|
+
"r"
|
|
1240
|
+
],
|
|
1241
|
+
"additionalProperties": false
|
|
1242
|
+
},
|
|
1243
|
+
"output": {
|
|
1244
|
+
"type": "array",
|
|
1245
|
+
"items": {
|
|
1246
|
+
"type": "array",
|
|
1247
|
+
"items": {
|
|
1248
|
+
"type": "number"
|
|
1249
|
+
}
|
|
1250
|
+
}
|
|
1251
|
+
},
|
|
1252
|
+
"effects": {
|
|
1253
|
+
"reads": [],
|
|
1254
|
+
"writes": []
|
|
1255
|
+
}
|
|
1256
|
+
},
|
|
1257
|
+
{
|
|
1258
|
+
"name": "recordedSpec",
|
|
1259
|
+
"path": [
|
|
1260
|
+
"generators",
|
|
1261
|
+
"recordedSpec"
|
|
1262
|
+
],
|
|
1263
|
+
"description": "This function gives the spec of the family `recorded` that draws from a table.",
|
|
1264
|
+
"params": [
|
|
1265
|
+
"table"
|
|
1266
|
+
],
|
|
1267
|
+
"input": {
|
|
1268
|
+
"type": "object",
|
|
1269
|
+
"properties": {
|
|
1270
|
+
"table": {
|
|
1271
|
+
"$ref": "#/$defs/RecordedTable"
|
|
1272
|
+
}
|
|
1273
|
+
},
|
|
1274
|
+
"required": [
|
|
1275
|
+
"table"
|
|
1276
|
+
],
|
|
1277
|
+
"additionalProperties": false
|
|
1278
|
+
},
|
|
1279
|
+
"output": {
|
|
1280
|
+
"$ref": "#/$defs/DistributionSpec"
|
|
1281
|
+
},
|
|
1282
|
+
"effects": {
|
|
1283
|
+
"reads": [],
|
|
1284
|
+
"writes": []
|
|
1285
|
+
}
|
|
1286
|
+
},
|
|
1287
|
+
{
|
|
1288
|
+
"name": "saltelliDesign",
|
|
1289
|
+
"path": [
|
|
1290
|
+
"generators",
|
|
1291
|
+
"saltelliDesign"
|
|
1292
|
+
],
|
|
1293
|
+
"description": "This function gives the Saltelli design for the Sobol indices of a model with `d` inputs: `a`, `b` and the `d` matrices `ab`. The design has `n * (d + 2)` points for the model. `a` comes from `r.fork(\"A\")`, and `b` comes from `r.fork(\"B\")`. With `base` `\"latin\"`, each is a Latin hypercube.",
|
|
1294
|
+
"params": [
|
|
1295
|
+
"n",
|
|
1296
|
+
"d",
|
|
1297
|
+
"r",
|
|
1298
|
+
"base"
|
|
1299
|
+
],
|
|
1300
|
+
"input": {
|
|
1301
|
+
"type": "object",
|
|
1302
|
+
"properties": {
|
|
1303
|
+
"n": {
|
|
1304
|
+
"type": "number"
|
|
1305
|
+
},
|
|
1306
|
+
"d": {
|
|
1307
|
+
"type": "number"
|
|
1308
|
+
},
|
|
1309
|
+
"r": {
|
|
1310
|
+
"type": "object",
|
|
1311
|
+
"properties": {
|
|
1312
|
+
"seed": {
|
|
1313
|
+
"anyOf": [
|
|
1314
|
+
{
|
|
1315
|
+
"type": "string"
|
|
1316
|
+
},
|
|
1317
|
+
{
|
|
1318
|
+
"type": "number"
|
|
1319
|
+
}
|
|
1320
|
+
]
|
|
1321
|
+
}
|
|
1322
|
+
},
|
|
1323
|
+
"required": [
|
|
1324
|
+
"seed"
|
|
1325
|
+
],
|
|
1326
|
+
"additionalProperties": false,
|
|
1327
|
+
"description": "The input of random: the procedure makes the Random with random(seed) before the call.",
|
|
1328
|
+
"x-procedures-construct": {
|
|
1329
|
+
"function": "random",
|
|
1330
|
+
"params": [
|
|
1331
|
+
"seed"
|
|
1332
|
+
]
|
|
1333
|
+
}
|
|
1334
|
+
},
|
|
1335
|
+
"base": {
|
|
1336
|
+
"enum": [
|
|
1337
|
+
"random",
|
|
1338
|
+
"latin"
|
|
1339
|
+
]
|
|
1340
|
+
}
|
|
1341
|
+
},
|
|
1342
|
+
"required": [
|
|
1343
|
+
"n",
|
|
1344
|
+
"d",
|
|
1345
|
+
"r"
|
|
1346
|
+
],
|
|
1347
|
+
"additionalProperties": false
|
|
1348
|
+
},
|
|
1349
|
+
"output": {
|
|
1350
|
+
"$ref": "#/$defs/SaltelliDesign"
|
|
1351
|
+
},
|
|
1352
|
+
"effects": {
|
|
1353
|
+
"reads": [],
|
|
1354
|
+
"writes": []
|
|
1355
|
+
}
|
|
1356
|
+
},
|
|
1357
|
+
{
|
|
1358
|
+
"name": "seedOf",
|
|
1359
|
+
"path": [
|
|
1360
|
+
"generators",
|
|
1361
|
+
"seedOf"
|
|
1362
|
+
],
|
|
1363
|
+
"description": "The 32-bit seed of a number (its low 32 bits, unsigned) or of a string (its FNV-1a hash).",
|
|
1364
|
+
"params": [
|
|
1365
|
+
"seed"
|
|
1366
|
+
],
|
|
1367
|
+
"input": {
|
|
1368
|
+
"type": "object",
|
|
1369
|
+
"properties": {
|
|
1370
|
+
"seed": {
|
|
1371
|
+
"anyOf": [
|
|
1372
|
+
{
|
|
1373
|
+
"type": "string"
|
|
1374
|
+
},
|
|
1375
|
+
{
|
|
1376
|
+
"type": "number"
|
|
1377
|
+
}
|
|
1378
|
+
]
|
|
1379
|
+
}
|
|
1380
|
+
},
|
|
1381
|
+
"required": [
|
|
1382
|
+
"seed"
|
|
1383
|
+
],
|
|
1384
|
+
"additionalProperties": false
|
|
1385
|
+
},
|
|
1386
|
+
"output": {
|
|
1387
|
+
"type": "number"
|
|
1388
|
+
},
|
|
1389
|
+
"effects": {
|
|
1390
|
+
"reads": [],
|
|
1391
|
+
"writes": []
|
|
1392
|
+
}
|
|
1393
|
+
},
|
|
1394
|
+
{
|
|
1395
|
+
"name": "seedsFrom",
|
|
1396
|
+
"path": [
|
|
1397
|
+
"generators",
|
|
1398
|
+
"seedsFrom"
|
|
1399
|
+
],
|
|
1400
|
+
"description": "The seeds of a run: the seeds in `given` (the text of an environment variable, for example `process.env.SEED`), else the default seeds. An empty text gives the defaults.",
|
|
1401
|
+
"params": [
|
|
1402
|
+
"given",
|
|
1403
|
+
"defaults"
|
|
1404
|
+
],
|
|
1405
|
+
"input": {
|
|
1406
|
+
"type": "object",
|
|
1407
|
+
"properties": {
|
|
1408
|
+
"given": {
|
|
1409
|
+
"type": "string"
|
|
1410
|
+
},
|
|
1411
|
+
"defaults": {
|
|
1412
|
+
"type": "array",
|
|
1413
|
+
"items": {
|
|
1414
|
+
"type": "number"
|
|
1415
|
+
}
|
|
1416
|
+
}
|
|
1417
|
+
},
|
|
1418
|
+
"required": [
|
|
1419
|
+
"given",
|
|
1420
|
+
"defaults"
|
|
1421
|
+
],
|
|
1422
|
+
"additionalProperties": false
|
|
1423
|
+
},
|
|
1424
|
+
"output": {
|
|
1425
|
+
"type": "array",
|
|
1426
|
+
"items": {
|
|
1427
|
+
"type": "number"
|
|
1428
|
+
}
|
|
1429
|
+
},
|
|
1430
|
+
"effects": {
|
|
1431
|
+
"reads": [],
|
|
1432
|
+
"writes": []
|
|
1433
|
+
}
|
|
1434
|
+
},
|
|
1435
|
+
{
|
|
1436
|
+
"name": "sha256Hex",
|
|
1437
|
+
"path": [
|
|
1438
|
+
"generators",
|
|
1439
|
+
"sha256Hex"
|
|
1440
|
+
],
|
|
1441
|
+
"description": "This function gives the SHA-256 digest of the bytes of a string, as 64 lowercase hex characters. The option `input` selects the bytes of a lone surrogate. It is not for passwords: it has no salt and no cost.",
|
|
1442
|
+
"params": [
|
|
1443
|
+
"text",
|
|
1444
|
+
"options"
|
|
1445
|
+
],
|
|
1446
|
+
"input": {
|
|
1447
|
+
"type": "object",
|
|
1448
|
+
"properties": {
|
|
1449
|
+
"text": {
|
|
1450
|
+
"type": "string"
|
|
1451
|
+
},
|
|
1452
|
+
"options": {
|
|
1453
|
+
"$ref": "#/$defs/Sha256Options"
|
|
1454
|
+
}
|
|
1455
|
+
},
|
|
1456
|
+
"required": [
|
|
1457
|
+
"text"
|
|
1458
|
+
],
|
|
1459
|
+
"additionalProperties": false
|
|
1460
|
+
},
|
|
1461
|
+
"output": {
|
|
1462
|
+
"type": "string"
|
|
1463
|
+
},
|
|
1464
|
+
"effects": {
|
|
1465
|
+
"reads": [],
|
|
1466
|
+
"writes": []
|
|
1467
|
+
}
|
|
1468
|
+
},
|
|
1469
|
+
{
|
|
1470
|
+
"name": "shrinkPoint",
|
|
1471
|
+
"path": [
|
|
1472
|
+
"generators",
|
|
1473
|
+
"shrinkPoint"
|
|
1474
|
+
],
|
|
1475
|
+
"description": "This function shrinks a point of a family that fails. Each dimension moves toward `shrinkTarget`, while the point still fails. - In each round, each dimension first tries its target. Then a bisection on the scale of the dimension finds the edge of the failure. - The rounds continue until a round has no move, or until the budget of checks ends. - The function `fails` gives `true` for a point that fails. A first point that does not fail is a `RangeError`. - The shrink has no random draws. Thus the same point and the same function give the same result.",
|
|
1476
|
+
"params": [
|
|
1477
|
+
"family",
|
|
1478
|
+
"point",
|
|
1479
|
+
"fails",
|
|
1480
|
+
"options"
|
|
1481
|
+
],
|
|
1482
|
+
"input": {
|
|
1483
|
+
"type": "object",
|
|
1484
|
+
"properties": {
|
|
1485
|
+
"family": {
|
|
1486
|
+
"$ref": "#/$defs/InputFamily"
|
|
1487
|
+
},
|
|
1488
|
+
"point": {
|
|
1489
|
+
"type": "object",
|
|
1490
|
+
"properties": {},
|
|
1491
|
+
"additionalProperties": {
|
|
1492
|
+
"type": "number"
|
|
1493
|
+
}
|
|
1494
|
+
},
|
|
1495
|
+
"fails": {
|
|
1496
|
+
"type": "object",
|
|
1497
|
+
"description": "One call of a pure procedure, as data, for the function (point: Readonly<Record<string, number>>) => boolean. It reads each parameter as {\"$ref\": \"<name>\"}: point.",
|
|
1498
|
+
"required": [
|
|
1499
|
+
"$proc"
|
|
1500
|
+
],
|
|
1501
|
+
"properties": {
|
|
1502
|
+
"$proc": {
|
|
1503
|
+
"type": "array",
|
|
1504
|
+
"items": {
|
|
1505
|
+
"type": "string"
|
|
1506
|
+
},
|
|
1507
|
+
"minItems": 1
|
|
1508
|
+
},
|
|
1509
|
+
"input": {},
|
|
1510
|
+
"$when": {
|
|
1511
|
+
"const": "$never"
|
|
1512
|
+
}
|
|
1513
|
+
},
|
|
1514
|
+
"x-procedures-program": {
|
|
1515
|
+
"params": [
|
|
1516
|
+
"point"
|
|
1517
|
+
],
|
|
1518
|
+
"inputs": [
|
|
1519
|
+
{
|
|
1520
|
+
"type": "object",
|
|
1521
|
+
"properties": {},
|
|
1522
|
+
"additionalProperties": {
|
|
1523
|
+
"type": "number"
|
|
1524
|
+
}
|
|
1525
|
+
}
|
|
1526
|
+
],
|
|
1527
|
+
"output": {
|
|
1528
|
+
"type": "boolean"
|
|
1529
|
+
}
|
|
1530
|
+
}
|
|
1531
|
+
},
|
|
1532
|
+
"options": {
|
|
1533
|
+
"$ref": "#/$defs/ShrinkOptions"
|
|
1534
|
+
}
|
|
1535
|
+
},
|
|
1536
|
+
"required": [
|
|
1537
|
+
"family",
|
|
1538
|
+
"point",
|
|
1539
|
+
"fails"
|
|
1540
|
+
],
|
|
1541
|
+
"additionalProperties": false
|
|
1542
|
+
},
|
|
1543
|
+
"output": {
|
|
1544
|
+
"$ref": "#/$defs/Shrunk"
|
|
1545
|
+
},
|
|
1546
|
+
"effects": {
|
|
1547
|
+
"reads": [],
|
|
1548
|
+
"writes": []
|
|
1549
|
+
}
|
|
1550
|
+
},
|
|
1551
|
+
{
|
|
1552
|
+
"name": "shrinkTarget",
|
|
1553
|
+
"path": [
|
|
1554
|
+
"generators",
|
|
1555
|
+
"shrinkTarget"
|
|
1556
|
+
],
|
|
1557
|
+
"description": "This function gives the target of a dimension: the value of its range nearest to 0.",
|
|
1558
|
+
"params": [
|
|
1559
|
+
"dimension"
|
|
1560
|
+
],
|
|
1561
|
+
"input": {
|
|
1562
|
+
"type": "object",
|
|
1563
|
+
"properties": {
|
|
1564
|
+
"dimension": {
|
|
1565
|
+
"$ref": "#/$defs/Dimension"
|
|
1566
|
+
}
|
|
1567
|
+
},
|
|
1568
|
+
"required": [
|
|
1569
|
+
"dimension"
|
|
1570
|
+
],
|
|
1571
|
+
"additionalProperties": false
|
|
1572
|
+
},
|
|
1573
|
+
"output": {
|
|
1574
|
+
"type": "number"
|
|
1575
|
+
},
|
|
1576
|
+
"effects": {
|
|
1577
|
+
"reads": [],
|
|
1578
|
+
"writes": []
|
|
1579
|
+
}
|
|
1580
|
+
},
|
|
1581
|
+
{
|
|
1582
|
+
"name": "stablePick",
|
|
1583
|
+
"path": [
|
|
1584
|
+
"generators",
|
|
1585
|
+
"stablePick"
|
|
1586
|
+
],
|
|
1587
|
+
"description": "One item of a list, chosen by highest random weight: each key has a weight from `seed`, and the largest weight wins.",
|
|
1588
|
+
"params": [
|
|
1589
|
+
"seed",
|
|
1590
|
+
"items",
|
|
1591
|
+
"keyOf"
|
|
1592
|
+
],
|
|
1593
|
+
"input": {
|
|
1594
|
+
"type": "object",
|
|
1595
|
+
"properties": {
|
|
1596
|
+
"seed": {
|
|
1597
|
+
"type": "number"
|
|
1598
|
+
},
|
|
1599
|
+
"items": {
|
|
1600
|
+
"type": "array",
|
|
1601
|
+
"items": {}
|
|
1602
|
+
},
|
|
1603
|
+
"keyOf": {
|
|
1604
|
+
"type": "object",
|
|
1605
|
+
"description": "One call of a pure procedure, as data, for the function (item: T) => string. It reads each parameter as {\"$ref\": \"<name>\"}: item.",
|
|
1606
|
+
"required": [
|
|
1607
|
+
"$proc"
|
|
1608
|
+
],
|
|
1609
|
+
"properties": {
|
|
1610
|
+
"$proc": {
|
|
1611
|
+
"type": "array",
|
|
1612
|
+
"items": {
|
|
1613
|
+
"type": "string"
|
|
1614
|
+
},
|
|
1615
|
+
"minItems": 1
|
|
1616
|
+
},
|
|
1617
|
+
"input": {},
|
|
1618
|
+
"$when": {
|
|
1619
|
+
"const": "$never"
|
|
1620
|
+
}
|
|
1621
|
+
},
|
|
1622
|
+
"x-procedures-program": {
|
|
1623
|
+
"params": [
|
|
1624
|
+
"item"
|
|
1625
|
+
],
|
|
1626
|
+
"inputs": [
|
|
1627
|
+
{}
|
|
1628
|
+
],
|
|
1629
|
+
"output": {
|
|
1630
|
+
"type": "string"
|
|
1631
|
+
}
|
|
1632
|
+
}
|
|
1633
|
+
}
|
|
1634
|
+
},
|
|
1635
|
+
"required": [
|
|
1636
|
+
"seed",
|
|
1637
|
+
"items"
|
|
1638
|
+
],
|
|
1639
|
+
"additionalProperties": false
|
|
1640
|
+
},
|
|
1641
|
+
"output": {},
|
|
1642
|
+
"generics": [
|
|
1643
|
+
"T"
|
|
1644
|
+
],
|
|
1645
|
+
"effects": {
|
|
1646
|
+
"reads": [],
|
|
1647
|
+
"writes": []
|
|
1648
|
+
}
|
|
1649
|
+
},
|
|
1650
|
+
{
|
|
1651
|
+
"name": "stratifiedDesign",
|
|
1652
|
+
"path": [
|
|
1653
|
+
"generators",
|
|
1654
|
+
"stratifiedDesign"
|
|
1655
|
+
],
|
|
1656
|
+
"description": "This function gives a stratified grid: `strata` strata on each axis, so `strata^d` cells, and one uniform point in each cell. The cells go in the order of their index in base `strata`, with the first dimension as the last digit.",
|
|
1657
|
+
"params": [
|
|
1658
|
+
"strata",
|
|
1659
|
+
"d",
|
|
1660
|
+
"r",
|
|
1661
|
+
"limit"
|
|
1662
|
+
],
|
|
1663
|
+
"input": {
|
|
1664
|
+
"type": "object",
|
|
1665
|
+
"properties": {
|
|
1666
|
+
"strata": {
|
|
1667
|
+
"type": "number"
|
|
1668
|
+
},
|
|
1669
|
+
"d": {
|
|
1670
|
+
"type": "number"
|
|
1671
|
+
},
|
|
1672
|
+
"r": {
|
|
1673
|
+
"type": "object",
|
|
1674
|
+
"properties": {
|
|
1675
|
+
"seed": {
|
|
1676
|
+
"anyOf": [
|
|
1677
|
+
{
|
|
1678
|
+
"type": "string"
|
|
1679
|
+
},
|
|
1680
|
+
{
|
|
1681
|
+
"type": "number"
|
|
1682
|
+
}
|
|
1683
|
+
]
|
|
1684
|
+
}
|
|
1685
|
+
},
|
|
1686
|
+
"required": [
|
|
1687
|
+
"seed"
|
|
1688
|
+
],
|
|
1689
|
+
"additionalProperties": false,
|
|
1690
|
+
"description": "The input of random: the procedure makes the Random with random(seed) before the call.",
|
|
1691
|
+
"x-procedures-construct": {
|
|
1692
|
+
"function": "random",
|
|
1693
|
+
"params": [
|
|
1694
|
+
"seed"
|
|
1695
|
+
]
|
|
1696
|
+
}
|
|
1697
|
+
},
|
|
1698
|
+
"limit": {
|
|
1699
|
+
"type": "number"
|
|
1700
|
+
}
|
|
1701
|
+
},
|
|
1702
|
+
"required": [
|
|
1703
|
+
"strata",
|
|
1704
|
+
"d",
|
|
1705
|
+
"r"
|
|
1706
|
+
],
|
|
1707
|
+
"additionalProperties": false
|
|
1708
|
+
},
|
|
1709
|
+
"output": {
|
|
1710
|
+
"type": "array",
|
|
1711
|
+
"items": {
|
|
1712
|
+
"type": "array",
|
|
1713
|
+
"items": {
|
|
1714
|
+
"type": "number"
|
|
1715
|
+
}
|
|
1716
|
+
}
|
|
1717
|
+
},
|
|
1718
|
+
"effects": {
|
|
1719
|
+
"reads": [],
|
|
1720
|
+
"writes": []
|
|
1721
|
+
}
|
|
1722
|
+
},
|
|
1723
|
+
{
|
|
1724
|
+
"name": "tupleCoverage",
|
|
1725
|
+
"path": [
|
|
1726
|
+
"generators",
|
|
1727
|
+
"tupleCoverage"
|
|
1728
|
+
],
|
|
1729
|
+
"description": "This function gives the coverage of some rows over named dimensions, with the strength `t` (the default is 2). A row holds a combination when it has each of its values. The function compares the values as text with `String`, and it ignores the fields of a row that are not dimensions. With fewer dimensions than `t`, the combinations are those of all the dimensions. Thus no dimensions give one empty combination, with the key `\"\"`.",
|
|
1730
|
+
"params": [
|
|
1731
|
+
"rows",
|
|
1732
|
+
"dimensions",
|
|
1733
|
+
"strength"
|
|
1734
|
+
],
|
|
1735
|
+
"input": {
|
|
1736
|
+
"type": "object",
|
|
1737
|
+
"properties": {
|
|
1738
|
+
"rows": {
|
|
1739
|
+
"type": "array",
|
|
1740
|
+
"items": {
|
|
1741
|
+
"type": "object",
|
|
1742
|
+
"properties": {},
|
|
1743
|
+
"additionalProperties": {}
|
|
1744
|
+
}
|
|
1745
|
+
},
|
|
1746
|
+
"dimensions": {
|
|
1747
|
+
"type": "object",
|
|
1748
|
+
"properties": {},
|
|
1749
|
+
"additionalProperties": {
|
|
1750
|
+
"type": "array",
|
|
1751
|
+
"items": {}
|
|
1752
|
+
}
|
|
1753
|
+
},
|
|
1754
|
+
"strength": {
|
|
1755
|
+
"type": "number"
|
|
1756
|
+
}
|
|
1757
|
+
},
|
|
1758
|
+
"required": [
|
|
1759
|
+
"rows",
|
|
1760
|
+
"dimensions"
|
|
1761
|
+
],
|
|
1762
|
+
"additionalProperties": false
|
|
1763
|
+
},
|
|
1764
|
+
"output": {
|
|
1765
|
+
"$ref": "#/$defs/Coverage"
|
|
1766
|
+
},
|
|
1767
|
+
"effects": {
|
|
1768
|
+
"reads": [],
|
|
1769
|
+
"writes": []
|
|
1770
|
+
}
|
|
1771
|
+
}
|
|
1772
|
+
],
|
|
1773
|
+
"exempt": [
|
|
1774
|
+
{
|
|
1775
|
+
"name": "coveringRows",
|
|
1776
|
+
"reason": "output-not-json",
|
|
1777
|
+
"detail": "D[string][number]"
|
|
1778
|
+
},
|
|
1779
|
+
{
|
|
1780
|
+
"name": "distributionOf",
|
|
1781
|
+
"reason": "output-not-json",
|
|
1782
|
+
"detail": "an object with the method cdf"
|
|
1783
|
+
},
|
|
1784
|
+
{
|
|
1785
|
+
"name": "familyMap",
|
|
1786
|
+
"reason": "output-not-json",
|
|
1787
|
+
"detail": "(unit: readonly number[]) => Readonly<Record<string, number>>"
|
|
1788
|
+
},
|
|
1789
|
+
{
|
|
1790
|
+
"name": "mulberry32",
|
|
1791
|
+
"reason": "output-not-json",
|
|
1792
|
+
"detail": "Source"
|
|
1793
|
+
},
|
|
1794
|
+
{
|
|
1795
|
+
"name": "random",
|
|
1796
|
+
"reason": "function-parameter",
|
|
1797
|
+
"detail": "source: (seed: number) => Source"
|
|
1798
|
+
},
|
|
1799
|
+
{
|
|
1800
|
+
"name": "randomOf",
|
|
1801
|
+
"reason": "function-parameter",
|
|
1802
|
+
"detail": "source: (seed: number) => Source"
|
|
1803
|
+
},
|
|
1804
|
+
{
|
|
1805
|
+
"name": "sampler",
|
|
1806
|
+
"reason": "output-not-json",
|
|
1807
|
+
"detail": "() => number"
|
|
1808
|
+
},
|
|
1809
|
+
{
|
|
1810
|
+
"name": "shrinkPointAsync",
|
|
1811
|
+
"reason": "function-parameter",
|
|
1812
|
+
"detail": "fails: (point: Readonly<Record<string, number>>) => boolean | Promise<boolean>"
|
|
1813
|
+
}
|
|
1814
|
+
],
|
|
1815
|
+
"others": {
|
|
1816
|
+
"classes": [],
|
|
1817
|
+
"values": 7,
|
|
1818
|
+
"types": 17
|
|
1819
|
+
}
|
|
1820
|
+
};
|