cessen/psychopath
1
0
Fork 0
Code Issues 1 Pull Requests Projects Releases Wiki Activity

RMath: implement cross product and bring back some unit tests.

Browse Source
This commit is contained in:
Nathan Vegdahl 2022-07-15 00:39:14 -07:00
parent 42cd282c47
commit a93a3f09da
6 changed files with 324 additions and 270 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
sub_crates/rmath/src/lib.rs
View File

@ -29,15 +29,22 @@ pub fn dot_fast<T: DotProduct>(a: T, b: T) -> f32 {
a.dot_fast(b) a.dot_fast(b)
} }
// /// Trait for calculating cross products. /// Trait for calculating cross products.
// pub trait CrossProduct { pub trait CrossProduct {
// fn cross(self, other: Self) -> Self; fn cross(self, other: Self) -> Self;
// }
// #[inline] fn cross_fast(self, other: Self) -> Self;
// pub fn cross<T: CrossProduct>(a: T, b: T) -> T { }
// a.cross(b)
// } #[inline(always)]
pub fn cross<T: CrossProduct>(a: T, b: T) -> T {
a.cross(b)
}
#[inline(always)]
pub fn cross_fast<T: CrossProduct>(a: T, b: T) -> T {
a.cross_fast(b)
}
//------------------------------------------------------------- //-------------------------------------------------------------

207
sub_crates/rmath/src/normal.rs
View File

@ -1,11 +1,12 @@
#![allow(dead_code)] #![allow(dead_code)]
use std::cmp::PartialEq;
use std::ops::{Add, Div, Mul, Neg, Sub}; use std::ops::{Add, Div, Mul, Neg, Sub};
use crate::wide4::Float4; use crate::wide4::Float4;
use crate::xform::XformFull; use crate::xform::XformFull;
use crate::DotProduct;
use crate::Vector; use crate::Vector;
use crate::{CrossProduct, DotProduct};
/// A surface normal in 3D space. /// A surface normal in 3D space.
#[derive(Debug, Copy, Clone)] #[derive(Debug, Copy, Clone)]
@ -138,6 +139,13 @@ impl Neg for Normal {
} }
} }
impl PartialEq for Normal {
#[inline(always)]
fn eq(&self, rhs: &Self) -> bool {
self.0.a() == rhs.0.a() && self.0.b() == rhs.0.b() && self.0.c() == rhs.0.c()
}
}
impl DotProduct for Normal { impl DotProduct for Normal {
#[inline(always)] #[inline(always)]
fn dot(self, other: Self) -> f32 { fn dot(self, other: Self) -> f32 {
@ -150,109 +158,132 @@ impl DotProduct for Normal {
} }
} }
// impl CrossProduct for Normal { impl CrossProduct for Normal {
// #[inline] #[inline(always)]
// fn cross(self, other: Normal) -> Normal { fn cross(self, other: Self) -> Self {
// Normal { Self(Float4::cross_3(self.0, other.0))
// co: self.co.cross(other.co), }
// }
// } #[inline(always)]
// } fn cross_fast(self, other: Self) -> Self {
Self(Float4::cross_3_fast(self.0, other.0))
}
}
//------------------------------------------------------------- //-------------------------------------------------------------
// #[cfg(test)] #[cfg(test)]
// mod tests { mod tests {
// use super::super::{CrossProduct, DotProduct, Transform}; use super::*;
// use super::*; use crate::{CrossProduct, DotProduct, Xform};
// use approx::assert_ulps_eq;
// #[test] #[test]
// fn add() { fn add() {
// let v1 = Normal::new(1.0, 2.0, 3.0); let v1 = Normal::new(1.0, 2.0, 3.0);
// let v2 = Normal::new(1.5, 4.5, 2.5); let v2 = Normal::new(1.5, 4.5, 2.5);
// let v3 = Normal::new(2.5, 6.5, 5.5); let v3 = Normal::new(2.5, 6.5, 5.5);
// assert_eq!(v3, v1 + v2); assert_eq!(v3, v1 + v2);
// } }
// #[test] #[test]
// fn sub() { fn sub() {
// let v1 = Normal::new(1.0, 2.0, 3.0); let v1 = Normal::new(1.0, 2.0, 3.0);
// let v2 = Normal::new(1.5, 4.5, 2.5); let v2 = Normal::new(1.5, 4.5, 2.5);
// let v3 = Normal::new(-0.5, -2.5, 0.5); let v3 = Normal::new(-0.5, -2.5, 0.5);
// assert_eq!(v3, v1 - v2); assert_eq!(v3, v1 - v2);
// } }
// #[test] #[test]
// fn mul_scalar() { fn mul_scalar() {
// let v1 = Normal::new(1.0, 2.0, 3.0); let v1 = Normal::new(1.0, 2.0, 3.0);
// let v2 = 2.0; let v2 = 2.0;
// let v3 = Normal::new(2.0, 4.0, 6.0); let v3 = Normal::new(2.0, 4.0, 6.0);
// assert_eq!(v3, v1 * v2); assert_eq!(v3, v1 * v2);
// } }
// #[test] #[test]
// fn mul_matrix_1() { fn xform() {
// let n = Normal::new(1.0, 2.5, 4.0); let n = Normal::new(1.0, 2.5, 4.0);
// let m = Transform::new_from_values( let m =
// 1.0, 2.0, 2.0, 1.5, 3.0, 6.0, 7.0, 8.0, 9.0, 2.0, 11.0, 12.0, Xform::new(1.0, 3.0, 9.0, 2.0, 6.0, 2.0, 2.0, 7.0, 11.0, 1.5, 8.0, 12.0).into_full();
// );
// let nm = n * m;
// let nm2 = Normal::new(-4.0625, 1.78125, -0.03125);
// for i in 0..3 {
// assert_ulps_eq!(nm.co[i], nm2.co[i], max_ulps = 4);
// }
// }
// #[test] assert_eq!(n.xform(&m), Normal::new(-4.0625, 1.78125, -0.03125));
// fn div() { assert_eq!(n.xform(&m).xform_inv(&m), n);
// let v1 = Normal::new(1.0, 2.0, 3.0); }
// let v2 = 2.0;
// let v3 = Normal::new(0.5, 1.0, 1.5);
// assert_eq!(v3, v1 / v2); #[test]
// } fn xform_fast() {
let n = Normal::new(1.0, 2.5, 4.0);
let m =
Xform::new(1.0, 3.0, 9.0, 2.0, 6.0, 2.0, 2.0, 7.0, 11.0, 1.5, 8.0, 12.0).into_full();
// #[test] assert_eq!(n.xform_fast(&m), Normal::new(-4.0625, 1.78125, -0.03125));
// fn length() { assert_eq!(n.xform_fast(&m).xform_inv_fast(&m), n);
// let n = Normal::new(1.0, 2.0, 3.0); }
// assert!((n.length() - 3.7416573867739413).abs() < 0.000001);
// }
// #[test] #[test]
// fn length2() { fn div() {
// let n = Normal::new(1.0, 2.0, 3.0); let v1 = Normal::new(1.0, 2.0, 3.0);
// assert_eq!(n.length2(), 14.0); let v2 = 2.0;
// } let v3 = Normal::new(0.5, 1.0, 1.5);
// #[test] assert_eq!(v3, v1 / v2);
// fn normalized() { }
// let n1 = Normal::new(1.0, 2.0, 3.0);
// let n2 = Normal::new(0.2672612419124244, 0.5345224838248488, 0.8017837257372732);
// let n3 = n1.normalized();
// assert!((n3.x() - n2.x()).abs() < 0.000001);
// assert!((n3.y() - n2.y()).abs() < 0.000001);
// assert!((n3.z() - n2.z()).abs() < 0.000001);
// }
// #[test] #[test]
// fn dot_test() { fn length() {
// let v1 = Normal::new(1.0, 2.0, 3.0); let n = Normal::new(1.0, 2.0, 3.0);
// let v2 = Normal::new(1.5, 4.5, 2.5); assert!((n.length() - 3.7416573867739413).abs() < 0.000001);
// let v3 = 18.0f32; }
// assert_eq!(v3, v1.dot(v2)); #[test]
// } fn length2() {
let n = Normal::new(1.0, 2.0, 3.0);
assert_eq!(n.length2(), 14.0);
}
// #[test] #[test]
// fn cross_test() { fn normalized() {
// let v1 = Normal::new(1.0, 0.0, 0.0); let n1 = Normal::new(1.0, 2.0, 3.0);
// let v2 = Normal::new(0.0, 1.0, 0.0); let n2 = Normal::new(0.2672612419124244, 0.5345224838248488, 0.8017837257372732);
// let v3 = Normal::new(0.0, 0.0, 1.0); let n3 = n1.normalized();
assert!((n3.x() - n2.x()).abs() < 0.000001);
assert!((n3.y() - n2.y()).abs() < 0.000001);
assert!((n3.z() - n2.z()).abs() < 0.000001);
}
// assert_eq!(v3, v1.cross(v2)); #[test]
// } fn dot() {
// } let v1 = Normal::new(1.0, 2.0, 3.0);
let v2 = Normal::new(1.5, 4.5, 2.5);
assert_eq!(v1.dot(v2), 18.0);
}
#[test]
fn dot_fast() {
let v1 = Normal::new(1.0, 2.0, 3.0);
let v2 = Normal::new(1.5, 4.5, 2.5);
assert_eq!(v1.dot_fast(v2), 18.0);
}
#[test]
fn cross() {
let v1 = Normal::new(1.0, 0.0, 0.0);
let v2 = Normal::new(0.0, 1.0, 0.0);
assert_eq!(v1.cross(v2), Normal::new(0.0, 0.0, 1.0));
}
#[test]
fn cross_fast() {
let v1 = Normal::new(1.0, 0.0, 0.0);
let v2 = Normal::new(0.0, 1.0, 0.0);
assert_eq!(v1.cross_fast(v2), Normal::new(0.0, 0.0, 1.0));
}
}

106
sub_crates/rmath/src/point.rs
View File

@ -1,4 +1,5 @@
#![allow(dead_code)] #![allow(dead_code)]
use std::cmp::PartialEq;
use std::ops::{Add, Sub}; use std::ops::{Add, Sub};
use crate::vector::Vector; use crate::vector::Vector;
@ -111,76 +112,53 @@ impl Sub<Vector> for Point {
} }
} }
// impl Mul<Transform> for Point { impl PartialEq for Point {
// type Output = Self; #[inline(always)]
fn eq(&self, rhs: &Self) -> bool {
// #[inline] self.0.a() == rhs.0.a() && self.0.b() == rhs.0.b() && self.0.c() == rhs.0.c()
// fn mul(self, other: Transform) -> Self { }
// Self { }
// co: other.0.transform_point3a(self.0),
// }
// }
// }
//------------------------------------------------------------- //-------------------------------------------------------------
// #[cfg(test)] #[cfg(test)]
// mod tests { mod tests {
// use super::super::{Transform, Vector}; use super::*;
// use super::*; use crate::{Vector, Xform};
// #[test] #[test]
// fn add() { fn add() {
// let p1 = Point::new(1.0, 2.0, 3.0); let p1 = Point::new(1.0, 2.0, 3.0);
// let v1 = Vector::new(1.5, 4.5, 2.5); let v1 = Vector::new(1.5, 4.5, 2.5);
// let p2 = Point::new(2.5, 6.5, 5.5); let p2 = Point::new(2.5, 6.5, 5.5);
// assert_eq!(p2, p1 + v1); assert_eq!(p2, p1 + v1);
// } }
// #[test] #[test]
// fn sub() { fn sub() {
// let p1 = Point::new(1.0, 2.0, 3.0); let p1 = Point::new(1.0, 2.0, 3.0);
// let p2 = Point::new(1.5, 4.5, 2.5); let p2 = Point::new(1.5, 4.5, 2.5);
// let v1 = Vector::new(-0.5, -2.5, 0.5); let v1 = Vector::new(-0.5, -2.5, 0.5);
// assert_eq!(v1, p1 - p2); assert_eq!(v1, p1 - p2);
// } }
// #[test] #[test]
// fn mul_matrix_1() { fn xform() {
// let p = Point::new(1.0, 2.5, 4.0); let p = Point::new(1.0, 2.5, 4.0);
// let m = Transform::new_from_values( let m =
// 1.0, 2.0, 2.0, 1.5, 3.0, 6.0, 7.0, 8.0, 9.0, 2.0, 11.0, 12.0, Xform::new(1.0, 3.0, 9.0, 2.0, 6.0, 2.0, 2.0, 7.0, 11.0, 1.5, 8.0, 12.0).into_full();
// ); assert_eq!(p.xform(&m), Point::new(15.5, 54.0, 70.0));
// let pm = Point::new(15.5, 54.0, 70.0); assert_eq!(p.xform(&m).xform_inv(&m), p);
// assert_eq!(p * m, pm); }
// }
// #[test] #[test]
// fn mul_matrix_2() { fn xform_fast() {
// let p = Point::new(1.0, 2.5, 4.0); let p = Point::new(1.0, 2.5, 4.0);
// let m = Transform::new_from_values( let m =
// 1.0, 2.0, 2.0, 1.5, 3.0, 6.0, 7.0, 8.0, 9.0, 2.0, 11.0, 12.0, Xform::new(1.0, 3.0, 9.0, 2.0, 6.0, 2.0, 2.0, 7.0, 11.0, 1.5, 8.0, 12.0).into_full();
// ); assert_eq!(p.xform_fast(&m), Point::new(15.5, 54.0, 70.0));
// let pm = Point::new(15.5, 54.0, 70.0); assert_eq!(p.xform_fast(&m).xform_inv_fast(&m), p);
// assert_eq!(p * m, pm); }
// } }
// #[test]
// fn mul_matrix_3() {
// // Make sure matrix multiplication composes the way one would expect
// let p = Point::new(1.0, 2.5, 4.0);
// let m1 = Transform::new_from_values(
// 1.0, 2.0, 2.0, 1.5, 3.0, 6.0, 7.0, 8.0, 9.0, 2.0, 11.0, 12.0,
// );
// let m2 =
// Transform::new_from_values(4.0, 1.0, 2.0, 3.5, 3.0, 6.0, 5.0, 2.0, 2.0, 2.0, 4.0, 12.0);
// println!("{:?}", m1 * m2);
// let pmm1 = p * (m1 * m2);
// let pmm2 = (p * m1) * m2;
// assert!((pmm1 - pmm2).length2() <= 0.00001); // Assert pmm1 and pmm2 are roughly equal
// }
// }

209
sub_crates/rmath/src/vector.rs
View File

@ -1,12 +1,13 @@
#![allow(dead_code)] #![allow(dead_code)]
use std::cmp::PartialEq;
use std::ops::{Add, Div, Mul, Neg, Sub}; use std::ops::{Add, Div, Mul, Neg, Sub};
use crate::normal::Normal; use crate::normal::Normal;
use crate::point::Point; use crate::point::Point;
use crate::wide4::Float4; use crate::wide4::Float4;
use crate::xform::XformFull; use crate::xform::XformFull;
use crate::DotProduct; use crate::{CrossProduct, DotProduct};
/// A direction vector in 3D space. /// A direction vector in 3D space.
#[derive(Debug, Copy, Clone)] #[derive(Debug, Copy, Clone)]
@ -144,6 +145,13 @@ impl Neg for Vector {
} }
} }
impl PartialEq for Vector {
#[inline(always)]
fn eq(&self, rhs: &Self) -> bool {
self.0.a() == rhs.0.a() && self.0.b() == rhs.0.b() && self.0.c() == rhs.0.c()
}
}
impl DotProduct for Vector { impl DotProduct for Vector {
#[inline(always)] #[inline(always)]
fn dot(self, other: Self) -> f32 { fn dot(self, other: Self) -> f32 {
@ -156,113 +164,132 @@ impl DotProduct for Vector {
} }
} }
// impl CrossProduct for Vector { impl CrossProduct for Vector {
// #[inline] #[inline(always)]
// fn cross(self, other: Self) -> Self { fn cross(self, other: Self) -> Self {
// Self { Self(Float4::cross_3(self.0, other.0))
// co: self.co.cross(other.co), }
// }
// } #[inline(always)]
// } fn cross_fast(self, other: Self) -> Self {
Self(Float4::cross_3_fast(self.0, other.0))
}
}
//------------------------------------------------------------- //-------------------------------------------------------------
// #[cfg(test)] #[cfg(test)]
// mod tests { mod tests {
// use super::super::{CrossProduct, DotProduct, Transform}; use super::*;
// use super::*; use crate::{CrossProduct, DotProduct, Xform};
// #[test] #[test]
// fn add() { fn add() {
// let v1 = Vector::new(1.0, 2.0, 3.0); let v1 = Vector::new(1.0, 2.0, 3.0);
// let v2 = Vector::new(1.5, 4.5, 2.5); let v2 = Vector::new(1.5, 4.5, 2.5);
// let v3 = Vector::new(2.5, 6.5, 5.5); let v3 = Vector::new(2.5, 6.5, 5.5);
// assert_eq!(v3, v1 + v2); assert_eq!(v3, v1 + v2);
// } }
// #[test] #[test]
// fn sub() { fn sub() {
// let v1 = Vector::new(1.0, 2.0, 3.0); let v1 = Vector::new(1.0, 2.0, 3.0);
// let v2 = Vector::new(1.5, 4.5, 2.5); let v2 = Vector::new(1.5, 4.5, 2.5);
// let v3 = Vector::new(-0.5, -2.5, 0.5); let v3 = Vector::new(-0.5, -2.5, 0.5);
// assert_eq!(v3, v1 - v2); assert_eq!(v3, v1 - v2);
// } }
// #[test] #[test]
// fn mul_scalar() { fn mul_scalar() {
// let v1 = Vector::new(1.0, 2.0, 3.0); let v1 = Vector::new(1.0, 2.0, 3.0);
// let v2 = 2.0; let v2 = 2.0;
// let v3 = Vector::new(2.0, 4.0, 6.0); let v3 = Vector::new(2.0, 4.0, 6.0);
// assert_eq!(v3, v1 * v2); assert_eq!(v3, v1 * v2);
// } }
// #[test] #[test]
// fn mul_matrix_1() { fn xform() {
// let v = Vector::new(1.0, 2.5, 4.0); let v = Vector::new(1.0, 2.5, 4.0);
// let m = Transform::new_from_values( let m =
// 1.0, 2.0, 2.0, 1.5, 3.0, 6.0, 7.0, 8.0, 9.0, 2.0, 11.0, 12.0, Xform::new(1.0, 3.0, 9.0, 2.0, 6.0, 2.0, 2.0, 7.0, 11.0, 1.5, 8.0, 12.0).into_full();
// );
// assert_eq!(v * m, Vector::new(14.0, 46.0, 58.0));
// }
// #[test] assert_eq!(v.xform(&m), Vector::new(14.0, 46.0, 58.0));
// fn mul_matrix_2() { assert_eq!(v.xform(&m).xform_inv(&m), v);
// let v = Vector::new(1.0, 2.5, 4.0); }
// let m = Transform::new_from_values(
// 1.0, 2.0, 2.0, 1.5, 3.0, 6.0, 7.0, 8.0, 9.0, 2.0, 11.0, 12.0,
// );
// assert_eq!(v * m, Vector::new(14.0, 46.0, 58.0));
// }
// #[test] #[test]
// fn div() { fn xform_fast() {
// let v1 = Vector::new(1.0, 2.0, 3.0); let v = Vector::new(1.0, 2.5, 4.0);
// let v2 = 2.0; let m =
// let v3 = Vector::new(0.5, 1.0, 1.5); Xform::new(1.0, 3.0, 9.0, 2.0, 6.0, 2.0, 2.0, 7.0, 11.0, 1.5, 8.0, 12.0).into_full();
// assert_eq!(v3, v1 / v2); assert_eq!(v.xform_fast(&m), Vector::new(14.0, 46.0, 58.0));
// } assert_eq!(v.xform_fast(&m).xform_inv_fast(&m), v);
}
// #[test] #[test]
// fn length() { fn div() {
// let v = Vector::new(1.0, 2.0, 3.0); let v1 = Vector::new(1.0, 2.0, 3.0);
// assert!((v.length() - 3.7416573867739413).abs() < 0.000001); let v2 = 2.0;
// } let v3 = Vector::new(0.5, 1.0, 1.5);
// #[test] assert_eq!(v3, v1 / v2);
// fn length2() { }
// let v = Vector::new(1.0, 2.0, 3.0);
// assert_eq!(v.length2(), 14.0);
// }
// #[test] #[test]
// fn normalized() { fn length() {
// let v1 = Vector::new(1.0, 2.0, 3.0); let v = Vector::new(1.0, 2.0, 3.0);
// let v2 = Vector::new(0.2672612419124244, 0.5345224838248488, 0.8017837257372732); assert!((v.length() - 3.7416573867739413).abs() < 0.000001);
// let v3 = v1.normalized(); }
// assert!((v3.x() - v2.x()).abs() < 0.000001);
// assert!((v3.y() - v2.y()).abs() < 0.000001);
// assert!((v3.z() - v2.z()).abs() < 0.000001);
// }
// #[test] #[test]
// fn dot_test() { fn length2() {
// let v1 = Vector::new(1.0, 2.0, 3.0); let v = Vector::new(1.0, 2.0, 3.0);
// let v2 = Vector::new(1.5, 4.5, 2.5); assert_eq!(v.length2(), 14.0);
// let v3 = 18.0f32; }
// assert_eq!(v3, v1.dot(v2)); #[test]
// } fn normalized() {
let v1 = Vector::new(1.0, 2.0, 3.0);
let v2 = Vector::new(0.2672612419124244, 0.5345224838248488, 0.8017837257372732);
let v3 = v1.normalized();
assert!((v3.x() - v2.x()).abs() < 0.000001);
assert!((v3.y() - v2.y()).abs() < 0.000001);
assert!((v3.z() - v2.z()).abs() < 0.000001);
}
// #[test] #[test]
// fn cross_test() { fn dot() {
// let v1 = Vector::new(1.0, 0.0, 0.0); let v1 = Vector::new(1.0, 2.0, 3.0);
// let v2 = Vector::new(0.0, 1.0, 0.0); let v2 = Vector::new(1.5, 4.5, 2.5);
// let v3 = Vector::new(0.0, 0.0, 1.0);
// assert_eq!(v3, v1.cross(v2)); assert_eq!(v1.dot(v2), 18.0);
// } }
// }
#[test]
fn dot_fast() {
let v1 = Vector::new(1.0, 2.0, 3.0);
let v2 = Vector::new(1.5, 4.5, 2.5);
assert_eq!(v1.dot_fast(v2), 18.0);
}
#[test]
fn cross() {
let v1 = Vector::new(1.0, 0.0, 0.0);
let v2 = Vector::new(0.0, 1.0, 0.0);
assert_eq!(v1.cross(v2), Vector::new(0.0, 0.0, 1.0));
}
#[test]
fn cross_fast() {
let v1 = Vector::new(1.0, 0.0, 0.0);
let v2 = Vector::new(0.0, 1.0, 0.0);
assert_eq!(v1.cross_fast(v2), Vector::new(0.0, 0.0, 1.0));
}
}

31
sub_crates/rmath/src/wide4.rs
View File

@ -1,6 +1,6 @@
use std::ops::{AddAssign, DivAssign, MulAssign, SubAssign}; use std::ops::{AddAssign, DivAssign, MulAssign, SubAssign};
use approx::relative_eq; use approx::ulps_eq;
use crate::{difference_of_products, two_prod, two_sum}; use crate::{difference_of_products, two_prod, two_sum};
@ -335,6 +335,20 @@ impl Float4 {
c.a() + c.b() + c.c() c.a() + c.b() + c.c()
} }
/// 3D cross product (only uses the first 3 components).
#[inline(always)]
pub fn cross_3(a: Self, b: Self) -> Self {
difference_of_products(a.bcad(), b.cabd(), a.cabd(), b.bcad())
}
/// 3D cross product (only uses the first 3 components).
///
/// Faster but less precise version.
#[inline(always)]
pub fn cross_3_fast(a: Self, b: Self) -> Self {
(a.bcad() * b.cabd()) - (a.cabd() * b.bcad())
}
#[inline(always)] #[inline(always)]
pub fn transpose_3x3(m: [Self; 3]) -> [Self; 3] { pub fn transpose_3x3(m: [Self; 3]) -> [Self; 3] {
[ [
@ -504,10 +518,7 @@ impl Float4 {
let (s2, s2_err) = two_sum(c, s1); let (s2, s2_err) = two_sum(c, s1);
let err2 = c_err + (err1 + s2_err); let err2 = c_err + (err1 + s2_err);
let (s3, s3_err) = two_sum(t, s2); s2 + err2
let err3 = err2 + s3_err;
s3 + err3
} }
/// Transforms a 3d point by an affine transform, except it applies /// Transforms a 3d point by an affine transform, except it applies
@ -530,12 +541,12 @@ impl Float4 {
/// ///
/// Each corresponding element cannot have a relative error exceeding /// Each corresponding element cannot have a relative error exceeding
/// `epsilon`. /// `epsilon`.
pub(crate) fn aprx_eq(a: Self, b: Self, epsilon: f32) -> bool { pub(crate) fn aprx_eq(a: Self, b: Self, max_ulps: u32) -> bool {
let mut eq = true; let mut eq = true;
eq &= relative_eq!(a.a(), b.a(), epsilon = epsilon); eq &= ulps_eq!(a.a(), b.a(), max_ulps = max_ulps);
eq &= relative_eq!(a.b(), b.b(), epsilon = epsilon); eq &= ulps_eq!(a.b(), b.b(), max_ulps = max_ulps);
eq &= relative_eq!(a.c(), b.c(), epsilon = epsilon); eq &= ulps_eq!(a.c(), b.c(), max_ulps = max_ulps);
eq &= relative_eq!(a.d(), b.d(), epsilon = epsilon); eq &= ulps_eq!(a.d(), b.d(), max_ulps = max_ulps);
eq eq
} }
} }

18
sub_crates/rmath/src/xform.rs
View File

@ -14,9 +14,9 @@ pub struct Xform {
} }
impl Xform { impl Xform {
/// Creates a new affine transform the specified values: /// Creates a new affine transform with the specified values:
/// ///
/// ``` /// ```text
/// a d g j /// a d g j
/// b e h k /// b e h k
/// c f i l /// c f i l
@ -78,19 +78,19 @@ impl Xform {
/// Returns whether the matrices are approximately equal to each other. /// Returns whether the matrices are approximately equal to each other.
/// Each corresponding element in the matrices cannot have a relative /// Each corresponding element in the matrices cannot have a relative
/// error exceeding epsilon. /// error exceeding epsilon.
pub(crate) fn aprx_eq(&self, other: Xform, epsilon: f32) -> bool { pub(crate) fn aprx_eq(&self, other: Xform, max_ulps: u32) -> bool {
let mut eq = true; let mut eq = true;
eq &= Float4::aprx_eq(self.m[0], other.m[0], epsilon); eq &= Float4::aprx_eq(self.m[0], other.m[0], max_ulps);
eq &= Float4::aprx_eq(self.m[1], other.m[1], epsilon); eq &= Float4::aprx_eq(self.m[1], other.m[1], max_ulps);
eq &= Float4::aprx_eq(self.m[2], other.m[2], epsilon); eq &= Float4::aprx_eq(self.m[2], other.m[2], max_ulps);
eq &= Float4::aprx_eq(self.t, other.t, epsilon); eq &= Float4::aprx_eq(self.t, other.t, max_ulps);
eq eq
} }
/// Computes a "full" version of the transform, which can do both /// Computes a "full" version of the transform, which can do both
/// forward and inverse transforms. /// forward and inverse transforms.
#[inline] #[inline]
pub fn compute_full(self) -> XformFull { pub fn into_full(self) -> XformFull {
XformFull { XformFull {
m: self.m, m: self.m,
m_inv: Float4::invert_3x3(self.m).unwrap_or([ m_inv: Float4::invert_3x3(self.m).unwrap_or([
@ -104,7 +104,7 @@ impl Xform {
/// Faster but less precise version of `compute_full()`. /// Faster but less precise version of `compute_full()`.
#[inline] #[inline]
pub fn compute_full_fast(self) -> XformFull { pub fn into_full_fast(self) -> XformFull {
XformFull { XformFull {
m: self.m, m: self.m,
m_inv: Float4::invert_3x3_fast(self.m).unwrap_or([ m_inv: Float4::invert_3x3_fast(self.m).unwrap_or([