phop-core 0.1.0

Core engine for phop: tensorized EML forests, differentiable topology, and discovery
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

//! Code generation for discovered EML expressions (Rust, Python/NumPy).
//!
//! LaTeX rendering is delegated to `oxieml` (`tree.lower().simplify().to_latex()`); this
//! module emits executable source in other targets directly from the EML AST.

use oxieml::{EmlNode, EmlTree};

fn rust_expr(node: &EmlNode) -> String {
    match node {
        EmlNode::One => "1.0_f64".to_string(),
        EmlNode::Const(c) => format!("{c}_f64"),
        EmlNode::Var(i) => format!("x{i}"),
        EmlNode::Eml { left, right } => format!(
            "(({}).exp() - ({}).ln())",
            rust_expr(left),
            rust_expr(right)
        ),
    }
}

fn numpy_expr(node: &EmlNode) -> String {
    match node {
        EmlNode::One => "1.0".to_string(),
        EmlNode::Const(c) => format!("{c}"),
        EmlNode::Var(i) => format!("x{i}"),
        EmlNode::Eml { left, right } => format!(
            "(np.exp({}) - np.log({}))",
            numpy_expr(left),
            numpy_expr(right)
        ),
    }
}

fn sympy_expr(node: &EmlNode) -> String {
    match node {
        EmlNode::One => "1".to_string(),
        EmlNode::Const(c) => format!("{c}"),
        EmlNode::Var(i) => format!("x{i}"),
        EmlNode::Eml { left, right } => {
            format!("(exp({}) - log({}))", sympy_expr(left), sympy_expr(right))
        }
    }
}

/// Generate a standalone Rust function `f(x0, x1, ...) -> f64` for the tree.
#[must_use]
pub fn rust_code(tree: &EmlTree) -> String {
    let n = tree.num_vars().max(1);
    let args = (0..n)
        .map(|i| format!("x{i}: f64"))
        .collect::<Vec<_>>()
        .join(", ");
    format!("fn f({args}) -> f64 {{ {} }}", rust_expr(&tree.root))
}

/// Generate a NumPy-compatible Python lambda body for the tree.
#[must_use]
pub fn numpy_code(tree: &EmlTree) -> String {
    let n = tree.num_vars().max(1);
    let args = (0..n)
        .map(|i| format!("x{i}"))
        .collect::<Vec<_>>()
        .join(", ");
    format!("lambda {args}: {}", numpy_expr(&tree.root))
}

/// Generate a SymPy expression string for the tree.
///
/// The result uses SymPy's `exp` / `log` and bare symbols `x0, x1, …`; it parses under
/// `from sympy import exp, log, symbols` (with the `xi` declared as symbols) and can then be
/// `simplify`-ed Python-side. The variables are listed in the doc comment of the emitted code.
#[must_use]
pub fn sympy_code(tree: &EmlTree) -> String {
    let n = tree.num_vars().max(1);
    let syms = (0..n)
        .map(|i| format!("x{i}"))
        .collect::<Vec<_>>()
        .join(" ");
    format!("# symbols('{syms}')\n{}", sympy_expr(&tree.root))
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn rust_codegen_for_exp() {
        let tree = oxieml::Canonical::exp(&EmlTree::var(0));
        let code = rust_code(&tree);
        assert!(code.contains("fn f("));
        assert!(code.contains(".exp()"));
    }

    #[test]
    fn numpy_codegen_for_exp() {
        let tree = oxieml::Canonical::exp(&EmlTree::var(0));
        let code = numpy_code(&tree);
        assert!(code.contains("np.exp"));
    }

    #[test]
    fn sympy_codegen_for_exp() {
        let tree = oxieml::Canonical::exp(&EmlTree::var(0));
        let code = sympy_code(&tree);
        assert!(code.contains("exp("));
        assert!(code.contains("log("));
        assert!(code.contains("x0"));
    }
}