Struct plexus::primitive::NGon

pub struct NGon<G, const N: usize>(pub [G; N]);

Monomorphic $n$-gon.

NGon represents a polygonal structure as an array. Each array element represents vertex data in order with adjacent elements being connected by an implicit undirected edge. For example, an NGon with three vertices (NGon<_, 3>) would represent a trigon (triangle). Generally these elements are labeled $A$, $B$, $C$, etc. Note that the constant parameter N represents the number of the NGon’s vertices and not the number of its edges (arity).

NGons with less than three vertices are a degenerate case. An NGon with two vertices (NGon<_, 2>) is considered a monogon and is used to represent edges. Such an NGon is not considered a digon, as it represents a single undirected edge rather than two distinct (but collapsed) edges. Note that the polygonal types BoundedPolygon and UnboundedPolygon never represent edges. See the Edge type definition.

NGons with one or zero vertices are unsupported and lack various trait implementations.

See the module documentation for more information.

Tuple Fields

0: [G; N]

Implementations

impl<G, const N: usize> NGon<G, N>

pub fn into_array(self) -> [G; N]

pub fn positions(&self) -> NGon<&Position<G>, N> where
    G: AsPosition, 

impl<'a, G, const N: usize> NGon<&'a G, N>

pub fn cloned(self) -> NGon<G, N> where
    G: Clone, 

impl<G> NGon<G, 2_usize>

pub fn new(a: G, b: G) -> Self

pub fn line(&self) -> Option<Line<Position<G>>> where
    G: AsPosition, 

pub fn is_bisected(&self, other: &Self) -> bool where
    G: AsPosition,
    Position<G>: FiniteDimensional<N = U2>, 

impl<G> NGon<G, 3_usize>

pub fn new(a: G, b: G, c: G) -> Self

pub fn plane(&self) -> Option<Plane<Position<G>>> where
    G: AsPosition,
    Position<G>: EuclideanSpace + FiniteDimensional<N = U3>,
    Vector<Position<G>>: Cross<Output = Vector<Position<G>>>, 

impl<G> NGon<G, 4_usize>

pub fn new(a: G, b: G, c: G, d: G) -> Self

Trait Implementations

impl<G, const N: usize> Adjunct for NGon<G, N>

type Item = G

impl<G, const N: usize> AsMut<[G]> for NGon<G, N>

fn as_mut(&mut self) -> &mut [G]

Converts this type into a mutable reference of the (usually inferred) input type.

impl<G, const N: usize> AsRef<[G]> for NGon<G, N>

fn as_ref(&self) -> &[G]

Converts this type into a shared reference of the (usually inferred) input type.

impl<G: Clone, const N: usize> Clone for NGon<G, N>

fn clone(&self) -> NGon<G, N>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<G, const N: usize> Converged for NGon<G, N> where
    G: Copy, 

fn converged(vertex: G) -> Self

impl<G: Debug, const N: usize> Debug for NGon<G, N>

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

Formats the value using the given formatter.

impl<G, const N: usize> DynamicArity for NGon<G, N> where
    Constant<N>: ToType,
    TypeOf<N>: Cmp<U1, Output = Greater>, 

type Dynamic = usize

fn arity(&self) -> Self::Dynamic

impl<G, const N: usize> Fold for NGon<G, N> where
    Self: Topological, 

fn fold<U, F>(self, seed: U, f: F) -> U where
    F: FnMut(U, Self::Item) -> U, 

fn sum(self) -> Self::Item where
    Self::Item: Add<Self::Item>,
    Self::Item: Zero,
    <Self::Item as Add<Self::Item>>::Output == Self::Item, 

fn product(self) -> Self::Item where
    Self::Item: Mul<Self::Item>,
    Self::Item: One,
    <Self::Item as Mul<Self::Item>>::Output == Self::Item, 

fn min_or_undefined(self) -> Self::Item where
    Self::Item: Bounded,
    Self::Item: IntrinsicOrd, 

fn max_or_undefined(self) -> Self::Item where
    Self::Item: Bounded,
    Self::Item: IntrinsicOrd, 

fn any<F>(self, f: F) -> bool where
    F: FnMut(Self::Item) -> bool, 

fn all<F>(self, f: F) -> bool where
    F: FnMut(Self::Item) -> bool, 

impl<G, const N: usize> From<[G; N]> for NGon<G, N>

fn from(array: [G; N]) -> Self

Converts to this type from the input type.

impl<G> From<NGon<G, 3_usize>> for BoundedPolygon<G>

fn from(trigon: Trigon<G>) -> Self

Converts to this type from the input type.

impl<G> From<NGon<G, 4_usize>> for BoundedPolygon<G>

fn from(tetragon: Tetragon<G>) -> Self

Converts to this type from the input type.

impl<G, const N: usize> From<NGon<G, N>> for UnboundedPolygon<G> where
    Constant<N>: ToType,
    TypeOf<N>: Cmp<U2, Output = Greater>,
    G: Clone, 

fn from(ngon: NGon<G, N>) -> Self

Converts to this type from the input type.

impl<G, const N: usize> FromItems for NGon<G, N>

fn from_items<I>(items: I) -> Option<Self> where
    I: IntoIterator<Item = Self::Item>, 

impl<G, const N: usize> Index<usize> for NGon<G, N>

type Output = G

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<G, const N: usize> IndexMut<usize> for NGon<G, N>

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

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

impl<T> Intersection<NGon<T, 2_usize>> for Edge<T> where
    T: AsPosition,
    Position<T>: FiniteDimensional<N = U2>, 

type Output = EdgeEdge<<T as AsPosition>::Position>

fn intersection(&self, other: &Edge<T>) -> Option<Self::Output>

impl<G, const N: usize> IntoEdges for NGon<G, N> where
    G: Clone,
    Constant<N>: ToType,
    TypeOf<N>: Cmp<U1, Output = Greater>, 

type Output = Vec<NGon<<NGon<G, N> as Topological>::Vertex, 2_usize>, Global>

fn into_edges(self) -> Self::Output

impl<G, const N: usize> IntoItems for NGon<G, N>

type Output = <NGon<G, N> as IntoIterator>::IntoIter

fn into_items(self) -> Self::Output

impl<G, const N: usize> IntoIterator for NGon<G, N>

type Item = G

The type of the elements being iterated over.

type IntoIter = IntoIter<G, N>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<G, H, const N: usize> Map<H> for NGon<G, N>

type Output = NGon<H, N>

fn map<F>(self, f: F) -> Self::Output where
    F: FnMut(Self::Item) -> H, 

impl<G: PartialEq, const N: usize> PartialEq<NGon<G, N>> for NGon<G, N>

fn eq(&self, other: &NGon<G, N>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &NGon<G, N>) -> bool

This method tests for !=.

impl<G, const N: usize> Polygonal for NGon<G, N> where
    Self: Topological,
    Constant<N>: ToType,
    TypeOf<N>: Cmp<U2, Output = Greater>, 

fn is_convex(&self) -> bool where
    Self::Vertex: AsPosition,
    Position<Self::Vertex>: EuclideanSpace + FiniteDimensional<N = U2>, 

Determines if the polygon is convex.

impl<G, const N: usize> StaticArity for NGon<G, N> where
    Constant<N>: ToType,
    TypeOf<N>: Cmp<U1, Output = Greater>, 

type Static = usize

const ARITY: Self::Static = crate::n_arity(N)

impl<G, const N: usize> Topological for NGon<G, N> where
    Constant<N>: ToType,
    TypeOf<N>: Cmp<U1, Output = Greater>, 

type Vertex = G

fn try_from_slice<I>(vertices: I) -> Option<Self> where
    Self::Vertex: Copy,
    I: AsRef<[Self::Vertex]>, 

fn embed_into_e3_xy<P>(ngon: P, z: Scalar<Self::Vertex>) -> Self where
    Self::Vertex: EuclideanSpace + FiniteDimensional<N = U3>,
    P: Map<Self::Vertex, Output = Self> + Topological,
    P::Vertex: EuclideanSpace + FiniteDimensional<N = U2> + Extend<Self::Vertex>,
    Vector<P::Vertex>: VectorSpace<Scalar = Scalar<Self::Vertex>>, 

Embeds an $n$-gon from $\Reals^2$ into $\Reals^3$.

fn embed_into_e3_xy_with<P, F>(
    ngon: P,
    z: Scalar<Position<Self::Vertex>>,
    f: F
) -> Self where
    Self::Vertex: AsPosition,
    Position<Self::Vertex>: EuclideanSpace + FiniteDimensional<N = U3>,
    P: Map<Self::Vertex, Output = Self> + Topological,
    P::Vertex: EuclideanSpace + FiniteDimensional<N = U2> + Extend<Position<Self::Vertex>>,
    Vector<P::Vertex>: VectorSpace<Scalar = Scalar<Position<Self::Vertex>>>,
    F: FnMut(Position<Self::Vertex>) -> Self::Vertex, 

fn embed_into_e3_plane<P>(ngon: P, plane: Plane<Self::Vertex>) -> Self where
    Self::Vertex: EuclideanSpace + FiniteDimensional<N = U3>,
    P: Map<Self::Vertex, Output = Self> + Topological,
    P::Vertex: EuclideanSpace + FiniteDimensional<N = U2> + Extend<Self::Vertex>,
    Vector<P::Vertex>: VectorSpace<Scalar = Scalar<Self::Vertex>>, 

Embeds an $n$-gon from $\Reals^2$ into $\Reals^3$.

fn embed_into_e3_plane_with<P, F>(
    ngon: P,
    _: Plane<Position<Self::Vertex>>,
    f: F
) -> Self where
    Self::Vertex: AsPosition,
    Position<Self::Vertex>: EuclideanSpace + FiniteDimensional<N = U3>,
    P: Map<Self::Vertex, Output = Self> + Topological,
    P::Vertex: EuclideanSpace + FiniteDimensional<N = U2> + Extend<Position<Self::Vertex>>,
    Vector<P::Vertex>: VectorSpace<Scalar = Scalar<Position<Self::Vertex>>>,
    F: FnMut(Position<Self::Vertex>) -> Self::Vertex, 

fn project_into_plane(self, plane: Plane<Position<Self::Vertex>>) -> Self where
    Self::Vertex: AsPositionMut,
    Position<Self::Vertex>: EuclideanSpace + FiniteDimensional,
    <Position<Self::Vertex> as FiniteDimensional>::N: Cmp<U2, Output = Greater>, 

Projects an $n$-gon into a plane.

fn edges(&self) -> Vec<Edge<&Self::Vertex>>

impl<G, const N: usize> TryFromIterator<G> for NGon<G, N>

type Error = ()

fn try_from_iter<I>(vertices: I) -> Result<Self, Self::Error> where
    I: Iterator<Item = G>, 

impl<G, H, const N: usize> ZipMap<H> for NGon<G, N>

type Output = NGon<H, N>

fn zip_map<F>(self, other: Self, f: F) -> Self::Output where
    F: FnMut(Self::Item, Self::Item) -> H, 

fn per_item_sum(self, other: Self) -> Self::Output where
    Self: Adjunct<Item = T>,
    T: Add<T, Output = T>, 

fn per_item_product(self, other: Self) -> Self::Output where
    Self: Adjunct<Item = T>,
    T: Mul<T, Output = T>, 

fn per_item_min_or_undefined(self, other: Self) -> Self::Output where
    Self: Adjunct<Item = T>,
    T: IntrinsicOrd, 

fn per_item_max_or_undefined(self, other: Self) -> Self::Output where
    Self: Adjunct<Item = T>,
    T: IntrinsicOrd, 

impl<G: Copy, const N: usize> Copy for NGon<G, N>

impl<G, const N: usize> Monomorphic for NGon<G, N> where
    Constant<N>: ToType,
    TypeOf<N>: Cmp<U1, Output = Greater>, 

impl<G, const N: usize> StructuralPartialEq for NGon<G, N>