一、源码
这段代码实现了一个二进制数字标准化系统，用于将二进制数字类型（B0/B1）转换为更简洁的表示形式。
//! 二进制数字标准化模块 / Binary Number Normalization Module
//!
//! 提供将二进制数字(B0/B1)标准化为更简洁表示形式的功能
//! Provides functionality to normalize binary numbers (B0/B1) into more concise representations
//!
//! 例如 B0<Z0> => Z0, B1<Z0> => P1, B1<N1> => N1
//! e.g. B0<Z0> => Z0, B1<Z0> => P1, B1<N1> => N1
use crate::number::{Z0, P1, N1, B0, B1, NonNegOne, NonZero};
/// 处理 B0<H> 类型的标准化 / Standardization for B0<H> types
///
/// 这个 trait 定义了将 B0<H> 类型数字标准化的行为。
/// This trait defines the behavior for normalizing B0<H> type numbers.
///
/// 当高位 H 为 Z0 时，将 B0<Z0> 转换为 Z0；
/// Converts B0<Z0> to Z0 when higher bit H is Z0;
/// 对于其他非零高位，保持 B0<H> 结构不变。
/// maintains B0<H> structure for other non-zero higher bits.
pub trait IfB0 {
type Output;
fn b0() -> Self::Output;
}
/// 处理 B1<H> 类型的标准化 / Standardization for B1<H> types
///
/// 这个 trait 定义了将 B1<H> 类型数字标准化的行为。
/// This trait defines the behavior for normalizing B1<H> type numbers.
///
/// 当高位 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;
/// 对于其他非零非负一高位，保持 B1<H> 结构不变。
/// maintains B1<H> structure for other non-zero non-negative-one higher bits.
pub trait IfB1 {
type Output;
fn b1() -> Self::Output;
}
// ==================== IfB0 实现 / IfB0 Implementations ====================
/// 为所有非零类型实现 IfB0 / IfB0 implementation for all non-zero types
///
/// 保持 B0<H> 结构不变，其中 H 是非零类型
/// Maintains B0<H> structure where H is non-zero type
impl<I: NonZero> IfB0 for I {
type Output = B0<I>;
#[inline(always)]
fn b0() -> Self::Output {
B0::new()
}
}
/// 为零类型 Z0 实现 IfB0 / IfB0 implementation for zero type Z0
///
/// 将 B0<Z0> 转换为 Z0
/// Converts B0<Z0> to Z0
impl IfB0 for Z0 {// B0<Z0> => Z0
type Output = Z0;
#[inline(always)]
fn b0() -> Self::Output {
Z0::new()
}
}
// ==================== IfB1 实现 / IfB1 Implementations ====================
/// 为非零非负一类型实现 IfB1 / IfB1 implementation for non-zero non-negative-one types
///
/// 保持 B1<H> 结构不变，其中 H 是非零非负一类型
/// Maintains B1<H> structure where H is non-zero non-negative-one type
impl<I: NonZero + NonNegOne> IfB1 for I {
type Output = B1<I>;
#[inline(always)]
fn b1() -> Self::Output {
B1::new()
}
}
/// 为负一类型 N1 实现 IfB1 / IfB1 implementation for negative-one type N1
///
/// 将 B1<N1> 转换为 N1
/// Converts B1<N1> to N1
impl IfB1 for N1 {// B1<N1> => N1
type Output = N1;
#[inline(always)]
fn b1() -> Self::Output {
N1::new()
}
}
/// 为零类型 Z0 实现 IfB1 / IfB1 implementation for zero type Z0
///
/// 将 B1<Z0> 转换为 P1
/// Converts B1<Z0> to P1
impl IfB1 for Z0 {// B1<Z0> => P1
type Output = P1;
#[inline(always)]
fn b1() -> Self::Output {
P1::new()
}
}
二、模块功能
提供将二进制数字（B0/B1）标准化为更简洁表示形式的功能
例如：
B0 => Z0（二进制0后跟零 → 零）
B1 => P1（二进制1后跟零 → 正一）
B1 => N1（二进制1后跟负一 → 负一）
三、核心Trait定义
- IfB0 Trait
处理B0类型的标准化
规则：
当高位H为Z0时：B0 → Z0
其他非零高位：保持B0结构不变
方法：
type Output;
fn b0() -> Self::Output;
- IfB1 Trait
处理B1类型的标准化
规则：
当高位H为N1时：B1 → N1
当高位H为Z0时：B1 → P1
其他非零非负一高位：保持B1结构不变
方法：
type Output;
fn b1() -> Self::Output;
四、具体实现
IfB0实现
- 对于所有非零类型：
保持B0结构不变
实现：
impl<I: NonZero> IfB0 for I {
type Output = B0<I>;
fn b0() -> Self::Output { B0::new() }
}
- 对于零类型Z0：
将B0转换为Z0
实现：
impl IfB0 for Z0 {
type Output = Z0;
fn b0() -> Self::Output { Z0::new() }
}
IfB1实现
- 对于非零非负一类型：
保持B1结构不变
实现：
impl<I: NonZero + NonNegOne> IfB1 for I {
type Output = B1<I>;
fn b1() -> Self::Output { B1::new() }
}
- 对于负一类型N1：
将B1转换为N1
实现：
impl IfB1 for N1 {
type Output = N1;
fn b1() -> Self::Output { N1::new() }
}
- 对于零类型Z0：
将B1转换为P1
实现：
impl IfB1 for Z0 {
type Output = P1;
fn b1() -> Self::Output { P1::new() }
}
五、技术细节
- 类型约束：
使用NonZero和NonNegOne trait bound来限制实现类型
确保只有符合条件的类型才能实现相应的trait
- 性能优化：
所有方法都标记为#[inline(always)]，确保内联优化
使用new()方法创建实例，以便编译时计算
- 类型转换：
通过关联类型Output指定转换结果类型
转换过程完全在类型系统层面进行，不涉及运行时开销
六、设计目的
这个系统的主要目的是：
简化二进制数字的类型表示
消除冗余的类型结构（如B0其实就是Z0）
为类型系统提供更简洁的表示形式
支持编译时的数值计算和转换
这种设计常用于需要类型级数值计算的场景，如：
物理单位系统
矩阵维度计算
编译时资源分配
类型安全的API设计