【PhysUnits】15.9 引入P1后的右移运算(shr.rs)

一、源码

这段代码是用Rust实现的类型级右移运算（>>），属于类型级编程的范畴。它通过类型体系来体现和操纵二进制数，并在编译期完成计算。

1. use super::basic::{Z0, P1, N1, B0, B1, NonZero, NonOne, Unsigned};
2. use super::sub1::Sub1;
3. use core::ops::Shr;
5. // ==================== Right Shift Operation (>>) ====================
6. // ==================== 右移运算（>>） ====================
8. // Z0 >> U
9. // Zero right shifted by any unsigned number is still zero
10. // 零右移任何无符号数仍然是零
11. impl<R: Unsigned> Shr<R> for Z0 {
12.     type Output = Z0;
13.     fn shr(self, _: R) -> Self::Output {
14.         Z0  // 0 >> n = 0
15.     }
16. }
18. // P1 >> U
19. // Positive one right shifted by zero is itself
20. // 正一右移零位是其本身
21. impl Shr<Z0> for P1 {
22.     type Output = Self;
23.     fn shr(self, _: Z0) -> Self::Output {
24.         self
25.     }
26. }
28. // Positive one right shifted by any non-zero unsigned number becomes zero
29. // 正一右移任何非零无符号数变为零
30. impl<R: Unsigned + NonZero> Shr<R> for P1 {
31.     type Output = Z0;
32.     fn shr(self, _: R) -> Self::Output {
33.         Z0::new()
34.     }
35. }
37. // N1 >> U
38. // Negative one right shifted by any unsigned number remains negative one
39. // (due to sign extension in two's complement)
40. // 负一右移任何无符号数仍然是负一（由于二进制补码中的符号扩展）
41. impl<R: Unsigned> Shr<R> for N1 {
42.     type Output = Self;
43.     fn shr(self, _: R) -> Self::Output {
44.         self
45.     }
46. }
48. // B0 >> U
49. // Binary number ending with 0 right shifted by zero is itself
50. // 以0结尾的二进制数右移零位是其本身
51. impl<H: NonZero> Shr<Z0> for B0<H> {
52.     type Output = Self;
53.     fn shr(self, _: Z0) -> Self::Output {
54.         self
55.     }
56. }
58. // Binary number ending with 0 right shifted by one becomes its head
59. // 以0结尾的二进制数右移一位变为其头部
60. impl<H: NonZero> Shr<P1> for B0<H> {
61.     type Output = H;
62.     fn shr(self, _: P1) -> Self::Output {
63.         H::default()
64.     }
65. }
67. // Binary number ending with 0 right shifted by more than one
68. // Recursively shifts right by one until the shift amount is zero
69. // 以0结尾的二进制数右移多于一位
70. // 递归地右移一位直到移位量为零
71. impl<H: NonZero, R: Unsigned + NonZero + NonOne + Sub1> Shr<R> for B0<H>
72. where
73.     H: Shr<<R as Sub1>::Output>
74. {
75.     type Output = <H as Shr<R::Output>>::Output;
76.     fn shr(self, r: R) -> Self::Output {
77.         (self>>P1)>>r.sub1()
78.     }
79. }
81. // B1 >> U
82. // Binary number ending with 1 right shifted by zero is itself
83. // 以1结尾的二进制数右移零位是其本身
84. impl<H: NonZero> Shr<Z0> for B1<H> {
85.     type Output = Self;
86.     fn shr(self, _: Z0) -> Self::Output {
87.         self
88.     }
89. }
91. // Binary number ending with 1 right shifted by one becomes its head
92. // 以1结尾的二进制数右移一位变为其头部
93. impl<H: NonZero> Shr<P1> for B1<H> {
94.     type Output = H;
95.     fn shr(self, _: P1) -> Self::Output {
96.         H::default()
97.     }
98. }
100. // Binary number ending with 1 right shifted by more than one
101. // Recursively shifts right by one until the shift amount is zero,
102. // and maintains the sign bit (B0 prefix)
103. // 以1结尾的二进制数右移多于一位
104. // 递归地右移一位直到移位量为零，并保持符号位（B0前缀）
105. impl<H: NonZero, R: Unsigned + NonZero + NonOne + Sub1> Shr<R> for B1<H>
106. where
107.     H: Shr<<R as Sub1>::Output>
108. {
109.     type Output = <H as Shr<R::Output>>::Output;
110.     fn shr(self, r: R) -> Self::Output {
111.         (self>>P1)>>(r.sub1())
112.     }
113. }
115. // Test cases
116. #[cfg(test)]
117. mod tests {
118.     use super::*;
119.    
120.     #[test]
121.     fn test_shr() {
122.         // Test Z0
123.         let _: Z0 = Z0 >> Z0;
124.         let _: Z0 = Z0 >> P1;
125.         
126.         // Test P1
127.         let _: P1 = P1 >> Z0;
128.         let _: Z0 = P1 >> P1;
129.         
130.         // Test N1
131.         let _: N1 = N1 >> Z0;
132.         let _: N1 = N1 >> P1;
133.         
134.         // Test B0
135.         let b0: B0<P1> = B0::new();
136.         let _: B0<P1> = b0 >> Z0;
137.         let _: P1 = b0 >> P1;
138.         
139.         // Test B1
140.         let b1: B1<P1> = B1::new();
141.         let _: B1<P1> = b1 >> Z0;
142.         let _: P1 = b1 >> P1;
143.     }
144. }

复制代码

二、根本概念

• 类型定义：
  

• Z0：体现数字0
  
• P1：体现+1
  
• N1：体现-1
  
• B0：体现以0末端的二进制数（如B0体现二进制10，即十进制2）
  
• B1：体现以1末端的二进制数（如B1体现二进制11，即十进制3）
  
• NonZero、NonOne、Unsigned：这些是标记trait，用于束缚类型参数
  

• 焦点trait：
  

• Shr：Rust的右移运算符trait，这里为差别类型实现了该trait
  

三、实现逻辑

• Z0（零）的右移：
  

• 任何数右移0位保持稳定
  
• 0右移任何位数仍然是0
  

• P1（+1）的右移：
  

• 右移0位：保持稳定
  
• 右移非零位：变为0（因为正数的右移会补0）
  

• N1（-1）的右移：
  

• 右移任何位数都保持稳定（因为负数的右移在补码体现中会进行符号扩展）
  

• B0（以0末端的二进制数）的右移：
  

• 右移0位：保持稳定
  
• 右移1位：去掉最后一位0，变成头部H
  
• 右移多位：递归地右移1位直到完成
  

• B1（以1末端的二进制数）的右移：
  

• 雷同B0，但会保持符号位
  

递归实现

对于多位右移操纵，代码使用了递归的方式：

1. impl<H: NonZero, R: Unsigned + NonZero + NonOne + Sub1> Shr<R> for B0<H>
2. where
3.     H: Shr<<R as Sub1>::Output>
4. {
5.     type Output = <H as Shr<R::Output>>::Output;
6.     fn shr(self, r: R) -> Self::Output {
7.         (self>>P1)>>r.sub1()
8.     }
9. }

复制代码

这里的意思是：要计算B0 >> R，先右移1位变成H，然后对剩下的R-1位继续右移。
测试用例

测试了各种情况：

• 零的右移
  
• +1的右移
  
• -1的右移
  
• 以0末端的二进制数的右移
  
• 以1末端的二进制数的右移
  

四、总结

这段代码展示了怎样使用Rust的类型体系在编译期完成右移运算。通过为差别类型实现Shr trait，并使用递归类型计算，实现了类型安全的右移操纵。这种技术常用于嵌入式开辟等需要编译期计算的场景。