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

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

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::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>,
}

/// Applies rewrite rules to an expression (JSON).
///
/// Input: JSON object with "expr" and "rules" fields
/// Output: JSON-serialized Expr (the normal form)
#[unsafe(no_mangle)]
pub extern "C" fn rssn_apply_rules_to_normal_form_json(json_str: *const c_char) -> *mut c_char {
    let input: Option<ApplyRulesInput> = from_json_string(json_str);

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

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

    to_json_string(&result)
}

/// Applies the Knuth-Bendix completion algorithm (JSON).
///
/// Input: JSON array of equations (`Expr::Eq`)
/// Output: JSON array of `RewriteRule` objects
#[unsafe(no_mangle)]
pub extern "C" fn rssn_knuth_bendix_json(json_str: *const c_char) -> *mut c_char {
    let equations: Option<Vec<Expr>> = from_json_string(json_str);

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

    match knuth_bendix(&equations) {
        | Ok(rules) => to_json_string(&rules),
        | Err(err) => {
            let error_response = serde_json::json!({ "error": err });

            to_json_string(&error_response)
        },
    }
}

/// Creates a rewrite rule from JSON.
///
/// Input: JSON object with "lhs" and "rhs" fields (both Expr)
/// Output: JSON-serialized `RewriteRule`
#[unsafe(no_mangle)]
pub extern "C" fn rssn_rewrite_rule_new_json(json_str: *const c_char) -> *mut c_char {
    #[derive(Deserialize)]
    struct RuleInput {
        lhs: Expr,
        rhs: Expr,
    }

    let input: Option<RuleInput> = from_json_string(json_str);

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

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

    to_json_string(&rule)
}

/// Converts a rewrite rule to a human-readable string (JSON).
///
/// Input: JSON-serialized `RewriteRule`
/// Output: JSON object with "string" field
#[unsafe(no_mangle)]
pub extern "C" fn rssn_rewrite_rule_to_string_json(json_str: *const c_char) -> *mut c_char {
    let rule: Option<RewriteRule> = from_json_string(json_str);

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

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

    let response = serde_json::json!({ "string": rule_str });

    to_json_string(&response)
}