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

【PhysUnits】17.5 实现常量除法(div.rs)

news 来源：原创 2025/6/13 1:57:03

一、源码

这段代码实现了一个类型级别的除法运算系统，主要用于处理不同类型的数值在编译期间进行的除法操作。它使用了Rust的类型系统和trait来实现编译时的计算。

use core::ops::{Neg, Div};use super::basic::{Z0, B0, B1, P1, N1};
use crate::constant::{Integer, NonZero};
use crate::variable::{Var, Numeric};// ========== Basic Type Division Operations ==========
// ========== 基本类型除法运算 ==========// ========== 0 / All ===========
// Division of zero by any non-zero type
// 0 除以任何非零类型// 0 / 0 is illegal and not implemented
// 0 / 0 非法，未实现// 0 / NonZero = 0
impl<I: NonZero> Div<I> for Z0 {type Output = Self;#[inline(always)]fn div(self, _rhs: I) -> Self::Output {self  // 0 / any non-zero = 0}
}// ========== 1 / All ===========
// Division of one by various types
// 1 除以各种类型// 1 / 0 is illegal and not implemented
// 1 / 0 非法，未实现// 1 / 1 = 1
impl Div<P1> for P1 {type Output = Self;#[inline(always)]fn div(self, _rhs: Self) -> Self::Output {P1}
}// 1/-1=-1
impl Div<N1> for P1 {type Output = N1;#[inline(always)]fn div(self, _rhs: N1) -> Self::Output {N1}
}// 1 / B0 has precision loss, returns f64
// 1 / B0 有精度损失，返回f64
impl<H:NonZero> Div<B0<H>> for P1 {type Output = f64;fn div(self, _: B0<H>) -> f64 {f64::from(1) / f64::from(B0::<H>::to_i32())}
}// 1 / B1 has precision loss, returns f64
// 1 / B1 有精度损失，返回f64
impl<H:NonZero> Div<B1<H>> for P1 {type Output = f64;fn div(self, _: B1<H>) -> f64 {f64::from(1) / f64::from(B1::<H>::to_i32())}
}// ========== -1 / All ===========
// Division of negative one by various types
// -1 除以各种类型// -1 / 0 is illegal and not implemented
// -1 / 0 非法，未实现// -1 / 1 = -1
impl Div<P1> for N1 {type Output = Self;#[inline(always)]fn div(self, _rhs: P1) -> Self::Output {N1}
}// -1/-1=1
impl Div<N1> for N1 {type Output = P1;#[inline(always)]fn div(self, _rhs: N1) -> Self::Output {P1}
}// -1 / B0 has precision loss, returns f64
// -1 / B0 有精度损失，返回f64
impl<H:NonZero> Div<B0<H>> for N1 {type Output = f64;fn div(self, _: B0<H>) -> f64 {f64::from(-1) / f64::from(B0::<H>::to_i32())}
}// -1 / B1 has precision loss, returns f64
// -1 / B1 有精度损失，返回f64
impl<H:NonZero> Div<B1<H>> for N1 {type Output = f64;fn div(self, _: B1<H>) -> f64 {f64::from(-1) / f64::from(B1::<H>::to_i32())}
}// ========== B0 / All ===========
// Division of binary type ending with 0 by various types
// 以0结尾的二进制类型除以各种类型// B0 / 0 is illegal and not implemented
// B0 / 0 非法，未实现// B0 / 1 = B0
impl<H: NonZero> Div<P1> for B0<H> {type Output = Self;#[inline(always)]fn div(self, _rhs: P1) -> Self::Output {self}
}// B0/-1=-B0
impl<H: NonZero> Div<N1> for B0<H>
where B0<H>: Neg,
{type Output = <B0<H> as Neg>::Output;#[inline(always)]fn div(self, _rhs: N1) -> Self::Output {-self}
}// B0 / B0 has precision loss, returns f64
// B0 / B0 有精度损失，返回f64
impl<H1:NonZero, H2:NonZero> Div<B0<H2>> for B0<H1> {type Output = f64;fn div(self, _: B0<H2>) -> f64 {f64::from(B0::<H1>::to_i32()) / f64::from(B0::<H2>::to_i32())}
}// B0 / B1 has precision loss, returns f64
// B0 / B1 有精度损失，返回f64
impl<H1:NonZero, H2:NonZero> Div<B1<H2>> for B0<H1> {type Output = f64;fn div(self, _: B1<H2>) -> f64 {f64::from(B0::<H1>::to_i32()) / f64::from(B1::<H2>::to_i32())}
}// ========== B1 / All ===========
// Division of binary type ending with 1 by various types
// 以1结尾的二进制类型除以各种类型// B1 / 0 is illegal and not implemented
// B1 / 0 非法，未实现// B1 / 1 = B1
impl<H: NonZero> Div<P1> for B1<H> {type Output = Self;#[inline(always)]fn div(self, _rhs: P1) -> Self::Output {self}
}// B1 / -1=-B1
impl<H: NonZero> Div<N1> for B1<H>
where B1<H>: Neg,
{type Output = <B1<H> as Neg>::Output;#[inline(always)]fn div(self, _rhs: N1) -> Self::Output {-self}
}// B1 / B0 has precision loss, returns f64
// B1 / B0 有精度损失，返回f64
impl<H1:NonZero, H2:NonZero> Div<B0<H2>> for B1<H1> {type Output = f64;fn div(self, _: B0<H2>) -> f64 {f64::from(B1::<H1>::to_i32()) / f64::from(B0::<H2>::to_i32())}
}// B1 / B1 has precision loss, returns f64
// B1 / B1 有精度损失，返回f64
impl<H1:NonZero, H2:NonZero> Div<B1<H2>> for B1<H1> {type Output = f64;fn div(self, _: B1<H2>) -> f64 {f64::from(B1::<H1>::to_i32()) / f64::from(B1::<H2>::to_i32())}
}// Quotient type alias
// 商类型别名
pub type Quot<A, B> = <A as Div<B>>::Output;// ========== Division with Var<T> ==========
// ========== 与Var<T>的除法运算 ==========// ========== 0 / Var<T> ==========
impl<T: Numeric + PartialEq> Div<Var<T>> for Z0 {type Output = Self;fn div(self, rhs: Var<T>) -> Self::Output {assert!(rhs.0 != T::from(0), "division by zero");self}
}// ========== 1 / Var<T> ==========
impl<T: Numeric> Div<Var<T>> for P1 {type Output = Var<T>;#[inline(always)]fn div(self, rhs: Var<T>) -> Self::Output {Var(T::from(1) / rhs.0)}
}// ========== -1 / Var<T> ==========
impl<T: Numeric> Div<Var<T>> for N1{type Output = <Var<T> as Neg>::Output;#[inline(always)]fn div(self, rhs: Var<T>) -> Self::Output {Var(T::from(-1) / rhs.0)}
}// ========== B0 / Var<T> ==========
impl<H: NonZero, T:Numeric> Div<Var<T>> for B0<H>
where B0<H>: Integer,Var<T>: Div<Var<T>>,
{type Output = Var<T>;#[inline(always)]fn div(self, rhs: Var<T>) -> Self::Output {Var(T::from(B0::<H>::to_i32()) / rhs.0)}
}// ========== B1 / Var<T> ==========impl<H: NonZero, T:Numeric> Div<Var<T>> for B1<H>
where B1<H>: Integer,Var<T>: Div<Var<T>>,
{type Output = Var<T>;#[inline(always)]fn div(self, rhs: Var<T>) -> Self::Output {Var(T::from(B1::<H>::to_i32()) / rhs.0)}
}