【PhysUnits】15.5 引入P1后的标准化表示(standardization.rs)

一、源码

这段代码实现了一个类型级别的二进制数标准化系统，主要用于处理二进制数的前导零和特殊值的简化。

use super::basic::{Z0, P1, N1, B0, B1, NonNegOne, NonZero};

/// 处理 B0<H> 类型的标准化
/// Standardization for B0<H> types
///
/// 当高位 H 为 Z0 时，将 B0<Z0> 转换为 Z0
/// Converts B0<Z0> to Z0 when higher bit H is Z0
pub trait IfB0 {
    type Output;
}

/// 处理 B1<H> 类型的标准化  
/// Standardization for B1<H> types
///
/// 当高位 H 为 N1 时，将 B1<N1> 转换为 N1
/// Converts B1<N1> to N1 when higher bit H is N1
/// 
/// 当高位 H 为 Z0 时，将 B1<Z0> 转换为 P1
/// Converts B1<Z0> to P1 when higher bit H is Z0

pub trait IfB1 {
    type Output;
}

// ==================== IfB0 实现 ====================
impl<I: NonZero> IfB0 for I {
    type Output = B0<I>;
}

impl IfB0 for Z0 {// B0<Z0> => Z0
    type Output = Z0;
}

// ==================== IfB1 实现 ====================
impl<I: NonZero + NonNegOne> IfB1 for I {
    type Output = B1<I>;
}

impl IfB1 for N1 {// B1<N1> => N1
    type Output = N1;
}

impl IfB1 for Z0 {// B1<Z0> => P1
    type Output = P1;
}

二、代码解释：

1. 引入依赖类型

use super::basic::{Z0, P1, N1, B0, B1, NonNegOne, NonZero};

从父模块中引入了以下类型和trait：

• Z0: 表示零

• P1: 表示正一

• N1: 表示负一

• B0, B1: 表示二进制位（0和1）

• NonNegOne, NonZero: 标记trait，表示非负一和非零类型

2. IfB0 trait

pub trait IfB0 {
    type Output;
}

这个trait用于处理B0类型的标准化：

• 当高位H是Z0时，将B0转换为Z0

• 否则保持B0不变

3. IfB1 trait

pub trait IfB1 {
    type Output;
}

这个trait用于处理B1类型的标准化：

• 当高位H是N1时，将B1转换为N1

• 当高位H是Z0时，将B1转换为P1

• 其他情况保持B1不变

4. IfB0的实现

impl<I: NonZero> IfB0 for I {
    type Output = B0<I>;
}

impl IfB0 for Z0 {
    type Output = Z0;
}

• 第一个实现：对于任何非零类型I，B0保持不变

• 第二个实现：特殊处理B0，将其转换为Z0

5. IfB1的实现

impl<I: NonZero + NonNegOne> IfB1 for I {
    type Output = B1<I>;
}

impl IfB1 for N1 {
    type Output = N1;
}

impl IfB1 for Z0 {
    type Output = P1;
}

• 第一个实现：对于任何非零且非负一的类型I，B1保持不变

• 第二个实现：特殊处理B1，将其转换为N1

• 第三个实现：特殊处理B1，将其转换为P1

三、功能总结：

这段代码实现了一个类型级的二进制数标准化系统，主要处理以下转换：

1. B0 → Z0

2. B1 → N1

3. B1 → P1

其他情况保持原样。这种标准化用于类型级的二进制表示优化，确保数值以最简形式表示。

所有函数都是编译时执行的（通过#[inline]提示和返回常量），这是类型级编程的典型特征，用于在编译时进行计算和类型转换。