```
#[repr(C)]pub struct Rangef {
pub min: f32,
pub max: f32,
}
```

## Expand description

Inclusive range of floats, i.e. `min..=max`

, but more ergonomic than `RangeInclusive`

.

## Fields§

§`min: f32`

§`max: f32`

## Implementations§

source§### impl Rangef

### impl Rangef

source#### pub const EVERYTHING: Self = _

#### pub const EVERYTHING: Self = _

Infinite range that contains everything, from -∞ to +∞, inclusive.

source#### pub const NOTHING: Self = _

#### pub const NOTHING: Self = _

The inverse of `Self::EVERYTHING`

: stretches from positive infinity to negative infinity.
Contains nothing.

#### pub fn new(min: f32, max: f32) -> Self

#### pub fn point(min_and_max: f32) -> Self

#### pub fn contains(self, x: f32) -> bool

source#### pub fn as_positive(self) -> Self

#### pub fn as_positive(self) -> Self

Flip `min`

and `max`

if needed, so that `min <= max`

after.

source#### pub fn intersection(self, other: Self) -> Self

#### pub fn intersection(self, other: Self) -> Self

The overlap of two ranges, i.e. the range that is contained by both.

If the ranges do not overlap, returns a range with `span() < 0.0`

.

```
assert_eq!(Rangef::new(0.0, 10.0).intersection(Rangef::new(5.0, 15.0)), Rangef::new(5.0, 10.0));
assert_eq!(Rangef::new(0.0, 10.0).intersection(Rangef::new(10.0, 20.0)), Rangef::new(10.0, 10.0));
assert!(Rangef::new(0.0, 10.0).intersection(Rangef::new(20.0, 30.0)).span() < 0.0);
```

source#### pub fn intersects(self, other: Self) -> bool

#### pub fn intersects(self, other: Self) -> bool

Do the two ranges intersect?

```
assert!(Rangef::new(0.0, 10.0).intersects(Rangef::new(5.0, 15.0)));
assert!(Rangef::new(0.0, 10.0).intersects(Rangef::new(5.0, 6.0)));
assert!(Rangef::new(0.0, 10.0).intersects(Rangef::new(10.0, 20.0)));
assert!(!Rangef::new(0.0, 10.0).intersects(Rangef::new(20.0, 30.0)));
```

## Trait Implementations§

source§### impl From<&RangeInclusive<f32>> for Rangef

### impl From<&RangeInclusive<f32>> for Rangef

source§#### fn from(range: &RangeInclusive<f32>) -> Self

#### fn from(range: &RangeInclusive<f32>) -> Self

Converts to this type from the input type.

source§### impl From<RangeInclusive<f32>> for Rangef

### impl From<RangeInclusive<f32>> for Rangef

source§#### fn from(range: RangeInclusive<f32>) -> Self

#### fn from(range: RangeInclusive<f32>) -> Self

Converts to this type from the input type.

source§### impl From<RangeToInclusive<f32>> for Rangef

### impl From<RangeToInclusive<f32>> for Rangef

source§#### fn from(range: RangeToInclusive<f32>) -> Self

#### fn from(range: RangeToInclusive<f32>) -> Self

Converts to this type from the input type.

source§### impl PartialEq<RangeInclusive<f32>> for Rangef

### impl PartialEq<RangeInclusive<f32>> for Rangef

source§### impl PartialEq<Rangef> for RangeInclusive<f32>

### impl PartialEq<Rangef> for RangeInclusive<f32>

source§### impl PartialEq for Rangef

### impl PartialEq for Rangef

### impl Copy for Rangef

### impl Pod for Rangef

### impl StructuralPartialEq for Rangef

## Auto Trait Implementations§

### impl Freeze for Rangef

### impl RefUnwindSafe for Rangef

### impl Send for Rangef

### impl Sync for Rangef

### impl Unpin for Rangef

### impl UnwindSafe for Rangef

## Blanket Implementations§

source§### impl<T> BorrowMut<T> for Twhere
T: ?Sized,

### impl<T> BorrowMut<T> for Twhere
T: ?Sized,

source§#### fn borrow_mut(&mut self) -> &mut T

#### fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

source§### impl<T> CheckedBitPattern for Twhere
T: AnyBitPattern,

### impl<T> CheckedBitPattern for Twhere
T: AnyBitPattern,

§#### type Bits = T

#### type Bits = T

`Self`

*must*have the same layout as the specified

`Bits`

except for
the possible invalid bit patterns being checked during
`is_valid_bit_pattern`

.source§#### fn is_valid_bit_pattern(_bits: &T) -> bool

#### fn is_valid_bit_pattern(_bits: &T) -> bool

If this function returns true, then it must be valid to reinterpret

`bits`

as `&Self`

.