1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
|
import boolbase from "boolbase";
/**
* Returns a function that checks if an elements index matches the given rule
* highly optimized to return the fastest solution.
*
* @param parsed A tuple [a, b], as returned by `parse`.
* @returns A highly optimized function that returns whether an index matches the nth-check.
* @example
*
* ```js
* const check = nthCheck.compile([2, 3]);
*
* check(0); // `false`
* check(1); // `false`
* check(2); // `true`
* check(3); // `false`
* check(4); // `true`
* check(5); // `false`
* check(6); // `true`
* ```
*/
export function compile(parsed) {
const a = parsed[0];
// Subtract 1 from `b`, to convert from one- to zero-indexed.
const b = parsed[1] - 1;
/*
* When `b <= 0`, `a * n` won't be lead to any matches for `a < 0`.
* Besides, the specification states that no elements are
* matched when `a` and `b` are 0.
*
* `b < 0` here as we subtracted 1 from `b` above.
*/
if (b < 0 && a <= 0)
return boolbase.falseFunc;
// When `a` is in the range -1..1, it matches any element (so only `b` is checked).
if (a === -1)
return (index) => index <= b;
if (a === 0)
return (index) => index === b;
// When `b <= 0` and `a === 1`, they match any element.
if (a === 1)
return b < 0 ? boolbase.trueFunc : (index) => index >= b;
/*
* Otherwise, modulo can be used to check if there is a match.
*
* Modulo doesn't care about the sign, so let's use `a`s absolute value.
*/
const absA = Math.abs(a);
// Get `b mod a`, + a if this is negative.
const bMod = ((b % absA) + absA) % absA;
return a > 1
? (index) => index >= b && index % absA === bMod
: (index) => index <= b && index % absA === bMod;
}
/**
* Returns a function that produces a monotonously increasing sequence of indices.
*
* If the sequence has an end, the returned function will return `null` after
* the last index in the sequence.
*
* @param parsed A tuple [a, b], as returned by `parse`.
* @returns A function that produces a sequence of indices.
* @example <caption>Always increasing (2n+3)</caption>
*
* ```js
* const gen = nthCheck.generate([2, 3])
*
* gen() // `1`
* gen() // `3`
* gen() // `5`
* gen() // `8`
* gen() // `11`
* ```
*
* @example <caption>With end value (-2n+10)</caption>
*
* ```js
*
* const gen = nthCheck.generate([-2, 5]);
*
* gen() // 0
* gen() // 2
* gen() // 4
* gen() // null
* ```
*/
export function generate(parsed) {
const a = parsed[0];
// Subtract 1 from `b`, to convert from one- to zero-indexed.
let b = parsed[1] - 1;
let n = 0;
// Make sure to always return an increasing sequence
if (a < 0) {
const aPos = -a;
// Get `b mod a`
const minValue = ((b % aPos) + aPos) % aPos;
return () => {
const val = minValue + aPos * n++;
return val > b ? null : val;
};
}
if (a === 0)
return b < 0
? // There are no result — always return `null`
() => null
: // Return `b` exactly once
() => (n++ === 0 ? b : null);
if (b < 0) {
b += a * Math.ceil(-b / a);
}
return () => a * n++ + b;
}
//# sourceMappingURL=compile.js.map
|
