Struct Line

pub struct Line<T> { /* private fields */ }

Implementations

impl<T> Line<T>

pub fn new(p1: Complex<T>, p2: Complex<T>) -> Self

impl<T> Line<T>

where T: Ccwable,

pub fn dir(&self) -> Complex<T>

Examples found in repository

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

    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
    }

pub fn ccw(&self, p: Complex<T>) -> Ccw

pub fn is_parallel(&self, other: &Self) -> bool

pub fn is_orthogonal(&self, other: &Self) -> bool

impl<T> Line<T>

where T: Ccwable + Float,

pub fn projection(&self, p: Complex<T>) -> Complex<T>

Examples found in repository

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

    pub fn reflection(&self, p: Complex<T>) -> Complex<T> {
        let d = self.projection(p) - p;
        p + d + d
    }

pub fn reflection(&self, p: Complex<T>) -> Complex<T>

pub fn distance_point(&self, p: Complex<T>) -> T

Trait Implementations

impl<T: Clone> Clone for Line<T>

fn clone(&self) -> Line<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Line<T>

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

Formats the value using the given formatter.

impl<T: PartialEq> PartialEq for Line<T>

fn eq(&self, other: &Line<T>) -> 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<T> StructuralPartialEq for Line<T>