odsek 0.1.0

#[cfg(test)]
mod tests {

    use odsek::endpoint_symmetric;
    use odsek::EndpointOC::*;
    use odsek::EndpointSymmetric;
    use odsek::*;

    fn ni<T, V>(
        left: &EndpointOC<T>,
        right: &EndpointOC<T>,
        value: &V,
    ) -> Interval<EndpointOC<T>, V>
    where
        T: Clone,
        V: Clone,
    {
        Interval::new(left.clone(), right.clone(), value.clone())
    }

    fn merge((a, b): &(Option<()>, Option<()>)) -> (bool, bool) {
        (a.is_some(), b.is_some())
    }

    // apply or(|) over two intervals
    fn iter_or_gen(
        ia: (&EndpointOC<i32>, &EndpointOC<i32>),
        ib: (&EndpointOC<i32>, &EndpointOC<i32>),
    ) -> Vec<Interval<EndpointOC<i32>, (bool, bool)>> {
        let ai = Interval::new(ia.0.clone(), ia.1.clone(), ());
        let bi = Interval::new(ib.0.clone(), ib.1.clone(), ());
        let ai = IntervalsSingle::new(ai);
        let bi = IntervalsSingle::new(bi);
        or(ai, bi).map(merge).into_iter().collect()
    }

    #[test]
    fn or_test() {
        for p1 in [Open(1), Closed(1)] {
            for p2 in [Closed(2), Open(2)] {
                for p3 in [Open(3), Closed(3)] {
                    for p4 in [Open(4), Closed(4)] {
                        let tf = (true, false);
                        let ft = (false, true);
                        let tt = (true, true);

                        // () []
                        let i1 = iter_or_gen((&p1, &p2), (&p3, &p4));
                        let v1 = vec![ni(&p1, &p2, &tf), ni(&p3, &p4, &ft)];
                        assert_eq!(i1, v1);

                        let i1 = iter_or_gen((&p3, &p4), (&p1, &p2));
                        let v1 = vec![ni(&p1, &p2, &ft), ni(&p3, &p4, &tf)];
                        assert_eq!(i1, v1);

                        // ([)]
                        let i1 = iter_or_gen((&p1, &p3), (&p2, &p4));
                        let v1 = vec![
                            ni(&p1, &p2.toggle_ref(), &tf),
                            ni(&p2, &p3, &tt),
                            ni(&p3.toggle_ref(), &p4, &ft),
                        ];

                        assert_eq!(i1, v1);

                        let i1 = iter_or_gen((&p2, &p4), (&p1, &p3));
                        let v1 = vec![
                            ni(&p1, &p2.toggle_ref(), &ft),
                            ni(&p2, &p3, &tt),
                            ni(&p3.toggle_ref(), &p4, &tf),
                        ];
                        assert_eq!(i1, v1);

                        // ([])
                        let i1 = iter_or_gen((&p1, &p3), (&p2, &p4));
                        let v1 = vec![
                            ni(&p1, &p2.toggle_ref(), &tf),
                            ni(&p2, &p3, &tt),
                            ni(&p3.toggle_ref(), &p4, &ft),
                        ];
                        assert_eq!(i1, v1);

                        let i1 = iter_or_gen((&p2, &p4), (&p1, &p3));
                        let v1 = vec![
                            ni(&p1, &p2.toggle_ref(), &ft),
                            ni(&p2, &p3, &tt),
                            ni(&p3.toggle_ref(), &p4, &tf),
                        ];
                        assert_eq!(i1, v1);
                    }
                }
            }
        }
    }

    #[test]
    fn or_nearly_equal() {
        let c1 = Closed(1);
        let o1 = Open(1);
        let c2 = Closed(2);
        let o2 = Open(2);

        let tf = (true, false);
        let ft = (false, true);
        let tt = (true, true);

        // ([])
        let i1 = iter_or_gen((&c1, &c2), (&o1, &o2));
        let v1 = vec![ni(&c1, &c1, &tf), ni(&o1, &o2, &tt), ni(&c2, &c2, &tf)];
        assert_eq!(i1, v1);

        let i1 = iter_or_gen((&o1, &o2), (&c1, &c2));
        let v1 = vec![ni(&c1, &c1, &ft), ni(&o1, &o2, &tt), ni(&c2, &c2, &ft)];
        assert_eq!(i1, v1);

        // ([)]
        let i1 = iter_or_gen((&c1, &o2), (&o1, &c2));
        let v1 = vec![ni(&c1, &c1, &tf), ni(&o1, &o2, &tt), ni(&c2, &c2, &ft)];
        assert_eq!(i1, v1);

        let i1 = iter_or_gen((&o1, &c2), (&c1, &o2));
        let v1 = vec![ni(&c1, &c1, &ft), ni(&o1, &o2, &tt), ni(&c2, &c2, &tf)];
        assert_eq!(i1, v1);

        // ()[]
        let i1 = iter_or_gen((&c1, &c1), (&o1, &o2));
        let v1 = vec![ni(&c1, &c1, &tf), ni(&o1, &o2, &ft)];
        assert_eq!(i1, v1);

        let i1 = iter_or_gen((&o1, &o2), (&c1, &c1));
        let v1 = vec![ni(&c1, &c1, &ft), ni(&o1, &o2, &tf)];
        assert_eq!(i1, v1);

        // ()[]
        let i1 = iter_or_gen((&c2, &c2), (&o1, &o2));
        let v1 = vec![ni(&o1, &o2, &ft), ni(&c2, &c2, &tf)];
        assert_eq!(i1, v1);

        let i1 = iter_or_gen((&o1, &o2), (&c2, &c2));
        let v1 = vec![ni(&o1, &o2, &tf), ni(&c2, &c2, &ft)];
        assert_eq!(i1, v1);
    }

    // apply and(&) over two intervals
    fn iter_and_gen(
        ia: (&EndpointOC<i32>, &EndpointOC<i32>),
        ib: (&EndpointOC<i32>, &EndpointOC<i32>),
    ) -> Vec<Interval<EndpointOC<i32>, ((), ())>> {
        let ai = Interval::new(ia.0.clone(), ia.1.clone(), ());
        let bi = Interval::new(ib.0.clone(), ib.1.clone(), ());
        let ai = IntervalsSingle::new(ai);
        let bi = IntervalsSingle::new(bi);
        and(ai, bi).into_iter().collect()
    }

    #[test]
    fn and_test() {
        for p1 in [Open(1), Closed(1)] {
            for p2 in [Closed(2), Open(2)] {
                for p3 in [Open(3), Closed(3)] {
                    for p4 in [Open(4), Closed(4)] {
                        let tt = ((), ());

                        // () []
                        let i1 = iter_and_gen((&p1, &p2), (&p3, &p4));
                        let v1 = vec![];
                        assert_eq!(i1, v1);

                        let i1 = iter_and_gen((&p3, &p4), (&p1, &p2));
                        let v1 = vec![];
                        assert_eq!(i1, v1);

                        // ([)]
                        let i1 = iter_and_gen((&p1, &p3), (&p2, &p4));
                        let v1 = vec![ni(&p2, &p3, &tt)];
                        assert_eq!(i1, v1);

                        let i1 = iter_and_gen((&p2, &p4), (&p1, &p3));
                        let v1 = vec![ni(&p2, &p3, &tt)];
                        assert_eq!(i1, v1);

                        // ([])
                        let i1 = iter_and_gen((&p1, &p3), (&p2, &p4));
                        let v1 = vec![ni(&p2, &p3, &tt)];
                        assert_eq!(i1, v1);

                        let i1 = iter_and_gen((&p2, &p4), (&p1, &p3));
                        let v1 = vec![ni(&p2, &p3, &tt)];
                        assert_eq!(i1, v1);
                    }
                }
            }
        }
    }

    #[test]
    fn and_nearly_equal() {
        let c1 = Closed(1);
        let o1 = Open(1);
        let c2 = Closed(2);
        let o2 = Open(2);

        let tt = ((), ());

        // ([])
        let i1 = iter_and_gen((&c1, &c2), (&o1, &o2));
        let v1 = vec![ni(&o1, &o2, &tt)];
        assert_eq!(i1, v1);

        let i1 = iter_and_gen((&o1, &o2), (&c1, &c2));
        let v1 = vec![ni(&o1, &o2, &tt)];
        assert_eq!(i1, v1);

        // ([)]
        let i1 = iter_and_gen((&c1, &o2), (&o1, &c2));
        let v1 = vec![ni(&o1, &o2, &tt)];
        assert_eq!(i1, v1);

        let i1 = iter_and_gen((&o1, &c2), (&c1, &o2));
        let v1 = vec![ni(&o1, &o2, &tt)];
        assert_eq!(i1, v1);

        // ()[]
        let i1 = iter_and_gen((&c1, &c1), (&o1, &o2));
        let v1 = vec![];
        assert_eq!(i1, v1);

        let i1 = iter_and_gen((&o1, &o2), (&c1, &c1));
        let v1 = vec![];
        assert_eq!(i1, v1);

        // ()[]
        let i1 = iter_and_gen((&c2, &c2), (&o1, &o2));
        let v1 = vec![];
        assert_eq!(i1, v1);

        let i1 = iter_and_gen((&o1, &o2), (&c2, &c2));
        let v1 = vec![];
        assert_eq!(i1, v1);

        // points
        let i1 = iter_and_gen((&o1, &c2), (&c2, &c2));
        let v1 = vec![ni(&c2, &c2, &tt)];
        assert_eq!(i1, v1);
    }

    #[test]
    fn test_and_vec() {
        fn cc<T>(a: i32, b: i32, v: T) -> Interval<EndpointOC<i32>, T> {
            Interval::new(EndpointOC::Closed(a), EndpointOC::Closed(b), v)
        }
        // create open interval (a,b) conating value s
        fn oo<T>(a: i32, b: i32, v: T) -> Interval<EndpointOC<i32>, T> {
            Interval::new(EndpointOC::Open(a), EndpointOC::Open(b), v)
        }
        // create half-open interval [a,b) conating value s
        fn co<T>(a: i32, b: i32, v: T) -> Interval<EndpointOC<i32>, T> {
            Interval::new(EndpointOC::Closed(a), EndpointOC::Open(b), v)
        }
        // create half-open interval (a,b] conating value s
        fn oc<T>(a: i32, b: i32, v: T) -> Interval<EndpointOC<i32>, T> {
            Interval::new(EndpointOC::Open(a), EndpointOC::Closed(b), v)
        }

        // create 2 vectors of intervals
        let va = vec![cc(1, 3, "A1"), co(4, 7, "A2"), oc(9, 11, "A3")];
        let vb = vec![oo(2, 6, "B1"), cc(6, 12, "B2"), cc(12, 14, "B3")];

        // convert vectors into intervals
        let ia = IntervalsFromArray::new(va.as_slice());
        let ib = IntervalsFromArray::new(vb.as_slice());

        let ic = and(ia, ib);

        //let ich = ic.head(None);

        // convert into vector of intervals
        let vc = ic.into_iter().collect::<Vec<_>>();

        // check result
        assert_eq!(
            vc,
            vec!(
                oc(2, 3, ("A1", "B1")),
                co(4, 6, ("A2", "B1")),
                co(6, 7, ("A2", "B2")),
                oc(9, 11, ("A3", "B2")),
            )
        );
    }

    // --- EndpointSymmetric tests ---

    fn ep(v: i32) -> EndpointSymmetric<i32> {
        endpoint_symmetric(v)
    }

    fn ni_s<T, V>(
        left: &EndpointSymmetric<T>,
        right: &EndpointSymmetric<T>,
        value: &V,
    ) -> Interval<EndpointSymmetric<T>, V>
    where
        T: Clone,
        V: Clone,
    {
        Interval::new(left.clone(), right.clone(), value.clone())
    }

    fn iter_or_gen_s(
        ia: (&EndpointSymmetric<i32>, &EndpointSymmetric<i32>),
        ib: (&EndpointSymmetric<i32>, &EndpointSymmetric<i32>),
    ) -> Vec<Interval<EndpointSymmetric<i32>, (bool, bool)>> {
        let ai = Interval::new(ia.0.clone(), ia.1.clone(), ());
        let bi = Interval::new(ib.0.clone(), ib.1.clone(), ());
        let ai = IntervalsSingle::new(ai);
        let bi = IntervalsSingle::new(bi);
        or(ai, bi).map(merge).into_iter().collect()
    }

    fn iter_and_gen_s(
        ia: (&EndpointSymmetric<i32>, &EndpointSymmetric<i32>),
        ib: (&EndpointSymmetric<i32>, &EndpointSymmetric<i32>),
    ) -> Vec<Interval<EndpointSymmetric<i32>, ((), ())>> {
        let ai = Interval::new(ia.0.clone(), ia.1.clone(), ());
        let bi = Interval::new(ib.0.clone(), ib.1.clone(), ());
        let ai = IntervalsSingle::new(ai);
        let bi = IntervalsSingle::new(bi);
        and(ai, bi).into_iter().collect()
    }

    #[test]
    fn or_test_symmetric() {
        let p1 = ep(1);
        let p2 = ep(2);
        let p3 = ep(3);
        let p4 = ep(4);

        let tf = (true, false);
        let ft = (false, true);
        let tt = (true, true);

        // [1,2) [3,4) — non-overlapping
        let i1 = iter_or_gen_s((&p1, &p2), (&p3, &p4));
        let v1 = vec![ni_s(&p1, &p2, &tf), ni_s(&p3, &p4, &ft)];
        assert_eq!(i1, v1);

        let i1 = iter_or_gen_s((&p3, &p4), (&p1, &p2));
        let v1 = vec![ni_s(&p1, &p2, &ft), ni_s(&p3, &p4, &tf)];
        assert_eq!(i1, v1);

        // [1,3) [2,4) — overlapping
        // toggle is identity for EndpointSymmetric, so toggle_ref returns same value
        let i1 = iter_or_gen_s((&p1, &p3), (&p2, &p4));
        let v1 = vec![
            ni_s(&p1, &p2, &tf),
            ni_s(&p2, &p3, &tt),
            ni_s(&p3, &p4, &ft),
        ];
        assert_eq!(i1, v1);

        let i1 = iter_or_gen_s((&p2, &p4), (&p1, &p3));
        let v1 = vec![
            ni_s(&p1, &p2, &ft),
            ni_s(&p2, &p3, &tt),
            ni_s(&p3, &p4, &tf),
        ];
        assert_eq!(i1, v1);
    }

    #[test]
    fn and_test_symmetric() {
        let p1 = ep(1);
        let p2 = ep(2);
        let p3 = ep(3);
        let p4 = ep(4);

        let tt = ((), ());

        // [1,2) [3,4) — non-overlapping
        let i1 = iter_and_gen_s((&p1, &p2), (&p3, &p4));
        assert_eq!(i1, vec![]);

        let i1 = iter_and_gen_s((&p3, &p4), (&p1, &p2));
        assert_eq!(i1, vec![]);

        // [1,3) [2,4) — overlapping → [2,3)
        let i1 = iter_and_gen_s((&p1, &p3), (&p2, &p4));
        let v1 = vec![ni_s(&p2, &p3, &tt)];
        assert_eq!(i1, v1);

        let i1 = iter_and_gen_s((&p2, &p4), (&p1, &p3));
        let v1 = vec![ni_s(&p2, &p3, &tt)];
        assert_eq!(i1, v1);
    }

    #[test]
    fn and_nearly_equal_symmetric() {
        let p1 = ep(1);
        let p2 = ep(2);

        let tt = ((), ());

        // [1,2) & [1,2) = [1,2)
        let i1 = iter_and_gen_s((&p1, &p2), (&p1, &p2));
        let v1 = vec![ni_s(&p1, &p2, &tt)];
        assert_eq!(i1, v1);

        // [1,2) & [2,3) = empty (right is open at 2, left is closed at 2 — but symmetric so no overlap at point)
        let p3 = ep(3);
        let i1 = iter_and_gen_s((&p1, &p2), (&p2, &p3));
        assert_eq!(i1, vec![]);
    }

    #[test]
    fn test_and_vec_symmetric() {
        fn s<T>(a: i32, b: i32, v: T) -> Interval<EndpointSymmetric<i32>, T> {
            Interval::new(ep(a), ep(b), v)
        }

        // all intervals are [a, b) style
        let va = vec![s(1, 3, "A1"), s(4, 7, "A2"), s(9, 11, "A3")];
        let vb = vec![s(2, 6, "B1"), s(6, 12, "B2"), s(12, 14, "B3")];

        let ia = IntervalsFromArray::new(va.as_slice());
        let ib = IntervalsFromArray::new(vb.as_slice());

        let ic = and(ia, ib);
        let vc = ic.into_iter().collect::<Vec<_>>();

        // [1,3) & [2,6) = [2,3)
        // [4,7) & [2,6) = [4,6)
        // [4,7) & [6,12) = [6,7)
        // [9,11) & [6,12) = [9,11)
        assert_eq!(
            vc,
            vec!(
                s(2, 3, ("A1", "B1")),
                s(4, 6, ("A2", "B1")),
                s(6, 7, ("A2", "B2")),
                s(9, 11, ("A3", "B2")),
            )
        );
    }

    #[test]
    fn test_and_vec_ref() {
        fn cc<T>(a: i32, b: i32, v: T) -> Interval<EndpointOC<i32>, T> {
            Interval::new(EndpointOC::Closed(a), EndpointOC::Closed(b), v)
        }
        // create open interval (a,b) conating value s
        fn oo<T>(a: i32, b: i32, v: T) -> Interval<EndpointOC<i32>, T> {
            Interval::new(EndpointOC::Open(a), EndpointOC::Open(b), v)
        }
        // create half-open interval [a,b) conating value s
        fn co<T>(a: i32, b: i32, v: T) -> Interval<EndpointOC<i32>, T> {
            Interval::new(EndpointOC::Closed(a), EndpointOC::Open(b), v)
        }
        // create half-open interval (a,b] conating value s
        fn oc<T>(a: i32, b: i32, v: T) -> Interval<EndpointOC<i32>, T> {
            Interval::new(EndpointOC::Open(a), EndpointOC::Closed(b), v)
        }

        // create 2 vectors of intervals
        let va = vec![cc(1, 3, "A1"), co(4, 7, "A2"), oc(9, 11, "A3")];
        let vb = vec![oo(2, 6, "B1"), cc(6, 12, "B2"), cc(12, 14, "B3")];

        // convert vectors into intervals
        let ia = IntervalsFromArray::new(va.as_slice());
        let ib = IntervalsFromArray::new(vb.as_slice());

        // compose two intervals applying union operation
        let ic = and(ia, ib);
        // convert into vector of intervals
        let vc = ic.into_iter().collect::<Vec<_>>();

        // check result
        assert_eq!(
            vc,
            vec!(
                oc(2, 3, ("A1", "B1")),
                co(4, 6, ("A2", "B1")),
                co(6, 7, ("A2", "B2")),
                oc(9, 11, ("A3", "B2")),
            )
        );
    }

    #[test]
    fn endpoint_map_intersects_with_operator() {
        // [1, 4) scaled x5 -> [5, 20); intersect with [5, 10) -> [5, 10)
        let a = Interval::new(EndpointOC::Closed(1), EndpointOC::Open(4), "A");
        let b = Interval::new(EndpointOC::Closed(5), EndpointOC::Open(10), "B");

        let ia = IntervalsSingle::new(a).map_endpoints(|x: i32| x * 5, |x: i32| x / 5);
        let ib = IntervalsSingle::new(b);

        let result: Vec<_> = and(ia, ib).into_iter().collect();
        assert_eq!(
            result,
            vec![Interval::new(
                EndpointOC::Closed(5),
                EndpointOC::Open(10),
                ("A", "B"),
            )]
        );
    }
}