【PhysUnits】4.4 零类型(Z0)及其算术运算(zero.rs) - qidao123.com技术社区-IT企服评测·应用市场

//! 零类型(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 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 {
type Output = Neg;
#[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 for Z0 {
type Output = Neg;
#[inline]
fn sub(self, _rhs: P) -> Self::Output {
Neg::::default()
}
}
/// 零减负数等于对应正数
impl<P: Positive> Sub<Neg> for Z0 {
type Output = P;
#[inline]
fn sub(self, _rhs: Neg) -> 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 {
type Output = Neg;
#[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 for Z0 {
type Output = Z0;
#[inline]
fn mul(self, _rhs: P) -> Self::Output {
Z0
}
}
/// 零乘负数等于零
impl<P: Positive> Mul<Neg> for Z0 {
type Output = Z0;
#[inline]
fn mul(self, _rhs: Neg) -> 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 {
type Output = Z0;
#[inline]
fn mul(self, _rhs: Z0) -> Self::Output {
Z0
}
}
// ========== 除法运算实现 ==========
/// 零除以正数等于零
impl<P: Positive> Div for Z0 {
type Output = Z0;
#[inline]
fn div(self, _rhs: P) -> Self::Output {
Z0
}
}
/// 零除以负数等于零
impl<P: Positive> Div<Neg> for Z0 {
type Output = Z0;
#[inline]
fn div(self, _rhs: Neg) -> 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());
}
}

复制代码