5 长度和距离计算模块（length.rs）

ops/2025/2/1 22:34:45/

这段代码定义了一个泛型结构体 Length<T, Unit>，用于表示一维长度，其中 T 表示长度的数值类型，而 Unit 是一个编译时检查单位一致性的占位符类型，不会用于运行时表示长度的值。这个设计允许开发者在编译阶段确保不同单位之间的长度值在使用前进行了显式的单位转换。

一、length.rs文件源码

rust">//! 用计量单位标记的一维长度。use crate::approxeq::ApproxEq;
use crate::approxord::{max, min};
use crate::num::Zero;
use crate::scale::Scale;use crate::num::One;
#[cfg(feature = "bytemuck")]
use bytemuck::{Pod, Zeroable};
use core::cmp::Ordering;
use core::fmt;
use core::hash::{Hash, Hasher};
use core::iter::Sum;
use core::marker::PhantomData;
use core::ops::{Add, Div, Mul, Neg, Sub};
use core::ops::{AddAssign, DivAssign, MulAssign, SubAssign};
use num_traits::{NumCast, Saturating};
#[cfg(feature = "serde")]
use serde::{Deserialize, Deserializer, Serialize, Serializer};/*
一维距离，其值由“T”表示，测量单位为“Unit”。 
“T”可以是任何数字类型，例如像“u64”或“f32”这样的基元类型。 
“Unit”不用于表示“Length”值。它仅在编译时使用，以确保用一个单位存储的“Length”在用于需要不同单位的表达式之前被显式转换。它可能是一个没有值的类型，例如空枚举。 
您可以将“Length”乘以“Scale”，将其从一个单位转换为另一个单位。请参阅[`Scale`]结构体。
*/
#[repr(C)]
pub struct Length<T, Unit>(pub T, #[doc(hidden)] pub PhantomData<Unit>);impl<T: Clone, U> Clone for Length<T, U> {fn clone(&self) -> Self {Length(self.0.clone(), PhantomData)}
}impl<T: Copy, U> Copy for Length<T, U> {}#[cfg(feature = "serde")]
impl<'de, T, U> Deserialize<'de> for Length<T, U> where T: Deserialize<'de>,{fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,{Ok(Length(Deserialize::deserialize(deserializer)?, PhantomData))}
}#[cfg(feature = "serde")]
impl<T, U> Serialize for Length<T, U> where T: Serialize,{fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,{self.0.serialize(serializer)}
}#[cfg(feature = "arbitrary")]
impl<'a, T, U> arbitrary::Arbitrary<'a> for Length<T, U>
whereT: arbitrary::Arbitrary<'a>,
{fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result<Self> {Ok(Length(arbitrary::Arbitrary::arbitrary(u)?, PhantomData))}
}#[cfg(feature = "bytemuck")]
unsafe impl<T: Zeroable, U> Zeroable for Length<T, U> {}#[cfg(feature = "bytemuck")]
unsafe impl<T: Pod, U: 'static> Pod for Length<T, U> {}impl<T, U> Length<T, U> {/// 将值与度量单位相关联。#[inline]pub const fn new(x: T) -> Self {Length(x, PhantomData)}
}impl<T: Clone, U> Length<T, U> {/// 从类中提取基值pub fn get(self) -> T {self.0}/// Cast the unit#[inline]pub fn cast_unit<V>(self) -> Length<T, V> {Length::new(self.0)}/// Linearly interpolate between this length and another length.////// # Example////// ```rust/// use euclid::default::Length;////// let from = Length::new(0.0);/// let to = Length::new(8.0);////// assert_eq!(from.lerp(to, -1.0), Length::new(-8.0));/// assert_eq!(from.lerp(to,  0.0), Length::new( 0.0));/// assert_eq!(from.lerp(to,  0.5), Length::new( 4.0));/// assert_eq!(from.lerp(to,  1.0), Length::new( 8.0));/// assert_eq!(from.lerp(to,  2.0), Length::new(16.0));/// ```#[inline]pub fn lerp(self, other: Self, t: T) -> SelfwhereT: One + Sub<Output = T> + Mul<Output = T> + Add<Output = T>,{let one_t = T::one() - t.clone();Length::new(one_t * self.0.clone() + t * other.0)}
}impl<T: PartialOrd, U> Length<T, U> {/// Returns minimum between this length and another length.#[inline]pub fn min(self, other: Self) -> Self {min(self, other)}/// Returns maximum between this length and another length.#[inline]pub fn max(self, other: Self) -> Self {max(self, other)}
}impl<T: NumCast + Clone, U> Length<T, U> {/// Cast from one numeric representation to another, preserving the units.#[inline]pub fn cast<NewT: NumCast>(self) -> Length<NewT, U> {self.try_cast().unwrap()}/// Fallible cast from one numeric representation to another, preserving the units.pub fn try_cast<NewT: NumCast>(self) -> Option<Length<NewT, U>> {NumCast::from(self.0).map(Length::new)}
}impl<T: fmt::Debug, U> fmt::Debug for Length<T, U> {fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {self.0.fmt(f)}
}impl<T: Default, U> Default for Length<T, U> {#[inline]fn default() -> Self {Length::new(Default::default())}
}impl<T: Hash, U> Hash for Length<T, U> {fn hash<H: Hasher>(&self, h: &mut H) {self.0.hash(h);}
}// length + length
impl<T: Add, U> Add for Length<T, U> {type Output = Length<T::Output, U>;fn add(self, other: Self) -> Self::Output {Length::new(self.0 + other.0)}
}// length + &length
impl<T: Add + Copy, U> Add<&Self> for Length<T, U> {type Output = Length<T::Output, U>;fn add(self, other: &Self) -> Self::Output {Length::new(self.0 + other.0)}
}// length_iter.copied().sum()
impl<T: Add<Output = T> + Zero, U> Sum for Length<T, U> {fn sum<I: Iterator<Item = Self>>(iter: I) -> Self {iter.fold(Self::zero(), Add::add)}
}// length_iter.sum()
impl<'a, T: 'a + Add<Output = T> + Copy + Zero, U: 'a> Sum<&'a Self> for Length<T, U> {fn sum<I: Iterator<Item = &'a Self>>(iter: I) -> Self {iter.fold(Self::zero(), Add::add)}
}// length += length
impl<T: AddAssign, U> AddAssign for Length<T, U> {fn add_assign(&mut self, other: Self) {self.0 += other.0;}
}// length - length
impl<T: Sub, U> Sub for Length<T, U> {type Output = Length<T::Output, U>;fn sub(self, other: Length<T, U>) -> Self::Output {Length::new(self.0 - other.0)}
}// length -= length
impl<T: SubAssign, U> SubAssign for Length<T, U> {fn sub_assign(&mut self, other: Self) {self.0 -= other.0;}
}// Saturating length + length and length - length.
impl<T: Saturating, U> Saturating for Length<T, U> {fn saturating_add(self, other: Self) -> Self {Length::new(self.0.saturating_add(other.0))}fn saturating_sub(self, other: Self) -> Self {Length::new(self.0.saturating_sub(other.0))}
}// length / length
impl<Src, Dst, T: Div> Div<Length<T, Src>> for Length<T, Dst> {type Output = Scale<T::Output, Src, Dst>;#[inline]fn div(self, other: Length<T, Src>) -> Self::Output {Scale::new(self.0 / other.0)}
}// length * scalar
impl<T: Mul, U> Mul<T> for Length<T, U> {type Output = Length<T::Output, U>;#[inline]fn mul(self, scale: T) -> Self::Output {Length::new(self.0 * scale)}
}// length *= scalar
impl<T: Copy + Mul<T, Output = T>, U> MulAssign<T> for Length<T, U> {#[inline]fn mul_assign(&mut self, scale: T) {*self = *self * scale;}
}// length / scalar
impl<T: Div, U> Div<T> for Length<T, U> {type Output = Length<T::Output, U>;#[inline]fn div(self, scale: T) -> Self::Output {Length::new(self.0 / scale)}
}// length /= scalar
impl<T: Copy + Div<T, Output = T>, U> DivAssign<T> for Length<T, U> {#[inline]fn div_assign(&mut self, scale: T) {*self = *self / scale;}
}// length * scaleFactor
impl<Src, Dst, T: Mul> Mul<Scale<T, Src, Dst>> for Length<T, Src> {type Output = Length<T::Output, Dst>;#[inline]fn mul(self, scale: Scale<T, Src, Dst>) -> Self::Output {Length::new(self.0 * scale.0)}
}// length / scaleFactor
impl<Src, Dst, T: Div> Div<Scale<T, Src, Dst>> for Length<T, Dst> {type Output = Length<T::Output, Src>;#[inline]fn div(self, scale: Scale<T, Src, Dst>) -> Self::Output {Length::new(self.0 / scale.0)}
}// -length
impl<U, T: Neg> Neg for Length<T, U> {type Output = Length<T::Output, U>;#[inline]fn neg(self) -> Self::Output {Length::new(-self.0)}
}impl<T: PartialEq, U> PartialEq for Length<T, U> {fn eq(&self, other: &Self) -> bool {self.0.eq(&other.0)}
}impl<T: PartialOrd, U> PartialOrd for Length<T, U> {fn partial_cmp(&self, other: &Self) -> Option<Ordering> {self.0.partial_cmp(&other.0)}
}impl<T: Eq, U> Eq for Length<T, U> {}impl<T: Ord, U> Ord for Length<T, U> {fn cmp(&self, other: &Self) -> Ordering {self.0.cmp(&other.0)}
}impl<T: Zero, U> Zero for Length<T, U> {#[inline]fn zero() -> Self {Length::new(Zero::zero())}
}impl<U, T: ApproxEq<T>> ApproxEq<T> for Length<T, U> {#[inline]fn approx_epsilon() -> T {T::approx_epsilon()}#[inline]fn approx_eq_eps(&self, other: &Length<T, U>, approx_epsilon: &T) -> bool {self.0.approx_eq_eps(&other.0, approx_epsilon)}
}#[cfg(test)]
mod tests {use super::Length;use crate::num::Zero;use crate::scale::Scale;use core::f32::INFINITY;use num_traits::Saturating;enum Inch {}enum Mm {}enum Cm {}enum Second {}#[cfg(feature = "serde")]mod serde {use super::*;extern crate serde_test;use self::serde_test::assert_tokens;use self::serde_test::Token;#[test]fn test_length_serde() {let one_cm: Length<f32, Mm> = Length::new(10.0);assert_tokens(&one_cm, &[Token::F32(10.0)]);}}#[test]fn test_clone() {// A cloned Length is a separate length with the state matching the// original Length at the point it was cloned.let mut variable_length: Length<f32, Inch> = Length::new(12.0);let one_foot = variable_length.clone();variable_length.0 = 24.0;assert_eq!(one_foot.get(), 12.0);assert_eq!(variable_length.get(), 24.0);}#[test]fn test_add() {let length1: Length<u8, Mm> = Length::new(250);let length2: Length<u8, Mm> = Length::new(5);assert_eq!((length1 + length2).get(), 255);assert_eq!((length1 + &length2).get(), 255);}#[test]fn test_sum() {type L = Length<f32, Mm>;let lengths = [L::new(1.0), L::new(2.0), L::new(3.0)];assert_eq!(lengths.iter().sum::<L>(), L::new(6.0));}#[test]fn test_addassign() {let one_cm: Length<f32, Mm> = Length::new(10.0);let mut measurement: Length<f32, Mm> = Length::new(5.0);measurement += one_cm;assert_eq!(measurement.get(), 15.0);}#[test]fn test_sub() {let length1: Length<u8, Mm> = Length::new(250);let length2: Length<u8, Mm> = Length::new(5);let result = length1 - length2;assert_eq!(result.get(), 245);}#[test]fn test_subassign() {let one_cm: Length<f32, Mm> = Length::new(10.0);let mut measurement: Length<f32, Mm> = Length::new(5.0);measurement -= one_cm;assert_eq!(measurement.get(), -5.0);}#[test]fn test_saturating_add() {let length1: Length<u8, Mm> = Length::new(250);let length2: Length<u8, Mm> = Length::new(6);let result = length1.saturating_add(length2);assert_eq!(result.get(), 255);}#[test]fn test_saturating_sub() {let length1: Length<u8, Mm> = Length::new(5);let length2: Length<u8, Mm> = Length::new(10);let result = length1.saturating_sub(length2);assert_eq!(result.get(), 0);}#[test]fn test_division_by_length() {// Division results in a Scale from denominator units// to numerator units.let length: Length<f32, Cm> = Length::new(5.0);let duration: Length<f32, Second> = Length::new(10.0);let result = length / duration;let expected: Scale<f32, Second, Cm> = Scale::new(0.5);assert_eq!(result, expected);}#[test]fn test_multiplication() {let length_mm: Length<f32, Mm> = Length::new(10.0);let cm_per_mm: Scale<f32, Mm, Cm> = Scale::new(0.1);let result = length_mm * cm_per_mm;let expected: Length<f32, Cm> = Length::new(1.0);assert_eq!(result, expected);}#[test]fn test_multiplication_with_scalar() {let length_mm: Length<f32, Mm> = Length::new(10.0);let result = length_mm * 2.0;let expected: Length<f32, Mm> = Length::new(20.0);assert_eq!(result, expected);}#[test]fn test_multiplication_assignment() {let mut length: Length<f32, Mm> = Length::new(10.0);length *= 2.0;let expected: Length<f32, Mm> = Length::new(20.0);assert_eq!(length, expected);}#[test]fn test_division_by_scalefactor() {let length: Length<f32, Cm> = Length::new(5.0);let cm_per_second: Scale<f32, Second, Cm> = Scale::new(10.0);let result = length / cm_per_second;let expected: Length<f32, Second> = Length::new(0.5);assert_eq!(result, expected);}#[test]fn test_division_by_scalar() {let length: Length<f32, Cm> = Length::new(5.0);let result = length / 2.0;let expected: Length<f32, Cm> = Length::new(2.5);assert_eq!(result, expected);}#[test]fn test_division_assignment() {let mut length: Length<f32, Mm> = Length::new(10.0);length /= 2.0;let expected: Length<f32, Mm> = Length::new(5.0);assert_eq!(length, expected);}#[test]fn test_negation() {let length: Length<f32, Cm> = Length::new(5.0);let result = -length;let expected: Length<f32, Cm> = Length::new(-5.0);assert_eq!(result, expected);}#[test]fn test_cast() {let length_as_i32: Length<i32, Cm> = Length::new(5);let result: Length<f32, Cm> = length_as_i32.cast();let length_as_f32: Length<f32, Cm> = Length::new(5.0);assert_eq!(result, length_as_f32);}#[test]fn test_equality() {let length_5_point_0: Length<f32, Cm> = Length::new(5.0);let length_5_point_1: Length<f32, Cm> = Length::new(5.1);let length_0_point_1: Length<f32, Cm> = Length::new(0.1);assert!(length_5_point_0 == length_5_point_1 - length_0_point_1);assert!(length_5_point_0 != length_5_point_1);}#[test]fn test_order() {let length_5_point_0: Length<f32, Cm> = Length::new(5.0);let length_5_point_1: Length<f32, Cm> = Length::new(5.1);let length_0_point_1: Length<f32, Cm> = Length::new(0.1);assert!(length_5_point_0 < length_5_point_1);assert!(length_5_point_0 <= length_5_point_1);assert!(length_5_point_0 <= length_5_point_1 - length_0_point_1);assert!(length_5_point_1 > length_5_point_0);assert!(length_5_point_1 >= length_5_point_0);assert!(length_5_point_0 >= length_5_point_1 - length_0_point_1);}#[test]fn test_zero_add() {type LengthCm = Length<f32, Cm>;let length: LengthCm = Length::new(5.0);let result = length - LengthCm::zero();assert_eq!(result, length);}#[test]fn test_zero_division() {type LengthCm = Length<f32, Cm>;let length: LengthCm = Length::new(5.0);let length_zero: LengthCm = Length::zero();let result = length / length_zero;let expected: Scale<f32, Cm, Cm> = Scale::new(INFINITY);assert_eq!(result, expected);}
}

二、结构体定义

rust">#[repr(C)]
pub struct Length<T, Unit>(pub T, #[doc(hidden)] pub PhantomData<Unit>);
  • #[repr©]：保证结构体在内存中的布局与C语言兼容，通常用于确保与C/C++代码或外部接口的二进制兼容性。
  • PhantomData：一个零大小的类型，用于在编译时携带类型信息，而不会增加结构体的大小。这里用于确保单位的一致性。

三、实现Clone

rust">impl<T: Clone, U> Clone for Length<T, U> {fn clone(&self) -> Self {Length(self.0.clone(), PhantomData)}
}
  • 这段代码实现了Clone trait，允许Length类型的值被克隆。
  • PhantomData的实例化应使用PhantomData::，而不是直接使用PhantomData（虽然Rust编译器通常可以推断）。

四、cast和try_cast方法

rust">impl<T: NumCast + Clone, U> Length<T, U> {/// Cast from one numeric representation to another, preserving the units.#[inline]pub fn cast<NewT: NumCast>(self) -> Length<NewT, U> {self.try_cast().unwrap()}/// Fallible cast from one numeric representation to another, preserving the units.pub fn try_cast<NewT: NumCast>(self) -> Option<Length<NewT, U>> {NumCast::from(self.0).map(Length::new)}
}
  • 这里我们使用了num_traits::NumCast trait来实现数值类型之间的转换。
  • cast方法调用try_cast并解包Option，这意味着如果转换失败，程序将会panic。
  • try_cast方法尝试将Length的数值部分从类型T转换为NewT，如果成功，则使用新的数值和原始的单位类型U创建一个新的Length值。

五、其他trait实现

  • fmt::Debug：为Length实现Debug trait，使得Length值可以格式化输出。
  • Default：为Length实现Default trait，允许使用default()方法创建默认值的Length实例。
  • Hash：为Length实现Hash trait，使得Length值可以被哈希。
  • Length + Length 的加法
  • Length + &Length 的加法
  • Length 迭代器的求和（Sum）实现（针对可复制的情况）
  • &Length 迭代器的求和（Sum）实现
  • Length += Length 的加法
  • 减法实现
  • 比较特性（PartialEq, PartialOrd, Eq, Ord）的实现
  • 零值特性（Zero）的实现
  • 近似相等特性（ApproxEq）的实现
    #六、结束语
    这个结构体不仅提供了数值和单位的泛型表示，还通过实现各种 trait 来支持丰富的操作，如加减、克隆、比较和哈希等。这使得 Length<T, U> 能够与 Rust 标准库中的许多算法和数据结构无缝协作，同时保持了泛型性和类型安全。

http://www.ppmy.cn/ops/154875.html

相关文章

【C++高并发服务器WebServer】-8：终端、进程组、会话、守护进程

【C++高并发服务器WebServer】-8：终端、进程组、会话、守护进程

本文目录 一、终端二、进程组三、会话四、进程组、会话、控制终端之间的关系五、守护进程六、创建守护进程的流程 一、终端 在 UNIX 系统中&#xff0c;用户通过终端登录系统后得到一个shell 进程&#xff0c;这个终端成为 shell 进程的控制终端(Controlling Terminal)&#x…
阅读更多...
舵机型号与识别

舵机型号与识别

舵机型号繁多&#xff0c;不同品牌和制造商有不同的命名规则。常见的舵机品牌包括 Futaba、Hitec、Tower Pro、Savox、JX Servo 等。以下是舵机型号的常见识别方法以及一些典型的型号示例&#xff1a; 一、舵机型号的识别方法 型号命名规则&#xff1a; 舵机型号通常由字母和数…
阅读更多...
vue3项目中编写less

vue3项目中编写less

css,less&#xff0c;sass文件一般写在vue3的asset目录下 1.引入依赖 npm install -D less2.定义less文件 3.在其他文件中引入less文件 如在app.vue文件中引入&#xff0c; 可使用绝对路径也可以使用相对路径
阅读更多...
2025数学建模美赛|C题成品论文|第一问

2025数学建模美赛|C题成品论文|第一问

1.模型建立与求解 1.1问题求解思路 为了准确预测奥运会奖牌分布情况&#xff0c;尤其是金牌数和奖牌总数&#xff0c;本研究采用以下步骤&#xff1a; &#xff08;1&#xff09;数据处理与特征工程 从提供的奥运会奖牌历史数据中提取核心信息。 补充外部特征&#xff0c;…
阅读更多...
网络工程师 （8）存储管理

网络工程师 （8）存储管理

一、页式存储基本原理 &#xff08;一&#xff09;内存划分 页式存储首先将内存物理空间划分成大小相等的存储块&#xff0c;这些块通常被称为“页帧”或“物理页”。每个页帧的大小是固定的&#xff0c;例如常见的页帧大小有4KB、8KB等&#xff0c;这个大小由操作系统决定。同…
阅读更多...
【项目集成Husky】

【项目集成Husky】

项目集成Husky 安装初始化 Husky在.husky → pre-commit文件中添加想要执行的命令 安装 使用 Husky 可以帮助你在 Git 钩子中运行脚本&#xff0c;例如在提交代码前运行测试或格式化代码pnpm add --save-dev husky初始化 Husky npx husky init这会在项目根目录下创建一个 .hu…
阅读更多...
Arcgis国产化替代：Bigemap Pro正式发布

Arcgis国产化替代：Bigemap Pro正式发布

在数字化时代&#xff0c;数据如同新时代的石油&#xff0c;蕴含着巨大的价值。从商业决策到科研探索&#xff0c;从城市规划到环境监测&#xff0c;海量数据的高效处理、精准分析与直观可视化&#xff0c;已成为各行业突破发展瓶颈、实现转型升级的关键所在。历经十年精心打磨…
阅读更多...
从替代到覆盖：暴雨信创服务器打开市场新局面

从替代到覆盖：暴雨信创服务器打开市场新局面

进入2025年,全球局势更加变幻莫测,高科技领域越来越受到全球局势影响。美国前任总统拜登在卸任前,特别颁布限制GPU产品出口法案。新任总统特朗普上任第一天,废除了多项之前法案,但显示技术交流的内容一条没变。 在如此艰难的局面下,我国信创市场的发展显得尤为重要,国家也从政策…
阅读更多...
最新文章

Copyright @ 2022~2023