Struct Vector 

pub struct Vector<const N: usize, T = Scalar> { /* private fields */ }

Implementations

impl<T: Number, const N: usize> Vector<N, T>

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

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

pub fn neg(&self) -> Self

pub fn prod_scalar(&self, s: T) -> Self

pub fn prod_dot(&self, other: &Self) -> T

pub fn norm_sq(&self) -> T

pub fn norm(&self) -> T

pub fn try_norm(&self) -> GeopResult<T>

|self|, failing where [Scalar::sqrt] refuses the squared length instead of panicking like Self::norm.

pub fn normalize(&self) -> GeopResult<Self>

pub fn orthonormal_complement(&self) -> GeopResult<Vec<Self>>

N - 1 orthonormal vectors perpendicular to self, or an error for a zero self. They are the columns other than the first of the Householder reflection H = I - 2 w wᵀ / (wᵀ w), w = v̂ + σ e_0, which swaps v̂ = self / |self| and σ e_0: H is orthogonal, so its columns are orthonormal, and all but the first are perpendicular to v̂. The sign σ of v̂_0 keeps wᵀ w = 2 (1 + |v̂_0|) >= 2 away from cancellation, so the result is well conditioned for every v̂.

pub fn distance_to_segment(&self, a: &Self, b: &Self) -> T

How far self is from the segment a..b.

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

True if every component could_be_equal other’s.

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

The componentwise [Scalar::union] of self and other.

impl<const N: usize> Vector<N>

pub fn sharpen(&self) -> Self

Componentwise [Scalar::sharpen] — see that method’s own doc comment for when collapsing a value to a single representative point is a safe, free choice (you only ever needed some point within the interval) versus a silent loss of real uncertainty.

impl<T: Number> Vector<3, T>

pub fn across(&self) -> GeopResult<[Self; 2]>

Two unit directions square to the unit vector self and to each other: the first from whichever of x, y, z runs least along it — the first no other definitely runs less along, so that an axis a hair off one of them does not pick between two by noise. A free choice, made the same way wherever a direction across an axis is measured from: a joint’s turns, a frame’s x, a sketch’s parallel.

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

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

Whether self and other could be parallel, in either sense: their cross product could be zero.

pub fn rotated_about(&self, axis: &Self, cos: T, sin: T) -> Self

self turned about the unit vector axis by the angle with cosine cos and sine sin (Rodrigues’ formula).

pub fn homogeneous(&self, w: T) -> Vector4<T>

The point self with weight w, homogeneous: (w x, w y, w z, w). Taken as it is where the weight is exactly one: multiplying by it would only widen it by rounding.

pub fn dehomogenized(&self) -> GeopResult<Vector2<T>>

The point the homogeneous 2-D point (w x, w y, w) stands for, (x, y): each coordinate divided by the weight (not multiplied by its inverse, which rounds twice).

impl<T: Number> Vector<4, T>

pub fn dehomogenized(&self) -> GeopResult<Vector3<T>>

The point the homogeneous 3-D point (w x, w y, w z, w) stands for, (x, y, z): each coordinate divided by the weight (not multiplied by its inverse, which rounds twice).

impl<T: Number> Vector<2, T>

pub fn prod_cross(&self, other: &Self) -> T

The 2-D cross product self.x * other.y - self.y * other.x: the z component of the 3-D one, positive when other lies counter-clockwise of self.

pub fn homogeneous(&self, w: T) -> Vector3<T>

The point self with weight w, homogeneous: (w x, w y, w) — taken as it is where the weight is exactly one (see Vector3::homogeneous).

pub fn perp(&self) -> Self

Rotated 90 degrees counter-clockwise — by neg, which is exact, where subtracting from zero would round.

pub fn rotate(&self, c: T, s: T) -> Self

Rotated counter-clockwise by the angle with cosine c and sine s.

impl<T: Default + Copy, const N: usize> Vector<N, T>

pub fn new() -> Self

pub fn size(&self) -> usize

impl<T: Number, const N: usize> Vector<N, T>

pub fn from_array(data: [T; N]) -> Self

pub fn to_array(&self) -> [T; N]

Its components, as an array.

pub fn to_f64_array(&self) -> [f64; N]

Its components as plain numbers (Scalar::to_f64, the midpoint): for output and drawing, never for construction.

pub fn map<U: Number>(&self, f: impl Fn(T) -> U) -> Vector<N, U>

Every component mapped by f — into dual numbers, say.

pub fn get(&self, idx: &[usize]) -> T

Element access using a multi-index slice; only the first index is used (vectors are 1-D). Panics if idx is empty.

impl<T: Number> Vector<2, T>

pub fn swap_xy(&self) -> Self

impl<T: Number, const N: usize> Vector<N, T>

pub fn zero() -> Self

pub fn axis(k: usize) -> Self

The k-th coordinate axis: one at k, zero elsewhere.

pub fn head<const M: usize>(&self) -> Vector<M, T>

The first M components — e.g. the Cartesian part H of a homogeneous point (H, w), which is not its position H / w.

impl<const N: usize> Vector<N>

pub fn everything() -> Self

Every component set to Scalar::ENTIRE — could_be_equals any other vector of the same dimension componentwise.

pub fn interpolate(a: &Self, b: &Self, alpha: Scalar) -> Self

Componentwise Scalar::interpolate: a at alpha=0, b at alpha=1. See that method’s doc comment for why this beats a manual a*(1-alpha) + b*alpha when components of a/b may coincide.

Trait Implementations

impl<const N: usize, T: Clone> Clone for Vector<N, T>

fn clone(&self) -> Vector<N, T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const N: usize, T: Copy> Copy for Vector<N, T>

impl<const N: usize, T: Debug> Debug for Vector<N, T>

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

Formats the value using the given formatter.

impl<T: Default + Copy, const N: usize> Default for Vector<N, T>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, T: Number, const N: usize> Deserialize<'de> for Vector<N, T>

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl<T: Number, const N: usize> Display for Vector<N, T>

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

Formats the value using the given formatter.

impl<const N: usize> Exact for Vector<N>

Its components, each exactly.

fn write<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

fn read<'de, D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

impl<T, const N: usize> Index<usize> for Vector<N, T>

type Output = T

The returned type after indexing.

fn index(&self, idx: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T: Default + Copy, const N: usize> IndexMut<usize> for Vector<N, T>

fn index_mut(&mut self, idx: usize) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<const N: usize> Iterate for Vector<N>

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

Whether self and other are the same value — the same enclosure, not merely overlapping ones.

impl<const N: usize> Mergeable for Vector<N>

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

fn union(&self, other: &Self) -> Self

impl<const N: usize, T: PartialEq> PartialEq for Vector<N, T>

fn eq(&self, other: &Vector<N, T>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<T: Number, const N: usize> Serialize for Vector<N, T>

A vector serializes as the array of its components’ midpoints — how it travels to a viewer, which draws points, not enclosures — and reads back from an array of plain numbers, each a sharp scalar.

fn serialize<Ser: Serializer>( &self, serializer: Ser, ) -> Result<Ser::Ok, Ser::Error>

Serialize this value into the given Serde serializer.

impl<const N: usize, T: PartialEq> StructuralPartialEq for Vector<N, T>