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

use crate::symbolic::core::Expr;
use crate::symbolic::matrix::add_matrices;
use crate::symbolic::matrix::determinant;
use crate::symbolic::matrix::inverse_matrix;
use crate::symbolic::matrix::mul_matrices;
use crate::symbolic::matrix::solve_linear_system;
use crate::symbolic::matrix::transpose_matrix;

/// Performs matrix addition using raw pointers to `Expr` objects.
/// Takes two raw pointers to `Expr` (representing matrices) as input,
/// and returns a raw pointer to a new `Expr` representing their sum.
#[unsafe(no_mangle)]
pub extern "C" fn rssn_matrix_add_handle(
    m1: *const Expr,
    m2: *const Expr,
) -> *mut Expr {
    let m1 = unsafe { &*m1 };

    let m2 = unsafe { &*m2 };

    let result = add_matrices(m1, m2);

    Box::into_raw(Box::new(result))
}

/// Performs matrix multiplication using raw pointers to `Expr` objects.
///
/// Takes two raw pointers to `Expr` (representing matrices) as input,
/// and returns a raw pointer to a new `Expr` representing their product.
#[unsafe(no_mangle)]
pub extern "C" fn rssn_matrix_mul_handle(
    m1: *const Expr,
    m2: *const Expr,
) -> *mut Expr {
    let m1 = unsafe { &*m1 };

    let m2 = unsafe { &*m2 };

    let result = mul_matrices(m1, m2);

    Box::into_raw(Box::new(result))
}

/// Performs matrix transposition using a raw pointer to an `Expr` object.
///
/// Takes a raw pointer to an `Expr` (representing a matrix) as input,
/// and returns a raw pointer to a new `Expr` representing its transpose.
#[unsafe(no_mangle)]
pub extern "C" fn rssn_matrix_transpose_handle(matrix: *const Expr) -> *mut Expr {
    let matrix = unsafe { &*matrix };

    let result = transpose_matrix(matrix);

    Box::into_raw(Box::new(result))
}

/// Computes the determinant of a matrix using a raw pointer to an `Expr` object.
///
/// Takes a raw pointer to an `Expr` (representing a matrix) as input,
/// and returns a raw pointer to a new `Expr` representing its determinant.
#[unsafe(no_mangle)]
pub extern "C" fn rssn_matrix_determinant_handle(matrix: *const Expr) -> *mut Expr {
    let matrix = unsafe { &*matrix };

    let result = determinant(matrix);

    Box::into_raw(Box::new(result))
}

/// Computes the inverse of a matrix using a raw pointer to an `Expr` object.
///
/// Takes a raw pointer to an `Expr` (representing a matrix) as input,
/// and returns a raw pointer to a new `Expr` representing its inverse.
#[unsafe(no_mangle)]
pub extern "C" fn rssn_matrix_inverse_handle(matrix: *const Expr) -> *mut Expr {
    let matrix = unsafe { &*matrix };

    let result = inverse_matrix(matrix);

    Box::into_raw(Box::new(result))
}

/// Solves a linear system of equations AX = B using raw pointers to `Expr` objects.
///
/// Takes two raw pointers to `Expr` (representing matrix A and vector B) as input,
/// and returns a raw pointer to a new `Expr` representing the solution vector X.
#[unsafe(no_mangle)]
pub extern "C" fn rssn_matrix_solve_linear_system_handle(
    a: *const Expr,
    b: *const Expr,
) -> *mut Expr {
    let a = unsafe { &*a };

    let b = unsafe { &*b };

    match solve_linear_system(a, b) {
        | Ok(result) => Box::into_raw(Box::new(result)),
        | Err(e) => Box::into_raw(Box::new(Expr::Variable(format!("Error: {e}")))),
    }
}