Struct particular::compute_method::storage::PointMass

#[repr(C)]
pub struct PointMass<V, S> {
    pub position: V,
    pub mass: S,
}

Point-mass representation of an object in space.

Fields

position: V

Position of the object.

mass: S

Mass of the object.

Implementations

impl<V: Zero, S: Zero> PointMass<V, S>

pub const ZERO: Self = _

PointMass with position and mass set to Zero::ZERO.

impl<V, S> PointMass<V, S>

pub const fn new(position: V, mass: S) -> Self

Creates a new PointMass with the given position and mass.

pub fn new_lane(position: V::Lane, mass: S::Lane) -> Self

where V: SIMD, S: SIMD,

Creates a new PointMass with the given lanes of positions and masses.

pub fn new_com(data: &[Self]) -> Self

where V: FloatVector<Float = S> + Sum + Copy, S: Float + FromPrimitive<usize> + Sum + Copy,

Returns the PointMass corresponding to the center of mass and total mass of the given slice of point-masses.

pub fn splat_lane(position: V::Element, mass: S::Element) -> Self

where V: SIMD, S: SIMD,

Creates a new PointMass with all lanes set to the given position and mass.

pub fn slice_to_lane<const L: usize, T, E>(slice: &[PointMass<T, E>]) -> Self

where T: Clone + Zero, E: Clone + Zero, V: SIMD<Lane = [T; L], Element = T>, S: SIMD<Lane = [E; L], Element = E>,

Returns a SIMD point-masses from a slice of SIMD::Element point-masses.

pub fn slice_to_lanes<'a, const L: usize, T, E>( slice: &'a [PointMass<T, E>] ) -> impl Iterator<Item = Self> + 'a

where T: Clone + Zero, E: Clone + Zero, V: SIMD<Lane = [T; L], Element = T> + 'a, S: SIMD<Lane = [E; L], Element = E> + 'a,

Returns an iterator of SIMD point-masses from a slice of SIMD::Element point-masses.

pub fn is_massless(&self) -> bool

where S: PartialEq + Zero,

Returns true if the mass is zero.

pub fn is_massive(&self) -> bool

where S: PartialEq + Zero,

Returns false if the mass is zero.

pub fn force_scalar<const CHECK_ZERO: bool>( &self, position: V, mass: S, softening: S ) -> V

where V: FloatVector<Float = S> + Copy, S: Float + Copy,

Computes the gravitational force exerted on the current point-mass using the given position and mass. This method is optimised in the case where V and S are scalar types.

If the position of the current point-mass is guaranteed to be different from the given position, this computation can be more efficient with CHECK_ZERO set to false.

pub fn force_simd<const CHECK_ZERO: bool>( &self, position: V, mass: S, softening: S ) -> V

where V: FloatVector<Float = S> + Copy, S: Float + BitAnd<Output = S> + CmpNe<Output = S> + Copy,

Computes the gravitational force exerted on the current point-mass using the given position and mass. This method is optimised in the case where V and S are simd types.

If the position of the current point-mass is guaranteed to be different from the given position, this computation can be more efficient with CHECK_ZERO set to false.

pub fn acceleration_tree<const X: usize, const D: usize>( &self, tree: &Orthtree<X, D, S, PointMass<V, S>>, node: Option<NodeID>, theta: S, softening: S ) -> V

where V: FloatVector<Float = S> + Copy + Sum, S: Float + PartialOrd + Copy,

Computes the gravitational acceleration exerted on the current point-mass by the specified node of the given Orthtree following the Barnes-Hut approximation with the given theta parameter, provided V and S are scalar types.

Trait Implementations

impl<V: Clone, S: Clone> Clone for PointMass<V, S>

fn clone(&self) -> PointMass<V, S>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<V: Debug, S: Debug> Debug for PointMass<V, S>

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

Formats the value using the given formatter.

impl<V: Default, S: Default> Default for PointMass<V, S>

fn default() -> PointMass<V, S>

Returns the “default value” for a type.

impl<V: Zeroable, S: Zeroable> Zeroable for PointMass<V, S>

fn zeroed() -> Self

Calls zeroed.

impl<V: Copy, S: Copy> Copy for PointMass<V, S>

impl<V: NoUninit, S: NoUninit> NoUninit for PointMass<V, S>