[#1] Removing unneeded imports and adjusting code.

Bounded was brought over from the weave library since weave is being
eliminated. Also, at some point along the way, rust 1.43.0, f32 and
f64 started defining NaN, so now we are using the compiler definitions.
This commit is contained in:
Myrddin Dundragon 2025-03-10 12:17:37 -04:00
parent f670beacef
commit 273a7c1699
4 changed files with 110 additions and 8 deletions

100
src/bounded.rs Normal file
View File

@ -0,0 +1,100 @@
/// Primitive types that have upper and lower bounds.
pub trait Bounded
{
/// The minimum value for this type.
const MIN: Self;
/// The maximum value for this type.
const MAX: Self;
}
/// A macro for making implementation of
/// the Bounded trait easier.
macro_rules! bounded_trait_impl
{
($T: ty, $minVal: expr, $maxVal: expr) =>
{
impl Bounded for $T
{
const MIN: $T = $minVal;
const MAX: $T = $maxVal;
}
}
}
// Implement the Bounded for all the primitive types.
bounded_trait_impl!(u8, 0u8, !0u8);
bounded_trait_impl!(u16, 0u16, !0u16);
bounded_trait_impl!(u32, 0u32, !0u32);
bounded_trait_impl!(u64, 0u64, !0u64);
bounded_trait_impl!(usize, 0usize, !0usize);
bounded_trait_impl!(i8, (!0i8 ^ (!0u8 >> 1u8) as i8),
!(!0i8 ^ (!0u8 >> 1u8) as i8));
bounded_trait_impl!(i16, (!0i16 ^ (!0u16 >> 1u16) as i16),
!(!0i16 ^ (!0u16 >> 1u16) as i16));
bounded_trait_impl!(i32, (!0i32 ^ (!0u32 >> 1u32) as i32),
!(!0i32 ^ (!0u32 >> 1u32) as i32));
bounded_trait_impl!(i64, (!0i64 ^ (!0u64 >> 1u64) as i64),
!(!0i64 ^ (!0u64 >> 1u64) as i64));
bounded_trait_impl!(isize, (!0isize ^ (!0usize >> 1usize) as isize),
!(!0isize ^ (!0usize >> 1usize) as isize));
bounded_trait_impl!(f32, -3.40282347e+38f32, 3.40282347e+38f32);
bounded_trait_impl!(f64, -1.7976931348623157e+308f64,
1.7976931348623157e+308f64);
#[cfg(test)]
mod tests
{
macro_rules! bounds_test
{
($T: ident, $func_name: ident, $minVal: expr, $maxVal: expr) =>
{
#[test]
fn $func_name()
{
use bounded::Bounded;
assert_eq!($T::MIN, $minVal);
assert_eq!($T::MAX, $maxVal);
}
}
}
bounds_test!(u8, min_max_u8, 0u8, !0u8);
bounds_test!(u16, min_max_u16, 0u16, !0u16);
bounds_test!(u32, min_max_u32, 0u32, !0u32);
bounds_test!(u64, min_max_u64, 0u64, !0u64);
bounds_test!(usize, min_max_usize, 0usize, !0usize);
bounds_test!(i8, min_max_i8,
-1i8 << (((::std::mem::size_of::<i8>() as i8)*8i8)-1i8),
!(-1i8 << (((::std::mem::size_of::<i8>() as i8)*8i8)-1i8)));
bounds_test!(i16, min_max_i16,
-1i16 << (((::std::mem::size_of::<i16>() as i16)*8i16)-1i16),
!(-1i16 << (((::std::mem::size_of::<i16>() as i16)*8i16)-1i16)));
bounds_test!(i32, min_max_i32,
-1i32 << (((::std::mem::size_of::<i32>() as i32)*8i32)-1i32),
!(-1i32 << (((::std::mem::size_of::<i32>() as i32)*8i32)-1i32)));
bounds_test!(i64, min_max_i64,
-1i64 << (((::std::mem::size_of::<i64>() as i64)*8i64)-1i64),
!(-1i64 << (((::std::mem::size_of::<i64>() as i64)*8i64)-1i64)));
bounds_test!(isize, min_max_isize,
-1isize << (((::std::mem::size_of::<isize>() as isize)*8isize)-1isize),
!(-1isize << (((::std::mem::size_of::<isize>() as isize)*8isize)-1isize)));
bounds_test!(f32, min_max_f32,
-3.40282347e+38f32, 3.40282347e+38f32);
bounds_test!(f64, min_max_f64,
-1.7976931348623157e+308f64,
1.7976931348623157e+308f64);
}

View File

@ -10,6 +10,8 @@ extern crate core as std;
#[macro_use] #[macro_use]
mod macros; mod macros;
mod bounded;
mod zero; mod zero;
mod one; mod one;
mod number; mod number;
@ -26,6 +28,7 @@ pub mod quaternion;
pub use self::bounded::Bounded;
pub use self::zero::Zero; pub use self::zero::Zero;
pub use self::one::One; pub use self::one::One;
pub use self::number::Number; pub use self::number::Number;

View File

@ -5,8 +5,7 @@ use std::ops::{Add, Sub, Mul, Div, Rem};
use std::ops::{AddAssign, SubAssign, MulAssign, DivAssign, RemAssign}; use std::ops::{AddAssign, SubAssign, MulAssign, DivAssign, RemAssign};
use std::str::FromStr; use std::str::FromStr;
use weave::Bounded; use crate::bounded::Bounded;
use crate::zero::Zero; use crate::zero::Zero;
use crate::one::One; use crate::one::One;

View File

@ -646,18 +646,18 @@ impl Real for f32
const NEG_INFINITY: Self = -1.0f32 / 0.0f32; const NEG_INFINITY: Self = -1.0f32 / 0.0f32;
/// ///
const NAN: Self = 0.0f32 / 0.0f32; const NAN: Self = f32::NAN;
fn is_nan(self) -> bool fn is_nan(self) -> bool
{ {
self == Self::NAN self.is_nan()
} }
fn is_finite(self) -> bool fn is_finite(self) -> bool
{ {
!self.is_infinite() && self != Self::NAN !self.is_infinite() && !self.is_nan()
} }
fn is_infinite(self) -> bool fn is_infinite(self) -> bool
@ -908,18 +908,18 @@ impl Real for f64
const NEG_INFINITY: Self = -1.0f64 / 0.0f64; const NEG_INFINITY: Self = -1.0f64 / 0.0f64;
/// ///
const NAN: Self = 0.0f64 / 0.0f64; const NAN: Self = f64::NAN;
fn is_nan(self) -> bool fn is_nan(self) -> bool
{ {
self == Self::NAN self.is_nan()
} }
fn is_finite(self) -> bool fn is_finite(self) -> bool
{ {
!self.is_infinite() && self != Self::NAN !self.is_infinite() && !self.is_nan()
} }
fn is_infinite(self) -> bool fn is_infinite(self) -> bool