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

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::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 via bincode serialization.
///
/// Given a basis of multivariate polynomials and a monomial order, this runs
/// Buchberger's algorithm to produce a Gröbner basis for the ideal they generate.
///
/// # Arguments
///
/// * `basis_buf` - `BincodeBuffer` encoding `Vec<SparsePolynomial>` for the initial basis.
/// * `order_buf` - `BincodeBuffer` encoding the [`MonomialOrder`] to use.
///
/// # Returns
///
/// A `BincodeBuffer` encoding `Vec<SparsePolynomial>` forming a Gröbner basis, or an
/// empty buffer if deserialization fails or the computation encounters an error.
///
/// # Safety
///
/// This function is an FFI entry point; callers must treat the returned buffer as
/// opaque and only pass it to compatible APIs.
#[unsafe(no_mangle)]
pub extern "C" fn rssn_bincode_buchberger(
    basis_buf: BincodeBuffer,
    order_buf: BincodeBuffer,
) -> BincodeBuffer {
    let basis: Option<Vec<SparsePolynomial>> = from_bincode_buffer(&basis_buf);

    let order: Option<MonomialOrder> = from_bincode_buffer(&order_buf);

    match (basis, order) {
        | (Some(b), Some(o)) => {
            match buchberger(&b, o) {
                | Ok(result) => to_bincode_buffer(&result),
                | Err(_) => BincodeBuffer::empty(),
            }
        },
        | _ => BincodeBuffer::empty(),
    }
}

/// Divides a multivariate polynomial by a list of divisors under a given monomial order,
/// returning the quotients and remainder via bincode serialization.
///
/// # Arguments
///
/// * `dividend_buf` - `BincodeBuffer` encoding the dividend `SparsePolynomial`.
/// * `divisors_buf` - `BincodeBuffer` encoding `Vec<SparsePolynomial>` of divisors.
/// * `order_buf` - `BincodeBuffer` encoding the [`MonomialOrder`] to use.
///
/// # Returns
///
/// A `BincodeBuffer` encoding `(Vec<SparsePolynomial>, SparsePolynomial)` containing
/// the quotient polynomials and the remainder, or an empty buffer if deserialization
/// fails or the division fails.
///
/// # Safety
///
/// This function is an FFI entry point; callers must treat the returned buffer as
/// opaque and only pass it to compatible APIs.
#[unsafe(no_mangle)]
pub extern "C" fn rssn_bincode_poly_division_multivariate(
    dividend_buf: BincodeBuffer,
    divisors_buf: BincodeBuffer,
    order_buf: BincodeBuffer,
) -> BincodeBuffer {
    let dividend: Option<SparsePolynomial> = from_bincode_buffer(&dividend_buf);

    let divisors: Option<Vec<SparsePolynomial>> = from_bincode_buffer(&divisors_buf);

    let order: Option<MonomialOrder> = from_bincode_buffer(&order_buf);

    match (dividend, divisors, order) {
        | (Some(d), Some(divs), Some(o)) => {
            match poly_division_multivariate(&d, &divs, o) {
                | Ok(result) => to_bincode_buffer(&result),
                | Err(_) => BincodeBuffer::empty(),
            }
        },
        | _ => BincodeBuffer::empty(),
    }
}