【unitrix】 6.11 二进制数字标准化模块(normalize.rs)

发布于：2025-07-22 ⋅ 阅读:(15) ⋅ 点赞:(0)

一、源码

这个模块实现了类型级别的二进制数标准化处理，确保二进制数在组合时保持最简形式。

//! 二进制数字标准化模块
//!
//! 提供二进制数字(B<H, L>)的组合前标准化功能，确保数字以最简形式表示，
//! 避免同一数值有不同表示形式。
//!
//! 示例：
//! - 当 H = B<Null, O> 且 L = O 时 => 标准化为 B<Null, O>
//! - 当 H = B<Null, I> 且 L = I 时 => 标准化为 B<Null, I>
//! - 当 H = O 且 L = Null 时 => 标准化为 Null
//! 
use crate::number::{Null, O, I, B, Bit};

/// 标准化条件判断 trait
/// 根据给定的最低位(L)对数字进行标准化处理
pub trait NormalizeIf<L> {
    type Output;
    fn normalize(self, l:L) -> Self::Output;
}

// 基础情况：当高位为 Null 时，直接构造 B<Null, X>
impl<X: Bit> NormalizeIf<X> for Null {
    type Output = B<Null, X>;
    fn normalize(self, _: X) -> Self::Output {
        B::new()
    }
}

// 规则1: 当 H = B<Null, O> 且 L = O 时，简化成高位
impl NormalizeIf<O> for B<Null, O> {
    type Output = Self;
    fn normalize(self, _: O) -> Self::Output {
        self
    }
}

// 规则1补充: 当 H = B<Null, I> 且 L = O 时，构造 B<B<Null, I>, O>
impl NormalizeIf<O> for B<Null, I> {
    type Output = B<Self, O>;
    fn normalize(self, _bit: O) -> Self::Output {
        B::new()
    }
}

// 规则2: 当 H = B<Null, I> 且 L = I 时，简化成高位
impl NormalizeIf<I> for B<Null, I> {
    type Output = Self;
    fn normalize(self, _: I) -> Self::Output {
        self
    }
}

// 规则2补充: 当 H = B<Null, O> 且 L = I 时，构造 B<B<Null, O>, I>
impl NormalizeIf<I> for B<Null, O> {
    type Output = B<Self, I>;
    fn normalize(self, _: I) -> Self::Output {
        B::new()
    }
}

// 通用情况: 对于更复杂的嵌套结构(B<B<B<HH, HL>, L>, LL>)，保持原结构
// 假设更高位已经是简化过的，或者需要手动调用该 trait 进行简化
impl<HH, HL: Bit, L: Bit, LL: Bit> NormalizeIf<LL> for B<B<HH, HL>, L> {
    type Output = B<Self, LL>;
    fn normalize(self, bit: LL) -> Self::Output {
        B::new()
    }
}

// 纯小数规则: 当 L = Null 且 H = O 时，简化成低位
impl NormalizeIf<Null> for O {
    type Output = Self;
    fn normalize(self, bit: Null) -> Self::Output {
        bit
    }
}

// 纯小数规则补充1: 当 L = Null 且 H = I 时，构造 B<I, Null>
impl NormalizeIf<Null> for I {
    type Output = B<I, Null>;
    fn normalize(self, _bit: Null) -> Self::Output {
        B::new()
    }
}

// 纯小数规则补充2: 当 L = B结构体B<LH， LL> 且 H 为Bit 时，构造 B<H, B<LH, LL>>
// 假设更低位已经是简化过的，或者需要手动调用该 trait 进行简化
impl<H: Bit, LH: Bit, LL> NormalizeIf<B<LH, LL>> for H {
    type Output = B<H, B<LH, LL>>;
    fn normalize(self, _bit: B<LH, LL>) -> Self::Output {
        B::new()
    }
}

pub type IfB0<H> = <H as NormalizeIf<O>>::Output;
pub type IfB1<H> = <H as NormalizeIf<I>>::Output;
pub type IfNull<H> = <H as NormalizeIf<Null>>::Output; //该规则仅用于小数部分

二、模块基础结构

  1. 类型定义

模块使用了以下基础类型（来自crate::number）：

  • Null - 表示空位/终止位

  • O - 表示二进制0

  • I - 表示二进制1

  • B<H, L> - 二进制数构造器，H是高位，L是最低位

  • Bit - trait，被O和I实现

  1. 核心Trait

pub trait NormalizeIf<L> {
    type Output;
    fn normalize(self, l: L) -> Self::Output;
}

这是一个泛型trait，用于定义标准化行为：

  • L - 输入的最低位类型

  • Output - 标准化后的输出类型

  • normalize - 执行标准化的方法

三、标准化规则实现

  1. 基础情况 - 处理Null高位

impl<X: Bit> NormalizeIf<X> for Null {
    type Output = B<Null, X>;
    fn normalize(self, _: X) -> Self::Output {
        B::new()
    }
}

  • 当高位是Null时，直接构造B<Null, X>

  • 例如：Null + O → B<Null, O> (表示0)

  • B::new()是构造新二进制数的函数

  1. 规则1 - 处理O(0)结尾的情况
    简化情况：

impl NormalizeIf<O> for B<Null, O> {
    type Output = Self;
    fn normalize(self, _: O) -> Self::Output {
        self
    }
}

  • 当H = B<Null, O>且L = O时，保持原样

  • 避免B<B<Null,O>,O>这样的冗余结构，直接返回B<Null,O>

非简化情况：


impl NormalizeIf<O> for B<Null, I> {
    type Output = B<Self, O>;
    fn normalize(self, _bit: O) -> Self::Output {
        B::new()
    }
}

  • 当H = B<Null, I>且L = O时，构造B<B<Null,I>,O>

  • 表示二进制"10"（十进制2）

  1. 规则2 - 处理I(1)结尾的情况
    简化情况：

impl NormalizeIf<I> for B<Null, I> {
    type Output = Self;
    fn normalize(self, _: I) -> Self::Output {
        self
    }
}

  • 当H = B<Null, I>且L = I时，保持原样

  • 避免B<B<Null,I>,I>这样的冗余结构，直接返回B<Null,I>

非简化情况：


impl NormalizeIf<I> for B<Null, O> {
    type Output = B<Self, I>;
    fn normalize(self, _: I) -> Self::Output {
        B::new()
    }
}

  • 当H = B<Null, O>且L = I时，构造B<B<Null,O>,I>

  • 表示二进制"01"（十进制1）

  1. 通用情况 - 处理嵌套结构

impl<HH, HL: Bit, L: Bit, LL: Bit> NormalizeIf<LL> for B<B<HH, HL>, L> {
    type Output = B<Self, LL>;
    fn normalize(self, bit: LL) -> Self::Output {
        B::new()
    }
}

  • 对于更复杂的嵌套结构（如B<B<B<H,L1>,L2>），保持原结构

  • 假设更高位已经是简化过的，或者需要手动调用该trait进行简化

  • 例如：B<B<Null,O>,I> + O → B<B<B<Null,O>,I>,O>（表示"010"）

  1. 纯小数规则
    简化情况：

impl NormalizeIf<Null> for O {
    type Output = Self;
    fn normalize(self, bit: Null) -> Self::Output {
        bit
    }
}

  • 处理小数部分，当H = O且L = Null时，返回Null

  • 用于表示纯小数如"0.xxx"

非简化情况：


impl NormalizeIf<Null> for I {
    type Output = B<I, Null>;
    fn normalize(self, _bit: Null) -> Self::Output {
        B::new()
    }
}

  • 当H = I且L = Null时，构造B<I, Null>

  • 用于表示纯小数如"1.xxx"


impl<H: Bit, LH: Bit, LL> NormalizeIf<B<LH, LL>> for H {
    type Output = B<H, B<LH, LL>>;
    fn normalize(self, _bit: B<LH, LL>) -> Self::Output {
        B::new()
    }
}

  • 当L是B结构体且H为Bit时，构造B<H, B<LH, LL>>

  • 用于处理更复杂的小数部分结构

  1. 类型别名

pub type IfB0<H> = <H as NormalizeIf<O>>::Output;
pub type IfB1<H> = <H as NormalizeIf<I>>::Output;
pub type IfNull<H> = <H as NormalizeIf<Null>>::Output;

这些类型别名提供了：

  • IfB0 - 当最低位是O时的标准化结果

  • IfB1 - 当最低位是I时的标准化结果

  • IfNull - 专门用于小数部分的标准化

五、设计模式分析

这个模块体现了多种设计模式：

  • 策略模式：通过不同的trait实现提供不同的标准化策略

  • 递归结构：使用泛型和关联类型处理嵌套的二进制结构

  • 类型级编程：在编译期完成所有标准化操作

  • 零成本抽象：运行时没有任何额外开销

六、使用示例

有以下二进制数：

  • B<Null, O> → 0

  • B<Null, I> → 1

  • B<B<Null, O>, I> → 01 (1)

  • B<B<Null, I>, O> → 10 (2)

标准化过程会确保：

  1. B<Null, O> + O → B<Null, O> (而不是B<B<Null,O>,O>)

  2. B<Null, I> + I → B<Null, I> (而不是B<B<Null,I>,I>)

  3. 更复杂的结构保持原样，除非有明确的简化规则

七、总结

这个二进制标准化模块：

  1. 通过类型系统保证二进制数的规范表示

  2. 消除冗余的前导零和重复结构

  3. 支持整数和小数部分的标准化

  4. 在编译期完成所有处理，运行时无开销

  5. 为类型安全的二进制运算提供基础

这种设计在需要精确控制二进制表示的场合（如物理单位、协议实现等）特别有用，可以避免许多潜在的边界情况错误。

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布