Struct plexus::primitive::UnboundedPolygon

pub struct UnboundedPolygon<G>(_);

Unbounded polymorphic $n$-gon.

UnboundedPolygon represents an $n$-gon with three or more edges. Unlike BoundedPolygon, there is no limit to the arity of polygons that UnboundedPolygon may represent.

It is not possible to trivially convert an UnboundedPolygon into other topological types like NGon. See the module documentation for more information.

Implementations

impl<G> UnboundedPolygon<G>

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

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

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

impl<'a, G> UnboundedPolygon<&'a G> where
    G: Clone, 

pub fn cloned(self) -> UnboundedPolygon<G>

Trait Implementations

impl<G> Adjunct for UnboundedPolygon<G>

type Item = G

impl<G> AsMut<[G]> for UnboundedPolygon<G>

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

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

impl<G> AsRef<[G]> for UnboundedPolygon<G>

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

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

impl<G: Clone> Clone for UnboundedPolygon<G>

fn clone(&self) -> UnboundedPolygon<G>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<G: Debug> Debug for UnboundedPolygon<G>

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

Formats the value using the given formatter.

impl<G> DynamicArity for UnboundedPolygon<G>

type Dynamic = usize

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

impl<G> From<BoundedPolygon<G>> for UnboundedPolygon<G> where
    G: Clone, 

fn from(polygon: BoundedPolygon<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> FromItems for UnboundedPolygon<G>

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

impl<G> Index<usize> for UnboundedPolygon<G>

type Output = G

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<G> IndexMut<usize> for UnboundedPolygon<G>

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

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

impl<T> IntoEdges for UnboundedPolygon<T> where
    T: Clone, 

type Output = Vec<NGon<<UnboundedPolygon<T> as Topological>::Vertex, 2_usize>, Global>

fn into_edges(self) -> Self::Output

impl<G> IntoItems for UnboundedPolygon<G>

type Output = SmallVec<[G; 4]>

fn into_items(self) -> Self::Output

impl<G> IntoIterator for UnboundedPolygon<G>

type IntoIter = <SmallVec<[G; 4]> as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

type Item = G

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T, U> Map<U> for UnboundedPolygon<T>

type Output = UnboundedPolygon<U>

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

impl<G: PartialEq> PartialEq<UnboundedPolygon<G>> for UnboundedPolygon<G>

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

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

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

This method tests for !=.

impl<G> Polygonal for UnboundedPolygon<G>

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

Determines if the polygon is convex.

impl<G> StaticArity for UnboundedPolygon<G>

type Static = (usize, Option<usize>)

const ARITY: Self::Static = (3, None)

impl<G> Topological for UnboundedPolygon<G>

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> TryFromIterator<G> for UnboundedPolygon<G>

type Error = ()

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

impl<G> StructuralPartialEq for UnboundedPolygon<G>