lexical_util/
step.rs

1//! The maximum digits that can be held in a u64 for a given radix without overflow.
2//!
3//! This is useful for 128-bit division and operations, since it can
4//! reduces the number of inefficient, non-native operations.
5//!
6//! # Generation
7//!
8//! See [`etc/step.py`] for the script to generate the divisors and the
9//! constants, and the division algorithm.
10//!
11//! [`etc/step.py`]: https://github.com/Alexhuszagh/rust-lexical/blob/main/lexical-util/etc/step.py
12
13#![cfg(any(feature = "parse", feature = "write"))]
14
15// NOTE:
16//  Fallback radixes use 1 for the value to avoid infinite loops,
17//  but allowing them in `const fn`.
18
19/// Calculate the maximum number of digits that can always be processed
20/// without overflowing for a given type. For example, 19 digits can
21/// always be processed for a decimal string for `u64` without overflowing.
22#[inline(always)]
23pub const fn min_step(radix: u32, bits: usize, is_signed: bool) -> usize {
24    if cfg!(feature = "radix") {
25        match radix {
26            2 => min_step_2(bits, is_signed),
27            3 => min_step_3(bits, is_signed),
28            4 => min_step_4(bits, is_signed),
29            5 => min_step_5(bits, is_signed),
30            6 => min_step_6(bits, is_signed),
31            7 => min_step_7(bits, is_signed),
32            8 => min_step_8(bits, is_signed),
33            9 => min_step_9(bits, is_signed),
34            10 => min_step_10(bits, is_signed),
35            11 => min_step_11(bits, is_signed),
36            12 => min_step_12(bits, is_signed),
37            13 => min_step_13(bits, is_signed),
38            14 => min_step_14(bits, is_signed),
39            15 => min_step_15(bits, is_signed),
40            16 => min_step_16(bits, is_signed),
41            17 => min_step_17(bits, is_signed),
42            18 => min_step_18(bits, is_signed),
43            19 => min_step_19(bits, is_signed),
44            20 => min_step_20(bits, is_signed),
45            21 => min_step_21(bits, is_signed),
46            22 => min_step_22(bits, is_signed),
47            23 => min_step_23(bits, is_signed),
48            24 => min_step_24(bits, is_signed),
49            25 => min_step_25(bits, is_signed),
50            26 => min_step_26(bits, is_signed),
51            27 => min_step_27(bits, is_signed),
52            28 => min_step_28(bits, is_signed),
53            29 => min_step_29(bits, is_signed),
54            30 => min_step_30(bits, is_signed),
55            31 => min_step_31(bits, is_signed),
56            32 => min_step_32(bits, is_signed),
57            33 => min_step_33(bits, is_signed),
58            34 => min_step_34(bits, is_signed),
59            35 => min_step_35(bits, is_signed),
60            36 => min_step_36(bits, is_signed),
61            _ => 1,
62        }
63    } else if cfg!(feature = "power-of-two") {
64        match radix {
65            2 => min_step_2(bits, is_signed),
66            4 => min_step_4(bits, is_signed),
67            8 => min_step_8(bits, is_signed),
68            10 => min_step_10(bits, is_signed),
69            16 => min_step_16(bits, is_signed),
70            32 => min_step_32(bits, is_signed),
71            _ => 1,
72        }
73    } else {
74        min_step_10(bits, is_signed)
75    }
76}
77
78/// Calculate the maximum number of digits that can be processed
79/// without always overflowing for a given type. For example, 20 digits can
80/// be processed for a decimal string for `u64` without overflowing, but
81/// it may overflow.
82#[inline(always)]
83pub const fn max_step(radix: u32, bits: usize, is_signed: bool) -> usize {
84    if cfg!(feature = "radix") {
85        match radix {
86            2 => max_step_2(bits, is_signed),
87            3 => max_step_3(bits, is_signed),
88            4 => max_step_4(bits, is_signed),
89            5 => max_step_5(bits, is_signed),
90            6 => max_step_6(bits, is_signed),
91            7 => max_step_7(bits, is_signed),
92            8 => max_step_8(bits, is_signed),
93            9 => max_step_9(bits, is_signed),
94            10 => max_step_10(bits, is_signed),
95            11 => max_step_11(bits, is_signed),
96            12 => max_step_12(bits, is_signed),
97            13 => max_step_13(bits, is_signed),
98            14 => max_step_14(bits, is_signed),
99            15 => max_step_15(bits, is_signed),
100            16 => max_step_16(bits, is_signed),
101            17 => max_step_17(bits, is_signed),
102            18 => max_step_18(bits, is_signed),
103            19 => max_step_19(bits, is_signed),
104            20 => max_step_20(bits, is_signed),
105            21 => max_step_21(bits, is_signed),
106            22 => max_step_22(bits, is_signed),
107            23 => max_step_23(bits, is_signed),
108            24 => max_step_24(bits, is_signed),
109            25 => max_step_25(bits, is_signed),
110            26 => max_step_26(bits, is_signed),
111            27 => max_step_27(bits, is_signed),
112            28 => max_step_28(bits, is_signed),
113            29 => max_step_29(bits, is_signed),
114            30 => max_step_30(bits, is_signed),
115            31 => max_step_31(bits, is_signed),
116            32 => max_step_32(bits, is_signed),
117            33 => max_step_33(bits, is_signed),
118            34 => max_step_34(bits, is_signed),
119            35 => max_step_35(bits, is_signed),
120            36 => max_step_36(bits, is_signed),
121            _ => 1,
122        }
123    } else if cfg!(feature = "power-of-two") {
124        match radix {
125            2 => max_step_2(bits, is_signed),
126            4 => max_step_4(bits, is_signed),
127            8 => max_step_8(bits, is_signed),
128            10 => max_step_10(bits, is_signed),
129            16 => max_step_16(bits, is_signed),
130            32 => max_step_32(bits, is_signed),
131            _ => 1,
132        }
133    } else {
134        max_step_10(bits, is_signed)
135    }
136}
137
138/// Calculate the number of digits that can be processed without overflowing a u64.
139/// Helper function since this is used for 128-bit division.
140#[inline(always)]
141pub const fn u64_step(radix: u32) -> usize {
142    min_step(radix, 64, false)
143}
144
145// AUTO-GENERATED
146// These functions were auto-generated by `etc/step.py`.
147// Do not edit them unless there is a good reason to.
148// Preferably, edit the source code to generate the constants.
149//
150// NOTE: For the fallthrough value for types (in case of adding short
151// or wider type support in the future), use 1 so it doesn't infinitely
152// recurse. Under normal circumstances, this will never be called.
153
154#[inline]
155const fn max_step_2(bits: usize, is_signed: bool) -> usize {
156    match bits {
157        8 if is_signed => 7,
158        8 if !is_signed => 8,
159        16 if is_signed => 15,
160        16 if !is_signed => 16,
161        32 if is_signed => 31,
162        32 if !is_signed => 32,
163        64 if is_signed => 63,
164        64 if !is_signed => 64,
165        128 if is_signed => 127,
166        128 if !is_signed => 128,
167        _ => 1,
168    }
169}
170
171#[inline]
172const fn min_step_2(bits: usize, is_signed: bool) -> usize {
173    match bits {
174        8 if is_signed => 7,
175        8 if !is_signed => 8,
176        16 if is_signed => 15,
177        16 if !is_signed => 16,
178        32 if is_signed => 31,
179        32 if !is_signed => 32,
180        64 if is_signed => 63,
181        64 if !is_signed => 64,
182        128 if is_signed => 127,
183        128 if !is_signed => 128,
184        _ => 1,
185    }
186}
187
188#[inline]
189const fn max_step_3(bits: usize, is_signed: bool) -> usize {
190    match bits {
191        8 if is_signed => 5,
192        8 if !is_signed => 6,
193        16 if is_signed => 10,
194        16 if !is_signed => 11,
195        32 if is_signed => 20,
196        32 if !is_signed => 21,
197        64 if is_signed => 40,
198        64 if !is_signed => 41,
199        128 if is_signed => 81,
200        128 if !is_signed => 81,
201        _ => 1,
202    }
203}
204
205#[inline]
206const fn min_step_3(bits: usize, is_signed: bool) -> usize {
207    match bits {
208        8 if is_signed => 4,
209        8 if !is_signed => 5,
210        16 if is_signed => 9,
211        16 if !is_signed => 10,
212        32 if is_signed => 19,
213        32 if !is_signed => 20,
214        64 if is_signed => 39,
215        64 if !is_signed => 40,
216        128 if is_signed => 80,
217        128 if !is_signed => 80,
218        _ => 1,
219    }
220}
221
222#[inline]
223const fn max_step_4(bits: usize, is_signed: bool) -> usize {
224    match bits {
225        8 if is_signed => 4,
226        8 if !is_signed => 4,
227        16 if is_signed => 8,
228        16 if !is_signed => 8,
229        32 if is_signed => 16,
230        32 if !is_signed => 16,
231        64 if is_signed => 32,
232        64 if !is_signed => 32,
233        128 if is_signed => 64,
234        128 if !is_signed => 64,
235        _ => 1,
236    }
237}
238
239#[inline]
240const fn min_step_4(bits: usize, is_signed: bool) -> usize {
241    match bits {
242        8 if is_signed => 3,
243        8 if !is_signed => 4,
244        16 if is_signed => 7,
245        16 if !is_signed => 8,
246        32 if is_signed => 15,
247        32 if !is_signed => 16,
248        64 if is_signed => 31,
249        64 if !is_signed => 32,
250        128 if is_signed => 63,
251        128 if !is_signed => 64,
252        _ => 1,
253    }
254}
255
256#[inline]
257const fn max_step_5(bits: usize, is_signed: bool) -> usize {
258    match bits {
259        8 if is_signed => 4,
260        8 if !is_signed => 4,
261        16 if is_signed => 7,
262        16 if !is_signed => 7,
263        32 if is_signed => 14,
264        32 if !is_signed => 14,
265        64 if is_signed => 28,
266        64 if !is_signed => 28,
267        128 if is_signed => 55,
268        128 if !is_signed => 56,
269        _ => 1,
270    }
271}
272
273#[inline]
274const fn min_step_5(bits: usize, is_signed: bool) -> usize {
275    match bits {
276        8 if is_signed => 3,
277        8 if !is_signed => 3,
278        16 if is_signed => 6,
279        16 if !is_signed => 6,
280        32 if is_signed => 13,
281        32 if !is_signed => 13,
282        64 if is_signed => 27,
283        64 if !is_signed => 27,
284        128 if is_signed => 54,
285        128 if !is_signed => 55,
286        _ => 1,
287    }
288}
289
290#[inline]
291const fn max_step_6(bits: usize, is_signed: bool) -> usize {
292    match bits {
293        8 if is_signed => 3,
294        8 if !is_signed => 4,
295        16 if is_signed => 6,
296        16 if !is_signed => 7,
297        32 if is_signed => 12,
298        32 if !is_signed => 13,
299        64 if is_signed => 25,
300        64 if !is_signed => 25,
301        128 if is_signed => 50,
302        128 if !is_signed => 50,
303        _ => 1,
304    }
305}
306
307#[inline]
308const fn min_step_6(bits: usize, is_signed: bool) -> usize {
309    match bits {
310        8 if is_signed => 2,
311        8 if !is_signed => 3,
312        16 if is_signed => 5,
313        16 if !is_signed => 6,
314        32 if is_signed => 11,
315        32 if !is_signed => 12,
316        64 if is_signed => 24,
317        64 if !is_signed => 24,
318        128 if is_signed => 49,
319        128 if !is_signed => 49,
320        _ => 1,
321    }
322}
323
324#[inline]
325const fn max_step_7(bits: usize, is_signed: bool) -> usize {
326    match bits {
327        8 if is_signed => 3,
328        8 if !is_signed => 3,
329        16 if is_signed => 6,
330        16 if !is_signed => 6,
331        32 if is_signed => 12,
332        32 if !is_signed => 12,
333        64 if is_signed => 23,
334        64 if !is_signed => 23,
335        128 if is_signed => 46,
336        128 if !is_signed => 46,
337        _ => 1,
338    }
339}
340
341#[inline]
342const fn min_step_7(bits: usize, is_signed: bool) -> usize {
343    match bits {
344        8 if is_signed => 2,
345        8 if !is_signed => 2,
346        16 if is_signed => 5,
347        16 if !is_signed => 5,
348        32 if is_signed => 11,
349        32 if !is_signed => 11,
350        64 if is_signed => 22,
351        64 if !is_signed => 22,
352        128 if is_signed => 45,
353        128 if !is_signed => 45,
354        _ => 1,
355    }
356}
357
358#[inline]
359const fn max_step_8(bits: usize, is_signed: bool) -> usize {
360    match bits {
361        8 if is_signed => 3,
362        8 if !is_signed => 3,
363        16 if is_signed => 5,
364        16 if !is_signed => 6,
365        32 if is_signed => 11,
366        32 if !is_signed => 11,
367        64 if is_signed => 21,
368        64 if !is_signed => 22,
369        128 if is_signed => 43,
370        128 if !is_signed => 43,
371        _ => 1,
372    }
373}
374
375#[inline]
376const fn min_step_8(bits: usize, is_signed: bool) -> usize {
377    match bits {
378        8 if is_signed => 2,
379        8 if !is_signed => 2,
380        16 if is_signed => 5,
381        16 if !is_signed => 5,
382        32 if is_signed => 10,
383        32 if !is_signed => 10,
384        64 if is_signed => 21,
385        64 if !is_signed => 21,
386        128 if is_signed => 42,
387        128 if !is_signed => 42,
388        _ => 1,
389    }
390}
391
392#[inline]
393const fn max_step_9(bits: usize, is_signed: bool) -> usize {
394    match bits {
395        8 if is_signed => 3,
396        8 if !is_signed => 3,
397        16 if is_signed => 5,
398        16 if !is_signed => 6,
399        32 if is_signed => 10,
400        32 if !is_signed => 11,
401        64 if is_signed => 20,
402        64 if !is_signed => 21,
403        128 if is_signed => 41,
404        128 if !is_signed => 41,
405        _ => 1,
406    }
407}
408
409#[inline]
410const fn min_step_9(bits: usize, is_signed: bool) -> usize {
411    match bits {
412        8 if is_signed => 2,
413        8 if !is_signed => 2,
414        16 if is_signed => 4,
415        16 if !is_signed => 5,
416        32 if is_signed => 9,
417        32 if !is_signed => 10,
418        64 if is_signed => 19,
419        64 if !is_signed => 20,
420        128 if is_signed => 40,
421        128 if !is_signed => 40,
422        _ => 1,
423    }
424}
425
426#[inline]
427const fn max_step_10(bits: usize, is_signed: bool) -> usize {
428    match bits {
429        8 if is_signed => 3,
430        8 if !is_signed => 3,
431        16 if is_signed => 5,
432        16 if !is_signed => 5,
433        32 if is_signed => 10,
434        32 if !is_signed => 10,
435        64 if is_signed => 19,
436        64 if !is_signed => 20,
437        128 if is_signed => 39,
438        128 if !is_signed => 39,
439        _ => 1,
440    }
441}
442
443#[inline]
444const fn min_step_10(bits: usize, is_signed: bool) -> usize {
445    match bits {
446        8 if is_signed => 2,
447        8 if !is_signed => 2,
448        16 if is_signed => 4,
449        16 if !is_signed => 4,
450        32 if is_signed => 9,
451        32 if !is_signed => 9,
452        64 if is_signed => 18,
453        64 if !is_signed => 19,
454        128 if is_signed => 38,
455        128 if !is_signed => 38,
456        _ => 1,
457    }
458}
459
460#[inline]
461const fn max_step_11(bits: usize, is_signed: bool) -> usize {
462    match bits {
463        8 if is_signed => 3,
464        8 if !is_signed => 3,
465        16 if is_signed => 5,
466        16 if !is_signed => 5,
467        32 if is_signed => 9,
468        32 if !is_signed => 10,
469        64 if is_signed => 19,
470        64 if !is_signed => 19,
471        128 if is_signed => 37,
472        128 if !is_signed => 38,
473        _ => 1,
474    }
475}
476
477#[inline]
478const fn min_step_11(bits: usize, is_signed: bool) -> usize {
479    match bits {
480        8 if is_signed => 2,
481        8 if !is_signed => 2,
482        16 if is_signed => 4,
483        16 if !is_signed => 4,
484        32 if is_signed => 8,
485        32 if !is_signed => 9,
486        64 if is_signed => 18,
487        64 if !is_signed => 18,
488        128 if is_signed => 36,
489        128 if !is_signed => 37,
490        _ => 1,
491    }
492}
493
494#[inline]
495const fn max_step_12(bits: usize, is_signed: bool) -> usize {
496    match bits {
497        8 if is_signed => 2,
498        8 if !is_signed => 3,
499        16 if is_signed => 5,
500        16 if !is_signed => 5,
501        32 if is_signed => 9,
502        32 if !is_signed => 9,
503        64 if is_signed => 18,
504        64 if !is_signed => 18,
505        128 if is_signed => 36,
506        128 if !is_signed => 36,
507        _ => 1,
508    }
509}
510
511#[inline]
512const fn min_step_12(bits: usize, is_signed: bool) -> usize {
513    match bits {
514        8 if is_signed => 1,
515        8 if !is_signed => 2,
516        16 if is_signed => 4,
517        16 if !is_signed => 4,
518        32 if is_signed => 8,
519        32 if !is_signed => 8,
520        64 if is_signed => 17,
521        64 if !is_signed => 17,
522        128 if is_signed => 35,
523        128 if !is_signed => 35,
524        _ => 1,
525    }
526}
527
528#[inline]
529const fn max_step_13(bits: usize, is_signed: bool) -> usize {
530    match bits {
531        8 if is_signed => 2,
532        8 if !is_signed => 3,
533        16 if is_signed => 5,
534        16 if !is_signed => 5,
535        32 if is_signed => 9,
536        32 if !is_signed => 9,
537        64 if is_signed => 18,
538        64 if !is_signed => 18,
539        128 if is_signed => 35,
540        128 if !is_signed => 35,
541        _ => 1,
542    }
543}
544
545#[inline]
546const fn min_step_13(bits: usize, is_signed: bool) -> usize {
547    match bits {
548        8 if is_signed => 1,
549        8 if !is_signed => 2,
550        16 if is_signed => 4,
551        16 if !is_signed => 4,
552        32 if is_signed => 8,
553        32 if !is_signed => 8,
554        64 if is_signed => 17,
555        64 if !is_signed => 17,
556        128 if is_signed => 34,
557        128 if !is_signed => 34,
558        _ => 1,
559    }
560}
561
562#[inline]
563const fn max_step_14(bits: usize, is_signed: bool) -> usize {
564    match bits {
565        8 if is_signed => 2,
566        8 if !is_signed => 3,
567        16 if is_signed => 4,
568        16 if !is_signed => 5,
569        32 if is_signed => 9,
570        32 if !is_signed => 9,
571        64 if is_signed => 17,
572        64 if !is_signed => 17,
573        128 if is_signed => 34,
574        128 if !is_signed => 34,
575        _ => 1,
576    }
577}
578
579#[inline]
580const fn min_step_14(bits: usize, is_signed: bool) -> usize {
581    match bits {
582        8 if is_signed => 1,
583        8 if !is_signed => 2,
584        16 if is_signed => 3,
585        16 if !is_signed => 4,
586        32 if is_signed => 8,
587        32 if !is_signed => 8,
588        64 if is_signed => 16,
589        64 if !is_signed => 16,
590        128 if is_signed => 33,
591        128 if !is_signed => 33,
592        _ => 1,
593    }
594}
595
596#[inline]
597const fn max_step_15(bits: usize, is_signed: bool) -> usize {
598    match bits {
599        8 if is_signed => 2,
600        8 if !is_signed => 3,
601        16 if is_signed => 4,
602        16 if !is_signed => 5,
603        32 if is_signed => 8,
604        32 if !is_signed => 9,
605        64 if is_signed => 17,
606        64 if !is_signed => 17,
607        128 if is_signed => 33,
608        128 if !is_signed => 33,
609        _ => 1,
610    }
611}
612
613#[inline]
614const fn min_step_15(bits: usize, is_signed: bool) -> usize {
615    match bits {
616        8 if is_signed => 1,
617        8 if !is_signed => 2,
618        16 if is_signed => 3,
619        16 if !is_signed => 4,
620        32 if is_signed => 7,
621        32 if !is_signed => 8,
622        64 if is_signed => 16,
623        64 if !is_signed => 16,
624        128 if is_signed => 32,
625        128 if !is_signed => 32,
626        _ => 1,
627    }
628}
629
630#[inline]
631const fn max_step_16(bits: usize, is_signed: bool) -> usize {
632    match bits {
633        8 if is_signed => 2,
634        8 if !is_signed => 2,
635        16 if is_signed => 4,
636        16 if !is_signed => 4,
637        32 if is_signed => 8,
638        32 if !is_signed => 8,
639        64 if is_signed => 16,
640        64 if !is_signed => 16,
641        128 if is_signed => 32,
642        128 if !is_signed => 32,
643        _ => 1,
644    }
645}
646
647#[inline]
648const fn min_step_16(bits: usize, is_signed: bool) -> usize {
649    match bits {
650        8 if is_signed => 1,
651        8 if !is_signed => 2,
652        16 if is_signed => 3,
653        16 if !is_signed => 4,
654        32 if is_signed => 7,
655        32 if !is_signed => 8,
656        64 if is_signed => 15,
657        64 if !is_signed => 16,
658        128 if is_signed => 31,
659        128 if !is_signed => 32,
660        _ => 1,
661    }
662}
663
664#[inline]
665const fn max_step_17(bits: usize, is_signed: bool) -> usize {
666    match bits {
667        8 if is_signed => 2,
668        8 if !is_signed => 2,
669        16 if is_signed => 4,
670        16 if !is_signed => 4,
671        32 if is_signed => 8,
672        32 if !is_signed => 8,
673        64 if is_signed => 16,
674        64 if !is_signed => 16,
675        128 if is_signed => 32,
676        128 if !is_signed => 32,
677        _ => 1,
678    }
679}
680
681#[inline]
682const fn min_step_17(bits: usize, is_signed: bool) -> usize {
683    match bits {
684        8 if is_signed => 1,
685        8 if !is_signed => 1,
686        16 if is_signed => 3,
687        16 if !is_signed => 3,
688        32 if is_signed => 7,
689        32 if !is_signed => 7,
690        64 if is_signed => 15,
691        64 if !is_signed => 15,
692        128 if is_signed => 31,
693        128 if !is_signed => 31,
694        _ => 1,
695    }
696}
697
698#[inline]
699const fn max_step_18(bits: usize, is_signed: bool) -> usize {
700    match bits {
701        8 if is_signed => 2,
702        8 if !is_signed => 2,
703        16 if is_signed => 4,
704        16 if !is_signed => 4,
705        32 if is_signed => 8,
706        32 if !is_signed => 8,
707        64 if is_signed => 16,
708        64 if !is_signed => 16,
709        128 if is_signed => 31,
710        128 if !is_signed => 31,
711        _ => 1,
712    }
713}
714
715#[inline]
716const fn min_step_18(bits: usize, is_signed: bool) -> usize {
717    match bits {
718        8 if is_signed => 1,
719        8 if !is_signed => 1,
720        16 if is_signed => 3,
721        16 if !is_signed => 3,
722        32 if is_signed => 7,
723        32 if !is_signed => 7,
724        64 if is_signed => 15,
725        64 if !is_signed => 15,
726        128 if is_signed => 30,
727        128 if !is_signed => 30,
728        _ => 1,
729    }
730}
731
732#[inline]
733const fn max_step_19(bits: usize, is_signed: bool) -> usize {
734    match bits {
735        8 if is_signed => 2,
736        8 if !is_signed => 2,
737        16 if is_signed => 4,
738        16 if !is_signed => 4,
739        32 if is_signed => 8,
740        32 if !is_signed => 8,
741        64 if is_signed => 15,
742        64 if !is_signed => 16,
743        128 if is_signed => 30,
744        128 if !is_signed => 31,
745        _ => 1,
746    }
747}
748
749#[inline]
750const fn min_step_19(bits: usize, is_signed: bool) -> usize {
751    match bits {
752        8 if is_signed => 1,
753        8 if !is_signed => 1,
754        16 if is_signed => 3,
755        16 if !is_signed => 3,
756        32 if is_signed => 7,
757        32 if !is_signed => 7,
758        64 if is_signed => 14,
759        64 if !is_signed => 15,
760        128 if is_signed => 29,
761        128 if !is_signed => 30,
762        _ => 1,
763    }
764}
765
766#[inline]
767const fn max_step_20(bits: usize, is_signed: bool) -> usize {
768    match bits {
769        8 if is_signed => 2,
770        8 if !is_signed => 2,
771        16 if is_signed => 4,
772        16 if !is_signed => 4,
773        32 if is_signed => 8,
774        32 if !is_signed => 8,
775        64 if is_signed => 15,
776        64 if !is_signed => 15,
777        128 if is_signed => 30,
778        128 if !is_signed => 30,
779        _ => 1,
780    }
781}
782
783#[inline]
784const fn min_step_20(bits: usize, is_signed: bool) -> usize {
785    match bits {
786        8 if is_signed => 1,
787        8 if !is_signed => 1,
788        16 if is_signed => 3,
789        16 if !is_signed => 3,
790        32 if is_signed => 7,
791        32 if !is_signed => 7,
792        64 if is_signed => 14,
793        64 if !is_signed => 14,
794        128 if is_signed => 29,
795        128 if !is_signed => 29,
796        _ => 1,
797    }
798}
799
800#[inline]
801const fn max_step_21(bits: usize, is_signed: bool) -> usize {
802    match bits {
803        8 if is_signed => 2,
804        8 if !is_signed => 2,
805        16 if is_signed => 4,
806        16 if !is_signed => 4,
807        32 if is_signed => 8,
808        32 if !is_signed => 8,
809        64 if is_signed => 15,
810        64 if !is_signed => 15,
811        128 if is_signed => 29,
812        128 if !is_signed => 30,
813        _ => 1,
814    }
815}
816
817#[inline]
818const fn min_step_21(bits: usize, is_signed: bool) -> usize {
819    match bits {
820        8 if is_signed => 1,
821        8 if !is_signed => 1,
822        16 if is_signed => 3,
823        16 if !is_signed => 3,
824        32 if is_signed => 7,
825        32 if !is_signed => 7,
826        64 if is_signed => 14,
827        64 if !is_signed => 14,
828        128 if is_signed => 28,
829        128 if !is_signed => 29,
830        _ => 1,
831    }
832}
833
834#[inline]
835const fn max_step_22(bits: usize, is_signed: bool) -> usize {
836    match bits {
837        8 if is_signed => 2,
838        8 if !is_signed => 2,
839        16 if is_signed => 4,
840        16 if !is_signed => 4,
841        32 if is_signed => 7,
842        32 if !is_signed => 8,
843        64 if is_signed => 15,
844        64 if !is_signed => 15,
845        128 if is_signed => 29,
846        128 if !is_signed => 29,
847        _ => 1,
848    }
849}
850
851#[inline]
852const fn min_step_22(bits: usize, is_signed: bool) -> usize {
853    match bits {
854        8 if is_signed => 1,
855        8 if !is_signed => 1,
856        16 if is_signed => 3,
857        16 if !is_signed => 3,
858        32 if is_signed => 6,
859        32 if !is_signed => 7,
860        64 if is_signed => 14,
861        64 if !is_signed => 14,
862        128 if is_signed => 28,
863        128 if !is_signed => 28,
864        _ => 1,
865    }
866}
867
868#[inline]
869const fn max_step_23(bits: usize, is_signed: bool) -> usize {
870    match bits {
871        8 if is_signed => 2,
872        8 if !is_signed => 2,
873        16 if is_signed => 4,
874        16 if !is_signed => 4,
875        32 if is_signed => 7,
876        32 if !is_signed => 8,
877        64 if is_signed => 14,
878        64 if !is_signed => 15,
879        128 if is_signed => 29,
880        128 if !is_signed => 29,
881        _ => 1,
882    }
883}
884
885#[inline]
886const fn min_step_23(bits: usize, is_signed: bool) -> usize {
887    match bits {
888        8 if is_signed => 1,
889        8 if !is_signed => 1,
890        16 if is_signed => 3,
891        16 if !is_signed => 3,
892        32 if is_signed => 6,
893        32 if !is_signed => 7,
894        64 if is_signed => 13,
895        64 if !is_signed => 14,
896        128 if is_signed => 28,
897        128 if !is_signed => 28,
898        _ => 1,
899    }
900}
901
902#[inline]
903const fn max_step_24(bits: usize, is_signed: bool) -> usize {
904    match bits {
905        8 if is_signed => 2,
906        8 if !is_signed => 2,
907        16 if is_signed => 4,
908        16 if !is_signed => 4,
909        32 if is_signed => 7,
910        32 if !is_signed => 7,
911        64 if is_signed => 14,
912        64 if !is_signed => 14,
913        128 if is_signed => 28,
914        128 if !is_signed => 28,
915        _ => 1,
916    }
917}
918
919#[inline]
920const fn min_step_24(bits: usize, is_signed: bool) -> usize {
921    match bits {
922        8 if is_signed => 1,
923        8 if !is_signed => 1,
924        16 if is_signed => 3,
925        16 if !is_signed => 3,
926        32 if is_signed => 6,
927        32 if !is_signed => 6,
928        64 if is_signed => 13,
929        64 if !is_signed => 13,
930        128 if is_signed => 27,
931        128 if !is_signed => 27,
932        _ => 1,
933    }
934}
935
936#[inline]
937const fn max_step_25(bits: usize, is_signed: bool) -> usize {
938    match bits {
939        8 if is_signed => 2,
940        8 if !is_signed => 2,
941        16 if is_signed => 4,
942        16 if !is_signed => 4,
943        32 if is_signed => 7,
944        32 if !is_signed => 7,
945        64 if is_signed => 14,
946        64 if !is_signed => 14,
947        128 if is_signed => 28,
948        128 if !is_signed => 28,
949        _ => 1,
950    }
951}
952
953#[inline]
954const fn min_step_25(bits: usize, is_signed: bool) -> usize {
955    match bits {
956        8 if is_signed => 1,
957        8 if !is_signed => 1,
958        16 if is_signed => 3,
959        16 if !is_signed => 3,
960        32 if is_signed => 6,
961        32 if !is_signed => 6,
962        64 if is_signed => 13,
963        64 if !is_signed => 13,
964        128 if is_signed => 27,
965        128 if !is_signed => 27,
966        _ => 1,
967    }
968}
969
970#[inline]
971const fn max_step_26(bits: usize, is_signed: bool) -> usize {
972    match bits {
973        8 if is_signed => 2,
974        8 if !is_signed => 2,
975        16 if is_signed => 4,
976        16 if !is_signed => 4,
977        32 if is_signed => 7,
978        32 if !is_signed => 7,
979        64 if is_signed => 14,
980        64 if !is_signed => 14,
981        128 if is_signed => 28,
982        128 if !is_signed => 28,
983        _ => 1,
984    }
985}
986
987#[inline]
988const fn min_step_26(bits: usize, is_signed: bool) -> usize {
989    match bits {
990        8 if is_signed => 1,
991        8 if !is_signed => 1,
992        16 if is_signed => 3,
993        16 if !is_signed => 3,
994        32 if is_signed => 6,
995        32 if !is_signed => 6,
996        64 if is_signed => 13,
997        64 if !is_signed => 13,
998        128 if is_signed => 27,
999        128 if !is_signed => 27,
1000        _ => 1,
1001    }
1002}
1003
1004#[inline]
1005const fn max_step_27(bits: usize, is_signed: bool) -> usize {
1006    match bits {
1007        8 if is_signed => 2,
1008        8 if !is_signed => 2,
1009        16 if is_signed => 4,
1010        16 if !is_signed => 4,
1011        32 if is_signed => 7,
1012        32 if !is_signed => 7,
1013        64 if is_signed => 14,
1014        64 if !is_signed => 14,
1015        128 if is_signed => 27,
1016        128 if !is_signed => 27,
1017        _ => 1,
1018    }
1019}
1020
1021#[inline]
1022const fn min_step_27(bits: usize, is_signed: bool) -> usize {
1023    match bits {
1024        8 if is_signed => 1,
1025        8 if !is_signed => 1,
1026        16 if is_signed => 3,
1027        16 if !is_signed => 3,
1028        32 if is_signed => 6,
1029        32 if !is_signed => 6,
1030        64 if is_signed => 13,
1031        64 if !is_signed => 13,
1032        128 if is_signed => 26,
1033        128 if !is_signed => 26,
1034        _ => 1,
1035    }
1036}
1037
1038#[inline]
1039const fn max_step_28(bits: usize, is_signed: bool) -> usize {
1040    match bits {
1041        8 if is_signed => 2,
1042        8 if !is_signed => 2,
1043        16 if is_signed => 4,
1044        16 if !is_signed => 4,
1045        32 if is_signed => 7,
1046        32 if !is_signed => 7,
1047        64 if is_signed => 14,
1048        64 if !is_signed => 14,
1049        128 if is_signed => 27,
1050        128 if !is_signed => 27,
1051        _ => 1,
1052    }
1053}
1054
1055#[inline]
1056const fn min_step_28(bits: usize, is_signed: bool) -> usize {
1057    match bits {
1058        8 if is_signed => 1,
1059        8 if !is_signed => 1,
1060        16 if is_signed => 3,
1061        16 if !is_signed => 3,
1062        32 if is_signed => 6,
1063        32 if !is_signed => 6,
1064        64 if is_signed => 13,
1065        64 if !is_signed => 13,
1066        128 if is_signed => 26,
1067        128 if !is_signed => 26,
1068        _ => 1,
1069    }
1070}
1071
1072#[inline]
1073const fn max_step_29(bits: usize, is_signed: bool) -> usize {
1074    match bits {
1075        8 if is_signed => 2,
1076        8 if !is_signed => 2,
1077        16 if is_signed => 4,
1078        16 if !is_signed => 4,
1079        32 if is_signed => 7,
1080        32 if !is_signed => 7,
1081        64 if is_signed => 13,
1082        64 if !is_signed => 14,
1083        128 if is_signed => 27,
1084        128 if !is_signed => 27,
1085        _ => 1,
1086    }
1087}
1088
1089#[inline]
1090const fn min_step_29(bits: usize, is_signed: bool) -> usize {
1091    match bits {
1092        8 if is_signed => 1,
1093        8 if !is_signed => 1,
1094        16 if is_signed => 3,
1095        16 if !is_signed => 3,
1096        32 if is_signed => 6,
1097        32 if !is_signed => 6,
1098        64 if is_signed => 12,
1099        64 if !is_signed => 13,
1100        128 if is_signed => 26,
1101        128 if !is_signed => 26,
1102        _ => 1,
1103    }
1104}
1105
1106#[inline]
1107const fn max_step_30(bits: usize, is_signed: bool) -> usize {
1108    match bits {
1109        8 if is_signed => 2,
1110        8 if !is_signed => 2,
1111        16 if is_signed => 4,
1112        16 if !is_signed => 4,
1113        32 if is_signed => 7,
1114        32 if !is_signed => 7,
1115        64 if is_signed => 13,
1116        64 if !is_signed => 14,
1117        128 if is_signed => 26,
1118        128 if !is_signed => 27,
1119        _ => 1,
1120    }
1121}
1122
1123#[inline]
1124const fn min_step_30(bits: usize, is_signed: bool) -> usize {
1125    match bits {
1126        8 if is_signed => 1,
1127        8 if !is_signed => 1,
1128        16 if is_signed => 3,
1129        16 if !is_signed => 3,
1130        32 if is_signed => 6,
1131        32 if !is_signed => 6,
1132        64 if is_signed => 12,
1133        64 if !is_signed => 13,
1134        128 if is_signed => 25,
1135        128 if !is_signed => 26,
1136        _ => 1,
1137    }
1138}
1139
1140#[inline]
1141const fn max_step_31(bits: usize, is_signed: bool) -> usize {
1142    match bits {
1143        8 if is_signed => 2,
1144        8 if !is_signed => 2,
1145        16 if is_signed => 4,
1146        16 if !is_signed => 4,
1147        32 if is_signed => 7,
1148        32 if !is_signed => 7,
1149        64 if is_signed => 13,
1150        64 if !is_signed => 13,
1151        128 if is_signed => 26,
1152        128 if !is_signed => 26,
1153        _ => 1,
1154    }
1155}
1156
1157#[inline]
1158const fn min_step_31(bits: usize, is_signed: bool) -> usize {
1159    match bits {
1160        8 if is_signed => 1,
1161        8 if !is_signed => 1,
1162        16 if is_signed => 3,
1163        16 if !is_signed => 3,
1164        32 if is_signed => 6,
1165        32 if !is_signed => 6,
1166        64 if is_signed => 12,
1167        64 if !is_signed => 12,
1168        128 if is_signed => 25,
1169        128 if !is_signed => 25,
1170        _ => 1,
1171    }
1172}
1173
1174#[inline]
1175const fn max_step_32(bits: usize, is_signed: bool) -> usize {
1176    match bits {
1177        8 if is_signed => 2,
1178        8 if !is_signed => 2,
1179        16 if is_signed => 3,
1180        16 if !is_signed => 4,
1181        32 if is_signed => 7,
1182        32 if !is_signed => 7,
1183        64 if is_signed => 13,
1184        64 if !is_signed => 13,
1185        128 if is_signed => 26,
1186        128 if !is_signed => 26,
1187        _ => 1,
1188    }
1189}
1190
1191#[inline]
1192const fn min_step_32(bits: usize, is_signed: bool) -> usize {
1193    match bits {
1194        8 if is_signed => 1,
1195        8 if !is_signed => 1,
1196        16 if is_signed => 3,
1197        16 if !is_signed => 3,
1198        32 if is_signed => 6,
1199        32 if !is_signed => 6,
1200        64 if is_signed => 12,
1201        64 if !is_signed => 12,
1202        128 if is_signed => 25,
1203        128 if !is_signed => 25,
1204        _ => 1,
1205    }
1206}
1207
1208#[inline]
1209const fn max_step_33(bits: usize, is_signed: bool) -> usize {
1210    match bits {
1211        8 if is_signed => 2,
1212        8 if !is_signed => 2,
1213        16 if is_signed => 3,
1214        16 if !is_signed => 4,
1215        32 if is_signed => 7,
1216        32 if !is_signed => 7,
1217        64 if is_signed => 13,
1218        64 if !is_signed => 13,
1219        128 if is_signed => 26,
1220        128 if !is_signed => 26,
1221        _ => 1,
1222    }
1223}
1224
1225#[inline]
1226const fn min_step_33(bits: usize, is_signed: bool) -> usize {
1227    match bits {
1228        8 if is_signed => 1,
1229        8 if !is_signed => 1,
1230        16 if is_signed => 2,
1231        16 if !is_signed => 3,
1232        32 if is_signed => 6,
1233        32 if !is_signed => 6,
1234        64 if is_signed => 12,
1235        64 if !is_signed => 12,
1236        128 if is_signed => 25,
1237        128 if !is_signed => 25,
1238        _ => 1,
1239    }
1240}
1241
1242#[inline]
1243const fn max_step_34(bits: usize, is_signed: bool) -> usize {
1244    match bits {
1245        8 if is_signed => 2,
1246        8 if !is_signed => 2,
1247        16 if is_signed => 3,
1248        16 if !is_signed => 4,
1249        32 if is_signed => 7,
1250        32 if !is_signed => 7,
1251        64 if is_signed => 13,
1252        64 if !is_signed => 13,
1253        128 if is_signed => 25,
1254        128 if !is_signed => 26,
1255        _ => 1,
1256    }
1257}
1258
1259#[inline]
1260const fn min_step_34(bits: usize, is_signed: bool) -> usize {
1261    match bits {
1262        8 if is_signed => 1,
1263        8 if !is_signed => 1,
1264        16 if is_signed => 2,
1265        16 if !is_signed => 3,
1266        32 if is_signed => 6,
1267        32 if !is_signed => 6,
1268        64 if is_signed => 12,
1269        64 if !is_signed => 12,
1270        128 if is_signed => 24,
1271        128 if !is_signed => 25,
1272        _ => 1,
1273    }
1274}
1275
1276#[inline]
1277const fn max_step_35(bits: usize, is_signed: bool) -> usize {
1278    match bits {
1279        8 if is_signed => 2,
1280        8 if !is_signed => 2,
1281        16 if is_signed => 3,
1282        16 if !is_signed => 4,
1283        32 if is_signed => 7,
1284        32 if !is_signed => 7,
1285        64 if is_signed => 13,
1286        64 if !is_signed => 13,
1287        128 if is_signed => 25,
1288        128 if !is_signed => 25,
1289        _ => 1,
1290    }
1291}
1292
1293#[inline]
1294const fn min_step_35(bits: usize, is_signed: bool) -> usize {
1295    match bits {
1296        8 if is_signed => 1,
1297        8 if !is_signed => 1,
1298        16 if is_signed => 2,
1299        16 if !is_signed => 3,
1300        32 if is_signed => 6,
1301        32 if !is_signed => 6,
1302        64 if is_signed => 12,
1303        64 if !is_signed => 12,
1304        128 if is_signed => 24,
1305        128 if !is_signed => 24,
1306        _ => 1,
1307    }
1308}
1309
1310#[inline]
1311const fn max_step_36(bits: usize, is_signed: bool) -> usize {
1312    match bits {
1313        8 if is_signed => 2,
1314        8 if !is_signed => 2,
1315        16 if is_signed => 3,
1316        16 if !is_signed => 4,
1317        32 if is_signed => 6,
1318        32 if !is_signed => 7,
1319        64 if is_signed => 13,
1320        64 if !is_signed => 13,
1321        128 if is_signed => 25,
1322        128 if !is_signed => 25,
1323        _ => 1,
1324    }
1325}
1326
1327#[inline]
1328const fn min_step_36(bits: usize, is_signed: bool) -> usize {
1329    match bits {
1330        8 if is_signed => 1,
1331        8 if !is_signed => 1,
1332        16 if is_signed => 2,
1333        16 if !is_signed => 3,
1334        32 if is_signed => 5,
1335        32 if !is_signed => 6,
1336        64 if is_signed => 12,
1337        64 if !is_signed => 12,
1338        128 if is_signed => 24,
1339        128 if !is_signed => 24,
1340        _ => 1,
1341    }
1342}
lexical_util/step.rs

lexical_util/
step.rs
