Merge pull request #111 from GeorgeFlerovsky/gf/aiken-interval

Author: MicroProofs

lib/aiken/interval.ak

@@ -394,7 +394,8 @@ pub fn is_entirely_after(self: Interval<Int>, point: Int) -> Bool {
       } else {
         point <= low
       }
-    _ -> False
+    NegativeInfinity -> False
+    PositiveInfinity -> True
   }
 }
 
@@ -434,6 +435,22 @@ test is_entirely_after_9() {
   !is_entirely_after(entirely_before(10), 5)
 }
 
+test is_entirely_after_10() {
+  is_entirely_after(
+    Interval {
+      lower_bound: IntervalBound {
+        bound_type: PositiveInfinity,
+        is_inclusive: True,
+      },
+      upper_bound: IntervalBound {
+        bound_type: PositiveInfinity,
+        is_inclusive: False,
+      },
+    },
+    1,
+  )
+}
+
 /// Check whether the interval is entirely before the point "a"
 ///
 /// ```aiken
@@ -450,7 +467,8 @@ pub fn is_entirely_before(self: Interval<Int>, point: Int) -> Bool {
       } else {
         hi <= point
       }
-    _ -> False
+    PositiveInfinity -> False
+    NegativeInfinity -> True
   }
 }
 
@@ -490,6 +508,158 @@ test is_entirely_before_9() {
   !is_entirely_before(entirely_after(10), 5)
 }
 
+test is_entirely_before_10() {
+  is_entirely_before(
+    Interval {
+      lower_bound: IntervalBound {
+        bound_type: NegativeInfinity,
+        is_inclusive: True,
+      },
+      upper_bound: IntervalBound {
+        bound_type: NegativeInfinity,
+        is_inclusive: False,
+      },
+    },
+    1,
+  )
+}
+
+/// Check whether the interval starts on or after the point.
+///
+/// ```aiken
+/// interval.is_hereafter(interval.after(10), 5) == True
+/// interval.is_hereafter(interval.after(10), 10) == True
+/// interval.is_hereafter(interval.after(10), 15) == False
+/// interval.is_hereafter(interval.between(10, 20), 30) == False
+/// interval.is_hereafter(interval.between(10, 20), 5) == True
+pub fn is_hereafter(self: Interval<Int>, point: Int) -> Bool {
+  when self.lower_bound.bound_type is {
+    Finite(lo) -> point <= lo
+    NegativeInfinity -> False
+    PositiveInfinity -> True
+  }
+}
+
+test is_hereafter_1() {
+  is_hereafter(after(10), 5)
+}
+
+test is_hereafter_2() {
+  is_hereafter(after(10), 10)
+}
+
+test is_hereafter_3() {
+  !is_hereafter(after(10), 15)
+}
+
+test is_hereafter_4() {
+  !is_hereafter(between(10, 20), 30)
+}
+
+test is_hereafter_5() {
+  is_hereafter(between(10, 20), 5)
+}
+
+test is_hereafter_6() {
+  is_hereafter(entirely_after(10), 10)
+}
+
+test is_hereafter_7() {
+  !is_hereafter(before(10), 5)
+}
+
+test is_hereafter_8() {
+  !is_hereafter(before(10), 15)
+}
+
+test is_hereafter_9() {
+  !is_hereafter(entirely_before(10), 5)
+}
+
+test is_hereafter_10() {
+  is_hereafter(
+    Interval {
+      lower_bound: IntervalBound {
+        bound_type: PositiveInfinity,
+        is_inclusive: True,
+      },
+      upper_bound: IntervalBound {
+        bound_type: PositiveInfinity,
+        is_inclusive: False,
+      },
+    },
+    1,
+  )
+}
+
+/// Check whether the interval ends on or before the point.
+///
+/// ```aiken
+/// interval.is_herebefore(interval.before(10), 15) == True
+/// interval.is_herebefore(interval.before(10), 10) == True
+/// interval.is_herebefore(interval.before(10), 5) == False
+/// interval.is_herebefore(interval.between(10, 20), 30) == True
+/// interval.is_herebefore(interval.between(10, 20), 5) == False
+pub fn is_herebefore(self: Interval<Int>, point: Int) -> Bool {
+  when self.upper_bound.bound_type is {
+    Finite(hi) -> hi <= point
+    PositiveInfinity -> False
+    NegativeInfinity -> True
+  }
+}
+
+test is_herebefore_1() {
+  is_herebefore(before(10), 15)
+}
+
+test is_herebefore_2() {
+  is_herebefore(before(10), 10)
+}
+
+test is_herebefore_3() {
+  !is_herebefore(before(10), 5)
+}
+
+test is_herebefore_4() {
+  is_herebefore(between(10, 20), 30)
+}
+
+test is_herebefore_5() {
+  !is_herebefore(between(10, 20), 5)
+}
+
+test is_herebefore_6() {
+  is_herebefore(entirely_before(10), 10)
+}
+
+test is_herebefore_7() {
+  !is_herebefore(after(10), 15)
+}
+
+test is_herebefore_8() {
+  !is_herebefore(after(10), 5)
+}
+
+test is_herebefore_9() {
+  !is_herebefore(entirely_after(10), 5)
+}
+
+test is_herebefore_10() {
+  is_herebefore(
+    Interval {
+      lower_bound: IntervalBound {
+        bound_type: NegativeInfinity,
+        is_inclusive: True,
+      },
+      upper_bound: IntervalBound {
+        bound_type: NegativeInfinity,
+        is_inclusive: False,
+      },
+    },
+    1,
+  )
+}
+
 // ## Combining
 
 /// Computes the smallest interval containing the two given intervals, if any