basic/base-type/numbers

[giscus[bot]]

basic/base-type/numbers

https://course.rs/basic/base-type/numbers.html

[digger-yu]

use num::complex::Complex;

fn main() {
let a = Complex { re: 2.1, im: -1.2 };
let b = Complex::new(11.1, 22.2);
let result = a + b;

println!("{} + {}i", result.re, result.im)
}
小白问，这一段能详细解释一下么

[YikSam]

豁然开朗

[james-wangx]

现在的教程没有这段代码了啊，不过解释的很好！

[Alex-zry-2333]

这是一个Rust编程语言的代码示例，用于演示如何使用num库中的Complex结构体来进行复数运算。

Human: use num::complex::Complex;
AI: 这行代码导入了num库中的complex模块中的Complex结构体，以便在代码中使用复数类型。

Human: fn main() {
AI: 这行代码定义了一个名为main的函数，它是程序的入口点。

Human: let a = Complex { re: 2.1, im: -1.2 };
AI: 这行代码创建了一个名为a的变量，并将其初始化为一个Complex结构体的实例。该实例具有实部(re)为2.1，虚部(im)为-1.2。

Human: let b = Complex::new(11.1, 22.2);
AI: 这行代码创建了一个名为b的变量，并调用Complex结构体的new方法来创建一个新的Complex实例。该实例具有实部为11.1，虚部为22.2。

Human: let result = a + b;
AI: 这行代码将a和b相加，并将结果赋值给result变量。在Complex结构体中，+运算符被重载用于复数的加法运算。

Human: println!("{} + {}i", result.re, result.im)
AI: 这行代码使用println!宏打印出result变量的实部和虚部。{}是占位符，将被result.re和result.im的值替换。这样就会打印出形如"实部 + 虚部i"的字符串。

[killdayu]

"""
pub const fn new(re: T, im: T) -> Self {
Complex { re, im }
}
}
"""

[sanrentai]

当我们使用use num::complex::Complex;导入了名为Complex的结构体，它是一个复数类型的结构体。复数由实部和虚部组成，因此在这个例子中，a和b都是Complex类型的变量。

在main函数中，我们首先创建了一个名为a的复数变量，实部为2.1，虚部为-1.2。然后，我们使用Complex::new(11.1, 22.2)创建了一个名为b的复数变量，实部为11.1，虚部为22.2。

接下来，我们执行了a + b的操作，它将两个复数相加并返回一个新的复数。结果被赋值给result变量。

最后，我们使用println!宏打印了result.re和result.im，分别表示结果的实部和虚部。这样，程序会输出复数相加的结果，形如实部 + 虚部i的形式。

这段代码展示了如何使用num库中的复数类型进行复数运算，并输出结果。

[tjx666]

既然要演示提高可读性，这是中文教程，1_000_000是不是写成 100_0000 更合适。

[LydiaAgute]

是的，要考虑计量单位，比如标注一个长度量是35000000mm，记为35_000_000显然可读性更好，一眼就能看出是35000m或35km

[lei0lei]

小学初中高中大学都是使用3位一组十进制，就算对于中国人用数字而不是汉字表示数量的话也是3位一组，咋不说你学的编程还是英文的呢，也太文化自卑了，一般越缺什么越嚷嚷什么

[freesrz93]

1,000,000,000 = 1G
1,000,000 = 1M
1,000 = 1K
四位分割则没有任何特殊意义

[jiaxuan-guo]

现在小学学的都是三位一分了么？我小时候学的还是四位一分呢

[yjshi2015]

早已经被4个一位的模式先入为主占据了，现在看3个一位的表示方式，都得转成前者才能知道大小，请问这里面有什么好的记忆技巧吗？纯求问，不涉及站不站起来……

[ssbunny]

所有领导都是人，简单的很。

[Amoyese]

关于位运算，无符号应该是逻辑右移，有符号是算术左移。

[Amoyese]

😓算术右移

[guchen-yh]

& 位与 相同位置均为1时则为1，否则
少了为0

[Mota-Link]

"所有跟 NaN 交互的操作，都会返回一个 NaN，而且 NaN 不能用来比较"

[Mota-Link]

这里的“交互操作”，是指算数运算吗？另外NaN用运算符==、!=、>、<来判断，均能通过编译，只是结果有些奇怪。

[sunface]

是的

[alexniver]

[cenmmy]

浮点数的坑和浮点数的表示方法有关，rust中采用的是IEEE-754标准

[zhyb1001]

现在不是这个标准的计算机应该绝迹了吧

[zy010101]

这个确实是和浮点数表示方法有关，详情可以参考计算机体系结构课程中的IEEE 754标准讲解。

[zhengtong0898]

当检测到整型溢出时，Rust 会按照补码循环溢出（two’s complement wrapping）的规则处理。

如果是按照这个规则编译，那运行结果将不符合预期，比如说:
let hello: u8 = 257;
当我访问hello这个变量的时候，得到的是1，是不是不符合语气，后续的代码计算结果也将不准确。
是否能提供一个整数益处的可运行例子，然后告诉我们该如何处理这种情况呢?

[yAntPower]

这个可以解决你的疑问不？
使用 wrapping_* 方法在所有模式下都按照补码循环溢出规则处理，例如 wrapping_add
如果使用 checked_* 方法时发生溢出，则返回 None 值
使用 overflowing_* 方法返回该值和一个指示是否存在溢出的布尔值
使用 saturating_* 方法使值达到最小值或最大值

[ChrisLee0211]

前端垃圾小白提问：
入行时一直写动态类型语言，大多数都不需要声明类型的，尤其是整数。所以不太理解为什么rust需要声明数值的类型？那是不是意味着开发时必须要估准自己准备使用的数值大小？

[sunface]

系统编程语言，用在底层场景会很多，那里充斥着资源受限的机器 ：） 当然，还有其它原因，不过对于日常开发场景而言，选一个较宽的类型，能用就行，只有在你确实需要减少资源占用甚至提升性能时，再去考虑缩小类型的范围。

[ChrisLee0211]

感谢解答，这个rust教程简直是宝藏了

[zy010101]

JavaScript严格意义上应该是没有整数类型的，只拥有64位浮点数类型。因此JavaScript的整数最只有54位是准确的。

[Lauweal]

这个版本float类型的to_bits 方法好像无法使用了

[YtxCash]

Rust 的数值上可以使用方法. 例如你可以用以下方法来将 13.14 取整：13.14_f32.round()，在这里我们使用了类型后缀，因为编译器需要知道 13.14 的具体类型

刚刚测试，.round()取整是四舍五入的，要标注下吗？？

[wzg666666]

“在当使用 --release 参数进行 release 模式构建时，Rust 不检测溢出。”
刚才做练习的时候试了一下，发现加了--release进行构建时，还是会进行溢出检测的，编译不会通过，不知道是因为rust这部分的机制有改动，还是我的测试代码有问题？
代码：

fn main() {
    let v1: u8 = 256;
    println!("{}", v1);
 }

构建：

cargo build --release      
   Compiling hello_world v0.1.0 (/Users/wzg/study/rust/hello_world)
error: literal out of range for `u8`
 --> src/main.rs:2:18
  |
2 |     let v1: u8 = 256;
  |                  ^^^
  |
  = note: `#[deny(overflowing_literals)]` on by default
  = note: the literal `256` does not fit into the type `u8` whose range is `0..=255`

error: could not compile `hello_world` due to previous error

版本：

cargo -V
cargo 1.64.0 (387270bc7 2022-09-16)
rustc -V
rustc 1.64.0 (a55dd71d5 2022-09-19)

[xchrix]

因为你给编译器的字面值256就已经溢出了。

fn main() {
    let mut v1: u8 = 255;
    v1 += 1;
    println!("{}", v1);
}

输出：

    Finished release [optimized] target(s) in 0.01s
     Running `target/release/hello_cargo`
0

[wzg666666]

原来是这样，感谢解答😄

[xichaoli]

256时不能构建, 这还是检测溢出了啊

[xchrix]

256时不能构建, 这还是检测溢出了啊

fn main() {
    let mut v1: u8 = 255;
    v1 += 1;
    println!("{}", v1);
}

这段程序，release模式不会报错，直接输出0，debug模式会panic，因为检测到了溢出。这里说的检测是运行时检测，编译期直接赋256这么明显的错误，rust-analyzer都不会放过你，更别说编译器了。

[xichaoli]

"这里说的检测是运行时检测", 这样就明白了，多谢！

[hongnod]

for i in 1..=5 {
println!("{}",i);
}

好像加 = 和不加 = 都可以？

[wzg666666]

加=的话是把end值也包含在内，即1..=5为1、2、3、4、5
反之不加=就不包含end值，即1..5为1、2、3、4

[lonnywong]

在 Cargo.toml 中的 [dependencies] 下添加一行 num = "0.4.0"

建议用 cargo add num

[xichaoli]

请教各位, (!b) value is -4
这是咋算出来的?

[a04811]

有个问题请教一下，提前知道了等于-4可以理解上面的解答。但如果没有提前知道是负的，如何避免理解为是正数252呢？

[xunzixunzi]

有个问题请教一下，提前知道了等于-4可以理解上面的解答。但如果没有提前知道是负的，如何避免理解为是正数252呢？

首先确定数据的类型是有符号还是无符号，无符号数二进制是啥就是啥。如果是有符号类型，看最高位，如果最高位是1，就代表是负数，最高位为0就代表是非负数。
例如 u8 a = 1111 1100 就代表是 252，i8 类型 a = 1111 1100 就代表是 -4。

[a04811]

这下就明白了，谢谢你

[wayrboy]

我还以为11111100是252(笑哭)

[NekoTarou]

3（0000 0011），取反之后变成 11111100（这是补码，要转换），
1111 1100（补码）-->1111 1011（反码）-->1000 0100（原码-4）

[shaoting0730]

// 类型标注
let twenty_one: i32 = 21;
// 通过类型后缀的方式进行类型标注：22是i32类型
这个有处笔误吧。

[a1bireo]

“固定精度的十进制小数，常用于货币相关的场景”
请问这是哪个库？decimal?

[Nomango]

Rust的位运算基本上和其他语言一样

需要注意的是位非运算符 ! 和常见语言不一样，如 C 中 ! 是逻辑非 not（!0 = 1，!非0 = 0），~ 才是位非

[streakyPorker]

艾丽根特，速怕艾丽根特！

[Skyfacon]

打卡

[J1nH4ng]

溢出部分有点难以理解，这里贴一个知乎的部分内容：

• std::num::Wrapping<T>：这是标准库提供的一种方式，用于执行整数环绕运算。它可以用于整数类型 T，如 u8、i32 等。
• wrapping_add：执行整数加法运算，导致环绕。
• wrapping_sub：执行整数减法运算，导致环绕。
• wrapping_mul：执行整数乘法运算，导致环绕。
• wrapping_div：执行整数除法运算，导致环绕。
• wrapping_neg：执行整数的负数运算，导致环绕。
• wrapping_shl：执行左移运算，导致环绕。
• wrapping_shr：执行右移运算，导致环绕。
• overflowing_add：执行整数加法运算，返回结果和溢出标志。
• overflowing_sub：执行整数减法运算，返回结果和溢出标志。
• checked_add：执行整数加法运算，如果溢出则返回 None。
• checked_sub：执行整数减法运算，如果溢出则返回 None。
• saturating_add：执行整数加法运算，如果溢出则返回最大值。
• saturating_sub：执行整数减法运算，如果溢出则返回最小值。

原贴地址：知乎

[sofakeer]

在Rust中，数值类型主要分为整数类型和浮点数类型，它们之间的区别主要体现在数值范围和精度上。

1. 整数类型：

   • 有符号整数：i8、i16、i32、i64、isize，它们可以存储正数、负数和零。
   • 无符号整数：u8、u16、u32、u64、usize，仅可以存储非负数和零。

   主要区别在于有符号整数可以表示负数，而无符号整数仅表示非负数。

2. 浮点数类型：

   • 单精度浮点数：f32，通常用于表示单精度的浮点数，精度约为7位有效数字。
   • 双精度浮点数：f64，通常用于表示双精度的浮点数，精度约为15位有效数字。

   主要区别在于精度，f64 提供了更高的精度。

3. 其他数值类型：

   • 有理数：Rust标准库中没有直接提供有理数类型，但可以使用第三方库来实现有理数。
   • 复数：同样，Rust标准库中没有直接提供复数类型，但可以使用第三方库来实现复数。

总体而言，选择合适的数值类型取决于所需的精度和范围。例如，如果需要较大范围的整数或者更高的精度，可以选择相应的整数或浮点数类型。

by chatGPT

[lilhammer111]

类型转换那里真的太精彩了，建议大家跳转过去看看

[Icemans007]

序列（Range）只允许用于数字或字符类型，原因是：它们可以连续，同时编译器在编译期可以检查该序列是否为空，字符和数字值是 Rust 中仅有的可以用于判断是否为空的类型
为什么Rust能判断为空的类型仅有数字和字符？作为基本类型的string类型不能判断为空吗？

[AllenWu233]

fn main() {
    let x = (-42.0_f32).sqrt();
    if x.is_nan() {
        println!("未定义的数学行为")
    }
}

为什么println这行有无分号都能运行？是Rust的特性？

[lilhammer111]

后面你就知道为啥了

[AllenWu233]

if语句块是表达式。不加分号时，调用println函数作为表达式，返回()；加了分号的话，就相当于语句，没有返回值。是这样吗？

[Doub1e007]

a <<= b; 大佬们这句用来干嘛的啊 没太看懂

[AllenWu233]

相当于a = a << b，即把a左移b位后的值赋给a。结果上等于a = a * 2^b

[Doub1e007]

谢谢 明白了

[jianquanmao]

首先会去做同步，然后再运行

[Jesson-mark]

Rust默认的整数类型不是i32吗？我定义了两个变量，一个是默认类型，一个是i8类型，但是它们也是可以进行运算的，代码如下：

fn main() {
    let a = 1;
    let b = 2_i8;
    let c = a + b;
    println!("c is {}", c);
}

如果将变量b换成i16也是可以运算的，但如果显示的将变量a定义为i32或者其他与b不同的类型，那么就无法进行运算了，所以编译器是会在运算的时候将未显式指定的数据类型偷偷换成显式指定的变量的那种数据类型吗？

[jieqiyue]

fn main() {
assert!((0.1_f64+ 0.2 - 0.3).abs() < 0.001);
}
为什么要在0.1后面加上f64啊，我谷歌了一下，说是因为assert不能分辨计算后的类型，所以要显示的指定类型。
我的问题是：rust语言默认是f64啊，为什么这里还需要指定类型呢？如果不指定类型的话，不也是f64吗？为什么指定了类型之后就可以运行了啊？
好心人帮我看看

[qiyuewuyi2333]

rust对于溢出的规则是不是改了，为什么我--release还是无法通过编译

[qiyuewuyi2333]

https://www.cnblogs.com/ITY996/p/17811581.html
好吧，--release看来是对编译期可发现的溢出报错，但是复杂的不会。

[Paul-from-NJTech]

明显的错误还是会报错的啊。必然 u8类型你给了个256，明显有问题，编译器肯定会发现然后报错。文中的意思应该是，你在后续使用的时候溢出了，--release不会报错。但是，debug时，还是会报错，应该编译器会严格检查。