【unitrix】 1.7 规范化常量类型结构(standardization.rs)
一、源码
这段代码实现了一个二进制数字标准化系统，用于将二进制数字类型（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> => N1use 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> => Z0type 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> => N1type 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> => P1type 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设计