Struct plexus::primitive::NGon

pub struct NGon<A>(pub A)
 where
    A: Array;

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<[T; 3]>) would represent a triangle (trigon). Generally these elements are labeled $A$, $B$, $C$, etc.

NGons with less than three vertices are a degenerate case. An NGon with two vertices (NGon<[T; 2]>) is considered a monogon despite common definitions specifying a single vertex. Such an NGon is not considered a digon, as it represents a single undirected edge rather than two distinct (but collapsed) edges. Single-vertex NGons are unsupported. See the Edge type definition.

Implementations

impl<A> NGon<A> where
    A: Array, 

pub fn into_array(self) -> A

impl<T> NGon<[T; 2]>

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

impl<T> NGon<[T; 3]>

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

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

impl<T> NGon<[T; 4]>

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

Trait Implementations

impl<A> Adjunct for NGon<A> where
    A: Array, 

type Item = A::Item

impl<A> AsMut<[<A as Array>::Item]> for NGon<A> where
    A: Array, 

fn as_mut(&mut self) -> &mut [A::Item]

Performs the conversion.

impl<A> AsRef<[<A as Array>::Item]> for NGon<A> where
    A: Array, 

fn as_ref(&self) -> &[A::Item]

Performs the conversion.

impl<A: Clone> Clone for NGon<A> where
    A: Array, 

fn clone(&self) -> NGon<A>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Converged for NGon<[T; 2]> where
    T: Copy, 

fn converged(item: T) -> Self

impl<T> Converged for NGon<[T; 3]> where
    T: Copy, 

fn converged(item: T) -> Self

impl<T> Converged for NGon<[T; 12]> where
    T: Copy, 

fn converged(item: T) -> Self

impl<T> Converged for NGon<[T; 4]> where
    T: Copy, 

fn converged(item: T) -> Self

impl<T> Converged for NGon<[T; 5]> where
    T: Copy, 

fn converged(item: T) -> Self

impl<T> Converged for NGon<[T; 6]> where
    T: Copy, 

fn converged(item: T) -> Self

impl<T> Converged for NGon<[T; 7]> where
    T: Copy, 

fn converged(item: T) -> Self

impl<T> Converged for NGon<[T; 8]> where
    T: Copy, 

fn converged(item: T) -> Self

impl<T> Converged for NGon<[T; 9]> where
    T: Copy, 

fn converged(item: T) -> Self

impl<T> Converged for NGon<[T; 10]> where
    T: Copy, 

fn converged(item: T) -> Self

impl<T> Converged for NGon<[T; 11]> where
    T: Copy, 

fn converged(item: T) -> Self

impl<A: Copy> Copy for NGon<A> where
    A: Array, 

impl<A: Debug> Debug for NGon<A> where
    A: Array, 

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

Formats the value using the given formatter.

impl<T> DynamicArity for NGon<[T; 2]>

type Dynamic = usize

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

impl<T> DynamicArity for NGon<[T; 3]>

type Dynamic = usize

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

impl<T> DynamicArity for NGon<[T; 12]>

type Dynamic = usize

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

impl<T> DynamicArity for NGon<[T; 4]>

type Dynamic = usize

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

impl<T> DynamicArity for NGon<[T; 5]>

type Dynamic = usize

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

impl<T> DynamicArity for NGon<[T; 6]>

type Dynamic = usize

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

impl<T> DynamicArity for NGon<[T; 7]>

type Dynamic = usize

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

impl<T> DynamicArity for NGon<[T; 8]>

type Dynamic = usize

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

impl<T> DynamicArity for NGon<[T; 9]>

type Dynamic = usize

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

impl<T> DynamicArity for NGon<[T; 10]>

type Dynamic = usize

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

impl<T> DynamicArity for NGon<[T; 11]>

type Dynamic = usize

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

impl<A> Fold for NGon<A> where
    Self: Topological + IntoItems,
    A: Array, 

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<A> From<A> for NGon<A> where
    A: Array, 

fn from(array: A) -> Self

Performs the conversion.

impl<T> From<NGon<[T; 10]>> for UnboundedPolygon<T> where
    T: Clone, 

fn from(ngon: NGon<[T; 10]>) -> Self

Performs the conversion.

impl<T> From<NGon<[T; 11]>> for UnboundedPolygon<T> where
    T: Clone, 

fn from(ngon: NGon<[T; 11]>) -> Self

Performs the conversion.

impl<T> From<NGon<[T; 12]>> for UnboundedPolygon<T> where
    T: Clone, 

fn from(ngon: NGon<[T; 12]>) -> Self

Performs the conversion.

impl<T> From<NGon<[T; 3]>> for BoundedPolygon<T>

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

Performs the conversion.

impl<T> From<NGon<[T; 3]>> for UnboundedPolygon<T> where
    T: Clone, 

fn from(ngon: NGon<[T; 3]>) -> Self

Performs the conversion.

impl<T> From<NGon<[T; 4]>> for BoundedPolygon<T>

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

Performs the conversion.

impl<T> From<NGon<[T; 4]>> for UnboundedPolygon<T> where
    T: Clone, 

fn from(ngon: NGon<[T; 4]>) -> Self

Performs the conversion.

impl<T> From<NGon<[T; 5]>> for UnboundedPolygon<T> where
    T: Clone, 

fn from(ngon: NGon<[T; 5]>) -> Self

Performs the conversion.

impl<T> From<NGon<[T; 6]>> for UnboundedPolygon<T> where
    T: Clone, 

fn from(ngon: NGon<[T; 6]>) -> Self

Performs the conversion.

impl<T> From<NGon<[T; 7]>> for UnboundedPolygon<T> where
    T: Clone, 

fn from(ngon: NGon<[T; 7]>) -> Self

Performs the conversion.

impl<T> From<NGon<[T; 8]>> for UnboundedPolygon<T> where
    T: Clone, 

fn from(ngon: NGon<[T; 8]>) -> Self

Performs the conversion.

impl<T> From<NGon<[T; 9]>> for UnboundedPolygon<T> where
    T: Clone, 

fn from(ngon: NGon<[T; 9]>) -> Self

Performs the conversion.

impl<A> FromItems for NGon<A> where
    A: Array, 

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

impl<A> Index<usize> for NGon<A> where
    A: Array + AsRef<[<A as Array>::Item]>, 

type Output = A::Item

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<A> IndexMut<usize> for NGon<A> where
    A: Array + AsRef<[<A as Array>::Item]> + AsMut<[<A as Array>::Item]>, 

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

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

impl<A> IntoItems for NGon<A> where
    A: Array, 

type Output = ArrayVec<A>

fn into_items(self) -> Self::Output

impl<A> IntoIterator for NGon<A> where
    A: Array, 

type Item = <A as Array>::Item

The type of the elements being iterated over.

type IntoIter = <Self::Output as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T, U> Map<U> for NGon<[T; 2]>

type Output = NGon<[U; 2]>

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

impl<T, U> Map<U> for NGon<[T; 3]>

type Output = NGon<[U; 3]>

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

impl<T, U> Map<U> for NGon<[T; 12]>

type Output = NGon<[U; 12]>

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

impl<T, U> Map<U> for NGon<[T; 4]>

type Output = NGon<[U; 4]>

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

impl<T, U> Map<U> for NGon<[T; 5]>

type Output = NGon<[U; 5]>

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

impl<T, U> Map<U> for NGon<[T; 6]>

type Output = NGon<[U; 6]>

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

impl<T, U> Map<U> for NGon<[T; 7]>

type Output = NGon<[U; 7]>

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

impl<T, U> Map<U> for NGon<[T; 8]>

type Output = NGon<[U; 8]>

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

impl<T, U> Map<U> for NGon<[T; 9]>

type Output = NGon<[U; 9]>

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

impl<T, U> Map<U> for NGon<[T; 10]>

type Output = NGon<[U; 10]>

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

impl<T, U> Map<U> for NGon<[T; 11]>

type Output = NGon<[U; 11]>

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

impl<T> Monomorphic for NGon<[T; 2]>

impl<T> Monomorphic for NGon<[T; 3]>

impl<T> Monomorphic for NGon<[T; 12]>

impl<T> Monomorphic for NGon<[T; 4]>

impl<T> Monomorphic for NGon<[T; 5]>

impl<T> Monomorphic for NGon<[T; 6]>

impl<T> Monomorphic for NGon<[T; 7]>

impl<T> Monomorphic for NGon<[T; 8]>

impl<T> Monomorphic for NGon<[T; 9]>

impl<T> Monomorphic for NGon<[T; 10]>

impl<T> Monomorphic for NGon<[T; 11]>

impl<T> Polygonal for NGon<[T; 3]>

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

Determines if a polygonal structure is convex.

impl<T> Polygonal for NGon<[T; 4]>

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

Determines if a polygonal structure is convex.

impl<T> Polygonal for NGon<[T; 5]>

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

Determines if a polygonal structure is convex.

impl<T> Polygonal for NGon<[T; 6]>

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

Determines if a polygonal structure is convex.

impl<T> Polygonal for NGon<[T; 7]>

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

Determines if a polygonal structure is convex.

impl<T> Polygonal for NGon<[T; 8]>

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

Determines if a polygonal structure is convex.

impl<T> Polygonal for NGon<[T; 9]>

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

Determines if a polygonal structure is convex.

impl<T> Polygonal for NGon<[T; 10]>

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

Determines if a polygonal structure is convex.

impl<T> Polygonal for NGon<[T; 11]>

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

Determines if a polygonal structure is convex.

impl<T> Polygonal for NGon<[T; 12]>

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

Determines if a polygonal structure is convex.

impl<T> StaticArity for NGon<[T; 2]>

type Static = usize

const ARITY: Self::Static

impl<T> StaticArity for NGon<[T; 3]>

type Static = usize

const ARITY: Self::Static

impl<T> StaticArity for NGon<[T; 12]>

type Static = usize

const ARITY: Self::Static

impl<T> StaticArity for NGon<[T; 4]>

type Static = usize

const ARITY: Self::Static

impl<T> StaticArity for NGon<[T; 5]>

type Static = usize

const ARITY: Self::Static

impl<T> StaticArity for NGon<[T; 6]>

type Static = usize

const ARITY: Self::Static

impl<T> StaticArity for NGon<[T; 7]>

type Static = usize

const ARITY: Self::Static

impl<T> StaticArity for NGon<[T; 8]>

type Static = usize

const ARITY: Self::Static

impl<T> StaticArity for NGon<[T; 9]>

type Static = usize

const ARITY: Self::Static

impl<T> StaticArity for NGon<[T; 10]>

type Static = usize

const ARITY: Self::Static

impl<T> StaticArity for NGon<[T; 11]>

type Static = usize

const ARITY: Self::Static

impl<T> Topological for NGon<[T; 2]>

type Vertex = T

fn try_from_slice<U>(vertices: U) -> Option<Self> where
    Self::Vertex: Copy,
    U: 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> + Push<Output = 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> + Push<Output = 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> + Push<Output = 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> + Push<Output = 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: AsPosition,
    Position<Self::Vertex>: EuclideanSpace + FiniteDimensional,
    <Position<Self::Vertex> as FiniteDimensional>::N: Cmp<U2, Output = Greater>, 

Projects an $n$-gon into a plane.

impl<T> Topological for NGon<[T; 3]>

type Vertex = T

fn try_from_slice<U>(vertices: U) -> Option<Self> where
    Self::Vertex: Copy,
    U: 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> + Push<Output = 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> + Push<Output = 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> + Push<Output = 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> + Push<Output = 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: AsPosition,
    Position<Self::Vertex>: EuclideanSpace + FiniteDimensional,
    <Position<Self::Vertex> as FiniteDimensional>::N: Cmp<U2, Output = Greater>, 

Projects an $n$-gon into a plane.

impl<T> Topological for NGon<[T; 12]>

type Vertex = T

fn try_from_slice<U>(vertices: U) -> Option<Self> where
    Self::Vertex: Copy,
    U: 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> + Push<Output = 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> + Push<Output = 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> + Push<Output = 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> + Push<Output = 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: AsPosition,
    Position<Self::Vertex>: EuclideanSpace + FiniteDimensional,
    <Position<Self::Vertex> as FiniteDimensional>::N: Cmp<U2, Output = Greater>, 

Projects an $n$-gon into a plane.

impl<T> Topological for NGon<[T; 4]>

type Vertex = T

fn try_from_slice<U>(vertices: U) -> Option<Self> where
    Self::Vertex: Copy,
    U: 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> + Push<Output = 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> + Push<Output = 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> + Push<Output = 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> + Push<Output = 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: AsPosition,
    Position<Self::Vertex>: EuclideanSpace + FiniteDimensional,
    <Position<Self::Vertex> as FiniteDimensional>::N: Cmp<U2, Output = Greater>, 

Projects an $n$-gon into a plane.

impl<T> Topological for NGon<[T; 5]>

type Vertex = T

fn try_from_slice<U>(vertices: U) -> Option<Self> where
    Self::Vertex: Copy,
    U: 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> + Push<Output = 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> + Push<Output = 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> + Push<Output = 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> + Push<Output = 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: AsPosition,
    Position<Self::Vertex>: EuclideanSpace + FiniteDimensional,
    <Position<Self::Vertex> as FiniteDimensional>::N: Cmp<U2, Output = Greater>, 

Projects an $n$-gon into a plane.

impl<T> Topological for NGon<[T; 6]>

type Vertex = T

fn try_from_slice<U>(vertices: U) -> Option<Self> where
    Self::Vertex: Copy,
    U: 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> + Push<Output = 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> + Push<Output = 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> + Push<Output = 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> + Push<Output = 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: AsPosition,
    Position<Self::Vertex>: EuclideanSpace + FiniteDimensional,
    <Position<Self::Vertex> as FiniteDimensional>::N: Cmp<U2, Output = Greater>, 

Projects an $n$-gon into a plane.

impl<T> Topological for NGon<[T; 7]>

type Vertex = T

fn try_from_slice<U>(vertices: U) -> Option<Self> where
    Self::Vertex: Copy,
    U: 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> + Push<Output = 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> + Push<Output = 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> + Push<Output = 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> + Push<Output = 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: AsPosition,
    Position<Self::Vertex>: EuclideanSpace + FiniteDimensional,
    <Position<Self::Vertex> as FiniteDimensional>::N: Cmp<U2, Output = Greater>, 

Projects an $n$-gon into a plane.

impl<T> Topological for NGon<[T; 8]>

type Vertex = T

fn try_from_slice<U>(vertices: U) -> Option<Self> where
    Self::Vertex: Copy,
    U: 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> + Push<Output = 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> + Push<Output = 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> + Push<Output = 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> + Push<Output = 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: AsPosition,
    Position<Self::Vertex>: EuclideanSpace + FiniteDimensional,
    <Position<Self::Vertex> as FiniteDimensional>::N: Cmp<U2, Output = Greater>, 

Projects an $n$-gon into a plane.

impl<T> Topological for NGon<[T; 9]>

type Vertex = T

fn try_from_slice<U>(vertices: U) -> Option<Self> where
    Self::Vertex: Copy,
    U: 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> + Push<Output = 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> + Push<Output = 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> + Push<Output = 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> + Push<Output = 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: AsPosition,
    Position<Self::Vertex>: EuclideanSpace + FiniteDimensional,
    <Position<Self::Vertex> as FiniteDimensional>::N: Cmp<U2, Output = Greater>, 

Projects an $n$-gon into a plane.

impl<T> Topological for NGon<[T; 10]>

type Vertex = T

fn try_from_slice<U>(vertices: U) -> Option<Self> where
    Self::Vertex: Copy,
    U: 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> + Push<Output = 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> + Push<Output = 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> + Push<Output = 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> + Push<Output = 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: AsPosition,
    Position<Self::Vertex>: EuclideanSpace + FiniteDimensional,
    <Position<Self::Vertex> as FiniteDimensional>::N: Cmp<U2, Output = Greater>, 

Projects an $n$-gon into a plane.

impl<T> Topological for NGon<[T; 11]>

type Vertex = T

fn try_from_slice<U>(vertices: U) -> Option<Self> where
    Self::Vertex: Copy,
    U: 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> + Push<Output = 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> + Push<Output = 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> + Push<Output = 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> + Push<Output = 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: AsPosition,
    Position<Self::Vertex>: EuclideanSpace + FiniteDimensional,
    <Position<Self::Vertex> as FiniteDimensional>::N: Cmp<U2, Output = Greater>, 

Projects an $n$-gon into a plane.

impl<T, U> ZipMap<U> for NGon<[T; 2]>

type Output = NGon<[U; 2]>

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

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<T, U> ZipMap<U> for NGon<[T; 3]>

type Output = NGon<[U; 3]>

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

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<T, U> ZipMap<U> for NGon<[T; 12]>

type Output = NGon<[U; 12]>

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

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<T, U> ZipMap<U> for NGon<[T; 4]>

type Output = NGon<[U; 4]>

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

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<T, U> ZipMap<U> for NGon<[T; 5]>

type Output = NGon<[U; 5]>

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

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<T, U> ZipMap<U> for NGon<[T; 6]>

type Output = NGon<[U; 6]>

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

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<T, U> ZipMap<U> for NGon<[T; 7]>

type Output = NGon<[U; 7]>

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

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<T, U> ZipMap<U> for NGon<[T; 8]>

type Output = NGon<[U; 8]>

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

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<T, U> ZipMap<U> for NGon<[T; 9]>

type Output = NGon<[U; 9]>

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

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<T, U> ZipMap<U> for NGon<[T; 10]>

type Output = NGon<[U; 10]>

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

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<T, U> ZipMap<U> for NGon<[T; 11]>

type Output = NGon<[U; 11]>

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

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,