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

一、源码

该代码定义了一个类型系统中的零类型Z0，并为其实现了基本的算术运算（加法、减法、乘法、除法）。这是一个典型的类型级编程示例，使用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的零成本抽象，运行时没有额外开销

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