【unitrix】 4.17 类型级别右移运算实现解析(shr.rs）

一、源码

这段代码实现了类型级别的右移运算（>>），包括对整数和定点数的支持。

/*类型级别的右移运算实现* 编制人: $ource* 修改版次:0版完成版* 本版次创建时间: 2025年6月27日* 最后修改时间: 2025年7月2日 Sub1修改* 待完善问题：无*/
use core::ops::{Shl, Shr};use crate::number::{Z0, P1, N1, B0, B1, Var, FixedPoint,TypedInt, NonZero, Primitive, PrimitiveInt, Unsigned,IfB0, IfB1, Sub1,
};// ==================== Right Shift Operation (>>) ====================
// ==================== 右移运算（>>） ====================// ==================== Z0 >> All ====================
// Zero right shifted by any amount is still zero
// 零右移任何位数仍然是零
impl<R: Unsigned> Shr<R> for Z0 {type Output = Z0;fn shr(self, _: R) -> Self::Output {Z0}
}// Zero right shifted by a variable amount is still zero
// 零右移可变位数仍然是零
impl<T: Primitive> Shr<Var<T>> for Z0 {type Output = Z0;fn shr(self, _: Var<T>) -> Self::Output {Z0}
}// ==================== P1 >> U ====================
// Positive one right shifted by zero is itself
// 正一右移零位是其本身
impl Shr<Z0> for P1 {type Output = Self;fn shr(self, _: Z0) -> Self::Output {self}
}// Positive one right shifted by any non-zero unsigned number becomes zero
// 正一右移任何非零无符号数变为零
impl<R: Unsigned + NonZero> Shr<R> for P1 {type Output = Z0;fn shr(self, _: R) -> Self::Output {Z0}
}impl<T: PrimitiveInt> Shr<Var<T>> for P1
where Var<T>: From<P1> + Shr<Output=Var<T>>
{type Output = Var<T>;fn shr(self, rhs: Var<T>) -> Self::Output {Var::<T>::from(self) >> rhs}
}// ==================== N1 >> U ====================
// Negative one right shifted by any unsigned number remains negative one
// (due to sign extension in two's complement arithmetic right shift)
// 负一右移任何无符号数仍然是负一（由于二进制补码算术右移中的符号扩展）
impl<R: Unsigned> Shr<R> for N1 {type Output = Self;fn shr(self, _: R) -> Self::Output {self}
}impl<T: PrimitiveInt> Shr<Var<T>> for N1 {type Output = Self;fn shr(self, _: Var<T>) -> Self::Output {self}
}// ==================== B0 >> U ====================
// Binary number ending with 0 right shifted by zero is itself
// 以0结尾的二进制数右移零位是其本身
impl<H: NonZero> Shr<Z0> for B0<H> {type Output = Self;fn shr(self, _: Z0) -> Self::Output {self}
}// Binary number ending with 0 right shifted by more than one
// Recursively shifts right by one until the shift amount is zero
// (equivalent to dropping the least significant bit and shifting the rest)
// 以0结尾的二进制数右移多于一位
// 递归地右移一位直到移位量为零（相当于丢弃最低有效位并右移其余位）
impl<H: NonZero + Default + Shr<<R as Sub1>::Output, Output:Default>, R: Unsigned + NonZero + Sub1> Shr<R> for B0<H>{type Output = <  H as Shr< <R as Sub1>::Output >  >::Output;fn shr(self, _: R) -> Self::Output {Default::default()}
}impl<H: NonZero, T: PrimitiveInt> Shr<Var<T>> for B0<H>
where Var<T>: From<B0<H>> + Shr<Output=Var<T>>,
{type Output = Var<T>;fn shr(self, rhs: Var<T>) -> Self::Output {Var::<T>::from(self) >> rhs}
}// ==================== B1 >> U ====================
// Binary number ending with 1 right shifted by zero is itself
// 以1结尾的二进制数右移零位是其本身
impl<H: NonZero> Shr<Z0> for B1<H> {type Output = Self;fn shr(self, _: Z0) -> Self::Output {self}
}// Binary number ending with 1 right shifted by more than one
// Recursively shifts right by one until the shift amount is zero,
// and maintains the sign bit
// 以1结尾的二进制数右移多于一位
// 递归地右移一位直到移位量为零，并保持符号位
impl<H: NonZero + Default + Shr<<R as Sub1>::Output, Output: Default>, R: Unsigned + NonZero + Sub1> Shr<R> for B1<H>{type Output = <  H as Shr< <R as Sub1>::Output >  >::Output;fn shr(self, _: R) -> Self::Output {Default::default()}
}impl<H: NonZero, T: PrimitiveInt> Shr<Var<T>> for B1<H>
where Var<T>: From<B1<H>> + Shr<Output=Var<T>>,
{type Output = Var<T>;fn shr(self, rhs: Var<T>) -> Self::Output {Var::<T>::from(self) >> rhs}
}// ==================== FixedPoint<IntPart, FracPart> >> All ====================
// ==================== 定点数右移实现 ====================// Fixed-point number right shift by zero - no change
// 定点数右移零位 - 无变化
impl<IntPart, FracPart> Shr<Z0> for FixedPoint<IntPart, FracPart> {type Output = Self;fn shr(self, _: Z0) -> Self::Output {self}
}// Fixed-point with zero integer part right shift
// Shifting affects only the fractional part
// 整数部分为零的定点数右移
// 移位仅影响小数部分
impl<FracPart: TypedInt + Shl<R>, R: Unsigned + NonZero> Shr<R> for FixedPoint<Z0, FracPart> { //FracPart是反向存储的type Output = FixedPoint<Z0, <FracPart as Shl<R>>::Output>;fn shr(self, _: R) -> Self::Output {FixedPoint::new()}
}// Fixed-point with positive one integer part right shift
// Shifting moves bits from integer to fractional part
// 整数部分为正一的定点数右移
// 移位将位从整数部分移动到小数部分
impl<FracPart: TypedInt + IfB1, R: Unsigned + NonZero + Sub1> Shr<R> for FixedPoint<P1, FracPart>
whereFixedPoint< Z0, <FracPart as IfB1>::Output > : Shr<<R as Sub1>::Output, Output: Default>,
{type Output = <  FixedPoint< Z0, <FracPart as IfB1>::Output > as Shr<<R as Sub1>::Output>  >::Output;fn shr(self, _: R) -> Self::Output {Default::default()}
}// Fixed-point with negative one integer part right shift
// Arithmetic right shift preserves the sign bit
// 整数部分为负一的定点数右移
// 算术右移保留符号位
impl<FracPart: IfB1, R> Shr<R> for FixedPoint<N1, FracPart>
whereR: Unsigned + NonZero + Sub1,<FracPart as IfB1>::Output : Shr<<R as Sub1>::Output>,  // 递归条件
{type Output = FixedPoint<N1, <<FracPart as IfB1>::Output as Shr<<R as Sub1>::Output> >::Output>;fn shr(self, _: R) -> Self::Output {FixedPoint::new()}
}// Fixed-point with binary integer part ending with 0 right shift
// 整数部分以0结尾的二进制定点数右移
impl<H:NonZero, FracPart: IfB0, R: Unsigned + NonZero + Sub1> Shr<R> for FixedPoint<B0<H>, FracPart>
whereFixedPoint<H,<FracPart as IfB0>::Output>: Shr<<R as Sub1>::Output, Output: Default>,  // 递归条件
{type Output = < FixedPoint<H,<FracPart as IfB0>::Output> as Shr<<R as Sub1>::Output> >::Output;fn shr(self, _: R) -> Self::Output {// 递归处理：先移1位，再移n-1位Default::default()}
}// Fixed-point with binary integer part ending with 1 right shift
// 整数部分以1结尾的二进制定点数右移
impl<H:NonZero, FracPart: IfB1, R: Unsigned + NonZero + Sub1> Shr<R> for FixedPoint<B1<H>, FracPart>
whereFixedPoint<H,<FracPart as IfB1>::Output>: Shr<<R as Sub1>::Output, Output: Default>,  // 递归条件
{type Output = < FixedPoint<H,<FracPart as IfB1>::Output> as Shr<<R as Sub1>::Output> >::Output;fn shr(self, _: R) -> Self::Output {// 递归处理：先移1位，再移n-1位Default::default()}
}// ==================== Var >> All ====================
impl<T: PrimitiveInt, R: Unsigned> Shr<R> for Var<T>
whereVar<T>: From<R> + Shr,
{type Output = <Var<T> as Shr>::Output;fn shr(self, rhs: R) -> Self::Output {self >> Var::<T>::from(rhs)}
}impl<T: PrimitiveInt + Shr<Output = T>> Shr<Var<T>> for Var<T>{type Output = Var<T>;fn shr(self, rhs: Var<T>) -> Self::Output {Var(self.0 >> rhs.0)}
}/* 右移一位特质实现* 编制人: $ource* 创建时间: 2023年7月4日*//// 定义右移一位的特质
pub trait Shr1 {type Output;fn shr1(self) -> Self::Output;
}// ==================== Z0 Shr1 ====================
// 零右移一位仍然是零
impl Shr1 for Z0 {type Output = Z0;fn shr1(self) -> Self::Output {Z0}
}// ==================== P1 Shr1 ====================
// 正一右移一位变为零
impl Shr1 for P1 {type Output = Z0;fn shr1(self) -> Self::Output {Z0}
}// ==================== N1 Shr1 ====================
// 负一右移一位仍然是负一（算术右移保留符号位）
impl Shr1 for N1 {type Output = N1;fn shr1(self) -> Self::Output {self}
}// ==================== B0 Shr1 ====================
// 以0结尾的二进制数右移一位相当于去掉最低位
impl<H: NonZero> Shr1 for B0<H> {type Output = H;fn shr1(self) -> Self::Output {H::default()}
}// ==================== B1 Shr1 ====================
// 以1结尾的二进制数右移一位相当于去掉最低位
impl<H: NonZero> Shr1 for B1<H> {type Output = H;fn shr1(self) -> Self::Output {H::default()}
}// ==================== FixedPoint Shr1 ====================
// 定点数右移一位实现// 整数部分为零的定点数右移一位
impl<FracPart: TypedInt + IfB0> Shr1 for FixedPoint<Z0, FracPart> {type Output = FixedPoint<Z0, <FracPart as IfB0>::Output>;fn shr1(self) -> Self::Output {FixedPoint::new()}
}// 整数部分为正一的定点数右移一位
impl<FracPart: TypedInt + IfB1> Shr1 for FixedPoint<P1, FracPart> {type Output = FixedPoint<Z0, <FracPart as IfB1>::Output>;fn shr1(self) -> Self::Output {FixedPoint::new()}
}// 整数部分为负一的定点数右移一位
impl<FracPart: IfB1> Shr1 for FixedPoint<N1, FracPart> {type Output = FixedPoint<N1, <FracPart as IfB1>::Output>;fn shr1(self) -> Self::Output {FixedPoint::new()}
}// 整数部分以0结尾的定点数右移一位
impl<H: NonZero, FracPart: IfB0> Shr1 for FixedPoint<B0<H>, FracPart> {type Output = FixedPoint<H, <FracPart as IfB0>::Output>;fn shr1(self) -> Self::Output {FixedPoint::new()}
}// 整数部分以1结尾的定点数右移一位
impl<H: NonZero, FracPart: IfB1> Shr1 for FixedPoint<B1<H>, FracPart> {type Output = FixedPoint<H, <FracPart as IfB1>::Output>;fn shr1(self) -> Self::Output {FixedPoint::new()}
}#[cfg(test)]
mod tests {use crate::number::*;// ==================== Z0 右移测试 ====================#[test]fn test_z0_shr() {let z0 = Z0;// Z0 >> U0 = Z0assert_eq!(z0 >> Z0, Z0);// Z0 >> U1 = Z0assert_eq!(z0 >> P1, Z0);// Z0 >> U5 = Z0assert_eq!(z0 >> B1::<B0<P1>>::new(), Z0);// Z0 >> Var = Z0let var = Var(5_i32);assert_eq!(z0 >> var, Z0);}// ==================== P1 右移测试 ====================#[test]fn test_p1_shr() {let p1 = P1;// P1 >> U0 = P1assert_eq!(p1 >> Z0, P1);// P1 >> U1 = Z0assert_eq!(p1 >> P1, Z0);// P1 >> U2 = Z0assert_eq!(p1 >> B0::<P1>::new(), Z0);// P1 >> Varlet var1 = Var(0_i32);assert_eq!(p1 >> var1, Var::<i32>::from(P1));let var2 = Var::<i32>::from(1);assert_eq!(p1 >> var2, Var::<i32>::from(Z0));}// ==================== N1 右移测试 ====================#[test]fn test_n1_shr() {let n1 = N1;// N1 >> U0 = N1assert_eq!(n1 >> Z0, N1);// N1 >> U1 = N1 (算术右移保留符号位)assert_eq!(n1 >> P1, N1);// N1 >> U5 = N1assert_eq!(n1 >> B1::<B0<P1>>::new(), N1);// N1 >> Varlet var = Var::<i32>::from(3);assert_eq!(n1 >> var, N1);}// ==================== B0 右移测试 ====================#[test]fn test_b0_shr() {let b0p1 = B0::<P1>::new();// B0<P1> >> U0 = B0<P1>assert_eq!(b0p1 >> Z0, b0p1);// B0<P1> >> U1 = P1assert_eq!(b0p1 >> P1, P1);// B0<P1> >> U2 = Z0 (P1 >> U1 = Z0)assert_eq!(b0p1 >> B0::<P1>::new(), Z0);// B0<P1> >> Varlet var1 = Var::<i32>::from(0);assert_eq!(b0p1 >> var1, Var::from(b0p1));let var2 = Var::<i32>::from(1);assert_eq!(b0p1 >> var2, Var::from(P1::new()));}// ==================== B1 右移测试 ====================#[test]fn test_b1_shr() {type B1P1 = B1<P1>;let b1p1 = B1P1::new();// B1<P1> >> U0 = B1<P1>assert_eq!(b1p1 >> Z0, b1p1);// B1<P1> >> U1 = P1assert_eq!(b1p1 >> P1, P1);// B1<P1> >> U2 = Z0 (P1 >> U1 = Z0)assert_eq!(b1p1 >> B0::<P1>::new(), Z0);// B1<P1> >> Varlet var1 = Var::<i32>::from(0);assert_eq!(b1p1 >> var1, Var::from(b1p1));let var2 = Var::<i32>::from(1);assert_eq!(b1p1 >> var2, Var::from(P1::new()));}// ==================== 定点数右移测试 ====================#[test]fn test_fixed_point_shr() {// 整数部分为0的定点数右移type FP1 = FixedPoint<Z0, B1<P1>>;let fp1 = FP1::new();// FP1 >> U0 = FP1assert_eq!(fp1 >> Z0, fp1);// FP1 >> U1 = FixedPoint<Z0, U3 << U1>// 注意：FracPart是反向存储的，左移实际上是增加小数位数// 这里需要根据实际实现调整断言// 整数部分为P1的定点数右移type FP2 = FixedPoint<P1, B1<P1>>;let fp2 = FP2::new();// FP2 >> U0 = FP2assert_eq!(fp2 >> Z0, fp2);// FP2 >> U1 = FixedPoint<Z0, ...>// 需要根据实际实现调整断言// 整数部分为N1的定点数右移type FP3 = FixedPoint<N1, B1<P1>>;let fp3 = FP3::new();// FP3 >> U1 = FP3 (算术右移保留符号位)assert_eq!(fp3 >> P1, FixedPoint::< N1, B1<B1<P1>> >::new());}// ==================== Var 右移测试 ====================#[test]fn test_var_shr() {// Var >> Unsignedlet var1 = Var::<i32>::from(8);assert_eq!(var1 >> P1, Var::from(4));assert_eq!(var1 >> B0::<P1>::new(), Var::from(2));assert_eq!(var1 >> B1::<P1>::new(), Var::from(1));// Var >> Varlet var2 = Var::<i32>::from(16);let shift = Var::<i32>::from(2);assert_eq!(var2 >> shift, Var::from(4));// 负数算术右移let var3 = Var::<i32>::from(-8);assert_eq!(var3 >> P1, Var::from(-4));assert_eq!(var3 >> B0::<P1>::new(), Var::from(-2));}#[test]fn test_shr1() {// 测试Z0assert_eq!(Z0.shr1(), Z0);// 测试P1assert_eq!(P1.shr1(), Z0);// 测试N1assert_eq!(N1.shr1(), N1);// 测试B0let b0 = B0::<P1>::new();assert_eq!(b0.shr1(), P1);// 测试B1let b1 = B1::<P1>::new();assert_eq!(b1.shr1(), P1);// 测试FixedPointlet fp1 = FixedPoint::<P1, B1<P1>>::new();assert_eq!(fp1.shr1(), FixedPoint::<Z0, B1<B1<P1>>>::new());let fp2 = FixedPoint::<B0<P1>, B1<P1>>::new();assert_eq!(fp2.shr1(), FixedPoint::<P1, B0<B1<P1>>>::new());}
}

二、基本概念

  1. 类型级别编程

  • 使用Rust的类型系统在编译期进行计算

  • 通过特质(trait)和泛型实现类型之间的运算

  1. 数字表示

  • Z0: 表示数字0

  • P1: 表示正1

  • N1: 表示负1

  • B0, B1: 二进制表示的数字，B0表示最低位为0，B1表示最低位为1

三、核心实现

  1. 零的右移 (Z0)

impl<R: Unsigned> Shr<R> for Z0 {type Output = Z0;fn shr(self, _: R) -> Self::Output { Z0 }
}
  • 任何数右移0仍然是0
  1. 正一的右移 (P1)

impl Shr<Z0> for P1 {type Output = Self;fn shr(self, _: Z0) -> Self::Output { self }
}impl<R: Unsigned + NonZero> Shr<R> for P1 {type Output = Z0;fn shr(self, _: R) -> Self::Output { Z0 }
}

  • 右移0位保持不变

  • 右移任何非零位数变为0

  1. 负一的右移 (N1)

impl<R: Unsigned> Shr<R> for N1 {type Output = Self;fn shr(self, _: R) -> Self::Output { self }
}
  • 算术右移保留符号位，所以总是保持-1
  1. 二进制数的右移 (B0, B1)

impl<H: NonZero + Default + Shr<<R as Sub1>::Output, Output:Default>, R: Unsigned + NonZero + Sub1> Shr<R> for B0<H>{type Output = <H as Shr<<R as Sub1>::Output>>::Output;fn shr(self, _: R) -> Self::Output { Default::default() }
}

  • 递归实现：右移n位 = 右移1位后再右移(n-1)位

  • B0>右移1位等于H（去掉最低位的0）

  • B1>右移1位等于H（去掉最低位的1）

四、定点数右移

定点数表示为FixedPoint<IntPart, FracPart>，其中：

  • IntPart: 整数部分类型

  • FracPart: 小数部分类型（反向存储）

实现要点


impl<FracPart: TypedInt + Shl<R>, R: Unsigned + NonZero> Shr<R> for FixedPoint<Z0, FracPart> {type Output = FixedPoint<Z0, <FracPart as Shl<R>>::Output>;fn shr(self, _: R) -> Self::Output { FixedPoint::new() }
}

  • 整数部分为0时，右移只影响小数部分

  • 小数部分是反向存储的，所以右移实际上是左移小数部分


impl<FracPart: TypedInt + IfB1, R: Unsigned + NonZero + Sub1> Shr<R> for FixedPoint<P1, FracPart>
whereFixedPoint<Z0, <FracPart as IfB1>::Output>: Shr<<R as Sub1>::Output, Output: Default>,
{type Output = <FixedPoint<Z0, <FracPart as IfB1>::Output> as Shr<<R as Sub1>::Output>>::Output;fn shr(self, _: R) -> Self::Output { Default::default() }
}
  • 整数部分为1时，右移会将整数部分的1移到小数部分

五、变量右移 (Var)


impl<T: PrimitiveInt + Shr<Output = T>> Shr<Var<T>> for Var<T>{type Output = Var<T>;fn shr(self, rhs: Var<T>) -> Self::Output { Var(self.0 >> rhs.0) }
}

  • 运行时实际的右移操作

  • 支持变量移位量

六、右移一位特质 (Shr1)

单独实现了Shr1特质来优化右移一位的操作，避免递归调用。

七、测试用例

代码包含了全面的测试用例，验证了:

  • 各种数字类型的右移行为

  • 定点数的右移行为

  • 变量移位

  • 边界情况处理

八、总结

这段代码展示了如何在Rust类型系统中实现复杂的算术运算，特点包括：

  1. 编译期计算

  2. 支持任意位数移位

  3. 正确处理算术右移的符号扩展

  4. 支持定点数的小数部分处理

  5. 提供运行时变量移位支持

这种类型级别的实现可以用于需要编译期计算和验证的场景，如嵌入式系统、金融计算等对精度和性能要求高的领域。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如若转载，请注明出处：http://www.pswp.cn/bicheng/87528.shtml
繁体地址，请注明出处：http://hk.pswp.cn/bicheng/87528.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Java 并发核心：AQS（AbstractQueuedSynchronizer） 详解

Java 并发核心：AQS（AbstractQueuedSynchronizer） 详解

一、什么是 AQS&#xff1f; AbstractQueuedSynchronizer&#xff08;简称 AQS&#xff09;是 Java 并发包 java.util.concurrent.locks 中的一个核心同步框架&#xff0c;用于构建锁和同步器&#xff0c;如&#xff1a; ReentrantLockReentrantReadWriteLockCountDownLatchS…
阅读更多...
LoRA 实战指南：NLP 与 CV 场景的高效微调方法全解析

LoRA 实战指南：NLP 与 CV 场景的高效微调方法全解析

大模型已成 AI 应用的“标配”&#xff0c;但高昂的训练和部署成本让很多企业望而却步。LoRA&#xff08;Low-Rank Adaptation&#xff09;作为一种轻量级微调方案&#xff0c;正成为 NLP 与 CV 场景中低成本定制的利器。本文详细通过详细介绍 LoRA 的核心原理、在文本与图像任…
阅读更多...
centos指令

centos指令

一、python 1、查询运行中脚本 ps aux | grep python2、关闭脚本进程 kill -15 <PID> # 优雅终止&#xff08;SIGTERM&#xff09; kill -9 <PID> # 强制终止&#xff08;SIGKILL&#xff09;
阅读更多...
用c语言写一个找两张图片不同处的游戏

用c语言写一个找两张图片不同处的游戏

回答 思考完成 我们计划开发一个用C语言实现的查找两张图片不同之处的游戏。这个程序需要加载两张图片&#xff0c;然后允许用户通过点击等方式标记出差异的位置。我们将使用一个简单的图形库&#xff08;例如SDL&#xff09;来处理图像和用户交互。步骤&#xff1a;1.加载两…
阅读更多...
【深度学习:进阶篇】--4.3.seq2seq与Attention机制

【深度学习:进阶篇】--4.3.seq2seq与Attention机制

学习目标 目标 掌握seq2seq模型特点掌握集束搜索方式掌握BLEU评估方法掌握Attention机制 应用 应用Keras实现seq2seq对日期格式的翻译 目录 学习目标 1.seq2seq 1.1.定义 1.2.条件语言模型理解 1.3.应用场景 2.注意力机制 2.1.长句子问题 2.2.定义 2.3.公式 3.机器…
阅读更多...
MYSQL与PostgreSQL的差异

MYSQL与PostgreSQL的差异

一、架构设计的根本差异 进程模型 vs 线程模型 ​PostgreSQL​&#xff1a;采用多进程架构&#xff08;每个连接独立进程&#xff09;&#xff0c;通过共享内存通信。优势在于进程隔离性强&#xff0c;单连接崩溃不影响整体服务&#xff0c;但资源消耗较高。 ​MySQL​&…
阅读更多...
Wpf布局之StackPanel！

Wpf布局之StackPanel！

文章目录 前言一、引言二、使用步骤 前言 Wpf布局之StackPanel&#xff01; 一、引言 StackPanel面板在水平或垂直的堆栈中放置元素。这个布局容器通常用于更大、更复杂窗口中的一些区域。 二、使用步骤 StackPanel默认是垂直堆叠 <Grid><StackPanel><Butt…
阅读更多...
【MySQL】 内置函数

【MySQL】 内置函数

目录 1.时间函数2.字符串函数3.数学函数4.其他函数 1.时间函数 函数名称描述current_date()当前日期current_time()当前时间current_timestamp()当前时间戳date(datetime)返回datetime参数的日期部分date_add(date,interval d_value_type)在date中添加日期/时间&#xff0c;in…
阅读更多...
【RK3568+PG2L50H开发板实验例程】Linux部分/FAN 检测案例

【RK3568+PG2L50H开发板实验例程】Linux部分/FAN 检测案例

本原创文章由深圳市小眼睛科技有限公司创作&#xff0c;版权归本公司所有&#xff0c;如需转载&#xff0c;需授权并注明出处&#xff08;www.meyesemi.com) 1.案例简介 本案例旨在介绍如何测试开发板上风扇接口控制风扇启停与调速功能 2. FAN接口介绍 开发板上 FAN接口是一个…
阅读更多...
Spring AI ETL Pipeline使用指南

Spring AI ETL Pipeline使用指南

前言&#xff08;Introduction&#xff09; 版本声明&#xff1a;本文基于 Spring AI 1.0.0 版本编写。由于 Spring AI 目前仍处于活跃开发阶段&#xff0c;API 和组件可能在后续版本中发生变化&#xff0c;请注意及时关注官方文档更新以保持兼容性。 在当今大数据和人工智能快…
阅读更多...
Docker 入门教程（九）：容器网络与通信机制

Docker 入门教程（九）：容器网络与通信机制

文章目录 &#x1f433; Docker 入门教程&#xff08;九&#xff09;&#xff1a;容器网络与通信机制一、Docker 网络模型二、Docker 的四种网络类型三、容器间通信机制四、相关指令 &#x1f433; Docker 入门教程&#xff08;九&#xff09;&#xff1a;容器网络与通信机制 一…
阅读更多...
从进攻性安全角度简析 Windows PowerShell

从进攻性安全角度简析 Windows PowerShell

PowerShell 是 Windows 系统中强大的脚本语言和命令行工具&#xff0c;因其灵活性和与 .NET 框架的深度集成&#xff0c;成为攻击者执行恶意操作的热门选择。从进攻性安全视角看&#xff0c;PowerShell 的语言模式、执行策略&#xff08;Execution Policy&#xff09;、AMSI 绕…
阅读更多...
MySQL的深度分页如何优化！

MySQL的深度分页如何优化！

MySQL深度分页&#xff08;例如 LIMIT 1000000, 20&#xff09;性能差的主要原因在于 OFFSET 需要扫描并跳过大量数据&#xff0c;即使这些数据最终并不返回。随着 OFFSET 增大&#xff0c;性能会急剧下降。 以下是优化深度分页的常用策略&#xff0c;根据场景选择最适合的方案…
阅读更多...
K8s Pod 调度基础——1

K8s Pod 调度基础——1

目录 一、Replication Controller&ReplicaSet ‌一、Replication Controller (RC)‌ ‌原理‌ ‌特性‌ ‌意义‌ ‌示例与逐行解释‌ ‌二、ReplicaSet (RS)‌ ‌原理‌ ‌特性‌ ‌意义‌ ‌示例与逐行解释‌ ‌三、RC 与 RS 的对比‌ ‌四、总结‌ 二、Dea…
阅读更多...
C# Task异步的常用方法

C# Task异步的常用方法

Task异步的常用方法 C# 中的 Task 类是 System.Threading.Tasks 命名空间的一部分&#xff0c;用于表示异步操作。 一、Task.Run(Action action): 此静态方法用于在后台运行一个新任务&#xff0c;并返回与该任务关联的 Task 实例。 本质是将任务放入线程池执行&#xff0c;自…
阅读更多...
OpenResty实战之PB级物联网数据处理：时序数据库优化实战

OpenResty实战之PB级物联网数据处理：时序数据库优化实战

某智慧能源平台通过本方案成功处理了日均1.2万亿数据点&#xff0c;存储成本降低70%&#xff0c;查询延迟从分钟级优化到亚秒级。本文将深入解析PB级物联网数据处理的核心挑战与时序数据库深度优化技巧。 一、物联网数据特性与存储挑战 1.1 物联网数据核心特征 #mermaid-svg-U…
阅读更多...
聊聊架构（5）数字化时代的平台商业架构

聊聊架构（5）数字化时代的平台商业架构

在数字化浪潮的推动下&#xff0c;平台经济已成为全球经济增长的关键驱动力。作为架构师&#xff0c;不仅要精通架构设计的基础方法论&#xff0c;还需具备敏锐的商业洞察力。架构的价值在于服务业务和商业&#xff0c;而业务的发展又促使架构不断演进。本文将深入探讨平台的商…
阅读更多...
【数据增强】精细化贴图数据增强

【数据增强】精细化贴图数据增强

1.任务背景 假设我有100个苹果的照片&#xff0c;我需要把这些照片粘贴到传送带照片上&#xff0c;模拟“传送带苹果检测”场景。 这种贴图的方式更加合理一些&#xff0c;因为yolo之类的mosaic贴图&#xff0c;会把图像弄的非常支离破碎。 现在我需要随机选择几张苹果图像&am…
阅读更多...
HTML响应式Web设计

HTML响应式Web设计

什么是响应式Web设计&#xff1f; RWD指的是响应式Web设计&#xff08;Responsive Web Design)RWD能够以可变尺寸传递网页RWD对于平板和移动设备是必需的 创建一个响应式设计&#xff1a; <!DOCTYPE html> <html lang"en-US"> <head> <styl…
阅读更多...
【读代码】百度开源大模型：ERNIE项目解析

【读代码】百度开源大模型：ERNIE项目解析

一、项目基本介绍 1.1 项目概述 ERNIE（Enhanced Representation through kNowledge IntEgration）是百度基于PaddlePaddle深度学习框架开发的多模态预训练模型体系。最新发布的ERNIE 4.5系列包含10个不同变体，涵盖从300B参数的巨型MoE模型到0.3B的轻量级模型，形成完整的多…
阅读更多...
最新文章

Copyright @ 2022~2023