【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的零成本抽象,运行时没有额外开销

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

相关推荐
a cool fish(无名)4 小时前
rust-方法语法
开发语言·后端·rust
a cool fish(无名)19 小时前
rust-参考与借用
java·前端·rust
叶 落1 天前
[Rust 基础课程]猜数字游戏-获取用户输入并打印
rust·rust基础
RustFS1 天前
RustFS 如何修改默认密码?
rust
景天科技苑1 天前
【Rust线程池】如何构建Rust线程池、Rayon线程池用法详细解析
开发语言·后端·rust·线程池·rayon·rust线程池·rayon线程池
该用户已不存在2 天前
Zig想要取代Go和Rust,它有资格吗
前端·后端·rust
用户1774125612442 天前
不懂装懂的AI,折了程序员的阳寿
rust
量子位3 天前
vivo自研蓝河操作系统内核开源!Rust开发新机遇来了
rust·ai编程
祈澈菇凉3 天前
rust嵌入式开发零基础入门教程(六)
stm32·单片机·rust
祈澈菇凉3 天前
rust嵌入式开发零基础入门教程(二)
开发语言·后端·rust