use std::ops::Add;
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct Segment {
min: f64,
max: f64,
}
impl Segment {
pub fn new(min: f64, max: f64) -> Segment {
assert!(min <= max, "segment bounds must satisfy min <= max");
assert!(
min < max || min.is_finite(),
"a segment of zero length must sit at a finite frequency"
);
Segment { min, max }
}
pub fn min(&self) -> f64 {
self.min
}
pub fn max(&self) -> f64 {
self.max
}
pub fn contains(&self, omega: f64) -> bool {
self.min <= omega && omega <= self.max
}
pub fn strictly_contains(&self, omega: f64) -> bool {
self.min < omega && omega < self.max
}
pub fn is_bounded(&self) -> bool {
self.min.is_finite() && self.max.is_finite()
}
pub fn is_degenerate(&self) -> bool {
self.min == self.max
}
pub fn length(&self) -> f64 {
self.max - self.min
}
pub fn midpoint(&self) -> f64 {
0.5 * self.min + 0.5 * self.max
}
pub fn mirrored(&self, omega: f64) -> Segment {
Segment {
min: omega - self.max,
max: omega - self.min,
}
}
pub fn shifted(&self, by: f64) -> Segment {
Segment {
min: self.min + by,
max: self.max + by,
}
}
pub fn split_at(&self, omega: f64) -> (Segment, Segment) {
assert!(
self.contains(omega),
"a segment can only be split at a frequency within it"
);
(
Segment {
min: self.min,
max: omega,
},
Segment {
min: omega,
max: self.max,
},
)
}
pub fn hull<I: IntoIterator<Item = Segment>>(segments: I) -> Option<Segment> {
segments.into_iter().reduce(|hull, segment| Segment {
min: f64::min(hull.min, segment.min),
max: f64::max(hull.max, segment.max),
})
}
pub fn intersection(&self, other: Segment) -> Option<Segment> {
let min = f64::max(self.min, other.min);
let max = f64::min(self.max, other.max);
(min <= max).then_some(Segment { min, max })
}
}
impl Add for Segment {
type Output = Segment;
fn add(self, other: Segment) -> Segment {
Segment {
min: self.min + other.min,
max: self.max + other.max,
}
}
}
#[cfg(test)]
mod tests {
use super::Segment;
#[test]
fn new() {
let segment = Segment::new(-1.5, 2.0);
assert_eq!(segment.min(), -1.5);
assert_eq!(segment.max(), 2.0);
let point = Segment::new(2.0, 2.0);
assert_eq!(point.min(), point.max());
}
#[test]
#[should_panic(expected = "min <= max")]
fn new_backwards() {
let _ = Segment::new(2.0, -1.5);
}
#[test]
#[should_panic(expected = "min <= max")]
fn new_nan() {
let _ = Segment::new(f64::NAN, 1.0);
}
#[test]
#[should_panic(expected = "must sit at a finite frequency")]
fn new_degenerate_at_infinity() {
let _ = Segment::new(f64::INFINITY, f64::INFINITY);
}
#[test]
#[should_panic(expected = "must sit at a finite frequency")]
fn new_degenerate_at_negative_infinity() {
let _ = Segment::new(f64::NEG_INFINITY, f64::NEG_INFINITY);
}
#[test]
fn contains() {
let segment = Segment::new(-1.5, 2.0);
for omega in [-1.5, -0.4, 0.0, 1.9, 2.0] {
assert!(segment.contains(omega), "{omega} is within the segment");
}
for omega in [-1.6, 2.1, f64::NEG_INFINITY, f64::INFINITY, f64::NAN] {
assert!(!segment.contains(omega), "{omega} is not");
}
let point = Segment::new(2.0, 2.0);
assert!(point.contains(2.0));
assert!(!point.contains(2.0f64.next_up()));
let unbounded = Segment::new(f64::NEG_INFINITY, f64::INFINITY);
assert!(unbounded.contains(1e300));
assert!(unbounded.contains(f64::INFINITY));
assert!(!unbounded.contains(f64::NAN));
}
#[test]
fn strictly_contains() {
let segment = Segment::new(-1.5, 2.0);
for omega in [-1.4, 0.0, 1.9] {
assert!(segment.strictly_contains(omega), "{omega} is inside");
}
for omega in [-1.5, 2.0, -1.6, 2.1, f64::NAN] {
assert!(!segment.strictly_contains(omega), "{omega} is not");
}
assert!(segment.strictly_contains((-1.5f64).next_up()));
assert!(segment.strictly_contains(2.0f64.next_down()));
assert!(!Segment::new(2.0, 2.0).strictly_contains(2.0));
}
#[test]
fn is_bounded() {
assert!(Segment::new(-1.5, 2.0).is_bounded());
assert!(Segment::new(2.0, 2.0).is_bounded());
assert!(!Segment::new(f64::NEG_INFINITY, 2.0).is_bounded());
assert!(!Segment::new(-1.5, f64::INFINITY).is_bounded());
assert!(!Segment::new(f64::NEG_INFINITY, f64::INFINITY).is_bounded());
}
#[test]
fn is_degenerate() {
assert!(Segment::new(2.0, 2.0).is_degenerate());
assert!(!Segment::new(-1.5, 2.0).is_degenerate());
assert!(!Segment::new(2.0, 2.0f64.next_up()).is_degenerate());
assert!(Segment::new(-0.0, 0.0).is_degenerate());
}
#[test]
fn length() {
assert_eq!(Segment::new(-1.5, 2.0).length(), 3.5);
assert_eq!(Segment::new(2.0, 2.0).length(), 0.0);
assert_eq!(Segment::new(-1.5, f64::INFINITY).length(), f64::INFINITY);
}
#[test]
fn midpoint() {
assert_eq!(Segment::new(-1.5, 2.0).midpoint(), 0.25);
assert_eq!(Segment::new(2.0, 2.0).midpoint(), 2.0);
let huge = Segment::new(-f64::MAX, f64::MAX);
assert_eq!(huge.midpoint(), 0.0);
}
#[test]
fn mirrored() {
let segment = Segment::new(-1.5, 2.0);
assert_eq!(segment.mirrored(0.0), Segment::new(-2.0, 1.5));
assert_eq!(segment.mirrored(1.0), Segment::new(-1.0, 2.5));
assert_eq!(segment.mirrored(0.5).mirrored(0.5), segment);
let mirrored = segment.mirrored(3.0);
assert_eq!(mirrored.length(), segment.length());
assert_eq!(mirrored.midpoint(), 3.0 - segment.midpoint());
}
#[test]
fn split_at() {
let segment = Segment::new(-1.5, 2.0);
let (lower, upper) = segment.split_at(0.5);
assert_eq!(lower, Segment::new(-1.5, 0.5));
assert_eq!(upper, Segment::new(0.5, 2.0));
assert_eq!(lower.length() + upper.length(), segment.length());
let (lower, upper) = segment.split_at(-1.5);
assert!(lower.is_degenerate());
assert_eq!(upper, segment);
}
#[test]
#[should_panic(expected = "within it")]
fn split_at_outside() {
let _ = Segment::new(-1.5, 2.0).split_at(2.5);
}
#[test]
fn add() {
assert_eq!(
Segment::new(-1.5, 2.0) + Segment::new(0.5, 3.0),
Segment::new(-1.0, 5.0)
);
let point = Segment::new(2.0, 2.0);
assert_eq!(point + point, Segment::new(4.0, 4.0));
let segment = Segment::new(-1.5, 2.0);
assert_eq!(segment + point, segment.shifted(2.0));
let (x, y) = (Segment::new(-1.5, 2.0), Segment::new(0.5, 3.0));
assert_eq!((x + y).length(), x.length() + y.length());
let upper = Segment::new(0.0, f64::INFINITY);
assert_eq!(segment + upper, Segment::new(-1.5, f64::INFINITY));
let whole = Segment::new(f64::NEG_INFINITY, f64::INFINITY);
assert_eq!(segment + whole, whole);
}
#[test]
fn hull() {
assert_eq!(Segment::hull([]), None);
let segment = Segment::new(-1.5, 2.0);
assert_eq!(Segment::hull([segment]), Some(segment));
let spread = [
Segment::new(0.0, 1.0),
Segment::new(-1.5, -0.5),
Segment::new(0.25, 0.75),
Segment::new(3.0, 4.0),
];
assert_eq!(Segment::hull(spread), Some(Segment::new(-1.5, 4.0)));
let mixed = [Segment::new(0.0, 1.0), Segment::new(-1.5, f64::INFINITY)];
assert_eq!(
Segment::hull(mixed),
Some(Segment::new(-1.5, f64::INFINITY))
);
}
#[test]
fn intersection() {
let segment = Segment::new(-1.5, 2.0);
assert_eq!(
segment.intersection(Segment::new(0.0, 4.0)),
Some(Segment::new(0.0, 2.0))
);
assert_eq!(
segment.intersection(Segment::new(-0.5, 0.5)),
Some(Segment::new(-0.5, 0.5))
);
assert_eq!(segment.intersection(segment), Some(segment));
let touching = segment.intersection(Segment::new(2.0, 5.0)).unwrap();
assert_eq!(touching, Segment::new(2.0, 2.0));
assert!(touching.is_degenerate());
assert_eq!(segment.intersection(Segment::new(2.5, 5.0)), None);
assert_eq!(Segment::new(2.5, 5.0).intersection(segment), None);
let unbounded = Segment::new(f64::NEG_INFINITY, f64::INFINITY);
assert_eq!(unbounded.intersection(segment), Some(segment));
assert_eq!(segment.intersection(unbounded), Some(segment));
}
}