ferray 0.2.8

A NumPy-equivalent library for Rust — N-dimensional arrays with SIMD acceleration
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
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286

// ferray: Main re-export crate providing `use ferray::prelude::*`
//
// This is the top-level crate that users depend on. It re-exports all
// subcrates into a unified namespace, matching NumPy's `import numpy as np`.

pub mod config;
pub mod prelude;

// ---------------------------------------------------------------------------
// REQ-1: Top-level namespace — core types and creation functions
// ---------------------------------------------------------------------------

// Core types
pub use ferray_core::ArcArray;
pub use ferray_core::Array;
pub use ferray_core::ArrayFlags;
pub use ferray_core::ArrayView;
pub use ferray_core::ArrayViewMut;
pub use ferray_core::AsRawBuffer;
pub use ferray_core::CowArray;
pub use ferray_core::DynArray;
pub use ferray_core::FerrayRecord;
pub use ferray_core::FieldDescriptor;

// Dimension types
pub use ferray_core::dimension::{self, Axis, Dimension, Ix0, Ix1, Ix2, Ix3, Ix4, Ix5, Ix6, IxDyn};

// Dtype system
pub use ferray_core::dtype::casting;
pub use ferray_core::dtype::finfo;
pub use ferray_core::dtype::promotion;
pub use ferray_core::{DType, Element, SliceInfoElem};

// Error handling
pub use ferray_core::{FerrayError, FerrayResult};

// Memory layout
pub use ferray_core::MemoryLayout;

// Macros
pub use ferray_core::{FerrayRecord as DeriveFerrayRecord, promoted_type, s};

// Type aliases
pub use ferray_core::aliases;

// Display configuration
pub use ferray_core::array::display::{get_print_options, set_print_options};

// ---------------------------------------------------------------------------
// REQ-3a: Constants (ferray::PI, ferray::INF, etc.)
// ---------------------------------------------------------------------------

pub use ferray_core::constants::{E, EULER_GAMMA, INF, NAN, NEG_INF, NEWAXIS, NZERO, PI, PZERO};

// ---------------------------------------------------------------------------
// REQ-1: Array creation functions at top level
// ---------------------------------------------------------------------------

pub use ferray_core::creation::{
    arange, array, asarray, diag, diagflat, empty, eye, frombuffer, fromiter, full, full_like,
    geomspace, identity, linspace, logspace, meshgrid, mgrid, ogrid, ones, ones_like, tri, tril,
    triu, zeros, zeros_like,
};

// ---------------------------------------------------------------------------
// REQ-1: Manipulation functions at top level
// ---------------------------------------------------------------------------

pub use ferray_core::manipulation::{
    array_split, block, broadcast_to, concatenate, dsplit, dstack, expand_dims, flatten, flip,
    fliplr, flipud, hsplit, hstack, moveaxis, ravel, reshape, roll, rollaxis, rot90, split,
    squeeze, stack, swapaxes, transpose, vsplit, vstack,
};

pub use ferray_core::manipulation::extended::{
    append, delete, insert, pad, repeat, resize, tile, trim_zeros,
};

// Indexing
pub use ferray_core::indexing::extended::{
    choose, compress, diag_indices, diag_indices_from, flatnonzero, indices, ix_,
    ndenumerate, ndindex, ravel_multi_index, select, take, take_along_axis, tril_indices,
    tril_indices_from, triu_indices, triu_indices_from, unravel_index,
};

// ---------------------------------------------------------------------------
// REQ-1: Ufunc functions at top level
// ---------------------------------------------------------------------------

// Trigonometric
pub use ferray_ufunc::{
    arccos, arccosh, arcsin, arcsinh, arctan, arctan2, arctanh, cos, cosh, deg2rad, degrees, hypot,
    rad2deg, radians, sin, sinh, tan, tanh, unwrap,
};

// Exponential and logarithmic
pub use ferray_ufunc::{
    exp, exp_fast, exp2, expm1, log, log1p, log2, log10, logaddexp, logaddexp2,
};

// Rounding
pub use ferray_ufunc::{around, ceil, fix, floor, rint, round, trunc};

// Arithmetic
pub use ferray_ufunc::{
    absolute, add, add_accumulate, add_broadcast, add_reduce, cbrt, cross, cumprod, cumsum, diff,
    divide, divide_broadcast, divmod, ediff1d, fabs, floor_divide, fmod, gcd, gradient, heaviside,
    lcm, mod_, multiply, multiply_broadcast, multiply_outer, nancumprod, nancumsum, negative,
    positive, power, reciprocal, remainder, sign, sqrt, square, subtract, subtract_broadcast,
    trapezoid, true_divide,
};

// Float intrinsics
pub use ferray_ufunc::{
    clip, copysign, float_power, fmax, fmin, frexp, isfinite, isinf, isnan, isneginf, isposinf,
    ldexp, maximum, minimum, nan_to_num, nextafter, signbit, spacing,
};

// Complex
pub use ferray_ufunc::{abs, angle, conj, conjugate, imag, real};

// Bitwise
pub use ferray_ufunc::{
    bitwise_and, bitwise_not, bitwise_or, bitwise_xor, invert, left_shift, right_shift,
};

// Comparison
pub use ferray_ufunc::{
    allclose, array_equal, array_equiv, equal, greater, greater_equal, isclose, less, less_equal,
    not_equal,
};

// Logical
pub use ferray_ufunc::{all, any, logical_and, logical_not, logical_or, logical_xor};

// Special
pub use ferray_ufunc::{i0, sinc};

// Convolution and interpolation
pub use ferray_ufunc::{ConvolveMode, convolve, interp, interp_one};

// Operator-style functions
pub use ferray_ufunc::{
    array_add, array_bitand, array_bitnot, array_bitor, array_bitxor, array_div, array_mul,
    array_neg, array_rem, array_shl, array_shr, array_sub,
};

// ---------------------------------------------------------------------------
// REQ-1: Stats functions at top level
// ---------------------------------------------------------------------------

// Reductions
pub use ferray_stats::{
    argmax, argmin, cumprod as stats_cumprod, cumsum as stats_cumsum, max, mean, min, prod, std_,
    sum, var,
};

// Quantile-based
pub use ferray_stats::{median, percentile, quantile};

// NaN-aware reductions
pub use ferray_stats::{
    nancumprod as stats_nancumprod, nancumsum as stats_nancumsum, nanmax, nanmean, nanmedian,
    nanmin, nanpercentile, nanprod, nanstd, nansum, nanvar,
};

// Correlation and covariance
pub use ferray_stats::{CorrelateMode, corrcoef, correlate, cov};

// Histogram
pub use ferray_stats::{Bins, bincount, digitize, histogram, histogram2d, histogramdd};

// Sorting and searching
pub use ferray_stats::{Side, SortKind, argsort, searchsorted, sort};
pub use ferray_stats::{UniqueResult, count_nonzero, nonzero, unique, where_};

// Set operations
pub use ferray_stats::{in1d, intersect1d, isin, setdiff1d, setxor1d, union1d};

// ---------------------------------------------------------------------------
// REQ-2: Submodule namespaces
// ---------------------------------------------------------------------------

/// I/O operations: .npy, .npz, text files, memory mapping.
#[cfg(feature = "io")]
pub use ferray_io as io;

/// Linear algebra operations.
#[cfg(feature = "linalg")]
pub use ferray_linalg as linalg;

/// FFT operations.
#[cfg(feature = "fft")]
pub use ferray_fft as fft;

/// Random number generation and distributions.
#[cfg(feature = "random")]
pub use ferray_random as random;

/// Polynomial operations.
#[cfg(feature = "polynomial")]
pub use ferray_polynomial as polynomial;

/// Window functions.
#[cfg(feature = "window")]
pub use ferray_window as window;

/// String operations on character arrays.
#[cfg(feature = "strings")]
pub use ferray_strings as strings;

/// Masked arrays.
#[cfg(feature = "ma")]
pub use ferray_ma as ma;

/// Stride manipulation utilities.
#[cfg(feature = "stride-tricks")]
pub use ferray_stride_tricks as stride_tricks;

/// Python/NumPy interop via PyO3.
#[cfg(feature = "numpy")]
pub use ferray_numpy_interop as numpy_interop;

// ---------------------------------------------------------------------------
// REQ-6, REQ-7: Thread pool configuration re-exports
// ---------------------------------------------------------------------------

pub use config::{set_num_threads, with_num_threads};

// ---------------------------------------------------------------------------
// REQ-8: Parallel threshold constants
// ---------------------------------------------------------------------------

/// Parallel threshold configuration constants.
pub mod threshold {
    pub use crate::config::{
        PARALLEL_THRESHOLD_COMPUTE, PARALLEL_THRESHOLD_ELEMENTWISE, PARALLEL_THRESHOLD_REDUCTION,
        PARALLEL_THRESHOLD_SORT,
    };
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn constants_accessible_ac7() {
        assert_eq!(PI, std::f64::consts::PI);
        assert_eq!(E, std::f64::consts::E);
        assert_eq!(INF, f64::INFINITY);
        assert_eq!(NEG_INF, f64::NEG_INFINITY);
        assert!(NAN.is_nan());
    }

    #[test]
    fn prelude_compiles_ac1() {
        use crate::prelude::*;
        // Verify core types are accessible
        let arr = zeros::<f64, Ix2>(Ix2::new([2, 3])).unwrap();
        assert_eq!(arr.shape(), &[2, 3]);
        let _: &[usize] = arr.shape();
    }

    #[test]
    fn creation_at_toplevel() {
        let a = zeros::<f64, Ix1>(Ix1::new([5])).unwrap();
        assert_eq!(a.size(), 5);
        let b = ones::<f64, Ix1>(Ix1::new([3])).unwrap();
        assert_eq!(b.size(), 3);
        let c = arange(0i32, 10, 2).unwrap();
        assert_eq!(c.size(), 5);
    }

    #[test]
    fn ufuncs_at_toplevel() {
        let a = ones::<f64, Ix1>(Ix1::new([4])).unwrap();
        let s = sin(&a).unwrap();
        assert_eq!(s.shape(), &[4]);
    }

    #[test]
    fn threshold_constants_accessible() {
        assert!(threshold::PARALLEL_THRESHOLD_ELEMENTWISE > 0);
        assert!(threshold::PARALLEL_THRESHOLD_COMPUTE > 0);
    }
}