Struct plexus::primitive::NGon

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

$n$-gon with fixed arity.

NGon represents a polygonal structure as an array. Each array element represents vertex data in order with neighboring 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.

Polygons are defined in $\Reals^2$, but NGon supports arbitrary vertex data. This includes positional data in Euclidean spaces of arbitrary dimension. As such, NGon does not represent a pure polygon, but instead a superset defined solely by its topology. NGons in $\Reals^3$ are useful for representing polygons embedded into three-dimensional space, but there are no restrictions on the geometry of vertices.

Methods

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

pub fn into_array(self) -> A

Trait Implementations

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

type Vertex = T

fn arity(&self) -> usize

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 arity(&self) -> usize

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 arity(&self) -> usize

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 arity(&self) -> usize

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 arity(&self) -> usize

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 arity(&self) -> usize

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 arity(&self) -> usize

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 arity(&self) -> usize

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 arity(&self) -> usize

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 arity(&self) -> usize

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 arity(&self) -> usize

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> Polygonal for NGon<[T; 3]>

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

Determines if a polygon is convex.

fn angles(&self) -> SmallVec<[Scalar<Position<Self::Vertex>>; 8]> where
    Self::Vertex: AsPosition,
    Position<Self::Vertex>: EuclideanSpace + FiniteDimensional<N = U2>,
    Scalar<Position<Self::Vertex>>: FloatConst, 

Gets the relative angles between adjacent line segments.

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

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

Determines if a polygon is convex.

fn angles(&self) -> SmallVec<[Scalar<Position<Self::Vertex>>; 8]> where
    Self::Vertex: AsPosition,
    Position<Self::Vertex>: EuclideanSpace + FiniteDimensional<N = U2>,
    Scalar<Position<Self::Vertex>>: FloatConst, 

Gets the relative angles between adjacent line segments.

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

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

Determines if a polygon is convex.

fn angles(&self) -> SmallVec<[Scalar<Position<Self::Vertex>>; 8]> where
    Self::Vertex: AsPosition,
    Position<Self::Vertex>: EuclideanSpace + FiniteDimensional<N = U2>,
    Scalar<Position<Self::Vertex>>: FloatConst, 

Gets the relative angles between adjacent line segments.

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

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

Determines if a polygon is convex.

fn angles(&self) -> SmallVec<[Scalar<Position<Self::Vertex>>; 8]> where
    Self::Vertex: AsPosition,
    Position<Self::Vertex>: EuclideanSpace + FiniteDimensional<N = U2>,
    Scalar<Position<Self::Vertex>>: FloatConst, 

Gets the relative angles between adjacent line segments.

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

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

Determines if a polygon is convex.

fn angles(&self) -> SmallVec<[Scalar<Position<Self::Vertex>>; 8]> where
    Self::Vertex: AsPosition,
    Position<Self::Vertex>: EuclideanSpace + FiniteDimensional<N = U2>,
    Scalar<Position<Self::Vertex>>: FloatConst, 

Gets the relative angles between adjacent line segments.

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

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

Determines if a polygon is convex.

fn angles(&self) -> SmallVec<[Scalar<Position<Self::Vertex>>; 8]> where
    Self::Vertex: AsPosition,
    Position<Self::Vertex>: EuclideanSpace + FiniteDimensional<N = U2>,
    Scalar<Position<Self::Vertex>>: FloatConst, 

Gets the relative angles between adjacent line segments.

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

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

Determines if a polygon is convex.

fn angles(&self) -> SmallVec<[Scalar<Position<Self::Vertex>>; 8]> where
    Self::Vertex: AsPosition,
    Position<Self::Vertex>: EuclideanSpace + FiniteDimensional<N = U2>,
    Scalar<Position<Self::Vertex>>: FloatConst, 

Gets the relative angles between adjacent line segments.

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

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

Determines if a polygon is convex.

fn angles(&self) -> SmallVec<[Scalar<Position<Self::Vertex>>; 8]> where
    Self::Vertex: AsPosition,
    Position<Self::Vertex>: EuclideanSpace + FiniteDimensional<N = U2>,
    Scalar<Position<Self::Vertex>>: FloatConst, 

Gets the relative angles between adjacent line segments.

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

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

Determines if a polygon is convex.

fn angles(&self) -> SmallVec<[Scalar<Position<Self::Vertex>>; 8]> where
    Self::Vertex: AsPosition,
    Position<Self::Vertex>: EuclideanSpace + FiniteDimensional<N = U2>,
    Scalar<Position<Self::Vertex>>: FloatConst, 

Gets the relative angles between adjacent line segments.

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

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

Determines if a polygon is convex.

fn angles(&self) -> SmallVec<[Scalar<Position<Self::Vertex>>; 8]> where
    Self::Vertex: AsPosition,
    Position<Self::Vertex>: EuclideanSpace + FiniteDimensional<N = U2>,
    Scalar<Position<Self::Vertex>>: FloatConst, 

Gets the relative angles between adjacent line segments.

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

const ARITY: usize

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

const ARITY: usize

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

const ARITY: usize

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

const ARITY: usize

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

const ARITY: usize

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

const ARITY: usize

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

const ARITY: usize

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

const ARITY: usize

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

const ARITY: usize

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

const ARITY: usize

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

const ARITY: usize

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

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

Performs the conversion.

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

fn from(array: A) -> Self

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

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

type Output = ArrayVec<A>

fn into_items(self) -> Self::Output

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; 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, 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> 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: Composite<Item = T>,
    T: Add<T, Output = T>, 

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

fn per_item_partial_min(self, other: Self) -> Self::Output where
    Self: Composite<Item = T>,
    T: Copy + Lattice, 

fn per_item_partial_max(self, other: Self) -> Self::Output where
    Self: Composite<Item = T>,
    T: Copy + Lattice, 

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: Composite<Item = T>,
    T: Add<T, Output = T>, 

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

fn per_item_partial_min(self, other: Self) -> Self::Output where
    Self: Composite<Item = T>,
    T: Copy + Lattice, 

fn per_item_partial_max(self, other: Self) -> Self::Output where
    Self: Composite<Item = T>,
    T: Copy + Lattice, 

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: Composite<Item = T>,
    T: Add<T, Output = T>, 

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

fn per_item_partial_min(self, other: Self) -> Self::Output where
    Self: Composite<Item = T>,
    T: Copy + Lattice, 

fn per_item_partial_max(self, other: Self) -> Self::Output where
    Self: Composite<Item = T>,
    T: Copy + Lattice, 

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: Composite<Item = T>,
    T: Add<T, Output = T>, 

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

fn per_item_partial_min(self, other: Self) -> Self::Output where
    Self: Composite<Item = T>,
    T: Copy + Lattice, 

fn per_item_partial_max(self, other: Self) -> Self::Output where
    Self: Composite<Item = T>,
    T: Copy + Lattice, 

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: Composite<Item = T>,
    T: Add<T, Output = T>, 

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

fn per_item_partial_min(self, other: Self) -> Self::Output where
    Self: Composite<Item = T>,
    T: Copy + Lattice, 

fn per_item_partial_max(self, other: Self) -> Self::Output where
    Self: Composite<Item = T>,
    T: Copy + Lattice, 

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: Composite<Item = T>,
    T: Add<T, Output = T>, 

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

fn per_item_partial_min(self, other: Self) -> Self::Output where
    Self: Composite<Item = T>,
    T: Copy + Lattice, 

fn per_item_partial_max(self, other: Self) -> Self::Output where
    Self: Composite<Item = T>,
    T: Copy + Lattice, 

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: Composite<Item = T>,
    T: Add<T, Output = T>, 

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

fn per_item_partial_min(self, other: Self) -> Self::Output where
    Self: Composite<Item = T>,
    T: Copy + Lattice, 

fn per_item_partial_max(self, other: Self) -> Self::Output where
    Self: Composite<Item = T>,
    T: Copy + Lattice, 

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: Composite<Item = T>,
    T: Add<T, Output = T>, 

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

fn per_item_partial_min(self, other: Self) -> Self::Output where
    Self: Composite<Item = T>,
    T: Copy + Lattice, 

fn per_item_partial_max(self, other: Self) -> Self::Output where
    Self: Composite<Item = T>,
    T: Copy + Lattice, 

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: Composite<Item = T>,
    T: Add<T, Output = T>, 

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

fn per_item_partial_min(self, other: Self) -> Self::Output where
    Self: Composite<Item = T>,
    T: Copy + Lattice, 

fn per_item_partial_max(self, other: Self) -> Self::Output where
    Self: Composite<Item = T>,
    T: Copy + Lattice, 

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: Composite<Item = T>,
    T: Add<T, Output = T>, 

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

fn per_item_partial_min(self, other: Self) -> Self::Output where
    Self: Composite<Item = T>,
    T: Copy + Lattice, 

fn per_item_partial_max(self, other: Self) -> Self::Output where
    Self: Composite<Item = T>,
    T: Copy + Lattice, 

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: Composite<Item = T>,
    T: Add<T, Output = T>, 

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

fn per_item_partial_min(self, other: Self) -> Self::Output where
    Self: Composite<Item = T>,
    T: Copy + Lattice, 

fn per_item_partial_max(self, other: Self) -> Self::Output where
    Self: Composite<Item = T>,
    T: Copy + Lattice, 

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

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

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

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

fn partial_min(self) -> T where
    Self: Composite<Item = T>,
    T: Bounded + Copy + Lattice, 

fn partial_max(self) -> T where
    Self: Composite<Item = T>,
    T: Bounded + Copy + Lattice, 

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

type Item = A::Item

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; 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<T> Converged for NGon<[T; 12]> where
    T: Copy, 

fn converged(item: T) -> Self