当前位置：首页 > news >正文

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

news 来源：原创 2025/6/2 16:32:09

一、源码

代码是用Rust编写的类型级编程代码，主要用于处理二进制数的标准化表示。它定义了两个trait（IfB0和IfB1）以及它们的实现，用于处理二进制数中的位（B0和B1）在不同情况下的标准化转换。

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 Z0pub trait IfB1 {type Output;
}// ==================== IfB0 实现 ====================
impl<I: NonZero> IfB0 for I {type Output = B0<I>;
}impl IfB0 for Z0 {// B0<Z0> => Z0type Output = Z0;
}// ==================== IfB1 实现 ====================
impl<I: NonZero + NonNegOne> IfB1 for I {type Output = B1<I>;
}impl IfB1 for N1 {// B1<N1> => N1type Output = N1;
}impl IfB1 for Z0 {// B1<Z0> => P1type Output = P1;
}

二、代码解释：

引入依赖类型

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

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

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

IfB0 trait

pub trait IfB0 {type Output;fn standardization() -> Self::Output;
}

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

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

IfB1 trait

pub trait IfB1 {type Output;fn standardization() -> Self::Output;
}

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

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

IfB0的实现

impl<I: NonZero> IfB0 for I {type Output = B0<I>;fn standardization() -> Self::Output { B0::new() }
}impl IfB0 for Z0 {type Output = Z0;fn standardization() -> Self::Output { Z0::new() }
}

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

IfB1的实现

impl<I: NonZero + NonNegOne> IfB1 for I {type Output = B1<I>;fn standardization() -> Self::Output { B1::new() }
}impl IfB1 for N1 {type Output = N1;fn standardization() -> Self::Output { N1::new() }
}impl IfB1 for Z0 {type Output = P1;fn standardization() -> Self::Output { P1::new() }
}