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

一、源码

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

rust 复制代码

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;
}

二、代码解释：

引入依赖类型

rust 复制代码

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

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

Z0: 表示零
P1: 表示正一
N1: 表示负一
B0, B1: 表示二进制位（0和1）
NonNegOne, NonZero: 标记trait，表示非负一和非零类型

IfB0 trait

rust 复制代码

pub trait IfB0 {
    type Output;
}

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

当高位H是Z0时，将B0转换为Z0
否则保持B0不变

IfB1 trait

rust 复制代码

pub trait IfB1 {
    type Output;
}

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

当高位H是N1时，将B1转换为N1
当高位H是Z0时，将B1转换为P1
其他情况保持B1不变

IfB0的实现

rust 复制代码

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

impl IfB0 for Z0 {
    type Output = Z0;
}

第一个实现：对于任何非零类型I，B0保持不变
第二个实现：特殊处理B0，将其转换为Z0

IfB1的实现

rust 复制代码

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

三、功能总结：

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

B0 → Z0
B1 → N1
B1 → P1

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

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