rssn 0.2.9

A comprehensive scientific computing library for Rust, aiming for feature parity with NumPy and SymPy.
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

//! Bincode-based FFI API for symbolic elementary functions.

use crate::ffi_apis::common::BincodeBuffer;
use crate::ffi_apis::common::from_bincode_buffer;
use crate::ffi_apis::common::to_bincode_buffer;
use crate::symbolic::core::Expr;
use crate::symbolic::elementary;

/// Creates a sine expression from bincode: sin(expr).
///
/// # Arguments
/// * `expr_buffer` - Bincode-serialized Expr
///
/// # Returns
/// Bincode-serialized Expr
#[unsafe(no_mangle)]
pub extern "C" fn rssn_sin_bincode(expr_buffer: BincodeBuffer) -> BincodeBuffer {
    let expr: Expr = match from_bincode_buffer(&expr_buffer) {
        | Some(e) => e,
        | None => return BincodeBuffer::empty(),
    };

    to_bincode_buffer(&elementary::sin(expr))
}

/// Creates a cosine expression from bincode: cos(expr).
#[unsafe(no_mangle)]
pub extern "C" fn rssn_cos_bincode(expr_buffer: BincodeBuffer) -> BincodeBuffer {
    let expr: Expr = match from_bincode_buffer(&expr_buffer) {
        | Some(e) => e,
        | None => return BincodeBuffer::empty(),
    };

    to_bincode_buffer(&elementary::cos(expr))
}

/// Creates a tangent expression from bincode: tan(expr).
#[unsafe(no_mangle)]
pub extern "C" fn rssn_tan_bincode(expr_buffer: BincodeBuffer) -> BincodeBuffer {
    let expr: Expr = match from_bincode_buffer(&expr_buffer) {
        | Some(e) => e,
        | None => return BincodeBuffer::empty(),
    };

    to_bincode_buffer(&elementary::tan(expr))
}

/// Creates an exponential expression from bincode: e^(expr).
#[unsafe(no_mangle)]
pub extern "C" fn rssn_exp_bincode(expr_buffer: BincodeBuffer) -> BincodeBuffer {
    let expr: Expr = match from_bincode_buffer(&expr_buffer) {
        | Some(e) => e,
        | None => return BincodeBuffer::empty(),
    };

    to_bincode_buffer(&elementary::exp(expr))
}

/// Creates a natural logarithm expression from bincode: ln(expr).
#[unsafe(no_mangle)]
pub extern "C" fn rssn_ln_bincode(expr_buffer: BincodeBuffer) -> BincodeBuffer {
    let expr: Expr = match from_bincode_buffer(&expr_buffer) {
        | Some(e) => e,
        | None => return BincodeBuffer::empty(),
    };

    to_bincode_buffer(&elementary::ln(expr))
}

/// Creates a square root expression from bincode: sqrt(expr).
#[unsafe(no_mangle)]
pub extern "C" fn rssn_sqrt_bincode(expr_buffer: BincodeBuffer) -> BincodeBuffer {
    let expr: Expr = match from_bincode_buffer(&expr_buffer) {
        | Some(e) => e,
        | None => return BincodeBuffer::empty(),
    };

    to_bincode_buffer(&elementary::sqrt(expr))
}

/// Creates a power expression from bincode: base^exp.
///
/// # Arguments
/// * `base_buffer` - Bincode-serialized base Expr
/// * `exp_buffer` - Bincode-serialized exponent Expr
#[unsafe(no_mangle)]
pub extern "C" fn rssn_pow_bincode(
    base_buffer: BincodeBuffer,
    exp_buffer: BincodeBuffer,
) -> BincodeBuffer {
    let base: Expr = match from_bincode_buffer(&base_buffer) {
        | Some(e) => e,
        | None => return BincodeBuffer::empty(),
    };

    let exp: Expr = match from_bincode_buffer(&exp_buffer) {
        | Some(e) => e,
        | None => return BincodeBuffer::empty(),
    };

    to_bincode_buffer(&elementary::pow(base, exp))
}

/// Returns Pi as bincode.
#[unsafe(no_mangle)]
pub extern "C" fn rssn_pi_bincode() -> BincodeBuffer {
    to_bincode_buffer(&elementary::pi())
}

/// Returns Euler's number (e) as bincode.
#[unsafe(no_mangle)]
pub extern "C" fn rssn_e_bincode() -> BincodeBuffer {
    to_bincode_buffer(&elementary::e())
}

/// Expands a symbolic expression from bincode.
#[unsafe(no_mangle)]
pub extern "C" fn rssn_expand_bincode(expr_buffer: BincodeBuffer) -> BincodeBuffer {
    let expr: Expr = match from_bincode_buffer(&expr_buffer) {
        | Some(e) => e,
        | None => return BincodeBuffer::empty(),
    };

    to_bincode_buffer(&elementary::expand(expr))
}