Skip to content

Commit 0e2242f

Browse files
brendanzabbrendanzab
committed
Add assert_approx_eq! macro
1 parent 0211833 commit 0e2242f

File tree

7 files changed

+275
-223
lines changed

7 files changed

+275
-223
lines changed

‎src/libcore/num/f32.rs

+65-74
Original file line numberDiff line numberDiff line change
@@ -826,15 +826,6 @@ mod tests {
826826
use super::*;
827827
use prelude::*;
828828

829-
macro_rules! assert_fuzzy_eq(
830-
($a:expr, $b:expr) => ({
831-
let a = $a, b = $b;
832-
if !((a - b).abs() < 1.0e-6) {
833-
fail!(fmt!("The values were not approximately equal. Found: %? and %?", a, b));
834-
}
835-
})
836-
)
837-
838829
#[test]
839830
fn test_num() {
840831
num::test_num(10f32, 2f32);
@@ -864,91 +855,91 @@ mod tests {
864855

865856
#[test]
866857
fn test_floor() {
867-
assert_fuzzy_eq!(1.0f32.floor(), 1.0f32);
868-
assert_fuzzy_eq!(1.3f32.floor(), 1.0f32);
869-
assert_fuzzy_eq!(1.5f32.floor(), 1.0f32);
870-
assert_fuzzy_eq!(1.7f32.floor(), 1.0f32);
871-
assert_fuzzy_eq!(0.0f32.floor(), 0.0f32);
872-
assert_fuzzy_eq!((-0.0f32).floor(), -0.0f32);
873-
assert_fuzzy_eq!((-1.0f32).floor(), -1.0f32);
874-
assert_fuzzy_eq!((-1.3f32).floor(), -2.0f32);
875-
assert_fuzzy_eq!((-1.5f32).floor(), -2.0f32);
876-
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);
877868
}
878869

879870
#[test]
880871
fn test_ceil() {
881-
assert_fuzzy_eq!(1.0f32.ceil(), 1.0f32);
882-
assert_fuzzy_eq!(1.3f32.ceil(), 2.0f32);
883-
assert_fuzzy_eq!(1.5f32.ceil(), 2.0f32);
884-
assert_fuzzy_eq!(1.7f32.ceil(), 2.0f32);
885-
assert_fuzzy_eq!(0.0f32.ceil(), 0.0f32);
886-
assert_fuzzy_eq!((-0.0f32).ceil(), -0.0f32);
887-
assert_fuzzy_eq!((-1.0f32).ceil(), -1.0f32);
888-
assert_fuzzy_eq!((-1.3f32).ceil(), -1.0f32);
889-
assert_fuzzy_eq!((-1.5f32).ceil(), -1.0f32);
890-
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);
891882
}
892883

893884
#[test]
894885
fn test_round() {
895-
assert_fuzzy_eq!(1.0f32.round(), 1.0f32);
896-
assert_fuzzy_eq!(1.3f32.round(), 1.0f32);
897-
assert_fuzzy_eq!(1.5f32.round(), 2.0f32);
898-
assert_fuzzy_eq!(1.7f32.round(), 2.0f32);
899-
assert_fuzzy_eq!(0.0f32.round(), 0.0f32);
900-
assert_fuzzy_eq!((-0.0f32).round(), -0.0f32);
901-
assert_fuzzy_eq!((-1.0f32).round(), -1.0f32);
902-
assert_fuzzy_eq!((-1.3f32).round(), -1.0f32);
903-
assert_fuzzy_eq!((-1.5f32).round(), -2.0f32);
904-
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);
905896
}
906897

907898
#[test]
908899
fn test_trunc() {
909-
assert_fuzzy_eq!(1.0f32.trunc(), 1.0f32);
910-
assert_fuzzy_eq!(1.3f32.trunc(), 1.0f32);
911-
assert_fuzzy_eq!(1.5f32.trunc(), 1.0f32);
912-
assert_fuzzy_eq!(1.7f32.trunc(), 1.0f32);
913-
assert_fuzzy_eq!(0.0f32.trunc(), 0.0f32);
914-
assert_fuzzy_eq!((-0.0f32).trunc(), -0.0f32);
915-
assert_fuzzy_eq!((-1.0f32).trunc(), -1.0f32);
916-
assert_fuzzy_eq!((-1.3f32).trunc(), -1.0f32);
917-
assert_fuzzy_eq!((-1.5f32).trunc(), -1.0f32);
918-
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);
919910
}
920911

921912
#[test]
922913
fn test_fract() {
923-
assert_fuzzy_eq!(1.0f32.fract(), 0.0f32);
924-
assert_fuzzy_eq!(1.3f32.fract(), 0.3f32);
925-
assert_fuzzy_eq!(1.5f32.fract(), 0.5f32);
926-
assert_fuzzy_eq!(1.7f32.fract(), 0.7f32);
927-
assert_fuzzy_eq!(0.0f32.fract(), 0.0f32);
928-
assert_fuzzy_eq!((-0.0f32).fract(), -0.0f32);
929-
assert_fuzzy_eq!((-1.0f32).fract(), -0.0f32);
930-
assert_fuzzy_eq!((-1.3f32).fract(), -0.3f32);
931-
assert_fuzzy_eq!((-1.5f32).fract(), -0.5f32);
932-
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);
933924
}
934925

935926
#[test]
936927
fn test_real_consts() {
937-
assert_fuzzy_eq!(Real::two_pi::<f32>(), 2f32 * Real::pi::<f32>());
938-
assert_fuzzy_eq!(Real::frac_pi_2::<f32>(), Real::pi::<f32>() / 2f32);
939-
assert_fuzzy_eq!(Real::frac_pi_3::<f32>(), Real::pi::<f32>() / 3f32);
940-
assert_fuzzy_eq!(Real::frac_pi_4::<f32>(), Real::pi::<f32>() / 4f32);
941-
assert_fuzzy_eq!(Real::frac_pi_6::<f32>(), Real::pi::<f32>() / 6f32);
942-
assert_fuzzy_eq!(Real::frac_pi_8::<f32>(), Real::pi::<f32>() / 8f32);
943-
assert_fuzzy_eq!(Real::frac_1_pi::<f32>(), 1f32 / Real::pi::<f32>());
944-
assert_fuzzy_eq!(Real::frac_2_pi::<f32>(), 2f32 / Real::pi::<f32>());
945-
assert_fuzzy_eq!(Real::frac_2_sqrtpi::<f32>(), 2f32 / Real::pi::<f32>().sqrt());
946-
assert_fuzzy_eq!(Real::sqrt2::<f32>(), 2f32.sqrt());
947-
assert_fuzzy_eq!(Real::frac_1_sqrt2::<f32>(), 1f32 / 2f32.sqrt());
948-
assert_fuzzy_eq!(Real::log2_e::<f32>(), Real::e::<f32>().log2());
949-
assert_fuzzy_eq!(Real::log10_e::<f32>(), Real::e::<f32>().log10());
950-
assert_fuzzy_eq!(Real::log_2::<f32>(), 2f32.log());
951-
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());
952943
}
953944

954945
#[test]

‎src/libcore/num/f64.rs

+65-75
Original file line numberDiff line numberDiff line change
@@ -869,16 +869,6 @@ mod tests {
869869
use super::*;
870870
use prelude::*;
871871

872-
macro_rules! assert_fuzzy_eq(
873-
($a:expr, $b:expr) => ({
874-
let a = $a, b = $b;
875-
if !((a - b).abs() < 1.0e-6) {
876-
fail!(fmt!("The values were not approximately equal. \
877-
Found: %? and expected %?", a, b));
878-
}
879-
})
880-
)
881-
882872
#[test]
883873
fn test_num() {
884874
num::test_num(10f64, 2f64);
@@ -912,91 +902,91 @@ mod tests {
912902

913903
#[test]
914904
fn test_floor() {
915-
assert_fuzzy_eq!(1.0f64.floor(), 1.0f64);
916-
assert_fuzzy_eq!(1.3f64.floor(), 1.0f64);
917-
assert_fuzzy_eq!(1.5f64.floor(), 1.0f64);
918-
assert_fuzzy_eq!(1.7f64.floor(), 1.0f64);
919-
assert_fuzzy_eq!(0.0f64.floor(), 0.0f64);
920-
assert_fuzzy_eq!((-0.0f64).floor(), -0.0f64);
921-
assert_fuzzy_eq!((-1.0f64).floor(), -1.0f64);
922-
assert_fuzzy_eq!((-1.3f64).floor(), -2.0f64);
923-
assert_fuzzy_eq!((-1.5f64).floor(), -2.0f64);
924-
assert_fuzzy_eq!((-1.7f64).floor(), -2.0f64);
905+
assert_approx_eq!(1.0f64.floor(), 1.0f64);
906+
assert_approx_eq!(1.3f64.floor(), 1.0f64);
907+
assert_approx_eq!(1.5f64.floor(), 1.0f64);
908+
assert_approx_eq!(1.7f64.floor(), 1.0f64);
909+
assert_approx_eq!(0.0f64.floor(), 0.0f64);
910+
assert_approx_eq!((-0.0f64).floor(), -0.0f64);
911+
assert_approx_eq!((-1.0f64).floor(), -1.0f64);
912+
assert_approx_eq!((-1.3f64).floor(), -2.0f64);
913+
assert_approx_eq!((-1.5f64).floor(), -2.0f64);
914+
assert_approx_eq!((-1.7f64).floor(), -2.0f64);
925915
}
926916

927917
#[test]
928918
fn test_ceil() {
929-
assert_fuzzy_eq!(1.0f64.ceil(), 1.0f64);
930-
assert_fuzzy_eq!(1.3f64.ceil(), 2.0f64);
931-
assert_fuzzy_eq!(1.5f64.ceil(), 2.0f64);
932-
assert_fuzzy_eq!(1.7f64.ceil(), 2.0f64);
933-
assert_fuzzy_eq!(0.0f64.ceil(), 0.0f64);
934-
assert_fuzzy_eq!((-0.0f64).ceil(), -0.0f64);
935-
assert_fuzzy_eq!((-1.0f64).ceil(), -1.0f64);
936-
assert_fuzzy_eq!((-1.3f64).ceil(), -1.0f64);
937-
assert_fuzzy_eq!((-1.5f64).ceil(), -1.0f64);
938-
assert_fuzzy_eq!((-1.7f64).ceil(), -1.0f64);
919+
assert_approx_eq!(1.0f64.ceil(), 1.0f64);
920+
assert_approx_eq!(1.3f64.ceil(), 2.0f64);
921+
assert_approx_eq!(1.5f64.ceil(), 2.0f64);
922+
assert_approx_eq!(1.7f64.ceil(), 2.0f64);
923+
assert_approx_eq!(0.0f64.ceil(), 0.0f64);
924+
assert_approx_eq!((-0.0f64).ceil(), -0.0f64);
925+
assert_approx_eq!((-1.0f64).ceil(), -1.0f64);
926+
assert_approx_eq!((-1.3f64).ceil(), -1.0f64);
927+
assert_approx_eq!((-1.5f64).ceil(), -1.0f64);
928+
assert_approx_eq!((-1.7f64).ceil(), -1.0f64);
939929
}
940930

941931
#[test]
942932
fn test_round() {
943-
assert_fuzzy_eq!(1.0f64.round(), 1.0f64);
944-
assert_fuzzy_eq!(1.3f64.round(), 1.0f64);
945-
assert_fuzzy_eq!(1.5f64.round(), 2.0f64);
946-
assert_fuzzy_eq!(1.7f64.round(), 2.0f64);
947-
assert_fuzzy_eq!(0.0f64.round(), 0.0f64);
948-
assert_fuzzy_eq!((-0.0f64).round(), -0.0f64);
949-
assert_fuzzy_eq!((-1.0f64).round(), -1.0f64);
950-
assert_fuzzy_eq!((-1.3f64).round(), -1.0f64);
951-
assert_fuzzy_eq!((-1.5f64).round(), -2.0f64);
952-
assert_fuzzy_eq!((-1.7f64).round(), -2.0f64);
933+
assert_approx_eq!(1.0f64.round(), 1.0f64);
934+
assert_approx_eq!(1.3f64.round(), 1.0f64);
935+
assert_approx_eq!(1.5f64.round(), 2.0f64);
936+
assert_approx_eq!(1.7f64.round(), 2.0f64);
937+
assert_approx_eq!(0.0f64.round(), 0.0f64);
938+
assert_approx_eq!((-0.0f64).round(), -0.0f64);
939+
assert_approx_eq!((-1.0f64).round(), -1.0f64);
940+
assert_approx_eq!((-1.3f64).round(), -1.0f64);
941+
assert_approx_eq!((-1.5f64).round(), -2.0f64);
942+
assert_approx_eq!((-1.7f64).round(), -2.0f64);
953943
}
954944

955945
#[test]
956946
fn test_trunc() {
957-
assert_fuzzy_eq!(1.0f64.trunc(), 1.0f64);
958-
assert_fuzzy_eq!(1.3f64.trunc(), 1.0f64);
959-
assert_fuzzy_eq!(1.5f64.trunc(), 1.0f64);
960-
assert_fuzzy_eq!(1.7f64.trunc(), 1.0f64);
961-
assert_fuzzy_eq!(0.0f64.trunc(), 0.0f64);
962-
assert_fuzzy_eq!((-0.0f64).trunc(), -0.0f64);
963-
assert_fuzzy_eq!((-1.0f64).trunc(), -1.0f64);
964-
assert_fuzzy_eq!((-1.3f64).trunc(), -1.0f64);
965-
assert_fuzzy_eq!((-1.5f64).trunc(), -1.0f64);
966-
assert_fuzzy_eq!((-1.7f64).trunc(), -1.0f64);
947+
assert_approx_eq!(1.0f64.trunc(), 1.0f64);
948+
assert_approx_eq!(1.3f64.trunc(), 1.0f64);
949+
assert_approx_eq!(1.5f64.trunc(), 1.0f64);
950+
assert_approx_eq!(1.7f64.trunc(), 1.0f64);
951+
assert_approx_eq!(0.0f64.trunc(), 0.0f64);
952+
assert_approx_eq!((-0.0f64).trunc(), -0.0f64);
953+
assert_approx_eq!((-1.0f64).trunc(), -1.0f64);
954+
assert_approx_eq!((-1.3f64).trunc(), -1.0f64);
955+
assert_approx_eq!((-1.5f64).trunc(), -1.0f64);
956+
assert_approx_eq!((-1.7f64).trunc(), -1.0f64);
967957
}
968958

969959
#[test]
970960
fn test_fract() {
971-
assert_fuzzy_eq!(1.0f64.fract(), 0.0f64);
972-
assert_fuzzy_eq!(1.3f64.fract(), 0.3f64);
973-
assert_fuzzy_eq!(1.5f64.fract(), 0.5f64);
974-
assert_fuzzy_eq!(1.7f64.fract(), 0.7f64);
975-
assert_fuzzy_eq!(0.0f64.fract(), 0.0f64);
976-
assert_fuzzy_eq!((-0.0f64).fract(), -0.0f64);
977-
assert_fuzzy_eq!((-1.0f64).fract(), -0.0f64);
978-
assert_fuzzy_eq!((-1.3f64).fract(), -0.3f64);
979-
assert_fuzzy_eq!((-1.5f64).fract(), -0.5f64);
980-
assert_fuzzy_eq!((-1.7f64).fract(), -0.7f64);
961+
assert_approx_eq!(1.0f64.fract(), 0.0f64);
962+
assert_approx_eq!(1.3f64.fract(), 0.3f64);
963+
assert_approx_eq!(1.5f64.fract(), 0.5f64);
964+
assert_approx_eq!(1.7f64.fract(), 0.7f64);
965+
assert_approx_eq!(0.0f64.fract(), 0.0f64);
966+
assert_approx_eq!((-0.0f64).fract(), -0.0f64);
967+
assert_approx_eq!((-1.0f64).fract(), -0.0f64);
968+
assert_approx_eq!((-1.3f64).fract(), -0.3f64);
969+
assert_approx_eq!((-1.5f64).fract(), -0.5f64);
970+
assert_approx_eq!((-1.7f64).fract(), -0.7f64);
981971
}
982972

983973
#[test]
984974
fn test_real_consts() {
985-
assert_fuzzy_eq!(Real::two_pi::<f64>(), 2.0 * Real::pi::<f64>());
986-
assert_fuzzy_eq!(Real::frac_pi_2::<f64>(), Real::pi::<f64>() / 2f64);
987-
assert_fuzzy_eq!(Real::frac_pi_3::<f64>(), Real::pi::<f64>() / 3f64);
988-
assert_fuzzy_eq!(Real::frac_pi_4::<f64>(), Real::pi::<f64>() / 4f64);
989-
assert_fuzzy_eq!(Real::frac_pi_6::<f64>(), Real::pi::<f64>() / 6f64);
990-
assert_fuzzy_eq!(Real::frac_pi_8::<f64>(), Real::pi::<f64>() / 8f64);
991-
assert_fuzzy_eq!(Real::frac_1_pi::<f64>(), 1f64 / Real::pi::<f64>());
992-
assert_fuzzy_eq!(Real::frac_2_pi::<f64>(), 2f64 / Real::pi::<f64>());
993-
assert_fuzzy_eq!(Real::frac_2_sqrtpi::<f64>(), 2f64 / Real::pi::<f64>().sqrt());
994-
assert_fuzzy_eq!(Real::sqrt2::<f64>(), 2f64.sqrt());
995-
assert_fuzzy_eq!(Real::frac_1_sqrt2::<f64>(), 1f64 / 2f64.sqrt());
996-
assert_fuzzy_eq!(Real::log2_e::<f64>(), Real::e::<f64>().log2());
997-
assert_fuzzy_eq!(Real::log10_e::<f64>(), Real::e::<f64>().log10());
998-
assert_fuzzy_eq!(Real::log_2::<f64>(), 2f64.log());
999-
assert_fuzzy_eq!(Real::log_10::<f64>(), 10f64.log());
975+
assert_approx_eq!(Real::two_pi::<f64>(), 2.0 * Real::pi::<f64>());
976+
assert_approx_eq!(Real::frac_pi_2::<f64>(), Real::pi::<f64>() / 2f64);
977+
assert_approx_eq!(Real::frac_pi_3::<f64>(), Real::pi::<f64>() / 3f64);
978+
assert_approx_eq!(Real::frac_pi_4::<f64>(), Real::pi::<f64>() / 4f64);
979+
assert_approx_eq!(Real::frac_pi_6::<f64>(), Real::pi::<f64>() / 6f64);
980+
assert_approx_eq!(Real::frac_pi_8::<f64>(), Real::pi::<f64>() / 8f64);
981+
assert_approx_eq!(Real::frac_1_pi::<f64>(), 1f64 / Real::pi::<f64>());
982+
assert_approx_eq!(Real::frac_2_pi::<f64>(), 2f64 / Real::pi::<f64>());
983+
assert_approx_eq!(Real::frac_2_sqrtpi::<f64>(), 2f64 / Real::pi::<f64>().sqrt());
984+
assert_approx_eq!(Real::sqrt2::<f64>(), 2f64.sqrt());
985+
assert_approx_eq!(Real::frac_1_sqrt2::<f64>(), 1f64 / 2f64.sqrt());
986+
assert_approx_eq!(Real::log2_e::<f64>(), Real::e::<f64>().log2());
987+
assert_approx_eq!(Real::log10_e::<f64>(), Real::e::<f64>().log10());
988+
assert_approx_eq!(Real::log_2::<f64>(), 2f64.log());
989+
assert_approx_eq!(Real::log_10::<f64>(), 10f64.log());
1000990
}
1001991

1002992
#[test]

0 commit comments

Comments
 (0)