Struct EightEight 

pub struct EightEight {}

A regular octagon in two-dimensional hyperbolic space.

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

Implementations

impl EightEight

pub const EIGHTEIGHT: f64 = 2.448_452_447_678_076

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

pub const CUSP_TO_EDGE: f64 = 1.528_570_919_480_998

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

pub const EDGE_LENGTH: f64 = 3.057_141_838_961_997

Length of one of the sides of the {8,8} 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 EightEight.

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::EightEight;
use hoomd_manifold::{Hyperbolic, Minkowski};
use std::f64::consts::PI;

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

pub fn boundary_points(number_of_points: usize) -> Vec<(f64, f64)>

Points on the boundary of the fundamental domain

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 EightEight

fn clone(&self) -> EightEight

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EightEight

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for EightEight

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 EightEight

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

Checks if a given Hyperbolic point is inside EightEight.

Example

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

let eight_eight = EightEight {};

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

impl PartialEq for EightEight

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

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 EightEight