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

use std::ffi::c_char;

use crate::ffi_apis::common::from_json_string;
use crate::ffi_apis::common::to_json_string;
use crate::symbolic::core::SparsePolynomial;
use crate::symbolic::grobner::MonomialOrder;
use crate::symbolic::grobner::buchberger;
use crate::symbolic::grobner::poly_division_multivariate;

/// Computes a Gröbner basis using Buchberger's algorithm and returns it as JSON-encoded polynomials.
///
/// # Arguments
///
/// * `basis_json` - C string pointer with JSON-encoded `Vec<SparsePolynomial>` for the initial basis.
/// * `order_json` - C string pointer with JSON-encoded [`MonomialOrder`].
///
/// # Returns
///
/// A C string pointer containing JSON-encoded `Vec<SparsePolynomial>` representing a
/// Gröbner basis, or null if deserialization fails or the computation encounters an error.
///
/// # Safety
///
/// This function is unsafe because it dereferences raw C string pointers and returns
/// ownership of a heap-allocated C string that must be freed by the caller.
#[unsafe(no_mangle)]
pub extern "C" fn rssn_json_buchberger(
    basis_json: *const c_char,
    order_json: *const c_char,
) -> *mut c_char {
    let basis: Option<Vec<SparsePolynomial>> = from_json_string(basis_json);

    let order: Option<MonomialOrder> = from_json_string(order_json);

    match (basis, order) {
        | (Some(b), Some(o)) => {
            match buchberger(&b, o) {
                | Ok(result) => to_json_string(&result),
                | Err(_) => std::ptr::null_mut(),
            }
        },
        | _ => std::ptr::null_mut(),
    }
}

/// Divides a multivariate polynomial by a list of divisors under a given monomial order
/// and returns quotients and remainder as JSON-encoded polynomials.
///
/// # Arguments
///
/// * `dividend_json` - C string pointer with JSON-encoded dividend `SparsePolynomial`.
/// * `divisors_json` - C string pointer with JSON-encoded `Vec<SparsePolynomial>` of divisors.
/// * `order_json` - C string pointer with JSON-encoded [`MonomialOrder`].
///
/// # Returns
///
/// A C string pointer containing JSON-encoded `(Vec<SparsePolynomial>, SparsePolynomial)`
/// with quotient polynomials and remainder, or null if deserialization fails or the
/// computation encounters an error.
///
/// # Safety
///
/// This function is unsafe because it dereferences raw C string pointers and returns
/// ownership of a heap-allocated C string that must be freed by the caller.
#[unsafe(no_mangle)]
pub extern "C" fn rssn_json_poly_division_multivariate(
    dividend_json: *const c_char,
    divisors_json: *const c_char,
    order_json: *const c_char,
) -> *mut c_char {
    let dividend: Option<SparsePolynomial> = from_json_string(dividend_json);

    let divisors: Option<Vec<SparsePolynomial>> = from_json_string(divisors_json);

    let order: Option<MonomialOrder> = from_json_string(order_json);

    match (dividend, divisors, order) {
        | (Some(d), Some(divs), Some(o)) => {
            match poly_division_multivariate(&d, &divs, o) {
                | Ok(result) => to_json_string(&result),
                | Err(_) => std::ptr::null_mut(),
            }
        },
        | _ => std::ptr::null_mut(),
    }
}