replace {min,max}_value() by {MIN,MAX}
This commit is contained in:
parent
91bd73bca4
commit
e1febebb31
|
@ -76,10 +76,15 @@ The conversions supported cover the following cases.
|
||||||
|
|
||||||
### Version 0.5.5 news (unreleased)
|
### Version 0.5.5 news (unreleased)
|
||||||
|
|
||||||
|
* The associated constants [`MIN`] and [`MAX`] were added to all
|
||||||
|
fixed-point types, to the [`Fixed`] trait, and to the [`Wrapping`]
|
||||||
|
wrapper.
|
||||||
* The methods [`int_log2`] and [`checked_int_log2`] were added to
|
* The methods [`int_log2`] and [`checked_int_log2`] were added to
|
||||||
all fixed-point types and to the [`Fixed`] trait.
|
all fixed-point types and to the [`Fixed`] trait.
|
||||||
* The method [`int_log2`][wril] was added to the [`Wrapping`]
|
* The method [`int_log2`][wril] was added to the [`Wrapping`]
|
||||||
wrapper.
|
wrapper.
|
||||||
|
* The following methods were deprecated:
|
||||||
|
* [`min_value`], [`max_value`]
|
||||||
|
|
||||||
### Version 0.5.4 news (2020-02-21)
|
### Version 0.5.4 news (2020-02-21)
|
||||||
|
|
||||||
|
@ -115,6 +120,8 @@ The conversions supported cover the following cases.
|
||||||
* [`Wrapping`] now supports serialization. (Thanks: Shane Pearman)
|
* [`Wrapping`] now supports serialization. (Thanks: Shane Pearman)
|
||||||
|
|
||||||
[`Fixed`]: https://docs.rs/fixed/0.5.4/fixed/traits/trait.Fixed.html
|
[`Fixed`]: https://docs.rs/fixed/0.5.4/fixed/traits/trait.Fixed.html
|
||||||
|
[`MAX`]: https://docs.rs/fixed/0.5.4/fixed/struct.FixedI32.html#associatedconstant.MAX
|
||||||
|
[`MIN`]: https://docs.rs/fixed/0.5.4/fixed/struct.FixedI32.html#associatedconstant.MIN
|
||||||
[`RemAssign`]: https://doc.rust-lang.org/nightly/core/ops/trait.RemAssign.html
|
[`RemAssign`]: https://doc.rust-lang.org/nightly/core/ops/trait.RemAssign.html
|
||||||
[`Rem`]: https://doc.rust-lang.org/nightly/core/ops/trait.Rem.html
|
[`Rem`]: https://doc.rust-lang.org/nightly/core/ops/trait.Rem.html
|
||||||
[`Wrapping`]: https://docs.rs/fixed/0.5.4/fixed/struct.Wrapping.html
|
[`Wrapping`]: https://docs.rs/fixed/0.5.4/fixed/struct.Wrapping.html
|
||||||
|
@ -124,6 +131,8 @@ The conversions supported cover the following cases.
|
||||||
[`checked_rem`]: https://docs.rs/fixed/0.5.4/fixed/struct.FixedI32.html#method.checked_rem
|
[`checked_rem`]: https://docs.rs/fixed/0.5.4/fixed/struct.FixedI32.html#method.checked_rem
|
||||||
[`div_euclid`]: https://docs.rs/fixed/0.5.4/fixed/struct.FixedI32.html#method.div_euclid
|
[`div_euclid`]: https://docs.rs/fixed/0.5.4/fixed/struct.FixedI32.html#method.div_euclid
|
||||||
[`int_log2`]: https://docs.rs/fixed/0.5.4/fixed/struct.FixedI32.html#method.int_log2
|
[`int_log2`]: https://docs.rs/fixed/0.5.4/fixed/struct.FixedI32.html#method.int_log2
|
||||||
|
[`max_value`]: https://docs.rs/fixed/0.5.4/fixed/struct.FixedI32.html#method.max_value
|
||||||
|
[`min_value`]: https://docs.rs/fixed/0.5.4/fixed/struct.FixedI32.html#method.min_value
|
||||||
[`overflowing_div_euclid`]: https://docs.rs/fixed/0.5.4/fixed/struct.FixedI32.html#method.overflowing_div_euclid
|
[`overflowing_div_euclid`]: https://docs.rs/fixed/0.5.4/fixed/struct.FixedI32.html#method.overflowing_div_euclid
|
||||||
[`overflowing_rem_int`]: https://docs.rs/fixed/0.5.4/fixed/struct.FixedI32.html#method.overflowing_rem_int
|
[`overflowing_rem_int`]: https://docs.rs/fixed/0.5.4/fixed/struct.FixedI32.html#method.overflowing_rem_int
|
||||||
[`rem_euclid_int`]: https://docs.rs/fixed/0.5.4/fixed/struct.FixedI32.html#method.rem_euclid_int
|
[`rem_euclid_int`]: https://docs.rs/fixed/0.5.4/fixed/struct.FixedI32.html#method.rem_euclid_int
|
||||||
|
|
|
@ -8,9 +8,14 @@ as-is, without any warranty. -->
|
||||||
Version 0.5.5 (unreleased)
|
Version 0.5.5 (unreleased)
|
||||||
==========================
|
==========================
|
||||||
|
|
||||||
|
* The associated constants `MIN` and `MAX` were added to all
|
||||||
|
fixed-point types, to the `Fixed` trait, and to the `Wrapping`
|
||||||
|
wrapper.
|
||||||
* The methods `int_log2` and `checked_int_log2` were added to all
|
* The methods `int_log2` and `checked_int_log2` were added to all
|
||||||
fixed-point types and to the `Fixed` trait.
|
fixed-point types and to the `Fixed` trait.
|
||||||
* The method `int_log2` was added to the `Wrapping` wrapper.
|
* The method `int_log2` was added to the `Wrapping` wrapper.
|
||||||
|
* The following methods were deprecated:
|
||||||
|
* `min_value`, `max_value`
|
||||||
|
|
||||||
Version 0.5.4 (2020-02-21)
|
Version 0.5.4 (2020-02-21)
|
||||||
==========================
|
==========================
|
||||||
|
|
10
src/arith.rs
10
src/arith.rs
|
@ -268,7 +268,7 @@ macro_rules! fixed_arith {
|
||||||
|
|
||||||
refs_assign! { impl DivAssign for $Fixed($LeEqU) { div_assign } }
|
refs_assign! { impl DivAssign for $Fixed($LeEqU) { div_assign } }
|
||||||
|
|
||||||
// do not pass! { Rem }, as I::min_value() % I::from(-1) should return 0, not panic
|
// do not pass! { Rem }, as I::MIN % I::from(-1) should return 0, not panic
|
||||||
impl<Frac> Rem<$Fixed<Frac>> for $Fixed<Frac> {
|
impl<Frac> Rem<$Fixed<Frac>> for $Fixed<Frac> {
|
||||||
type Output = $Fixed<Frac>;
|
type Output = $Fixed<Frac>;
|
||||||
#[inline]
|
#[inline]
|
||||||
|
@ -828,10 +828,10 @@ mod tests {
|
||||||
I0F32::from_num(f)
|
I0F32::from_num(f)
|
||||||
}
|
}
|
||||||
|
|
||||||
assert_eq!(I16F16::min_value() % -1, 0);
|
assert_eq!(I16F16::MIN % -1, 0);
|
||||||
assert_eq!(I16F16::min_value().checked_rem_int(-1).unwrap(), 0);
|
assert_eq!(I16F16::MIN.checked_rem_int(-1).unwrap(), 0);
|
||||||
assert_eq!(I16F16::min_value().rem_euclid_int(-1), 0);
|
assert_eq!(I16F16::MIN.rem_euclid_int(-1), 0);
|
||||||
assert_eq!(I16F16::min_value().checked_rem_euclid_int(-1).unwrap(), 0);
|
assert_eq!(I16F16::MIN.checked_rem_euclid_int(-1).unwrap(), 0);
|
||||||
|
|
||||||
assert_eq!(i1(-1.0) % 1, i1(0.0));
|
assert_eq!(i1(-1.0) % 1, i1(0.0));
|
||||||
assert_eq!(i1(-1.0).rem_euclid_int(1), i1(0.0));
|
assert_eq!(i1(-1.0).rem_euclid_int(1), i1(0.0));
|
||||||
|
|
|
@ -1056,9 +1056,9 @@ mod tests {
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn to_size() {
|
fn to_size() {
|
||||||
let min_i24 = I24F8::min_value();
|
let min_i24 = I24F8::MIN;
|
||||||
let max_i24 = I24F8::max_value();
|
let max_i24 = I24F8::MAX;
|
||||||
let max_u24 = U24F8::max_value();
|
let max_u24 = U24F8::MAX;
|
||||||
assert_eq!(min_i24.overflowing_to_num::<isize>(), (!0 << 23, false));
|
assert_eq!(min_i24.overflowing_to_num::<isize>(), (!0 << 23, false));
|
||||||
assert_eq!(max_i24.overflowing_to_num::<isize>(), (!(!0 << 23), false));
|
assert_eq!(max_i24.overflowing_to_num::<isize>(), (!(!0 << 23), false));
|
||||||
assert_eq!(max_u24.overflowing_to_num::<isize>(), (!(!0 << 24), false));
|
assert_eq!(max_u24.overflowing_to_num::<isize>(), (!(!0 << 24), false));
|
||||||
|
@ -1066,9 +1066,9 @@ mod tests {
|
||||||
assert_eq!(max_i24.overflowing_to_num::<usize>(), (!(!0 << 23), false));
|
assert_eq!(max_i24.overflowing_to_num::<usize>(), (!(!0 << 23), false));
|
||||||
assert_eq!(max_u24.overflowing_to_num::<usize>(), (!(!0 << 24), false));
|
assert_eq!(max_u24.overflowing_to_num::<usize>(), (!(!0 << 24), false));
|
||||||
|
|
||||||
let min_i56 = I56F8::min_value();
|
let min_i56 = I56F8::MIN;
|
||||||
let max_i56 = I56F8::max_value();
|
let max_i56 = I56F8::MAX;
|
||||||
let max_u56 = U56F8::max_value();
|
let max_u56 = U56F8::MAX;
|
||||||
#[cfg(target_pointer_width = "32")]
|
#[cfg(target_pointer_width = "32")]
|
||||||
{
|
{
|
||||||
assert_eq!(min_i56.overflowing_to_num::<isize>(), (0, true));
|
assert_eq!(min_i56.overflowing_to_num::<isize>(), (0, true));
|
||||||
|
@ -1088,9 +1088,9 @@ mod tests {
|
||||||
assert_eq!(max_u56.overflowing_to_num::<usize>(), (!(!0 << 56), false));
|
assert_eq!(max_u56.overflowing_to_num::<usize>(), (!(!0 << 56), false));
|
||||||
}
|
}
|
||||||
|
|
||||||
let min_i120 = I120F8::min_value();
|
let min_i120 = I120F8::MIN;
|
||||||
let max_i120 = I120F8::max_value();
|
let max_i120 = I120F8::MAX;
|
||||||
let max_u120 = U120F8::max_value();
|
let max_u120 = U120F8::MAX;
|
||||||
assert_eq!(min_i120.overflowing_to_num::<isize>(), (0, true));
|
assert_eq!(min_i120.overflowing_to_num::<isize>(), (0, true));
|
||||||
assert_eq!(max_i120.overflowing_to_num::<isize>(), (!0, true));
|
assert_eq!(max_i120.overflowing_to_num::<isize>(), (!0, true));
|
||||||
assert_eq!(max_u120.overflowing_to_num::<isize>(), (!0, true));
|
assert_eq!(max_u120.overflowing_to_num::<isize>(), (!0, true));
|
||||||
|
@ -1336,7 +1336,7 @@ mod tests {
|
||||||
fn to_infinite_f32() {
|
fn to_infinite_f32() {
|
||||||
// too_large is 1.ffff_ffff_ffff... << 127,
|
// too_large is 1.ffff_ffff_ffff... << 127,
|
||||||
// which will be rounded to 1.0 << 128.
|
// which will be rounded to 1.0 << 128.
|
||||||
let too_large = U128F0::max_value();
|
let too_large = U128F0::MAX;
|
||||||
assert_eq!(too_large.count_ones(), 128);
|
assert_eq!(too_large.count_ones(), 128);
|
||||||
assert!(too_large.to_num::<f32>().is_infinite());
|
assert!(too_large.to_num::<f32>().is_infinite());
|
||||||
|
|
||||||
|
@ -1355,7 +1355,7 @@ mod tests {
|
||||||
assert!(!not_too_large.to_num::<f32>().is_infinite());
|
assert!(!not_too_large.to_num::<f32>().is_infinite());
|
||||||
|
|
||||||
// min_128 is -1.0 << 127.
|
// min_128 is -1.0 << 127.
|
||||||
let min_i128 = I128F0::min_value();
|
let min_i128 = I128F0::MIN;
|
||||||
assert_eq!(min_i128.count_ones(), 1);
|
assert_eq!(min_i128.count_ones(), 1);
|
||||||
assert_eq!(min_i128.to_num::<f32>(), -(127f32.exp2()));
|
assert_eq!(min_i128.to_num::<f32>(), -(127f32.exp2()));
|
||||||
}
|
}
|
||||||
|
|
|
@ -676,9 +676,9 @@ macro_rules! impl_from_str_traits {
|
||||||
Ok((val, false)) => Ok(val),
|
Ok((val, false)) => Ok(val),
|
||||||
Ok((_, true)) => {
|
Ok((_, true)) => {
|
||||||
if s.starts_with('-') {
|
if s.starts_with('-') {
|
||||||
Ok(Self::min_value())
|
Ok(Self::MIN)
|
||||||
} else {
|
} else {
|
||||||
Ok(Self::max_value())
|
Ok(Self::MAX)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
Err(e) => Err(e),
|
Err(e) => Err(e),
|
||||||
|
|
|
@ -82,11 +82,7 @@ macro_rules! impl_sealed {
|
||||||
FloatKind::Infinite { neg } => neg,
|
FloatKind::Infinite { neg } => neg,
|
||||||
FloatKind::Finite { neg, .. } => neg,
|
FloatKind::Finite { neg, .. } => neg,
|
||||||
};
|
};
|
||||||
let saturated = if neg {
|
let saturated = if neg { Self::MIN } else { Self::MAX };
|
||||||
Self::min_value()
|
|
||||||
} else {
|
|
||||||
Self::max_value()
|
|
||||||
};
|
|
||||||
let conv = match src.kind {
|
let conv = match src.kind {
|
||||||
FloatKind::Finite { conv, .. } => conv,
|
FloatKind::Finite { conv, .. } => conv,
|
||||||
_ => return saturated,
|
_ => return saturated,
|
||||||
|
@ -100,7 +96,7 @@ macro_rules! impl_sealed {
|
||||||
Widest::Unsigned(bits) => {
|
Widest::Unsigned(bits) => {
|
||||||
let bits = bits as _;
|
let bits = bits as _;
|
||||||
if bits < 0 {
|
if bits < 0 {
|
||||||
return Self::max_value();
|
return Self::MAX;
|
||||||
}
|
}
|
||||||
bits
|
bits
|
||||||
}
|
}
|
||||||
|
@ -108,7 +104,7 @@ macro_rules! impl_sealed {
|
||||||
},
|
},
|
||||||
match conv.bits {
|
match conv.bits {
|
||||||
Widest::Unsigned(bits) => bits as _,
|
Widest::Unsigned(bits) => bits as _,
|
||||||
Widest::Negative(_) => return Self::min_value(),
|
Widest::Negative(_) => return Self::MIN,
|
||||||
},
|
},
|
||||||
};
|
};
|
||||||
Self::from_bits(bits)
|
Self::from_bits(bits)
|
||||||
|
|
|
@ -326,8 +326,8 @@ assert_eq!(Fix::from_num(7.5).rem_euclid_int(2), Fix::from_num(1.5));
|
||||||
```rust
|
```rust
|
||||||
use fixed::{types::extra::U4, ", $s_fixed, "};
|
use fixed::{types::extra::U4, ", $s_fixed, "};
|
||||||
type Fix = ", $s_fixed, "<U4>;
|
type Fix = ", $s_fixed, "<U4>;
|
||||||
assert_eq!(Fix::max_value().checked_mul(Fix::from_num(1)), Some(Fix::max_value()));
|
assert_eq!(Fix::MAX.checked_mul(Fix::from_num(1)), Some(Fix::MAX));
|
||||||
assert_eq!(Fix::max_value().checked_mul(Fix::from_num(2)), None);
|
assert_eq!(Fix::MAX.checked_mul(Fix::from_num(2)), None);
|
||||||
```
|
```
|
||||||
|
|
||||||
[`None`]: https://doc.rust-lang.org/nightly/core/option/enum.Option.html#variant.None
|
[`None`]: https://doc.rust-lang.org/nightly/core/option/enum.Option.html#variant.None
|
||||||
|
@ -350,8 +350,8 @@ the divisor is zero or on overflow.
|
||||||
```rust
|
```rust
|
||||||
use fixed::{types::extra::U4, ", $s_fixed, "};
|
use fixed::{types::extra::U4, ", $s_fixed, "};
|
||||||
type Fix = ", $s_fixed, "<U4>;
|
type Fix = ", $s_fixed, "<U4>;
|
||||||
assert_eq!(Fix::max_value().checked_div(Fix::from_num(1)), Some(Fix::max_value()));
|
assert_eq!(Fix::MAX.checked_div(Fix::from_num(1)), Some(Fix::MAX));
|
||||||
assert_eq!(Fix::max_value().checked_div(Fix::from_num(1) / 2), None);
|
assert_eq!(Fix::MAX.checked_div(Fix::from_num(1) / 2), None);
|
||||||
```
|
```
|
||||||
|
|
||||||
[`None`]: https://doc.rust-lang.org/nightly/core/option/enum.Option.html#variant.None
|
[`None`]: https://doc.rust-lang.org/nightly/core/option/enum.Option.html#variant.None
|
||||||
|
@ -379,7 +379,7 @@ use fixed::{types::extra::U4, ", $s_fixed, "};
|
||||||
type Fix = ", $s_fixed, "<U4>;
|
type Fix = ", $s_fixed, "<U4>;
|
||||||
assert_eq!(Fix::from_num(7.5).checked_div_euclid(Fix::from_num(2)), Some(Fix::from_num(3)));
|
assert_eq!(Fix::from_num(7.5).checked_div_euclid(Fix::from_num(2)), Some(Fix::from_num(3)));
|
||||||
assert_eq!(Fix::from_num(7.5).checked_div_euclid(Fix::from_num(0)), None);
|
assert_eq!(Fix::from_num(7.5).checked_div_euclid(Fix::from_num(0)), None);
|
||||||
assert_eq!(Fix::max_value().checked_div_euclid(Fix::from_num(0.25)), None);
|
assert_eq!(Fix::MAX.checked_div_euclid(Fix::from_num(0.25)), None);
|
||||||
",
|
",
|
||||||
if_signed_else_empty_str! {
|
if_signed_else_empty_str! {
|
||||||
$Signedness,
|
$Signedness,
|
||||||
|
@ -438,7 +438,7 @@ assert_eq!(Fix::from_num(3.75).checked_rem_int(0), None);
|
||||||
Some(fixed_rhs) => self.checked_rem(fixed_rhs),
|
Some(fixed_rhs) => self.checked_rem(fixed_rhs),
|
||||||
None => Some(if_signed_unsigned!(
|
None => Some(if_signed_unsigned!(
|
||||||
$Signedness,
|
$Signedness,
|
||||||
if self == Self::min_value()
|
if self == Self::MIN
|
||||||
&& (Self::INT_NBITS > 0 && rhs == 1 << (Self::INT_NBITS - 1))
|
&& (Self::INT_NBITS > 0 && rhs == 1 << (Self::INT_NBITS - 1))
|
||||||
{
|
{
|
||||||
Self::from_bits(0)
|
Self::from_bits(0)
|
||||||
|
@ -471,7 +471,7 @@ assert_eq!(Fix::from_num(7.5).checked_div_euclid_int(0), None);
|
||||||
",
|
",
|
||||||
if_signed_else_empty_str! {
|
if_signed_else_empty_str! {
|
||||||
$Signedness,
|
$Signedness,
|
||||||
"assert_eq!(Fix::min_value().checked_div_euclid_int(-1), None);
|
"assert_eq!(Fix::MIN.checked_div_euclid_int(-1), None);
|
||||||
",
|
",
|
||||||
},
|
},
|
||||||
"```
|
"```
|
||||||
|
@ -563,7 +563,7 @@ assert_eq!(Fix::from_num(-7.5).checked_rem_euclid_int(20), None);
|
||||||
use fixed::{types::extra::U4, ", $s_fixed, "};
|
use fixed::{types::extra::U4, ", $s_fixed, "};
|
||||||
type Fix = ", $s_fixed, "<U4>;
|
type Fix = ", $s_fixed, "<U4>;
|
||||||
assert_eq!(Fix::from_num(3).saturating_mul(Fix::from_num(2)), Fix::from_num(6));
|
assert_eq!(Fix::from_num(3).saturating_mul(Fix::from_num(2)), Fix::from_num(6));
|
||||||
assert_eq!(Fix::max_value().saturating_mul(Fix::from_num(2)), Fix::max_value());
|
assert_eq!(Fix::MAX.saturating_mul(Fix::from_num(2)), Fix::MAX);
|
||||||
```
|
```
|
||||||
";
|
";
|
||||||
#[inline]
|
#[inline]
|
||||||
|
@ -572,9 +572,9 @@ assert_eq!(Fix::max_value().saturating_mul(Fix::from_num(2)), Fix::max_value());
|
||||||
(ans, false) => Self::from_bits(ans),
|
(ans, false) => Self::from_bits(ans),
|
||||||
(_, true) => {
|
(_, true) => {
|
||||||
if (self < 0) != (rhs < 0) {
|
if (self < 0) != (rhs < 0) {
|
||||||
Self::min_value()
|
Self::MIN
|
||||||
} else {
|
} else {
|
||||||
Self::max_value()
|
Self::MAX
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -595,7 +595,7 @@ use fixed::{types::extra::U4, ", $s_fixed, "};
|
||||||
type Fix = ", $s_fixed, "<U4>;
|
type Fix = ", $s_fixed, "<U4>;
|
||||||
let one_half = Fix::from_num(1) / 2;
|
let one_half = Fix::from_num(1) / 2;
|
||||||
assert_eq!(Fix::from_num(1).saturating_div(Fix::from_num(2)), one_half);
|
assert_eq!(Fix::from_num(1).saturating_div(Fix::from_num(2)), one_half);
|
||||||
assert_eq!(Fix::max_value().saturating_div(one_half), Fix::max_value());
|
assert_eq!(Fix::MAX.saturating_div(one_half), Fix::MAX);
|
||||||
```
|
```
|
||||||
";
|
";
|
||||||
#[inline]
|
#[inline]
|
||||||
|
@ -604,9 +604,9 @@ assert_eq!(Fix::max_value().saturating_div(one_half), Fix::max_value());
|
||||||
(ans, false) => Self::from_bits(ans),
|
(ans, false) => Self::from_bits(ans),
|
||||||
(_, true) => {
|
(_, true) => {
|
||||||
if (self < 0) != (rhs < 0) {
|
if (self < 0) != (rhs < 0) {
|
||||||
Self::min_value()
|
Self::MIN
|
||||||
} else {
|
} else {
|
||||||
Self::max_value()
|
Self::MAX
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -627,12 +627,12 @@ Panics if the divisor is zero.
|
||||||
use fixed::{types::extra::U4, ", $s_fixed, "};
|
use fixed::{types::extra::U4, ", $s_fixed, "};
|
||||||
type Fix = ", $s_fixed, "<U4>;
|
type Fix = ", $s_fixed, "<U4>;
|
||||||
assert_eq!(Fix::from_num(7.5).saturating_div_euclid(Fix::from_num(2)), Fix::from_num(3));
|
assert_eq!(Fix::from_num(7.5).saturating_div_euclid(Fix::from_num(2)), Fix::from_num(3));
|
||||||
assert_eq!(Fix::max_value().saturating_div_euclid(Fix::from_num(0.25)), Fix::max_value());
|
assert_eq!(Fix::MAX.saturating_div_euclid(Fix::from_num(0.25)), Fix::MAX);
|
||||||
",
|
",
|
||||||
if_signed_else_empty_str! {
|
if_signed_else_empty_str! {
|
||||||
$Signedness,
|
$Signedness,
|
||||||
"assert_eq!(Fix::from_num(-7.5).saturating_div_euclid(Fix::from_num(2)), Fix::from_num(-4));
|
"assert_eq!(Fix::from_num(-7.5).saturating_div_euclid(Fix::from_num(2)), Fix::from_num(-4));
|
||||||
assert_eq!(Fix::min_value().saturating_div_euclid(Fix::from_num(0.25)), Fix::min_value());
|
assert_eq!(Fix::MIN.saturating_div_euclid(Fix::from_num(0.25)), Fix::MIN);
|
||||||
",
|
",
|
||||||
},
|
},
|
||||||
"```
|
"```
|
||||||
|
@ -646,9 +646,9 @@ assert_eq!(Fix::min_value().saturating_div_euclid(Fix::from_num(0.25)), Fix::min
|
||||||
}
|
}
|
||||||
self.checked_div_euclid(rhs).unwrap_or_else(|| {
|
self.checked_div_euclid(rhs).unwrap_or_else(|| {
|
||||||
if (self.to_bits() > 0) == (rhs.to_bits() > 0) {
|
if (self.to_bits() > 0) == (rhs.to_bits() > 0) {
|
||||||
Self::max_value()
|
Self::MAX
|
||||||
} else {
|
} else {
|
||||||
Self::min_value()
|
Self::MIN
|
||||||
}
|
}
|
||||||
})
|
})
|
||||||
}
|
}
|
||||||
|
@ -664,7 +664,7 @@ use fixed::{types::extra::U4, ", $s_fixed, "};
|
||||||
type Fix = ", $s_fixed, "<U4>;
|
type Fix = ", $s_fixed, "<U4>;
|
||||||
assert_eq!(Fix::from_num(3).wrapping_mul(Fix::from_num(2)), Fix::from_num(6));
|
assert_eq!(Fix::from_num(3).wrapping_mul(Fix::from_num(2)), Fix::from_num(6));
|
||||||
let wrapped = Fix::from_bits(!0 << 2);
|
let wrapped = Fix::from_bits(!0 << 2);
|
||||||
assert_eq!(Fix::max_value().wrapping_mul(Fix::from_num(4)), wrapped);
|
assert_eq!(Fix::MAX.wrapping_mul(Fix::from_num(4)), wrapped);
|
||||||
```
|
```
|
||||||
";
|
";
|
||||||
#[inline]
|
#[inline]
|
||||||
|
@ -690,7 +690,7 @@ let one_point_5 = Fix::from_bits(0b11 << (4 - 1));
|
||||||
assert_eq!(Fix::from_num(3).wrapping_div(Fix::from_num(2)), one_point_5);
|
assert_eq!(Fix::from_num(3).wrapping_div(Fix::from_num(2)), one_point_5);
|
||||||
let quarter = Fix::from_num(1) / 4;
|
let quarter = Fix::from_num(1) / 4;
|
||||||
let wrapped = Fix::from_bits(!0 << 2);
|
let wrapped = Fix::from_bits(!0 << 2);
|
||||||
assert_eq!(Fix::max_value().wrapping_div(quarter), wrapped);
|
assert_eq!(Fix::MAX.wrapping_div(quarter), wrapped);
|
||||||
```
|
```
|
||||||
";
|
";
|
||||||
#[inline]
|
#[inline]
|
||||||
|
@ -713,8 +713,8 @@ Panics if the divisor is zero.
|
||||||
use fixed::{types::extra::U4, ", $s_fixed, "};
|
use fixed::{types::extra::U4, ", $s_fixed, "};
|
||||||
type Fix = ", $s_fixed, "<U4>;
|
type Fix = ", $s_fixed, "<U4>;
|
||||||
assert_eq!(Fix::from_num(7.5).wrapping_div_euclid(Fix::from_num(2)), Fix::from_num(3));
|
assert_eq!(Fix::from_num(7.5).wrapping_div_euclid(Fix::from_num(2)), Fix::from_num(3));
|
||||||
let wrapped = Fix::max_value().wrapping_mul_int(4).round_to_zero();
|
let wrapped = Fix::MAX.wrapping_mul_int(4).round_to_zero();
|
||||||
assert_eq!(Fix::max_value().wrapping_div_euclid(Fix::from_num(0.25)), wrapped);
|
assert_eq!(Fix::MAX.wrapping_div_euclid(Fix::from_num(0.25)), wrapped);
|
||||||
```
|
```
|
||||||
";
|
";
|
||||||
#[inline]
|
#[inline]
|
||||||
|
@ -750,8 +750,8 @@ assert_eq!(Fix::from_num(7.5).wrapping_div_euclid_int(2), Fix::from_num(3));
|
||||||
if_signed_else_empty_str! {
|
if_signed_else_empty_str! {
|
||||||
$Signedness,
|
$Signedness,
|
||||||
"assert_eq!(Fix::from_num(-7.5).wrapping_div_euclid_int(2), Fix::from_num(-4));
|
"assert_eq!(Fix::from_num(-7.5).wrapping_div_euclid_int(2), Fix::from_num(-4));
|
||||||
let wrapped = Fix::min_value().round_to_zero();
|
let wrapped = Fix::MIN.round_to_zero();
|
||||||
assert_eq!(Fix::min_value().wrapping_div_euclid_int(-1), wrapped);
|
assert_eq!(Fix::MIN.wrapping_div_euclid_int(-1), wrapped);
|
||||||
",
|
",
|
||||||
},
|
},
|
||||||
"```
|
"```
|
||||||
|
@ -815,7 +815,7 @@ use fixed::{types::extra::U4, ", $s_fixed, "};
|
||||||
type Fix = ", $s_fixed, "<U4>;
|
type Fix = ", $s_fixed, "<U4>;
|
||||||
assert_eq!(Fix::from_num(3).overflowing_mul(Fix::from_num(2)), (Fix::from_num(6), false));
|
assert_eq!(Fix::from_num(3).overflowing_mul(Fix::from_num(2)), (Fix::from_num(6), false));
|
||||||
let wrapped = Fix::from_bits(!0 << 2);
|
let wrapped = Fix::from_bits(!0 << 2);
|
||||||
assert_eq!(Fix::max_value().overflowing_mul(Fix::from_num(4)), (wrapped, true));
|
assert_eq!(Fix::MAX.overflowing_mul(Fix::from_num(4)), (wrapped, true));
|
||||||
```
|
```
|
||||||
|
|
||||||
[`bool`]: https://doc.rust-lang.org/nightly/std/primitive.bool.html
|
[`bool`]: https://doc.rust-lang.org/nightly/std/primitive.bool.html
|
||||||
|
@ -847,7 +847,7 @@ let one_point_5 = Fix::from_bits(0b11 << (4 - 1));
|
||||||
assert_eq!(Fix::from_num(3).overflowing_div(Fix::from_num(2)), (one_point_5, false));
|
assert_eq!(Fix::from_num(3).overflowing_div(Fix::from_num(2)), (one_point_5, false));
|
||||||
let quarter = Fix::from_num(1) / 4;
|
let quarter = Fix::from_num(1) / 4;
|
||||||
let wrapped = Fix::from_bits(!0 << 2);
|
let wrapped = Fix::from_bits(!0 << 2);
|
||||||
assert_eq!(Fix::max_value().overflowing_div(quarter), (wrapped, true));
|
assert_eq!(Fix::MAX.overflowing_div(quarter), (wrapped, true));
|
||||||
```
|
```
|
||||||
|
|
||||||
[`bool`]: https://doc.rust-lang.org/nightly/std/primitive.bool.html
|
[`bool`]: https://doc.rust-lang.org/nightly/std/primitive.bool.html
|
||||||
|
@ -877,8 +877,8 @@ use fixed::{types::extra::U4, ", $s_fixed, "};
|
||||||
type Fix = ", $s_fixed, "<U4>;
|
type Fix = ", $s_fixed, "<U4>;
|
||||||
let check = Fix::from_num(3);
|
let check = Fix::from_num(3);
|
||||||
assert_eq!(Fix::from_num(7.5).overflowing_div_euclid(Fix::from_num(2)), (check, false));
|
assert_eq!(Fix::from_num(7.5).overflowing_div_euclid(Fix::from_num(2)), (check, false));
|
||||||
let wrapped = Fix::max_value().wrapping_mul_int(4).round_to_zero();
|
let wrapped = Fix::MAX.wrapping_mul_int(4).round_to_zero();
|
||||||
assert_eq!(Fix::max_value().overflowing_div_euclid(Fix::from_num(0.25)), (wrapped, true));
|
assert_eq!(Fix::MAX.overflowing_div_euclid(Fix::from_num(0.25)), (wrapped, true));
|
||||||
```
|
```
|
||||||
|
|
||||||
[`bool`]: https://doc.rust-lang.org/nightly/std/primitive.bool.html
|
[`bool`]: https://doc.rust-lang.org/nightly/std/primitive.bool.html
|
||||||
|
@ -938,8 +938,8 @@ assert_eq!(Fix::from_num(7.5).overflowing_div_euclid_int(2), (Fix::from_num(3),
|
||||||
if_signed_else_empty_str! {
|
if_signed_else_empty_str! {
|
||||||
$Signedness,
|
$Signedness,
|
||||||
"assert_eq!(Fix::from_num(-7.5).overflowing_div_euclid_int(2), (Fix::from_num(-4), false));
|
"assert_eq!(Fix::from_num(-7.5).overflowing_div_euclid_int(2), (Fix::from_num(-4), false));
|
||||||
let wrapped = Fix::min_value().round_to_zero();
|
let wrapped = Fix::MIN.round_to_zero();
|
||||||
assert_eq!(Fix::min_value().overflowing_div_euclid_int(-1), (wrapped, true));
|
assert_eq!(Fix::MIN.overflowing_div_euclid_int(-1), (wrapped, true));
|
||||||
",
|
",
|
||||||
},
|
},
|
||||||
"```
|
"```
|
||||||
|
|
|
@ -183,6 +183,8 @@ assert_eq!(",
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// TODO when rustc requirement >= 1.43.0, use {MIN,MAX}
|
||||||
|
// instead of {min,max}_value() in example
|
||||||
comment! {
|
comment! {
|
||||||
"Creates a fixed-point number from another number if it
|
"Creates a fixed-point number from another number if it
|
||||||
fits, otherwise returns [`None`].
|
fits, otherwise returns [`None`].
|
||||||
|
@ -213,7 +215,7 @@ type Fix = ", $s_fixed, "<U4>;
|
||||||
// 1.75 is 1.11 in binary
|
// 1.75 is 1.11 in binary
|
||||||
let src = I16F16::from_bits(0b111 << (16 - 2));
|
let src = I16F16::from_bits(0b111 << (16 - 2));
|
||||||
assert_eq!(Fix::checked_from_num(src), Some(Fix::from_bits(0b111 << (4 - 2))));
|
assert_eq!(Fix::checked_from_num(src), Some(Fix::from_bits(0b111 << (4 - 2))));
|
||||||
let too_large = ", $s_fixed, "::<U2>::max_value();
|
let too_large = ", $s_fixed, "::<U2>::MAX;
|
||||||
assert!(Fix::checked_from_num(too_large).is_none());
|
assert!(Fix::checked_from_num(too_large).is_none());
|
||||||
|
|
||||||
assert_eq!(Fix::checked_from_num(3), Some(Fix::from_bits(3 << 4)));
|
assert_eq!(Fix::checked_from_num(3), Some(Fix::from_bits(3 << 4)));
|
||||||
|
@ -302,7 +304,7 @@ let src = Fix::from_bits(0b111 << (4 - 2));
|
||||||
let expected = I16F16::from_bits(0b111 << (16 - 2));
|
let expected = I16F16::from_bits(0b111 << (16 - 2));
|
||||||
assert_eq!(src.checked_to_num::<I16F16>(), Some(expected));
|
assert_eq!(src.checked_to_num::<I16F16>(), Some(expected));
|
||||||
type TooFewIntBits = ", $s_fixed, "<U6>;
|
type TooFewIntBits = ", $s_fixed, "<U6>;
|
||||||
assert!(Fix::max_value().checked_to_num::<TooFewIntBits>().is_none());
|
assert!(Fix::MAX.checked_to_num::<TooFewIntBits>().is_none());
|
||||||
|
|
||||||
// 2.5 is 10.1 in binary
|
// 2.5 is 10.1 in binary
|
||||||
let two_point_5 = Fix::from_bits(0b101 << (4 - 1));
|
let two_point_5 = Fix::from_bits(0b101 << (4 - 1));
|
||||||
|
@ -319,7 +321,7 @@ assert!(AllInt::",
|
||||||
if_signed_unsigned! {
|
if_signed_unsigned! {
|
||||||
$Signedness,
|
$Signedness,
|
||||||
"from_bits(-1).checked_to_num::<u",
|
"from_bits(-1).checked_to_num::<u",
|
||||||
"max_value().checked_to_num::<i",
|
"MAX.checked_to_num::<i",
|
||||||
},
|
},
|
||||||
$s_nbits, ">().is_none());
|
$s_nbits, ">().is_none());
|
||||||
|
|
||||||
|
@ -355,6 +357,7 @@ assert_eq!(one_point_625.checked_to_num::<f32>(), Some(1.625f32));
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// TODO when rustc requirement >= 1.43.0, use MIN instead of min_value() in example
|
||||||
comment! {
|
comment! {
|
||||||
"Creates a fixed-point number from another number,
|
"Creates a fixed-point number from another number,
|
||||||
saturating if it does not fit.
|
saturating if it does not fit.
|
||||||
|
@ -390,8 +393,8 @@ type Fix = ", $s_fixed, "<U4>;
|
||||||
// 1.75 is 1.11 in binary
|
// 1.75 is 1.11 in binary
|
||||||
let src = I16F16::from_bits(0b111 << (16 - 2));
|
let src = I16F16::from_bits(0b111 << (16 - 2));
|
||||||
assert_eq!(Fix::saturating_from_num(src), Fix::from_bits(0b111 << (4 - 2)));
|
assert_eq!(Fix::saturating_from_num(src), Fix::from_bits(0b111 << (4 - 2)));
|
||||||
let too_large = ", $s_fixed, "::<U2>::max_value();
|
let too_large = ", $s_fixed, "::<U2>::MAX;
|
||||||
assert_eq!(Fix::saturating_from_num(too_large), Fix::max_value());
|
assert_eq!(Fix::saturating_from_num(too_large), Fix::MAX);
|
||||||
|
|
||||||
assert_eq!(Fix::saturating_from_num(3), Fix::from_bits(3 << 4));
|
assert_eq!(Fix::saturating_from_num(3), Fix::from_bits(3 << 4));
|
||||||
let too_small = ",
|
let too_small = ",
|
||||||
|
@ -401,7 +404,7 @@ let too_small = ",
|
||||||
"-1",
|
"-1",
|
||||||
},
|
},
|
||||||
";
|
";
|
||||||
assert_eq!(Fix::saturating_from_num(too_small), Fix::min_value());
|
assert_eq!(Fix::saturating_from_num(too_small), Fix::MIN);
|
||||||
|
|
||||||
// 1.75 is 1.11 in binary
|
// 1.75 is 1.11 in binary
|
||||||
let expected = Fix::from_bits(0b111 << (4 - 2));
|
let expected = Fix::from_bits(0b111 << (4 - 2));
|
||||||
|
@ -413,8 +416,8 @@ assert_eq!(Fix::saturating_from_num(",
|
||||||
"1.75f64), ",
|
"1.75f64), ",
|
||||||
},
|
},
|
||||||
"expected);
|
"expected);
|
||||||
assert_eq!(Fix::saturating_from_num(2e38), Fix::max_value());
|
assert_eq!(Fix::saturating_from_num(2e38), Fix::MAX);
|
||||||
assert_eq!(Fix::saturating_from_num(std::f64::NEG_INFINITY), Fix::min_value());
|
assert_eq!(Fix::saturating_from_num(std::f64::NEG_INFINITY), Fix::MIN);
|
||||||
```
|
```
|
||||||
|
|
||||||
[NaN]: https://doc.rust-lang.org/nightly/std/primitive.f64.html#method.is_nan
|
[NaN]: https://doc.rust-lang.org/nightly/std/primitive.f64.html#method.is_nan
|
||||||
|
@ -444,6 +447,7 @@ assert_eq!(Fix::saturating_from_num(std::f64::NEG_INFINITY), Fix::min_value());
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// TODO when rustc requirement >= 1.43.0, use MAX instead of max_value() in example
|
||||||
comment! {
|
comment! {
|
||||||
"Converts a fixed-point number to another number,
|
"Converts a fixed-point number to another number,
|
||||||
saturating the value if it does not fit.
|
saturating the value if it does not fit.
|
||||||
|
@ -477,8 +481,8 @@ let src = Fix::from_bits(0b111 << (4 - 2));
|
||||||
let expected = I16F16::from_bits(0b111 << (16 - 2));
|
let expected = I16F16::from_bits(0b111 << (16 - 2));
|
||||||
assert_eq!(src.saturating_to_num::<I16F16>(), expected);
|
assert_eq!(src.saturating_to_num::<I16F16>(), expected);
|
||||||
type TooFewIntBits = ", $s_fixed, "<U6>;
|
type TooFewIntBits = ", $s_fixed, "<U6>;
|
||||||
let saturated = Fix::max_value().saturating_to_num::<TooFewIntBits>();
|
let saturated = Fix::MAX.saturating_to_num::<TooFewIntBits>();
|
||||||
assert_eq!(saturated, TooFewIntBits::max_value());
|
assert_eq!(saturated, TooFewIntBits::MAX);
|
||||||
|
|
||||||
// 2.5 is 10.1 in binary
|
// 2.5 is 10.1 in binary
|
||||||
let two_point_5 = Fix::from_bits(0b101 << (4 - 1));
|
let two_point_5 = Fix::from_bits(0b101 << (4 - 1));
|
||||||
|
@ -489,7 +493,7 @@ assert_eq!(",
|
||||||
$Signedness,
|
$Signedness,
|
||||||
concat!("AllInt::from_bits(-1).saturating_to_num::<u", $s_nbits, ">(), 0"),
|
concat!("AllInt::from_bits(-1).saturating_to_num::<u", $s_nbits, ">(), 0"),
|
||||||
concat!(
|
concat!(
|
||||||
"AllInt::max_value().saturating_to_num::<i", $s_nbits, ">(), ",
|
"AllInt::MAX.saturating_to_num::<i", $s_nbits, ">(), ",
|
||||||
"i", $s_nbits, "::max_value()",
|
"i", $s_nbits, "::max_value()",
|
||||||
),
|
),
|
||||||
},
|
},
|
||||||
|
@ -606,6 +610,7 @@ assert_eq!(Fix::wrapping_from_num(large), wrapped);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// TODO when rustc requirement >= 1.43.0, use MAX instead of max_value() in example
|
||||||
comment! {
|
comment! {
|
||||||
"Converts a fixed-point number to another number,
|
"Converts a fixed-point number to another number,
|
||||||
wrapping the value on overflow.
|
wrapping the value on overflow.
|
||||||
|
@ -639,8 +644,8 @@ let src = Fix::from_bits(0b111 << (4 - 2));
|
||||||
let expected = I16F16::from_bits(0b111 << (16 - 2));
|
let expected = I16F16::from_bits(0b111 << (16 - 2));
|
||||||
assert_eq!(src.wrapping_to_num::<I16F16>(), expected);
|
assert_eq!(src.wrapping_to_num::<I16F16>(), expected);
|
||||||
type TooFewIntBits = ", $s_fixed, "<U6>;
|
type TooFewIntBits = ", $s_fixed, "<U6>;
|
||||||
let wrapped = TooFewIntBits::from_bits(Fix::max_value().to_bits() << 2);
|
let wrapped = TooFewIntBits::from_bits(Fix::MAX.to_bits() << 2);
|
||||||
assert_eq!(Fix::max_value().wrapping_to_num::<TooFewIntBits>(), wrapped);
|
assert_eq!(Fix::MAX.wrapping_to_num::<TooFewIntBits>(), wrapped);
|
||||||
|
|
||||||
// 2.5 is 10.1 in binary
|
// 2.5 is 10.1 in binary
|
||||||
let two_point_5 = Fix::from_bits(0b101 << (4 - 1));
|
let two_point_5 = Fix::from_bits(0b101 << (4 - 1));
|
||||||
|
@ -653,7 +658,7 @@ assert_eq!(",
|
||||||
"AllInt::from_bits(-1).wrapping_to_num::<u", $s_nbits, ">(), ",
|
"AllInt::from_bits(-1).wrapping_to_num::<u", $s_nbits, ">(), ",
|
||||||
"u", $s_nbits, "::max_value()",
|
"u", $s_nbits, "::max_value()",
|
||||||
),
|
),
|
||||||
concat!("AllInt::max_value().wrapping_to_num::<i", $s_nbits, ">(), -1"),
|
concat!("AllInt::MAX.wrapping_to_num::<i", $s_nbits, ">(), -1"),
|
||||||
},
|
},
|
||||||
");
|
");
|
||||||
|
|
||||||
|
@ -810,14 +815,14 @@ let src = Fix::from_bits(0b111 << (4 - 2));
|
||||||
let expected = I16F16::from_bits(0b111 << (16 - 2));
|
let expected = I16F16::from_bits(0b111 << (16 - 2));
|
||||||
assert_eq!(src.overflowing_to_num::<I16F16>(), (expected, false));
|
assert_eq!(src.overflowing_to_num::<I16F16>(), (expected, false));
|
||||||
type TooFewIntBits = ", $s_fixed, "<U6>;
|
type TooFewIntBits = ", $s_fixed, "<U6>;
|
||||||
let wrapped = TooFewIntBits::from_bits(Fix::max_value().to_bits() << 2);
|
let wrapped = TooFewIntBits::from_bits(Fix::MAX.to_bits() << 2);
|
||||||
assert_eq!(Fix::max_value().overflowing_to_num::<TooFewIntBits>(), (wrapped, true));
|
assert_eq!(Fix::MAX.overflowing_to_num::<TooFewIntBits>(), (wrapped, true));
|
||||||
|
|
||||||
// 2.5 is 10.1 in binary
|
// 2.5 is 10.1 in binary
|
||||||
let two_point_5 = Fix::from_bits(0b101 << (4 - 1));
|
let two_point_5 = Fix::from_bits(0b101 << (4 - 1));
|
||||||
assert_eq!(two_point_5.overflowing_to_num::<i32>(), (2, false));
|
assert_eq!(two_point_5.overflowing_to_num::<i32>(), (2, false));
|
||||||
let does_not_fit = ", $s_fixed, "::<U0>::",
|
let does_not_fit = ", $s_fixed, "::<U0>::",
|
||||||
if_signed_unsigned! { $Signedness, "from_bits(-1)", "max_value()" },
|
if_signed_unsigned! { $Signedness, "from_bits(-1)", "MAX" },
|
||||||
";
|
";
|
||||||
let wrapped = ",
|
let wrapped = ",
|
||||||
if_signed_unsigned! {
|
if_signed_unsigned! {
|
||||||
|
@ -963,11 +968,11 @@ Rounding is to the nearest, with ties rounded to even.
|
||||||
if_signed_unsigned! {
|
if_signed_unsigned! {
|
||||||
$Signedness,
|
$Signedness,
|
||||||
"use fixed::types::I8F8;
|
"use fixed::types::I8F8;
|
||||||
assert_eq!(I8F8::saturating_from_str(\"9999\"), Ok(I8F8::max_value()));
|
assert_eq!(I8F8::saturating_from_str(\"9999\"), Ok(I8F8::MAX));
|
||||||
assert_eq!(I8F8::saturating_from_str(\"-9999\"), Ok(I8F8::min_value()));
|
assert_eq!(I8F8::saturating_from_str(\"-9999\"), Ok(I8F8::MIN));
|
||||||
",
|
",
|
||||||
"use fixed::types::U8F8;
|
"use fixed::types::U8F8;
|
||||||
assert_eq!(U8F8::saturating_from_str(\"9999\"), Ok(U8F8::max_value()));
|
assert_eq!(U8F8::saturating_from_str(\"9999\"), Ok(U8F8::MAX));
|
||||||
assert_eq!(U8F8::saturating_from_str(\"-1\"), Ok(U8F8::from_num(0)));
|
assert_eq!(U8F8::saturating_from_str(\"-1\"), Ok(U8F8::from_num(0)));
|
||||||
",
|
",
|
||||||
},
|
},
|
||||||
|
@ -992,11 +997,11 @@ Rounding is to the nearest, with ties rounded to even.
|
||||||
if_signed_unsigned! {
|
if_signed_unsigned! {
|
||||||
$Signedness,
|
$Signedness,
|
||||||
"use fixed::types::I8F8;
|
"use fixed::types::I8F8;
|
||||||
assert_eq!(I8F8::saturating_from_str_binary(\"101100111000\"), Ok(I8F8::max_value()));
|
assert_eq!(I8F8::saturating_from_str_binary(\"101100111000\"), Ok(I8F8::MAX));
|
||||||
assert_eq!(I8F8::saturating_from_str_binary(\"-101100111000\"), Ok(I8F8::min_value()));
|
assert_eq!(I8F8::saturating_from_str_binary(\"-101100111000\"), Ok(I8F8::MIN));
|
||||||
",
|
",
|
||||||
"use fixed::types::U8F8;
|
"use fixed::types::U8F8;
|
||||||
assert_eq!(U8F8::saturating_from_str_binary(\"101100111000\"), Ok(U8F8::max_value()));
|
assert_eq!(U8F8::saturating_from_str_binary(\"101100111000\"), Ok(U8F8::MAX));
|
||||||
assert_eq!(U8F8::saturating_from_str_binary(\"-1\"), Ok(U8F8::from_num(0)));
|
assert_eq!(U8F8::saturating_from_str_binary(\"-1\"), Ok(U8F8::from_num(0)));
|
||||||
",
|
",
|
||||||
},
|
},
|
||||||
|
@ -1021,11 +1026,11 @@ Rounding is to the nearest, with ties rounded to even.
|
||||||
if_signed_unsigned! {
|
if_signed_unsigned! {
|
||||||
$Signedness,
|
$Signedness,
|
||||||
"use fixed::types::I8F8;
|
"use fixed::types::I8F8;
|
||||||
assert_eq!(I8F8::saturating_from_str_octal(\"7777\"), Ok(I8F8::max_value()));
|
assert_eq!(I8F8::saturating_from_str_octal(\"7777\"), Ok(I8F8::MAX));
|
||||||
assert_eq!(I8F8::saturating_from_str_octal(\"-7777\"), Ok(I8F8::min_value()));
|
assert_eq!(I8F8::saturating_from_str_octal(\"-7777\"), Ok(I8F8::MIN));
|
||||||
",
|
",
|
||||||
"use fixed::types::U8F8;
|
"use fixed::types::U8F8;
|
||||||
assert_eq!(U8F8::saturating_from_str_octal(\"7777\"), Ok(U8F8::max_value()));
|
assert_eq!(U8F8::saturating_from_str_octal(\"7777\"), Ok(U8F8::MAX));
|
||||||
assert_eq!(U8F8::saturating_from_str_octal(\"-1\"), Ok(U8F8::from_num(0)));
|
assert_eq!(U8F8::saturating_from_str_octal(\"-1\"), Ok(U8F8::from_num(0)));
|
||||||
",
|
",
|
||||||
},
|
},
|
||||||
|
@ -1050,11 +1055,11 @@ Rounding is to the nearest, with ties rounded to even.
|
||||||
if_signed_unsigned! {
|
if_signed_unsigned! {
|
||||||
$Signedness,
|
$Signedness,
|
||||||
"use fixed::types::I8F8;
|
"use fixed::types::I8F8;
|
||||||
assert_eq!(I8F8::saturating_from_str_hex(\"FFFF\"), Ok(I8F8::max_value()));
|
assert_eq!(I8F8::saturating_from_str_hex(\"FFFF\"), Ok(I8F8::MAX));
|
||||||
assert_eq!(I8F8::saturating_from_str_hex(\"-FFFF\"), Ok(I8F8::min_value()));
|
assert_eq!(I8F8::saturating_from_str_hex(\"-FFFF\"), Ok(I8F8::MIN));
|
||||||
",
|
",
|
||||||
"use fixed::types::U8F8;
|
"use fixed::types::U8F8;
|
||||||
assert_eq!(U8F8::saturating_from_str_hex(\"FFFF\"), Ok(U8F8::max_value()));
|
assert_eq!(U8F8::saturating_from_str_hex(\"FFFF\"), Ok(U8F8::MAX));
|
||||||
assert_eq!(U8F8::saturating_from_str_hex(\"-1\"), Ok(U8F8::from_num(0)));
|
assert_eq!(U8F8::saturating_from_str_hex(\"-1\"), Ok(U8F8::from_num(0)));
|
||||||
",
|
",
|
||||||
},
|
},
|
||||||
|
|
|
@ -21,38 +21,34 @@ macro_rules! fixed_no_frac {
|
||||||
$UInner:ty, $Signedness:tt
|
$UInner:ty, $Signedness:tt
|
||||||
) => {
|
) => {
|
||||||
impl<Frac> $Fixed<Frac> {
|
impl<Frac> $Fixed<Frac> {
|
||||||
|
// TODO when rustc requirement >= 1.43.0, use MIN instead of min_value() in example
|
||||||
comment! {
|
comment! {
|
||||||
"Returns the smallest value that can be represented.
|
"The smallest value that can be represented.
|
||||||
|
|
||||||
# Examples
|
# Examples
|
||||||
|
|
||||||
```rust
|
```rust
|
||||||
use fixed::{types::extra::U4, ", $s_fixed, "};
|
use fixed::{types::extra::U4, ", $s_fixed, "};
|
||||||
type Fix = ", $s_fixed, "<U4>;
|
type Fix = ", $s_fixed, "<U4>;
|
||||||
assert_eq!(Fix::min_value(), Fix::from_bits(", $s_inner, "::min_value()));
|
assert_eq!(Fix::MIN, Fix::from_bits(", $s_inner, "::min_value()));
|
||||||
```
|
```
|
||||||
";
|
";
|
||||||
#[inline]
|
pub const MIN: Self = Self::from_bits(<$Inner>::min_value());
|
||||||
pub const fn min_value() -> $Fixed<Frac> {
|
|
||||||
Self::from_bits(<$Inner>::min_value())
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// TODO when rustc requirement >= 1.43.0, use MAX instead of max_value() in example
|
||||||
comment! {
|
comment! {
|
||||||
"Returns the largest value that can be represented.
|
"The largest value that can be represented.
|
||||||
|
|
||||||
# Examples
|
# Examples
|
||||||
|
|
||||||
```rust
|
```rust
|
||||||
use fixed::{types::extra::U4, ", $s_fixed, "};
|
use fixed::{types::extra::U4, ", $s_fixed, "};
|
||||||
type Fix = ", $s_fixed, "<U4>;
|
type Fix = ", $s_fixed, "<U4>;
|
||||||
assert_eq!(Fix::max_value(), Fix::from_bits(", $s_inner, "::max_value()));
|
assert_eq!(Fix::MAX, Fix::from_bits(", $s_inner, "::max_value()));
|
||||||
```
|
```
|
||||||
";
|
";
|
||||||
#[inline]
|
pub const MAX: Self = Self::from_bits(<$Inner>::max_value());
|
||||||
pub const fn max_value() -> $Fixed<Frac> {
|
|
||||||
Self::from_bits(<$Inner>::max_value())
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
comment! {
|
comment! {
|
||||||
|
@ -524,7 +520,7 @@ type Fix = ", $s_fixed, "<U4>;
|
||||||
if_signed_unsigned! {
|
if_signed_unsigned! {
|
||||||
$Signedness,
|
$Signedness,
|
||||||
"assert_eq!(Fix::from_num(5).checked_neg(), Some(Fix::from_num(-5)));
|
"assert_eq!(Fix::from_num(5).checked_neg(), Some(Fix::from_num(-5)));
|
||||||
assert_eq!(Fix::min_value().checked_neg(), None);",
|
assert_eq!(Fix::MIN.checked_neg(), None);",
|
||||||
"assert_eq!(Fix::from_num(0).checked_neg(), Some(Fix::from_num(0)));
|
"assert_eq!(Fix::from_num(0).checked_neg(), Some(Fix::from_num(0)));
|
||||||
assert_eq!(Fix::from_num(5).checked_neg(), None);",
|
assert_eq!(Fix::from_num(5).checked_neg(), None);",
|
||||||
},
|
},
|
||||||
|
@ -548,8 +544,8 @@ assert_eq!(Fix::from_num(5).checked_neg(), None);",
|
||||||
use fixed::{types::extra::U4, ", $s_fixed, "};
|
use fixed::{types::extra::U4, ", $s_fixed, "};
|
||||||
type Fix = ", $s_fixed, "<U4>;
|
type Fix = ", $s_fixed, "<U4>;
|
||||||
let one = Fix::from_num(1);
|
let one = Fix::from_num(1);
|
||||||
assert_eq!((Fix::max_value() - one).checked_add(one), Some(Fix::max_value()));
|
assert_eq!((Fix::MAX - one).checked_add(one), Some(Fix::MAX));
|
||||||
assert_eq!(Fix::max_value().checked_add(one), None);
|
assert_eq!(Fix::MAX.checked_add(one), None);
|
||||||
```
|
```
|
||||||
|
|
||||||
[`None`]: https://doc.rust-lang.org/nightly/core/option/enum.Option.html#variant.None
|
[`None`]: https://doc.rust-lang.org/nightly/core/option/enum.Option.html#variant.None
|
||||||
|
@ -569,8 +565,8 @@ assert_eq!(Fix::max_value().checked_add(one), None);
|
||||||
use fixed::{types::extra::U4, ", $s_fixed, "};
|
use fixed::{types::extra::U4, ", $s_fixed, "};
|
||||||
type Fix = ", $s_fixed, "<U4>;
|
type Fix = ", $s_fixed, "<U4>;
|
||||||
let one = Fix::from_num(1);
|
let one = Fix::from_num(1);
|
||||||
assert_eq!((Fix::min_value() + one).checked_sub(one), Some(Fix::min_value()));
|
assert_eq!((Fix::MIN + one).checked_sub(one), Some(Fix::MIN));
|
||||||
assert_eq!(Fix::min_value().checked_sub(one), None);
|
assert_eq!(Fix::MIN.checked_sub(one), None);
|
||||||
```
|
```
|
||||||
|
|
||||||
[`None`]: https://doc.rust-lang.org/nightly/core/option/enum.Option.html#variant.None
|
[`None`]: https://doc.rust-lang.org/nightly/core/option/enum.Option.html#variant.None
|
||||||
|
@ -624,8 +620,8 @@ product, or [`None`] on overflow.
|
||||||
```rust
|
```rust
|
||||||
use fixed::{types::extra::U4, ", $s_fixed, "};
|
use fixed::{types::extra::U4, ", $s_fixed, "};
|
||||||
type Fix = ", $s_fixed, "<U4>;
|
type Fix = ", $s_fixed, "<U4>;
|
||||||
assert_eq!(Fix::max_value().checked_mul_int(1), Some(Fix::max_value()));
|
assert_eq!(Fix::MAX.checked_mul_int(1), Some(Fix::MAX));
|
||||||
assert_eq!(Fix::max_value().checked_mul_int(2), None);
|
assert_eq!(Fix::MAX.checked_mul_int(2), None);
|
||||||
```
|
```
|
||||||
|
|
||||||
[`None`]: https://doc.rust-lang.org/nightly/core/option/enum.Option.html#variant.None
|
[`None`]: https://doc.rust-lang.org/nightly/core/option/enum.Option.html#variant.None
|
||||||
|
@ -651,12 +647,12 @@ assert_eq!(Fix::max_value().checked_mul_int(2), None);
|
||||||
```rust
|
```rust
|
||||||
use fixed::{types::extra::U4, ", $s_fixed, "};
|
use fixed::{types::extra::U4, ", $s_fixed, "};
|
||||||
type Fix = ", $s_fixed, "<U4>;
|
type Fix = ", $s_fixed, "<U4>;
|
||||||
assert_eq!(Fix::max_value().checked_div_int(1), Some(Fix::max_value()));
|
assert_eq!(Fix::MAX.checked_div_int(1), Some(Fix::MAX));
|
||||||
assert_eq!(Fix::from_num(1).checked_div_int(0), None);
|
assert_eq!(Fix::from_num(1).checked_div_int(0), None);
|
||||||
",
|
",
|
||||||
if_signed_else_empty_str! {
|
if_signed_else_empty_str! {
|
||||||
$Signedness,
|
$Signedness,
|
||||||
"assert_eq!(Fix::min_value().checked_div_int(-1), None);
|
"assert_eq!(Fix::MIN.checked_div_int(-1), None);
|
||||||
",
|
",
|
||||||
},
|
},
|
||||||
"```
|
"```
|
||||||
|
@ -765,7 +761,7 @@ Overflow can only occur when trying to find the absolute value of the minimum va
|
||||||
use fixed::{types::extra::U4, ", $s_fixed, "};
|
use fixed::{types::extra::U4, ", $s_fixed, "};
|
||||||
type Fix = ", $s_fixed, "<U4>;
|
type Fix = ", $s_fixed, "<U4>;
|
||||||
assert_eq!(Fix::from_num(-5).checked_abs(), Some(Fix::from_num(5)));
|
assert_eq!(Fix::from_num(-5).checked_abs(), Some(Fix::from_num(5)));
|
||||||
assert_eq!(Fix::min_value().checked_abs(), None);
|
assert_eq!(Fix::MIN.checked_abs(), None);
|
||||||
```
|
```
|
||||||
|
|
||||||
[`None`]: https://doc.rust-lang.org/nightly/core/option/enum.Option.html#variant.None
|
[`None`]: https://doc.rust-lang.org/nightly/core/option/enum.Option.html#variant.None
|
||||||
|
@ -793,7 +789,7 @@ let three_eights = Fix::from_bits(0b0110);
|
||||||
// 1/2 is 0.1000
|
// 1/2 is 0.1000
|
||||||
let half = Fix::from_bits(0b1000);
|
let half = Fix::from_bits(0b1000);
|
||||||
assert_eq!(three_eights.checked_next_power_of_two(), Some(half));
|
assert_eq!(three_eights.checked_next_power_of_two(), Some(half));
|
||||||
assert!(Fix::max_value().checked_next_power_of_two().is_none());
|
assert!(Fix::MAX.checked_next_power_of_two().is_none());
|
||||||
```
|
```
|
||||||
|
|
||||||
[`None`]: https://doc.rust-lang.org/nightly/core/option/enum.Option.html#variant.None
|
[`None`]: https://doc.rust-lang.org/nightly/core/option/enum.Option.html#variant.None
|
||||||
|
@ -825,7 +821,7 @@ type Fix = ", $s_fixed, "<U4>;
|
||||||
if_signed_unsigned! {
|
if_signed_unsigned! {
|
||||||
$Signedness,
|
$Signedness,
|
||||||
"assert_eq!(Fix::from_num(5).saturating_neg(), Fix::from_num(-5));
|
"assert_eq!(Fix::from_num(5).saturating_neg(), Fix::from_num(-5));
|
||||||
assert_eq!(Fix::min_value().saturating_neg(), Fix::max_value());",
|
assert_eq!(Fix::MIN.saturating_neg(), Fix::MAX);",
|
||||||
"assert_eq!(Fix::from_num(0).saturating_neg(), Fix::from_num(0));
|
"assert_eq!(Fix::from_num(0).saturating_neg(), Fix::from_num(0));
|
||||||
assert_eq!(Fix::from_num(5).saturating_neg(), Fix::from_num(0));",
|
assert_eq!(Fix::from_num(5).saturating_neg(), Fix::from_num(0));",
|
||||||
},
|
},
|
||||||
|
@ -838,7 +834,7 @@ assert_eq!(Fix::from_num(5).saturating_neg(), Fix::from_num(0));",
|
||||||
$Signedness,
|
$Signedness,
|
||||||
{
|
{
|
||||||
let (val, overflow) = self.overflowing_neg();
|
let (val, overflow) = self.overflowing_neg();
|
||||||
val.if_cond_else(!overflow, Self::max_value())
|
val.if_cond_else(!overflow, Self::MAX)
|
||||||
},
|
},
|
||||||
Self::from_bits(0),
|
Self::from_bits(0),
|
||||||
}
|
}
|
||||||
|
@ -854,7 +850,7 @@ assert_eq!(Fix::from_num(5).saturating_neg(), Fix::from_num(0));",
|
||||||
use fixed::{types::extra::U4, ", $s_fixed, "};
|
use fixed::{types::extra::U4, ", $s_fixed, "};
|
||||||
type Fix = ", $s_fixed, "<U4>;
|
type Fix = ", $s_fixed, "<U4>;
|
||||||
assert_eq!(Fix::from_num(3).saturating_add(Fix::from_num(2)), Fix::from_num(5));
|
assert_eq!(Fix::from_num(3).saturating_add(Fix::from_num(2)), Fix::from_num(5));
|
||||||
assert_eq!(Fix::max_value().saturating_add(Fix::from_num(1)), Fix::max_value());
|
assert_eq!(Fix::MAX.saturating_add(Fix::from_num(1)), Fix::MAX);
|
||||||
```
|
```
|
||||||
";
|
";
|
||||||
#[inline]
|
#[inline]
|
||||||
|
@ -864,8 +860,8 @@ assert_eq!(Fix::max_value().saturating_add(Fix::from_num(1)), Fix::max_value());
|
||||||
!overflow,
|
!overflow,
|
||||||
if_signed_unsigned! {
|
if_signed_unsigned! {
|
||||||
$Signedness,
|
$Signedness,
|
||||||
Self::min_value().if_cond_else(self.to_bits() < 0, Self::max_value()),
|
Self::MIN.if_cond_else(self.to_bits() < 0, Self::MAX),
|
||||||
Self::max_value(),
|
Self::MAX,
|
||||||
},
|
},
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
|
@ -883,7 +879,7 @@ type Fix = ", $s_fixed, "<U4>;
|
||||||
if_signed_unsigned! {
|
if_signed_unsigned! {
|
||||||
$Signedness,
|
$Signedness,
|
||||||
"assert_eq!(Fix::from_num(1).saturating_sub(Fix::from_num(3)), Fix::from_num(-2));
|
"assert_eq!(Fix::from_num(1).saturating_sub(Fix::from_num(3)), Fix::from_num(-2));
|
||||||
assert_eq!(Fix::min_value().saturating_sub(Fix::from_num(1)), Fix::min_value());",
|
assert_eq!(Fix::MIN.saturating_sub(Fix::from_num(1)), Fix::MIN);",
|
||||||
"assert_eq!(Fix::from_num(5).saturating_sub(Fix::from_num(3)), Fix::from_num(2));
|
"assert_eq!(Fix::from_num(5).saturating_sub(Fix::from_num(3)), Fix::from_num(2));
|
||||||
assert_eq!(Fix::from_num(0).saturating_sub(Fix::from_num(1)), Fix::from_num(0));",
|
assert_eq!(Fix::from_num(0).saturating_sub(Fix::from_num(1)), Fix::from_num(0));",
|
||||||
},
|
},
|
||||||
|
@ -897,11 +893,11 @@ assert_eq!(Fix::from_num(0).saturating_sub(Fix::from_num(1)), Fix::from_num(0));
|
||||||
!overflow,
|
!overflow,
|
||||||
if_signed_unsigned! {
|
if_signed_unsigned! {
|
||||||
$Signedness,
|
$Signedness,
|
||||||
Self::min_value().if_cond_else(
|
Self::MIN.if_cond_else(
|
||||||
self.to_bits() < rhs.to_bits(),
|
self.to_bits() < rhs.to_bits(),
|
||||||
Self::max_value(),
|
Self::MAX,
|
||||||
),
|
),
|
||||||
Self::min_value(),
|
Self::MIN,
|
||||||
},
|
},
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
|
@ -916,7 +912,7 @@ assert_eq!(Fix::from_num(0).saturating_sub(Fix::from_num(1)), Fix::from_num(0));
|
||||||
use fixed::{types::extra::U4, ", $s_fixed, "};
|
use fixed::{types::extra::U4, ", $s_fixed, "};
|
||||||
type Fix = ", $s_fixed, "<U4>;
|
type Fix = ", $s_fixed, "<U4>;
|
||||||
assert_eq!(Fix::from_num(3).saturating_mul_int(2), Fix::from_num(6));
|
assert_eq!(Fix::from_num(3).saturating_mul_int(2), Fix::from_num(6));
|
||||||
assert_eq!(Fix::max_value().saturating_mul_int(2), Fix::max_value());
|
assert_eq!(Fix::MAX.saturating_mul_int(2), Fix::MAX);
|
||||||
```
|
```
|
||||||
";
|
";
|
||||||
#[inline]
|
#[inline]
|
||||||
|
@ -926,11 +922,11 @@ assert_eq!(Fix::max_value().saturating_mul_int(2), Fix::max_value());
|
||||||
!overflow,
|
!overflow,
|
||||||
if_signed_unsigned! {
|
if_signed_unsigned! {
|
||||||
$Signedness,
|
$Signedness,
|
||||||
Self::min_value().if_cond_else(
|
Self::MIN.if_cond_else(
|
||||||
(self.to_bits() < 0) != (rhs < 0),
|
(self.to_bits() < 0) != (rhs < 0),
|
||||||
Self::max_value(),
|
Self::MAX,
|
||||||
),
|
),
|
||||||
Self::max_value(),
|
Self::MAX,
|
||||||
},
|
},
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
|
@ -949,13 +945,13 @@ Overflow can only occur when trying to find the absolute value of the minimum va
|
||||||
use fixed::{types::extra::U4, ", $s_fixed, "};
|
use fixed::{types::extra::U4, ", $s_fixed, "};
|
||||||
type Fix = ", $s_fixed, "<U4>;
|
type Fix = ", $s_fixed, "<U4>;
|
||||||
assert_eq!(Fix::from_num(-5).saturating_abs(), Fix::from_num(5));
|
assert_eq!(Fix::from_num(-5).saturating_abs(), Fix::from_num(5));
|
||||||
assert_eq!(Fix::min_value().saturating_abs(), Fix::max_value());
|
assert_eq!(Fix::MIN.saturating_abs(), Fix::MAX);
|
||||||
```
|
```
|
||||||
";
|
";
|
||||||
#[inline]
|
#[inline]
|
||||||
pub const fn saturating_abs(self) -> $Fixed<Frac> {
|
pub const fn saturating_abs(self) -> $Fixed<Frac> {
|
||||||
let (val, overflow) = self.overflowing_abs();
|
let (val, overflow) = self.overflowing_abs();
|
||||||
val.if_cond_else(!overflow, Self::max_value())
|
val.if_cond_else(!overflow, Self::MAX)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -980,7 +976,7 @@ type Fix = ", $s_fixed, "<U4>;
|
||||||
if_signed_unsigned! {
|
if_signed_unsigned! {
|
||||||
$Signedness,
|
$Signedness,
|
||||||
"assert_eq!(Fix::from_num(5).wrapping_neg(), Fix::from_num(-5));
|
"assert_eq!(Fix::from_num(5).wrapping_neg(), Fix::from_num(-5));
|
||||||
assert_eq!(Fix::min_value().wrapping_neg(), Fix::min_value());",
|
assert_eq!(Fix::MIN.wrapping_neg(), Fix::MIN);",
|
||||||
"assert_eq!(Fix::from_num(0).wrapping_neg(), Fix::from_num(0));
|
"assert_eq!(Fix::from_num(0).wrapping_neg(), Fix::from_num(0));
|
||||||
assert_eq!(Fix::from_num(5).wrapping_neg(), Fix::wrapping_from_num(-5));
|
assert_eq!(Fix::from_num(5).wrapping_neg(), Fix::wrapping_from_num(-5));
|
||||||
let neg_five_bits = !Fix::from_num(5).to_bits() + 1;
|
let neg_five_bits = !Fix::from_num(5).to_bits() + 1;
|
||||||
|
@ -1006,8 +1002,8 @@ type Fix = ", $s_fixed, "<U4>;
|
||||||
let one = Fix::from_num(1);
|
let one = Fix::from_num(1);
|
||||||
let one_minus_bit = one - Fix::from_bits(1);
|
let one_minus_bit = one - Fix::from_bits(1);
|
||||||
assert_eq!(Fix::from_num(3).wrapping_add(Fix::from_num(2)), Fix::from_num(5));
|
assert_eq!(Fix::from_num(3).wrapping_add(Fix::from_num(2)), Fix::from_num(5));
|
||||||
assert_eq!(Fix::max_value().wrapping_add(one), ",
|
assert_eq!(Fix::MAX.wrapping_add(one), ",
|
||||||
if_signed_else_empty_str! { $Signedness, "Fix::min_value() + " },
|
if_signed_else_empty_str! { $Signedness, "Fix::MIN + " },
|
||||||
"one_minus_bit);
|
"one_minus_bit);
|
||||||
```
|
```
|
||||||
";
|
";
|
||||||
|
@ -1031,11 +1027,11 @@ let one_minus_bit = one - Fix::from_bits(1);
|
||||||
if_signed_unsigned! {
|
if_signed_unsigned! {
|
||||||
$Signedness,
|
$Signedness,
|
||||||
"assert_eq!(Fix::from_num(3).wrapping_sub(Fix::from_num(5)), Fix::from_num(-2));
|
"assert_eq!(Fix::from_num(3).wrapping_sub(Fix::from_num(5)), Fix::from_num(-2));
|
||||||
assert_eq!(Fix::min_value()",
|
assert_eq!(Fix::MIN",
|
||||||
"assert_eq!(Fix::from_num(5).wrapping_sub(Fix::from_num(3)), Fix::from_num(2));
|
"assert_eq!(Fix::from_num(5).wrapping_sub(Fix::from_num(3)), Fix::from_num(2));
|
||||||
assert_eq!(Fix::from_num(0)",
|
assert_eq!(Fix::from_num(0)",
|
||||||
},
|
},
|
||||||
".wrapping_sub(one), Fix::max_value() - one_minus_bit);
|
".wrapping_sub(one), Fix::MAX - one_minus_bit);
|
||||||
```
|
```
|
||||||
";
|
";
|
||||||
#[inline]
|
#[inline]
|
||||||
|
@ -1054,7 +1050,7 @@ use fixed::{types::extra::U4, ", $s_fixed, "};
|
||||||
type Fix = ", $s_fixed, "<U4>;
|
type Fix = ", $s_fixed, "<U4>;
|
||||||
assert_eq!(Fix::from_num(3).wrapping_mul_int(2), Fix::from_num(6));
|
assert_eq!(Fix::from_num(3).wrapping_mul_int(2), Fix::from_num(6));
|
||||||
let wrapped = Fix::from_bits(!0 << 2);
|
let wrapped = Fix::from_bits(!0 << 2);
|
||||||
assert_eq!(Fix::max_value().wrapping_mul_int(4), wrapped);
|
assert_eq!(Fix::MAX.wrapping_mul_int(4), wrapped);
|
||||||
```
|
```
|
||||||
";
|
";
|
||||||
#[inline]
|
#[inline]
|
||||||
|
@ -1091,7 +1087,7 @@ assert_eq!(Fix::from_num(3).wrapping_div_int(2), one_point_5);
|
||||||
",
|
",
|
||||||
if_signed_else_empty_str! {
|
if_signed_else_empty_str! {
|
||||||
$Signedness,
|
$Signedness,
|
||||||
"assert_eq!(Fix::min_value().wrapping_div_int(-1), Fix::min_value());
|
"assert_eq!(Fix::MIN.wrapping_div_int(-1), Fix::MIN);
|
||||||
",
|
",
|
||||||
},
|
},
|
||||||
"```
|
"```
|
||||||
|
@ -1153,7 +1149,7 @@ Overflow can only occur when trying to find the absolute value of the minimum va
|
||||||
use fixed::{types::extra::U4, ", $s_fixed, "};
|
use fixed::{types::extra::U4, ", $s_fixed, "};
|
||||||
type Fix = ", $s_fixed, "<U4>;
|
type Fix = ", $s_fixed, "<U4>;
|
||||||
assert_eq!(Fix::from_num(-5).wrapping_abs(), Fix::from_num(5));
|
assert_eq!(Fix::from_num(-5).wrapping_abs(), Fix::from_num(5));
|
||||||
assert_eq!(Fix::min_value().wrapping_abs(), Fix::min_value());
|
assert_eq!(Fix::MIN.wrapping_abs(), Fix::MIN);
|
||||||
```
|
```
|
||||||
";
|
";
|
||||||
#[inline]
|
#[inline]
|
||||||
|
@ -1186,7 +1182,7 @@ type Fix = ", $s_fixed, "<U4>;
|
||||||
if_signed_unsigned! {
|
if_signed_unsigned! {
|
||||||
$Signedness,
|
$Signedness,
|
||||||
"assert_eq!(Fix::from_num(5).overflowing_neg(), (Fix::from_num(-5), false));
|
"assert_eq!(Fix::from_num(5).overflowing_neg(), (Fix::from_num(-5), false));
|
||||||
assert_eq!(Fix::min_value().overflowing_neg(), (Fix::min_value(), true));",
|
assert_eq!(Fix::MIN.overflowing_neg(), (Fix::MIN, true));",
|
||||||
"assert_eq!(Fix::from_num(0).overflowing_neg(), (Fix::from_num(0), false));
|
"assert_eq!(Fix::from_num(0).overflowing_neg(), (Fix::from_num(0), false));
|
||||||
assert_eq!(Fix::from_num(5).overflowing_neg(), Fix::overflowing_from_num(-5));
|
assert_eq!(Fix::from_num(5).overflowing_neg(), Fix::overflowing_from_num(-5));
|
||||||
let neg_five_bits = !Fix::from_num(5).to_bits() + 1;
|
let neg_five_bits = !Fix::from_num(5).to_bits() + 1;
|
||||||
|
@ -1219,8 +1215,8 @@ type Fix = ", $s_fixed, "<U4>;
|
||||||
let one = Fix::from_num(1);
|
let one = Fix::from_num(1);
|
||||||
let one_minus_bit = one - Fix::from_bits(1);
|
let one_minus_bit = one - Fix::from_bits(1);
|
||||||
assert_eq!(Fix::from_num(3).overflowing_add(Fix::from_num(2)), (Fix::from_num(5), false));
|
assert_eq!(Fix::from_num(3).overflowing_add(Fix::from_num(2)), (Fix::from_num(5), false));
|
||||||
assert_eq!(Fix::max_value().overflowing_add(one), (",
|
assert_eq!(Fix::MAX.overflowing_add(one), (",
|
||||||
if_signed_else_empty_str! { $Signedness, "Fix::min_value() + " },
|
if_signed_else_empty_str! { $Signedness, "Fix::MIN + " },
|
||||||
"one_minus_bit, true));
|
"one_minus_bit, true));
|
||||||
```
|
```
|
||||||
|
|
||||||
|
@ -1251,11 +1247,11 @@ let one_minus_bit = one - Fix::from_bits(1);
|
||||||
if_signed_unsigned! {
|
if_signed_unsigned! {
|
||||||
$Signedness,
|
$Signedness,
|
||||||
"assert_eq!(Fix::from_num(3).overflowing_sub(Fix::from_num(5)), (Fix::from_num(-2), false));
|
"assert_eq!(Fix::from_num(3).overflowing_sub(Fix::from_num(5)), (Fix::from_num(-2), false));
|
||||||
assert_eq!(Fix::min_value()",
|
assert_eq!(Fix::MIN",
|
||||||
"assert_eq!(Fix::from_num(5).overflowing_sub(Fix::from_num(3)), (Fix::from_num(2), false));
|
"assert_eq!(Fix::from_num(5).overflowing_sub(Fix::from_num(3)), (Fix::from_num(2), false));
|
||||||
assert_eq!(Fix::from_num(0)",
|
assert_eq!(Fix::from_num(0)",
|
||||||
},
|
},
|
||||||
".overflowing_sub(one), (Fix::max_value() - one_minus_bit, true));
|
".overflowing_sub(one), (Fix::MAX - one_minus_bit, true));
|
||||||
```
|
```
|
||||||
|
|
||||||
[`bool`]: https://doc.rust-lang.org/nightly/std/primitive.bool.html
|
[`bool`]: https://doc.rust-lang.org/nightly/std/primitive.bool.html
|
||||||
|
@ -1281,7 +1277,7 @@ use fixed::{types::extra::U4, ", $s_fixed, "};
|
||||||
type Fix = ", $s_fixed, "<U4>;
|
type Fix = ", $s_fixed, "<U4>;
|
||||||
assert_eq!(Fix::from_num(3).overflowing_mul_int(2), (Fix::from_num(6), false));
|
assert_eq!(Fix::from_num(3).overflowing_mul_int(2), (Fix::from_num(6), false));
|
||||||
let wrapped = Fix::from_bits(!0 << 2);
|
let wrapped = Fix::from_bits(!0 << 2);
|
||||||
assert_eq!(Fix::max_value().overflowing_mul_int(4), (wrapped, true));
|
assert_eq!(Fix::MAX.overflowing_mul_int(4), (wrapped, true));
|
||||||
```
|
```
|
||||||
|
|
||||||
[`bool`]: https://doc.rust-lang.org/nightly/std/primitive.bool.html
|
[`bool`]: https://doc.rust-lang.org/nightly/std/primitive.bool.html
|
||||||
|
@ -1322,7 +1318,7 @@ assert_eq!(Fix::from_num(3).overflowing_div_int(2), (one_point_5, false));
|
||||||
",
|
",
|
||||||
if_signed_else_empty_str! {
|
if_signed_else_empty_str! {
|
||||||
$Signedness,
|
$Signedness,
|
||||||
"assert_eq!(Fix::min_value().overflowing_div_int(-1), (Fix::min_value(), true));
|
"assert_eq!(Fix::MIN.overflowing_div_int(-1), (Fix::MIN, true));
|
||||||
",
|
",
|
||||||
},
|
},
|
||||||
"```
|
"```
|
||||||
|
@ -1407,7 +1403,7 @@ Overflow can only occur when trying to find the absolute value of the minimum va
|
||||||
use fixed::{types::extra::U4, ", $s_fixed, "};
|
use fixed::{types::extra::U4, ", $s_fixed, "};
|
||||||
type Fix = ", $s_fixed, "<U4>;
|
type Fix = ", $s_fixed, "<U4>;
|
||||||
assert_eq!(Fix::from_num(-5).overflowing_abs(), (Fix::from_num(5), false));
|
assert_eq!(Fix::from_num(-5).overflowing_abs(), (Fix::from_num(5), false));
|
||||||
assert_eq!(Fix::min_value().overflowing_abs(), (Fix::min_value(), true));
|
assert_eq!(Fix::MIN.overflowing_abs(), (Fix::MIN, true));
|
||||||
```
|
```
|
||||||
|
|
||||||
[`bool`]: https://doc.rust-lang.org/nightly/std/primitive.bool.html
|
[`bool`]: https://doc.rust-lang.org/nightly/std/primitive.bool.html
|
||||||
|
@ -1426,6 +1422,20 @@ assert_eq!(Fix::min_value().overflowing_abs(), (Fix::min_value(), true));
|
||||||
let not_mask = (cond as $Inner).wrapping_sub(1);
|
let not_mask = (cond as $Inner).wrapping_sub(1);
|
||||||
Self::from_bits((self.to_bits() & !not_mask) | (otherwise.to_bits() & not_mask))
|
Self::from_bits((self.to_bits() & !not_mask) | (otherwise.to_bits() & not_mask))
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// Returns the smallest value that can be represented.
|
||||||
|
#[inline]
|
||||||
|
#[deprecated(since = "0.5.5", note = "replaced by `MIN`")]
|
||||||
|
pub const fn min_value() -> $Fixed<Frac> {
|
||||||
|
Self::MIN
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Returns the largest value that can be represented.
|
||||||
|
#[inline]
|
||||||
|
#[deprecated(since = "0.5.5", note = "replaced by `MAX`")]
|
||||||
|
pub const fn max_value() -> $Fixed<Frac> {
|
||||||
|
Self::MAX
|
||||||
|
}
|
||||||
}
|
}
|
||||||
};
|
};
|
||||||
}
|
}
|
||||||
|
|
|
@ -315,7 +315,7 @@ assert_eq!(Fix::from_num(2.5).checked_ceil(), Some(Fix::from_num(3)));
|
||||||
"assert_eq!(Fix::from_num(-2.5).checked_ceil(), Some(Fix::from_num(-2)));
|
"assert_eq!(Fix::from_num(-2.5).checked_ceil(), Some(Fix::from_num(-2)));
|
||||||
",
|
",
|
||||||
},
|
},
|
||||||
"assert!(Fix::max_value().checked_ceil().is_none());
|
"assert!(Fix::MAX.checked_ceil().is_none());
|
||||||
```
|
```
|
||||||
|
|
||||||
[`None`]: https://doc.rust-lang.org/nightly/core/option/enum.Option.html#variant.None
|
[`None`]: https://doc.rust-lang.org/nightly/core/option/enum.Option.html#variant.None
|
||||||
|
@ -360,7 +360,7 @@ assert_eq!(Fix::from_num(2.5).checked_floor(), Some(Fix::from_num(2)));
|
||||||
$Signedness,
|
$Signedness,
|
||||||
"assert_eq!(Fix::from_num(-2.5).checked_floor(), Some(Fix::from_num(-3)));
|
"assert_eq!(Fix::from_num(-2.5).checked_floor(), Some(Fix::from_num(-3)));
|
||||||
type AllFrac = ", $s_fixed, "<U", $s_nbits, ">;
|
type AllFrac = ", $s_fixed, "<U", $s_nbits, ">;
|
||||||
assert!(AllFrac::min_value().checked_floor().is_none());
|
assert!(AllFrac::MIN.checked_floor().is_none());
|
||||||
",
|
",
|
||||||
},
|
},
|
||||||
"```
|
"```
|
||||||
|
@ -397,7 +397,7 @@ assert_eq!(Fix::from_num(2.5).checked_round(), Some(Fix::from_num(3)));
|
||||||
"assert_eq!(Fix::from_num(-2.5).checked_round(), Some(Fix::from_num(-3)));
|
"assert_eq!(Fix::from_num(-2.5).checked_round(), Some(Fix::from_num(-3)));
|
||||||
",
|
",
|
||||||
},
|
},
|
||||||
"assert!(Fix::max_value().checked_round().is_none());
|
"assert!(Fix::MAX.checked_round().is_none());
|
||||||
```
|
```
|
||||||
|
|
||||||
[`None`]: https://doc.rust-lang.org/nightly/core/option/enum.Option.html#variant.None
|
[`None`]: https://doc.rust-lang.org/nightly/core/option/enum.Option.html#variant.None
|
||||||
|
@ -420,7 +420,7 @@ use fixed::{types::extra::U4, ", $s_fixed, "};
|
||||||
type Fix = ", $s_fixed, "<U4>;
|
type Fix = ", $s_fixed, "<U4>;
|
||||||
assert_eq!(Fix::from_num(2.5).checked_round_ties_to_even(), Some(Fix::from_num(2)));
|
assert_eq!(Fix::from_num(2.5).checked_round_ties_to_even(), Some(Fix::from_num(2)));
|
||||||
assert_eq!(Fix::from_num(3.5).checked_round_ties_to_even(), Some(Fix::from_num(4)));
|
assert_eq!(Fix::from_num(3.5).checked_round_ties_to_even(), Some(Fix::from_num(4)));
|
||||||
assert!(Fix::max_value().checked_round_ties_to_even().is_none());
|
assert!(Fix::MAX.checked_round_ties_to_even().is_none());
|
||||||
```
|
```
|
||||||
|
|
||||||
[`None`]: https://doc.rust-lang.org/nightly/core/option/enum.Option.html#variant.None
|
[`None`]: https://doc.rust-lang.org/nightly/core/option/enum.Option.html#variant.None
|
||||||
|
@ -448,13 +448,13 @@ assert_eq!(Fix::from_num(2.5).saturating_ceil(), Fix::from_num(3));
|
||||||
"assert_eq!(Fix::from_num(-2.5).saturating_ceil(), Fix::from_num(-2));
|
"assert_eq!(Fix::from_num(-2.5).saturating_ceil(), Fix::from_num(-2));
|
||||||
",
|
",
|
||||||
},
|
},
|
||||||
"assert_eq!(Fix::max_value().saturating_ceil(), Fix::max_value());
|
"assert_eq!(Fix::MAX.saturating_ceil(), Fix::MAX);
|
||||||
```
|
```
|
||||||
";
|
";
|
||||||
#[inline]
|
#[inline]
|
||||||
pub fn saturating_ceil(self) -> $Fixed<Frac> {
|
pub fn saturating_ceil(self) -> $Fixed<Frac> {
|
||||||
let (ceil, overflow) = self.overflowing_ceil();
|
let (ceil, overflow) = self.overflowing_ceil();
|
||||||
if overflow { Self::max_value() } else { ceil }
|
if overflow { Self::MAX } else { ceil }
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -491,7 +491,7 @@ assert_eq!(Fix::from_num(2.5).saturating_floor(), Fix::from_num(2));
|
||||||
$Signedness,
|
$Signedness,
|
||||||
"assert_eq!(Fix::from_num(-2.5).saturating_floor(), Fix::from_num(-3));
|
"assert_eq!(Fix::from_num(-2.5).saturating_floor(), Fix::from_num(-3));
|
||||||
type AllFrac = ", $s_fixed, "<U", $s_nbits, ">;
|
type AllFrac = ", $s_fixed, "<U", $s_nbits, ">;
|
||||||
assert_eq!(AllFrac::min_value().saturating_floor(), AllFrac::min_value());
|
assert_eq!(AllFrac::MIN.saturating_floor(), AllFrac::MIN);
|
||||||
",
|
",
|
||||||
},
|
},
|
||||||
"```
|
"```
|
||||||
|
@ -499,7 +499,7 @@ assert_eq!(AllFrac::min_value().saturating_floor(), AllFrac::min_value());
|
||||||
#[inline]
|
#[inline]
|
||||||
pub fn saturating_floor(self) -> $Fixed<Frac> {
|
pub fn saturating_floor(self) -> $Fixed<Frac> {
|
||||||
let (floor, overflow) = self.overflowing_floor();
|
let (floor, overflow) = self.overflowing_floor();
|
||||||
if overflow { Self::min_value() } else { floor }
|
if overflow { Self::MIN } else { floor }
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -519,15 +519,15 @@ assert_eq!(Fix::from_num(2.5).saturating_round(), Fix::from_num(3));
|
||||||
"assert_eq!(Fix::from_num(-2.5).saturating_round(), Fix::from_num(-3));
|
"assert_eq!(Fix::from_num(-2.5).saturating_round(), Fix::from_num(-3));
|
||||||
",
|
",
|
||||||
},
|
},
|
||||||
"assert_eq!(Fix::max_value().saturating_round(), Fix::max_value());
|
"assert_eq!(Fix::MAX.saturating_round(), Fix::MAX);
|
||||||
```
|
```
|
||||||
";
|
";
|
||||||
#[inline]
|
#[inline]
|
||||||
pub fn saturating_round(self) -> $Fixed<Frac> {
|
pub fn saturating_round(self) -> $Fixed<Frac> {
|
||||||
let saturated = if self.to_bits() > 0 {
|
let saturated = if self.to_bits() > 0 {
|
||||||
$Fixed::max_value()
|
$Fixed::MAX
|
||||||
} else {
|
} else {
|
||||||
$Fixed::min_value()
|
$Fixed::MIN
|
||||||
};
|
};
|
||||||
let (round, overflow) = self.overflowing_round();
|
let (round, overflow) = self.overflowing_round();
|
||||||
if overflow { saturated } else { round }
|
if overflow { saturated } else { round }
|
||||||
|
@ -545,15 +545,15 @@ use fixed::{types::extra::U4, ", $s_fixed, "};
|
||||||
type Fix = ", $s_fixed, "<U4>;
|
type Fix = ", $s_fixed, "<U4>;
|
||||||
assert_eq!(Fix::from_num(2.5).saturating_round_ties_to_even(), Fix::from_num(2));
|
assert_eq!(Fix::from_num(2.5).saturating_round_ties_to_even(), Fix::from_num(2));
|
||||||
assert_eq!(Fix::from_num(3.5).saturating_round_ties_to_even(), Fix::from_num(4));
|
assert_eq!(Fix::from_num(3.5).saturating_round_ties_to_even(), Fix::from_num(4));
|
||||||
assert_eq!(Fix::max_value().saturating_round_ties_to_even(), Fix::max_value());
|
assert_eq!(Fix::MAX.saturating_round_ties_to_even(), Fix::MAX);
|
||||||
```
|
```
|
||||||
";
|
";
|
||||||
#[inline]
|
#[inline]
|
||||||
pub fn saturating_round_ties_to_even(self) -> $Fixed<Frac> {
|
pub fn saturating_round_ties_to_even(self) -> $Fixed<Frac> {
|
||||||
let saturated = if self.to_bits() > 0 {
|
let saturated = if self.to_bits() > 0 {
|
||||||
$Fixed::max_value()
|
$Fixed::MAX
|
||||||
} else {
|
} else {
|
||||||
$Fixed::min_value()
|
$Fixed::MIN
|
||||||
};
|
};
|
||||||
let (round, overflow) = self.overflowing_round_ties_to_even();
|
let (round, overflow) = self.overflowing_round_ties_to_even();
|
||||||
if overflow { saturated } else { round }
|
if overflow { saturated } else { round }
|
||||||
|
@ -576,7 +576,7 @@ assert_eq!(Fix::from_num(2.5).wrapping_ceil(), Fix::from_num(3));
|
||||||
"assert_eq!(Fix::from_num(-2.5).wrapping_ceil(), Fix::from_num(-2));
|
"assert_eq!(Fix::from_num(-2.5).wrapping_ceil(), Fix::from_num(-2));
|
||||||
",
|
",
|
||||||
},
|
},
|
||||||
"assert_eq!(Fix::max_value().wrapping_ceil(), Fix::min_value());
|
"assert_eq!(Fix::MAX.wrapping_ceil(), Fix::MIN);
|
||||||
```
|
```
|
||||||
";
|
";
|
||||||
#[inline]
|
#[inline]
|
||||||
|
@ -618,7 +618,7 @@ assert_eq!(Fix::from_num(2.5).wrapping_floor(), Fix::from_num(2));
|
||||||
$Signedness,
|
$Signedness,
|
||||||
"assert_eq!(Fix::from_num(-2.5).wrapping_floor(), Fix::from_num(-3));
|
"assert_eq!(Fix::from_num(-2.5).wrapping_floor(), Fix::from_num(-3));
|
||||||
type AllFrac = ", $s_fixed, "<U", $s_nbits, ">;
|
type AllFrac = ", $s_fixed, "<U", $s_nbits, ">;
|
||||||
assert_eq!(AllFrac::min_value().wrapping_floor(), AllFrac::from_num(0));
|
assert_eq!(AllFrac::MIN.wrapping_floor(), AllFrac::from_num(0));
|
||||||
",
|
",
|
||||||
},
|
},
|
||||||
"```
|
"```
|
||||||
|
@ -645,7 +645,7 @@ assert_eq!(Fix::from_num(2.5).wrapping_round(), Fix::from_num(3));
|
||||||
"assert_eq!(Fix::from_num(-2.5).wrapping_round(), Fix::from_num(-3));
|
"assert_eq!(Fix::from_num(-2.5).wrapping_round(), Fix::from_num(-3));
|
||||||
",
|
",
|
||||||
},
|
},
|
||||||
"assert_eq!(Fix::max_value().wrapping_round(), Fix::min_value());
|
"assert_eq!(Fix::MAX.wrapping_round(), Fix::MIN);
|
||||||
```
|
```
|
||||||
";
|
";
|
||||||
#[inline]
|
#[inline]
|
||||||
|
@ -665,7 +665,7 @@ use fixed::{types::extra::U4, ", $s_fixed, "};
|
||||||
type Fix = ", $s_fixed, "<U4>;
|
type Fix = ", $s_fixed, "<U4>;
|
||||||
assert_eq!(Fix::from_num(2.5).wrapping_round_ties_to_even(), Fix::from_num(2));
|
assert_eq!(Fix::from_num(2.5).wrapping_round_ties_to_even(), Fix::from_num(2));
|
||||||
assert_eq!(Fix::from_num(3.5).wrapping_round_ties_to_even(), Fix::from_num(4));
|
assert_eq!(Fix::from_num(3.5).wrapping_round_ties_to_even(), Fix::from_num(4));
|
||||||
assert_eq!(Fix::max_value().wrapping_round_ties_to_even(), Fix::min_value());
|
assert_eq!(Fix::MAX.wrapping_round_ties_to_even(), Fix::MIN);
|
||||||
```
|
```
|
||||||
";
|
";
|
||||||
#[inline]
|
#[inline]
|
||||||
|
@ -693,7 +693,7 @@ assert_eq!(Fix::from_num(2.5).overflowing_ceil(), (Fix::from_num(3), false));
|
||||||
"assert_eq!(Fix::from_num(-2.5).overflowing_ceil(), (Fix::from_num(-2), false));
|
"assert_eq!(Fix::from_num(-2.5).overflowing_ceil(), (Fix::from_num(-2), false));
|
||||||
"
|
"
|
||||||
},
|
},
|
||||||
"assert_eq!(Fix::max_value().overflowing_ceil(), (Fix::min_value(), true));
|
"assert_eq!(Fix::MAX.overflowing_ceil(), (Fix::MIN, true));
|
||||||
```
|
```
|
||||||
|
|
||||||
[`bool`]: https://doc.rust-lang.org/nightly/std/primitive.bool.html
|
[`bool`]: https://doc.rust-lang.org/nightly/std/primitive.bool.html
|
||||||
|
@ -756,7 +756,7 @@ assert_eq!(Fix::from_num(2.5).overflowing_floor(), (Fix::from_num(2), false));
|
||||||
$Signedness,
|
$Signedness,
|
||||||
"assert_eq!(Fix::from_num(-2.5).overflowing_floor(), (Fix::from_num(-3), false));
|
"assert_eq!(Fix::from_num(-2.5).overflowing_floor(), (Fix::from_num(-3), false));
|
||||||
type AllFrac = ", $s_fixed, "<U", $s_nbits, ">;
|
type AllFrac = ", $s_fixed, "<U", $s_nbits, ">;
|
||||||
assert_eq!(AllFrac::min_value().overflowing_floor(), (AllFrac::from_num(0), true));
|
assert_eq!(AllFrac::MIN.overflowing_floor(), (AllFrac::from_num(0), true));
|
||||||
",
|
",
|
||||||
},
|
},
|
||||||
"```
|
"```
|
||||||
|
@ -798,7 +798,7 @@ assert_eq!(Fix::from_num(2.5).overflowing_round(), (Fix::from_num(3), false));
|
||||||
"assert_eq!(Fix::from_num(-2.5).overflowing_round(), (Fix::from_num(-3), false));
|
"assert_eq!(Fix::from_num(-2.5).overflowing_round(), (Fix::from_num(-3), false));
|
||||||
",
|
",
|
||||||
},
|
},
|
||||||
"assert_eq!(Fix::max_value().overflowing_round(), (Fix::min_value(), true));
|
"assert_eq!(Fix::MAX.overflowing_round(), (Fix::MIN, true));
|
||||||
```
|
```
|
||||||
|
|
||||||
[`bool`]: https://doc.rust-lang.org/nightly/std/primitive.bool.html
|
[`bool`]: https://doc.rust-lang.org/nightly/std/primitive.bool.html
|
||||||
|
@ -857,7 +857,7 @@ use fixed::{types::extra::U4, ", $s_fixed, "};
|
||||||
type Fix = ", $s_fixed, "<U4>;
|
type Fix = ", $s_fixed, "<U4>;
|
||||||
assert_eq!(Fix::from_num(2.5).overflowing_round_ties_to_even(), (Fix::from_num(2), false));
|
assert_eq!(Fix::from_num(2.5).overflowing_round_ties_to_even(), (Fix::from_num(2), false));
|
||||||
assert_eq!(Fix::from_num(3.5).overflowing_round_ties_to_even(), (Fix::from_num(4), false));
|
assert_eq!(Fix::from_num(3.5).overflowing_round_ties_to_even(), (Fix::from_num(4), false));
|
||||||
assert_eq!(Fix::max_value().overflowing_round_ties_to_even(), (Fix::min_value(), true));
|
assert_eq!(Fix::MAX.overflowing_round_ties_to_even(), (Fix::MIN, true));
|
||||||
```
|
```
|
||||||
|
|
||||||
[`bool`]: https://doc.rust-lang.org/nightly/std/primitive.bool.html
|
[`bool`]: https://doc.rust-lang.org/nightly/std/primitive.bool.html
|
||||||
|
|
|
@ -246,11 +246,11 @@ where
|
||||||
/// [`frac_nbits`]: #tymethod.frac_nbits
|
/// [`frac_nbits`]: #tymethod.frac_nbits
|
||||||
type Frac: Unsigned;
|
type Frac: Unsigned;
|
||||||
|
|
||||||
/// Returns the smallest value that can be represented.
|
/// The smallest value that can be represented.
|
||||||
fn min_value() -> Self;
|
const MIN: Self;
|
||||||
|
|
||||||
/// Returns the largest value that can be represented.
|
/// The largest value that can be represented.
|
||||||
fn max_value() -> Self;
|
const MAX: Self;
|
||||||
|
|
||||||
/// Returns the number of integer bits.
|
/// Returns the number of integer bits.
|
||||||
fn int_nbits() -> u32;
|
fn int_nbits() -> u32;
|
||||||
|
@ -985,6 +985,18 @@ where
|
||||||
/// [tuple]: https://doc.rust-lang.org/nightly/std/primitive.tuple.html
|
/// [tuple]: https://doc.rust-lang.org/nightly/std/primitive.tuple.html
|
||||||
fn overflowing_shr(self, rhs: u32) -> (Self, bool);
|
fn overflowing_shr(self, rhs: u32) -> (Self, bool);
|
||||||
|
|
||||||
|
/// Returns the smallest value that can be represented.
|
||||||
|
#[deprecated(since = "0.5.5", note = "replaced by `MIN`")]
|
||||||
|
fn min_value() -> Self {
|
||||||
|
Self::MIN
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Returns the largest value that can be represented.
|
||||||
|
#[deprecated(since = "0.5.5", note = "replaced by `MAX`")]
|
||||||
|
fn max_value() -> Self {
|
||||||
|
Self::MAX
|
||||||
|
}
|
||||||
|
|
||||||
/// Remainder for division by an integer.
|
/// Remainder for division by an integer.
|
||||||
///
|
///
|
||||||
/// # Panics
|
/// # Panics
|
||||||
|
@ -1173,6 +1185,7 @@ where
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// TODO when rustc requirement >= 1.43.0, use MAX instead of max_value() in example
|
||||||
/// This trait provides checked conversions from fixed-point numbers.
|
/// This trait provides checked conversions from fixed-point numbers.
|
||||||
///
|
///
|
||||||
/// This trait is implemented for conversions between integer
|
/// This trait is implemented for conversions between integer
|
||||||
|
@ -1261,7 +1274,7 @@ pub trait FromFixed {
|
||||||
/// let checked: Option<U8F8> = too_large.checked_to_num();
|
/// let checked: Option<U8F8> = too_large.checked_to_num();
|
||||||
/// assert_eq!(checked, None);
|
/// assert_eq!(checked, None);
|
||||||
/// let saturating: U8F8 = too_large.saturating_to_num();
|
/// let saturating: U8F8 = too_large.saturating_to_num();
|
||||||
/// assert_eq!(saturating, U8F8::max_value());
|
/// assert_eq!(saturating, U8F8::MAX);
|
||||||
/// let wrapping: U8F8 = too_large.wrapping_to_num();
|
/// let wrapping: U8F8 = too_large.wrapping_to_num();
|
||||||
/// assert_eq!(wrapping, U8F8::from_bits(0x3456));
|
/// assert_eq!(wrapping, U8F8::from_bits(0x3456));
|
||||||
/// let overflowing: (U8F8, bool) = too_large.overflowing_to_num();
|
/// let overflowing: (U8F8, bool) = too_large.overflowing_to_num();
|
||||||
|
@ -1747,8 +1760,8 @@ macro_rules! impl_fixed {
|
||||||
type Bits = $Bits;
|
type Bits = $Bits;
|
||||||
type Bytes = [u8; mem::size_of::<$Bits>()];
|
type Bytes = [u8; mem::size_of::<$Bits>()];
|
||||||
type Frac = Frac;
|
type Frac = Frac;
|
||||||
trait_delegate! { fn min_value() -> Self }
|
const MIN: Self = Self::MIN;
|
||||||
trait_delegate! { fn max_value() -> Self }
|
const MAX: Self = Self::MAX;
|
||||||
trait_delegate! { fn int_nbits() -> u32 }
|
trait_delegate! { fn int_nbits() -> u32 }
|
||||||
trait_delegate! { fn frac_nbits() -> u32 }
|
trait_delegate! { fn frac_nbits() -> u32 }
|
||||||
trait_delegate! { fn from_bits(bits: Self::Bits) -> Self }
|
trait_delegate! { fn from_bits(bits: Self::Bits) -> Self }
|
||||||
|
@ -1923,18 +1936,14 @@ macro_rules! impl_fixed {
|
||||||
fn saturating_from_fixed<F: Fixed>(src: F) -> Self {
|
fn saturating_from_fixed<F: Fixed>(src: F) -> Self {
|
||||||
let conv = src.private_to_fixed_helper(Self::FRAC_NBITS, Self::INT_NBITS);
|
let conv = src.private_to_fixed_helper(Self::FRAC_NBITS, Self::INT_NBITS);
|
||||||
if conv.overflow {
|
if conv.overflow {
|
||||||
return if src < 0 {
|
return if src < 0 { Self::MIN } else { Self::MAX };
|
||||||
Self::min_value()
|
|
||||||
} else {
|
|
||||||
Self::max_value()
|
|
||||||
};
|
|
||||||
}
|
}
|
||||||
let bits = if_signed_unsigned! {
|
let bits = if_signed_unsigned! {
|
||||||
$Signedness,
|
$Signedness,
|
||||||
match conv.bits {
|
match conv.bits {
|
||||||
Widest::Unsigned(bits) => {
|
Widest::Unsigned(bits) => {
|
||||||
if (bits as $Bits) < 0 {
|
if (bits as $Bits) < 0 {
|
||||||
return Self::max_value();
|
return Self::MAX;
|
||||||
}
|
}
|
||||||
bits as $Bits
|
bits as $Bits
|
||||||
}
|
}
|
||||||
|
@ -1943,7 +1952,7 @@ macro_rules! impl_fixed {
|
||||||
match conv.bits {
|
match conv.bits {
|
||||||
Widest::Unsigned(bits) => bits as $Bits,
|
Widest::Unsigned(bits) => bits as $Bits,
|
||||||
Widest::Negative(_) => {
|
Widest::Negative(_) => {
|
||||||
return Self::min_value();
|
return Self::MIN;
|
||||||
}
|
}
|
||||||
},
|
},
|
||||||
};
|
};
|
||||||
|
|
|
@ -42,40 +42,34 @@ use core::{
|
||||||
///
|
///
|
||||||
/// ```rust
|
/// ```rust
|
||||||
/// use fixed::{types::I16F16, Wrapping};
|
/// use fixed::{types::I16F16, Wrapping};
|
||||||
/// let max = Wrapping(I16F16::max_value());
|
/// let max = Wrapping(I16F16::MAX);
|
||||||
/// let delta = Wrapping(I16F16::from_bits(1));
|
/// let delta = Wrapping(I16F16::from_bits(1));
|
||||||
/// assert_eq!(I16F16::min_value(), (max + delta).0);
|
/// assert_eq!(I16F16::MIN, (max + delta).0);
|
||||||
/// ```
|
/// ```
|
||||||
#[repr(transparent)]
|
#[repr(transparent)]
|
||||||
#[derive(Clone, Copy, Default, Hash, Debug, Eq, PartialEq, Ord, PartialOrd)]
|
#[derive(Clone, Copy, Default, Hash, Debug, Eq, PartialEq, Ord, PartialOrd)]
|
||||||
pub struct Wrapping<F>(pub F);
|
pub struct Wrapping<F>(pub F);
|
||||||
|
|
||||||
impl<F: Fixed> Wrapping<F> {
|
impl<F: Fixed> Wrapping<F> {
|
||||||
/// Returns the smallest value that can be represented.
|
/// The smallest value that can be represented.
|
||||||
///
|
///
|
||||||
/// # Examples
|
/// # Examples
|
||||||
///
|
///
|
||||||
/// ```rust
|
/// ```rust
|
||||||
/// use fixed::{types::I16F16, Wrapping};
|
/// use fixed::{types::I16F16, Wrapping};
|
||||||
/// assert_eq!(Wrapping::<I16F16>::min_value(), Wrapping(I16F16::min_value()));
|
/// assert_eq!(Wrapping::<I16F16>::MIN, Wrapping(I16F16::MIN));
|
||||||
/// ```
|
/// ```
|
||||||
#[inline]
|
pub const MIN: Wrapping<F> = Wrapping(F::MIN);
|
||||||
pub fn min_value() -> Wrapping<F> {
|
|
||||||
Wrapping(F::min_value())
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns the largest value that can be represented.
|
/// The largest value that can be represented.
|
||||||
///
|
///
|
||||||
/// # Examples
|
/// # Examples
|
||||||
///
|
///
|
||||||
/// ```rust
|
/// ```rust
|
||||||
/// use fixed::{types::I16F16, Wrapping};
|
/// use fixed::{types::I16F16, Wrapping};
|
||||||
/// assert_eq!(Wrapping::<I16F16>::max_value(), Wrapping(I16F16::max_value()));
|
/// assert_eq!(Wrapping::<I16F16>::MAX, Wrapping(I16F16::MAX));
|
||||||
/// ```
|
/// ```
|
||||||
#[inline]
|
pub const MAX: Wrapping<F> = Wrapping(F::MAX);
|
||||||
pub fn max_value() -> Wrapping<F> {
|
|
||||||
Wrapping(F::max_value())
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns the number of integer bits.
|
/// Returns the number of integer bits.
|
||||||
///
|
///
|
||||||
|
@ -233,8 +227,8 @@ impl<F: Fixed> Wrapping<F> {
|
||||||
/// assert_eq!(src.to_num::<I16F16>(), expected);
|
/// assert_eq!(src.to_num::<I16F16>(), expected);
|
||||||
///
|
///
|
||||||
/// // conversion that wraps
|
/// // conversion that wraps
|
||||||
/// let src = Wrapping(I4F4::max_value());
|
/// let src = Wrapping(I4F4::MAX);
|
||||||
/// let wrapped = I2F6::from_bits(I2F6::max_value().to_bits() << 2);
|
/// let wrapped = I2F6::from_bits(I2F6::MAX.to_bits() << 2);
|
||||||
/// assert_eq!(src.to_num::<I2F6>(), wrapped);
|
/// assert_eq!(src.to_num::<I2F6>(), wrapped);
|
||||||
/// ```
|
/// ```
|
||||||
///
|
///
|
||||||
|
@ -382,7 +376,7 @@ impl<F: Fixed> Wrapping<F> {
|
||||||
/// use fixed::{types::I16F16, Wrapping};
|
/// use fixed::{types::I16F16, Wrapping};
|
||||||
/// let two_half = Wrapping(I16F16::from_num(5) / 2);
|
/// let two_half = Wrapping(I16F16::from_num(5) / 2);
|
||||||
/// assert_eq!(two_half.ceil(), Wrapping(I16F16::from_num(3)));
|
/// assert_eq!(two_half.ceil(), Wrapping(I16F16::from_num(3)));
|
||||||
/// assert_eq!(Wrapping(I16F16::max_value()).ceil(), Wrapping(I16F16::min_value()));
|
/// assert_eq!(Wrapping(I16F16::MAX).ceil(), Wrapping(I16F16::MIN));
|
||||||
/// ```
|
/// ```
|
||||||
#[inline]
|
#[inline]
|
||||||
pub fn ceil(self) -> Wrapping<F> {
|
pub fn ceil(self) -> Wrapping<F> {
|
||||||
|
@ -404,7 +398,7 @@ impl<F: Fixed> Wrapping<F> {
|
||||||
/// };
|
/// };
|
||||||
/// let two_half = Wrapping(I16F16::from_num(5) / 2);
|
/// let two_half = Wrapping(I16F16::from_num(5) / 2);
|
||||||
/// assert_eq!(two_half.floor(), Wrapping(I16F16::from_num(2)));
|
/// assert_eq!(two_half.floor(), Wrapping(I16F16::from_num(2)));
|
||||||
/// assert_eq!(Wrapping(I0F32::min_value()).floor(), Wrapping(I0F32::from_num(0)));
|
/// assert_eq!(Wrapping(I0F32::MIN).floor(), Wrapping(I0F32::from_num(0)));
|
||||||
/// ```
|
/// ```
|
||||||
#[inline]
|
#[inline]
|
||||||
pub fn floor(self) -> Wrapping<F> {
|
pub fn floor(self) -> Wrapping<F> {
|
||||||
|
@ -421,7 +415,7 @@ impl<F: Fixed> Wrapping<F> {
|
||||||
/// let two_half = Wrapping(I16F16::from_num(5) / 2);
|
/// let two_half = Wrapping(I16F16::from_num(5) / 2);
|
||||||
/// assert_eq!(two_half.round(), Wrapping(I16F16::from_num(3)));
|
/// assert_eq!(two_half.round(), Wrapping(I16F16::from_num(3)));
|
||||||
/// assert_eq!((-two_half).round(), Wrapping(I16F16::from_num(-3)));
|
/// assert_eq!((-two_half).round(), Wrapping(I16F16::from_num(-3)));
|
||||||
/// assert_eq!(Wrapping(I16F16::max_value()).round(), Wrapping(I16F16::min_value()));
|
/// assert_eq!(Wrapping(I16F16::MAX).round(), Wrapping(I16F16::MIN));
|
||||||
/// ```
|
/// ```
|
||||||
#[inline]
|
#[inline]
|
||||||
pub fn round(self) -> Wrapping<F> {
|
pub fn round(self) -> Wrapping<F> {
|
||||||
|
@ -439,8 +433,8 @@ impl<F: Fixed> Wrapping<F> {
|
||||||
/// assert_eq!(two_half.round_ties_to_even(), Wrapping(I16F16::from_num(2)));
|
/// assert_eq!(two_half.round_ties_to_even(), Wrapping(I16F16::from_num(2)));
|
||||||
/// let three_half = Wrapping(I16F16::from_num(3.5));
|
/// let three_half = Wrapping(I16F16::from_num(3.5));
|
||||||
/// assert_eq!(three_half.round_ties_to_even(), Wrapping(I16F16::from_num(4)));
|
/// assert_eq!(three_half.round_ties_to_even(), Wrapping(I16F16::from_num(4)));
|
||||||
/// let max = Wrapping(I16F16::max_value());
|
/// let max = Wrapping(I16F16::MAX);
|
||||||
/// assert_eq!(max.round_ties_to_even(), Wrapping(I16F16::min_value()));
|
/// assert_eq!(max.round_ties_to_even(), Wrapping(I16F16::MIN));
|
||||||
/// ```
|
/// ```
|
||||||
#[inline]
|
#[inline]
|
||||||
pub fn round_ties_to_even(self) -> Wrapping<F> {
|
pub fn round_ties_to_even(self) -> Wrapping<F> {
|
||||||
|
@ -555,8 +549,8 @@ impl<F: Fixed> Wrapping<F> {
|
||||||
/// let den = Wrapping(I16F16::from_num(2));
|
/// let den = Wrapping(I16F16::from_num(2));
|
||||||
/// assert_eq!(num.div_euclid(den), Wrapping(I16F16::from_num(3)));
|
/// assert_eq!(num.div_euclid(den), Wrapping(I16F16::from_num(3)));
|
||||||
/// let quarter = Wrapping(I16F16::from_num(0.25));
|
/// let quarter = Wrapping(I16F16::from_num(0.25));
|
||||||
/// let check = (Wrapping::max_value() * 4i32).round_to_zero();
|
/// let check = (Wrapping::MAX * 4i32).round_to_zero();
|
||||||
/// assert_eq!(Wrapping::max_value().div_euclid(quarter), check);
|
/// assert_eq!(Wrapping::MAX.div_euclid(quarter), check);
|
||||||
/// ```
|
/// ```
|
||||||
#[inline]
|
#[inline]
|
||||||
pub fn div_euclid(self, divisor: Wrapping<F>) -> Wrapping<F> {
|
pub fn div_euclid(self, divisor: Wrapping<F>) -> Wrapping<F> {
|
||||||
|
@ -595,7 +589,7 @@ impl<F: Fixed> Wrapping<F> {
|
||||||
/// use fixed::{types::I16F16, Wrapping};
|
/// use fixed::{types::I16F16, Wrapping};
|
||||||
/// let num = Wrapping(I16F16::from_num(7.5));
|
/// let num = Wrapping(I16F16::from_num(7.5));
|
||||||
/// assert_eq!(num.div_euclid_int(2), Wrapping(I16F16::from_num(3)));
|
/// assert_eq!(num.div_euclid_int(2), Wrapping(I16F16::from_num(3)));
|
||||||
/// let min = Wrapping(I16F16::min_value());
|
/// let min = Wrapping(I16F16::MIN);
|
||||||
/// assert_eq!(min.div_euclid_int(-1), min);
|
/// assert_eq!(min.div_euclid_int(-1), min);
|
||||||
/// ```
|
/// ```
|
||||||
#[inline]
|
#[inline]
|
||||||
|
@ -621,6 +615,20 @@ impl<F: Fixed> Wrapping<F> {
|
||||||
pub fn rem_euclid_int(self, divisor: F::Bits) -> Wrapping<F> {
|
pub fn rem_euclid_int(self, divisor: F::Bits) -> Wrapping<F> {
|
||||||
Wrapping(self.0.wrapping_rem_euclid_int(divisor))
|
Wrapping(self.0.wrapping_rem_euclid_int(divisor))
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// Returns the smallest value that can be represented.
|
||||||
|
#[deprecated(since = "0.5.5", note = "replaced by `MIN`")]
|
||||||
|
#[inline]
|
||||||
|
pub fn min_value() -> Wrapping<F> {
|
||||||
|
Self::MIN
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Returns the largest value that can be represented.
|
||||||
|
#[inline]
|
||||||
|
#[deprecated(since = "0.5.5", note = "replaced by `MAX`")]
|
||||||
|
pub fn max_value() -> Wrapping<F> {
|
||||||
|
Self::MAX
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<F: FixedSigned> Wrapping<F> {
|
impl<F: FixedSigned> Wrapping<F> {
|
||||||
|
@ -669,7 +677,7 @@ impl<F: FixedSigned> Wrapping<F> {
|
||||||
/// ```rust
|
/// ```rust
|
||||||
/// use fixed::{types::I16F16, Wrapping};
|
/// use fixed::{types::I16F16, Wrapping};
|
||||||
/// assert_eq!(Wrapping(I16F16::from_num(-5)).abs(), Wrapping(I16F16::from_num(5)));
|
/// assert_eq!(Wrapping(I16F16::from_num(-5)).abs(), Wrapping(I16F16::from_num(5)));
|
||||||
/// assert_eq!(Wrapping(I16F16::min_value()).abs(), Wrapping(I16F16::min_value()));
|
/// assert_eq!(Wrapping(I16F16::MIN).abs(), Wrapping(I16F16::MIN));
|
||||||
/// ```
|
/// ```
|
||||||
#[inline]
|
#[inline]
|
||||||
pub fn abs(self) -> Wrapping<F> {
|
pub fn abs(self) -> Wrapping<F> {
|
||||||
|
@ -749,7 +757,7 @@ impl<F: FixedUnsigned> Wrapping<F> {
|
||||||
/// let four = Wrapping(U16F16::from_num(4));
|
/// let four = Wrapping(U16F16::from_num(4));
|
||||||
/// assert_eq!(Wrapping(U16F16::from_num(4)).next_power_of_two(), four);
|
/// assert_eq!(Wrapping(U16F16::from_num(4)).next_power_of_two(), four);
|
||||||
/// let zero = Wrapping(U16F16::from_num(0));
|
/// let zero = Wrapping(U16F16::from_num(0));
|
||||||
/// assert_eq!(Wrapping(U16F16::max_value()).next_power_of_two(), zero);
|
/// assert_eq!(Wrapping(U16F16::MAX).next_power_of_two(), zero);
|
||||||
/// ```
|
/// ```
|
||||||
#[inline]
|
#[inline]
|
||||||
pub fn next_power_of_two(self) -> Wrapping<F> {
|
pub fn next_power_of_two(self) -> Wrapping<F> {
|
||||||
|
|
Loading…
Reference in New Issue