lib 0.0.2-alpha

LIB: Math and container utilities for Rust. Notice: study purpose, not production ready.
Documentation 
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
114
115
116
117
118
119
120
121
122
123

use std::fmt::{Display, Formatter};
use std::ops::{Bound, Range, RangeBounds, RangeInclusive};
use crate::datas::traits::set::Contains;

pub struct Interval<T>where T:Ord{
    range: ClosedRange<T>,
    flag:IntervalFlag
}
impl<T> Interval<T> where T:Ord{
    pub fn new(left:T,right:T,left_open:bool,right_open:bool)->Interval<T>{
        if(right>left){
            return Interval::new_valid(left,right,left_open,right_open);
        }else{
            return Interval::new_valid(right,left,right_open,left_open);
        }
    }
    fn new_valid(a:T,b:T,left_open:bool,right_open:bool)->Interval<T>{
        Interval{ range:ClosedRange{lf:a,rt:b},flag:IntervalFlag::new(left_open, right_open)}
    }
    pub fn from_closed(range: ClosedRange<T>) -> Self {
        Interval { range, flag: IntervalFlag::new(false, false) }
    }
    pub const fn left(&self)->&T{&self.range.lf}
    pub const fn right(&self)->&T{&self.range.rt}
    pub const fn left_open(&self) -> bool{self.flag.left_open()}
    pub const fn right_open(&self) -> bool{self.flag.right_open()}
    pub fn is_overlap(&self,other:&Interval<T>)->bool{(
        if(self.left_open()||other.right_open()){
            other.right()>self.left()
        }else{
            other.right()>=self.left()
        }&&if(self.right_open()||other.left_open()){
            self.right()>other.left()
        }else{
            self.right()>=other.left()
        }
    )}

    pub fn take_away(self)->(T,T,IntervalFlag){
        (self.range.lf,self.range.rt,self.flag)
    }
}
impl<T:Ord> Contains<T> for Interval<T>{
    fn contains(&self,value:&T)->bool{(
        if(self.left_open()){value>self.left()}else{value>=self.left()}//check left
            &&
            if(self.right_open()){value<self.right() }else{value<=self.right()} //check right
    )}
}
impl<T:Ord> RangeBounds<T> for Interval<T> {
    fn start_bound(&self) -> Bound<&T> {
        if(self.left_open()){
            Bound::Excluded(self.left())
        }else{
            Bound::Included(self.left())
        }
    }
    fn end_bound(&self) -> Bound<&T> {
        if(self.right_open()){
            Bound::Excluded(self.right())
        }else{
            Bound::Included(self.right())
        }
    }
}
impl<T:Display + std::cmp::Ord> Display for Interval<T> {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f,"{}{},{}{}", if(self.left_open()){"("}else{"["}, self.left().to_string(),
        self.right().to_string(),if(self.right_open()){"("}else{"["})
    }
}




pub struct IntervalFlag{
    state:u8
}
impl IntervalFlag{
    pub fn new(left_open:bool, right_open:bool)->IntervalFlag{
        IntervalFlag{state: (left_open as u8)<<1|right_open as u8 }
    }
    pub const fn left_open(&self)->bool{self.state&0b00000010!=0}
    pub const fn right_open(&self)->bool{self.state&0b00000001!=0}
}



#[derive(Debug, Copy, Clone,PartialEq,Eq)]
pub struct ClosedRange<T>
where T: Ord {
    lf: T,
    rt: T,
}
impl<T: Ord> ClosedRange<T> {
    pub fn new(lf: T, rt: T)->ClosedRange<T>{
        ClosedRange{lf, rt }
    }

    pub fn is_overlap(&self, other: &ClosedRange<T>) -> bool {
        other.rt >= self.lf && self.rt >= other.lf
    }
    
    pub fn left(&self)->&T{&self.lf}
    pub fn right(&self)->&T{&self.rt}
    pub fn take_away(self)->(T,T){
        (self.lf,self.rt)
    }
    
    
    pub fn into_range(self)->Range<T>{
        self.lf..self.rt
    }
    pub fn to_range(&self) -> RangeInclusive<T>
    where T: Clone {
        self.lf.clone()..=self.rt.clone()
    }
}
impl<T:Ord> Contains<T> for ClosedRange<T>{
    fn contains(&self, value: &T) -> bool {
        self.lf <= *value && *value <= self.rt
    }
}