Struct PositiveSign 

pub struct PositiveSign<T>(/* private fields */);

A floating-point number which is not NaN and whose sign bit is positive.

The allowed values consist of positive zero, positive infinity, and every value in between those. This set of values means that this type:

• Implements Eq straightforwardly; neither NaN nor signed zeroes can cause problems with using it as a map key for caching, interning, etc.
• Is closed under multiplication and addition, so unlike NotNan, cannot cause a panic from uncautious arithmetic.

The permitted values of a PositiveSign<T> are a subset of those of a NotNan<T>. (This may not be guaranteed if T implements numeric traits in inconsistent ways, but may be assumed for f32 and f64.)

The arithmetic behavior of PositiveSign<T> is not identical to T. Specifically, the value of 0. * fXX::INFINITY is NaN, but the value of PositiveSign(0.) * PositiveSign(fXX::INFINITY) is PositiveSign(0.) instead. Our assumption here is that for the applications where PositiveSign is suitable, infinities are either impossible or arise as “would be finite but it is too large to be represented”, and do not arise as the reciprocal of zero, and thus we can treat “zero times anything is zero” as being a more important property than “infinity times anything is infinity”.

Implementations

impl<T: FloatCore> PositiveSign<T>

pub const unsafe fn new_unchecked(value: T) -> Self

Construct PositiveSign without checking the value.

Safety

value must not be NaN and must have a positive sign bit. Note that value >= 0. is not a sufficient condition, because it does not exclude negative zero.

pub const fn into_inner(self) -> T

Unwraps the value without modifying it.

pub fn floor(self) -> Self

Returns the largest integer less than or equal to self.

pub fn ceil(self) -> Self

Returns the smallest integer greater than or equal to self.

pub fn round(self) -> Self

Returns the nearest integer to self. If a value is half-way between two integers, round up from 0.0.

pub fn is_finite(&self) -> bool

Returns whether the value is finite.

Since the value is statically guaranteed to be neither NaN nor negative, the only case where this returns false is when the value is positive infinity.

pub fn clamp_01(self) -> ZeroOne<T>

Convert to ZeroOne, replacing too-large values with 1.0.

impl PositiveSign<f32>

pub const INFINITY: Self

Positive infinity (∞).

pub const fn new_strict(value: f32) -> Self

Wraps the given value in PositiveSign.

• If value is positive (including positive infinity), returns wrapped value.
• If value is zero of either sign, returns wrapped positive zero. This is lossy, but corresponds to the IEEE 754 idea that -0.0 == +0.0.
• If value is negative non-zero or NaN, panics.

pub const fn new_clamped(value: f32) -> Self

Wraps the given value in PositiveSign.

• If the value is NaN, panics.
• If the value has a negative sign, it is replaced with positive zero.

pub fn saturating_sub(self, other: Self) -> Self

Subtract other from self; if the result would be negative, it is zero instead.

impl PositiveSign<f64>

pub const INFINITY: Self

Positive infinity (∞).

pub const fn new_strict(value: f64) -> Self

Wraps the given value in PositiveSign.

• If value is positive (including positive infinity), returns wrapped value.
• If value is zero of either sign, returns wrapped positive zero. This is lossy, but corresponds to the IEEE 754 idea that -0.0 == +0.0.
• If value is negative non-zero or NaN, panics.

pub const fn new_clamped(value: f64) -> Self

Wraps the given value in PositiveSign.

• If the value is NaN, panics.
• If the value has a negative sign, it is replaced with positive zero.

pub fn saturating_sub(self, other: Self) -> Self

Subtract other from self; if the result would be negative, it is zero instead.

Trait Implementations

impl<T: FloatCore + Add<Output = T>> Add for PositiveSign<T>

type Output = PositiveSign<T>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<T: FloatCore + Add<Output = T>> AddAssign for PositiveSign<T>

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<T> AsRef<T> for PositiveSign<T>

fn as_ref(&self) -> &T

Converts this type into a shared reference of the (usually inferred) input type.

impl<T: Clone> Clone for PositiveSign<T>

fn clone(&self) -> PositiveSign<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: FloatCore + ConstOne> ConstOne for PositiveSign<T>

const ONE: Self

The multiplicative identity element of Self, 1.

impl<T: FloatCore + ConstZero> ConstZero for PositiveSign<T>

const ZERO: Self

The additive identity element of Self, 0.

impl<T: Copy> Copy for PositiveSign<T>

impl<T: Debug> Debug for PositiveSign<T>

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

Formats the value using the given formatter.

impl<T: FloatCore + Zero> Default for PositiveSign<T>

fn default() -> Self

The default is zero, regardless of what T::default() is.

impl<T: Display> Display for PositiveSign<T>

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

Formats the value using the given formatter.

impl<T: PartialEq> Eq for PositiveSign<T>

impl From<PositiveSign<f32>> for NotNan<f32>

fn from(value: PositiveSign<f32>) -> Self

Converts to this type from the input type.

impl From<PositiveSign<f32>> for f32

fn from(value: PositiveSign<f32>) -> Self

Converts to this type from the input type.

impl From<PositiveSign<f64>> for NotNan<f64>

fn from(value: PositiveSign<f64>) -> Self

Converts to this type from the input type.

impl From<PositiveSign<f64>> for f64

fn from(value: PositiveSign<f64>) -> Self

Converts to this type from the input type.

impl From<ZeroOne<f32>> for PositiveSign<f32>

fn from(value: ZeroOne<f32>) -> Self

Converts to this type from the input type.

impl From<ZeroOne<f64>> for PositiveSign<f64>

fn from(value: ZeroOne<f64>) -> Self

Converts to this type from the input type.

impl From<bool> for PositiveSign<f32>

fn from(value: bool) -> PositiveSign<f32>

Converts to this type from the input type.

impl From<bool> for PositiveSign<f64>

fn from(value: bool) -> PositiveSign<f64>

Converts to this type from the input type.

impl From<u8> for PositiveSign<f32>

fn from(value: u8) -> PositiveSign<f32>

Converts to this type from the input type.

impl From<u8> for PositiveSign<f64>

fn from(value: u8) -> PositiveSign<f64>

Converts to this type from the input type.

impl From<u16> for PositiveSign<f32>

fn from(value: u16) -> PositiveSign<f32>

Converts to this type from the input type.

impl From<u16> for PositiveSign<f64>

fn from(value: u16) -> PositiveSign<f64>

Converts to this type from the input type.

impl From<u32> for PositiveSign<f64>

fn from(value: u32) -> PositiveSign<f64>

Converts to this type from the input type.

impl<T: PrimitiveFloat> Hash for PositiveSign<T>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: FloatCore + Mul<Output = T>> Mul for PositiveSign<T>

fn mul(self, rhs: Self) -> Self::Output

This multiplication operation differs from standard floating-point multiplication in that multiplying zero by positive infinity returns zero instead of NaN. This is necessary for the type to be closed under multiplication.

type Output = PositiveSign<T>

The resulting type after applying the * operator.

impl<T: FloatCore> Mul<PositiveSign<T>> for ZeroOne<T>

where PositiveSign<T>: From<ZeroOne<T>>,

type Output = PositiveSign<T>

The resulting type after applying the * operator.

fn mul(self, rhs: PositiveSign<T>) -> Self::Output

Performs the * operation.

impl Mul<PositiveSign<f32>> for Rgb

Multiplies this color value by a scalar.

fn mul(self, scalar: PositiveSign<f32>) -> Self

Multiplies this color value by a scalar.

type Output = Rgb

The resulting type after applying the * operator.

impl<T: FloatCore> Mul<ZeroOne<T>> for PositiveSign<T>

where PositiveSign<T>: From<ZeroOne<T>>,

type Output = PositiveSign<T>

The resulting type after applying the * operator.

fn mul(self, rhs: ZeroOne<T>) -> Self::Output

Performs the * operation.

impl<T: FloatCore + Mul<Output = T>> MulAssign for PositiveSign<T>

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<T: FloatCore + One> One for PositiveSign<T>

fn one() -> Self

Returns the multiplicative identity element of Self, 1.

fn set_one(&mut self)

Sets self to the multiplicative identity element of Self, 1.

fn is_one(&self) -> bool

where Self: PartialEq,

Returns true if self is equal to the multiplicative identity.

impl<T: FloatCore + PartialOrd> Ord for PositiveSign<T>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T: PartialEq> PartialEq for PositiveSign<T>

fn eq(&self, other: &PositiveSign<T>) -> 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<T: PartialEq> PartialEq<T> for PositiveSign<T>

fn eq(&self, other: &T) -> 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<T: FloatCore + PartialOrd> PartialOrd for PositiveSign<T>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T: PartialOrd> PartialOrd<T> for PositiveSign<T>

fn partial_cmp(&self, other: &T) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T> StructuralPartialEq for PositiveSign<T>

impl<T: FloatCore + Sum> Sum for PositiveSign<T>

where Self: TryFrom<T>,

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<T> TryFrom<NotNan<T>> for PositiveSign<T>

where Self: TryFrom<T, Error = NotPositiveSign<T>>,

fn try_from(value: NotNan<T>) -> Result<Self, Self::Error>

Checks that value is non-negative.

• If value is positive (including positive infinity), returns wrapped value.
• If value is zero of either sign, returns wrapped positive zero. This is lossy, but corresponds to the IEEE 754 idea that -0.0 == +0.0.
• If value is negative non-zero or NaN, returns an error.

type Error = NotPositiveSign<T>

The type returned in the event of a conversion error.

impl TryFrom<f32> for PositiveSign<f32>

fn try_from(value: f32) -> Result<Self, Self::Error>

Checks that value is non-negative and non-NaN.

• If value is positive (including positive infinity), returns wrapped value.
• If value is zero of either sign, returns wrapped positive zero. This is lossy, but corresponds to the IEEE 754 idea that -0.0 == +0.0.
• If value is negative non-zero or NaN, returns an error.

type Error = NotPositiveSign<f32>

The type returned in the event of a conversion error.

impl TryFrom<f64> for PositiveSign<f64>

fn try_from(value: f64) -> Result<Self, Self::Error>

Checks that value is non-negative and non-NaN.

• If value is positive (including positive infinity), returns wrapped value.
• If value is zero of either sign, returns wrapped positive zero. This is lossy, but corresponds to the IEEE 754 idea that -0.0 == +0.0.
• If value is negative non-zero or NaN, returns an error.

type Error = NotPositiveSign<f64>

The type returned in the event of a conversion error.

impl<T: FloatCore + Zero> Zero for PositiveSign<T>

fn zero() -> Self

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.