numrs2 0.2.0

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

//! Mathematical functions for NumRS2 arrays
//!
//! This module provides comprehensive mathematical operations for arrays,
//! organized into logical submodules:
//!
//! - `elementwise` - SIMD-optimized element-wise operations (sin, cos, exp, log, etc.)
//! - `creation` - Array creation functions (zeros, ones, linspace, meshgrid, etc.)
//! - `diff` - Differentiation and integration (diff, trapz)
//! - `statistics` - Statistical functions (mean, std, var, cumsum, etc.)
//! - `aggregation` - Aggregation functions (sum, max, min, sort)
//! - `nan_handling` - NaN-aware functions (nansum, nanmean, nanstd, etc.)
//! - `search` - Search and binning (searchsorted, digitize, bincount)
//! - `checking` - Value checking (isnan, isinf, isfinite)
//! - `utilities` - Utility functions (gcd, lcm, copysign, etc.)
//! - `window` - Window functions (hanning, hamming, blackman, kaiser)
//! - `gradient` - Gradient and additional math functions
//! - `nan_extrema` - NaN-aware extrema functions
//!
//! # Example
//!
//! ```
//! use numrs2::prelude::*;
//! use numrs2::math::{linspace, mean, std};
//!
//! let x = linspace(0.0, 1.0, 100);
//! let mean_val = mean(&x, None, false).expect("mean failed");
//! let std_val = std(&x, None, 0, false).expect("std failed");
//! ```

// Submodules
mod aggregation;
mod checking;
mod creation;
mod diff;
mod elementwise;
mod gradient;
mod nan_extrema;
mod nan_handling;
mod search;
mod statistics;
mod utilities;
mod window;

// Re-export helper functions for use by submodules
pub(crate) use elementwise::{
    from_nd_array, should_use_simd, to_nd_array_f32, to_nd_array_f64, SIMD_THRESHOLD,
};

// Re-export everything from submodules

// Element-wise math trait and implementation
pub use elementwise::ElementWiseMath;

// Array creation functions
pub use creation::{
    angle, arange, complex_abs, conj, empty, geomspace, imag, linspace, logspace, meshgrid,
    meshgrid2d, mgrid, ogrid, ones, real, unwrap, zeros,
};

// Differentiation and integration
pub use diff::{diff, diff_extended, ediff1d, trapz};

// Statistics functions
pub use statistics::{
    argmax, argmin, argsort, around, clip, cumprod, cumsum, mean, prod, resize, std, var,
};

// Aggregation functions
pub use aggregation::{
    amax, amin, argpartition, cumulative_prod, cumulative_sum, max, min, round, sort, sum,
};

// NaN-handling functions
pub use nan_handling::{
    nancumsum, nanmax, nanmean, nanmin, nanpercentile, nanprod, nanquantile, nanstd, nansum, nanvar,
};

// Search and binning functions
pub use search::{bincount, digitize, interp, median, partition, searchsorted};

// Value checking functions
pub use checking::{
    count_nonzero, flatnonzero, iscomplex, isfinite, isinf, isnan, isneginf, isnormal, isposinf,
    isreal, nan_to_num, nonzero,
};

// Utility functions
pub use utilities::{
    copysign, divmod, fmod, frexp, gcd, heaviside, lcm, ldexp, modf, nextafter, real_if_close,
    remainder, sinc,
};

// Window functions
pub use window::{bartlett, blackman, hamming, hanning, i0, kaiser};

// Gradient and additional math functions
pub use gradient::{
    fix, fmax, fmin, gradient, negative, positive, reciprocal, rint, signbit, GradientSpacing,
};

// NaN-aware extrema functions
pub use nan_extrema::{nanargmax, nanargmin, nancumprod};