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> PositiveSign<T>

where T: FloatCore,

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

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) -> PositiveSign<T>

Returns the largest integer less than or equal to self.

pub fn ceil(self) -> PositiveSign<T>

Returns the smallest integer greater than or equal to self.

pub fn round(self) -> PositiveSign<T>

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: PositiveSign<f32>

Positive infinity (∞).

pub const fn new_strict(value: f32) -> PositiveSign<f32>

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) -> PositiveSign<f32>

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: PositiveSign<f32>) -> PositiveSign<f32>

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

impl PositiveSign<f64>

pub const INFINITY: PositiveSign<f64>

Positive infinity (∞).

pub const fn new_strict(value: f64) -> PositiveSign<f64>

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) -> PositiveSign<f64>

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: PositiveSign<f64>) -> PositiveSign<f64>

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

Trait Implementations

impl<T> Add for PositiveSign<T>

where T: FloatCore<Output = T> + Add,

type Output = PositiveSign<T>

The resulting type after applying the + operator.

fn add(self, rhs: PositiveSign<T>) -> <PositiveSign<T> as Add>::Output

Performs the + operation.

impl<T> AddAssign for PositiveSign<T>

where T: FloatCore<Output = T> + Add,

fn add_assign(&mut self, rhs: PositiveSign<T>)

Performs the += operation.

impl<'a, T> Arbitrary<'a> for PositiveSign<T>

where NotNan<T>: Arbitrary<'a> + Neg<Output = NotNan<T>> + Copy, PositiveSign<T>: TryFrom<NotNan<T>>,

fn arbitrary(u: &mut Unstructured<'a>) -> Result<PositiveSign<T>, Error>

Generate an arbitrary value of Self from the given unstructured data.

fn size_hint(depth: usize) -> (usize, Option<usize>)

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self, Error>

Generate an arbitrary value of Self from the entirety of the given unstructured data.

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 for PositiveSign<T>

where T: Clone,

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> ConstOne for PositiveSign<T>

where T: FloatCore + ConstOne,

const ONE: PositiveSign<T>

The multiplicative identity element of Self, 1.

impl<T> ConstZero for PositiveSign<T>

where T: FloatCore + ConstZero,

const ZERO: PositiveSign<T>

The additive identity element of Self, 0.

impl<T> Debug for PositiveSign<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Default for PositiveSign<T>

where T: FloatCore + Zero,

fn default() -> PositiveSign<T>

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

impl<'de, T> Deserialize<'de> for PositiveSign<T>

where T: Deserialize<'de>, PositiveSign<T>: TryFrom<T>, <PositiveSign<T> as TryFrom<T>>::Error: Error,

fn deserialize<D>( deserializer: D, ) -> Result<PositiveSign<T>, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> Display for PositiveSign<T>

where T: Display,

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

Formats the value using the given formatter.

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

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

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

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

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<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 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<T> Hash for PositiveSign<T>

where T: PrimitiveFloat,

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

where H: Hasher,

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> Mul<PositiveSign<T>> for ZeroOne<T>

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

type Output = PositiveSign<T>

The resulting type after applying the * operator.

fn mul( self, rhs: PositiveSign<T>, ) -> <ZeroOne<T> as Mul<PositiveSign<T>>>::Output

Performs the * operation.

impl Mul<PositiveSign<f32>> for Rgb

Multiplies this color value by a scalar.

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

Multiplies this color value by a scalar.

type Output = Rgb

The resulting type after applying the * operator.

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

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

type Output = PositiveSign<T>

The resulting type after applying the * operator.

fn mul(self, rhs: ZeroOne<T>) -> <PositiveSign<T> as Mul<ZeroOne<T>>>::Output

Performs the * operation.

impl<T> Mul for PositiveSign<T>

where T: FloatCore<Output = T> + Mul,

fn mul(self, rhs: PositiveSign<T>) -> <PositiveSign<T> as Mul>::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> MulAssign for PositiveSign<T>

where T: FloatCore<Output = T> + Mul,

fn mul_assign(&mut self, rhs: PositiveSign<T>)

Performs the *= operation.

impl<T> One for PositiveSign<T>

where T: FloatCore + One,

fn one() -> PositiveSign<T>

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> Ord for PositiveSign<T>

where T: FloatCore + PartialOrd,

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

where T: PartialEq,

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> PartialEq for PositiveSign<T>

where T: PartialEq,

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> PartialOrd<T> for PositiveSign<T>

where T: PartialOrd,

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> PartialOrd for PositiveSign<T>

where T: FloatCore + PartialOrd,

fn partial_cmp(&self, other: &PositiveSign<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> Serialize for PositiveSign<T>

where T: Serialize,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> Sum for PositiveSign<T>

where T: FloatCore + Sum, PositiveSign<T>: TryFrom<T>,

fn sum<I>(iter: I) -> PositiveSign<T>

where I: Iterator<Item = PositiveSign<T>>,

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

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

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

fn try_from( value: NotNan<T>, ) -> Result<PositiveSign<T>, <PositiveSign<T> as TryFrom<NotNan<T>>>::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<PositiveSign<f32>, <PositiveSign<f32> as TryFrom<f32>>::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<PositiveSign<f64>, <PositiveSign<f64> as TryFrom<f64>>::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> Zero for PositiveSign<T>

where T: FloatCore + Zero,

fn zero() -> PositiveSign<T>

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.

impl<T> Copy for PositiveSign<T>

where T: Copy,

impl<T> Eq for PositiveSign<T>

where T: PartialEq,

impl<T> StructuralPartialEq for PositiveSign<T>