use std::ops::Mul;
use crate::physics::basic::{
Force, ForceType, Vector3, Coef, Momentum,
};
use crate::utils::float;
impl Mul<chrono::TimeDelta> for Vector3<Force> {
type Output = Vector3<Momentum>;
fn mul(self, rhs: chrono::TimeDelta) -> Self::Output {
let x = self.x * rhs;
let y = self.y * rhs;
let z = self.z * rhs;
Vector3::<Momentum>::new(x, y, z)
}
}
impl Vector3<Force> {
pub fn limit_float(&self, threshold: f64, force_type: ForceType) -> Self {
let (x, y, z) = match force_type {
ForceType::Newton => (
float::limit_float(self.x.as_newton(), threshold),
float::limit_float(self.y.as_newton(), threshold),
float::limit_float(self.z.as_newton(), threshold),
),
ForceType::MillNewton => (
float::limit_float(self.x.as_mill_newton(), threshold),
float::limit_float(self.y.as_mill_newton(), threshold),
float::limit_float(self.z.as_mill_newton(), threshold),
),
ForceType::MicroNewton => (
float::limit_float(self.x.as_micro_newton(), threshold),
float::limit_float(self.y.as_micro_newton(), threshold),
float::limit_float(self.z.as_micro_newton(), threshold),
),
ForceType::NanoNewton => (
float::limit_float(self.x.as_nano_newton(), threshold),
float::limit_float(self.y.as_nano_newton(), threshold),
float::limit_float(self.z.as_nano_newton(), threshold),
),
ForceType::KiloNewton => (
float::limit_float(self.x.as_kilo_newton(), threshold),
float::limit_float(self.y.as_kilo_newton(), threshold),
float::limit_float(self.z.as_kilo_newton(), threshold),
),
ForceType::MegaNewton => (
float::limit_float(self.x.as_mega_newton(), threshold),
float::limit_float(self.y.as_mega_newton(), threshold),
float::limit_float(self.z.as_mega_newton(), threshold),
),
};
match force_type {
ForceType::Newton => Self { x: Force::from_newton(x), y: Force::from_newton(y), z: Force::from_newton(z) },
ForceType::MillNewton => Self { x: Force::from_mill_newton(x), y: Force::from_mill_newton(y), z: Force::from_mill_newton(z) },
ForceType::MicroNewton => Self { x: Force::from_micro_newton(x), y: Force::from_micro_newton(y), z: Force::from_micro_newton(z) },
ForceType::NanoNewton => Self { x: Force::from_nano_newton(x), y: Force::from_nano_newton(y), z: Force::from_nano_newton(z) },
ForceType::KiloNewton => Self { x: Force::from_kilo_newton(x), y: Force::from_kilo_newton(y), z: Force::from_kilo_newton(z) },
ForceType::MegaNewton => Self { x: Force::from_mega_newton(x), y: Force::from_mega_newton(y), z: Force::from_mega_newton(z) },
}
}
pub fn to_vector3_coef(&self, force_type: ForceType) -> Vector3<Coef> {
match force_type {
ForceType::Newton => {
let (x, y, z) = (self.x.as_newton(), self.y.as_newton(), self.z.as_newton());
Vector3::<Coef>::from_array([x, y, z])
}
ForceType::MillNewton => {
let (x, y, z) = (self.x.as_mill_newton(), self.y.as_mill_newton(), self.z.as_mill_newton());
Vector3::<Coef>::from_array([x, y, z])
}
ForceType::MicroNewton => {
let (x, y, z) = (self.x.as_micro_newton(), self.y.as_micro_newton(), self.z.as_micro_newton());
Vector3::<Coef>::from_array([x, y, z])
}
ForceType::NanoNewton => {
let (x, y, z) = (self.x.as_nano_newton(), self.y.as_nano_newton(), self.z.as_nano_newton());
Vector3::<Coef>::from_array([x, y, z])
}
ForceType::KiloNewton => {
let (x, y, z) = (self.x.as_kilo_newton(), self.y.as_kilo_newton(), self.z.as_kilo_newton());
Vector3::<Coef>::from_array([x, y, z])
}
ForceType::MegaNewton => {
let (x, y, z) = (self.x.as_mega_newton(), self.y.as_mega_newton(), self.z.as_mega_newton());
Vector3::<Coef>::from_array([x, y, z])
}
}
}
pub fn from_vector_coef(coef: Vector3<Coef>, force_type: ForceType) -> Vector3<Force> {
let [x, y, z] = coef.to_array();
match force_type {
ForceType::Newton => {
Vector3::new(
Force::from_newton(x),
Force::from_newton(y),
Force::from_newton(z),
)
}
ForceType::MillNewton => {
Vector3::new(
Force::from_mill_newton(x),
Force::from_mill_newton(y),
Force::from_mill_newton(z),
)
}
ForceType::MicroNewton => {
Vector3::new(
Force::from_micro_newton(x),
Force::from_micro_newton(y),
Force::from_micro_newton(z),
)
}
ForceType::NanoNewton => {
Vector3::new(
Force::from_nano_newton(x),
Force::from_nano_newton(y),
Force::from_nano_newton(z),
)
}
ForceType::KiloNewton => {
Vector3::new(
Force::from_kilo_newton(x),
Force::from_kilo_newton(y),
Force::from_kilo_newton(z),
)
}
ForceType::MegaNewton => {
Vector3::new(
Force::from_mega_newton(x),
Force::from_mega_newton(y),
Force::from_mega_newton(z),
)
}
}
}
pub fn from_array_with_unit(array: [f64; 3], force_type: ForceType) -> Vector3<Force> {
let [x, y, z] = array;
match force_type {
ForceType::Newton => {
Vector3::new(
Force::from_newton(x),
Force::from_newton(y),
Force::from_newton(z),
)
}
ForceType::MillNewton => {
Vector3::new(
Force::from_mill_newton(x),
Force::from_mill_newton(y),
Force::from_mill_newton(z),
)
}
ForceType::MicroNewton => {
Vector3::new(
Force::from_micro_newton(x),
Force::from_micro_newton(y),
Force::from_micro_newton(z),
)
}
ForceType::NanoNewton => {
Vector3::new(
Force::from_nano_newton(x),
Force::from_nano_newton(y),
Force::from_nano_newton(z),
)
}
ForceType::KiloNewton => {
Vector3::new(
Force::from_kilo_newton(x),
Force::from_kilo_newton(y),
Force::from_kilo_newton(z),
)
}
ForceType::MegaNewton => {
Vector3::new(
Force::from_mega_newton(x),
Force::from_mega_newton(y),
Force::from_mega_newton(z),
)
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_mul_timedelta() {
let f = Vector3::new(
Force::from_newton(1.0),
Force::from_newton(2.0),
Force::from_newton(-3.0),
);
let p = f * chrono::TimeDelta::seconds(2);
assert_relative_eq!(p.x.as_kg_m_s(), 2.0);
assert_relative_eq!(p.y.as_kg_m_s(), 4.0);
assert_relative_eq!(p.z.as_kg_m_s(), -6.0);
let p_neg = f * chrono::TimeDelta::seconds(-1);
assert_relative_eq!(p_neg.x.as_kg_m_s(), -1.0);
let p_zero = f * chrono::TimeDelta::zero();
assert_relative_eq!(p_zero.x.as_kg_m_s(), 0.0);
}
use approx::assert_relative_eq;
#[test]
fn test_limit_float() {
let v = Vector3::new(
Force::from_newton(1.0),
Force::from_newton(-5.0),
Force::from_newton(3.0),
);
let result = v.limit_float(3.0, ForceType::Newton);
assert_relative_eq!(result.x.as_newton(), 1.0);
assert_relative_eq!(result.y.as_newton(), -3.0);
assert_relative_eq!(result.z.as_newton(), 3.0);
let result = v.limit_float(1e10, ForceType::MillNewton);
assert_relative_eq!(result.x.as_mill_newton(), 1000.0);
assert_relative_eq!(result.y.as_mill_newton(), -5000.0);
assert_relative_eq!(result.z.as_mill_newton(), 3000.0);
let result = v.limit_float(1e10, ForceType::MicroNewton);
assert_relative_eq!(result.x.as_micro_newton(), 1000000.0);
assert_relative_eq!(result.y.as_micro_newton(), -5000000.0);
assert_relative_eq!(result.z.as_micro_newton(), 3000000.0);
let result = v.limit_float(1e10, ForceType::NanoNewton);
assert_relative_eq!(result.x.as_nano_newton(), 1000000000.0);
assert_relative_eq!(result.y.as_nano_newton(), -5000000000.0);
assert_relative_eq!(result.z.as_nano_newton(), 3000000000.0);
let result = v.limit_float(1e10, ForceType::KiloNewton);
assert_relative_eq!(result.x.as_kilo_newton(), 0.001);
assert_relative_eq!(result.y.as_kilo_newton(), -0.005);
assert_relative_eq!(result.z.as_kilo_newton(), 0.003);
let result = v.limit_float(1e10, ForceType::MegaNewton);
assert_relative_eq!(result.x.as_mega_newton(), 0.000001);
assert_relative_eq!(result.y.as_mega_newton(), -0.000005);
assert_relative_eq!(result.z.as_mega_newton(), 0.000003);
}
#[test]
fn test_to_vector3_coef_newton() {
let force_vec = Vector3::new(
Force::from_newton(1.0),
Force::from_newton(2.0),
Force::from_newton(3.0),
);
let coef_vec = force_vec.to_vector3_coef(ForceType::Newton);
assert_relative_eq!(coef_vec.x.get_value(), 1.0, epsilon = 1e-10);
assert_relative_eq!(coef_vec.y.get_value(), 2.0, epsilon = 1e-10);
assert_relative_eq!(coef_vec.z.get_value(), 3.0, epsilon = 1e-10);
}
#[test]
fn test_from_vector_coef_newton() {
let coef_vec = Vector3::new(Coef::new(1.0), Coef::new(2.0), Coef::new(3.0));
let force_vec = Vector3::<Force>::from_vector_coef(coef_vec, ForceType::Newton);
assert_relative_eq!(force_vec.x.as_newton(), 1.0, epsilon = 1e-10);
assert_relative_eq!(force_vec.y.as_newton(), 2.0, epsilon = 1e-10);
assert_relative_eq!(force_vec.z.as_newton(), 3.0, epsilon = 1e-10);
}
#[test]
fn test_from_vector_coef_mill_newton() {
let coef_vec = Vector3::new(Coef::new(1.0), Coef::new(2.0), Coef::new(3.0));
let force_vec = Vector3::<Force>::from_vector_coef(coef_vec, ForceType::MillNewton);
assert_relative_eq!(force_vec.x.as_mill_newton(), 1.0, epsilon = 1e-10);
assert_relative_eq!(force_vec.y.as_mill_newton(), 2.0, epsilon = 1e-10);
assert_relative_eq!(force_vec.z.as_mill_newton(), 3.0, epsilon = 1e-10);
}
#[test]
fn test_from_vector_coef_micro_newton() {
let coef_vec = Vector3::new(Coef::new(1.0), Coef::new(2.0), Coef::new(3.0));
let force_vec = Vector3::<Force>::from_vector_coef(coef_vec, ForceType::MicroNewton);
assert_relative_eq!(force_vec.x.as_micro_newton(), 1.0, epsilon = 1e-10);
assert_relative_eq!(force_vec.y.as_micro_newton(), 2.0, epsilon = 1e-10);
assert_relative_eq!(force_vec.z.as_micro_newton(), 3.0, epsilon = 1e-10);
}
#[test]
fn test_from_vector_coef_nano_newton() {
let coef_vec = Vector3::new(Coef::new(1.0), Coef::new(2.0), Coef::new(3.0));
let force_vec = Vector3::<Force>::from_vector_coef(coef_vec, ForceType::NanoNewton);
assert_relative_eq!(force_vec.x.as_nano_newton(), 1.0, epsilon = 1e-10);
assert_relative_eq!(force_vec.y.as_nano_newton(), 2.0, epsilon = 1e-10);
assert_relative_eq!(force_vec.z.as_nano_newton(), 3.0, epsilon = 1e-10);
}
#[test]
fn test_from_vector_coef_kilo_newton() {
let coef_vec = Vector3::new(Coef::new(1.0), Coef::new(2.0), Coef::new(3.0));
let force_vec = Vector3::<Force>::from_vector_coef(coef_vec, ForceType::KiloNewton);
assert_relative_eq!(force_vec.x.as_kilo_newton(), 1.0, epsilon = 1e-10);
assert_relative_eq!(force_vec.y.as_kilo_newton(), 2.0, epsilon = 1e-10);
assert_relative_eq!(force_vec.z.as_kilo_newton(), 3.0, epsilon = 1e-10);
}
#[test]
fn test_from_vector_coef_mega_newton() {
let coef_vec = Vector3::new(Coef::new(1.0), Coef::new(2.0), Coef::new(3.0));
let force_vec = Vector3::<Force>::from_vector_coef(coef_vec, ForceType::MegaNewton);
assert_relative_eq!(force_vec.x.as_mega_newton(), 1.0, epsilon = 1e-10);
assert_relative_eq!(force_vec.y.as_mega_newton(), 2.0, epsilon = 1e-10);
assert_relative_eq!(force_vec.z.as_mega_newton(), 3.0, epsilon = 1e-10);
}
#[test]
fn test_force_comprehensive_as_methods() {
let force_vec = Vector3::new(
Force::from_newton(1.0),
Force::from_newton(2.0),
Force::from_newton(3.0),
);
let coef_newton = force_vec.to_vector3_coef(ForceType::Newton);
let coef_mill_newton = force_vec.to_vector3_coef(ForceType::MillNewton);
let coef_micro_newton = force_vec.to_vector3_coef(ForceType::MicroNewton);
let coef_nano_newton = force_vec.to_vector3_coef(ForceType::NanoNewton);
let coef_kilo_newton = force_vec.to_vector3_coef(ForceType::KiloNewton);
let coef_mega_newton = force_vec.to_vector3_coef(ForceType::MegaNewton);
assert_relative_eq!(coef_newton.x.get_value(), 1.0, epsilon = 1e-10);
assert_relative_eq!(coef_mill_newton.x.get_value(), 1000.0, epsilon = 1e-10);
assert_relative_eq!(coef_micro_newton.x.get_value(), 1000000.0, epsilon = 1e-10);
assert_relative_eq!(coef_nano_newton.x.get_value(), 1000000000.0, epsilon = 1e-10);
assert_relative_eq!(coef_kilo_newton.x.get_value(), 0.001, epsilon = 1e-10);
assert_relative_eq!(coef_mega_newton.x.get_value(), 0.000001, epsilon = 1e-10);
let mill_newton_vec = Vector3::new(
Force::from_mill_newton(1000.0),
Force::from_mill_newton(2000.0),
Force::from_mill_newton(3000.0),
);
let coef_from_mill_newton = mill_newton_vec.to_vector3_coef(ForceType::Newton);
let coef_from_mill_newton_mill = mill_newton_vec.to_vector3_coef(ForceType::MillNewton);
let coef_from_mill_newton_micro = mill_newton_vec.to_vector3_coef(ForceType::MicroNewton);
let coef_from_mill_newton_nano = mill_newton_vec.to_vector3_coef(ForceType::NanoNewton);
let coef_from_mill_newton_kilo = mill_newton_vec.to_vector3_coef(ForceType::KiloNewton);
let coef_from_mill_newton_mega = mill_newton_vec.to_vector3_coef(ForceType::MegaNewton);
assert_relative_eq!(coef_from_mill_newton.x.get_value(), 1.0, epsilon = 1e-10);
assert_relative_eq!(coef_from_mill_newton_mill.x.get_value(), 1000.0, epsilon = 1e-10);
assert_relative_eq!(coef_from_mill_newton_micro.x.get_value(), 1000000.0, epsilon = 1e-10);
assert_relative_eq!(coef_from_mill_newton_nano.x.get_value(), 1000000000.0, epsilon = 1e-10);
assert_relative_eq!(coef_from_mill_newton_kilo.x.get_value(), 0.001, epsilon = 1e-10);
assert_relative_eq!(coef_from_mill_newton_mega.x.get_value(), 0.000001, epsilon = 1e-10);
let micro_newton_vec = Vector3::new(
Force::from_micro_newton(1000000.0),
Force::from_micro_newton(2000000.0),
Force::from_micro_newton(3000000.0),
);
let coef_from_micro_newton = micro_newton_vec.to_vector3_coef(ForceType::Newton);
let coef_from_micro_newton_mill = micro_newton_vec.to_vector3_coef(ForceType::MillNewton);
let coef_from_micro_newton_micro = micro_newton_vec.to_vector3_coef(ForceType::MicroNewton);
let coef_from_micro_newton_nano = micro_newton_vec.to_vector3_coef(ForceType::NanoNewton);
let coef_from_micro_newton_kilo = micro_newton_vec.to_vector3_coef(ForceType::KiloNewton);
let coef_from_micro_newton_mega = micro_newton_vec.to_vector3_coef(ForceType::MegaNewton);
assert_relative_eq!(coef_from_micro_newton.x.get_value(), 1.0, epsilon = 1e-10);
assert_relative_eq!(coef_from_micro_newton_mill.x.get_value(), 1000.0, epsilon = 1e-10);
assert_relative_eq!(coef_from_micro_newton_micro.x.get_value(), 1000000.0, epsilon = 1e-10);
assert_relative_eq!(coef_from_micro_newton_nano.x.get_value(), 1000000000.0, epsilon = 1e-10);
assert_relative_eq!(coef_from_micro_newton_kilo.x.get_value(), 0.001, epsilon = 1e-10);
assert_relative_eq!(coef_from_micro_newton_mega.x.get_value(), 0.000001, epsilon = 1e-10);
let nano_newton_vec = Vector3::new(
Force::from_nano_newton(1000000000.0),
Force::from_nano_newton(2000000000.0),
Force::from_nano_newton(3000000000.0),
);
let coef_from_nano_newton = nano_newton_vec.to_vector3_coef(ForceType::Newton);
let coef_from_nano_newton_mill = nano_newton_vec.to_vector3_coef(ForceType::MillNewton);
let coef_from_nano_newton_micro = nano_newton_vec.to_vector3_coef(ForceType::MicroNewton);
let coef_from_nano_newton_nano = nano_newton_vec.to_vector3_coef(ForceType::NanoNewton);
let coef_from_nano_newton_kilo = nano_newton_vec.to_vector3_coef(ForceType::KiloNewton);
let coef_from_nano_newton_mega = nano_newton_vec.to_vector3_coef(ForceType::MegaNewton);
assert_relative_eq!(coef_from_nano_newton.x.get_value(), 1.0, epsilon = 1e-10);
assert_relative_eq!(coef_from_nano_newton_mill.x.get_value(), 1000.0, epsilon = 1e-10);
assert_relative_eq!(coef_from_nano_newton_micro.x.get_value(), 1000000.0, epsilon = 1e-10);
assert_relative_eq!(coef_from_nano_newton_nano.x.get_value(), 1000000000.0, epsilon = 1e-10);
assert_relative_eq!(coef_from_nano_newton_kilo.x.get_value(), 0.001, epsilon = 1e-10);
assert_relative_eq!(coef_from_nano_newton_mega.x.get_value(), 0.000001, epsilon = 1e-10);
let kilo_newton_vec = Vector3::new(
Force::from_kilo_newton(0.001),
Force::from_kilo_newton(0.002),
Force::from_kilo_newton(0.003),
);
let coef_from_kilo_newton = kilo_newton_vec.to_vector3_coef(ForceType::Newton);
let coef_from_kilo_newton_mill = kilo_newton_vec.to_vector3_coef(ForceType::MillNewton);
let coef_from_kilo_newton_micro = kilo_newton_vec.to_vector3_coef(ForceType::MicroNewton);
let coef_from_kilo_newton_nano = kilo_newton_vec.to_vector3_coef(ForceType::NanoNewton);
let coef_from_kilo_newton_kilo = kilo_newton_vec.to_vector3_coef(ForceType::KiloNewton);
let coef_from_kilo_newton_mega = kilo_newton_vec.to_vector3_coef(ForceType::MegaNewton);
assert_relative_eq!(coef_from_kilo_newton.x.get_value(), 1.0, epsilon = 1e-10);
assert_relative_eq!(coef_from_kilo_newton_mill.x.get_value(), 1000.0, epsilon = 1e-10);
assert_relative_eq!(coef_from_kilo_newton_micro.x.get_value(), 1000000.0, epsilon = 1e-10);
assert_relative_eq!(coef_from_kilo_newton_nano.x.get_value(), 1000000000.0, epsilon = 1e-10);
assert_relative_eq!(coef_from_kilo_newton_kilo.x.get_value(), 0.001, epsilon = 1e-10);
assert_relative_eq!(coef_from_kilo_newton_mega.x.get_value(), 0.000001, epsilon = 1e-10);
let mega_newton_vec = Vector3::new(
Force::from_mega_newton(0.000001),
Force::from_mega_newton(0.000002),
Force::from_mega_newton(0.000003),
);
let coef_from_mega_newton = mega_newton_vec.to_vector3_coef(ForceType::Newton);
let coef_from_mega_newton_mill = mega_newton_vec.to_vector3_coef(ForceType::MillNewton);
let coef_from_mega_newton_micro = mega_newton_vec.to_vector3_coef(ForceType::MicroNewton);
let coef_from_mega_newton_nano = mega_newton_vec.to_vector3_coef(ForceType::NanoNewton);
let coef_from_mega_newton_kilo = mega_newton_vec.to_vector3_coef(ForceType::KiloNewton);
let coef_from_mega_newton_mega = mega_newton_vec.to_vector3_coef(ForceType::MegaNewton);
assert_relative_eq!(coef_from_mega_newton.x.get_value(), 1.0, epsilon = 1e-10);
assert_relative_eq!(coef_from_mega_newton_mill.x.get_value(), 1000.0, epsilon = 1e-10);
assert_relative_eq!(coef_from_mega_newton_micro.x.get_value(), 1000000.0, epsilon = 1e-10);
assert_relative_eq!(coef_from_mega_newton_nano.x.get_value(), 1000000000.0, epsilon = 1e-10);
assert_relative_eq!(coef_from_mega_newton_kilo.x.get_value(), 0.001, epsilon = 1e-10);
assert_relative_eq!(coef_from_mega_newton_mega.x.get_value(), 0.000001, epsilon = 1e-10);
}
#[test]
fn test_from_array_with_unit() {
let array = [1.0, 2.0, 3.0];
let force_vec = Vector3::<Force>::from_array_with_unit(array, ForceType::Newton);
assert_relative_eq!(force_vec.x.as_newton(), 1.0, epsilon = 1e-10);
assert_relative_eq!(force_vec.y.as_newton(), 2.0, epsilon = 1e-10);
assert_relative_eq!(force_vec.z.as_newton(), 3.0, epsilon = 1e-10);
let force_vec_mill = Vector3::<Force>::from_array_with_unit(array, ForceType::MillNewton);
assert_relative_eq!(force_vec_mill.x.as_mill_newton(), 1.0, epsilon = 1e-10);
assert_relative_eq!(force_vec_mill.y.as_mill_newton(), 2.0, epsilon = 1e-10);
assert_relative_eq!(force_vec_mill.z.as_mill_newton(), 3.0, epsilon = 1e-10);
let force_vec_micro = Vector3::<Force>::from_array_with_unit(array, ForceType::MicroNewton);
assert_relative_eq!(force_vec_micro.x.as_micro_newton(), 1.0, epsilon = 1e-10);
assert_relative_eq!(force_vec_micro.y.as_micro_newton(), 2.0, epsilon = 1e-10);
assert_relative_eq!(force_vec_micro.z.as_micro_newton(), 3.0, epsilon = 1e-10);
let force_vec_nano = Vector3::<Force>::from_array_with_unit(array, ForceType::NanoNewton);
assert_relative_eq!(force_vec_nano.x.as_nano_newton(), 1.0, epsilon = 1e-10);
assert_relative_eq!(force_vec_nano.y.as_nano_newton(), 2.0, epsilon = 1e-10);
assert_relative_eq!(force_vec_nano.z.as_nano_newton(), 3.0, epsilon = 1e-10);
let force_vec_kilo = Vector3::<Force>::from_array_with_unit(array, ForceType::KiloNewton);
assert_relative_eq!(force_vec_kilo.x.as_kilo_newton(), 1.0, epsilon = 1e-10);
assert_relative_eq!(force_vec_kilo.y.as_kilo_newton(), 2.0, epsilon = 1e-10);
assert_relative_eq!(force_vec_kilo.z.as_kilo_newton(), 3.0, epsilon = 1e-10);
let force_vec_mega = Vector3::<Force>::from_array_with_unit(array, ForceType::MegaNewton);
assert_relative_eq!(force_vec_mega.x.as_mega_newton(), 1.0, epsilon = 1e-10);
assert_relative_eq!(force_vec_mega.y.as_mega_newton(), 2.0, epsilon = 1e-10);
assert_relative_eq!(force_vec_mega.z.as_mega_newton(), 3.0, epsilon = 1e-10);
}
}