Struct HyperbolicConvexPolytope 

pub struct HyperbolicConvexPolytope<const N: usize> { /* private fields */ }

A faceted hyperbolic solid defined by the convex hull of its vertices.

Examples

Construction and basic methods:

use hoomd_geometry::{
    BoundingSphereRadius, shape::HyperbolicConvexPolytope,
};

let hyperbolic_square = HyperbolicConvexPolytope::<3>::regular(4, 0.5);

let bounding_radius = hyperbolic_square.bounding_sphere_radius();

assert_eq!(bounding_radius.get(), 0.5);

Overlap check:

use hoomd_geometry::{IntersectsAtGlobal, shape::HyperbolicConvexPolytope};
use hoomd_manifold::Hyperbolic;
use hoomd_vector::Angle;

let square = HyperbolicConvexPolytope::<3>::regular(4, 0.5);
assert!(square.intersects_at_global(
    &square,
    &Hyperbolic::<3>::default(),
    &Angle::default(),
    &Hyperbolic::<3>::from_polar_coordinates(0.49, 2.3),
    &Angle::from(0.4)
));

assert!(!square.intersects_at_global(
    &square,
    &Hyperbolic::<3>::default(),
    &Angle::default(),
    &Hyperbolic::<3>::from_polar_coordinates(3.0, 2.3),
    &Angle::from(0.2)
));

Implementations

impl<const N: usize> HyperbolicConvexPolytope<N>

pub fn vertices(&self) -> &[Hyperbolic<N>]

Get the vertices of the shape.

impl HyperbolicConvexPolytope<3>

pub fn regular(n: usize, circumradius: f64) -> HyperbolicConvexPolytope<3>

Create a regular n-gon with n vertices and a given circumradius in hyperbolic space.

pub fn edge_distance(&self, phi: f64) -> f64

Calculate the distance between the center of a HyperbolicConvexPolytope<3> centered at the origin and the edge at angle phi. The calculation works by computing the intersection of the the hyperboloid with a plane passing through the origin and the two adjacent vertices of the polygon.

Example

use approxim::assert_relative_eq;
use hoomd_geometry::shape::HyperbolicConvexPolytope;
use std::f64::consts::PI;

let bounding_radius = 0.5;
let hyperbolic_square =
    HyperbolicConvexPolytope::<3>::regular(4, bounding_radius);

// calculation using hyperbolic trigonometry
let pi_fourths_distance =
    (((PI / 4.0).cos()) * (bounding_radius.tanh())).atanh();

let edge_distance = hyperbolic_square.edge_distance(PI / 4.0);

assert_relative_eq!(pi_fourths_distance, edge_distance);

Trait Implementations

impl<const N: usize> BoundingSphereRadius for HyperbolicConvexPolytope<N>

fn bounding_sphere_radius(&self) -> PositiveReal

Get the bounding radius.

impl<const N: usize> Clone for HyperbolicConvexPolytope<N>

fn clone(&self) -> HyperbolicConvexPolytope<N>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const N: usize> Debug for HyperbolicConvexPolytope<N>

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

Formats the value using the given formatter.

impl IntersectsAtGlobal<HyperbolicConvexPolytope<3>, Hyperbolic<3>, Angle> for HyperbolicConvexPolytope<3>

fn intersects_at_global( &self, other: &HyperbolicConvexPolytope<3>, r_self: &Hyperbolic<3>, o_self: &Angle, r_other: &Hyperbolic<3>, o_other: &Angle, ) -> bool

Test whether the set of points in one shape intersects with the set of another (in the global frame).

impl<const N: usize> PartialEq for HyperbolicConvexPolytope<N>

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

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const N: usize> StructuralPartialEq for HyperbolicConvexPolytope<N>