Skip to content

Commit 2e4790c

Browse files
nikomatsakisnikomatsakis
committed
Merge remote-tracking branch 'mozilla/incoming' into issue-5910-dyna-freeze
2 parents 0ef4e86 + a5891be commit 2e4790c

18 files changed

+403
-363
lines changed

Diff for: ‎src/libcore/cmp.rs

+7
Original file line numberDiff line numberDiff line change
@@ -66,6 +66,13 @@ totaleq_impl!(uint)
6666

6767
totaleq_impl!(char)
6868

69+
/// Trait for testing approximate equality
70+
pub trait ApproxEq<Eps> {
71+
fn approx_epsilon() -> Eps;
72+
fn approx_eq(&self, other: &Self) -> bool;
73+
fn approx_eq_eps(&self, other: &Self, approx_epsilon: &Eps) -> bool;
74+
}
75+
6976
#[deriving(Clone, Eq)]
7077
pub enum Ordering { Less = -1, Equal = 0, Greater = 1 }
7178

Diff for: ‎src/libcore/num/f32.rs

+90-74
Original file line numberDiff line numberDiff line change
@@ -210,6 +210,22 @@ impl Eq for f32 {
210210
fn ne(&self, other: &f32) -> bool { (*self) != (*other) }
211211
}
212212

213+
#[cfg(notest)]
214+
impl ApproxEq<f32> for f32 {
215+
#[inline(always)]
216+
fn approx_epsilon() -> f32 { 1.0e-6 }
217+
218+
#[inline(always)]
219+
fn approx_eq(&self, other: &f32) -> bool {
220+
self.approx_eq_eps(other, &ApproxEq::approx_epsilon::<f32, f32>())
221+
}
222+
223+
#[inline(always)]
224+
fn approx_eq_eps(&self, other: &f32, approx_epsilon: &f32) -> bool {
225+
(*self - *other).abs() < *approx_epsilon
226+
}
227+
}
228+
213229
#[cfg(notest)]
214230
impl Ord for f32 {
215231
#[inline(always)]
@@ -810,15 +826,6 @@ mod tests {
810826
use super::*;
811827
use prelude::*;
812828

813-
macro_rules! assert_fuzzy_eq(
814-
($a:expr, $b:expr) => ({
815-
let a = $a, b = $b;
816-
if !((a - b).abs() < 1.0e-6) {
817-
fail!(fmt!("The values were not approximately equal. Found: %? and %?", a, b));
818-
}
819-
})
820-
)
821-
822829
#[test]
823830
fn test_num() {
824831
num::test_num(10f32, 2f32);
@@ -848,91 +855,91 @@ mod tests {
848855

849856
#[test]
850857
fn test_floor() {
851-
assert_fuzzy_eq!(1.0f32.floor(), 1.0f32);
852-
assert_fuzzy_eq!(1.3f32.floor(), 1.0f32);
853-
assert_fuzzy_eq!(1.5f32.floor(), 1.0f32);
854-
assert_fuzzy_eq!(1.7f32.floor(), 1.0f32);
855-
assert_fuzzy_eq!(0.0f32.floor(), 0.0f32);
856-
assert_fuzzy_eq!((-0.0f32).floor(), -0.0f32);
857-
assert_fuzzy_eq!((-1.0f32).floor(), -1.0f32);
858-
assert_fuzzy_eq!((-1.3f32).floor(), -2.0f32);
859-
assert_fuzzy_eq!((-1.5f32).floor(), -2.0f32);
860-
assert_fuzzy_eq!((-1.7f32).floor(), -2.0f32);
858+
assert_approx_eq!(1.0f32.floor(), 1.0f32);
859+
assert_approx_eq!(1.3f32.floor(), 1.0f32);
860+
assert_approx_eq!(1.5f32.floor(), 1.0f32);
861+
assert_approx_eq!(1.7f32.floor(), 1.0f32);
862+
assert_approx_eq!(0.0f32.floor(), 0.0f32);
863+
assert_approx_eq!((-0.0f32).floor(), -0.0f32);
864+
assert_approx_eq!((-1.0f32).floor(), -1.0f32);
865+
assert_approx_eq!((-1.3f32).floor(), -2.0f32);
866+
assert_approx_eq!((-1.5f32).floor(), -2.0f32);
867+
assert_approx_eq!((-1.7f32).floor(), -2.0f32);
861868
}
862869

863870
#[test]
864871
fn test_ceil() {
865-
assert_fuzzy_eq!(1.0f32.ceil(), 1.0f32);
866-
assert_fuzzy_eq!(1.3f32.ceil(), 2.0f32);
867-
assert_fuzzy_eq!(1.5f32.ceil(), 2.0f32);
868-
assert_fuzzy_eq!(1.7f32.ceil(), 2.0f32);
869-
assert_fuzzy_eq!(0.0f32.ceil(), 0.0f32);
870-
assert_fuzzy_eq!((-0.0f32).ceil(), -0.0f32);
871-
assert_fuzzy_eq!((-1.0f32).ceil(), -1.0f32);
872-
assert_fuzzy_eq!((-1.3f32).ceil(), -1.0f32);
873-
assert_fuzzy_eq!((-1.5f32).ceil(), -1.0f32);
874-
assert_fuzzy_eq!((-1.7f32).ceil(), -1.0f32);
872+
assert_approx_eq!(1.0f32.ceil(), 1.0f32);
873+
assert_approx_eq!(1.3f32.ceil(), 2.0f32);
874+
assert_approx_eq!(1.5f32.ceil(), 2.0f32);
875+
assert_approx_eq!(1.7f32.ceil(), 2.0f32);
876+
assert_approx_eq!(0.0f32.ceil(), 0.0f32);
877+
assert_approx_eq!((-0.0f32).ceil(), -0.0f32);
878+
assert_approx_eq!((-1.0f32).ceil(), -1.0f32);
879+
assert_approx_eq!((-1.3f32).ceil(), -1.0f32);
880+
assert_approx_eq!((-1.5f32).ceil(), -1.0f32);
881+
assert_approx_eq!((-1.7f32).ceil(), -1.0f32);
875882
}
876883

877884
#[test]
878885
fn test_round() {
879-
assert_fuzzy_eq!(1.0f32.round(), 1.0f32);
880-
assert_fuzzy_eq!(1.3f32.round(), 1.0f32);
881-
assert_fuzzy_eq!(1.5f32.round(), 2.0f32);
882-
assert_fuzzy_eq!(1.7f32.round(), 2.0f32);
883-
assert_fuzzy_eq!(0.0f32.round(), 0.0f32);
884-
assert_fuzzy_eq!((-0.0f32).round(), -0.0f32);
885-
assert_fuzzy_eq!((-1.0f32).round(), -1.0f32);
886-
assert_fuzzy_eq!((-1.3f32).round(), -1.0f32);
887-
assert_fuzzy_eq!((-1.5f32).round(), -2.0f32);
888-
assert_fuzzy_eq!((-1.7f32).round(), -2.0f32);
886+
assert_approx_eq!(1.0f32.round(), 1.0f32);
887+
assert_approx_eq!(1.3f32.round(), 1.0f32);
888+
assert_approx_eq!(1.5f32.round(), 2.0f32);
889+
assert_approx_eq!(1.7f32.round(), 2.0f32);
890+
assert_approx_eq!(0.0f32.round(), 0.0f32);
891+
assert_approx_eq!((-0.0f32).round(), -0.0f32);
892+
assert_approx_eq!((-1.0f32).round(), -1.0f32);
893+
assert_approx_eq!((-1.3f32).round(), -1.0f32);
894+
assert_approx_eq!((-1.5f32).round(), -2.0f32);
895+
assert_approx_eq!((-1.7f32).round(), -2.0f32);
889896
}
890897

891898
#[test]
892899
fn test_trunc() {
893-
assert_fuzzy_eq!(1.0f32.trunc(), 1.0f32);
894-
assert_fuzzy_eq!(1.3f32.trunc(), 1.0f32);
895-
assert_fuzzy_eq!(1.5f32.trunc(), 1.0f32);
896-
assert_fuzzy_eq!(1.7f32.trunc(), 1.0f32);
897-
assert_fuzzy_eq!(0.0f32.trunc(), 0.0f32);
898-
assert_fuzzy_eq!((-0.0f32).trunc(), -0.0f32);
899-
assert_fuzzy_eq!((-1.0f32).trunc(), -1.0f32);
900-
assert_fuzzy_eq!((-1.3f32).trunc(), -1.0f32);
901-
assert_fuzzy_eq!((-1.5f32).trunc(), -1.0f32);
902-
assert_fuzzy_eq!((-1.7f32).trunc(), -1.0f32);
900+
assert_approx_eq!(1.0f32.trunc(), 1.0f32);
901+
assert_approx_eq!(1.3f32.trunc(), 1.0f32);
902+
assert_approx_eq!(1.5f32.trunc(), 1.0f32);
903+
assert_approx_eq!(1.7f32.trunc(), 1.0f32);
904+
assert_approx_eq!(0.0f32.trunc(), 0.0f32);
905+
assert_approx_eq!((-0.0f32).trunc(), -0.0f32);
906+
assert_approx_eq!((-1.0f32).trunc(), -1.0f32);
907+
assert_approx_eq!((-1.3f32).trunc(), -1.0f32);
908+
assert_approx_eq!((-1.5f32).trunc(), -1.0f32);
909+
assert_approx_eq!((-1.7f32).trunc(), -1.0f32);
903910
}
904911

905912
#[test]
906913
fn test_fract() {
907-
assert_fuzzy_eq!(1.0f32.fract(), 0.0f32);
908-
assert_fuzzy_eq!(1.3f32.fract(), 0.3f32);
909-
assert_fuzzy_eq!(1.5f32.fract(), 0.5f32);
910-
assert_fuzzy_eq!(1.7f32.fract(), 0.7f32);
911-
assert_fuzzy_eq!(0.0f32.fract(), 0.0f32);
912-
assert_fuzzy_eq!((-0.0f32).fract(), -0.0f32);
913-
assert_fuzzy_eq!((-1.0f32).fract(), -0.0f32);
914-
assert_fuzzy_eq!((-1.3f32).fract(), -0.3f32);
915-
assert_fuzzy_eq!((-1.5f32).fract(), -0.5f32);
916-
assert_fuzzy_eq!((-1.7f32).fract(), -0.7f32);
914+
assert_approx_eq!(1.0f32.fract(), 0.0f32);
915+
assert_approx_eq!(1.3f32.fract(), 0.3f32);
916+
assert_approx_eq!(1.5f32.fract(), 0.5f32);
917+
assert_approx_eq!(1.7f32.fract(), 0.7f32);
918+
assert_approx_eq!(0.0f32.fract(), 0.0f32);
919+
assert_approx_eq!((-0.0f32).fract(), -0.0f32);
920+
assert_approx_eq!((-1.0f32).fract(), -0.0f32);
921+
assert_approx_eq!((-1.3f32).fract(), -0.3f32);
922+
assert_approx_eq!((-1.5f32).fract(), -0.5f32);
923+
assert_approx_eq!((-1.7f32).fract(), -0.7f32);
917924
}
918925

919926
#[test]
920927
fn test_real_consts() {
921-
assert_fuzzy_eq!(Real::two_pi::<f32>(), 2f32 * Real::pi::<f32>());
922-
assert_fuzzy_eq!(Real::frac_pi_2::<f32>(), Real::pi::<f32>() / 2f32);
923-
assert_fuzzy_eq!(Real::frac_pi_3::<f32>(), Real::pi::<f32>() / 3f32);
924-
assert_fuzzy_eq!(Real::frac_pi_4::<f32>(), Real::pi::<f32>() / 4f32);
925-
assert_fuzzy_eq!(Real::frac_pi_6::<f32>(), Real::pi::<f32>() / 6f32);
926-
assert_fuzzy_eq!(Real::frac_pi_8::<f32>(), Real::pi::<f32>() / 8f32);
927-
assert_fuzzy_eq!(Real::frac_1_pi::<f32>(), 1f32 / Real::pi::<f32>());
928-
assert_fuzzy_eq!(Real::frac_2_pi::<f32>(), 2f32 / Real::pi::<f32>());
929-
assert_fuzzy_eq!(Real::frac_2_sqrtpi::<f32>(), 2f32 / Real::pi::<f32>().sqrt());
930-
assert_fuzzy_eq!(Real::sqrt2::<f32>(), 2f32.sqrt());
931-
assert_fuzzy_eq!(Real::frac_1_sqrt2::<f32>(), 1f32 / 2f32.sqrt());
932-
assert_fuzzy_eq!(Real::log2_e::<f32>(), Real::e::<f32>().log2());
933-
assert_fuzzy_eq!(Real::log10_e::<f32>(), Real::e::<f32>().log10());
934-
assert_fuzzy_eq!(Real::log_2::<f32>(), 2f32.log());
935-
assert_fuzzy_eq!(Real::log_10::<f32>(), 10f32.log());
928+
assert_approx_eq!(Real::two_pi::<f32>(), 2f32 * Real::pi::<f32>());
929+
assert_approx_eq!(Real::frac_pi_2::<f32>(), Real::pi::<f32>() / 2f32);
930+
assert_approx_eq!(Real::frac_pi_3::<f32>(), Real::pi::<f32>() / 3f32);
931+
assert_approx_eq!(Real::frac_pi_4::<f32>(), Real::pi::<f32>() / 4f32);
932+
assert_approx_eq!(Real::frac_pi_6::<f32>(), Real::pi::<f32>() / 6f32);
933+
assert_approx_eq!(Real::frac_pi_8::<f32>(), Real::pi::<f32>() / 8f32);
934+
assert_approx_eq!(Real::frac_1_pi::<f32>(), 1f32 / Real::pi::<f32>());
935+
assert_approx_eq!(Real::frac_2_pi::<f32>(), 2f32 / Real::pi::<f32>());
936+
assert_approx_eq!(Real::frac_2_sqrtpi::<f32>(), 2f32 / Real::pi::<f32>().sqrt());
937+
assert_approx_eq!(Real::sqrt2::<f32>(), 2f32.sqrt());
938+
assert_approx_eq!(Real::frac_1_sqrt2::<f32>(), 1f32 / 2f32.sqrt());
939+
assert_approx_eq!(Real::log2_e::<f32>(), Real::e::<f32>().log2());
940+
assert_approx_eq!(Real::log10_e::<f32>(), Real::e::<f32>().log10());
941+
assert_approx_eq!(Real::log_2::<f32>(), 2f32.log());
942+
assert_approx_eq!(Real::log_10::<f32>(), 10f32.log());
936943
}
937944

938945
#[test]
@@ -974,6 +981,15 @@ mod tests {
974981
assert!(!NaN.is_negative());
975982
}
976983

984+
#[test]
985+
fn test_approx_eq() {
986+
assert!(1.0f32.approx_eq(&1f32));
987+
assert!(0.9999999f32.approx_eq(&1f32));
988+
assert!(1.000001f32.approx_eq_eps(&1f32, &1.0e-5));
989+
assert!(1.0000001f32.approx_eq_eps(&1f32, &1.0e-6));
990+
assert!(!1.0000001f32.approx_eq_eps(&1f32, &1.0e-7));
991+
}
992+
977993
#[test]
978994
fn test_primitive() {
979995
assert_eq!(Primitive::bits::<f32>(), sys::size_of::<f32>() * 8);

0 commit comments

Comments
 (0)