@isopodlabs/utilities 1.5.9 → 1.7.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.
Files changed (3) hide show
  1. package/dist/bits.d.ts +148 -57
  2. package/dist/bits.js +946 -344
  3. package/package.json +1 -1
package/dist/bits.d.ts CHANGED
@@ -1,119 +1,210 @@
1
1
  export declare function lowestSet32(x: number): number;
2
2
  export declare function highestSet32(x: number): number;
3
+ export declare function highestSet1024(x: number): number;
3
4
  export declare function countSet32(x: number): number;
4
5
  export declare function nthSet32(x: number, i: number): number;
6
+ export declare function reverse32(x: number): number;
5
7
  export declare function highestSet(x: bigint | number): number;
6
8
  export declare function lowestSet(x: number | bigint): number;
7
9
  export declare function countSet(x: bigint | number): number;
8
10
  export declare function nthSet(x: bigint | number, i: number): number;
11
+ export declare function reverse(x: number): number;
12
+ export declare function reverse(x: bigint): bigint;
9
13
  export declare function highestClear(x: number | bigint): number;
10
14
  export declare function lowestClear(x: number | bigint): number;
11
15
  export declare function countClear(x: bigint | number): number;
12
16
  export declare function clearLowest(x: bigint): bigint;
13
17
  export declare function clearLowest(x: number): number;
14
18
  export declare function clearLowest(x: bigint | number): bigint | number;
15
- export interface immutableBitSet {
19
+ export interface BitSet {
16
20
  test(a: number): boolean;
21
+ equals(other: this): boolean;
22
+ contains(other: this): boolean;
23
+ intersects(other: this): boolean;
17
24
  countSet(): number;
18
25
  nthSet(a: number): number;
19
- complement(): this;
20
- intersect(other: this): this;
21
- union(other: this): this;
22
- xor(other: this): this;
23
- contains(other: this): boolean;
26
+ complement(): BitSet;
27
+ intersect(other: this): BitSet;
28
+ union(other: this): BitSet;
29
+ xor(other: this): BitSet;
30
+ difference(other: this): BitSet;
24
31
  next(a: number, set: boolean): number;
25
- where(set: boolean, from?: number): {
32
+ where(set: boolean, from?: number, to?: number): {
26
33
  [Symbol.iterator](): Generator<number>;
27
34
  };
28
- ranges(): {
29
- [Symbol.iterator](): Generator<number[]>;
35
+ ranges(set?: boolean): {
36
+ [Symbol.iterator](): Generator<[number, number]>;
30
37
  };
38
+ slice(from: number, to?: number): BitSet;
31
39
  [Symbol.iterator](): Generator<number>;
32
- }
33
- export interface BitSet extends immutableBitSet {
34
40
  set(a: number): void;
35
41
  clear(a: number): void;
36
42
  setRange(a: number, b: number): this;
37
43
  clearRange(a: number, b: number): this;
38
- selfComplement(): this;
44
+ selfComplement?(): this;
39
45
  selfIntersect(other: this): this;
40
46
  selfUnion(other: this): this;
41
47
  selfXor(other: this): this;
48
+ selfDifference(other: this): this;
42
49
  }
43
- export declare class ImmutableSparseBits implements immutableBitSet {
44
- protected bits: number[];
45
- protected undef: number;
46
- static whereGenerator(bits: number[], undef: number, set: boolean, from?: number): Generator<number>;
47
- constructor(initial?: boolean);
48
- protected create(init?: boolean): this;
49
- protected copyUndefined(other: ImmutableSparseBits): this;
50
- protected flipUndefined(other: ImmutableSparseBits): this;
51
- static fromEntries<T extends ImmutableSparseBits>(this: new (initial?: boolean) => T, entries: Record<number, number> | [number, number][], initial?: boolean): T;
52
- keys(): number[];
53
- entries(): [number, number][];
50
+ export declare class DenseBits implements BitSet {
51
+ protected bits: bigint;
52
+ constructor(bits?: bigint);
53
+ protected create(bits?: bigint): this;
54
+ static fromIndices<C extends new (bits: bigint, ...args: any[]) => any>(this: C, ...indices: number[]): InstanceType<C>;
55
+ get length(): number;
54
56
  test(a: number): boolean;
57
+ equals(other: this): boolean;
58
+ contains(other: this): boolean;
59
+ intersects(other: this): boolean;
55
60
  countSet(): number;
56
61
  nthSet(a: number): number;
57
62
  complement(): this;
58
- intersect(other: ImmutableSparseBits): this;
59
- union(other: ImmutableSparseBits): this;
60
- xor(other: ImmutableSparseBits): this;
61
- contains(other: ImmutableSparseBits): boolean;
63
+ intersect(other: DenseBits): this;
64
+ union(other: DenseBits): this;
65
+ xor(other: DenseBits): this;
66
+ difference(other: DenseBits): this;
62
67
  next(a: number, set?: boolean): number;
63
- where(set: boolean, from?: number): {
64
- [Symbol.iterator]: () => Generator<number, any, any>;
68
+ where(set: boolean, from?: number, to?: number): {
69
+ [Symbol.iterator](): Generator<number>;
65
70
  };
66
- ranges(): {
67
- [Symbol.iterator](): Generator<number[]>;
71
+ ranges(set?: boolean): {
72
+ [Symbol.iterator](): Generator<[number, number]>;
68
73
  };
69
74
  [Symbol.iterator](): Generator<number>;
70
- clean(): this;
71
- toDense(): DenseBits;
72
- }
73
- export declare class SparseBits extends ImmutableSparseBits implements BitSet {
74
- private setMask;
75
- private clearMask;
75
+ toSparse(): SparseBits;
76
+ slice(from: number, to?: number): BitSet;
77
+ protected setMask(m: bigint): void;
78
+ protected clearMask(m: bigint): void;
76
79
  set(a: number): void;
77
80
  clear(a: number): void;
78
81
  setRange(a: number, b: number): this;
79
82
  clearRange(a: number, b: number): this;
80
83
  selfComplement(): this;
81
- selfIntersect(other: SparseBits): this;
82
- selfUnion(other: SparseBits): this;
83
- selfXor(other: SparseBits): this;
84
+ selfIntersect(other: DenseBits): this;
85
+ selfUnion(other: DenseBits): this;
86
+ selfXor(other: DenseBits): this;
87
+ selfDifference(other: DenseBits): this;
84
88
  }
85
- export declare class ImmutableDenseBits implements immutableBitSet {
86
- protected bits: bigint;
87
- constructor(bits?: bigint);
88
- protected create(bits?: bigint): this;
89
+ export declare class DenseBits32 implements BitSet {
90
+ protected bits: Uint32Array;
91
+ constructor(bits?: Uint32Array);
92
+ protected create(bits?: Uint32Array): this;
93
+ static fromIndices<C extends new (bits: Uint32Array, ...args: any[]) => any>(this: C, ...indices: number[]): InstanceType<C>;
89
94
  get length(): number;
90
95
  test(a: number): boolean;
96
+ equals(other: this): boolean;
97
+ contains(other: this): boolean;
98
+ intersects(other: this): boolean;
91
99
  countSet(): number;
92
100
  nthSet(a: number): number;
93
101
  complement(): this;
94
- intersect(other: ImmutableDenseBits): this;
95
- union(other: ImmutableDenseBits): this;
96
- xor(other: ImmutableDenseBits): this;
97
- contains(other: this): boolean;
102
+ intersect(other: DenseBits32): this;
103
+ union(other: DenseBits32): this;
104
+ xor(other: DenseBits32): this;
105
+ difference(other: DenseBits32): this;
98
106
  next(a: number, set?: boolean): number;
99
- where(set: boolean, from?: number): {
107
+ where(set: boolean, from?: number, to?: number): {
100
108
  [Symbol.iterator](): Generator<number>;
101
109
  };
102
- ranges(): {
103
- [Symbol.iterator](): Generator<number[]>;
110
+ ranges(set?: boolean): {
111
+ [Symbol.iterator](): Generator<[number, number]>;
104
112
  };
105
113
  [Symbol.iterator](): Generator<number>;
106
114
  toSparse(): SparseBits;
115
+ slice(from: number, to?: number): BitSet;
116
+ protected setMask(i: number, m: number): void;
117
+ protected clearMask(i: number, m: number): void;
118
+ set(a: number): void;
119
+ clear(a: number): void;
120
+ setRange(a: number, b: number): this;
121
+ clearRange(a: number, b: number): this;
122
+ selfComplement(): this;
123
+ selfIntersect(other: DenseBits32): this;
124
+ selfUnion(other: DenseBits32): this;
125
+ selfXor(other: DenseBits32): this;
126
+ selfDifference(other: DenseBits32): this;
127
+ clean(): this;
107
128
  }
108
- export declare class DenseBits extends ImmutableDenseBits implements BitSet {
109
- protected setMask(m: bigint): void;
110
- protected clearMask(m: bigint): void;
129
+ type SparseNumberArray = number[] | Record<number, number>;
130
+ type ExtraParams<T> = T extends new (bits: SparseNumberArray, ...args: infer P) => any ? P : never;
131
+ export declare class SparseBits implements BitSet {
132
+ protected bits: number[];
133
+ constructor(bits?: SparseNumberArray);
134
+ protected create(bits?: SparseNumberArray): this;
135
+ static fromEntries<C extends new (bits: SparseNumberArray, ...args: any[]) => any>(this: C, entries: Record<number, number> | [number, number][], ...extra: ExtraParams<C>): InstanceType<C>;
136
+ static fromIndices<C extends new (bits: SparseNumberArray, ...args: any[]) => any>(this: C, ...indices: number[]): InstanceType<C>;
137
+ static fromIndices<C extends new (bits: SparseNumberArray, ...args: any[]) => any>(this: C, indices: number[], ...extra: ExtraParams<C>): InstanceType<C>;
138
+ copy(): this;
139
+ empty(): boolean;
140
+ keys(): number[];
141
+ entries(): [number, number][];
142
+ test(a: number): boolean;
143
+ equals(other: this): boolean;
144
+ contains(other: SparseBits): boolean;
145
+ intersects(other: SparseBits): boolean;
146
+ countSet(): number;
147
+ nthSet(a: number): number;
148
+ complement(): SparseBits2;
149
+ intersect(other: SparseBits): this;
150
+ union(other: SparseBits): this;
151
+ xor(other: SparseBits): this;
152
+ difference(other: this): BitSet;
153
+ next(from: number, set?: boolean): number;
154
+ where(set: boolean, from?: number, to?: number): {
155
+ [Symbol.iterator]: () => Generator<number, void, unknown>;
156
+ };
157
+ ranges(set?: boolean): {
158
+ [Symbol.iterator]: () => Generator<[number, number], any, any>;
159
+ };
160
+ [Symbol.iterator](): Generator<number>;
161
+ clean(): this;
162
+ toDense(): DenseBits;
163
+ slice(from: number, to?: number): BitSet;
164
+ set(a: number): void;
165
+ clear(a: number): void;
166
+ setRange(a: number, b: number): this;
167
+ clearRange(a: number, b: number): this;
168
+ selfIntersect(other: SparseBits): this;
169
+ selfUnion(other: SparseBits): this;
170
+ selfXor(other: SparseBits): this;
171
+ selfDifference(other: this): this;
172
+ }
173
+ export declare class SparseBits2 extends SparseBits {
174
+ protected undef: number;
175
+ constructor(bits?: SparseNumberArray, initial?: boolean);
176
+ protected create(bits?: SparseNumberArray, initial?: boolean): this;
177
+ copy(): this;
178
+ empty(): boolean;
179
+ test(a: number): boolean;
180
+ equals(other: this): boolean;
181
+ contains(other: SparseBits2): boolean;
182
+ intersects(other: SparseBits2): boolean;
183
+ nthSet(a: number): number;
184
+ complement(): this;
185
+ intersect(other: SparseBits2): this;
186
+ union(other: SparseBits2): this;
187
+ xor(other: SparseBits2): this;
188
+ difference(other: SparseBits2): BitSet;
189
+ next(from: number, set?: boolean): number;
190
+ where(set: boolean, from?: number, to?: number): {
191
+ [Symbol.iterator]: () => Generator<number, void, unknown>;
192
+ };
193
+ ranges(set?: boolean): {
194
+ [Symbol.iterator]: () => Generator<[number, number], any, any>;
195
+ };
196
+ [Symbol.iterator](): Generator<number>;
197
+ clean(): this;
198
+ toDense(): DenseBits;
199
+ slice(from: number, to?: number): BitSet;
111
200
  set(a: number): void;
112
201
  clear(a: number): void;
113
202
  setRange(a: number, b: number): this;
114
203
  clearRange(a: number, b: number): this;
115
204
  selfComplement(): this;
116
- selfIntersect(other: DenseBits): this;
117
- selfUnion(other: DenseBits): this;
118
- selfXor(other: DenseBits): this;
205
+ selfIntersect(other: SparseBits2): this;
206
+ selfUnion(other: SparseBits2): this;
207
+ selfXor(other: SparseBits2): this;
208
+ selfDifference(other: this): this;
119
209
  }
210
+ export {};