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
126
127
128
129
130
131
132
133

//! JSON-based FFI API for symbolic integral equations.

use std::os::raw::c_char;

use serde::Deserialize;
use serde::Serialize;

use crate::ffi_apis::common::from_json_string;
use crate::ffi_apis::common::to_json_string;
use crate::symbolic::core::Expr;
use crate::symbolic::integral_equations::FredholmEquation;
use crate::symbolic::integral_equations::VolterraEquation;
use crate::symbolic::integral_equations::solve_airfoil_equation;

#[derive(Serialize, Deserialize)]
struct FredholmNeumannInput {
    equation: FredholmEquation,
    iterations: usize,
}

#[derive(Serialize, Deserialize)]
struct FredholmSeparableInput {
    equation: FredholmEquation,
    a_funcs: Vec<Expr>,
    b_funcs: Vec<Expr>,
}

#[derive(Serialize, Deserialize)]
struct VolterraSuccessiveInput {
    equation: VolterraEquation,
    iterations: usize,
}

#[derive(Serialize, Deserialize)]
struct AirfoilInput {
    f_x: Expr,
    var_x: String,
    var_t: String,
}

/// Solves a Fredholm equation using the Neumann series method (JSON).
#[unsafe(no_mangle)]
pub extern "C" fn rssn_fredholm_solve_neumann_json(input_json: *const c_char) -> *mut c_char {
    let input: Option<FredholmNeumannInput> = from_json_string(input_json);

    let input = match input {
        | Some(i) => i,
        | None => {
            return std::ptr::null_mut();
        },
    };

    let result = input.equation.solve_neumann_series(input.iterations);

    to_json_string(&result)
}

/// Solves a Fredholm equation with a separable kernel (JSON).
#[unsafe(no_mangle)]
pub extern "C" fn rssn_fredholm_solve_separable_json(input_json: *const c_char) -> *mut c_char {
    let input: Option<FredholmSeparableInput> = from_json_string(input_json);

    let input = match input {
        | Some(i) => i,
        | None => {
            return std::ptr::null_mut();
        },
    };

    match input
        .equation
        .solve_separable_kernel(&input.a_funcs, &input.b_funcs)
    {
        | Ok(result) => to_json_string(&result),
        | Err(_) => std::ptr::null_mut(),
    }
}

/// Solves a Volterra equation using successive approximations (JSON).
#[unsafe(no_mangle)]
pub extern "C" fn rssn_volterra_solve_successive_json(input_json: *const c_char) -> *mut c_char {
    let input: Option<VolterraSuccessiveInput> = from_json_string(input_json);

    let input = match input {
        | Some(i) => i,
        | None => {
            return std::ptr::null_mut();
        },
    };

    let result = input
        .equation
        .solve_successive_approximations(input.iterations);

    to_json_string(&result)
}

/// Solves a Volterra equation by differentiation (JSON).
#[unsafe(no_mangle)]
pub extern "C" fn rssn_volterra_solve_by_differentiation_json(
    input_json: *const c_char
) -> *mut c_char {
    let equation: Option<VolterraEquation> = from_json_string(input_json);

    let equation = match equation {
        | Some(e) => e,
        | None => {
            return std::ptr::null_mut();
        },
    };

    match equation.solve_by_differentiation() {
        | Ok(result) => to_json_string(&result),
        | Err(_) => std::ptr::null_mut(),
    }
}

/// Solves the airfoil singular integral equation (JSON).
#[unsafe(no_mangle)]
pub extern "C" fn rssn_solve_airfoil_equation_json(input_json: *const c_char) -> *mut c_char {
    let input: Option<AirfoilInput> = from_json_string(input_json);

    let input = match input {
        | Some(i) => i,
        | None => {
            return std::ptr::null_mut();
        },
    };

    let result = solve_airfoil_equation(&input.f_x, &input.var_x, &input.var_t);

    to_json_string(&result)
}