1#![allow(nonstandard_style)]
3#[cfg(not(target_pointer_width = "64"))]
4compile_error!("The bindings are only valid for 64-bit applications. All Matlab versions after 2015b are only available in 64-bit.");
5pub type FILE = _iobuf;
6pub type mwSize = usize;
7pub type mwIndex = usize;
8pub type mwSignedIndex = isize;
9#[doc = " Forward declaration for mxArray"]
10pub type mxArray = mxArray_tag;
11#[doc = " MEX-file entry point type"]
12pub type mxFunctionPtr = ::core::option::Option<
13 unsafe extern "C" fn(
14 nlhs: ::core::ffi::c_int,
15 plhs: *mut *mut mxArray,
16 nrhs: ::core::ffi::c_int,
17 prhs: *mut *mut mxArray,
18 ),
19>;
20#[doc = " Logical type"]
21pub type mxLogical = bool;
22#[doc = " Required for Unicode support in MATLAB"]
23pub type mxChar = u16;
24pub type mex_exit_fn = ::core::option::Option<unsafe extern "C" fn()>;
25pub type MATFile = MatFile_tag;
26pub type matError = ::core::ffi::c_int;
27pub type Engine = engine;
28#[repr(C)]
29#[derive(Debug, Copy, Clone)]
30pub struct _iobuf {
31 pub _Placeholder: *mut ::core::ffi::c_void,
32}
33#[repr(C)]
34#[derive(Debug, Copy, Clone)]
35pub struct mxArray_tag {
36 _unused: [u8; 0],
37}
38#[repr(C)]
39#[derive(Debug, Copy, Clone)]
40pub struct mxComplexDouble {
41 pub real: f64,
42 pub imag: f64,
43}
44#[repr(C)]
45#[derive(Debug, Copy, Clone)]
46pub struct mxComplexSingle {
47 pub real: f32,
48 pub imag: f32,
49}
50#[repr(C)]
51pub struct mxComplexInt8 {
52 pub real: i8,
53 pub imag: i8,
54}
55#[repr(C)]
56pub struct mxComplexUint8 {
57 pub real: u8,
58 pub imag: u8,
59}
60#[repr(C)]
61pub struct mxComplexInt16 {
62 pub real: i16,
63 pub imag: i16,
64}
65#[repr(C)]
66pub struct mxComplexUint16 {
67 pub real: u16,
68 pub imag: u16,
69}
70#[repr(C)]
71pub struct mxComplexInt32 {
72 pub real: i32,
73 pub imag: i32,
74}
75#[repr(C)]
76pub struct mxComplexUint32 {
77 pub real: u32,
78 pub imag: u32,
79}
80#[repr(C)]
81pub struct mxComplexInt64 {
82 pub real: i64,
83 pub imag: i64,
84}
85#[repr(C)]
86pub struct mxComplexUint64 {
87 pub real: u64,
88 pub imag: u64,
89}
90#[repr(C)]
91#[derive(Debug, Copy, Clone)]
92pub struct MatFile_tag {
93 _unused: [u8; 0],
94}
95#[repr(C)]
96#[derive(Debug, Copy, Clone)]
97pub struct engine {
98 _unused: [u8; 0],
99}
100pub const MWSIZE_MAX: u64 = 281474976710655;
101pub const MWINDEX_MAX: u64 = 281474976710655;
102pub const MWSINDEX_MAX: u64 = 281474976710655;
103pub const MWSINDEX_MIN: i64 = -281474976710655;
104pub const MWSIZE_MIN: u32 = 0;
105pub const MWINDEX_MIN: u32 = 0;
106pub const mxMAXNAM: u32 = 64;
107pub mod mxClassID {
108 #[doc = " mxArray classes."]
109 pub type Type = i32;
110 pub const mxUNKNOWN_CLASS: Type = 0;
111 pub const mxCELL_CLASS: Type = 1;
112 pub const mxSTRUCT_CLASS: Type = 2;
113 pub const mxLOGICAL_CLASS: Type = 3;
114 pub const mxCHAR_CLASS: Type = 4;
115 pub const mxVOID_CLASS: Type = 5;
116 pub const mxDOUBLE_CLASS: Type = 6;
117 pub const mxSINGLE_CLASS: Type = 7;
118 pub const mxINT8_CLASS: Type = 8;
119 pub const mxUINT8_CLASS: Type = 9;
120 pub const mxINT16_CLASS: Type = 10;
121 pub const mxUINT16_CLASS: Type = 11;
122 pub const mxINT32_CLASS: Type = 12;
123 pub const mxUINT32_CLASS: Type = 13;
124 pub const mxINT64_CLASS: Type = 14;
125 pub const mxUINT64_CLASS: Type = 15;
126 pub const mxFUNCTION_CLASS: Type = 16;
127 pub const mxOPAQUE_CLASS: Type = 17;
128 pub const mxOBJECT_CLASS: Type = 18;
129 pub const mxINDEX_CLASS: Type = 15;
130}
131pub mod mxComplexity {
132 #[doc = " Indicates whether floating-point mxArrays are real or complex."]
133 pub type Type = i32;
134 pub const mxREAL: Type = 0;
135 pub const mxCOMPLEX: Type = 1;
136}
137extern "C" {
138 #[link_name = "\u{1}mxMalloc_800"]
139 pub fn mxMalloc(n: usize) -> *mut ::core::ffi::c_void;
140 #[link_name = "\u{1}mxCalloc_800"]
141 pub fn mxCalloc(n: usize, size: usize) -> *mut ::core::ffi::c_void;
142 #[link_name = "\u{1}mxFree_800"]
143 pub fn mxFree(ptr: *mut ::core::ffi::c_void);
144 #[link_name = "\u{1}mxRealloc_800"]
145 pub fn mxRealloc(ptr: *mut ::core::ffi::c_void, size: usize) -> *mut ::core::ffi::c_void;
146 #[link_name = "\u{1}mxGetNumberOfDimensions_800"]
147 pub fn mxGetNumberOfDimensions(pa: *const mxArray) -> mwSize;
148 #[link_name = "\u{1}mxGetDimensions_800"]
149 pub fn mxGetDimensions(pa: *const mxArray) -> *const mwSize;
150 #[link_name = "\u{1}mxGetM_800"]
151 pub fn mxGetM(pa: *const mxArray) -> usize;
152 #[link_name = "\u{1}mxGetIr_800"]
153 pub fn mxGetIr(pa: *const mxArray) -> *mut mwIndex;
154 #[link_name = "\u{1}mxGetJc_800"]
155 pub fn mxGetJc(pa: *const mxArray) -> *mut mwIndex;
156 #[link_name = "\u{1}mxGetNzmax_800"]
157 pub fn mxGetNzmax(pa: *const mxArray) -> mwSize;
158 #[link_name = "\u{1}mxSetNzmax_800"]
159 pub fn mxSetNzmax(pa: *mut mxArray, nzmax: mwSize);
160 #[link_name = "\u{1}mxGetFieldNameByNumber_800"]
161 pub fn mxGetFieldNameByNumber(
162 pa: *const mxArray,
163 n: ::core::ffi::c_int,
164 ) -> *const ::core::ffi::c_char;
165 #[link_name = "\u{1}mxGetFieldByNumber_800"]
166 pub fn mxGetFieldByNumber(
167 pa: *const mxArray,
168 i: mwIndex,
169 fieldnum: ::core::ffi::c_int,
170 ) -> *mut mxArray;
171 #[link_name = "\u{1}mxGetCell_800"]
172 pub fn mxGetCell(pa: *const mxArray, i: mwIndex) -> *mut mxArray;
173 #[link_name = "\u{1}mxGetClassID_800"]
174 pub fn mxGetClassID(pa: *const mxArray) -> mxClassID::Type;
175 #[link_name = "\u{1}mxGetData_800"]
176 pub fn mxGetData(pa: *const mxArray) -> *mut ::core::ffi::c_void;
177 #[link_name = "\u{1}mxSetData_800"]
178 pub fn mxSetData(pa: *mut mxArray, newdata: *mut ::core::ffi::c_void);
179 #[link_name = "\u{1}mxIsNumeric_800"]
180 pub fn mxIsNumeric(pa: *const mxArray) -> bool;
181 #[link_name = "\u{1}mxIsCell_800"]
182 pub fn mxIsCell(pa: *const mxArray) -> bool;
183 #[link_name = "\u{1}mxIsLogical_800"]
184 pub fn mxIsLogical(pa: *const mxArray) -> bool;
185 #[link_name = "\u{1}mxIsScalar_800"]
186 pub fn mxIsScalar(pa: *const mxArray) -> bool;
187 #[link_name = "\u{1}mxIsChar_800"]
188 pub fn mxIsChar(pa: *const mxArray) -> bool;
189 #[link_name = "\u{1}mxIsStruct_800"]
190 pub fn mxIsStruct(pa: *const mxArray) -> bool;
191 #[link_name = "\u{1}mxIsOpaque_800"]
192 pub fn mxIsOpaque(pa: *const mxArray) -> bool;
193 #[link_name = "\u{1}mxIsFunctionHandle_800"]
194 pub fn mxIsFunctionHandle(pa: *const mxArray) -> bool;
195 #[link_name = "\u{1}mxIsObject_800"]
196 pub fn mxIsObject(pa: *const mxArray) -> bool;
197 #[link_name = "\u{1}mxIsComplex_800"]
198 pub fn mxIsComplex(pa: *const mxArray) -> bool;
199 #[link_name = "\u{1}mxIsSparse_800"]
200 pub fn mxIsSparse(pa: *const mxArray) -> bool;
201 #[link_name = "\u{1}mxIsDouble_800"]
202 pub fn mxIsDouble(pa: *const mxArray) -> bool;
203 #[link_name = "\u{1}mxIsSingle_800"]
204 pub fn mxIsSingle(pa: *const mxArray) -> bool;
205 #[link_name = "\u{1}mxIsInt8_800"]
206 pub fn mxIsInt8(pa: *const mxArray) -> bool;
207 #[link_name = "\u{1}mxIsUint8_800"]
208 pub fn mxIsUint8(pa: *const mxArray) -> bool;
209 #[link_name = "\u{1}mxIsInt16_800"]
210 pub fn mxIsInt16(pa: *const mxArray) -> bool;
211 #[link_name = "\u{1}mxIsUint16_800"]
212 pub fn mxIsUint16(pa: *const mxArray) -> bool;
213 #[link_name = "\u{1}mxIsInt32_800"]
214 pub fn mxIsInt32(pa: *const mxArray) -> bool;
215 #[link_name = "\u{1}mxIsUint32_800"]
216 pub fn mxIsUint32(pa: *const mxArray) -> bool;
217 #[link_name = "\u{1}mxIsInt64_800"]
218 pub fn mxIsInt64(pa: *const mxArray) -> bool;
219 #[link_name = "\u{1}mxIsUint64_800"]
220 pub fn mxIsUint64(pa: *const mxArray) -> bool;
221 #[link_name = "\u{1}mxGetNumberOfElements_800"]
222 pub fn mxGetNumberOfElements(pa: *const mxArray) -> usize;
223 #[link_name = "\u{1}mxGetChars_800"]
224 pub fn mxGetChars(pa: *const mxArray) -> *mut mxChar;
225 #[link_name = "\u{1}mxGetUserBits_800"]
226 pub fn mxGetUserBits(pa: *const mxArray) -> ::core::ffi::c_int;
227 #[link_name = "\u{1}mxSetUserBits_800"]
228 pub fn mxSetUserBits(pa: *mut mxArray, value: ::core::ffi::c_int);
229 #[link_name = "\u{1}mxGetScalar_800"]
230 pub fn mxGetScalar(pa: *const mxArray) -> f64;
231 #[link_name = "\u{1}mxIsFromGlobalWS_800"]
232 pub fn mxIsFromGlobalWS(pa: *const mxArray) -> bool;
233 #[link_name = "\u{1}mxSetFromGlobalWS_800"]
234 pub fn mxSetFromGlobalWS(pa: *mut mxArray, global: bool);
235 #[link_name = "\u{1}mxSetM_800"]
236 pub fn mxSetM(pa: *mut mxArray, m: mwSize);
237 #[link_name = "\u{1}mxGetN_800"]
238 pub fn mxGetN(pa: *const mxArray) -> usize;
239 #[link_name = "\u{1}mxIsEmpty_800"]
240 pub fn mxIsEmpty(pa: *const mxArray) -> bool;
241 #[link_name = "\u{1}mxGetFieldNumber_800"]
242 pub fn mxGetFieldNumber(
243 pa: *const mxArray,
244 name: *const ::core::ffi::c_char,
245 ) -> ::core::ffi::c_int;
246 #[link_name = "\u{1}mxSetIr_800"]
247 pub fn mxSetIr(pa: *mut mxArray, newir: *mut mwIndex);
248 #[link_name = "\u{1}mxSetJc_800"]
249 pub fn mxSetJc(pa: *mut mxArray, newjc: *mut mwIndex);
250 #[link_name = "\u{1}mxGetPr_800"]
251 pub fn mxGetPr(pa: *const mxArray) -> *mut f64;
252 #[link_name = "\u{1}mxSetPr_800"]
253 pub fn mxSetPr(pa: *mut mxArray, newdata: *mut f64);
254 #[link_name = "\u{1}mxGetElementSize_800"]
255 pub fn mxGetElementSize(pa: *const mxArray) -> usize;
256 #[link_name = "\u{1}mxCalcSingleSubscript_800"]
257 pub fn mxCalcSingleSubscript(
258 pa: *const mxArray,
259 nsubs: mwSize,
260 subs: *const mwIndex,
261 ) -> mwIndex;
262 #[link_name = "\u{1}mxGetNumberOfFields_800"]
263 pub fn mxGetNumberOfFields(pa: *const mxArray) -> ::core::ffi::c_int;
264 #[link_name = "\u{1}mxSetCell_800"]
265 pub fn mxSetCell(pa: *mut mxArray, i: mwIndex, value: *mut mxArray);
266 #[link_name = "\u{1}mxSetFieldByNumber_800"]
267 pub fn mxSetFieldByNumber(
268 pa: *mut mxArray,
269 i: mwIndex,
270 fieldnum: ::core::ffi::c_int,
271 value: *mut mxArray,
272 );
273 #[link_name = "\u{1}mxGetField_800"]
274 pub fn mxGetField(
275 pa: *const mxArray,
276 i: mwIndex,
277 fieldname: *const ::core::ffi::c_char,
278 ) -> *mut mxArray;
279 #[link_name = "\u{1}mxSetField_800"]
280 pub fn mxSetField(
281 pa: *mut mxArray,
282 i: mwIndex,
283 fieldname: *const ::core::ffi::c_char,
284 value: *mut mxArray,
285 );
286 #[link_name = "\u{1}mxGetProperty_800"]
287 pub fn mxGetProperty(
288 pa: *const mxArray,
289 i: mwIndex,
290 propname: *const ::core::ffi::c_char,
291 ) -> *mut mxArray;
292 #[link_name = "\u{1}mxSetProperty_800"]
293 pub fn mxSetProperty(
294 pa: *mut mxArray,
295 i: mwIndex,
296 propname: *const ::core::ffi::c_char,
297 value: *const mxArray,
298 );
299 #[link_name = "\u{1}mxGetClassName_800"]
300 pub fn mxGetClassName(pa: *const mxArray) -> *const ::core::ffi::c_char;
301 #[link_name = "\u{1}mxIsClass_800"]
302 pub fn mxIsClass(pa: *const mxArray, name: *const ::core::ffi::c_char) -> bool;
303 #[link_name = "\u{1}mxCreateNumericMatrix_800"]
304 pub fn mxCreateNumericMatrix(
305 m: mwSize,
306 n: mwSize,
307 classid: mxClassID::Type,
308 flag: mxComplexity::Type,
309 ) -> *mut mxArray;
310 #[link_name = "\u{1}mxCreateUninitNumericMatrix_800"]
311 pub fn mxCreateUninitNumericMatrix(
312 m: usize,
313 n: usize,
314 classid: mxClassID::Type,
315 flag: mxComplexity::Type,
316 ) -> *mut mxArray;
317 #[link_name = "\u{1}mxCreateUninitNumericArray_800"]
318 pub fn mxCreateUninitNumericArray(
319 ndim: usize,
320 dims: *mut usize,
321 classid: mxClassID::Type,
322 flag: mxComplexity::Type,
323 ) -> *mut mxArray;
324 #[link_name = "\u{1}mxSetN_800"]
325 pub fn mxSetN(pa: *mut mxArray, n: mwSize);
326 #[link_name = "\u{1}mxSetDimensions_800"]
327 pub fn mxSetDimensions(
328 pa: *mut mxArray,
329 pdims: *const mwSize,
330 ndims: mwSize,
331 ) -> ::core::ffi::c_int;
332 #[link_name = "\u{1}mxDestroyArray_800"]
333 pub fn mxDestroyArray(pa: *mut mxArray);
334 #[link_name = "\u{1}mxCreateNumericArray_800"]
335 pub fn mxCreateNumericArray(
336 ndim: mwSize,
337 dims: *const mwSize,
338 classid: mxClassID::Type,
339 flag: mxComplexity::Type,
340 ) -> *mut mxArray;
341 #[link_name = "\u{1}mxCreateCharArray_800"]
342 pub fn mxCreateCharArray(ndim: mwSize, dims: *const mwSize) -> *mut mxArray;
343 #[link_name = "\u{1}mxCreateDoubleMatrix_800"]
344 pub fn mxCreateDoubleMatrix(m: mwSize, n: mwSize, flag: mxComplexity::Type) -> *mut mxArray;
345 #[link_name = "\u{1}mxGetLogicals_800"]
346 pub fn mxGetLogicals(pa: *const mxArray) -> *mut mxLogical;
347 #[link_name = "\u{1}mxCreateLogicalArray_800"]
348 pub fn mxCreateLogicalArray(ndim: mwSize, dims: *const mwSize) -> *mut mxArray;
349 #[link_name = "\u{1}mxCreateLogicalMatrix_800"]
350 pub fn mxCreateLogicalMatrix(m: mwSize, n: mwSize) -> *mut mxArray;
351 #[link_name = "\u{1}mxCreateLogicalScalar_800"]
352 pub fn mxCreateLogicalScalar(value: bool) -> *mut mxArray;
353 #[link_name = "\u{1}mxIsLogicalScalar_800"]
354 pub fn mxIsLogicalScalar(pa: *const mxArray) -> bool;
355 #[link_name = "\u{1}mxIsLogicalScalarTrue_800"]
356 pub fn mxIsLogicalScalarTrue(pa: *const mxArray) -> bool;
357 #[link_name = "\u{1}mxCreateDoubleScalar_800"]
358 pub fn mxCreateDoubleScalar(value: f64) -> *mut mxArray;
359 #[link_name = "\u{1}mxCreateSparse_800"]
360 pub fn mxCreateSparse(
361 m: mwSize,
362 n: mwSize,
363 nzmax: mwSize,
364 flag: mxComplexity::Type,
365 ) -> *mut mxArray;
366 #[link_name = "\u{1}mxCreateSparseLogicalMatrix_800"]
367 pub fn mxCreateSparseLogicalMatrix(m: mwSize, n: mwSize, nzmax: mwSize) -> *mut mxArray;
368 #[link_name = "\u{1}mxGetNChars_800"]
369 pub fn mxGetNChars(pa: *const mxArray, buf: *mut ::core::ffi::c_char, nChars: mwSize);
370 #[link_name = "\u{1}mxGetString_800"]
371 pub fn mxGetString(
372 pa: *const mxArray,
373 buf: *mut ::core::ffi::c_char,
374 buflen: mwSize,
375 ) -> ::core::ffi::c_int;
376 #[link_name = "\u{1}mxArrayToString_800"]
377 pub fn mxArrayToString(pa: *const mxArray) -> *mut ::core::ffi::c_char;
378 #[link_name = "\u{1}mxArrayToUTF8String_800"]
379 pub fn mxArrayToUTF8String(pa: *const mxArray) -> *mut ::core::ffi::c_char;
380 #[link_name = "\u{1}mxCreateStringFromNChars_800"]
381 pub fn mxCreateStringFromNChars(str_: *const ::core::ffi::c_char, n: mwSize) -> *mut mxArray;
382 #[link_name = "\u{1}mxCreateString_800"]
383 pub fn mxCreateString(str_: *const ::core::ffi::c_char) -> *mut mxArray;
384 #[link_name = "\u{1}mxCreateCharMatrixFromStrings_800"]
385 pub fn mxCreateCharMatrixFromStrings(
386 m: mwSize,
387 str_: *mut *const ::core::ffi::c_char,
388 ) -> *mut mxArray;
389 #[link_name = "\u{1}mxCreateCellMatrix_800"]
390 pub fn mxCreateCellMatrix(m: mwSize, n: mwSize) -> *mut mxArray;
391 #[link_name = "\u{1}mxCreateCellArray_800"]
392 pub fn mxCreateCellArray(ndim: mwSize, dims: *const mwSize) -> *mut mxArray;
393 #[link_name = "\u{1}mxCreateStructMatrix_800"]
394 pub fn mxCreateStructMatrix(
395 m: mwSize,
396 n: mwSize,
397 nfields: ::core::ffi::c_int,
398 fieldnames: *mut *const ::core::ffi::c_char,
399 ) -> *mut mxArray;
400 #[link_name = "\u{1}mxCreateStructArray_800"]
401 pub fn mxCreateStructArray(
402 ndim: mwSize,
403 dims: *const mwSize,
404 nfields: ::core::ffi::c_int,
405 fieldnames: *mut *const ::core::ffi::c_char,
406 ) -> *mut mxArray;
407 #[link_name = "\u{1}mxDuplicateArray_800"]
408 pub fn mxDuplicateArray(in_: *const mxArray) -> *mut mxArray;
409 #[link_name = "\u{1}mxSetClassName_800"]
410 pub fn mxSetClassName(
411 pa: *mut mxArray,
412 classname: *const ::core::ffi::c_char,
413 ) -> ::core::ffi::c_int;
414 #[link_name = "\u{1}mxAddField_800"]
415 pub fn mxAddField(
416 pa: *mut mxArray,
417 fieldname: *const ::core::ffi::c_char,
418 ) -> ::core::ffi::c_int;
419 #[link_name = "\u{1}mxRemoveField_800"]
420 pub fn mxRemoveField(pa: *mut mxArray, field: ::core::ffi::c_int);
421 #[link_name = "\u{1}mxGetEps_800"]
422 pub fn mxGetEps() -> f64;
423 #[link_name = "\u{1}mxGetInf_800"]
424 pub fn mxGetInf() -> f64;
425 #[link_name = "\u{1}mxGetNaN_800"]
426 pub fn mxGetNaN() -> f64;
427 #[link_name = "\u{1}mxIsFinite_800"]
428 pub fn mxIsFinite(x: f64) -> bool;
429 #[link_name = "\u{1}mxIsInf_800"]
430 pub fn mxIsInf(x: f64) -> bool;
431 #[link_name = "\u{1}mxIsNaN_800"]
432 pub fn mxIsNaN(x: f64) -> bool;
433 #[link_name = "\u{1}mxGetDoubles_800"]
434 pub fn mxGetDoubles(arg1: *const mxArray) -> *mut f64;
435 #[link_name = "\u{1}mxSetDoubles_800"]
436 pub fn mxSetDoubles(arg1: *mut mxArray, arg2: *mut f64) -> ::core::ffi::c_int;
437 #[link_name = "\u{1}mxGetComplexDoubles_800"]
438 pub fn mxGetComplexDoubles(arg1: *const mxArray) -> *mut mxComplexDouble;
439 #[link_name = "\u{1}mxSetComplexDoubles_800"]
440 pub fn mxSetComplexDoubles(
441 arg1: *mut mxArray,
442 arg2: *mut mxComplexDouble,
443 ) -> ::core::ffi::c_int;
444 #[link_name = "\u{1}mxGetSingles_800"]
445 pub fn mxGetSingles(arg1: *const mxArray) -> *mut f32;
446 #[link_name = "\u{1}mxSetSingles_800"]
447 pub fn mxSetSingles(arg1: *mut mxArray, arg2: *mut f32) -> ::core::ffi::c_int;
448 #[link_name = "\u{1}mxGetComplexSingles_800"]
449 pub fn mxGetComplexSingles(arg1: *const mxArray) -> *mut mxComplexSingle;
450 #[link_name = "\u{1}mxSetComplexSingles_800"]
451 pub fn mxSetComplexSingles(
452 arg1: *mut mxArray,
453 arg2: *mut mxComplexSingle,
454 ) -> ::core::ffi::c_int;
455 #[link_name = "\u{1}mxGetInt8s_800"]
456 pub fn mxGetInt8s(arg1: *const mxArray) -> *mut i8;
457 #[link_name = "\u{1}mxSetInt8s_800"]
458 pub fn mxSetInt8s(arg1: *mut mxArray, arg2: *mut i8) -> ::core::ffi::c_int;
459 #[link_name = "\u{1}mxGetComplexInt8s_800"]
460 pub fn mxGetComplexInt8s(arg1: *const mxArray) -> *mut mxComplexInt8;
461 #[link_name = "\u{1}mxSetComplexInt8s_800"]
462 pub fn mxSetComplexInt8s(arg1: *mut mxArray, arg2: *mut mxComplexInt8) -> ::core::ffi::c_int;
463 #[link_name = "\u{1}mxGetUint8s_800"]
464 pub fn mxGetUint8s(arg1: *const mxArray) -> *mut u8;
465 #[link_name = "\u{1}mxSetUint8s_800"]
466 pub fn mxSetUint8s(arg1: *mut mxArray, arg2: *mut u8) -> ::core::ffi::c_int;
467 #[link_name = "\u{1}mxGetComplexUint8s_800"]
468 pub fn mxGetComplexUint8s(arg1: *const mxArray) -> *mut mxComplexUint8;
469 #[link_name = "\u{1}mxSetComplexUint8s_800"]
470 pub fn mxSetComplexUint8s(arg1: *mut mxArray, arg2: *mut mxComplexUint8) -> ::core::ffi::c_int;
471 #[link_name = "\u{1}mxGetInt16s_800"]
472 pub fn mxGetInt16s(arg1: *const mxArray) -> *mut i16;
473 #[link_name = "\u{1}mxSetInt16s_800"]
474 pub fn mxSetInt16s(arg1: *mut mxArray, arg2: *mut i16) -> ::core::ffi::c_int;
475 #[link_name = "\u{1}mxGetComplexInt16s_800"]
476 pub fn mxGetComplexInt16s(arg1: *const mxArray) -> *mut mxComplexInt16;
477 #[link_name = "\u{1}mxSetComplexInt16s_800"]
478 pub fn mxSetComplexInt16s(arg1: *mut mxArray, arg2: *mut mxComplexInt16) -> ::core::ffi::c_int;
479 #[link_name = "\u{1}mxGetUint16s_800"]
480 pub fn mxGetUint16s(arg1: *const mxArray) -> *mut u16;
481 #[link_name = "\u{1}mxSetUint16s_800"]
482 pub fn mxSetUint16s(arg1: *mut mxArray, arg2: *mut u16) -> ::core::ffi::c_int;
483 #[link_name = "\u{1}mxGetComplexUint16s_800"]
484 pub fn mxGetComplexUint16s(arg1: *const mxArray) -> *mut mxComplexUint16;
485 #[link_name = "\u{1}mxSetComplexUint16s_800"]
486 pub fn mxSetComplexUint16s(
487 arg1: *mut mxArray,
488 arg2: *mut mxComplexUint16,
489 ) -> ::core::ffi::c_int;
490 #[link_name = "\u{1}mxGetInt32s_800"]
491 pub fn mxGetInt32s(arg1: *const mxArray) -> *mut i32;
492 #[link_name = "\u{1}mxSetInt32s_800"]
493 pub fn mxSetInt32s(arg1: *mut mxArray, arg2: *mut i32) -> ::core::ffi::c_int;
494 #[link_name = "\u{1}mxGetComplexInt32s_800"]
495 pub fn mxGetComplexInt32s(arg1: *const mxArray) -> *mut mxComplexInt32;
496 #[link_name = "\u{1}mxSetComplexInt32s_800"]
497 pub fn mxSetComplexInt32s(arg1: *mut mxArray, arg2: *mut mxComplexInt32) -> ::core::ffi::c_int;
498 #[link_name = "\u{1}mxGetUint32s_800"]
499 pub fn mxGetUint32s(arg1: *const mxArray) -> *mut u32;
500 #[link_name = "\u{1}mxSetUint32s_800"]
501 pub fn mxSetUint32s(arg1: *mut mxArray, arg2: *mut u32) -> ::core::ffi::c_int;
502 #[link_name = "\u{1}mxGetComplexUint32s_800"]
503 pub fn mxGetComplexUint32s(arg1: *const mxArray) -> *mut mxComplexUint32;
504 #[link_name = "\u{1}mxSetComplexUint32s_800"]
505 pub fn mxSetComplexUint32s(
506 arg1: *mut mxArray,
507 arg2: *mut mxComplexUint32,
508 ) -> ::core::ffi::c_int;
509 #[link_name = "\u{1}mxGetInt64s_800"]
510 pub fn mxGetInt64s(arg1: *const mxArray) -> *mut i64;
511 #[link_name = "\u{1}mxSetInt64s_800"]
512 pub fn mxSetInt64s(arg1: *mut mxArray, arg2: *mut i64) -> ::core::ffi::c_int;
513 #[link_name = "\u{1}mxGetComplexInt64s_800"]
514 pub fn mxGetComplexInt64s(arg1: *const mxArray) -> *mut mxComplexInt64;
515 #[link_name = "\u{1}mxSetComplexInt64s_800"]
516 pub fn mxSetComplexInt64s(arg1: *mut mxArray, arg2: *mut mxComplexInt64) -> ::core::ffi::c_int;
517 #[link_name = "\u{1}mxGetUint64s_800"]
518 pub fn mxGetUint64s(arg1: *const mxArray) -> *mut u64;
519 #[link_name = "\u{1}mxSetUint64s_800"]
520 pub fn mxSetUint64s(arg1: *mut mxArray, arg2: *mut u64) -> ::core::ffi::c_int;
521 #[link_name = "\u{1}mxGetComplexUint64s_800"]
522 pub fn mxGetComplexUint64s(arg1: *const mxArray) -> *mut mxComplexUint64;
523 #[link_name = "\u{1}mxSetComplexUint64s_800"]
524 pub fn mxSetComplexUint64s(
525 arg1: *mut mxArray,
526 arg2: *mut mxComplexUint64,
527 ) -> ::core::ffi::c_int;
528 #[link_name = "\u{1}mxMakeArrayReal_800"]
529 pub fn mxMakeArrayReal(arg1: *mut mxArray) -> ::core::ffi::c_int;
530 #[link_name = "\u{1}mxMakeArrayComplex_800"]
531 pub fn mxMakeArrayComplex(arg1: *mut mxArray) -> ::core::ffi::c_int;
532 #[link_name = "\u{1}mexErrMsgTxt_800"]
533 pub fn mexErrMsgTxt(error_msg: *const ::core::ffi::c_char);
534 #[link_name = "\u{1}mexErrMsgIdAndTxt_800"]
535 pub fn mexErrMsgIdAndTxt(
536 identifier: *const ::core::ffi::c_char,
537 err_msg: *const ::core::ffi::c_char,
538 ...
539 );
540 #[link_name = "\u{1}mexWarnMsgTxt_800"]
541 pub fn mexWarnMsgTxt(warn_msg: *const ::core::ffi::c_char);
542 #[link_name = "\u{1}mexWarnMsgIdAndTxt_800"]
543 pub fn mexWarnMsgIdAndTxt(
544 identifier: *const ::core::ffi::c_char,
545 warn_msg: *const ::core::ffi::c_char,
546 ...
547 );
548 #[link_name = "\u{1}mexPrintf_800"]
549 pub fn mexPrintf(fmt: *const ::core::ffi::c_char, ...) -> ::core::ffi::c_int;
550 #[link_name = "\u{1}mexMakeArrayPersistent_800"]
551 pub fn mexMakeArrayPersistent(pa: *mut mxArray);
552 #[link_name = "\u{1}mexMakeMemoryPersistent_800"]
553 pub fn mexMakeMemoryPersistent(ptr: *mut ::core::ffi::c_void);
554 #[link_name = "\u{1}mexCallMATLAB_800"]
555 pub fn mexCallMATLAB(
556 nlhs: ::core::ffi::c_int,
557 plhs: *mut *mut mxArray,
558 nrhs: ::core::ffi::c_int,
559 prhs: *mut *mut mxArray,
560 fcn_name: *const ::core::ffi::c_char,
561 ) -> ::core::ffi::c_int;
562 #[link_name = "\u{1}mexCallMATLABWithTrap_800"]
563 pub fn mexCallMATLABWithTrap(
564 nlhs: ::core::ffi::c_int,
565 plhs: *mut *mut mxArray,
566 nrhs: ::core::ffi::c_int,
567 prhs: *mut *mut mxArray,
568 fcn_name: *const ::core::ffi::c_char,
569 ) -> *mut mxArray;
570 #[link_name = "\u{1}mexPrintAssertion_800"]
571 pub fn mexPrintAssertion(
572 test: *const ::core::ffi::c_char,
573 fname: *const ::core::ffi::c_char,
574 linenum: ::core::ffi::c_int,
575 message: *const ::core::ffi::c_char,
576 );
577 #[link_name = "\u{1}mexIsGlobal_800"]
578 pub fn mexIsGlobal(pA: *const mxArray) -> bool;
579 #[link_name = "\u{1}mexPutVariable_800"]
580 pub fn mexPutVariable(
581 workspace: *const ::core::ffi::c_char,
582 name: *const ::core::ffi::c_char,
583 parray: *const mxArray,
584 ) -> ::core::ffi::c_int;
585 #[link_name = "\u{1}mexGetVariablePtr_800"]
586 pub fn mexGetVariablePtr(
587 workspace: *const ::core::ffi::c_char,
588 name: *const ::core::ffi::c_char,
589 ) -> *const mxArray;
590 #[link_name = "\u{1}mexGetVariable_800"]
591 pub fn mexGetVariable(
592 workspace: *const ::core::ffi::c_char,
593 name: *const ::core::ffi::c_char,
594 ) -> *mut mxArray;
595 #[link_name = "\u{1}mexLock_800"]
596 pub fn mexLock();
597 #[link_name = "\u{1}mexUnlock_800"]
598 pub fn mexUnlock();
599 #[link_name = "\u{1}mexIsLocked_800"]
600 pub fn mexIsLocked() -> bool;
601 #[link_name = "\u{1}mexFunctionName_800"]
602 pub fn mexFunctionName() -> *const ::core::ffi::c_char;
603 #[link_name = "\u{1}mexEvalString_800"]
604 pub fn mexEvalString(str_: *const ::core::ffi::c_char) -> ::core::ffi::c_int;
605 #[link_name = "\u{1}mexEvalStringWithTrap_800"]
606 pub fn mexEvalStringWithTrap(str_: *const ::core::ffi::c_char) -> *mut mxArray;
607 #[link_name = "\u{1}mexAtExit_800"]
608 pub fn mexAtExit(exit_fcn: mex_exit_fn) -> ::core::ffi::c_int;
609 pub fn mexFunction(
610 nlhs: ::core::ffi::c_int,
611 plhs: *mut *mut mxArray,
612 nrhs: ::core::ffi::c_int,
613 prhs: *mut *const mxArray,
614 );
615 #[link_name = "\u{1}matOpen_800"]
616 pub fn matOpen(
617 filename: *const ::core::ffi::c_char,
618 mode: *const ::core::ffi::c_char,
619 ) -> *mut MATFile;
620 #[link_name = "\u{1}matClose_800"]
621 pub fn matClose(pMF: *mut MATFile) -> matError;
622 #[link_name = "\u{1}matGetErrno_800"]
623 pub fn matGetErrno(pMF: *mut MATFile) -> matError;
624 #[link_name = "\u{1}matGetFp_800"]
625 pub fn matGetFp(pMF: *mut MATFile) -> *mut FILE;
626 #[link_name = "\u{1}matPutVariable_800"]
627 pub fn matPutVariable(
628 pMF: *mut MATFile,
629 name: *const ::core::ffi::c_char,
630 pA: *const mxArray,
631 ) -> matError;
632 #[link_name = "\u{1}matPutVariableAsGlobal_800"]
633 pub fn matPutVariableAsGlobal(
634 pMF: *mut MATFile,
635 name: *const ::core::ffi::c_char,
636 pA: *const mxArray,
637 ) -> matError;
638 #[link_name = "\u{1}matGetVariable_800"]
639 pub fn matGetVariable(pMF: *mut MATFile, name: *const ::core::ffi::c_char) -> *mut mxArray;
640 #[link_name = "\u{1}matGetNextVariable_800"]
641 pub fn matGetNextVariable(
642 pMF: *mut MATFile,
643 nameptr: *mut *const ::core::ffi::c_char,
644 ) -> *mut mxArray;
645 #[link_name = "\u{1}matGetNextVariableInfo_800"]
646 pub fn matGetNextVariableInfo(
647 pMF: *mut MATFile,
648 nameptr: *mut *const ::core::ffi::c_char,
649 ) -> *mut mxArray;
650 #[link_name = "\u{1}matGetVariableInfo_800"]
651 pub fn matGetVariableInfo(pMF: *mut MATFile, name: *const ::core::ffi::c_char) -> *mut mxArray;
652 #[link_name = "\u{1}matDeleteVariable_800"]
653 pub fn matDeleteVariable(pMF: *mut MATFile, name: *const ::core::ffi::c_char) -> matError;
654 #[link_name = "\u{1}matGetDir_800"]
655 pub fn matGetDir(
656 pMF: *mut MATFile,
657 num: *mut ::core::ffi::c_int,
658 ) -> *mut *mut ::core::ffi::c_char;
659 pub fn engEvalString(ep: *mut Engine, string: *const ::core::ffi::c_char)
660 -> ::core::ffi::c_int;
661 pub fn engOpenSingleUse(
662 startcmd: *const ::core::ffi::c_char,
663 reserved: *mut ::core::ffi::c_void,
664 retstatus: *mut ::core::ffi::c_int,
665 ) -> *mut Engine;
666 pub fn engSetVisible(ep: *mut Engine, newVal: bool) -> ::core::ffi::c_int;
667 pub fn engGetVisible(ep: *mut Engine, bVal: *mut bool) -> ::core::ffi::c_int;
668 pub fn engOpen(startcmd: *const ::core::ffi::c_char) -> *mut Engine;
669 pub fn engClose(ep: *mut Engine) -> ::core::ffi::c_int;
670 pub fn engGetVariable(ep: *mut Engine, name: *const ::core::ffi::c_char) -> *mut mxArray;
671 pub fn engPutVariable(
672 ep: *mut Engine,
673 var_name: *const ::core::ffi::c_char,
674 ap: *const mxArray,
675 ) -> ::core::ffi::c_int;
676 pub fn engOutputBuffer(
677 ep: *mut Engine,
678 buffer: *mut ::core::ffi::c_char,
679 buflen: ::core::ffi::c_int,
680 ) -> ::core::ffi::c_int;
681}