numrs2 0.3.3

A Rust implementation inspired by NumPy for numerical computing (NumRS2)
Documentation 
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
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

//! Complex Number Operations Benchmarks
//!
//! Benchmarks for complex array construction, unary operations,
//! polar conversion, and throughput comparison with real arithmetic.

use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
use numrs2::complex_ops::{absolute, angle, conj, from_polar, imag, real, to_complex};
use numrs2::prelude::*;
use scirs2_core::Complex;
use std::hint::black_box;

/// Benchmark conversion of f64 arrays to complex arrays
fn bench_complex_construction(c: &mut Criterion) {
    let mut group = c.benchmark_group("complex_construction");

    for &n in [1_000usize, 10_000, 100_000, 1_000_000].iter() {
        group.throughput(Throughput::Elements(n as u64));

        let rng = random::default_rng();
        if let Ok(real_arr) = rng.random::<f64>(&[n]) {
            group.bench_with_input(BenchmarkId::new("to_complex", n), &n, |bencher, _| {
                bencher.iter(|| {
                    black_box(to_complex(&real_arr));
                });
            });
        }
    }

    group.finish();
}

/// Benchmark unary operations on complex arrays
fn bench_complex_unary_ops(c: &mut Criterion) {
    let mut group = c.benchmark_group("complex_unary_ops");

    for &n in [10_000usize, 100_000, 1_000_000].iter() {
        group.throughput(Throughput::Elements(n as u64));

        let rng = random::default_rng();
        if let Ok(real_arr) = rng.random::<f64>(&[n]) {
            let complex_arr = to_complex(&real_arr);

            group.bench_with_input(BenchmarkId::new("conj", n), &n, |bencher, _| {
                bencher.iter(|| {
                    black_box(conj(&complex_arr));
                });
            });

            group.bench_with_input(BenchmarkId::new("absolute", n), &n, |bencher, _| {
                bencher.iter(|| {
                    black_box(absolute(&complex_arr));
                });
            });

            group.bench_with_input(BenchmarkId::new("angle_radians", n), &n, |bencher, _| {
                bencher.iter(|| {
                    black_box(angle(&complex_arr, false));
                });
            });

            group.bench_with_input(BenchmarkId::new("real", n), &n, |bencher, _| {
                bencher.iter(|| {
                    black_box(real(&complex_arr));
                });
            });

            group.bench_with_input(BenchmarkId::new("imag", n), &n, |bencher, _| {
                bencher.iter(|| {
                    black_box(imag(&complex_arr));
                });
            });
        }
    }

    group.finish();
}

/// Benchmark polar-to-complex conversion
fn bench_from_polar(c: &mut Criterion) {
    let mut group = c.benchmark_group("from_polar");

    for &n in [10_000usize, 100_000].iter() {
        group.throughput(Throughput::Elements(n as u64));

        let rng = random::default_rng();
        if let (Ok(r_arr), Ok(theta_arr)) = (rng.random::<f64>(&[n]), rng.random::<f64>(&[n])) {
            group.bench_with_input(BenchmarkId::new("from_polar", n), &n, |bencher, _| {
                bencher.iter(|| {
                    if let Ok(result) = from_polar(&r_arr, &theta_arr, false) {
                        black_box(result);
                    }
                });
            });
        }
    }

    group.finish();
}

/// Throughput comparison: real f64 element-wise add vs complex element-wise add
///
/// Both operate on 1_000_000-element arrays to measure the cost of complex arithmetic
/// relative to real arithmetic.
fn bench_complex_vs_real_throughput(c: &mut Criterion) {
    let mut group = c.benchmark_group("complex_vs_real_throughput");
    let n = 1_000_000usize;
    group.throughput(Throughput::Elements(n as u64));

    let rng = random::default_rng();
    if let (Ok(a_real), Ok(b_real)) = (rng.random::<f64>(&[n]), rng.random::<f64>(&[n])) {
        // Real f64 element-wise addition
        group.bench_function("real_add_f64", |bencher| {
            bencher.iter(|| {
                black_box(a_real.add(&b_real));
            });
        });

        // Complex element-wise addition (Array<Complex<f64>>.add is non-Result)
        let a_complex = to_complex(&a_real);
        let b_complex = to_complex(&b_real);
        group.bench_function("complex_add", |bencher| {
            bencher.iter(|| {
                black_box(a_complex.add(&b_complex));
            });
        });
    }

    // Suppress unused-import warning for Complex (used for type annotation in doc)
    let _ = Complex::<f64>::new(0.0, 0.0);

    group.finish();
}

criterion_group!(
    complex_benches,
    bench_complex_construction,
    bench_complex_unary_ops,
    bench_from_polar,
    bench_complex_vs_real_throughput,
);
criterion_main!(complex_benches);