Struct rust_examples::rsqrt::PositiveFloat

pub struct PositiveFloat(_);

Thin wrapper around f32 with additional semantics that the values can only be positive floats and excluding infinity and nan.

Zero-cost abstraction

use std::mem::size_of;
use rust_examples::rsqrt::PositiveFloat;

assert_eq!(size_of::<PositiveFloat>(), size_of::<f32>());

Automatic derivation or arithmetic operators

Notice that some of impls on PositiveFloat are automatically derived using derive_more.

Implementations

impl PositiveFloat

pub fn new(v: f32) -> Option<Self>

Constructs new PositiveFloat from given f32 only if:

• it is sign positive
• is a normal float value (i.e. not a zero, nan or infinity)

Note that this factory ensures the safety of PositiveFloat::fast_rsqrt as it makes the illegal states mentioned above unrepresentable.

Example

use rust_examples::rsqrt::PositiveFloat;

assert_eq!(PositiveFloat::new(-4.2), None);
assert_eq!(PositiveFloat::new(0.0), None);
assert_eq!(PositiveFloat::new(f32::NAN), None);
assert_eq!(PositiveFloat::new(f32::INFINITY), None);

pub fn from_square(x: f32) -> Self

pub fn inner(&self) -> f32

Retrieves inner f32 value

pub fn rsqrt(&self) -> Self

Calculates the inverse square root of given number

pub fn fast_rsqrt<const ITERS: usize>(&self) -> Self

Approximates the inverse square root of given number.

This implementation is safe in the sense that by the construction of PositiveFloat, it is not possible to call PositiveFloat::fast_rsqrt on any invalid value: negative floats, zero, nan or infinity.

Constant generic parameter ITERS determines the number of iterations of the Newton’s method used to find the approximation. Note that despite the fact that it is usize, the implementation executes at least one iteration even if it is set to 0.

Trait Implementations

impl Add<PositiveFloat> for PositiveFloat

type Output = PositiveFloat

The resulting type after applying the + operator.

fn add(self, rhs: PositiveFloat) -> PositiveFloat

Performs the + operation.

impl Clone for PositiveFloat

fn clone(&self) -> PositiveFloat

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for PositiveFloat

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

Formats the value using the given formatter.

impl Mul<PositiveFloat> for PositiveFloat

type Output = PositiveFloat

The resulting type after applying the * operator.

fn mul(self, rhs: PositiveFloat) -> PositiveFloat

Performs the * operation.

impl PartialEq<PositiveFloat> for PositiveFloat

fn eq(&self, other: &PositiveFloat) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl Copy for PositiveFloat

impl StructuralPartialEq for PositiveFloat