Struct TwelveTwelve 

pub struct TwelveTwelve {}

A regular dodecagon in two-dimensional hyperbolic space.

TwelveTwelve implements a single regular dodecagon in the {12,12} tiling of two-dimensional hyperbolic space. The scaling of the octagon is set such that each of the angles is $\frac{2\pi}{12}$ so that twelve equivalent dodecagons meet at each vertex.

Implementations

impl TwelveTwelve

pub const TWELVETWELVE: f64 = 3.3257717821172421f64

Cusp-to-vertex distance for the {12,12} tiling for Gauss curvature K = -1.

pub const CUSP_TO_EDGE: f64 = 1.991652391049437f64

Cusp-to-middle-of-edge distance for the {12,12} tiling for Gauss curvature K = -1.

pub const EDGE_LENGTH: f64 = 3.9833047820988741f64

Length of one of the sides of the {12,12} tiling for Gauss curvature K = -1.

pub fn distance_to_boundary(point: &Hyperbolic<3>) -> f64

Computes the shortest distance between a given point and the boundary of TwelveTwelve.

The shortest distance is computed by finding the arclength of the geodesic which passes through the query point and intersects the boundary at a right angle.

Example

use approxim::assert_relative_eq;
use hoomd_geometry::shape::TwelveTwelve;
use hoomd_manifold::{Hyperbolic, Minkowski};
use std::f64::consts::PI;

let v: f64 = TwelveTwelve::CUSP_TO_EDGE - 0.4;
let theta: f64 = PI / 12.0;
let x = Hyperbolic::from_minkowski_coordinates(
    [
        (v.sinh()) * (theta.cos()),
        (v.sinh()) * (theta.sin()),
        (v.cosh()),
    ]
    .into(),
);
assert_relative_eq!(
    TwelveTwelve::distance_to_boundary(&x),
    0.4,
    epsilon = 1e-12
);

pub fn gamma(eta: f64, theta: f64, point: &[f64; 3]) -> [f64; 3]

Apply a lattice transformation to a point.

pub fn reorient(theta: f64, point: &[f64; 3]) -> f64

Calculate the change in angle in the tangent bundle associated with a lattice transformation.

Trait Implementations

impl Clone for TwelveTwelve

fn clone(&self) -> TwelveTwelve

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TwelveTwelve

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TwelveTwelve

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl IsPointInside<Hyperbolic<3>> for TwelveTwelve

fn is_point_inside(&self, point: &Hyperbolic<3>) -> bool

Checks if a given Hyperbolic point is inside TwelveTwelve.

Example

use hoomd_geometry::{IsPointInside, shape::TwelveTwelve};
use hoomd_manifold::Hyperbolic;
use std::f64::consts::PI;

let twelve_twelve = TwelveTwelve {};

let point = Hyperbolic::<3>::from_polar_coordinates(1.0, PI / 8.0);
assert!(twelve_twelve.is_point_inside(&point));

impl PartialEq for TwelveTwelve

fn eq(&self, other: &TwelveTwelve) -> 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 Serialize for TwelveTwelve

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for TwelveTwelve