当前位置：首页 > news >正文

【学Rust写CAD】16 0、1、-1代数单位元（algebraic_units.rs）

news 来源：原创 2025/5/8 7:33:33

前文曾经叙述的常量类（Const）包含了本程序的功能，但它目前必须在夜版rust下编译。考虑2D CAD使用需要相对简单，过渡期采用本程序。待rust稳定版可以实现常量类或有3D需求时改用常量类。

源码

//algebraic_units.rs 代数单位元
use std::ops::{Add, Mul, Neg};

/// 零元素 (加法单位元)
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct Zero;

/// 单位元 (乘法单位元)
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct One;

/// 负单位元 (乘法逆元)
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct DecOne;

// ========== Zero 的实现 ==========

// Zero + T = T
impl<T> Add<T> for Zero {
    type Output = T;
    fn add(self, rhs: T) -> T {
        rhs
    }
}

// Zero * Zero = Zero
impl Mul for Zero {
    type Output = Zero;
    fn mul(self, _: Self) -> Self {
        Zero
    }
}

// Zero * T = Zero
impl<T> Mul<T> for Zero {
    type Output = Zero;
    fn mul(self, _: T) -> Self {
        Zero
    }
}

// T * Zero = Zero
impl<T> Mul<Zero> for T {
    type Output = Zero;
    fn mul(self, _: Zero) -> Zero {
        Zero
    }
}

// ========== One 的实现 ==========

// One * One = One
impl Mul for One {
    type Output = One;
    fn mul(self, _: Self) -> Self {
        One
    }
}

// One * T = T
impl<T> Mul<T> for One {
    type Output = T;
    fn mul(self, rhs: T) -> T {
        rhs
    }
}

// T * One = T
impl<T> Mul<One> for T {
    type Output = T;
    fn mul(self, _: One) -> T {
        self
    }
}

// One + T = T + 1 (需要 T 支持 Add<i32>)
impl<T: Add<i32, Output = T>> Add<T> for One {
    type Output = T;
    fn add(self, rhs: T) -> T {
        rhs + 1
    }
}

// ========== DecOne 的实现 ==========

// DecOne * DecOne = One
impl Mul for DecOne {
    type Output = One;
    fn mul(self, _: Self) -> One {
        One
    }
}

// DecOne * T = -T (需要 T 支持 Neg)
impl<T: Neg<Output = T>> Mul<T> for DecOne {
    type Output = T;
    fn mul(self, rhs: T) -> T {
        -rhs
    }
}

// T * DecOne = -T (需要 T 支持 Neg)
impl<T: Neg<Output = T>> Mul<DecOne> for T {
    type Output = T;
    fn mul(self, _: DecOne) -> T {
        -self
    }
}

// DecOne + T = T - 1 (需要 T 支持 Sub<i32>)
impl<T: Sub<i32, Output = T>> Add<T> for DecOne {
    type Output = T;
    fn add(self, rhs: T) -> T {
        rhs - 1
    }
}

// ========== 其他组合运算 ==========

// One * DecOne = DecOne
impl Mul<DecOne> for One {
    type Output = DecOne;
    fn mul(self, rhs: DecOne) -> DecOne {
        rhs
    }
}

// DecOne * One = DecOne
impl Mul<One> for DecOne {
    type Output = DecOne;
    fn mul(self, _: One) -> DecOne {
        self
    }
}

// Zero * DecOne = Zero (已由 Zero 的通用实现覆盖)
// DecOne * Zero = Zero (已由 Zero 的通用实现覆盖)

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_zero_operations() {
        let z = Zero;

        // 加法测试
        assert_eq!(z + 5, 5);       // 0 + 5 = 5
        assert_eq!(z + (-3), -3);  // 0 + (-3) = -3
        assert_eq!(z + "hello", "hello"); // 0 + 非数字类型

        // 乘法测试
        assert_eq!(z * z, z);       // 0 * 0 = 0
        assert_eq!(z * 10, z);      // 0 * 10 = 0
        assert_eq!(10 * z, z);      // 10 * 0 = 0
        assert_eq!(z * One, z);     // 0 * 1 = 0
        assert_eq!(One * z, z);     // 1 * 0 = 0
        assert_eq!(z * DecOne, z);  // 0 * -1 = 0
        assert_eq!(DecOne * z, z);  // -1 * 0 = 0
    }

    #[test]
    fn test_one_operations() {
        let o = One;

        // 乘法测试
        assert_eq!(o * o, o);       // 1 * 1 = 1
        assert_eq!(o * 7, 7);       // 1 * 7 = 7
        assert_eq!(7 * o, 7);       // 7 * 1 = 7
        assert_eq!(o * DecOne, DecOne); // 1 * -1 = -1
        assert_eq!(DecOne * o, DecOne); // -1 * 1 = -1

        // 加法测试
        assert_eq!(o + 3, 4);       // 1 + 3 = 4
        assert_eq!(o + (-2), -1);   // 1 + (-2) = -1
    }

    #[test]
    fn test_dec_one_operations() {
        let d = DecOne;

        // 乘法测试
        assert_eq!(d * d, One);     // -1 * -1 = 1
        assert_eq!(d * 4, -4);      // -1 * 4 = -4
        assert_eq!(4 * d, -4);      // 4 * -1 = -4
        assert_eq!(d * One, d);     // -1 * 1 = -1
        assert_eq!(One * d, d);     // 1 * -1 = -1

        // 加法测试
        assert_eq!(d + 5, 4);       // -1 + 5 = 4
        assert_eq!(d + (-3), -4);   // -1 + (-3) = -4
    }

    #[test]
    fn test_mixed_operations() {
        // 混合类型运算
        assert_eq!(One * (DecOne * 3), -3); // 1 * (-1 * 3) = -3
        assert_eq!((Zero + One) * DecOne, DecOne); // (0 + 1) * -1 = -1
        assert_eq!(DecOne * (One + 1), -2); // -1 * (1 + 1) = -2
    }

    #[test]
    fn test_commutative_law() {
        // 验证交换律
        let a = 5;
        assert_eq!(a * One, One * a);
        assert_eq!(a * DecOne, DecOne * a);
        assert_eq!(a * Zero, Zero * a);
    }

    #[test]
    fn test_associative_law() {
        // 验证结合律 (注意：加法实现不满足严格结合律)
        assert_eq!((One * DecOne) * DecOne, One * (DecOne * DecOne)); // (-1) * -1 = 1
    }

    #[test]
    fn test_distributive_law() {
        // 验证分配律 (a + b) * c = a*c + b*c
        let a = 2;
        let b = 3;
        let c = DecOne;
        assert_eq!((a + b) * c, a * c + b * c); // 5 * -1 = -2 + -3
    }
}

代码分析

这段代码定义了几个表示数学概念的单元类型（Zero、One、DecOne）并实现了它们的运算规则。下面将详细解释：

类型定义

#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct Zero;  // 表示加法单位元(0)
#[derive(Clone, Debug, Default, PartialEq, Eq)] 
pub struct One;   // 表示乘法单位元(1)
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct DecOne; // 表示乘法逆元(-1)