Struct Vector 

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

Implementations

impl<S: Scalar, const N: usize> Vector<S, N>

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

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

pub fn neg(&self) -> Self

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.

pub fn interpolate(a: &Self, b: &Self, alpha: S) -> 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.

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

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

pub fn norm_sq(&self) -> S

pub fn norm(&self) -> S

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

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<S: Scalar> Vector<S, 3>

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

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

pub fn new() -> Self

pub fn size(&self) -> usize

impl<S: Scalar, const N: usize> Vector<S, N>

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

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

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

impl<S: Scalar> Vector<S, 2>

pub fn swap_xy(&self) -> Self

impl<S: Scalar, const N: usize> Vector<S, N>

pub fn zero() -> Self

pub fn everything() -> Self

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

Trait Implementations

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

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

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

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

Formats the value using the given formatter.

impl<S: Scalar, const N: usize> Display for Vector<S, N>

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

Formats the value using the given formatter.

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

type Output = S

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

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

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

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

impl<S: Scalar, const N: usize> Mergeable for Vector<S, N>

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

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

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

fn eq(&self, other: &Vector<S, N>) -> 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<S: PartialEq, const N: usize> StructuralPartialEq for Vector<S, N>