extern crate nalgebra as na;
extern crate num;
use self::na::Complex;
use self::num::traits::real::Real;
use crate::cosmic::Orbit;
use crate::linalg::{
allocator::Allocator, DefaultAllocator, DimName, Matrix3, Matrix6, OVector, Vector3, Vector6,
};
pub fn tilde_matrix(v: &Vector3<f64>) -> Matrix3<f64> {
Matrix3::new(
0.0,
-v[(2, 0)],
v[(1, 0)],
v[(2, 0)],
0.0,
-v[(0, 0)],
-v[(1, 0)],
v[(0, 0)],
0.0,
)
}
pub fn is_diagonal(m: &Matrix3<f64>) -> bool {
for i in 1..2 {
for j in 0..i {
if i == j && (m[(i, j)] - m[(0, 0)]) > f64::EPSILON
|| i != j
&& (m[(i, j)].abs() > f64::EPSILON
|| (m[(i, j)] - m[(j, i)]).abs() > f64::EPSILON)
{
return false;
}
}
}
true
}
#[allow(clippy::if_same_then_else)]
#[allow(clippy::branches_sharing_code)]
pub fn are_eigenvalues_stable<N: DimName>(eigenvalues: OVector<Complex<f64>, N>) -> bool
where
DefaultAllocator: Allocator<Complex<f64>, N>,
{
for ev in &eigenvalues {
if ev.im.abs() > 0.0 {
if ev.re > 0.0 {
return false;
} else {
continue;
}
} else {
if ev.re > 0.0 {
return false;
} else {
continue;
}
}
}
true
}
pub fn between_0_360(angle: f64) -> f64 {
let mut bounded = angle;
while bounded > 360.0 {
bounded -= 360.0;
}
while bounded < 0.0 {
bounded += 360.0;
}
bounded
}
pub fn between_pm_180(angle: f64) -> f64 {
between_pm_x(angle, 180.0)
}
pub fn between_pm_x(angle: f64, x: f64) -> f64 {
let mut bounded = angle;
while bounded > x {
bounded -= 2.0 * x;
}
while bounded < -x {
bounded += 2.0 * x;
}
bounded
}
pub fn kronecker<T: Real>(a: T, b: T) -> T {
if (a - b).abs() <= T::epsilon() {
T::one()
} else {
T::zero()
}
}
pub fn r1(angle: f64) -> Matrix3<f64> {
let (s, c) = angle.sin_cos();
Matrix3::new(1.0, 0.0, 0.0, 0.0, c, s, 0.0, -s, c)
}
pub fn r2(angle: f64) -> Matrix3<f64> {
let (s, c) = angle.sin_cos();
Matrix3::new(c, 0.0, -s, 0.0, 1.0, 0.0, s, 0.0, c)
}
pub fn r3(angle: f64) -> Matrix3<f64> {
let (s, c) = angle.sin_cos();
Matrix3::new(c, s, 0.0, -s, c, 0.0, 0.0, 0.0, 1.0)
}
pub fn rotv(v: &Vector3<f64>, axis: &Vector3<f64>, theta: f64) -> Vector3<f64> {
let k_hat = axis / axis.norm();
v * theta.cos() + k_hat.cross(v) * theta.sin() + k_hat.dot(v) * k_hat * (1.0 - theta.cos())
}
pub fn perpv(a: &Vector3<f64>, b: &Vector3<f64>) -> Vector3<f64> {
let big_a = a[0].abs().max(a[1].abs().max(a[2].abs()));
let big_b = b[0].abs().max(b[1].abs().max(b[2].abs()));
if big_a < f64::EPSILON {
Vector3::zeros()
} else if big_b < f64::EPSILON {
*a
} else {
let a_scl = a / big_a;
let b_scl = b / big_b;
let v = projv(&a_scl, &b_scl);
big_a * (a_scl - v)
}
}
pub fn projv(a: &Vector3<f64>, b: &Vector3<f64>) -> Vector3<f64> {
b * a.dot(b) / b.dot(b)
}
pub fn rss_errors<N: DimName>(prop_err: &OVector<f64, N>, cur_state: &OVector<f64, N>) -> f64
where
DefaultAllocator: Allocator<f64, N>,
{
let mut v = 0.0;
for i in 0..N::dim() {
v += (prop_err[i] - cur_state[i]).powi(2);
}
v.sqrt()
}
pub fn rss_orbit_errors(prop_err: &Orbit, cur_state: &Orbit) -> (f64, f64) {
(
rss_errors(&prop_err.radius(), &cur_state.radius()),
rss_errors(&prop_err.velocity(), &cur_state.velocity()),
)
}
pub fn rss_orbit_vec_errors(prop_err: &Vector6<f64>, cur_state: &Vector6<f64>) -> (f64, f64) {
let err_radius = (prop_err.fixed_rows::<3>(0) - cur_state.fixed_rows::<3>(0)).norm();
let err_velocity = (prop_err.fixed_rows::<3>(3) - cur_state.fixed_rows::<3>(3)).norm();
(err_radius, err_velocity)
}
pub fn normalize(x: f64, min_x: f64, max_x: f64) -> f64 {
2.0 * (x - min_x) / (max_x - min_x) - 1.0
}
pub fn denormalize(xp: f64, min_x: f64, max_x: f64) -> f64 {
(max_x - min_x) * (xp + 1.0) / 2.0 + min_x
}
pub fn capitalize(s: &str) -> String {
let mut c = s.chars();
match c.next() {
None => String::new(),
Some(f) => f.to_uppercase().collect::<String>() + c.as_str(),
}
}
pub(crate) fn dcm_finite_differencing(
dcm_pre: Matrix3<f64>,
dcm_cur: Matrix3<f64>,
dcm_post: Matrix3<f64>,
) -> Matrix6<f64> {
let drdt = 0.5 * dcm_post - 0.5 * dcm_pre;
dcm_assemble(dcm_cur, drdt)
}
pub(crate) fn dcm_assemble(r: Matrix3<f64>, drdt: Matrix3<f64>) -> Matrix6<f64> {
let mut full_dcm = Matrix6::zeros();
for i in 0..6 {
for j in 0..6 {
if (i < 3 && j < 3) || (i >= 3 && j >= 3) {
full_dcm[(i, j)] = r[(i % 3, j % 3)];
} else if i >= 3 && j < 3 {
full_dcm[(i, j)] = drdt[(i - 3, j)];
}
}
}
full_dcm
}
#[macro_export]
macro_rules! pseudo_inverse {
($mat:expr) => {{
use crate::NyxError;
let (rows, cols) = $mat.shape();
if rows < cols {
match ($mat * $mat.transpose()).try_inverse() {
Some(m1_inv) => Ok($mat.transpose() * m1_inv),
None => Err(NyxError::SingularJacobian),
}
} else {
match ($mat.transpose() * $mat).try_inverse() {
Some(m2_inv) => Ok(m2_inv * $mat.transpose()),
None => Err(NyxError::SingularJacobian),
}
}
}};
}
pub fn mag_order(value: f64) -> i32 {
value.abs().log10().floor() as i32
}
pub fn unitize(v: Vector3<f64>) -> Vector3<f64> {
if v.norm() < f64::EPSILON {
v
} else {
v / v.norm()
}
}
pub fn cartesian_to_spherical(v: &Vector3<f64>) -> (f64, f64, f64) {
if v.norm() < f64::EPSILON {
(0.0, 0.0, 0.0)
} else {
let range_ρ = v.norm();
let θ = v.y.atan2(v.x);
let φ = (v.z / range_ρ).acos();
(range_ρ, θ, φ)
}
}
pub fn spherical_to_cartesian(range_ρ: f64, θ: f64, φ: f64) -> Vector3<f64> {
if range_ρ < f64::EPSILON {
Vector3::zeros()
} else {
let x = range_ρ * φ.sin() * θ.cos();
let y = range_ρ * φ.sin() * θ.sin();
let z = range_ρ * φ.cos();
Vector3::new(x, y, z)
}
}
#[test]
fn test_tilde_matrix() {
let vec = Vector3::new(1.0, 2.0, 3.0);
let rslt = Matrix3::new(0.0, -3.0, 2.0, 3.0, 0.0, -1.0, -2.0, 1.0, 0.0);
assert_eq!(tilde_matrix(&vec), rslt);
}
#[test]
fn test_diagonality() {
assert!(
!is_diagonal(&Matrix3::new(10.0, 0.0, 0.0, 1.0, 5.0, 0.0, 0.0, 0.0, 2.0)),
"lower triangular"
);
assert!(
!is_diagonal(&Matrix3::new(10.0, 1.0, 0.0, 1.0, 5.0, 0.0, 0.0, 0.0, 2.0)),
"symmetric but not diag"
);
assert!(
!is_diagonal(&Matrix3::new(10.0, 1.0, 0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 2.0)),
"upper triangular"
);
assert!(
is_diagonal(&Matrix3::new(10.0, 0.0, 0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 2.0)),
"diagonal"
);
}
#[test]
fn test_perpv() {
assert_eq!(
perpv(&Vector3::new(6.0, 6.0, 6.0), &Vector3::new(2.0, 0.0, 0.0)),
Vector3::new(0.0, 6.0, 6.0)
);
assert_eq!(
perpv(&Vector3::new(6.0, 6.0, 6.0), &Vector3::new(-3.0, 0.0, 0.0)),
Vector3::new(0.0, 6.0, 6.0)
);
assert_eq!(
perpv(&Vector3::new(6.0, 6.0, 0.0), &Vector3::new(0.0, 7.0, 0.0)),
Vector3::new(6.0, 0.0, 0.0)
);
assert_eq!(
perpv(&Vector3::new(6.0, 0.0, 0.0), &Vector3::new(0.0, 0.0, 9.0)),
Vector3::new(6.0, 0.0, 0.0)
);
}
#[test]
fn test_projv() {
assert_eq!(
projv(&Vector3::new(6.0, 6.0, 6.0), &Vector3::new(2.0, 0.0, 0.0)),
Vector3::new(6.0, 0.0, 0.0)
);
assert_eq!(
projv(&Vector3::new(6.0, 6.0, 6.0), &Vector3::new(-3.0, 0.0, 0.0)),
Vector3::new(6.0, 0.0, 0.0)
);
assert_eq!(
projv(&Vector3::new(6.0, 6.0, 0.0), &Vector3::new(0.0, 7.0, 0.0)),
Vector3::new(0.0, 6.0, 0.0)
);
assert_eq!(
projv(&Vector3::new(6.0, 0.0, 0.0), &Vector3::new(0.0, 0.0, 9.0)),
Vector3::new(0.0, 0.0, 0.0)
);
}
#[test]
fn test_angle_bounds() {
assert!((between_pm_180(181.0) - -179.0).abs() < f64::EPSILON);
assert!((between_0_360(-179.0) - 181.0).abs() < f64::EPSILON);
}
#[test]
fn test_pseudo_inv() {
use crate::linalg::{DMatrix, SMatrix};
let mut mat = DMatrix::from_element(1, 3, 0.0);
mat[(0, 0)] = -1407.273208782421;
mat[(0, 1)] = -2146.3100013104886;
mat[(0, 2)] = 84.05022886527551;
println!("{}", pseudo_inverse!(&mat).unwrap());
let mut mat = SMatrix::<f64, 1, 3>::zeros();
mat[(0, 0)] = -1407.273208782421;
mat[(0, 1)] = -2146.3100013104886;
mat[(0, 2)] = 84.05022886527551;
println!("{}", pseudo_inverse!(&mat).unwrap());
let mut mat = SMatrix::<f64, 3, 1>::zeros();
mat[(0, 0)] = -1407.273208782421;
mat[(1, 0)] = -2146.3100013104886;
mat[(2, 0)] = 84.05022886527551;
println!("{}", pseudo_inverse!(&mat).unwrap());
let mat = SMatrix::<f64, 2, 2>::new(3.0, 4.0, -2.0, 1.0);
println!("{}", mat.try_inverse().unwrap());
println!("{}", pseudo_inverse!(&mat).unwrap());
}
#[test]
fn spherical() {
for v in &[
Vector3::<f64>::x(),
Vector3::<f64>::y(),
Vector3::<f64>::z(),
Vector3::<f64>::zeros(),
Vector3::<f64>::new(159.1, 561.2, 756.3),
] {
let (range_ρ, θ, φ) = cartesian_to_spherical(v);
let v_prime = spherical_to_cartesian(range_ρ, θ, φ);
assert!(rss_errors(v, &v_prime) < 1e-12, "{} != {}", v, &v_prime);
}
}