Struct Hypersphere 

pub struct Hypersphere<const N: usize> {
    pub radius: PositiveReal,
}

All points within a given radius from the origin.

Examples

Basic construction and methods:

use hoomd_geometry::{SupportMapping, Volume, shape::Hypersphere};
use hoomd_vector::Cartesian;
use std::f64::consts::PI;

let unit_sphere = Hypersphere::<3>::default();
let volume = unit_sphere.volume();

assert_eq!(unit_sphere.radius.get(), 1.0);
assert_eq!(volume, 4.0 * PI / 3.0);

assert_eq!(
    unit_sphere.support_mapping(&Cartesian::from([1.0; 3])),
    [1.0 / f64::sqrt(3.0); 3].into()
)

Test for intersections:

use hoomd_geometry::{IntersectsAt, shape::Hypersphere};
use hoomd_vector::{Cartesian, Versor};

let unit_sphere = Hypersphere::<3>::default();

assert!(!unit_sphere.intersects_at(
    &unit_sphere,
    &Cartesian::from([2.1, 0.0, 0.0]),
    &Versor::default()
));
assert!(unit_sphere.intersects_at(
    &unit_sphere,
    &Cartesian::from([0.0, 1.9, 0.0]),
    &Versor::default()
));

Fields

radius: PositiveReal

Radius of the sphere

Implementations

impl<const N: usize> Hypersphere<N>

pub fn with_radius(radius: PositiveReal) -> Self

Create a sphere with a given positive real radius.

pub fn intersects<V>(&self, other: &Hypersphere<N>, v_ij: &V) -> bool

where V: InnerProduct,

Test whether one sphere intersects with another.

The vector v_ij points from the local origin of self to the local origin of other.

Trait Implementations

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

fn bounding_sphere_radius(&self) -> PositiveReal

Get the bounding radius.

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

fn clone(&self) -> Hypersphere<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 Hypersphere<N>

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

Formats the value using the given formatter.

impl<const N: usize> Default for Hypersphere<N>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, const N: usize> Deserialize<'de> for Hypersphere<N>

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<const N: usize> Distribution<Cartesian<N>> for Hypersphere<N>

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Cartesian<N>

Generate points uniformly distributed in the hypersphere.

Example

use hoomd_geometry::{IsPointInside, shape::Sphere};
use rand::{SeedableRng, distr::Distribution, rngs::StdRng};

let sphere = Sphere {
    radius: 5.0.try_into()?,
};
let mut rng = StdRng::seed_from_u64(1);

let point = sphere.sample(&mut rng);
assert!(sphere.is_point_inside(&point));

fn sample_iter<R>(self, rng: R) -> Iter<Self, R, T>

where R: Rng, Self: Sized,

Create an iterator that generates random values of T, using rng as the source of randomness.

fn map<F, S>(self, func: F) -> Map<Self, F, T, S>

where F: Fn(T) -> S, Self: Sized,

Map sampled values to type S

impl<const N: usize, V, R> IntersectsAt<Hypersphere<N>, V, R> for Hypersphere<N>

where V: InnerProduct, R: Rotation + Rotate<V>,

fn intersects_at(&self, other: &Hypersphere<N>, v_ij: &V, _o_ij: &R) -> bool

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

fn approximate_separation_distance( &self, other: &S, v_ij: &V, o_ij: &R, resolution: PositiveReal, ) -> f64

where V: InnerProduct,

Approximate the amount of overlap between two shapes.

impl<const N: usize, R> IntersectsAtGlobal<Hypersphere<N>, Cartesian<N>, R> for Hypersphere<N>

where R: Rotation + Rotate<Cartesian<N>>,

fn intersects_at_global( &self, other: &Hypersphere<N>, r_self: &Cartesian<N>, o_self: &R, r_other: &Cartesian<N>, o_other: &R, ) -> bool

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

impl<const N: usize, V> IsPointInside<V> for Hypersphere<N>

where V: InnerProduct,

fn is_point_inside(&self, point: &V) -> bool

Check if a vector is inside a hypersphere.

use hoomd_geometry::{IsPointInside, shape::Sphere};
use hoomd_vector::Cartesian;

let sphere = Sphere {
    radius: 3.0.try_into()?,
};

assert!(sphere.is_point_inside(&Cartesian::from([2.5, 0.0, 0.0])));
assert!(!sphere.is_point_inside(&Cartesian::from([3.0, -3.0, 2.0])));

impl<const N: usize> MapPoint<Cartesian<N>> for Hypersphere<N>

fn map_point( &self, point: Cartesian<N>, other: &Self, ) -> Result<Cartesian<N>, Error>

Map a point from one hypersphere to another.

Given a point P inside self, map it to the other shape by scaling.

Errors

Returns Error::PointOutsideShape when point is outside the shape self.

Example

use hoomd_geometry::{MapPoint, shape::Circle};
use hoomd_vector::Cartesian;

let closed_a = Circle {
    radius: 10.0.try_into()?,
};
let closed_b = Circle {
    radius: 20.0.try_into()?,
};

let mapped_point =
    closed_a.map_point(Cartesian::from([-1.0, 1.0]), &closed_b);

assert_eq!(mapped_point, Ok(Cartesian::from([-2.0, 2.0])));
assert_eq!(
    closed_a.map_point(Cartesian::from([-100.0, 1.0]), &closed_b),
    Err(hoomd_geometry::Error::PointOutsideShape)
);

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

fn eq(&self, other: &Hypersphere<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> Scale for Hypersphere<N>

fn scale_length(&self, v: PositiveReal) -> Self

Construct a scaled hypersphere.

The resulting hypersphere’s radious $r_\mathrm{new}$ is the original’s $r$ scaled by $v$:

r_\mathrm{new} = v r

The centroid remains at the origin.

Example

use hoomd_geometry::{Scale, shape::Sphere};

let sphere = Sphere {
    radius: 5.0.try_into()?,
};

let scaled_sphere = sphere.scale_length(0.5.try_into()?);

assert_eq!(scaled_sphere.radius.get(), 2.5);

fn scale_volume(&self, v: PositiveReal) -> Self

Construct a scaled hypersphere.

The resulting hypersphere’s radius $r_\mathrm{new}$ is the original’s $r$ scaled by $v^\frac{1}{N}$:

r_\mathrm{new} = v^\frac{1}{N} r

The centroid remains at the origin.

Example

Example

use hoomd_geometry::{Scale, shape::Circle};

let sphere = Circle {
    radius: 5.0.try_into()?,
};

let scaled_sphere = sphere.scale_volume(0.25.try_into()?);

assert_eq!(scaled_sphere.radius.get(), 2.5);

impl<const N: usize> Serialize for Hypersphere<N>

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<const N: usize, V: InnerProduct> SupportMapping<V> for Hypersphere<N>

fn support_mapping(&self, n: &V) -> V

Return the furthest extent of a shape in the direction of n.

impl<const N: usize> Volume for Hypersphere<N>

fn volume(&self) -> f64

The N-hypervolume of a geometry.

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