【PhysUnits】16.1 完善Var 结构体及其运算(variable.rs)

news2025/6/7 12:25:41

一、源码

这段代码定义了一个泛型结构体 Var，并为它实现了各种数学运算。

/*
 * 变量结构体 Var
 * 该结构体泛型参数 T 需满足 Numeric 约束
 */

use core::ops::{Neg, Add, Sub, Mul};
use crate::constant::Integer;
/// 定义 Numeric trait，约束 T 必须实现基本数值运算
pub trait Numeric:
    Neg<Output = Self> +
    Add<Output = Self> +
    Sub<Output = Self> +
    Mul<Output = Self> +
    From<i32> +
    Copy +
    Sized
{}

// 为基本类型实现 Numeric
impl Numeric for i64 {}
impl Numeric for f64 {}

/// 变量结构体，封装一个泛型值 T
#[derive(Debug, Clone, Copy, PartialEq, Default)]
pub struct Var<T: Numeric>(pub T);

/// 实现 Var 与 Var 的乘法运算
/// V * V
impl<T: Numeric> Mul<Var<T>> for Var<T> {
    type Output = Self;

    fn mul(self, b: Self) -> Self::Output {
        Var(self.0 * b.0)
    }
}

/// 实现 Var 与 Var 的加法运算
/// V + V
impl<T: Numeric> Add for Var<T> {
    type Output = Self;

    fn add(self, b: Self) -> Self::Output {
        Var(self.0 + b.0)
    }
}

/// 实现 Var 的取反运算
/// -V
impl<T: Numeric> Neg for Var<T> {
    type Output = Self;

    fn neg(self) -> Self::Output {
        Var(-self.0)
    }
}

/// 实现 Var 与 Var 的减法运算
/// V - V
impl<T: Numeric> Sub for Var<T> {
    type Output = Self;

    fn sub(self, b: Self) -> Self::Output {
        Var(self.0 - b.0)
    }
}

/// 与常量运算(新增加)
/// V * C
impl<T: Numeric, C:Integer + Mul<Var<T>>> Mul<C> for Var<T> {
    type Output = <C as Mul<Var<T>>>::Output;

    fn mul(self, c: C) -> Self::Output {
        c * self
    }
}

/// V + C
impl<T: Numeric, C: Integer + Add<Var<T>>> Add<C> for Var<T> {
    type Output = <C as Add<Var<T>>>::Output;

    fn add(self, c:C) -> Self::Output {
        c + self
    }
}

/// V - C
impl<T: Numeric, C: Integer + Neg> Sub<C> for Var<T>
where 
    <C as Neg>::Output: Add<Var<T>>,
{
    type Output = < C::Output as Add<Var<T>> >::Output;

    fn sub(self, c: C) -> Self::Output {
        -c+self
    }
}

二、Numeric Trait

pub trait Numeric:
    Neg<Output = Self> +
    Add<Output = Self> +
    Sub<Output = Self> +
    Mul<Output = Self> +
    From<i32> +
    Copy +
    Sized
{}

这个 trait 定义了数值类型需要实现的操作和特性：

必须实现取反(Neg)、加(Add)、减(Sub)、乘(Mul)运算
可以从i32类型转换(From)
必须是可拷贝的(Copy)和大小固定的(Sized)

为i64和f64实现了这个 trait，表示这两种类型可以用作Var的泛型参数。

三、Var 结构体

#[derive(Debug, Clone, Copy, PartialEq, Default)]
pub struct Var<T: Numeric>(pub T);

这是一个简单的元组结构体，包装了一个泛型值T，其中T必须实现Numeric trait。它自动派生了一些常用 trait：

Debug: 可以打印调试信息
Clone/Copy: 可以克隆/拷贝
PartialEq: 可以比较相等性
Default: 有默认值

四、基本运算实现

Var 与 Var 的运算

impl<T: Numeric> Mul<Var<T>> for Var<T> {
    type Output = Self;
    fn mul(self, b: Self) -> Self::Output {
        Var(self.0 * b.0)
    }
}

实现了Var之间的乘法运算，实际上是解包内部值相乘后再包装成新的Var。

类似的还实现了：

加法(Add)
取反(Neg)
减法(Sub)

五、与常量的运算（新增）

Var 与常量©的乘法

impl<T: Numeric, C: Integer + Mul<Var<T>>> Mul<C> for Var<T> {
    type Output = <C as Mul<Var<T>>>::Output;
    fn mul(self, c: C) -> Self::Output {
        c * self
    }
}

这里委托给常量的Mul<Var>实现，让常量类型决定如何与Var相乘。

Var 与常量©的加法

impl<T: Numeric, C: Integer + Add<Var<T>>> Add<C> for Var<T> {
    type Output = <C as Add<Var<T>>>::Output;
    fn add(self, c: C) -> Self::Output {
        c + self
    }
}

同样委托给常量的Add<Var>实现。

Var 与常量©的减法

impl<T: Numeric, C: Integer + Neg> Sub<C> for Var<T>
where 
    <C as Neg>::Output: Add<Var<T>>,
{
    type Output = < C::Output as Add<Var<T>> >::Output;
    fn sub(self, c: C) -> Self::Output {
        -c + self
    }
}