Struct Total 

pub struct Total<T: TotalFloat>(/* private fields */);

Experimental: A transparent wrapper around floating point values with total ordering.

Comparison, equality, and hashing all agree with total_cmp.

Enabling

This type is experimental and must be enabled with the float_experimental feature.

cargo add range-set-blaze --features "float_experimental"

That provides the TotalF32 and TotalF64 types.

If you’re building with nightly, you can instead use the float_nightly_experimental feature.

cargo add range-set-blaze --features "float_nightly_experimental"

To also use the TotalF16 and TotalF128 types.

Implementations

impl<T: TotalFloat> Total<T>

pub const MIN: Self

The minimum value that can be represented by the type. I.e., the smallest possible value according to total_cmp
Maps directly to crate::Integer::min_value()

Examples

use range_set_blaze::TotalF64;

assert_eq!(TotalF64::MIN, TotalF64::new(f64::from_bits(u64::MAX)));

pub const MAX: Self

The maximum value that can be represented by the type. I.e., the largest possible value according to total_cmp
Maps directly to crate::Integer::max_value()

Examples

use range_set_blaze::TotalF64;

assert_eq!(TotalF64::MAX, TotalF64::new(f64::from_bits(0x7fff_ffff_ffff_ffff)));

pub const MAX_SIZE: T::SafeLen = T::MAX_SIZE

The maximum possible size of a range, i.e. the size if [MIN..=MAX]

Examples

use range_set_blaze::TotalF32;

assert_eq!(TotalF32::MAX_SIZE, u32::MAX as i64 + 1);

pub const fn new(x: T) -> Self

Creates a new Total from a primitive float. All values are legal.

Examples

use range_set_blaze::TotalF64;

let _ = TotalF64::new(f64::INFINITY);

pub fn inclusive_end_from_start(self, b: T::SafeLen) -> Self

Computes self + (b - 1) where b is of type SafeLen.

Precondition

b must be small enough that the result stays within range for T. This is checked with debug_assert! and is not checked in release builds, where violating it produces an unspecified (nonsense, but not unsafe) result rather than a panic. Callers are expected to only ever pass a b that satisfies this.

pub fn start_from_inclusive_end(self, b: T::SafeLen) -> Self

Computes self - (b - 1) where b is of type SafeLen.

Precondition

b must be small enough that the result stays within range for T. This is checked with debug_assert! and is not checked in release builds, where violating it produces an unspecified (nonsense, but not unsafe) result rather than a panic. Callers are expected to only ever pass a b that satisfies this.

pub const fn into_inner(self) -> T

Returns the wrapped value.

Examples

use range_set_blaze::TotalF64;

assert_eq!(TotalF64::new(42.0).into_inner(), 42.0);

pub fn after(self) -> Self

Returns the next float in total order.

Examples

use range_set_blaze::TotalF64;

assert_eq!(TotalF64::new(42.0).after().before().into_inner(), 42.0);

Panics

In debug builds, panics if self is the maximum value. In release builds, wraps around to the minimum value instead.

pub fn before(self) -> Self

Returns the previous float in total order.

Examples

use range_set_blaze::TotalF64;

assert_eq!(TotalF64::new(42.0).before().after().into_inner(), 42.0);

Panics

In debug builds, panics if self is the minimum value. In release builds, wraps around to the maximum value instead.

pub fn checked_after(self) -> Option<Self>

Returns the next float.

Returns None if self is the maximum value.

Examples

use range_set_blaze::TotalF64;

let value = TotalF64::new(42.0);
assert_eq!(value.checked_after(), Some(value.after()));
let value = TotalF64::MAX;
assert_eq!(value.checked_after(), None);

pub fn checked_before(self) -> Option<Self>

Returns the previous float.

Returns None if self is the minimum value.

Examples

use range_set_blaze::TotalF64;

let value = TotalF64::new(42.0);
assert_eq!(value.checked_before(), Some(value.before()));
let value = TotalF64::MIN;
assert_eq!(value.checked_before(), None);

pub fn from_primitive_range(range: RangeInclusive<T>) -> RangeInclusive<Self>

Converts an inclusive primitive range into an inclusive Total range.

“Primitive” here means Rust’s built-in float type (e.g. f64).

Examples

use range_set_blaze::{RangeSetBlaze, TotalF64};

let short = RangeSetBlaze::from(TotalF64::from_primitive_range(3.0..=5.0));
let long = RangeSetBlaze::from(TotalF64::new(3.0)..=TotalF64::new(5.0));
assert_eq!(short, long);

pub fn from_primitive_ranges<I>( ranges: I, ) -> impl Iterator<Item = RangeInclusive<Self>>

where I: IntoIterator<Item = RangeInclusive<T>>,

Converts inclusive primitive ranges into inclusive Total ranges.

“Primitive” here means Rust’s built-in float type (e.g. f64).

Examples

use range_set_blaze::{RangeSetBlaze, TotalF64};

let short = RangeSetBlaze::from_iter(TotalF64::from_primitive_ranges([1.0..=2.0, 3.0..=4.0]));
let long = RangeSetBlaze::from_iter([TotalF64::new(1.0)..=TotalF64::new(2.0), TotalF64::new(3.0)..=TotalF64::new(4.0)]);
assert_eq!(short, long);

pub fn values<I>(values: I) -> impl Iterator<Item = Self>

where I: IntoIterator<Item = T>,

Convenience method to convert primitive values into ordered Total values.

Examples

use range_set_blaze::{RangeSetBlaze, TotalF64};

let short = RangeSetBlaze::from_iter(TotalF64::values([1.0, 2.0, 3.0, 4.0]));
let long = RangeSetBlaze::from_iter([TotalF64::new(1.0), TotalF64::new(2.0), TotalF64::new(3.0), TotalF64::new(4.0)]);
assert_eq!(short, long);

pub const fn from_primitive_slice(values: &[T]) -> &[Self]

Views primitive values as ordered Total values.

“Primitive” here means Rust’s built-in float type (e.g. f64).

This runs in O(1) and does not allocate.

Examples

use range_set_blaze::{RangeSetBlaze, TotalF64};

let short = RangeSetBlaze::from_iter(TotalF64::from_primitive_slice(&[1.0, 2.0, 3.0, 4.0]));
let long = RangeSetBlaze::from_iter([TotalF64::new(1.0), TotalF64::new(2.0), TotalF64::new(3.0), TotalF64::new(4.0)]);
assert_eq!(short, long);

Trait Implementations

impl<T: Clone + TotalFloat> Clone for Total<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Copy + TotalFloat> Copy for Total<T>

impl<T: Debug + TotalFloat> Debug for Total<T>

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

Formats the value using the given formatter.

impl<T: Default + TotalFloat> Default for Total<T>

fn default() -> Total<T>

Returns the “default value” for a type.

impl<T: TotalFloat> Eq for Total<T>

impl<T: TotalFloat> Hash for Total<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: TotalFloat> Integer for Total<T>

type SafeLen = <T as TotalFloat>::SafeLen

The type representing the safe length for a RangeSetBlaze. For example, the length of a RangeSetBlaze<u8> is u16 to handle ranges up to 256 elements. For larger types like u128, this is represented by a custom type UIntPlusOne<u128>.

fn checked_add_one(self) -> Option<Self>

Attempts to add one to the current value, returning None if the operation would overflow.

fn add_one(self) -> Self

Adds one to the current value, panicking in debug mode if the operation overflows.

fn sub_one(self) -> Self

Subtracts one from the current value, panicking in debug mode if the operation underflows.

fn assign_sub_one(&mut self)

Subtracts one from the current value and assigns it back to self.

fn range_next(range: &mut RangeInclusive<Self>) -> Option<Self>

Advances the iterator for the given range by one step, returning the next value or None if the range is exhausted.

fn range_next_back(range: &mut RangeInclusive<Self>) -> Option<Self>

Advances the iterator for the given range in reverse by one step, returning the previous value or None if the range is exhausted.

fn min_value() -> Self

Returns the minimum value that can be represented by the type.

fn max_value() -> Self

Returns the maximum value that can be represented by the type.

fn from_slice(slice: impl AsRef<[Self]>) -> RangeSetBlaze<Self>

Creates a RangeSetBlaze from a slice, specific to the integer type.

fn safe_len(r: &RangeInclusive<Self>) -> Self::SafeLen

Calculates the length of a range without overflow.

fn safe_len_to_f64_lossy(len: Self::SafeLen) -> f64

Converts Integer::SafeLen to f64, potentially losing precision for large values.

fn f64_to_safe_len_lossy(f: f64) -> Self::SafeLen

Converts a f64 to Integer::SafeLen using the formula f as Self::SafeLen. For large integer types, this will result in a loss of precision.

fn inclusive_end_from_start(self, b: Self::SafeLen) -> Self

Computes self + (b - 1) where b is of type Integer::SafeLen.

fn start_from_inclusive_end(self, b: Self::SafeLen) -> Self

Computes self - (b - 1) where b is of type Integer::SafeLen.

fn exhausted_range() -> RangeInclusive<Self>

Returns an exhausted range, which is a range that starts from the maximum value and ends at the minimum value. This results in an empty range.

impl<T: TotalFloat> Ord for Total<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: TotalFloat> PartialEq for Total<T>

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

Equality operator ==.

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

Inequality operator !=.

impl<T: TotalFloat> PartialOrd for Total<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.