Rust 迭代器性能:collect 之前,先想清楚是惰性求值还是立即执行

Oracle GoldenGate (OGG) 实战:从安装到故障排查的完整避坑指南 本文提供了一份详尽的Oracle GoldenGate实战指南,涵盖从环境准备、核心进程配置到性能调优与故障排查的全过程。重点解析了OGG安装与部署中的常见陷阱,并分享了确保数据同步链路稳定运行的高级运维技巧与常见故障处理方法,帮助技术人员高效避坑。 阅读详情

Rust 迭代器性能:collect 之前,先想清楚是惰性求值还是立即执行

后来我才明白,这是 Rust 迭代器最被低估的特性:惰性求值(Lazy Evaluation)。迭代器链条里 .filter()、.map() 这些操作不会马上执行,它们的角色是"组装生产线的流水线",真正干活是在你做 .collect() 或者 for 循环的时候。今天这篇文章,我就来深入拆解 Rust 迭代器的性能模型。

一、惰性求值 vs 立即执行:用血压计类比

先说最重要的概念。Rust 的迭代器有两种状态:

  1. 惰性(Lazy):调用 .map()、.filter() 只是"描述你想做什么",不执行
  2. 立即(Eager):调用 .collect()、.count()、.sum() 是"现在就做,给我结果"

我用一个血压计的类比来帮助记忆:

/// 类比:量血压
/// 
/// 惰性操作 = 医生告诉你流程:
/// "先撸起袖子 → 绑好袖带 → 按开始键 → 读取数值"
/// 但这只是描述,你还没开始量血压
///
/// 立即操作 = 医生说:"现在就开始量!"
/// 刚才描述的流程一次性执行,给你一个最终结果

/// 惰性阶段:只是描述流水线,不分配任何容器
fn lazy_stage() -> impl Iterator<Item = u64> {
    (0..1_000_000u64)                      // 1. 创建一个范围(O(1) 内存)
        .filter(|x| x % 2 == 0)            // 2. 过滤:只保留偶数
        .map(|x| x * x)                    // 3. 映射:计算平方
        .take(10)                          // 4. 取前 10 个
    // ↑ 注意:直到这里,一行真正的计算都还没发生
    // 迭代器只是一个"配方",不是结果
}

/// 立即执行阶段:消费迭代器,真正计算
fn eager_stage() -> Vec<u64> {
    let result: Vec<u64> = lazy_stage().collect();
    // collect() 是触发器——它遍历迭代器
    // 每遍历一个元素,filter → map → take 链式执行
    // 但不创建中间 Vec<u64>!
    println!("结果: {:?}", result);  // [0, 4, 16, 36, 64, 100, 144, 196, 256, 324]
    result
}

这段代码最让人惊讶的地方是:虽然迭代范围是 0..1_000_000,但最终只计算了不到 20 个元素(找到 10 个偶数就停了)。因为 filter 和 map 是在每个元素上依次执行的,不是先把 100 万个元素过滤完再 map。这就像流水线——产品一个接一个流过去,每到一个工位做一步操作,最后只产出 10 个成品。

二、性能陷阱:无效的 collect 和不经意的收集

惰性求值虽然高效,但前提是你让它惰性到最后。很多初学者(包括我早期)写出这种代码:

use std::time::Instant;

/// ❌ 反模式 1:在循环中反复 collect
/// 每次 collect 都会创建新的 Vec,分配新内存
fn anti_pattern_1(data: &[i32]) -> i32 {
    let filtered: Vec<&i32> = data.iter()
        .filter(|x| **x > 0)
        .collect();  // ← 第一次分配:创建 Vec
    
    let doubled: Vec<i32> = filtered.iter()
        .map(|x| *x * 2)
        .collect();  // ← 第二次分配:又创建 Vec
    
    doubled.iter().sum()  // ← 第三次遍历!
}

/// ✅ 优化:把三个操作合并成一个迭代器链
/// 只创建最终结果,不建中间容器
fn optimized_1(data: &[i32]) -> i32 {
    data.iter()
        .filter(|x| **x > 0)     // 过滤
        .map(|x| *x * 2)         // 映射
        .sum()                    // 求和 —— 一次性完成
    // 时间复杂度一样,但:
    // - 少两次内存分配
    // - 少两次数据遍历
    // - 缓存友好:数据在被处理完之前都在 CPU cache 里
}

/// ❌ 反模式 2:collect 了但只取前几个
/// 浪费了大量计算和内存
fn anti_pattern_2() -> Vec<u64> {
    let all: Vec<u64> = (0..10_000_000u64)
        .filter(|x| x % 7 == 0)  // 找到所有 7 的倍数
        .map(|x| x * x * x)       // 计算立方
        .collect();               // ← 收集所有结果(可能有 140 万个!)
    
    all.into_iter().take(5).collect()  // ← 只要前 5 个!前面的白算了
}

/// ✅ 优化:take 放在 collect 之前
/// 迭代器一旦找到 5 个就停,不会处理剩余 9,999,995 个元素
fn optimized_2() -> Vec<u64> {
    (0..10_000_000u64)
        .filter(|x| x % 7 == 0)
        .map(|x| x * x * x)
        .take(5)         // ← 关键:take 在 collect 之前
        .collect()       // 只收集 5 个元素
}

/// ❌ 反模式 3:用 collect + 外部循环代替迭代器
/// 可读性差且性能可能更差(无法利用迭代器的编译优化)
fn anti_pattern_3(strings: &[String]) -> Vec<String> {
    let mut result = Vec::with_capacity(strings.len());
    for s in strings {
        if s.len() > 3 {
            result.push(s.to_uppercase());
        }
    }
    result
}

/// ✅ 优化:用迭代器更清晰,编译器可能做更好的优化
fn optimized_3(strings: &[String]) -> Vec<String> {
    strings.iter()
        .filter(|s| s.len() > 3)
        .map(|s| s.to_uppercase())
        .collect()
    // 编译器可能内联整个迭代器链,消除函数调用开销
}

fn main() {
    let data = vec![-1, 2, -3, 4, -5, 6, -7, 8];
    
    let start = Instant::now();
    let r1 = anti_pattern_1(&data);
    println!("反模式1: {} ({:?})", r1, start.elapsed());
    
    let start = Instant::now();
    let r2 = optimized_1(&data);
    println!("优化1: {} ({:?})", r2, start.elapsed());
    
    let r3 = optimized_2();
    println!("优化2: {:?}", r3);
}

这里我用一张图来总结"迭代器链何时终止"的决策规则:

flowchart TD
    A["开始设计数据处理流程"] --> B{"我能用迭代器链<br/>一次性表达吗?"}
    
    B -->|能| C{"中间结果还需要<br/>单独使用吗?"}
    
    C -->|不需要| D["✅ 惰性到最后<br/>避免中间 collect"]
    D --> D1["好处:无额外分配<br/>缓存友好<br/>可能被编译器优化"]
    
    C -->|需要| E{"需要几次?"}
    E -->|一次| F["在真正需要的地方<br/>collect 一次"]
    E -->|多次| G["✅ ref 引用复用<br/>或用 itertools 的 tee"]
    
    B -->|不能| H{"无法用迭代器<br/>表达的原因?"}
    H -->|有副作用| I["⚠️ for 循环更合适<br/>迭代器不应该有副作用"]
    H -->|需要提前退出| J["✅ 用 try_fold<br/>或 for + break"]
    H -->|多阶段依赖| K["每阶段一次 collect<br/>但明确注释原因"]
    
    style D fill:#c8e6c9
    style D1 fill:#c8e6c9
    style G fill:#c8e6c9
    style J fill:#c8e6c9
    style I fill:#fff9c4
    style K fill:#fff9c4

三、fold、reduce 和 scan:不只是"遍历",而是"有状态的消费"

提到迭代器,很多人只想到 .collect()。但实际上,Rust 迭代器提供了一系列有状态的消费方法,比 collect + 手动循环高效得多:

/// 迭代器的三种"状态消费"方式
/// 它们都能代替"创建一个可变变量 + for 循环"的模式

fn stateful_consumers() {
    let numbers = vec![10, 20, 30, 40, 50];

    // ===== fold:带初始值的累积 =====
    // 类比:从初始余额开始,每笔交易更新余额
    let balance: i32 = numbers.iter().fold(100, |acc, &x| {
        // acc = 累积值(初始100),x = 当前元素
        acc - x  // 每笔支出
    });
    println!("fold: 初始 100,支出后余额 = {}", balance);
    
    // 等价于 for 循环:
    // let mut balance = 100;
    // for &x in &numbers { balance -= x; }

    // ===== reduce:无初始值的累积 =====
    // 第一个元素作为初始值,第二个开始累积
    let product: Option<&i32> = numbers.iter().reduce(|a, b| {
        // a = 上一个累积结果,b = 当前值
        // 返回 a * b 但不改变原数据
        // 只能用这种"返回新值"的方式
        // 注意:这里返回的是 &i32,不能做乘法运算
        // 实际项目中 fold 更常用
        a  // 实际场景返回计算结果
    });
    
    // 更实用的 reduce 例子:
    let sum: i32 = vec![1, 2, 3, 4, 5]
        .into_iter()
        .reduce(|a, b| a + b)
        .unwrap_or(0);
    println!("reduce 求和: {}", sum);

    // ===== scan:带状态的惰性迭代器 =====
    // 和 fold 的区别:fold 返回最终值,scan 返回每一步的中间结果
    let running_total: Vec<i32> = numbers
        .iter()
        .scan(0, |state, &x| {
            // state = 可变的状态变量(跨迭代保持)
            *state += x;       // 更新状态
            Some(*state)       // 返回当前累积值
        })
        .collect();
    
    println!("scan 累积: {:?}", running_total);
    // 输出: [10, 30, 60, 100, 150]
    // 每一步都输出当前累积值,而不是等最后
    
    // scan 的实用场景:滑动窗口计算
    let window_sum: Vec<i32> = vec![1, 3, 5, 7, 9, 11]
        .windows(3)  // 每次取3个元素的滑动窗口
        .map(|w| w.iter().sum())
        .collect();
    println!("滑动窗口求和: {:?}", window_sum);
}

/// fold vs for 循环的性能对比:
/// fold 通常更快,因为:
/// 1. 编译器可以更好地优化(内联、向量化)
/// 2. 避免了手动索引的边界检查
/// 3. 更容易被 LLVM 自动向量化

use std::time::Instant;

fn fold_vs_loop_benchmark() {
    let data: Vec<i64> = (0..10_000_000).collect();
    
    // fold 版本
    let start = Instant::now();
    let sum1: i64 = data.iter().fold(0i64, |acc, &x| acc.wrapping_add(x));
    let fold_time = start.elapsed();
    
    // for 循环版本
    let start = Instant::now();
    let mut sum2 = 0i64;
    for &x in &data {
        sum2 = sum2.wrapping_add(x);
    }
    let loop_time = start.elapsed();
    
    println!("fold: {:?}, for: {:?}, 结果一致: {}", 
             fold_time, loop_time, sum1 == sum2);
    // 在 release 模式下,两者性能几乎相同(LLVM 优化)
    // 在 debug 模式下,fold 有时更快(迭代器有专门的优化路径)
}

四、itertools:当标准库迭代器不够用的时候

标准库的迭代器很强大,但有些场景还是不够。itertools crate 填补了这些空白:

// 需要先在 Cargo.toml 中添加:
// [dependencies]
// itertools = "0.13"

use itertools::Itertools;

/// itertools 中最实用的几个方法
fn itertools_showcase() -> Vec<String> {
    let data = vec!["Alice", "Bob", "Charlie", "David", "Eve"];

    // ===== chunk:分组迭代 =====
    // 标准库没有按数量分组的迭代器
    let groups: Vec<Vec<&&str>> = data.iter().chunks(2)
        .into_iter()
        .map(|chunk| chunk.collect::<Vec<_>>())
        .collect();
    println!("分组: {:?}", groups);
    // 输出: [["Alice", "Bob"], ["Charlie", "David"], ["Eve"]]

    // ===== tuple_windows:滑动窗口 =====
    // 生成前后元素组成的元组
    let transitions: Vec<(&&str, &&str)> = data.iter()
        .tuple_windows()
        .collect();
    println!("相邻对: {:?}", transitions);
    // 输出: [("Alice","Bob"), ("Bob","Charlie"), ("Charlie","David"), ("David","Eve")]

    // ===== unique:去重(惰性)=====
    let numbers = vec![1, 2, 2, 3, 3, 3, 4, 5, 5];
    let unique_nums: Vec<i32> = numbers.into_iter()
        .unique()           // ← 惰性去重,内部用 HashSet 记录已见过的元素
        .collect();
    println!("去重: {:?}", unique_nums);
    // 输出: [1, 2, 3, 4, 5]

    // ===== sorted:排序(立即执行)=====
    let mut unsorted = vec![3, 1, 4, 1, 5, 9, 2, 6];
    let sorted: Vec<i32> = unsorted.iter()
        .sorted()           // ← 立即执行排序
        .copied()
        .collect();
    println!("排序: {:?}", sorted);
    
    // ===== merge:合并两个已排序的迭代器 =====
    let a = vec![1, 3, 5, 7];
    let b = vec![2, 4, 6, 8];
    let merged: Vec<i32> = a.iter()
        .merge(b.iter())
        .copied()
        .collect();
    println!("合并有序: {:?}", merged);
    // 输出: [1, 2, 3, 4, 5, 6, 7, 8]
    // 时间复杂度 O(n+m),比 concat + sort 快
    
    // ===== combinations:组合数 =====
    let items = vec!["A", "B", "C", "D"];
    let combos: Vec<Vec<&&str>> = items.iter()
        .combinations(2)    // 从4个中选2个的所有组合
        .collect();
    println!("组合: {:?}", combos);
    // 输出: [[A,B], [A,C], [A,D], [B,C], [B,D], [C,D]]
    
    vec![] // 占位返回值
}

itertools 的 unique() 内用 HashSet 存已见元素,数据量大时内存开销不小。我在扫描 100 万行日志去重时,unique() 的内存冲到 500MB。换成 sorted().dedup() 先排序再去重,内存只用了 50MB,虽然多了排序的 CPU 开销,但不会 OOM。

itertools 的 tuple_windows() 在做滑动窗口时很顺手,但注意它内部用的是 clone() 而不是引用。如果元素是 String 或 Vec,大窗口会导致大量内存拷贝。对于大窗口场景,用 .windows(n) + Iterator 引用更省内存。

五、总结

这篇文章围绕 Rust 迭代器的性能,我分享了四个核心认知:

  1. 惰性求值是 Rust 迭代器最大的性能优势——.map().filter().take() 不创建中间容器,在消费时才"按需计算"
  2. 过早的 collect 是性能杀手——每次 collect 都创建新容器、触发新遍历。除非中间结果要复用它,否则把链一路串联到底
  3. fold/reduce/scan 是比 for 循环更高效的工具——它们给编译器更多的优化空间,代码也更短
  4. itertools 补全了标准库的缺口——tuple_windows、unique、combinations 这些都是高频需求

作为一个自学者,我最初以为迭代器只是 Rust 的"语法糖",为了方便而牺牲性能。但深入了解后才发现完全相反——迭代器是 Rust 编译器最擅长优化的模式之一,大多数时候迭代器链的汇编输出比手写 for 循环更紧凑。

我的经验法则是:能用迭代器的就不用手写 for 循环,能让它惰性的就别急着 collect。当你习惯了这种思维方式,你会发现自己的 Rust 代码越来越短、越来越快、也越来越"Rusty"。

如果你也有迭代器相关的性能心得,欢迎评论区交流,我们下篇见!

lammps案例:扭转 扭转有两种方式,一是固定一端旋转另外一端,二是两端沿相反的方向旋转。案例为两侧旋转方式,扭转后的效果如图所示。 阅读详情

相关推荐

台达伺服B3驱动器参数的设定和CN1的接法

3. B2的电子齿轮比是直接设定P1-44(分子)和P1-45(分母)就就可以的,但是B3的有个隐藏的细节,就是P1-44的默认值77216不用去更改,这是官方客服说的,需要改的是P1-45这个参数,比如说,我使用的丝杆螺距是5mm的,那么就是以5000脉冲走完5mm为一圈,则就把P1-45设定为5000即可;我的是三菱FX3S系列的PLC,是NPN型的,输出点是24V-作为信号的,所以接41、37,具体可参考B3的。,跟着客服的讲解操作才解决的,以下就是解决方法,希望能够帮到需要的各位。

qq_38681017的博客 1万+

Rust 迭代器组合子:map、filter、fold 链式调用的性能陷阱分析

不要在中间步骤collect(),让惰性求值发挥作用。除非你需要多次消费同一个迭代器。理解filter_map,它能合并filtermap两步为一步,减少一次闭包调用开销。能用fold就别先collect再fold一次消费,零分配。在 release 模式下测试,debug 模式的迭代器几乎没有优化,性能数据无参考意义。关注itertools库,它的sorted()unique()等惰性适配器能进一步减少分配。实际项目里优化过一个 200 万条日志解析的 pipeline,把三步链改成。

no1coder的博客 4862

Unity集成抖音小游戏:从IL2CPP配置到SDK接入全流程解析

本文详细解析了使用Unity开发抖音小游戏的完整流程。从关键的IL2CPP编译后端配置、PlayerSettings设置,到StarkSDK的接入与资源优化(如AutoStreaming),再到激励视频广告、录屏分享等核心功能的代码实现,提供了从环境准备到打包上传的全方位实战指南,帮助开发者高效完成技术适配。

weixin_27943395的博客 692

【Rust自学】13.10. 性能对比:循环 vs. 迭代器

迭代器是Rust中的一种高层次的抽象,它在编译后生成的代码和我们手写的底层代码是几乎一样的产物。这套东西叫做零开销抽象(Zero-Cost Abstraction)

A Rookie in San Domenico School 1434

睿思综述智能体:100篇高质量文献一键生成万字长文,还能联网PubMed,科研效率拉满!

对一个主题进行文献综述,是日常科研人绕不过去的工作,无论是写论文前言,综述论文,或者基金申请书的立项依据,需要根据主题,从海量文献中提取相关信息,梳理出清晰的逻辑线,再组织成流畅的文字。4 一键生成万字全文:大纲确认后,它会基于对所有论文的深度理解,逐个章节进行详细撰写,最终生成一篇逻辑连贯、内容翔实、引用规范的万字综述长文,并直接保存为Word(.docx)文件。3 智能撰写大纲:你可以提供自己的大纲,也可以让它根据所有文献内容,智能生成一个逻辑清晰的综述大纲,并支持你在此基础上修改。

dinaxuejie的博客 822

KEPServerEX中,别名映射(Alias Mapping)数据标签重命名机制

目录核心机制应用场景配置步骤技术特性与参考内容的差异KEPServerEX中,别名映射(Alias Mapping) 是一种数据标签重命名机制,主要用于简化复杂标签路径的调用或实现跨系统兼容。其核心逻辑和功能如下:路径抽象 将设备层级结构中的完整标签路径(如 Channel1.Device1.Tag1)映射为简短别名(如 TempSensor1),降低客户端调用的复杂度。动态绑定 别名与实际标签实时关联,数据更新和读写操作通过别名直接传递到底层物理标签,无需修改客户端配置。多对一映射支持多个别名指向

「东哥说MES」 专注于MES制造执行系统,为你拆解核心架构、功能模块及与ERP/PLC的集成逻辑。提供从入门到精通的系列干货、精选行业报告与实用工具,构建你的数字化知识体系,关注我,用实战经验照亮你的数字化之路。 1591

Rust 迭代器的性能优化技巧

Rust 迭代器性能优化指南 Rust 的迭代器提供了强大的链式操作能力,但不当使用会导致性能问题。本文分析了迭代器的惰性求值特性及其常见性能瓶颈,如不必要的内存分配和冗余遍历。关键优化技巧包括:减少中间集合创建、使用fold()合并操作、预分配内存以及优化链式调用方式。通过合理应用这些方法,可显著提升大数据处理场景下的迭代器性能。性能测试表明,fold()通常比map+filter组合更高效。掌握这些优化技巧有助于编写既简洁又高效的Rust代码。

qq_46698164的博客 1008

使用 Simulink + Simscape Electrical 实现一个三相半控桥式整流器的仿真模型

本文详细介绍了使用Simulink搭建三相半控桥式整流器仿真模型的方法。主要内容包括系统结构设计、建模步骤(从创建项目到参数配置)、移相触发控制的实现,以及阻感负载下的动态响应分析。通过合理设置三相电源、整流器模块、触发控制和测量模块,实现了输出电压和电流波形的仿真观测。文章还提供了优化建议,如添加滤波器、实时控制等改进方向,为电力电子变换器的仿真研究和性能优化提供了实用指导。

amy_mhd的博客 141

Rust从入门到暴走(22)--- Rust的函数式编程之迭代器iterator和集合操作

Rust提供了自己的迭代器类型,称为 Iterator。Rust 的迭代器设计旨在提供高效且安全的迭代器抽象。迭代器是 Rust 中非常重要的概念,它允许您以函数式编程的风格对集合进行操作,提供了一组方法来遍历集合元素,如 collection()、map()、filter() 等。

Luca的博客, 网络安全Hacker,人工智能AIer,区块链Web3er,全栈软件开发er 1390

【NLP】第十五章:隐马尔可夫——前向算法、后向算法、维特比算法、Baum-Welch算法

就是好比我现在知道了观测序列Observations、掩藏序列States,我试着去学一个最优的(π, A, B),让在这个(π, A, B)下,观测序列Observations、掩藏序列States的概率最大。(2)矩阵B就更好理解了,矩阵B的第一行表示我已经抽取的是盒子1,那我抽取白球的概率就是0.4,抽取黑球的概率就是0.6了,因为第一个盒子只有4白6黑嘛。三是,由于每次抽取的小球的颜色的概率不仅取决于,小球所在的盒子中的黑白球的比例,还取决于你是从哪个盒子中抽的,所以其实观测序列还对应着一个。

因为热爱所以坚持 1163

YOLOv8【第四章:注意力机制篇·第20节】一文讲透,注意力机制设计原则与选择指南 - 从原理到实践的系统化方法论!

🏆 本文收录于 《YOLOv8实战:从入门到深度优化》,该专栏持续复现网络上各种热门内容(全网YOLO改进最全最新的专栏,质量分97分+,全网顶流),改进内容支持(分类、检测、分割、追踪、关键点、OBB检测)。且专栏会随订阅人数上升而涨价(毕竟不断更新),当前性价比极高,有一定的参考&学习价值,部分内容会基于现有的国内外顶尖人工智能AIGC等AI大模型技术总结改进而来,嘎嘎硬核。    ✨ 特惠福利:目前活动一折秒杀价!一次订阅,永久免费,所有后续更新内容均免费阅读!

**My Coding Family** 899

Rust集合类型与迭代器——高效处理复杂数据结构的核心工具

本文摘要:Rust集合类型与迭代器是处理复杂数据结构的高效工具。主要内容包括:1)标准库集合类型(Vec、HashMap等)的基本操作与高级用法;2)迭代器系统的链式操作、适配器和消费者模式;3)集合的性能优化技巧(预分配内存、容量调整等);4)常见错误点(索引越界、所有权问题等)。文章通过大量代码示例展示了集合和迭代器的实际应用,帮助开发者根据业务需求选择合适的数据结构并优化性能。

编程世界如山海,探索不止。 2万+

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

深入浅出 Rust 迭代器:从基础用法到性能优化

在 Rust 开发中,迭代器(Iterator)不仅是遍历集合的工具,更是 Rust 函数式编程风格的基石,也是零成本抽象理念的典型体现。本文将从基础用法入手,逐步深入迭代器的核心特性、高级用法,再到性能优化技巧,帮助你真正掌握 Rust 迭代器。

github_28443763的博客 626

Camera2Demo

在Camera2 的基础上进行封装,使得Camera2一堆初始化逻辑与Activity分离,降低耦合度,完成预览拍照并保存的操作

计算机控制技术及应用

《计算机控制技术及应用》通过总结作者的科研成果和吸收国内外的先进理论、方法和技术,以计算机控制系统的网络化、开放化、智能化和集成化发展趋势为主线索,主要介绍计算机控制系统的基本概念和计算机控制系统的典型形式,计算机控制系统的数学描述与基本分析方法,以及数字PID控制器、最少拍控制系统、达林算法、状态变量设计法等设计方法及其各种改进算法。重点突出计算机控制系统输入输出通道接口的设计方法和典型控制系统的设计案例与实现方法等。

Rust:迭代器

讲解Rust的迭代器

博客网站 https://async-area.com 610

Rust 中的迭代器(Iterator)是一个强大且灵活的工具,用于对集合(如数组、向量、链表等)进行逐步访问和操作。

Rust迭代器是处理集合数据的强大工具,具有惰性求值、所有权安全、链式调用等特性。它通过实现Iterator trait,提供map、filter等适配器方法来转换和处理数据,可通过iter()、iter_mut()等方法创建不同所有权类型的迭代器。迭代器支持for循环遍历,并可通过collect、sum等方法消耗迭代器获取结果。Rust迭代器语法简洁高效,还支持自定义实现和并行处理,是Rust高效安全内存管理的重要体现。示例代码展示了如何创建、转换和消耗迭代器来处理数组数据。

2301_79516720的博客 756

【Rust自学】13.6. 迭代器 Pt.2:消耗和产生迭代器的方法

Rust语言在设计过程中收到了很多语言的启发,而函数式编程对Rust产生了非常显著的影响。函数式编程通常包括通过将函数作为值传递给参数、从其他函数返回它们、将它们分配给变量以供以后执行等等。

A Rookie in San Domenico School 789

Rust专项——迭代器高级用法:flat_map、fold、并行迭代与性能优化

本节深入讲解 Rust 迭代器的高级用法,包括扁平化映射 (flat_map)、累积归约 (fold/reduce)、并行迭代 (rayon) 以及自定义迭代器实现。内容涵盖:1) flat_map 的嵌套结构扁平化处理;2) fold 与 reduce 的累积计算差异;3) 利用 rayon 实现数据并行处理;4) 如何编写高效的自定义迭代器。通过代码示例展示 Rust 迭代器的高级特性,帮助开发者编写更简洁高效的代码。掌握这些技巧可显著提升 Rust 程序的性能和可读性。

小雨下雨的雨 985

Rust 性能解析:迭代器与手写循环的零成本抽象——来自 The Rust Programming Language 的基准测试验证

本文基于 [The Rust Programming Language](https://link.gitcode.com/i/769fb8897da5be137a3df630e3eeccb9) 官方仓库第 13 章《函数式语言特性》的最后一节,聚焦一个几乎所有 Rust 开发者都会纠结的问题:**使用迭代器(iterator)编写的代码,和手写 `for` 循环相比,性能到底会不会变差?** 文

gitblog_00414的博客 236

迭代器的性能优化技巧

Rust迭代器性能优化核心要点:零成本抽象让迭代器与手写循环性能相当。关键技巧包括利用惰性求值与短路计算,避免不必要的collect操作,合理使用chunks/windows分块处理,以及预分配容量。实践中,组合使用filter_map、fold等方法可显著提升性能,并行迭代器Rayon适合大数据量场景。优化前应先用基准测试定位瓶颈,优先保证代码正确性再针对性优化。

2501_94047625的博客 431

吃透 Rust 迭代器:Iterator trait 核心方法 + 企业级日志处理案例

unfold()是生产型方法中最灵活的一个,通过初始状态和闭包生成序列,支持复杂的自定义逻辑(如斐波那契数列、状态机驱动的序列)。官方文档将其描述为 “反向 fold”——fold()是累积状态,unfold()是基于状态生成元素。方法签名(基于 Rust 1.75.0 官方定义)where:初始状态值。f:闭包,接收可变状态引用,返回Some(Item)生成下一个元素,None结束迭代)。实战案例:生成斐波那契数列(经典算法场景)

【青云交】华为云云享专家 | 阿里云开发者社区专家博主 技术圈个人影响力前 9 | 博客之星 TOP12 优快云 首位四榜(原力榜 / 作者周榜 / 领军人物 / 综合热榜)榜首,破平台纪录! 苏州地区全榜霸榜,感恩全网十多万粉丝同行! 1081

Rust 常用语法速记 - 迭代器

迭代器是任何实现了Iterator​trait 的类型,它能够逐个产生序列中的值。迭代器的核心特点是惰性求值(lazy evaluation),只有在消费时才会真正执行计算。// Iterator trait 基本定义 pub trait Iterator { type Item;// 关联类型:迭代器产生的元素类型 fn next(&mut self) -> Option<Self::Item>;// 核心方法 }

sc35262的博客 726

迭代器的性能优化技巧:挖掘Rust零成本抽象的最大潜力

本文深入探讨Rust迭代器的性能优化技巧,揭示了其"零成本抽象"背后的核心机制。通过编译器内联、内存布局优化和算法选择,迭代器代码可以超越手写循环的性能。关键优化包括:利用编译器单态化消除动态分发开销,优化内存访问模式提升缓存命中率,减少不必要的内存分配,以及选择短路求值和SIMD优化的迭代器方法。文章通过实际案例展示了从多次遍历到单次融合迭代、从基础实现到并行处理的四级优化路径,证明经过精心优化的迭代器能够实现极致的执行效率。

超哥的博客 853

从市场报价到可定价的模型:用 QuantLib 搭收益率曲线与波动率曲面的完整链路

拿到一批互换、债券或期权报价后,如何在 QuantLib 中把它们变成连续、可插值、可直接喂给定价引擎的收益率曲线和波动率曲面?读完本文,你能看懂 bootstrap 的输入输出、选对曲线基类与插值器,并把单维度曲线扩展到期限×行权价的双维曲面。 ## 从一篮子报价开始:bootstrap 到底在做什么 真实业务里你拿到的不是曲线,而是离散的报价:若干期限的 IRS 平价利率、几只债券的净价、

gitblog_00056的博客 148

Rust的迭代器链式调用与中间操作惰性求值在内存上的优化效果

而Rust的迭代器链(如`iter().filter().map()`)仅构建操作描述,直到调用`collect()`或`for`循环时才逐元素执行完整流程。例如,处理百万级数据时,惰性求值避免了生成多个临时向量,内存占用仅为最终结果所需空间。在追求高性能与低内存占用的系统编程领域,Rust的迭代器链式调用与惰性求值机制展现了独特的优化能力。通过将多个操作组合成一条链式调用,并延迟实际计算到最终消费时执行,Rust不仅减少了中间数据的生成,还显著降低了内存开销。Rust迭代器链式调用的内存优化之道。

ftujka_486的博客 211

RustTraining 系列:C/C++ 开发者视角的 Rust 闭包与迭代器——从 lambda 捕获到惰性迭代链

本篇技术指南以 RustTraining 仓库中 [C/C++ 转 Rust 培训课程](https://link.gitcode.com/i/1acd8c4d8163a6a626d76b6a99410d51) 的 [第 12 章:Closures(闭包)](https://link.gitcode.com/i/bc0b2d71ed92cc5be48e36a096a14ee9) 为骨架,面向已有

gitblog_00284的博客 243

Rust迭代器原理与高效编程实践

迭代器是函数式编程中的核心概念,通过惰性求值机制实现高效的数据流处理。其工作原理基于trait抽象,在Rust中表现为Iterator trait,通过next()方法按需产生值。这种设计带来了零成本抽象、链式组合和内存安全三大技术优势,特别适合处理大规模数据集。在实际工程中,迭代器广泛应用于集合转换、流式处理和并行计算等场景,配合map/filter等适配器可以实现声明式编程。Rust的迭代器还通过所有权系统避免数据竞争,结合rayon库可轻松实现并行迭代。掌握迭代器优化技巧如避免中间分配、选择合适基础迭

weixin_30402231的博客 341

Rust 迭代器全面实战:从 for 循环到自定义 Iterator 与消费型/适配型方法(基于 rust-by-practice 教程)

迭代器(Iterator)是 Rust 标准库中最高频、最优雅的抽象之一:它将"遍历每个元素"与"判断序列何时结束"的逻辑封装成统一接口,让开发者可以用声明式的方式完成循环、转换与聚合。本篇以 rust-by-practice 仓库的 [Iterator 教程](https://link.gitcode.com/i/4ac8b5075725757140670e8dc8366a2a) 为核心骨架,结

gitblog_00002的博客 230
上一篇: AI 辅助理解 Rust 的 Send 和 Sync:让模型用生活场景类比并发安全
下一篇: AI Agent 的降级策略:模型不可用时,怎么让用户至少得到缓存结果
第一程序员
博客等级 码龄1年 1万+粉丝 1822原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值