1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
use rand::{Rng, SeedableRng}; // 必须导入这两个 Trait
use rand::rngs::StdRng;
use rand_distr::{Normal, Distribution};

fn main() {
    // --- 1. 设置种子 ---
    // 方式 A: 使用简单的 u64 数字作为种子 (最常用)
    let mut rng = StdRng::seed_from_u64(42);

    // 方式 B: 使用 32 字节数组 (更底层/精确)
    // let seed: [u8; 32] = [0u8; 32];
    // let mut rng = StdRng::from_seed(seed);

    // --- 2. 生成随机数 ---
    
    // 生成基础随机数 (0.9 版本推荐使用 .random() 代替 .gen())
    let n1: f64 = rng.random(); 
    println!("0.0 到 1.0 之间的随机数: {}", n1);

    // 生成指定范围内的随机数
    let n2: i32 = rng.random_range(1..=100);
    println!("1 到 100 之间的整数: {}", n2);

    // --- 3. 结合布朗运动场景 (正态分布) ---
    // 生成均值为 0，标准差为 1 的正态分布随机数
    let normal = Normal::new(0.0, 1.0).unwrap();
    let v: f64 = normal.sample(&mut rng);
    println!("正态分布随机数 (用于布朗运动步长): {}", v);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
use owens_t;
// 还需要一个用于标准正态 CDF (Phi(x)) 的库，例如 statrs
// Cargo.toml 中需要添加 statrs = "0.18" (或其他版本)
use statrs::distribution::{ContinuousCDF, Normal};

/// 计算 P(xi_1 < a, xi_2 < b)
fn bivariate_standard_normal_cdf_via_owens(a: f64, b: f64, rho: f64) -> f64 {
    // 1. 获取标准正态 CDF 函数
    let standard_normal = Normal::new(0.0, 1.0).unwrap();
    let phi_a = standard_normal.cdf(a);
    let phi_b = standard_normal.cdf(b);

    // 2. 使用 owens_t::biv_norm 计算 P(xi_1 > a, xi_2 > b)
    // biv_norm(a, b, rho) 计算 P(X > a, Y > b)
    let p_gt_a_gt_b = owens_t::biv_norm(a, b, rho);

    // 3. 应用概率恒等式: P(A, B) = 1 - P(A^c) - P(B^c) + P(A^c, B^c)
    // P(xi_1 < a, xi_2 < b) = 1 - P(xi_1 > a) - P(xi_2 > b) + P(xi_1 > a, xi_2 > b)
    // P(xi_1 < a, xi_2 < b) = phi_a + phi_b - 1 + p_gt_a_gt_b
    
    // 注意: biv_norm 的参数是 f64，直接传递 a, b 即可
    phi_a + phi_b - 1.0 + p_gt_a_gt_b
}

fn main() {
    let a = 1.0;
    let b = 1.0;
    let rho = 0.5;

    let probability = bivariate_standard_normal_cdf_via_owens(a, b, rho);

    println!("a = {}, b = {}, rho = {}", a, b, rho);
    println!("P(xi_1 < a, xi_2 < b) = {}", probability);
}

1
2
3
4
5
6
let nums = vec![1, 2, 3, 3, 4];
let target = 3;

// 查找第一个 >= target 的元素的位置 (lower_bound)
let lower = nums.partition_point(|&x| x < target);
println!("Lower bound of {} is at index: {}", target, lower); // 输出 2

1
2
3
// 查找第一个 > target 的元素的位置 (upper_bound)
let upper = nums.partition_point(|&x| x <= target);
println!("Upper bound of {} is at index: {}", target, upper); // 输出 4

1
2
3
4
5
6
let j = g.partition_point(|&x| x < h);
if j < g.len() {
    g[j] = h;
} else {
    g.push(h);
}

1
2
3
4
let mut v = [5, 4, 1, 3, 2];
// 降序排序
v.sort_by(|a, b| b.cmp(a));
assert!(v == [5, 4, 3, 2, 1]); // 结果是从大到小

1
2
3
4
5
6
7
8
9
10
11
12
13
14
pub fn erase_overlap_intervals(intervals: Vec<Vec<i32>>) -> i32 {
        let n=intervals.len();
        let mut intervals=intervals;
        intervals.sort_by(|&a,&b|a[1].cmp(&b[1])); //这里应该改为|a,b|
        let mut rec=1;
        let mut preed=intervals[0][1];
        for i in 1..n{
            if intervals[i][0]>=preed{
                rec+=1;
                preed=intervals[i][1];
            }
        }
        (n-rec) as i32
    }

1
2
//envelopes: mut Vec<Vec<i32>>
envelopes.sort_unstable_by_key(|e| (e[0], -e[1]));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
use std::collections::BinaryHeap;
use std::cmp::Reverse;

fn main() {
    // 创建一个存储 Reverse<i32> 的 BinaryHeap
    let mut min_heap = BinaryHeap::new();

    // 插入元素时，用 Reverse 包装起来
    min_heap.push(Reverse(3));
    min_heap.push(Reverse(1));
    min_heap.push(Reverse(2));

    println!("最小堆弹出顺序：");
    while let Some(Reverse(num)) = min_heap.pop() {
        println!("{}", num); // 输出顺序：1, 2, 3
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
//用最小堆实现霍夫曼树
use std::collections::BinaryHeap;
use std::cmp::Reverse;
impl Solution {
    pub fn min_build_time(blocks: Vec<i32>, split: i32) -> i32 {
        let n=blocks.len();
        let mut pqu=BinaryHeap::new();
        for i in 0..n{
            pqu.push(Reverse(blocks[i]));
        }
        while pqu.len()>1{
            let a=pqu.pop().unwrap().0;
            let b=pqu.pop().unwrap().0;
            pqu.push(Reverse(split+std::cmp::max(a,b)));
        }
        pqu.pop().unwrap().0
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
fn main(){
    let x=5;
    let y=10;

    //Fn闭包：通过引用捕获变量
    let add = |a| a+x;

    //FnMut闭包：通过可变引用捕获变量
    let mut multiply = |a|{
        a/y
    };

    //FnOnce闭包：通过值捕获变量
    let divide = move |a|{
    a/y
    };
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
use std::{thread,time::Duration,Builder};

fn main(){
    thread::spawn(|| {
        for i in 1..10 {
            println!("hi number {} from the spawned thread!", i);
            thread::sleep(Duration::from_millis(1));
        }
    });

    //Thread也支持通过std::thread::Builder结构体进行创建，Builder提供了一些线程的配置项

    let handle=Builder::new()
        .name("my_thread".to_string()) //线程名
        .stack_size(1024*4)    //设置线程的堆栈大小是1024*4
        .spawn({
            "hello world" //相当于子线程的执行结果就是字符串"hello world"
        });
    let res=handle.join().unwrap();  //阻止当前线程（主线程）执行，等待子线程执行完毕，得到子线程的执行结果，即"hello world"

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
use std::thread;

fn main(){
    let data=String::from("hello world");
    let thread=std::thread::spawn(move ||{  //使用move把data的所有权转到线程内
        println!("{}",data);
    });
    thread.join();

    let v=vec![1,3,5,7,9];
    let mut childs=vec![];
    for n in v{
        let c=thread::spawn(move ||{
            println!("{}",n*n);
        });
        childs.push(c);
    }
    for c in childs{
        c.join().unwrap();  //等待所有子进程结束，或者使用expect方法来获取返回值
    }
}

1
2
3
4
5
6
7
use std::{io,thread};
fn main() ->io::Result<()>{
    let count=thread::available_parallelism()?.get();
    assert!(count>=1_usize);
    println!("{},{}",count,1_usize);
    Ok(())
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
use std::sync::{Arc,Mutex};
use std::thread;

fn main() {
    let counter=Arc::new(Mutex::new(0));
    let mut handles=vec![];

    for _ in 0..10{
        let counter=Arc::clone(&counter);
        let handle=thread::spawn(move||{
            let mut num=counter.lock().unwrap();
            *num+=1;
        });
        handles.push(handle);
    }

    for handle in handles{
        handle.join().unwrap();
    }

    println!("result: {}",*counter.lock().unwrap());
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
use std::io;

fn myf(){
    //一行有多个数
    let mut buf = String::new();
    io::stdin().read_line(&mut buf).unwrap();
    let mut nums=buf.split_whitespace();
    let num1:f64=nums.next().unwrap().parse().unwrap();
    let num2:f64=nums.next().unwrap().parse().unwrap();
    let num3:f64=nums.next().unwrap().parse().unwrap();
  
    //读入数组
    let mut buf=String::new();
    io::stdin().read_line(&mut buf).unwrap();
    let ns:Vec<i32>=buff.split_whitespace().map(|x| x.parse().unwrap()).collect();
    for v in ns{
        print!("{} ",v);
    }
}

fn main(){
    let mut buf=String::new();
    io::stdin().read_line(&mut buf).unwrap();
    let num1:i32=buf.trim().parse().unwrap();
    println!("{}",num1);
  
    myf();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
use std::io::{self,BufRead}
fn main()->io::Result<()>{
    let mut buffer=String::new();
    let mystdin=io::stdin();
    let mut handle=stdin.lock();  //显式互斥
  
    handle.read_line(&mut buffer);
    Ok(())
}


use std::io;
fn main()->io::Result<()>{
    let mut buffer=String::new();
    io::stdion().read_line(&mut buffer)； //隐式同步读取内容
    Ok(())
}

1
2
3
4
5
6
use std::io::{self,Write};

fn main()->io::Result<()>{
    io::stdout().write_all(b"hello world")?;
    Ok(())
}

1
2
3
4
5
6
7
8
use std::io::{self,Write};

fn main()->io::Result<()>{
    let stdout=io::stdout();
    let mut handle=stdout.lock();
    handle.write_all(b"hello world")?;
    Ok(())
}

1
2
3
4
use std::io::Write;
fn main(){
    std::io::stdout().write("http".as_bytes()).unwrap();
}

1
2
3
4
5
6
fn main(){
    let cmd_line=std::env::args();
    for arg in cmd_line{
        println!("{} ",arg);
    }
}

1
2
3
4
5
6
use Calc::European_Call;

fn main(){
    let call=European_Call(S,K,r,sigma,q,T);
    println!("{call:?}");
}

1
2
3
4
5
6
use std::collections::VecDeque;

let mut deque = VecDeque::new();
deque.push_back('a'); // 队列: [a]
deque.push_front('b'); // 队列: [b, a]
deque.push_back('c'); // 队列: [b, a, c]

1
2
3
4
5
let mut deque = VecDeque::from(['b', 'a', 'c']);
assert_eq!(deque.pop_front(), Some('b')); // 移除并返回头部元素 'b'
assert_eq!(deque.pop_back(), Some('c')); // 移除并返回尾部元素 'c'
assert_eq!(deque.pop_back(), Some('a')); // 移除并返回尾部元素 'a'
assert_eq!(deque.pop_back(), None); // 队列已空，返回 None

1
2
3
4
5
6
7
8
9
let mut deque = VecDeque::from([10, 20, 30]);
// 查看元素
assert_eq!(deque.front(), Some(&10));
assert_eq!(deque.back(), Some(&30));
// 通过索引获取和修改
if let Some(elem) = deque.get_mut(1) {
    *elem = 25; // 将索引1处的元素从20修改为25
}
assert_eq!(deque[1], 25);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
use plotters::prelude::*;
fn main(){
    let r:f64=0.05;
    let rf=0.1;
    let X:f64=2.0;

    let t_values: Vec<f64> = (1..=20).map(|x| x as f64 * 0.1).collect(); // T = 0.1, 0.2, ..., 2.0
    let f_values:Vec<f64>=t_values.iter().map(|&t| X*((r-rf)*t).exp()).collect();
    // 使用 fold 手动计算最大值和最小值，以避免 Ord trait 的限制
    let min_forward = f_values
        .iter()
        .fold(f64::INFINITY, |a, &b| a.min(b)); // 初始值设为无穷大，然后不断取较小值

    let max_forward = f_values
        .iter()
        .fold(f64::NEG_INFINITY, |a, &b| a.max(b)); // 初始值设为负无穷大，然后不断取较大值

    println!("\nMaturity (T)\tForward Rate (F)");
    for (t,f) in t_values.iter().zip(f_values.iter()){
        println!("{:.1}\t\t{:.6}",t,f);
    }
    let root=BitMapBackend::new("forward_plot.png", (800, 600)).into_drawing_area();
    root.fill(&WHITE).unwrap();

    let mut chart = ChartBuilder::on(&root)
        .caption("Forward Exchange Rate vs. Maturity",("sans-serif",30))
        .margin(10)
        .x_label_area_size(40)
        .y_label_area_size(40)
        .build_cartesian_2d(0.0..2.1,min_forward*0.95..max_forward*1.05)
        .unwrap();
    chart.configure_mesh().draw().unwrap();
    chart.draw_series(
        t_values
            .iter()
            .zip(f_values.iter())
            .map(|(&x, &y)| Circle::new((x, y), 3, BLUE.filled()))
    ).unwrap();
    chart.draw_series(LineSeries::new(
        t_values.iter().zip(f_values.iter()).map(|(&t,&f)| (t,f)),
        &RED,
    )).unwrap();
    println!("\nPlot saved as 'forward_plot.png'");
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
    let r:f64=0.05;
    let rf=0.1;
    let X:f64=2.0;

    let t_values: Vec<f64> = (1..=20).map(|x| x as f64 * 0.1).collect(); // T = 0.1, 0.2, ..., 2.0
    let f_values:Vec<f64>=t_values.iter().map(|&t| X*((r-rf)*t).exp()).collect();
    // 使用 fold 手动计算最大值和最小值，以避免 Ord trait 的限制
    let min_forward = f_values
        .iter()
        .fold(f64::INFINITY, |a, &b| a.min(b)); // 初始值设为无穷大，然后不断取较小值

    let max_forward = f_values
        .iter()
        .fold(f64::NEG_INFINITY, |a, &b| a.max(b)); // 初始值设为负无穷大，然后不断取较大值

    println!("\nMaturity (T)\tForward Rate (F)");
    for (t,f) in t_values.iter().zip(f_values.iter()){
        println!("{:.1}\t\t{:.6}",t,f);
    }

1
let root=BitMapBackend::new("forward_plot.png", (800, 600)).into_drawing_area();

1
root.fill(&WHITE).unwrap();

1
2
3
4
5
6
7
 let mut chart = ChartBuilder::on(&root)
        .caption("Forward Exchange Rate vs. Maturity",("sans-serif",30))
        .margin(10)
        .x_label_area_size(40)
        .y_label_area_size(40)
        .build_cartesian_2d(0.0..2.1,min_forward*0.95..max_forward*1.05)
        .unwrap();

1
2
3
4
5
6
7
8
9
chart.configure_mesh().draw().unwrap();

chart.configure_mesh()
    .x_labels(10)              // X轴显示10个刻度标签
    .y_labels(5)               // Y轴显示5个刻度标签
    .light_line_style(&TRANSPARENT)  // 副网格线设为透明
    .bold_line_style(&RED.mix(0.5))  // 主网格线设为半透明红色
    .disable_x_mesh()          // 禁用X轴网格线
    .draw()?;                  // 应用配置（需错误处理）

1
2
3
4
5
6
chart.draw_series(
    t_values
        .iter()
        .zip(f_values.iter())  // 1. 压缩配对两个数组的迭代器
        .map(|(&x, &y)| Circle::new((x, y), 3, BLUE.filled()))  // 2. 转换为 Circle 元素
).unwrap();  // 3. 错误处理

1
2
3
4
    chart.draw_series(LineSeries::new(
        t_values.iter().zip(f_values.iter()).map(|(&t,&f)| (t,f)),
        &RED,
    )).unwrap();