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
287
288
289
290
291
292
293
294
295
use num_complex::Complex;
use std::ffi::{c_float, c_int};
#[link(name = "Accelerate", kind = "framework")]
extern "C" {
/// Sets all elements in the single-precision complex vector `x` to the given complex value `alpha`.
///
/// # Precision
/// This function operates on `Complex<f32>` complex numbers.
///
/// # Parameters
/// - `n`: The number of elements in the vector `x`.
/// - `alpha`: A pointer to the complex value to set all elements of `x`.
/// - `x`: A pointer to the vector to be modified in-place.
/// - `inc_x`: The increment between elements in `x`.
///
/// # Safety
/// This is an `unsafe` C function, and it is the caller's responsibility to ensure that
/// the memory region accessed by `x` (up to `n * inc_x`) is valid and within bounds.
#[link_name = "catlas_cset"]
pub fn set(n: c_int, alpha: *const Complex<c_float>, x: *mut Complex<c_float>, inc_x: c_int);
/// Computes the dot product of the complex conjugate of the first single-precision complex vector `X`
/// with the second single-precision complex vector `Y`.
///
/// # Precision
/// This function operates on `Complex<f32>` numbers.
///
/// # Parameters
/// - `n`: The number of elements in the vectors.
/// - `x`: A pointer to the first input vector of complex numbers (complex conjugate).
/// - `inc_x`: The increment between elements in `x`.
/// - `y`: A pointer to the second input vector of complex numbers.
/// - `inc_y`: The increment between elements in `y`.
/// - `dotc`: A pointer to store the result of the dot product (complex conjugate).
///
/// # Safety
/// This is an `unsafe` C function. The caller must ensure that the memory regions accessed by `x` and `y`
/// (up to `n * inc_x` and `n * inc_y`) are valid and within bounds, and that the memory pointed to by `dotc` is valid.
#[link_name = "cblas_cdotc_sub"]
pub fn dot_conj_plus(
n: c_int,
x: *const Complex<c_float>,
inc_x: c_int,
y: *const Complex<c_float>,
inc_y: c_int,
dotc: *mut Complex<c_float>,
);
/// Computes the dot product of two single-precision complex vectors `X` and `Y`, without conjugating the first vector.
///
/// # Precision
/// This function operates on `Complex<f32>` numbers.
///
/// # Parameters
/// - `n`: The number of elements in the vectors `X` and `Y`.
/// - `x`: A pointer to the first input vector of `Complex<f32>` numbers.
/// - `inc_x`: The increment between elements in `x`.
/// - `y`: A pointer to the second input vector of `Complex<f32>` numbers.
/// - `inc_y`: The increment between elements in `y`.
/// - `dotu`: A pointer to store the result of the dot product (`Complex<f32>`).
///
/// # Safety
/// This is an `unsafe` C function. The caller must ensure that the memory regions accessed by `x` and `y`
/// (up to `n * inc_x` and `n * inc_y`) are valid and within bounds, and that the memory pointed to by `dotu` is valid.
#[link_name = "cblas_cdotu_sub"]
pub fn dot_unconj_plus(
n: c_int,
x: *const Complex<c_float>,
inc_x: c_int,
y: *const Complex<c_float>,
inc_y: c_int,
dotu: *mut Complex<c_float>,
);
/// Computes a constant times a vector plus a vector (single-precision complex).
///
/// `Y = alpha * X + Y`
///
/// This function modifies the vector `Y` in-place.
///
/// # Precision
/// This function operates on `f32` complex numbers.
///
/// # Parameters
/// - `n`: The number of elements in the vectors `X` and `Y`.
/// - `alpha`: A pointer to the complex scalar that scales vector `X`.
/// - `x`: A pointer to the input vector `X` (of complex numbers).
/// - `inc_x`: The stride between elements in vector `X`.
/// - `y`: A pointer to the input/output vector `Y` (of complex numbers).
/// - `inc_y`: The stride between elements in vector `Y`.
///
/// # Safety
/// This is an `unsafe` function. The caller must ensure that the memory regions pointed to by `x` and `y` are valid
/// and that accessing the data up to `n * inc_x` and `n * inc_y` is safe.
#[link_name = "cblas_caxpy"]
pub fn scaled_plus(
n: c_int, // Number of elements in vectors
alpha: *const Complex<c_float>, // Scaling factor for X (complex scalar)
x: *const Complex<c_float>, // Input vector X
inc_x: c_int, // Stride within X
y: *mut Complex<c_float>, // Input/output vector Y
inc_y: c_int, // Stride within Y
);
/// Copies a vector to another vector (single-precision complex).
///
/// Copies the elements from the vector `X` to the vector `Y`.
///
/// # Precision
/// This function operates on `f32` complex numbers.
///
/// # Parameters
/// - `n`: The number of elements in the vectors `X` and `Y`.
/// - `x`: A pointer to the source vector `X` (complex numbers).
/// - `inc_x`: The stride between elements in vector `X`.
/// - `y`: A pointer to the destination vector `Y` (complex numbers).
/// - `inc_y`: The stride between elements in vector `Y`.
///
/// # Safety
/// This is an `unsafe` function. The caller must ensure that the memory regions pointed to by `x` and `y` are valid
/// and that accessing the data up to `n * inc_x` and `n * inc_y` is safe.
#[link_name = "cblas_ccopy"]
pub fn copy(
n: c_int, // Number of elements in vectors
x: *const Complex<c_float>, // Source vector X
inc_x: c_int, // Stride within X
y: *mut Complex<c_float>, // Destination vector Y
inc_y: c_int, // Stride within Y
);
/// Multiplies each element of a complex vector by a constant scaling factor.
///
/// # Precision
/// This function operates on single-precision complex numbers (`Complex<f32>`).
///
/// # Parameters
/// - `n`: The number of elements in the vector `X`.
/// - `alpha`: A pointer to the constant scaling factor.
/// - `x`: A pointer to the input/output vector `X`. The result is stored in-place.
/// - `inc_x`: The stride between elements in `X`. For example, if `inc_x` is 7, every 7th element of `X` is used.
///
/// # Safety
/// This is an `unsafe` C function. The caller must ensure that the memory regions accessed by `x` are valid and that the stride `inc_x` is correctly set.
///
/// # Discussion
/// The function scales each element in the vector `X` by a constant value `alpha`, modifying `X` in place.
#[link_name = "cblas_cscal"]
pub fn scale_by_c32(
n: c_int,
alpha: *const Complex<c_float>,
x: *mut Complex<c_float>,
inc_x: c_int,
);
/// Multiplies each element of a complex vector `X` by a constant scalar `alpha`.
///
/// # Precision
/// This function operates on single-precision complex numbers (`Complex<f32>`).
///
/// # Parameters
/// - `n`: The number of elements in vector `X`.
/// - `alpha`: The constant scalar that scales each element of `X`.
/// - `x`: A pointer to the complex vector `X`, which is modified in place.
/// - `inc_x`: The increment (stride) between elements in `X`. For example, if `inc_x` is 7, every 7th element is used.
///
/// # Safety
/// This is an `unsafe` C function. The caller must ensure that the memory regions accessed by `X` are valid.
///
/// # Discussion
/// This function scales each element of the complex vector `X` by the constant `alpha`.
#[link_name = "cblas_csscal"]
pub fn scale_by_f32(n: c_int, alpha: c_float, x: *mut Complex<c_float>, inc_x: c_int);
/// Exchanges the elements of two complex vectors `X` and `Y`.
///
/// # Precision
/// This function operates on single-precision complex numbers (`Complex<f32>`).
///
/// # Parameters
/// - `n`: The number of elements in vectors `X` and `Y`.
/// - `x`: A pointer to the first complex vector `X`. On return, contains elements copied from vector `Y`.
/// - `inc_x`: The increment (stride) between elements in `X`. For example, if `inc_x` is 7, every 7th element is used.
/// - `y`: A pointer to the second complex vector `Y`. On return, contains elements copied from vector `X`.
/// - `inc_y`: The increment (stride) between elements in `Y`. For example, if `inc_y` is 7, every 7th element is used.
///
/// # Safety
/// This is an `unsafe` C function. The caller must ensure that the memory regions accessed by `X` and `Y` are valid and within bounds.
///
/// # Discussion
/// This function swaps the elements between two complex vectors `X` and `Y` in place.
#[link_name = "cblas_cswap"]
pub fn swap(
n: c_int,
x: *mut Complex<c_float>,
inc_x: c_int,
y: *mut Complex<c_float>,
inc_y: c_int,
);
/// Computes the sum of the absolute values of real and imaginary parts of elements in a vector (single-precision complex).
///
/// # Precision
/// This function operates on single-precision complex numbers (`Complex<f32>`).
///
/// # Parameters
/// - `n`: The number of elements in the vector `X`.
/// - `x`: A pointer to the source vector `X` (stored as single-precision complex numbers).
/// - `inc_x`: The stride between elements in `X`. For example, if `inc_x = 7`, every 7th element is used.
///
/// # Return Value
/// Returns a single floating-point value containing the sum of the absolute values of both the real and imaginary parts of the vector.
///
/// # Safety
/// This is an `unsafe` C function. The caller must ensure that the memory regions accessed by `x` are valid.
#[link_name = "cblas_scasum"]
pub fn norm1(
n: c_int, // Number of elements in the vector
x: *const Complex<c_float>, // Pointer to source vector X
inc_x: c_int, // Stride within vector X
) -> c_float;
/// Computes the unitary norm (Euclidean norm or 2-norm) of a vector (single-precision complex).
///
/// # Precision
/// This function operates on single-precision complex numbers (`Complex<f32>`).
///
/// # Parameters
/// - `n`: The length of the vector `X`.
/// - `x`: A pointer to the vector `X` (stored as single-precision complex numbers).
/// - `inc_x`: The stride between elements in `X`. For example, if `inc_x = 7`, every 7th element is used.
///
/// # Return Value
/// Returns the unitary norm (Euclidean norm) of the vector.
///
/// # Safety
/// This is an `unsafe` C function. The caller must ensure that the memory regions accessed by `x` are valid.
#[link_name = "cblas_scnrm2"]
pub fn norm2(
n: c_int, // Length of vector X
x: *const Complex<c_float>, // Pointer to vector X
inc_x: c_int, // Stride within vector X
) -> c_float;
/// Finds the index of the element with the largest absolute value in the single-precision complex vector `x`.
///
/// # Precision
/// This function operates on `Complex<f32>` numbers.
///
/// # Parameters
/// - `n`: The number of elements in the vector `x`.
/// - `x`: A pointer to the input vector of `Complex<f32>` numbers.
/// - `inc_x`: The increment between elements in `x`.
///
/// # Returns
/// - The index of the element with the largest absolute value.
///
/// # Safety
/// This is an `unsafe` C function. The caller must ensure that the memory region accessed by `x`
/// (up to `n * inc_x`) is valid and within bounds.
#[link_name = "cblas_icamax"]
pub fn argmax_mod(n: c_int, x: *const Complex<c_float>, inc_x: c_int) -> c_int;
/// Computes the linear combination of two single-precision complex vectors `x` and `y` as:
/// `y = alpha * x + beta * y`.
/// This modifies the `y` vector in-place.
///
/// # Precision
/// This function operates on `Complex<f32>` complex numbers.
///
/// # Parameters
/// - `n`: The number of elements in the vectors `x` and `y`.
/// - `alpha`: A pointer to the scalar that scales the `x` vector.
/// - `x`: A pointer to the first input vector of complex numbers.
/// - `inc_x`: The increment between elements in `x`.
/// - `beta`: A pointer to the scalar that scales the `y` vector.
/// - `y`: A pointer to the second input vector, which stores the result in-place.
/// - `inc_y`: The increment between elements in `y`.
///
/// # Safety
/// This is an `unsafe` C function, and it is the caller's responsibility to ensure that
/// the memory regions accessed by `x` and `y` (up to `n * inc_x` and `n * inc_y` respectively)
/// are valid and within bounds.
#[link_name = "catlas_caxpby"]
pub fn lin_comb_c32_catlas(
n: c_int,
alpha: *const Complex<c_float>,
x: *const Complex<c_float>,
inc_x: c_int,
beta: *const Complex<c_float>,
y: *mut Complex<c_float>,
inc_y: c_int,
);
}