From 18e666a620d6d5fbb0998f7949a1697a820bcf75 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jean-S=C3=A9bastien=20Bour?= Date: Wed, 25 Sep 2024 17:18:43 +0200 Subject: [PATCH 1/2] Update to Rust edition 2021 --- Cargo.toml | 3 ++- src/abs_diff_eq.rs | 4 ++-- src/lib.rs | 12 ++---------- src/relative_eq.rs | 3 ++- src/ulps_eq.rs | 2 +- tests/abs_diff_eq.rs | 18 +++++++++++++----- tests/macro_import.rs | 2 -- tests/macros.rs | 6 ++++-- tests/relative_eq.rs | 18 +++++++++++++----- tests/ulps_eq.rs | 18 +++++++++++++----- 10 files changed, 52 insertions(+), 34 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index d4ff24d..fc05a2a 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -4,6 +4,7 @@ version = "0.5.1" authors = ["Brendan Zabarauskas "] license = "Apache-2.0" description = "Approximate floating point equality comparisons and assertions." +edition = "2021" documentation = "https://docs.rs/approx" homepage = "https://github.com/brendanzab/approx" @@ -29,5 +30,5 @@ default = ["std"] std = [] [dependencies] -num-traits = { version = "0.2.0", default_features = false } +num-traits = { version = "0.2.0", default-features = false } num-complex = { version = "0.4.0", optional = true } diff --git a/src/abs_diff_eq.rs b/src/abs_diff_eq.rs index b3b3974..52d0f07 100644 --- a/src/abs_diff_eq.rs +++ b/src/abs_diff_eq.rs @@ -83,8 +83,8 @@ impl_signed_abs_diff_eq!(i16, 0); impl_signed_abs_diff_eq!(i32, 0); impl_signed_abs_diff_eq!(i64, 0); impl_signed_abs_diff_eq!(isize, 0); -impl_signed_abs_diff_eq!(f32, core::f32::EPSILON); -impl_signed_abs_diff_eq!(f64, core::f64::EPSILON); +impl_signed_abs_diff_eq!(f32, f32::EPSILON); +impl_signed_abs_diff_eq!(f64, f64::EPSILON); /////////////////////////////////////////////////////////////////////////////////////////////////// // Derived implementations diff --git a/src/lib.rs b/src/lib.rs index 4730864..e258cc4 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -20,10 +20,8 @@ //! more positional style: //! //! ```rust -//! #[macro_use] -//! extern crate approx; -//! //! use std::f64; +//! use approx::{abs_diff_eq, relative_eq, ulps_eq}; //! //! # fn main() { //! abs_diff_eq!(1.0, 1.0); @@ -51,9 +49,7 @@ //! For example, we might want to be able to do approximate assertions on a complex number type: //! //! ```rust -//! #[macro_use] -//! extern crate approx; -//! # use approx::{AbsDiffEq, RelativeEq, UlpsEq}; +//! # use approx::{AbsDiffEq, RelativeEq, UlpsEq, assert_relative_eq, assert_ulps_eq}; //! //! #[derive(Debug, PartialEq)] //! struct Complex { @@ -157,10 +153,6 @@ #![no_std] #![allow(clippy::transmute_float_to_int)] -#[cfg(feature = "num-complex")] -extern crate num_complex; -extern crate num_traits; - mod abs_diff_eq; mod relative_eq; mod ulps_eq; diff --git a/src/relative_eq.rs b/src/relative_eq.rs index 2919044..65cb927 100644 --- a/src/relative_eq.rs +++ b/src/relative_eq.rs @@ -1,7 +1,8 @@ use core::{cell, f32, f64}; #[cfg(feature = "num-complex")] use num_complex::Complex; -use AbsDiffEq; + +use crate::AbsDiffEq; /// Equality comparisons between two numbers using both the absolute difference and /// relative based comparisons. diff --git a/src/ulps_eq.rs b/src/ulps_eq.rs index 6e58dfa..d182bfc 100644 --- a/src/ulps_eq.rs +++ b/src/ulps_eq.rs @@ -3,7 +3,7 @@ use core::cell; use num_complex::Complex; use num_traits::Signed; -use AbsDiffEq; +use crate::AbsDiffEq; /// Equality comparisons between two numbers using both the absolute difference and ULPs /// (Units in Last Place) based comparisons. diff --git a/tests/abs_diff_eq.rs b/tests/abs_diff_eq.rs index 90e8f1a..37347fd 100644 --- a/tests/abs_diff_eq.rs +++ b/tests/abs_diff_eq.rs @@ -16,10 +16,8 @@ // https://github.com/Pybonacci/puntoflotante.org/blob/master/content/errors/NearlyEqualsTest.java #![no_std] -#[macro_use] -extern crate approx; - mod test_f32 { + use approx::{assert_abs_diff_eq, assert_abs_diff_ne}; use core::f32; #[test] @@ -189,6 +187,7 @@ mod test_f32 { #[cfg(test)] mod test_f64 { + use approx::{assert_abs_diff_eq, assert_abs_diff_ne}; use core::f64; #[test] @@ -358,6 +357,8 @@ mod test_f64 { mod test_ref { mod test_f32 { + use approx::{assert_abs_diff_eq, assert_abs_diff_ne}; + #[test] fn test_basic() { assert_abs_diff_eq!(&1.0f32, &1.0f32); @@ -366,6 +367,8 @@ mod test_ref { } mod test_f64 { + use approx::{assert_abs_diff_eq, assert_abs_diff_ne}; + #[test] fn test_basic() { assert_abs_diff_eq!(&1.0f64, &1.0f64); @@ -376,6 +379,8 @@ mod test_ref { mod test_slice { mod test_f32 { + use approx::{assert_abs_diff_eq, assert_abs_diff_ne}; + #[test] fn test_basic() { assert_abs_diff_eq!([1.0f32, 2.0f32][..], [1.0f32, 2.0f32][..]); @@ -384,6 +389,8 @@ mod test_slice { } mod test_f64 { + use approx::{assert_abs_diff_eq, assert_abs_diff_ne}; + #[test] fn test_basic() { assert_abs_diff_eq!([1.0f64, 2.0f64][..], [1.0f64, 2.0f64][..]); @@ -394,11 +401,11 @@ mod test_slice { #[cfg(feature = "num-complex")] mod test_complex { - extern crate num_complex; - pub use self::num_complex::Complex; + pub use num_complex::Complex; mod test_f32 { use super::Complex; + use approx::{assert_abs_diff_eq, assert_abs_diff_ne}; #[test] fn test_basic() { @@ -421,6 +428,7 @@ mod test_complex { mod test_f64 { use super::Complex; + use approx::{assert_abs_diff_eq, assert_abs_diff_ne}; #[test] fn test_basic() { diff --git a/tests/macro_import.rs b/tests/macro_import.rs index 02b949d..6ff6d3f 100644 --- a/tests/macro_import.rs +++ b/tests/macro_import.rs @@ -1,5 +1,3 @@ -extern crate approx; - mod test_macro_import { use approx::{ assert_abs_diff_eq, assert_abs_diff_ne, assert_relative_eq, assert_relative_ne, diff --git a/tests/macros.rs b/tests/macros.rs index 223d89c..0d8d257 100644 --- a/tests/macros.rs +++ b/tests/macros.rs @@ -14,8 +14,10 @@ //! Macro instantiation tests -#[macro_use] -extern crate approx; +use approx::{ + abs_diff_eq, abs_diff_ne, assert_abs_diff_eq, assert_relative_eq, assert_ulps_eq, relative_eq, + relative_ne, ulps_eq, ulps_ne, +}; #[test] fn test_abs_diff_eq() { diff --git a/tests/relative_eq.rs b/tests/relative_eq.rs index 3a7629e..f72d979 100644 --- a/tests/relative_eq.rs +++ b/tests/relative_eq.rs @@ -16,10 +16,8 @@ // https://github.com/Pybonacci/puntoflotante.org/blob/master/content/errors/NearlyEqualsTest.java #![no_std] -#[macro_use] -extern crate approx; - mod test_f32 { + use approx::{assert_relative_eq, assert_relative_ne}; use core::f32; #[test] @@ -191,6 +189,7 @@ mod test_f32 { #[cfg(test)] mod test_f64 { + use approx::{assert_relative_eq, assert_relative_ne}; use core::f64; #[test] @@ -356,6 +355,8 @@ mod test_f64 { mod test_ref { mod test_f32 { + use approx::{assert_relative_eq, assert_relative_ne}; + #[test] fn test_basic() { assert_relative_eq!(&1.0f32, &1.0f32); @@ -364,6 +365,8 @@ mod test_ref { } mod test_f64 { + use approx::{assert_relative_eq, assert_relative_ne}; + #[test] fn test_basic() { assert_relative_eq!(&1.0f64, &1.0f64); @@ -374,6 +377,8 @@ mod test_ref { mod test_slice { mod test_f32 { + use approx::{assert_relative_eq, assert_relative_ne}; + #[test] fn test_basic() { assert_relative_eq!([1.0f32, 2.0f32][..], [1.0f32, 2.0f32][..]); @@ -382,6 +387,8 @@ mod test_slice { } mod test_f64 { + use approx::{assert_relative_eq, assert_relative_ne}; + #[test] fn test_basic() { assert_relative_eq!([1.0f64, 2.0f64][..], [1.0f64, 2.0f64][..]); @@ -392,11 +399,11 @@ mod test_slice { #[cfg(feature = "num-complex")] mod test_complex { - extern crate num_complex; - pub use self::num_complex::Complex; + pub use num_complex::Complex; mod test_f32 { use super::Complex; + use approx::{assert_relative_eq, assert_relative_ne}; #[test] fn test_basic() { @@ -419,6 +426,7 @@ mod test_complex { mod test_f64 { use super::Complex; + use approx::{assert_relative_eq, assert_relative_ne}; #[test] fn test_basic() { diff --git a/tests/ulps_eq.rs b/tests/ulps_eq.rs index b0e89ed..4db0211 100644 --- a/tests/ulps_eq.rs +++ b/tests/ulps_eq.rs @@ -16,10 +16,8 @@ // https://github.com/Pybonacci/puntoflotante.org/blob/master/content/errors/NearlyEqualsTest.java #![no_std] -#[macro_use] -extern crate approx; - mod test_f32 { + use approx::{assert_ulps_eq, assert_ulps_ne}; use core::f32; #[test] @@ -187,6 +185,7 @@ mod test_f32 { #[cfg(test)] mod test_f64 { + use approx::{assert_ulps_eq, assert_ulps_ne}; use core::f64; #[test] @@ -354,6 +353,8 @@ mod test_f64 { mod test_ref { mod test_f32 { + use approx::{assert_ulps_eq, assert_ulps_ne}; + #[test] fn test_basic() { assert_ulps_eq!(&1.0f32, &1.0f32); @@ -362,6 +363,8 @@ mod test_ref { } mod test_f64 { + use approx::{assert_ulps_eq, assert_ulps_ne}; + #[test] fn test_basic() { assert_ulps_eq!(&1.0f64, &1.0f64); @@ -372,6 +375,8 @@ mod test_ref { mod test_slice { mod test_f32 { + use approx::{assert_ulps_eq, assert_ulps_ne}; + #[test] fn test_basic() { assert_ulps_eq!([1.0f32, 2.0f32][..], [1.0f32, 2.0f32][..]); @@ -382,6 +387,8 @@ mod test_slice { mod test_f64 { #[test] fn test_basic() { + use approx::{assert_ulps_eq, assert_ulps_ne}; + assert_ulps_eq!([1.0f64, 2.0f64][..], [1.0f64, 2.0f64][..]); assert_ulps_ne!([1.0f64, 2.0f64][..], [2.0f64, 1.0f64][..]); } @@ -390,11 +397,11 @@ mod test_slice { #[cfg(feature = "num-complex")] mod test_complex { - extern crate num_complex; - pub use self::num_complex::Complex; + pub use num_complex::Complex; mod test_f32 { use super::Complex; + use approx::{assert_ulps_eq, assert_ulps_ne}; #[test] fn test_basic() { @@ -417,6 +424,7 @@ mod test_complex { mod test_f64 { use super::Complex; + use approx::{assert_ulps_eq, assert_ulps_ne}; #[test] fn test_basic() { From 65134eb07a5eb9aba87af0e6b2a38f0fb9e1930e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jean-S=C3=A9bastien=20Bour?= Date: Wed, 25 Sep 2024 17:37:28 +0200 Subject: [PATCH 2/2] Update dependencies --- Cargo.toml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index fc05a2a..cb030ac 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -30,5 +30,5 @@ default = ["std"] std = [] [dependencies] -num-traits = { version = "0.2.0", default-features = false } -num-complex = { version = "0.4.0", optional = true } +num-traits = { version = "0.2.19", default-features = false } +num-complex = { version = "0.4.6", optional = true }