embedded-vector 0.2.1

2D, 3D, and 4D f32 vectors for no_std embedded systems
Documentation
//! API shared by `Vec2`, `Vec3`, and `Vec4` (generated by a macro).
mod common;
use common::close;
use embedded_vector::{Vec2, Vec3, Vec4, VecError};

#[test]
fn constants() {
    assert_eq!(Vec2::ZERO.as_array(), [0.0, 0.0]);
    assert_eq!(Vec2::ONE.as_array(), [1.0, 1.0]);
    assert_eq!(Vec3::Z.as_array(), [0.0, 0.0, 1.0]);
    assert_eq!(Vec4::W.as_array(), [0.0, 0.0, 0.0, 1.0]);
    assert_eq!(Vec4::default(), Vec4::ZERO);
}

#[test]
fn array_conversions() {
    let v = Vec3::from([1.0, 2.0, 3.0]);
    let a: [f32; 3] = v.into();
    assert_eq!(a, [1.0, 2.0, 3.0]);
    assert_eq!(Vec2::from_array([1.0, 2.0]).as_array(), [1.0, 2.0]);
}

#[test]
fn dot_all() {
    assert!(close(
        Vec2::new(1.0, 2.0).dot(&Vec2::new(3.0, 4.0)),
        11.0,
        1e-6
    ));
    assert!(close(
        Vec3::new(1.0, 2.0, 3.0).dot(&Vec3::new(4.0, 5.0, 6.0)),
        32.0,
        1e-6
    ));
    assert!(close(
        Vec4::new(1.0, 2.0, 3.0, 4.0).dot(&Vec4::X),
        1.0,
        1e-6
    ));
}

#[test]
fn norm_basic() {
    assert!(close(Vec2::new(3.0, 4.0).norm().unwrap(), 5.0, 1e-5));
    assert!(close(Vec3::new(1.0, 2.0, 2.0).norm().unwrap(), 3.0, 1e-5));
    assert!(close(
        Vec4::new(1.0, 1.0, 1.0, 1.0).norm().unwrap(),
        2.0,
        1e-5
    ));
    assert_eq!(Vec3::ZERO.norm(), Ok(0.0));
}

#[test]
fn normalize() {
    assert_eq!(Vec3::new(0.0, 0.0, 5.0).normalize().unwrap(), Vec3::Z);
    assert_eq!(Vec2::ZERO.normalize(), Err(VecError::ZeroNorm));
    assert_eq!(Vec4::ZERO.normalize(), Err(VecError::ZeroNorm));
    assert_eq!(Vec3::ZERO.normalize_or_zero(), Vec3::ZERO);
}

#[test]
fn distance() {
    assert!(close(
        Vec2::ZERO.distance(&Vec2::new(3.0, 4.0)).unwrap(),
        5.0,
        1e-5
    ));
    let a = Vec3::new(1.0, 0.0, 0.0);
    assert!(close(
        a.distance(&Vec3::new(4.0, 0.0, 0.0)).unwrap(),
        3.0,
        1e-5
    ));
    assert_eq!(a.distance(&a), Ok(0.0));
    assert!(close(Vec4::ZERO.distance_sq(&Vec4::ONE), 4.0, 1e-6));
}

#[test]
fn lerp_hadamard_minmax() {
    let m = Vec3::ZERO.lerp(&Vec3::new(2.0, 4.0, 6.0), 0.5);
    assert_eq!(m, Vec3::new(1.0, 2.0, 3.0));
    let h = Vec2::new(2.0, 3.0).hadamard(&Vec2::new(4.0, 5.0));
    assert_eq!(h, Vec2::new(8.0, 15.0));
    let a = Vec2::new(1.0, 5.0);
    let b = Vec2::new(3.0, 2.0);
    assert_eq!(a.min(&b), Vec2::new(1.0, 2.0));
    assert_eq!(a.max(&b), Vec2::new(3.0, 5.0));
    assert_eq!(Vec2::new(-1.0, 2.0).abs(), Vec2::new(1.0, 2.0));
}

#[test]
fn checked_div() {
    assert_eq!(Vec2::ONE.checked_div(0.0), Err(VecError::DivisionByZero));
    assert_eq!(Vec2::ONE.checked_div(2.0), Ok(Vec2::new(0.5, 0.5)));
    assert_eq!(
        Vec2::new(f32::MAX, 0.0).checked_div(0.5),
        Err(VecError::NonFiniteValue)
    );
}

#[test]
fn approx_eq() {
    assert!(Vec3::ONE.is_approx_eq(&Vec3::new(1.0005, 1.0, 0.9995), 1e-3));
    assert!(!Vec3::ONE.is_approx_eq(&Vec3::new(1.1, 1.0, 1.0), 1e-3));
}