diman 0.2.0

Zero-cost compile-time dimensional analysis.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

use mpi::environment::Universe;
use mpi::Threading;

lazy_static::lazy_static! {
    pub static ref MPI_UNIVERSE: Universe = {
        let threading = Threading::Single;
        let (universe, _) =
            mpi::initialize_with_threading(threading).unwrap();
        universe
    };
}

macro_rules! gen_tests_for_float {
    ($float_name: ident) => {
        mod $float_name {
            use crate::example_system::$float_name::Length;
            use mpi::traits::Communicator;

            #[test]
            fn pack_unpack_f64_quantity() {
                let world = super::MPI_UNIVERSE.world();
                let q1 = Length::meters(1.0);
                let mut q2 = Length::meters(2.0);
                let a = world.pack(&q1);
                unsafe {
                    world.unpack_into(&a, &mut q2, 0);
                }
                assert_eq!(q1, q2);
            }
        }
    };
}

macro_rules! gen_tests_for_vector_2 {
    ($vec_mod_name: ident) => {
        mod $vec_mod_name {
            use crate::example_system::$vec_mod_name::Length as VecLength;
            use mpi::topology::Communicator;

            #[test]
            fn pack_unpack_vec_quantity() {
                let world = super::MPI_UNIVERSE.world();
                let q1 = VecLength::meters(1.0, 2.0);
                let mut q2 = VecLength::meters(3.0, 4.0);
                let a = world.pack(&q1);
                unsafe {
                    world.unpack_into(&a, &mut q2, 0);
                }
                assert_eq!(q1, q2);
            }
        }
    };
}

macro_rules! gen_tests_for_vector_3 {
    ($vec_mod_name: ident) => {
        mod $vec_mod_name {
            use crate::example_system::$vec_mod_name::Length as VecLength;
            use mpi::topology::Communicator;

            #[test]
            fn pack_unpack_vec_quantity() {
                let world = super::MPI_UNIVERSE.world();
                let q1 = VecLength::meters(1.0, 2.0, 3.0);
                let mut q2 = VecLength::meters(3.0, 4.0, 5.0);
                let a = world.pack(&q1);
                unsafe {
                    world.unpack_into(&a, &mut q2, 0);
                }
                assert_eq!(q1, q2);
            }
        }
    };
}

#[cfg(feature = "f32")]
gen_tests_for_float!(f32);

#[cfg(feature = "f64")]
gen_tests_for_float!(f64);

#[cfg(all(feature = "f32", feature = "glam-vec2"))]
gen_tests_for_vector_2!(vec2);

#[cfg(all(feature = "f64", feature = "glam-dvec2"))]
gen_tests_for_vector_2!(dvec2);

#[cfg(all(feature = "f32", feature = "glam-vec3"))]
gen_tests_for_vector_3!(vec3);

#[cfg(all(feature = "f64", feature = "glam-dvec3"))]
gen_tests_for_vector_3!(dvec3);