gnxlxnxx/dubins_path
1
0
Fork 0
mirror of https://github.com/gnxlxnxx/dubins_path synced 2026-07-27 07:03:03 +02:00
Code Issues Releases Wiki Activity

use float_cmp

Browse Source 
I've acknoledged there are approximate equality checks in euclid itself,
and I'm going to look into using them since I believe the ugly angle approximation
is probably handled better there, but for now this works!
I've just seen it too late :D
This commit is contained in:
gnxlxnxx
2020-06-08 22:15:50 +02:00
parent 3e123ce32b
commit 52da8d9637
2 changed files with 24 additions and 59 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Cargo.toml
+3
View File
@@ -17,3 +17,6 @@ edition = "2018"
[dependencies]
euclid = "0.20.11"
thiserror = "1.0"
[dev-dependencies]
float-cmp = "0.8.0"
tests/unit_test.rs
+21 -59
View File
@@ -1,74 +1,36 @@
#[cfg(test)]
mod tests {
use dubins_path::*;
const ERROR: f64 = 0.000000000000001;
use float_cmp::approx_eq;
fn circle_in_error_margin(
result: CircleVector,
expected_result: CircleVector,
) -> Result<(), ()> {
if result.center.x - expected_result.center.x > ERROR {
return Err(());
}
if result.center.x - expected_result.center.x < -ERROR {
return Err(());
}
if result.center.y - expected_result.center.y > ERROR {
return Err(());
}
if result.center.y - expected_result.center.y < -ERROR {
return Err(());
}
if result.radius - expected_result.radius > ERROR {
return Err(());
}
if result.radius - expected_result.radius < -ERROR {
return Err(());
}
if result.angle.radians - expected_result.angle.radians > ERROR
&& result.angle.signed().radians - expected_result.angle.signed().radians > ERROR
{
return Err(());
}
if result.angle.radians - expected_result.angle.radians < -ERROR
&& result.angle.signed().radians - expected_result.angle.signed().radians < -ERROR
{
return Err(());
}
assert!(approx_eq!(f64, result.center.x, expected_result.center.x));
assert!(approx_eq!(f64, result.center.x, expected_result.center.x));
assert!(approx_eq!(f64, result.center.y, expected_result.center.y));
assert!(approx_eq!(f64, result.center.y, expected_result.center.y));
assert!(approx_eq!(f64, result.radius, expected_result.radius));
assert!(approx_eq!(f64, result.radius, expected_result.radius));
assert!(approx_eq!(f64, result.angle.radians, expected_result.angle.radians) ||
approx_eq!(f64, result.angle.signed().radians, expected_result.angle.signed().radians));
assert!(approx_eq!(f64, result.angle.radians, expected_result.angle.radians) ||
approx_eq!(f64, result.angle.signed().radians, expected_result.angle.signed().radians));
Ok(())
}
fn vector_in_error_margin(result: Vector, expected_result: Vector) -> Result<(), ()> {
if result.origin.x - expected_result.origin.x > ERROR {
return Err(());
}
if result.origin.x - expected_result.origin.x < -ERROR {
return Err(());
}
if result.origin.y - expected_result.origin.y > ERROR {
return Err(());
}
if result.origin.y - expected_result.origin.y < -ERROR {
return Err(());
}
if result.angle.radians - expected_result.angle.radians > ERROR
|| result.angle.signed().radians - expected_result.angle.signed().radians > ERROR
{
return Err(());
}
if result.angle.radians - expected_result.angle.radians < -ERROR
|| result.angle.signed().radians - expected_result.angle.signed().radians < -ERROR
{
return Err(());
}
if result.magnitude - expected_result.magnitude > ERROR {
return Err(());
}
if result.magnitude - expected_result.magnitude < -ERROR {
return Err(());
}
assert!(approx_eq!(f64, result.origin.x, expected_result.origin.x));
assert!(approx_eq!(f64, result.origin.x, expected_result.origin.x));
assert!(approx_eq!(f64, result.origin.y, expected_result.origin.y));
assert!(approx_eq!(f64, result.origin.y, expected_result.origin.y));
assert!(approx_eq!(f64, result.angle.radians, expected_result.angle.radians) ||
approx_eq!(f64, result.angle.signed().radians, expected_result.angle.signed().radians));
assert!(approx_eq!(f64, result.angle.radians, expected_result.angle.radians) ||
approx_eq!(f64, result.angle.signed().radians, expected_result.angle.signed().radians));
assert!(approx_eq!(f64, result.magnitude, expected_result.magnitude));
assert!(approx_eq!(f64, result.magnitude, expected_result.magnitude));
Ok(())
}