wolfram-library-link 0.5.0

Bindings to Wolfram LibraryLink
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

use std::ffi::CString;

use wolfram_library_link::{
    self as wll,
    sys::{mint, mreal},
    NumericArray, UninitNumericArray,
};

//======================================
// Primitive data types
//======================================

#[wll::export]
fn test_no_args() -> i64 {
    4
}

#[wll::export]
fn test_ret_void() {
    // Do nothing.
}

//------------
// mint, mreal
//------------

#[wll::export]
fn test_mint(x: mint) -> mint {
    x * x
}

// Test NativeFunction impl for raw function using raw MArguments.
#[wll::export]
fn test_raw_mint(args: &[wll::sys::MArgument], ret: wll::sys::MArgument) {
    if args.len() != 1 {
        panic!("unexpected number of arguments");
    }

    let x: mint = unsafe { *args[0].integer };

    unsafe {
        *ret.integer = x * x;
    }
}

#[wll::export]
fn test_mint_mint(x: mint, y: mint) -> mint {
    x + y
}

#[wll::export]
fn test_mreal(x: mreal) -> mreal {
    x * x
}

//------------
// i64, f64
//------------

#[wll::export]
fn test_i64(x: i64) -> i64 {
    x * x
}

#[wll::export]
fn test_i64_i64(x: i64, y: i64) -> i64 {
    x + y
}

#[wll::export]
fn test_f64(x: f64) -> f64 {
    x * x
}

//--------
// Strings
//--------

// fn test_str(string: &str) -> String {
//     string.chars().rev().collect()
// }

#[wll::export]
fn test_string(string: String) -> String {
    string.chars().rev().collect()
}

#[wll::export]
fn test_c_string(string: CString) -> i64 {
    i64::try_from(string.as_bytes().len()).expect("string len usize overflows i64")
}

//-------
// Panics
//-------

#[wll::export]
fn test_panic() {
    panic!("this function panicked");
}

//======================================
// NumericArray's
//======================================

#[wll::export]
fn total_i64(list: &NumericArray<i64>) -> i64 {
    list.as_slice().into_iter().sum()
}

/// Get the sign of every element in `list` as a numeric array of 0's and 1's.
///
/// The returned array will have the same dimensions as `list`.
#[wll::export]
fn positive_i64(list: &NumericArray<i64>) -> NumericArray<u8> {
    let mut bools: UninitNumericArray<u8> =
        UninitNumericArray::from_dimensions(list.dimensions());

    for pair in list.as_slice().into_iter().zip(bools.as_slice_mut()) {
        let (elem, entry): (&i64, &mut std::mem::MaybeUninit<u8>) = pair;

        entry.write(u8::from(elem.is_positive()));
    }

    unsafe { bools.assume_init() }
}