affn 0.6.2

Affine geometry primitives: strongly-typed coordinate systems, reference frames, and centers for scientific computing.
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
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

//! Internal macros that forward a by-value operator impl to the three
//! reference variants (`&T op U`, `T op &U`, `&T op &U`).
//!
//! # Cost model
//!
//! These macros implement the reference variants by dereferencing
//! (`*self` / `*rhs`) and delegating to the by-value impl. They therefore
//! require both operand types to be `Copy`. For most affine geometry types
//! in this crate the underlying storage is a small fixed-size array of
//! `f64`/`Quantity<U>`, so the bitwise copy is trivial and the compiler can
//! inline it away.
//!
//! For types whose `Copy`-ness depends on a generic parameter (e.g.
//! `Position<C, F, U>` is `Copy` only when `C::Params: Copy`), callers add
//! the appropriate `where` clause to the macro invocation; the generated
//! impls are then bounded the same way and never apply when the by-value
//! impl is moved-only.
//!
//! Three atomic helpers (`_lhs`, `_rhs`, `_both`) exist so call sites can
//! opt out of generating a particular variant when a hand-written one
//! already exists — emitting it would conflict with the existing impl.

macro_rules! forward_ref_binop_lhs {
    (impl[$($gp:tt)*] $imp:ident, $method:ident for $t:ty, $u:ty
     $(where ($($wp:tt)*))?) => {
        impl<$($gp)*> core::ops::$imp<$u> for &$t
        $(where $($wp)*)?
        {
            type Output = <$t as core::ops::$imp<$u>>::Output;
            #[inline]
            fn $method(self, rhs: $u) -> <Self as core::ops::$imp<$u>>::Output {
                (*self).$method(rhs)
            }
        }
    };
    (impl $imp:ident, $method:ident for $t:ty, $u:ty
     $(where ($($wp:tt)*))?) => {
        impl core::ops::$imp<$u> for &$t
        $(where $($wp)*)?
        {
            type Output = <$t as core::ops::$imp<$u>>::Output;
            #[inline]
            fn $method(self, rhs: $u) -> <Self as core::ops::$imp<$u>>::Output {
                (*self).$method(rhs)
            }
        }
    };
}

macro_rules! forward_ref_binop_rhs {
    (impl[$($gp:tt)*] $imp:ident, $method:ident for $t:ty, $u:ty
     $(where ($($wp:tt)*))?) => {
        impl<$($gp)*> core::ops::$imp<&$u> for $t
        $(where $($wp)*)?
        {
            type Output = <$t as core::ops::$imp<$u>>::Output;
            #[inline]
            fn $method(self, rhs: &$u) -> <Self as core::ops::$imp<&$u>>::Output {
                self.$method(*rhs)
            }
        }
    };
    (impl $imp:ident, $method:ident for $t:ty, $u:ty
     $(where ($($wp:tt)*))?) => {
        impl core::ops::$imp<&$u> for $t
        $(where $($wp)*)?
        {
            type Output = <$t as core::ops::$imp<$u>>::Output;
            #[inline]
            fn $method(self, rhs: &$u) -> <Self as core::ops::$imp<&$u>>::Output {
                self.$method(*rhs)
            }
        }
    };
}

macro_rules! forward_ref_binop_both {
    (impl[$($gp:tt)*] $imp:ident, $method:ident for $t:ty, $u:ty
     $(where ($($wp:tt)*))?) => {
        impl<$($gp)*> core::ops::$imp<&$u> for &$t
        $(where $($wp)*)?
        {
            type Output = <$t as core::ops::$imp<$u>>::Output;
            #[inline]
            fn $method(self, rhs: &$u) -> <Self as core::ops::$imp<&$u>>::Output {
                (*self).$method(*rhs)
            }
        }
    };
    (impl $imp:ident, $method:ident for $t:ty, $u:ty
     $(where ($($wp:tt)*))?) => {
        impl core::ops::$imp<&$u> for &$t
        $(where $($wp)*)?
        {
            type Output = <$t as core::ops::$imp<$u>>::Output;
            #[inline]
            fn $method(self, rhs: &$u) -> <Self as core::ops::$imp<&$u>>::Output {
                (*self).$method(*rhs)
            }
        }
    };
}

/// Generates all three reference variants (`&T op U`, `T op &U`, `&T op &U`)
/// from a by-value impl `T op U`. See module docs for the cost/`Copy` model.
///
/// Generic parameters (when present) are written in brackets: `impl[F, U]` —
/// this avoids local ambiguity from `tt`-greedy matching of `<...>`.
macro_rules! forward_ref_binop {
    (impl[$($gp:tt)*] $imp:ident, $method:ident for $t:ty, $u:ty
     $(where ($($wp:tt)*))?) => {
        forward_ref_binop_lhs!  { impl[$($gp)*] $imp, $method for $t, $u $(where ($($wp)*))? }
        forward_ref_binop_rhs!  { impl[$($gp)*] $imp, $method for $t, $u $(where ($($wp)*))? }
        forward_ref_binop_both! { impl[$($gp)*] $imp, $method for $t, $u $(where ($($wp)*))? }
    };
    (impl $imp:ident, $method:ident for $t:ty, $u:ty
     $(where ($($wp:tt)*))?) => {
        forward_ref_binop_lhs!  { impl $imp, $method for $t, $u $(where ($($wp)*))? }
        forward_ref_binop_rhs!  { impl $imp, $method for $t, $u $(where ($($wp)*))? }
        forward_ref_binop_both! { impl $imp, $method for $t, $u $(where ($($wp)*))? }
    };
}

/// Generates the reference variant (`&T -> Out`) for a unary operator impl.
macro_rules! forward_ref_unop {
    (impl[$($gp:tt)*] $imp:ident, $method:ident for $t:ty
     $(where ($($wp:tt)*))?) => {
        impl<$($gp)*> core::ops::$imp for &$t
        $(where $($wp)*)?
        {
            type Output = <$t as core::ops::$imp>::Output;
            #[inline]
            fn $method(self) -> <Self as core::ops::$imp>::Output {
                (*self).$method()
            }
        }
    };
    (impl $imp:ident, $method:ident for $t:ty
     $(where ($($wp:tt)*))?) => {
        impl core::ops::$imp for &$t
        $(where $($wp)*)?
        {
            type Output = <$t as core::ops::$imp>::Output;
            #[inline]
            fn $method(self) -> <Self as core::ops::$imp>::Output {
                (*self).$method()
            }
        }
    };
}