Enum Ccw

pub enum Ccw {
    OnlineFront = -2,
    Clockwise = -1,
    OnSegment = 0,
    CounterClockwise = 1,
    OnlineBack = 2,
}

Variants

OnlineFront = -2

a–b–c

Clockwise = -1

a–b-vc

OnSegment = 0

a–c–b

CounterClockwise = 1

a–b-^c

OnlineBack = 2

c–a–b

Implementations

impl Ccw

pub fn ccw<T>(a: Complex<T>, b: Complex<T>, c: Complex<T>) -> Self

where T: Ccwable,

Examples found in repository

crates/competitive/src/geometry/line.rs (line 21)

    pub fn ccw(&self, p: Complex<T>) -> Ccw {
        Ccw::ccw(self.p1, self.p2, p)
    }
    pub fn is_parallel(&self, other: &Self) -> bool {
        Approx(self.dir().cross(other.dir())) == Approx(T::zero())
    }
    pub fn is_orthogonal(&self, other: &Self) -> bool {
        Approx(self.dir().dot(other.dir())) == Approx(T::zero())
    }
}
impl<T> Line<T>
where
    T: Ccwable + Float,
{
    pub fn projection(&self, p: Complex<T>) -> Complex<T> {
        let e = self.dir().unit();
        self.p1 + e * (p - self.p1).dot(e)
    }
    pub fn reflection(&self, p: Complex<T>) -> Complex<T> {
        let d = self.projection(p) - p;
        p + d + d
    }
    pub fn distance_point(&self, p: Complex<T>) -> T {
        (p / self.dir().unit()).re
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct LineSegment<T> {
    p1: Complex<T>,
    p2: Complex<T>,
}
impl<T> LineSegment<T> {
    pub fn new(p1: Complex<T>, p2: Complex<T>) -> Self {
        LineSegment { p1, p2 }
    }
}
impl<T> LineSegment<T>
where
    T: Ccwable,
{
    pub fn dir(&self) -> Complex<T> {
        self.p2 - self.p1
    }
    pub fn ccw(&self, p: Complex<T>) -> Ccw {
        Ccw::ccw(self.p1, self.p2, p)
    }

crates/competitive/src/geometry/polygon.rs (line 12)

pub fn convex_hull<T>(mut ps: Vec<Complex<T>>) -> Vec<Complex<T>>
where
    T: PartialOrd + Ccwable,
{
    ps.sort_by(|p1, p2| ((p1.re, p1.im).partial_cmp(&(p2.re, p2.im)).unwrap()));
    let mut qs = Vec::new();
    for &p in ps.iter().chain(ps.iter().rev().skip(1)) {
        while {
            let k = qs.len();
            k > 1 && matches!(Ccw::ccw(qs[k - 2], qs[k - 1], p), Ccw::Clockwise)
        } {
            qs.pop();
        }
        qs.push(p);
    }
    qs.pop();
    qs
}

pub fn ccw_open<T>(a: Complex<T>, b: Complex<T>, c: Complex<T>) -> Self

where T: Ccwable,

Trait Implementations

impl Clone for Ccw

fn clone(&self) -> Ccw

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Ccw

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Hash for Ccw

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Ccw

fn cmp(&self, other: &Ccw) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Ccw

fn eq(&self, other: &Ccw) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Ccw

fn partial_cmp(&self, other: &Ccw) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Copy for Ccw

impl Eq for Ccw

impl StructuralPartialEq for Ccw