rangex/
basic_range.rs

1use std::mem;
2use std::ops::*;
3use num::{Num, Zero, One, FromPrimitive};
4
5pub const DEBUG_PRINT: bool = false;
6pub const ERROR_PRINT: bool = true;
7
8/// StepOps describes trait for 'step' in 'for' loop
9pub trait StepOps:
10    Num
11    + PartialOrd
12    + Copy
13    + std::fmt::Debug
14    + std::fmt::Display
15{
16    /// min value of step
17    fn min() -> Self;
18    /// max value of step
19    fn max() -> Self;
20    /// -1 value of step
21    fn negative_one() -> Self { Self::zero() - Self::one() }
22    /// floor for float, or same for int
23    fn floor(self) -> Self { self }
24    /// abs value
25    fn abs(self) -> Self { if self < Self::zero() { Self::zero() - self } else { self } }
26    // Convert to usize type
27    fn to_usize(self) -> usize;
28}
29
30impl StepOps for isize {
31    fn min() -> Self {
32        Self::MIN
33    }
34    fn max() -> Self {
35        Self::MAX
36    }
37    fn to_usize(self) -> usize {
38        self as usize
39    }
40}
41
42impl StepOps for i128 {
43    fn min() -> Self {
44        Self::MIN
45    }
46    fn max() -> Self {
47        Self::MAX
48    }
49    fn to_usize(self) -> usize {
50        self as usize
51    }
52}
53
54impl StepOps for i64 {
55    fn min() -> Self {
56        Self::MIN
57    }
58    fn max() -> Self {
59        Self::MAX
60    }
61    fn to_usize(self) -> usize {
62        self as usize
63    }
64}
65
66impl StepOps for i32 {
67    fn min() -> Self {
68        Self::MIN
69    }
70    fn max() -> Self {
71        Self::MAX
72    }
73    fn to_usize(self) -> usize {
74        self as usize
75    }
76}
77
78impl StepOps for i16 {
79    fn min() -> Self {
80        Self::MIN
81    }
82    fn max() -> Self {
83        Self::MAX
84    }
85    fn to_usize(self) -> usize {
86        self as usize
87    }
88}
89
90impl StepOps for i8 {
91    fn min() -> Self {
92        Self::MIN
93    }
94    fn max() -> Self {
95        Self::MAX
96    }
97    fn to_usize(self) -> usize {
98        self as usize
99    }
100}
101
102impl StepOps for f32 {
103    fn min() -> Self {
104        Self::MIN
105    }
106    fn max() -> Self {
107        Self::MAX
108    }
109    fn floor(self) -> Self {
110        self.floor()
111    }
112
113    fn to_usize(self) -> usize {
114        self as usize
115    }
116}
117
118impl StepOps for f64 {
119    fn min() -> Self {
120        Self::MIN
121    }
122    fn max() -> Self {
123        Self::MAX
124    }
125    fn floor(self) -> Self {
126        self.floor()
127    }
128
129    fn to_usize(self) -> usize {
130        self as usize
131    }
132}
133
134// #![feature(f128_type)]
135// impl StepOps for f128 {
136//     fn zero() -> Self { 0.0 }
137//     fn one() -> Self { 1.0 }
138//     fn negative_one() -> Self { -1.0 }
139//     fn floor(self) -> Self { self.floor() }
140// }
141
142/// IteratorOps describes trait for 'from'/'to' in 'for' loop
143pub trait IteratorOps:
144    Num
145    + PartialOrd
146    + Copy
147    + std::fmt::Debug
148    + std::fmt::Display
149{
150    /// Step is the type for 'step', signed counterpart of 'from'/'to
151    type Step: StepOps;
152    type ExtendedStep: StepOps;
153    fn min() -> Self;
154    fn max() -> Self;
155    fn to_step(self) -> Self::Step;
156    fn from_step(step: Self::Step) -> Self;
157    fn to_extended_step(self) -> Self::ExtendedStep;
158    fn from_extended_step(extended_step: Self::ExtendedStep) -> Self;
159    fn extend_step(step: Self::Step) -> Self::ExtendedStep;
160    //fn next(&mut self, step: Self::Step) { *self = *self + Self::from_step(step); }
161    fn next(&mut self, step: Self::Step) {
162        *self = Self::from_extended_step(self.to_extended_step() + Self::extend_step(step));
163    }
164}
165
166pub trait SizeCompatible<T> {}
167
168// Implement `SizeCompatible` only for types with the same size.
169impl SizeCompatible<u8> for i8 {}
170impl SizeCompatible<i8> for i8 {}
171impl SizeCompatible<u16> for i16 {}
172impl SizeCompatible<i16> for i16 {}
173impl SizeCompatible<u32> for i32 {}
174impl SizeCompatible<i32> for i32 {}
175impl SizeCompatible<u64> for i64 {}
176impl SizeCompatible<i64> for i64 {}
177impl SizeCompatible<u128> for i128 {}
178impl SizeCompatible<i128> for i128 {}
179
180// Implement the trait for specific types
181impl IteratorOps for u8 {
182    type Step = i8;
183    type ExtendedStep = i16;
184
185    fn min() -> Self {
186        u8::MIN
187    }
188    fn max() -> Self {
189        u8::MAX
190    }
191
192    fn to_step(self) -> i8 {
193        unsafe { mem::transmute(self) }
194    }
195
196    fn from_step(step: i8) -> u8 {
197        unsafe { mem::transmute(step) }
198    }
199
200    fn to_extended_step(self) -> i16 {
201        self as i16
202    }
203    fn from_extended_step(extended_step: Self::ExtendedStep) -> Self {
204        if let Some(result) = Self::from_i16(extended_step) {
205            if DEBUG_PRINT {
206                println!("From extended step {} {}", extended_step, result);
207            }
208            result
209        } else {
210            let self_range_inclusive_number = 1 + Self::MAX as Self::ExtendedStep - Self::MIN as Self::ExtendedStep;
211            let result =
212            if extended_step > Self::MAX as Self::ExtendedStep {
213                (extended_step - self_range_inclusive_number) as Self
214            } else { 
215                (self_range_inclusive_number + extended_step) as Self
216            };            
217            if DEBUG_PRINT || ERROR_PRINT {
218                println!("From extended step overflow {} adjust with {} as {}", extended_step, self_range_inclusive_number, result);
219            }
220            result
221        }
222    }
223    fn extend_step(step: Self::Step) -> Self::ExtendedStep {
224        step as Self::ExtendedStep
225    }
226}
227
228impl IteratorOps for i8 {
229    type Step = i8;
230    type ExtendedStep = i16;
231
232    fn min() -> Self {
233        i8::MIN
234    }
235    fn max() -> Self {
236        i8::MAX
237    }
238
239    fn to_step(self) -> Self::Step {
240        self
241    }
242    fn from_step(step: Self::Step) -> Self {
243        step
244    }
245
246    fn to_extended_step(self) -> Self::ExtendedStep {
247        self as Self::ExtendedStep
248    }
249    fn from_extended_step(extended_step: Self::ExtendedStep) -> Self {
250        if let Some(result) = Self::from_i16(extended_step) {
251            if DEBUG_PRINT {
252                println!("From extended step {} {}", extended_step, result);
253            }
254            result
255        } else {
256            let self_range_inclusive_number = 1 + Self::MAX as Self::ExtendedStep - Self::MIN as Self::ExtendedStep;
257            let result =
258            if extended_step > Self::MAX as Self::ExtendedStep {
259                (extended_step - self_range_inclusive_number) as Self
260            } else { 
261                (self_range_inclusive_number + extended_step) as Self
262            };            
263            if DEBUG_PRINT || ERROR_PRINT {
264                println!("From extended step overflow {} adjust with {} as {}", extended_step, self_range_inclusive_number, result);
265            }
266            result
267        }
268    }
269    fn extend_step(step: Self::Step) -> Self::ExtendedStep {
270        step as Self::ExtendedStep
271    }
272}
273
274impl IteratorOps for u16 {
275    type Step = i16;
276    type ExtendedStep = i32;
277
278    fn min() -> Self {
279        u16::MIN
280    }
281    fn max() -> Self {
282        u16::MAX
283    }
284
285    fn to_step(self) -> Self::Step {
286        unsafe { mem::transmute(self) }
287    }
288    fn from_step(step: Self::Step) -> Self {
289        unsafe { mem::transmute(step) }
290    }
291
292    fn to_extended_step(self) -> Self::ExtendedStep {
293        self as Self::ExtendedStep
294    }
295    fn from_extended_step(extended_step: Self::ExtendedStep) -> Self {
296        if let Some(result) = Self::from_i32(extended_step) {
297            if DEBUG_PRINT {
298                println!("From extended step {} {}", extended_step, result);
299            }
300            result
301        } else {
302            let self_range_inclusive_number = 1 + Self::MAX as Self::ExtendedStep - Self::MIN as Self::ExtendedStep;
303            let result =
304            if extended_step > Self::MAX as Self::ExtendedStep {
305                (extended_step - self_range_inclusive_number) as Self
306            } else { 
307                (self_range_inclusive_number + extended_step) as Self
308            };            
309            if DEBUG_PRINT || ERROR_PRINT {
310                println!("From extended step overflow {} adjust with {} as {}", extended_step, self_range_inclusive_number, result);
311            }
312            result
313        }
314    }
315    fn extend_step(step: Self::Step) -> Self::ExtendedStep {
316        step as Self::ExtendedStep
317    }
318}
319
320impl IteratorOps for i16 {
321    type Step = i16;
322    type ExtendedStep = i32;
323
324    fn min() -> Self {
325        i16::MIN
326    }
327    fn max() -> Self {
328        i16::MAX
329    }
330
331    fn to_step(self) -> Self::Step {
332        self
333    }
334    fn from_step(step: Self::Step) -> Self {
335        step
336    }
337
338    fn to_extended_step(self) -> Self::ExtendedStep {
339        self as Self::ExtendedStep
340    }
341    fn from_extended_step(extended_step: Self::ExtendedStep) -> Self {
342        if let Some(result) = Self::from_i32(extended_step) {
343            if DEBUG_PRINT {
344                println!("From extended step {} {}", extended_step, result);
345            }
346            result
347        } else {
348            let self_range_inclusive_number = 1 + Self::MAX as Self::ExtendedStep - Self::MIN as Self::ExtendedStep;
349            let result =
350            if extended_step > Self::MAX as Self::ExtendedStep {
351                (extended_step - self_range_inclusive_number) as Self
352            } else { 
353                (self_range_inclusive_number + extended_step) as Self
354            };            
355            if DEBUG_PRINT || ERROR_PRINT {
356                println!("From extended step overflow {} adjust with {} as {}", extended_step, self_range_inclusive_number, result);
357            }
358            result
359        }
360    }
361    fn extend_step(step: Self::Step) -> Self::ExtendedStep {
362        step as Self::ExtendedStep
363    }
364}
365
366impl IteratorOps for u32 {
367    type Step = i32;
368    type ExtendedStep = i64;
369
370    fn min() -> Self {
371        u32::MIN
372    }
373    fn max() -> Self {
374        u32::MAX
375    }
376
377    fn to_step(self) -> Self::Step {
378        unsafe { mem::transmute(self) }
379    }
380    fn from_step(step: Self::Step) -> Self {
381        unsafe { mem::transmute(step) }
382    }
383
384    fn to_extended_step(self) -> Self::ExtendedStep {
385        self as Self::ExtendedStep
386    }
387    fn from_extended_step(extended_step: Self::ExtendedStep) -> Self {
388        if let Some(result) = Self::from_i64(extended_step) {
389            if DEBUG_PRINT {
390                println!("From extended step {} {}", extended_step, result);
391            }
392            result
393        } else {
394            let self_range_inclusive_number = 1 + Self::MAX as Self::ExtendedStep - Self::MIN as Self::ExtendedStep;
395            let result =
396            if extended_step > Self::MAX as Self::ExtendedStep {
397                (extended_step - self_range_inclusive_number) as Self
398            } else { 
399                (self_range_inclusive_number + extended_step) as Self
400            };            
401            if DEBUG_PRINT || ERROR_PRINT {
402                println!("From extended step overflow {} adjust with {} as {}", extended_step, self_range_inclusive_number, result);
403            }
404            result
405        }
406    }
407    fn extend_step(step: Self::Step) -> Self::ExtendedStep {
408        step as Self::ExtendedStep
409    }
410}
411
412impl IteratorOps for i32 {
413    type Step = i32;
414    type ExtendedStep = i64;
415
416    fn min() -> Self {
417        i32::MIN
418    }
419    fn max() -> Self {
420        i32::MAX
421    }
422
423    fn to_step(self) -> Self::Step {
424        self
425    }
426    fn from_step(step: Self::Step) -> Self {
427        step
428    }
429
430    fn to_extended_step(self) -> Self::ExtendedStep {
431        self as Self::ExtendedStep
432    }
433    fn from_extended_step(extended_step: Self::ExtendedStep) -> Self {
434        if let Some(result) = Self::from_i64(extended_step) {
435            if DEBUG_PRINT {
436                println!("From extended step {} {}", extended_step, result);
437            }
438            result
439        } else {
440            let self_range_inclusive_number = 1 + Self::MAX as Self::ExtendedStep - Self::MIN as Self::ExtendedStep;
441            let result =
442            if extended_step > Self::MAX as Self::ExtendedStep {
443                (extended_step - self_range_inclusive_number) as Self
444            } else { 
445                (self_range_inclusive_number + extended_step) as Self
446            };            
447            if DEBUG_PRINT || ERROR_PRINT {
448                println!("From extended step overflow {} adjust with {} as {}", extended_step, self_range_inclusive_number, result);
449            }
450            result
451        }
452    }
453    fn extend_step(step: Self::Step) -> Self::ExtendedStep {
454        step as Self::ExtendedStep
455    }
456}
457
458impl IteratorOps for u64 {
459    type Step = i64;
460    type ExtendedStep = i128;
461
462    fn min() -> Self {
463        u64::MIN
464    }
465    fn max() -> Self {
466        u64::MAX
467    }
468
469    fn to_step(self) -> Self::Step {
470        unsafe { mem::transmute(self) }
471    }
472    fn from_step(step: Self::Step) -> Self {
473        unsafe { mem::transmute(step) }
474    }
475
476    fn to_extended_step(self) -> Self::ExtendedStep {
477        self as Self::ExtendedStep
478    }
479    fn from_extended_step(extended_step: Self::ExtendedStep) -> Self {
480        if let Some(result) = Self::from_i128(extended_step) {
481            if DEBUG_PRINT {
482                println!("From extended step {} {}", extended_step, result);
483            }
484            result
485        } else {
486            let self_range_inclusive_number = 1 + Self::MAX as Self::ExtendedStep - Self::MIN as Self::ExtendedStep;
487            let result =
488            if extended_step > Self::MAX as Self::ExtendedStep {
489                (extended_step - self_range_inclusive_number) as Self
490            } else { 
491                (self_range_inclusive_number + extended_step) as Self
492            };            
493            if DEBUG_PRINT || ERROR_PRINT {
494                println!("From extended step overflow {} adjust with {} as {}", extended_step, self_range_inclusive_number, result);
495            }
496            result
497        }
498    }
499    fn extend_step(step: Self::Step) -> Self::ExtendedStep {
500        step as Self::ExtendedStep
501    }
502}
503
504impl IteratorOps for i64 {
505    type Step = i64;
506    type ExtendedStep = i128;
507
508    fn min() -> Self {
509        i64::MIN
510    }
511    fn max() -> Self {
512        i64::MAX
513    }
514
515    fn to_step(self) -> Self::Step {
516        self
517    }
518    fn from_step(step: Self::Step) -> Self {
519        step
520    }
521
522    fn to_extended_step(self) -> Self::ExtendedStep {
523        self as Self::ExtendedStep
524    }
525    fn from_extended_step(extended_step: Self::ExtendedStep) -> Self {
526        if let Some(result) = Self::from_i128(extended_step) {
527            if DEBUG_PRINT {
528                println!("From extended step {} {}", extended_step, result);
529            }
530            result
531        } else {
532            let self_range_inclusive_number = 1 + Self::MAX as Self::ExtendedStep - Self::MIN as Self::ExtendedStep;
533            let result =
534            if extended_step > Self::MAX as Self::ExtendedStep {
535                (extended_step - self_range_inclusive_number) as Self
536            } else { 
537                (self_range_inclusive_number + extended_step) as Self
538            };            
539            if DEBUG_PRINT || ERROR_PRINT {
540                println!("From extended step overflow {} adjust with {} as {}", extended_step, self_range_inclusive_number, result);
541            }
542            result
543        }
544    }
545    fn extend_step(step: Self::Step) -> Self::ExtendedStep {
546        step as Self::ExtendedStep
547    }
548}
549
550impl IteratorOps for u128 {
551    type Step = i128;
552    type ExtendedStep = i128;
553
554    fn min() -> Self {
555        u128::MIN
556    }
557    fn max() -> Self {
558        u128::MAX
559    }
560
561    fn to_step(self) -> Self::Step {
562        unsafe { mem::transmute(self) }
563    }
564    fn from_step(step: Self::Step) -> Self {
565        unsafe { mem::transmute(step) }
566    }
567
568    fn to_extended_step(self) -> Self::ExtendedStep {
569        unsafe { mem::transmute(self) }
570    }
571    fn from_extended_step(step: Self::ExtendedStep) -> Self {
572        unsafe { mem::transmute(step) }
573    }
574    fn extend_step(step: Self::Step) -> Self::ExtendedStep {
575        step as Self::ExtendedStep
576    }
577}
578
579impl IteratorOps for i128 {
580    type Step = i128;
581    type ExtendedStep = i128;
582
583    fn min() -> i128 {
584        i128::MIN
585    }
586    fn max() -> i128 {
587        i128::MAX
588    }
589
590    fn to_step(self) -> Self::Step {
591        self
592    }
593    fn from_step(step: Self::Step) -> Self {
594        step
595    }
596
597    fn to_extended_step(self) -> Self::ExtendedStep {
598        self
599    }
600    fn from_extended_step(extended_step: Self::ExtendedStep) -> Self {
601        extended_step
602    }
603    fn extend_step(step: Self::Step) -> Self::ExtendedStep {
604        step as Self::ExtendedStep
605    }
606}
607
608impl IteratorOps for usize {
609    type Step = isize;
610    type ExtendedStep = isize;
611
612    fn min() -> Self {
613        usize::MIN
614    }
615    fn max() -> Self {
616        usize::MAX
617    }
618
619    fn to_step(self) -> Self::Step {
620        unsafe { mem::transmute(self) }
621    }
622    fn from_step(step: Self::Step) -> Self {
623        unsafe { mem::transmute(step) }
624    }
625
626    fn to_extended_step(self) -> Self::ExtendedStep {
627        unsafe { mem::transmute(self) }
628    }
629    fn from_extended_step(step: Self::ExtendedStep) -> Self {
630        unsafe { mem::transmute(step) }
631    }
632
633    fn extend_step(step: Self::Step) -> Self::ExtendedStep {
634        step as Self::ExtendedStep
635    }
636}
637
638impl IteratorOps for isize {
639    type Step = isize;
640    type ExtendedStep = isize;
641
642    fn min() -> isize {
643        isize::MIN
644    }
645    fn max() -> isize {
646        isize::MAX
647    }
648
649    fn to_step(self) -> Self::Step {
650        self
651    }
652    fn from_step(step: Self::Step) -> Self {
653        step
654    }
655
656    fn to_extended_step(self) -> Self::ExtendedStep {
657        self
658    }
659    fn from_extended_step(extended_step: Self::ExtendedStep) -> Self {
660        extended_step
661    }
662    
663    fn extend_step(step: Self::Step) -> Self::ExtendedStep {
664        step as Self::ExtendedStep
665    }
666}
667
668impl IteratorOps for f32 {
669    type Step = f32;
670    type ExtendedStep = f64;
671
672    fn min() -> f32 {
673        f32::MIN
674    }
675    fn max() -> f32 {
676        f32::MAX
677    }
678
679    fn to_step(self) -> Self::Step {
680        self
681    }
682    fn from_step(step: Self::Step) -> Self {
683        step
684    }
685
686    fn to_extended_step(self) -> Self::ExtendedStep {
687        self as f64
688    }
689    fn from_extended_step(extended_step: Self::ExtendedStep) -> Self {
690        if let Some(result) = f32::from_f64(extended_step) {
691            result
692        } else {
693            0.0
694        }
695    }
696    fn extend_step(step: Self::Step) -> Self::ExtendedStep {
697        step as Self::ExtendedStep
698    }
699
700    fn next(&mut self, step: Self::Step) {
701        *self += step;
702    }
703}
704
705impl IteratorOps for f64 {
706    type Step = f64;
707    type ExtendedStep = f64;
708
709    fn min() -> f64 {
710        f64::MIN
711    }
712    fn max() -> f64 {
713        f64::MAX
714    }
715
716    fn to_step(self) -> Self::Step {
717        self
718    }
719    fn from_step(step: Self::Step) -> Self {
720        step
721    }
722
723    fn to_extended_step(self) -> Self::ExtendedStep {
724        self
725    }
726    fn from_extended_step(step: Self::Step) -> Self {
727        step
728    }
729    fn extend_step(step: Self::Step) -> Self::ExtendedStep {
730        step as Self::ExtendedStep
731    }
732
733    fn next(&mut self, step: Self::Step) {
734        *self += step;
735    }
736}
737
738// impl IteratorOps for f128 {
739//     type Step = f128;
740//     type ExtendedStep = f128;
741
742//     fn to_step(self) -> Self::Step {
743//         self
744//     }
745
746//     fn from_step(step: Self::Step) -> Self {
747//         step
748//     }
749// }
750
751pub struct BasicRange<T>
752where
753    T: IteratorOps,
754{
755    pub start: T,
756    pub end: T,
757    pub step: T::Step,
758
759    pub inclusive_or_not_on_step: bool,
760    pub invalid_range: bool,
761}
762
763impl<T> BasicRange<T>
764where
765    T: IteratorOps
766{
767    pub fn new(start: T, mut end: T, step: T::Step, inclusive: bool) -> Self {
768        if step == T::Step::zero() {
769            panic!("Step can't be 0");
770        }
771
772        let mut on_step = true;
773        let invalid_range = (start < end && step < T::Step::zero()) ||
774            (start > end && step > T::Step::zero());
775
776        if !invalid_range {
777            let range_size: T::ExtendedStep = if step > T::Step::zero() {
778                end.to_extended_step() - start.to_extended_step()
779            } else {
780                start.to_extended_step() - end.to_extended_step()
781            };
782
783            if start != end {
784                if step < T::Step::negative_one() || T::Step::one() < step {
785                    (end, on_step) = Self::calculate_stop_and_steps(start, end, range_size, step);
786                    if DEBUG_PRINT {
787                        println!("end is {}, zero is {}, step is {}, on_step is {}", end, T::Step::zero(), step, on_step);
788                    }
789                } else {
790                    on_step = true;
791                }
792            }
793
794            if inclusive || !on_step {
795                if DEBUG_PRINT {
796                    println!("end is {}, zero is {}, step is {}, on_step is {}", end, T::Step::zero(), step, on_step);
797                }
798                end.next(step);
799                if DEBUG_PRINT {
800                    println!("end is {}, zero is {}, step is {}, on_step is {}", end, T::Step::zero(), step, on_step);
801                }
802            }
803        }
804        if DEBUG_PRINT {
805            println!("invalid_range: {}, end: {}, step: {}, inclusive: {}, on_step: {}", invalid_range, end, step, inclusive, on_step);
806        }
807        BasicRange { start, end, step, inclusive_or_not_on_step: inclusive || !on_step, invalid_range }
808    }
809
810    fn calculate_stop_and_steps(start: T, end: T, range_size: T::ExtendedStep, step: T::Step) -> (T, bool)
811    where
812        T: IteratorOps
813    {
814        if DEBUG_PRINT {
815            println!("start {} end {} range_size {} step {}", start, end, range_size, step);
816        }
817        let range_size_as_extended_step = range_size;
818        let positive_step :T::ExtendedStep = if step < T::Step::zero() { T::ExtendedStep::zero() - T::extend_step(step) } else { T::extend_step(step) };
819        let steps = (range_size_as_extended_step / positive_step).floor();
820        if DEBUG_PRINT {
821            println!("range_size_as_extended_step {} steps {}", range_size_as_extended_step, steps);
822        }
823        let on_step = T::ExtendedStep::zero() == range_size_as_extended_step.rem(positive_step);
824        let new_range_size = steps * positive_step;
825        let new_end : T::ExtendedStep = start.to_extended_step() + if start < end {
826            new_range_size
827        } else {
828            T::ExtendedStep::zero() - new_range_size
829        };
830        if DEBUG_PRINT {
831            println!("new end {}", new_end);
832        }
833        (T::from_extended_step(new_end), on_step)
834    }
835}
836
837pub struct BasicRangeIter<T>
838where
839    T: IteratorOps,
840{
841    pub current: T,
842    pub end: T,
843    pub step: T::Step,
844
845    pub inclusive_or_not_on_step: bool,
846    pub invalid_range: bool,
847}
848
849impl<T> Iterator for BasicRangeIter<T>
850where
851    T: IteratorOps,
852{
853    type Item = T;
854
855    fn next(&mut self) -> Option<Self::Item> {
856        if DEBUG_PRINT {
857            println!("Current {}, step {}, end {}", self.current, self.step, self.end);
858        }
859        if self.invalid_range {
860            None
861        } else {
862            if DEBUG_PRINT {
863                println!("Current {}, step {}, end {} inclusive or not on step {}", self.current, self.step, self.end, self.inclusive_or_not_on_step);
864            }
865            let stop = self.current == self.end;
866
867            if !self.inclusive_or_not_on_step {
868                if stop {
869                    if DEBUG_PRINT {
870                        println!("Stop!");
871                    }
872                    return None
873                }
874            } else {
875                self.inclusive_or_not_on_step = false;
876            }
877
878            // Zig lesson
879            // const result = @addWithOverflow(@as(SignedT, @bitCast(self.curr)), self.step);
880            // self.curr = @as(T, @bitCast(result[0]));
881
882            let result = self.current;
883            self.current = T::from_extended_step(self.current.to_extended_step() + T::extend_step(self.step));
884            if DEBUG_PRINT {
885                println!("Current {}, step {}, end {}, current + step {}/{}", result, self.step, self.end, result.to_extended_step() + T::extend_step(self.step), self.current);
886            }
887            Some(result)
888        }
889    }
890}
891
892impl<T> IntoIterator for BasicRange<T>
893where
894    T: IteratorOps,
895{
896    type Item = T;
897    type IntoIter = BasicRangeIter<T>;
898
899    fn into_iter(self) -> Self::IntoIter {
900        BasicRangeIter {
901            current: self.start,
902            end: self.end,
903            step: self.step,
904
905            inclusive_or_not_on_step: self.inclusive_or_not_on_step,
906            invalid_range: self.invalid_range,
907        }
908    }
909}
910
911#[macro_export]
912macro_rules! range_exclusive {
913    ($start:expr, $end:expr) => {
914        $start..$end
915    };
916    ($typename:ty, $start:expr, $end:expr) => {
917        range_exclusive!($typename, $start, $end, 1)
918    };
919    ($typename:ty, $start:expr, $end:expr, $step:expr) => {
920        BasicRange::<$typename>::new($start, $end, $step, false)
921    };
922}
923
924#[macro_export]
925macro_rules! range_inclusive {
926    ($start:expr, $end:expr) => {
927        $start..=$end
928    };
929    ($typename:ty, $start:expr, $end:expr) => {
930        range_inclusive!($typename, $start, $end, 1)
931    };
932    ($typename:ty, $start:expr, $end:expr, $step:expr) => {
933        BasicRange::<$typename>::new($start, $end, $step, true)
934    };
935}
936
937#[cfg(test)]
938mod main_test {
939    use super::*;
940
941    fn verify_range<T>(expect: Vec<T>, r: BasicRange<T>)
942    where
943        T: IteratorOps,
944    {
945        let mut index = 0;
946        for value in r {
947            assert_eq!(value, expect[index]);
948            //println!("index:{} value:{}", index, value);
949            index += 1;
950        }
951        assert_eq!(index, expect.len());
952    }
953
954    fn verify_std_range<T, R>(expect: Vec<T>, r: R)
955    where
956        T: IteratorOps,
957        R: IntoIterator<Item = T>,
958    {
959        let mut index = 0;
960        for value in r {
961            assert_eq!(value, expect[index]);
962            //println!("index:{} value:{}", index, value);
963            index += 1;
964        }
965        assert_eq!(index, expect.len());
966    }
967
968    #[test]
969    fn basic_1() {
970        let expect = vec![0, 1, 2];
971        verify_range(expect, BasicRange::new(0, 3, 1, false));
972
973        let expect = vec![0, 1, 2];
974        verify_range(expect, BasicRange::new(0, 2, 1, true));
975    }
976
977    #[test]
978    fn basic_1_float() {
979        let expect = vec![0.0, 1.0, 2.0];
980        verify_range(expect, BasicRange::new(0.0, 3.0, 1.0, false));
981
982        let expect = vec![0.0, 1.0, 2.0];
983        verify_range(expect, BasicRange::new(0.0, 2.0, 1.0, true));
984    }
985
986    #[test]
987    fn basic_2() {
988        let expect = vec![0, 1, 2];
989        verify_std_range(expect, range_exclusive!(0, 3));
990
991        let expect = vec![0, 1, 2];
992        verify_std_range(expect, range_inclusive!(0, 2));
993
994        let expect = vec![3, 2, 1];
995        verify_range(expect, BasicRange::new(3, 0, -1, false));
996
997        let expect = vec![3, 2, 1];
998        verify_range(expect, range_exclusive!(i32, 3, 0, -1));
999
1000        let expect = vec![3, 2, 1];
1001        verify_range(expect, range_inclusive!(i32, 3, 1, -1));
1002    }
1003    #[test]
1004    fn basic_2_float() {
1005        let expect = vec![0.0, 1.0, 2.0];
1006        verify_std_range(expect, range_exclusive!(f32, 0.0, 3.0, 1.0));
1007
1008        let expect = vec![0.0, 1.0, 2.0];
1009        verify_std_range(expect, range_inclusive!(f32, 0.0, 2.0, 1.0));
1010
1011        let expect = vec![3.0, 2.0, 1.0];
1012        verify_range(expect, BasicRange::new(3.0, 0.0, -1.0, false));
1013
1014        let expect = vec![3.0, 2.0, 1.0];
1015        verify_range(expect, range_exclusive!(f32, 3.0, 0.0, -1.0));
1016
1017        let expect = vec![3.0, 2.0, 1.0];
1018        verify_range(expect, range_inclusive!(f32, 3.0, 1.0, -1.0));
1019    }
1020    //}
1021
1022    #[test]
1023    fn std_notation() {
1024        let mut s = 0;
1025        for v in 3..0 {
1026            s += v;
1027        }
1028        assert_eq!(s, 0);
1029
1030        let mut s = 0;
1031        let elements = vec![10, 20, 30, 40, 50, 60, 70, 80, 90, 100];
1032        for (index, element) in elements.iter().enumerate() {
1033            //println!("Index: {}, Element: {}", index, element);
1034            assert!(index < elements.len());
1035            assert_eq!(*element, elements[index]);
1036            s += *element;
1037        }
1038        assert_eq!(s, elements.iter().sum());
1039
1040        let mut s = 0.0;
1041        let elements = vec![10.0, 20.0, 30.0, 40.0, 50.0, 60.0, 70.0, 80.0, 90.0, 100.0];
1042        for (index, element) in elements.iter().enumerate() {
1043            //println!("Index: {}, Element: {}", index, element);
1044            assert!(index < elements.len());
1045            assert_eq!(*element, elements[index]);
1046            s += *element;
1047        }
1048        assert_eq!(s, elements.iter().sum());
1049    }
1050
1051    mod success {
1052        use super::*;
1053        //use proptest::prelude::*; // randomly test if used
1054
1055        //proptest ! {
1056        #[test]
1057        //fn void_range_prop(inclusive in 0..=1) {
1058        fn void_range_prop() {
1059            for inclusive in 0..=1 {
1060                let expect_none = vec![];
1061                let expect_once = vec![0];
1062                verify_range(if inclusive > 0 { expect_once } else { expect_none }, BasicRange::new(0, 0, -2, inclusive > 0));
1063
1064                let expect_none = vec![];
1065                let expect_once = vec![0];
1066                verify_range(if inclusive > 0 { expect_once } else { expect_none }, BasicRange::new(0, 0, 2, inclusive > 0));
1067
1068                let expect = vec![];
1069                verify_range(expect, BasicRange::new(3, 0, 1, inclusive > 0));
1070
1071                let expect = vec![];
1072                verify_range(expect, BasicRange::new(0, 1, -1, inclusive > 0));
1073            }
1074        }
1075        #[test]
1076        fn void_range_prop_float() {
1077            for inclusive in 0..=1 {
1078                let expect_none = vec![];
1079                let expect_once = vec![0.0];
1080                verify_range(if inclusive > 0 { expect_once } else { expect_none }, BasicRange::new(0.0, 0.0, -2.0, inclusive > 0));
1081
1082                let expect_none = vec![];
1083                let expect_once = vec![0.0];
1084                verify_range(if inclusive > 0 { expect_once } else { expect_none }, BasicRange::new(0.0, 0.0, 2.0, inclusive > 0));
1085
1086                let expect = vec![];
1087                verify_range(expect, BasicRange::new(3.0, 0.0, 1.0, inclusive > 0));
1088
1089                let expect = vec![];
1090                verify_range(expect, BasicRange::new(0.0, 1.0, -1.0, inclusive > 0));
1091            }
1092        }
1093        #[test]
1094        //fn not_on_step_1_prop(inclusive in 0..=1) {
1095        fn not_on_step_1() {
1096            for inclusive in 0..=1 {
1097                let expect = vec![0, 2, 4];
1098                verify_range(expect, BasicRange::new(0, 5, 2, inclusive > 0));
1099            }
1100        }
1101        //}
1102        #[test]
1103        //fn not_on_step_1_prop(inclusive in 0..=1) {
1104        fn not_on_step_1_float() {
1105            for inclusive in 0..=1 {
1106                let expect = vec![0.0, 2.0, 4.0];
1107                verify_range(expect, BasicRange::new(0.0, 5.0, 2.0, inclusive > 0));
1108            }
1109        }
1110        #[test]
1111        fn not_on_step_2() {
1112            for inclusive in 0..=1 {
1113                let expect = vec![0, 2, 4];
1114                verify_std_range(
1115                    expect,
1116                    if 0 == inclusive {
1117                        range_exclusive!(i32, 0, 5, 2)
1118                    } else {
1119                        range_inclusive!(i32, 0, 5, 2)
1120                    },
1121                );
1122            }
1123        }
1124        #[test]
1125        fn not_on_step_2_float() {
1126            for inclusive in 0..=1 {
1127                let expect = vec![0.0, 2.0, 4.0];
1128                verify_std_range(
1129                    expect,
1130                    if 0 == inclusive {
1131                        range_exclusive!(f32, 0.0, 5.0, 2.0)
1132                    } else {
1133                        range_inclusive!(f32, 0.0, 5.0, 2.0)
1134                    },
1135                );
1136            }
1137        }
1138
1139        #[test]
1140        fn not_on_step_3() {
1141            for inclusive in 0..=1 {
1142                let expect = vec![5, 3];
1143                verify_range(expect, BasicRange::new(5, 2, -2, inclusive > 0));
1144            }
1145            for inclusive in 0..=1 {
1146                let expect = vec![5, 3];
1147                verify_range(expect, BasicRange::<u32>::new(5, 2, -2, inclusive > 0));
1148            }
1149        }
1150
1151        #[test]
1152        fn not_on_step_3_float() {
1153            for inclusive in 0..=1 {
1154                let expect = vec![5.0, 3.0];
1155                verify_range(expect, BasicRange::<f32>::new(5.0, 2.0, -2.0, inclusive > 0));
1156            }
1157            for inclusive in 0..=1 {
1158                let expect = vec![5.0, 3.0];
1159                verify_range(expect, BasicRange::<f64>::new(5.0, 2.0, -2.0, inclusive > 0));
1160            }
1161        }
1162        #[test]
1163        fn not_on_step_4() {
1164            for inclusive in 0..=1 {
1165                let expect = vec![5, 3];
1166                verify_range(
1167                    expect,
1168                    if inclusive > 0 {
1169                        range_inclusive!(i32, 5, 2, -2)
1170                    } else {
1171                        range_exclusive!(i32, 5, 2, -2)
1172                    },
1173                );
1174            }
1175        }
1176
1177        #[test]
1178        fn not_on_step_4_float() {
1179            for inclusive in 0..=1 {
1180                let expect = vec![5.0, 3.0];
1181                verify_range(
1182                    expect,
1183                    if inclusive > 0 {
1184                        range_inclusive!(f32, 5.0, 2.0, -2.0)
1185                    } else {
1186                        range_exclusive!(f32, 5.0, 2.0, -2.0)
1187                    },
1188                );
1189            }
1190        }
1191    }
1192
1193    mod fail {
1194        use super::*;
1195        // This causes zero_step() run multiple times #[test]#[test]
1196
1197        #[test]
1198        #[should_panic]
1199        fn zero_step() {
1200            // Infinity or panic
1201            for _value in BasicRange::new(0, 1, 0, false) {
1202                //println!("{}", _value);
1203            }
1204
1205            // Infinity or panic
1206            for _value in BasicRange::new(0, 1, 0, true) {
1207                //println!("{}", _value);
1208            }
1209
1210            // Infinity or panic
1211            for _value in BasicRange::new(0.0, 1.0, 0.0, false) {
1212                //println!("{}", _value);
1213            }
1214
1215            // Infinity or panic
1216            for _value in BasicRange::new(0.0, 1.0, 0.0, true) {
1217                //println!("{}", _value);
1218            }
1219        }
1220    }
1221}
rangex/basic_range.rs

rangex/
basic_range.rs
