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

news2025/5/25 3:47:24

一、源码

该代码定义了一个类型系统中的零类型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());
    }
}