【PhysUnits】4.4 零类型(Z0)及其算术运算(zero.rs)

一、源码

该代码定义了一个类型体系中的零类型Z0，并为实在现了基本的算术运算（加法、减法、乘法、除法）。这是一个典范的类型级编程示例，使用Rust的类型体系在编译期进行数学运算。

1. //! 零类型(Z0)及其算术运算实现
2. //!
3. //! 本模块定义了类型系统中的零类型，并为其实现了基本算术运算。
4. //! 所有运算遵循数学规则，特别是零元素的算术特性。
6. use core::ops::{Add, Sub, Mul, Div};
7. use core::marker::PhantomData;
8. use crate::sealed::Sealed;
9. use super::{Positive, Neg, Integer, Null};
11. /// 零类型实现Sealed标记trait
12. impl Sealed for Z0 {}
14. /// 类型系统中的零类型表示
15. ///
16. /// # 示例
17. /// ```
18. /// use type_arithmetic::Z0;
19. ///
20. /// let zero = Z0;
21. /// ```
22. #[derive(Eq, PartialEq, Clone, Copy, Debug, Default)]
23. pub struct Z0;
25. // ========== 加法运算实现 ==========
27. /// 零加零等于零
28. impl Add<Z0> for Z0 {
29.     type Output = Z0;
30.    
31.     #[inline]
32.     fn add(self, _rhs: Z0) -> Self::Output {
33.         Z0
34.     }
35. }
37. /// 零加正数等于该正数
38. impl<P: Positive> Add<P> for Z0 {
39.     type Output = P;
40.    
41.     #[inline]
42.     fn add(self, rhs: P) -> Self::Output {
43.         rhs
44.     }
45. }
47. /// 正数加零等于该正数
48. impl<P: Positive> Add<Z0> for P {
49.     type Output = P;
50.    
51.     #[inline]
52.     fn add(self, _rhs: Z0) -> Self::Output {
53.         self
54.     }
55. }
57. /// 负数加零等于该负数
58. impl<P: Positive> Add<Z0> for Neg<P> {
59.     type Output = Neg<P>;
60.    
61.     #[inline]
62.     fn add(self, _rhs: Z0) -> Self::Output {
63.         self
64.     }
65. }
67. // ========== 减法运算实现 ==========
69. /// 零减零等于零
70. impl Sub for Z0 {
71.     type Output = Z0;
72.    
73.     #[inline]
74.     fn sub(self, _rhs: Self) -> Self::Output {
75.         Z0
76.     }
77. }
79. /// 零减正数等于对应负数
80. impl<P: Positive> Sub<P> for Z0 {
81.     type Output = Neg<P>;
82.    
83.     #[inline]
84.     fn sub(self, _rhs: P) -> Self::Output {
85.         Neg::<P>::default()
86.     }
87. }
89. /// 零减负数等于对应正数
90. impl<P: Positive> Sub<Neg<P>> for Z0 {
91.     type Output = P;
92.    
93.     #[inline]
94.     fn sub(self, _rhs: Neg<P>) -> Self::Output {
95.         P::default()
96.     }
97. }
99. /// 正数减零等于该正数
100. impl<P: Positive> Sub<Z0> for P {
101.     type Output = P;
102.    
103.     #[inline]
104.     fn sub(self, _rhs: Z0) -> Self::Output {
105.         self
106.     }
107. }
109. /// 负数减零等于该负数
110. impl<P: Positive> Sub<Z0> for Neg<P> {
111.     type Output = Neg<P>;
112.    
113.     #[inline]
114.     fn sub(self, _rhs: Z0) -> Self::Output {
115.         self
116.     }
117. }
119. // ========== 乘法运算实现 ==========
121. /// 零乘零等于零
122. impl Mul for Z0 {
123.     type Output = Z0;
124.    
125.     #[inline]
126.     fn mul(self, _rhs: Self) -> Self::Output {
127.         Z0
128.     }
129. }
131. /// 零乘正数等于零
132. impl<P: Positive> Mul<P> for Z0 {
133.     type Output = Z0;
134.    
135.     #[inline]
136.     fn mul(self, _rhs: P) -> Self::Output {
137.         Z0
138.     }
139. }
141. /// 零乘负数等于零
142. impl<P: Positive> Mul<Neg<P>> for Z0 {
143.     type Output = Z0;
144.    
145.     #[inline]
146.     fn mul(self, _rhs: Neg<P>) -> Self::Output {
147.         Z0
148.     }
149. }
151. /// 正数乘零等于零
152. impl<P: Positive> Mul<Z0> for P {
153.     type Output = Z0;
154.    
155.     #[inline]
156.     fn mul(self, _rhs: Z0) -> Self::Output {
157.         Z0
158.     }
159. }
161. /// 负数乘零等于零
162. impl<P: Positive> Mul<Z0> for Neg<P> {
163.     type Output = Z0;
164.    
165.     #[inline]
166.     fn mul(self, _rhs: Z0) -> Self::Output {
167.         Z0
168.     }
169. }
171. // ========== 除法运算实现 ==========
173. /// 零除以正数等于零
174. impl<P: Positive> Div<P> for Z0 {
175.     type Output = Z0;
176.    
177.     #[inline]
178.     fn div(self, _rhs: P) -> Self::Output {
179.         Z0
180.     }
181. }
183. /// 零除以负数等于零
184. impl<P: Positive> Div<Neg<P>> for Z0 {
185.     type Output = Z0;
186.    
187.     #[inline]
188.     fn div(self, _rhs: Neg<P>) -> Self::Output {
189.         Z0
190.     }
191. }
193. // 注意：正数/零和负数/零未实现，因为数学上除以零未定义
195. #[cfg(test)]
196. mod tests {
197.     use super::*;
198.     use crate::{P1, N1};
199.    
200.     #[test]
201.     fn test_z0_addition() {
202.         let zero = Z0;
203.         let p1 = P1::default();
204.         let n1 = N1::default();
205.         
206.         assert_eq!(zero + p1, p1);
207.         assert_eq!(zero + n1, n1);
208.         assert_eq!(p1 + zero, p1);
209.         assert_eq!(n1 + zero, n1);
210.     }
211.    
212.     #[test]
213.     fn test_z0_subtraction() {
214.         let zero = Z0;
215.         let p1 = P1::default();
216.         let n1 = N1::default();
217.         
218.         assert_eq!(zero - p1, N1::default());
219.         assert_eq!(zero - n1, P1::default());
220.         assert_eq!(p1 - zero, p1);
221.         assert_eq!(n1 - zero, n1);
222.     }
223.    
224.     #[test]
225.     fn test_z0_multiplication() {
226.         let zero = Z0;
227.         let p2 = P1::default();
228.         let n1 = N1::default();
229.         
230.         assert_eq!(zero * p1, zero);
231.         assert_eq!(zero * n1, zero);
232.         assert_eq!(p1 * zero, zero);
233.         assert_eq!(n1 * zero, zero);
234.     }
235.    
236.     #[test]
237.     fn test_z0_division() {
238.         let zero = Z0;
239.         let p1 = P1::default();
240.         let n1 = N1::default();
241.         
242.         assert_eq!(zero / p1, zero);
243.         assert_eq!(zero / n1, zero);
244.     }
245.    
246.     #[test]
247.     fn test_z0_interactions() {
248.         let zero = Z0;
249.         let p1 = P1::default();
250.         let n1 = N1::default();
251.         
252.         assert_eq!(zero + p1, P1::default());
253.         assert_eq!((zero - p1) + n1, zero);
254.         assert_eq!((p1 + zero) * n1, N1::default());
255.     }
256. }

复制代码

二、核心概念

• Z0类型：表示类型体系中的零值，是一个单位结构体(pub struct Z0;)
  
• 特性实现：
  

• 实现了Sealed标记trait（一种设计模式，防止外部实现）
  
• 实现了Add、Sub、Mul、Div等运算trait
  

三、运算实现细节

加法运算

• Z0 + Z0 = Z0
  
• Z0 + 正数 = 正数
  
• 正数 + Z0 = 正数
  
• 负数 + Z0 = 负数
  

减法运算

• Z0 - Z0 = Z0
  
• Z0 - 正数 = 对应负数
  
• Z0 - 负数 = 对应正数
  
• 正数 - Z0 = 正数
  
• 负数 - Z0 = 负数
  

乘法运算

• Z0 * 任何数 = Z0（符合数学中零乘以任何数等于零的规则）
  

除法运算

• Z0 / 正数 = Z0
  
• Z0 / 负数 = Z0
  
• 没有实现任何数除以Z0（由于数学上不允许除以零）
  

四、测试用例

代码包含了详尽的测试用例，验证了：

• 零与正数(P1)、负数(N1)的加法
  
• 零与正负数之间的减法
  
• 零与正负数的乘法
  
• 零除以正负数的除法
  
• 各种运算的组合
  

五、设计特点

• 类型安全：全部运算在编译期进行类型检查
  
• 零特性：严格遵循数学中零元素的算术特性
  
• 扩展性：可以与体系中的其他数值类型（正数、负数）交互
  
• 零开销：使用Rust的零成本抽象，运行时没有额外开销
  

这种类型级编程技能常用于需要编译期盘算和验证的场景，如维度检查、单位体系等。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。