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

//! Bincode-based FFI API for term rewriting systems.

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

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::rewriting::RewriteRule;
use crate::symbolic::rewriting::apply_rules_to_normal_form;
use crate::symbolic::rewriting::knuth_bendix;

#[derive(Serialize, Deserialize)]
struct ApplyRulesInput {
    expr: Expr,
    rules: Vec<RewriteRule>,
}

#[derive(Serialize, Deserialize)]
struct RuleInput {
    lhs: Expr,
    rhs: Expr,
}

#[derive(Serialize, Deserialize)]
struct StringResponse {
    string: String,
}

#[derive(Serialize, Deserialize)]
struct ErrorResponse {
    error: String,
}

/// Applies rewrite rules to an expression (Bincode).
#[unsafe(no_mangle)]
pub extern "C" fn rssn_apply_rules_to_normal_form_bincode(input: BincodeBuffer) -> BincodeBuffer {
    let input_data: Option<ApplyRulesInput> = from_bincode_buffer(&input);

    let input_data = match input_data {
        | Some(i) => i,
        | None => {
            return BincodeBuffer::empty();
        },
    };

    let result = apply_rules_to_normal_form(&input_data.expr, &input_data.rules);

    to_bincode_buffer(&result)
}

/// Applies the Knuth-Bendix completion algorithm (Bincode).
#[unsafe(no_mangle)]
pub extern "C" fn rssn_knuth_bendix_bincode(input: BincodeBuffer) -> BincodeBuffer {
    let equations: Option<Vec<Expr>> = from_bincode_buffer(&input);

    let equations = match equations {
        | Some(e) => e,
        | None => {
            return BincodeBuffer::empty();
        },
    };

    match knuth_bendix(&equations) {
        | Ok(rules) => to_bincode_buffer(&rules),
        | Err(err) => {
            let error_response = ErrorResponse { error: err };

            to_bincode_buffer(&error_response)
        },
    }
}

/// Creates a rewrite rule from Bincode.
#[unsafe(no_mangle)]
pub extern "C" fn rssn_rewrite_rule_new_bincode(input: BincodeBuffer) -> BincodeBuffer {
    let input_data: Option<RuleInput> = from_bincode_buffer(&input);

    let input_data = match input_data {
        | Some(i) => i,
        | None => {
            return BincodeBuffer::empty();
        },
    };

    let rule = RewriteRule {
        lhs: input_data.lhs,
        rhs: input_data.rhs,
    };

    to_bincode_buffer(&rule)
}

/// Converts a rewrite rule to a human-readable string (Bincode).
#[unsafe(no_mangle)]
pub extern "C" fn rssn_rewrite_rule_to_string_bincode(input: BincodeBuffer) -> BincodeBuffer {
    let rule: Option<RewriteRule> = from_bincode_buffer(&input);

    let rule = match rule {
        | Some(r) => r,
        | None => {
            return BincodeBuffer::empty();
        },
    };

    let rule_str = format!("{} -> {}", rule.lhs, rule.rhs);

    let response = StringResponse { string: rule_str };

    to_bincode_buffer(&response)
}