Struct Lnc 

pub struct Lnc { /* private fields */ }

A point of type Lnc, computed from p, q and t:

x = q.x + t * (p.x - q.x)
y = q.y + t * (p.y - q.y)
z = q.z + t * (p.z - q.z)
where 0 <= t, t <= 1

The constructors compute the coordinates in f64 with a bound on the error of each one, Point::approx and Point::err; Point::exact computes them exactly.

Implementations

impl Lnc

pub fn new(p: [f64; 3], q: [f64; 3], t: f64) -> Result<Self, PointError>

The point of type Lnc with the parameters p, q and t.

Errors

PointError::NonFinite if an input is NaN or infinite, and PointError::ParamOutOfRange if the parameters do not satisfy the conditions of the type.

pub fn new_unchecked(p: [f64; 3], q: [f64; 3], t: f64) -> Self

The point of type Lnc with the parameters p, q and t, without checking them: any f64 is accepted. A coordinate whose approximation or error bound is not finite gets an error of +∞, and Point::exact fails with ExactError::OutOfRange when an input is not finite.

pub fn p(&self) -> &[f64; 3]

The parameter p.

pub fn q(&self) -> &[f64; 3]

The parameter q.

pub fn t(&self) -> f64

The parameter t.

Trait Implementations

impl Clone for Lnc

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Lnc

impl Debug for Lnc

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

Formats the value using the given formatter.

impl From<Lnc> for AnyPoint

fn from(p: Lnc) -> Self

Converts to this type from the input type.

impl PartialEq for Lnc

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

Equality operator ==.

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

Inequality operator !=.

impl Point for Lnc

fn approx(&self) -> &[f64; 3]

Returns an approximation of the coordinates.

fn err(&self) -> &[f64; 3]

Returns, per coordinate, a bound on the error of approx.

fn is_explicit(&self) -> bool

Whether the point is explicit. It may return true only if approx holds the exact coordinates, every err is zero and exact gives Weight::One; returning false is always allowed. A wrong true makes the predicates return wrong signs, unchecked.

fn exact(&self, scratch: &mut Scratch<'_>) -> Result<ExactCoords, ExactError>

Writes the exact coordinates as expansions in scratch: the point is (x / w, y / w, z / w). Every span returned must hold a valid expansion of scratch (see expansion); predicates rely on it without checking it.

impl StructuralPartialEq for Lnc