rustify-ml 0.1.2

Profile Python hotspots and auto-generate Rust + PyO3 stubs via maturin
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

�

��i�����SrSSKJr SSjrSSjrSSjrSSjrSSjr\S:XGa9SS	K	r	S
r
\"\
5Vs/sHn\"US-5PM snr
/SQrS
r\"S\
S\S35 \	R""5r\"\5Hr\"\
\5 M \	R""5\-
r\"S\SS\\-S-SS35 \	R""5r\"\5Hr\"\
S5 M \	R""5\-
r\"S\SS\\-S-SS35 \	R""5r\"\5Hr\"\
5 M
 \	R""5\-
r\"S\SS\\-S-SS35 g	g	s snf)u
scipy.signal-style 1D signal processing — rustify-ml acceleration targets.

Pure-Python implementations of common signal processing operations.
The nested for-loop patterns translate cleanly to Rust with zero fallbacks.

Expected Rust speedup: 10–40x via Vec<f64> + nested loops.
�)�annotationsc���[U5n[U5nS/X#-
S--n[X#-
S-5H)nSn[U5HnX`XW-X--
nM XdU'M+ U$)z�1D convolution: output[i] = sum(signal[i+j] * kernel[j] for j in range(k)).

Equivalent to scipy.signal.convolve(signal, kernel, mode='valid').
����len�range)�signal�kernel�n�k�result�i�total�js        �Dd:\WindsurfProjects\rustify\rustify-ml\examples\signal_processing.py�
convolve1dr
ss��
	�F��A��F��A��U�a�e�a�i�
 �F�
�1�5�1�9�
�����q��A��A�E�]�V�Y�.�.�E���q�	�	�
�M�c��[U5nS/X!-
S--n[X!-
S-5H&nSn[U5HnXPXF--
nM XQ-X4'M( U$)z�Sliding window mean: result[i] = mean(signal[i:i+window]).

Equivalent to pandas rolling(window).mean() or scipy uniform_filter1d.
rrr)r
�windowrrrrrs       r�moving_averagerse��
	�F��A��U�a�j�1�n�
%�F�
�1�:��>�
"�����v��A��A�E�]�"�E���N��	�	#�
�Mrc��[U5n[U5nX2-
S-nS/U-n[U5H*nSn[U5HnXpUXU---
nM XuU'M, U$)zp1D cross-correlation: output[i] = sum(a[j] * b[j+i] for j).

Equivalent to numpy.correlate(a, b, mode='valid').
rrr)	�a�br�m�out_lenrrrrs	         r�cross_correlater,sq��
	�A��A��A��A��e�a�i�G��U�W�_�F�
�7�^�����q��A��q�T�A�!�e�H�_�$�E���q�	�	�
�Mrc�t�[U5nS/US-
-n[US-
5HnXS-X-
X#'M U$)z`First-order difference: result[i] = signal[i+1] - signal[i].

Equivalent to numpy.diff(signal).
rrr)r
rrrs    r�diffr=sG��
	�F��A��U�a�!�e�_�F�
�1�q�5�\���q�5�M�F�I�-��	���Mrc�f�[U5nS/U-nSn[U5HnX0U-
nX2U'M U$)zUCumulative sum: result[i] = sum(signal[0:i+1]).

Equivalent to numpy.cumsum(signal).
rr)r
rrrrs     r�cumsumr!IsE��
	�F��A��U�Q�Y�F��E�
�1�X��
������q�	���Mr�__main__Ni'�d)��?g�?r$i�z"Benchmarking signal processing (n=z, iters=z)...z  convolve1d (k=3):    z.3fzs (i�z.2fzms/call)�
z  moving_average (w=10): z  cumsum:              )r
�listrr&�returnr&)r
r&r�intr'r&)rr&rr&r'r&)r
r&r'r&)�__doc__�
__future__rrrrrr!�__name__�timerr	�floatr
r�n_iters�print�perf_counter�start�_�elapsed)rs0r�<module>r4s����#�
� ��"	���z����A�&+�A�h�
/�h��e�A��G�n�h�
/�F�
�F��G�	�.�q�c��'��$�
G�H�����E�
�7�^���6�6�"�����!�E�)�G�	�#�G�C�=��G�G�O�D�4H��3M�X�
V�W�����E�
�7�^���v�r�"�����!�E�)�G�	�%�g�c�]�#�g�g�o�d�6J�3�5O�x�
X�Y�����E�
�7�^���v������!�E�)�G�	�#�G�C�=��G�G�O�D�4H��3M�X�
V�W�5��0s�E#