【PhysUnits】4.4 零类型(Z0)及其算术运算(zero.rs)

一、源码

该代码定义了一个类型系统中的零类型Z0,并为其实现了基本的算术运算(加法、减法、乘法、除法)。这是一个典型的类型级编程示例,使用Rust的类型系统在编译期进行数学运算。

rust 复制代码
//! 零类型(Z0)及其算术运算实现
//! 
//! 本模块定义了类型系统中的零类型,并为其实现了基本算术运算。
//! 所有运算遵循数学规则,特别是零元素的算术特性。

use core::ops::{Add, Sub, Mul, Div};
use core::marker::PhantomData;
use crate::sealed::Sealed;
use super::{Positive, Neg, Integer, Null};

/// 零类型实现Sealed标记trait
impl Sealed for Z0 {}

/// 类型系统中的零类型表示
///
/// # 示例
/// ```
/// use type_arithmetic::Z0;
/// 
/// let zero = Z0;
/// ```
#[derive(Eq, PartialEq, Clone, Copy, Debug, Default)]
pub struct Z0;

// ========== 加法运算实现 ==========

/// 零加零等于零
impl Add<Z0> for Z0 {
    type Output = Z0;
    
    #[inline]
    fn add(self, _rhs: Z0) -> Self::Output {
        Z0
    }
}

/// 零加正数等于该正数
impl<P: Positive> Add<P> for Z0 {
    type Output = P;
    
    #[inline]
    fn add(self, rhs: P) -> Self::Output {
        rhs
    }
}

/// 正数加零等于该正数
impl<P: Positive> Add<Z0> for P {
    type Output = P;
    
    #[inline]
    fn add(self, _rhs: Z0) -> Self::Output {
        self
    }
}

/// 负数加零等于该负数
impl<P: Positive> Add<Z0> for Neg<P> {
    type Output = Neg<P>;
    
    #[inline]
    fn add(self, _rhs: Z0) -> Self::Output {
        self
    }
}

// ========== 减法运算实现 ==========

/// 零减零等于零
impl Sub for Z0 {
    type Output = Z0;
    
    #[inline]
    fn sub(self, _rhs: Self) -> Self::Output {
        Z0
    }
}

/// 零减正数等于对应负数
impl<P: Positive> Sub<P> for Z0 {
    type Output = Neg<P>;
    
    #[inline]
    fn sub(self, _rhs: P) -> Self::Output {
        Neg::<P>::default()
    }
}

/// 零减负数等于对应正数
impl<P: Positive> Sub<Neg<P>> for Z0 {
    type Output = P;
    
    #[inline]
    fn sub(self, _rhs: Neg<P>) -> Self::Output {
        P::default()
    }
}

/// 正数减零等于该正数
impl<P: Positive> Sub<Z0> for P {
    type Output = P;
    
    #[inline]
    fn sub(self, _rhs: Z0) -> Self::Output {
        self
    }
}

/// 负数减零等于该负数
impl<P: Positive> Sub<Z0> for Neg<P> {
    type Output = Neg<P>;
    
    #[inline]
    fn sub(self, _rhs: Z0) -> Self::Output {
        self
    }
}

// ========== 乘法运算实现 ==========

/// 零乘零等于零
impl Mul for Z0 {
    type Output = Z0;
    
    #[inline]
    fn mul(self, _rhs: Self) -> Self::Output {
        Z0
    }
}

/// 零乘正数等于零
impl<P: Positive> Mul<P> for Z0 {
    type Output = Z0;
    
    #[inline]
    fn mul(self, _rhs: P) -> Self::Output {
        Z0
    }
}

/// 零乘负数等于零
impl<P: Positive> Mul<Neg<P>> for Z0 {
    type Output = Z0;
    
    #[inline]
    fn mul(self, _rhs: Neg<P>) -> Self::Output {
        Z0
    }
}

/// 正数乘零等于零
impl<P: Positive> Mul<Z0> for P {
    type Output = Z0;
    
    #[inline]
    fn mul(self, _rhs: Z0) -> Self::Output {
        Z0
    }
}

/// 负数乘零等于零
impl<P: Positive> Mul<Z0> for Neg<P> {
    type Output = Z0;
    
    #[inline]
    fn mul(self, _rhs: Z0) -> Self::Output {
        Z0
    }
}

// ========== 除法运算实现 ==========

/// 零除以正数等于零
impl<P: Positive> Div<P> for Z0 {
    type Output = Z0;
    
    #[inline]
    fn div(self, _rhs: P) -> Self::Output {
        Z0
    }
}

/// 零除以负数等于零
impl<P: Positive> Div<Neg<P>> for Z0 {
    type Output = Z0;
    
    #[inline]
    fn div(self, _rhs: Neg<P>) -> Self::Output {
        Z0
    }
}

// 注意:正数/零和负数/零未实现,因为数学上除以零未定义

#[cfg(test)]
mod tests {
    use super::*;
    use crate::{P1, N1};
    
    #[test]
    fn test_z0_addition() {
        let zero = Z0;
        let p1 = P1::default();
        let n1 = N1::default();
        
        assert_eq!(zero + p1, p1);
        assert_eq!(zero + n1, n1);
        assert_eq!(p1 + zero, p1);
        assert_eq!(n1 + zero, n1);
    }
    
    #[test]
    fn test_z0_subtraction() {
        let zero = Z0;
        let p1 = P1::default();
        let n1 = N1::default();
        
        assert_eq!(zero - p1, N1::default());
        assert_eq!(zero - n1, P1::default());
        assert_eq!(p1 - zero, p1);
        assert_eq!(n1 - zero, n1);
    }
    
    #[test]
    fn test_z0_multiplication() {
        let zero = Z0;
        let p2 = P1::default();
        let n1 = N1::default();
        
        assert_eq!(zero * p1, zero);
        assert_eq!(zero * n1, zero);
        assert_eq!(p1 * zero, zero);
        assert_eq!(n1 * zero, zero);
    }
    
    #[test]
    fn test_z0_division() {
        let zero = Z0;
        let p1 = P1::default();
        let n1 = N1::default();
        
        assert_eq!(zero / p1, zero);
        assert_eq!(zero / n1, zero);
    }
    
    #[test]
    fn test_z0_interactions() {
        let zero = Z0;
        let p1 = P1::default();
        let n1 = N1::default();
        
        assert_eq!(zero + p1, P1::default());
        assert_eq!((zero - p1) + n1, zero);
        assert_eq!((p1 + zero) * n1, N1::default());
    }
}

二、核心概念

  1. Z0类型:表示类型系统中的零值,是一个单元结构体(pub struct Z0;)

  2. 特性实现:

  • 实现了Sealed标记trait(一种设计模式,防止外部实现)

  • 实现了Add、Sub、Mul、Div等运算trait

三、运算实现细节

加法运算
  • Z0 + Z0 = Z0

  • Z0 + 正数 = 正数

  • 正数 + Z0 = 正数

  • 负数 + Z0 = 负数

减法运算
  • Z0 - Z0 = Z0

  • Z0 - 正数 = 对应负数

  • Z0 - 负数 = 对应正数

  • 正数 - Z0 = 正数

  • 负数 - Z0 = 负数

乘法运算
  • Z0 * 任何数 = Z0(符合数学中零乘以任何数等于零的规则)
除法运算
  • Z0 / 正数 = Z0

  • Z0 / 负数 = Z0

  • 没有实现任何数除以Z0(因为数学上不允许除以零)

四、测试用例

代码包含了详尽的测试用例,验证了:

  1. 零与正数(P1)、负数(N1)的加法

  2. 零与正负数之间的减法

  3. 零与正负数的乘法

  4. 零除以正负数的除法

  5. 各种运算的组合

五、设计特点

  1. 类型安全:所有运算在编译期进行类型检查

  2. 零特性:严格遵循数学中零元素的算术特性

  3. 扩展性:可以与系统中的其他数值类型(正数、负数)交互

  4. 零开销:使用Rust的零成本抽象,运行时没有额外开销

这种类型级编程技术常用于需要编译期计算和验证的场景,如维度检查、单位系统等。

相关推荐
SomeOtherTime16 小时前
第 11 讲(大结局):编译期元编程与零拷贝架构——卫生声明宏(macro_rules!)、过程宏 AST 手术刀与 Serde 零反射序列化的终极合龙
rust
SomeOtherTime21 小时前
番外篇(第 12 讲):走向工业界深水区——从物理定律看 Rust 在真实工程中的“降维打击”与“阿喀琉斯之踵”
开发语言·rust
Kapaseker1 天前
Rust 桌面开发到底怎么选?先看这篇文章!
rust
奶油话梅糖1 天前
容器启停 2.5 毫秒:11 天 1,700 Star 的 Kiri,用一个 900 KB 的 PID 1 干掉了 runc 和 dockerd
前端·人工智能·rust
wflynn1 天前
GitHub 今日推荐|kiri:clone3 系统调用直达容器,2.5 毫秒启动无 runc 中间层
docker·rust·kubernetes·开源·github·containers
SomeOtherTime2 天前
第 4 讲:突破静态枷锁——智能指针(Box/Rc/Arc)与内部可变性(Cell/RefCell/UnsafeCell)的内存暗道
rust
SomeOtherTime2 天前
第 9 讲:异步并发与 Pin 的底层解剖——async/await 无栈协程状态机脱糖、自引用死锁的终极救赎与 Future/Waker 驱动模型
rust
wflynn3 天前
GitHub 今日推荐|Stela:在 PC 上直接启动 macOS 的翻译层
rust·开源·github
aifannihao3 天前
Rust 1.100 的 DropGuard:用 Python 实测失败回滚与吞异常
python·rust·异常处理·标准库·contextlib
鶴哥只手遮天3 天前
《rustc 内幕》第 1 章 全景:rustc 编译流水线与 crate 版图
后端·rust·开源