Struct Solution 

pub struct Solution {
    pub tree: EmlTree,
    pub mse: f64,
    pub complexity: usize,
}

A single discovered expression together with its accuracy and complexity.

Fields

tree: EmlTree

The EML tree (with fitted constants).

mse: f64

Mean-squared error on the training data.

complexity: usize

Structural complexity (EML node count).

Implementations

impl Solution

pub fn new(tree: EmlTree, mse: f64) -> Self

Build a solution from a tree and its MSE; complexity is the node count.

pub fn latex(&self) -> String

Render the expression as a LaTeX math string (via oxieml lowering + simplification).

pub fn pretty(&self) -> String

A human-readable EML form, e.g. eml(x0, 1).

pub fn rust_code(&self) -> String

Generate a standalone Rust function for the expression.

pub fn numpy_code(&self) -> String

Generate a NumPy-compatible Python lambda for the expression.

pub fn sympy_code(&self) -> String

Generate a SymPy expression string for the expression.

pub fn distill(&self) -> Distilled

Distill the expression into every supported output format at once (canonical LaTeX/pretty plus Rust/NumPy/SymPy code).

pub fn predict(&self, x: &Array2<f64>) -> Result<Array1<f64>>

Evaluate the discovered expression on new data x ([n_rows, n_vars]), returning the predictions [n_rows] through phop’s guarded forward.

Errors

Returns crate::PhopError if evaluation fails or produces non-finite values.

pub fn to_model_json(&self) -> Result<String>

Serialize the discovered law (its EML tree) to a portable JSON string — the model artifact phop predict consumes. Round-trips with Self::from_model_json.

Errors

Returns crate::PhopError::Symbolic if serialization fails.

pub fn from_model_json(s: &str) -> Result<Self>

Reconstruct a law from Self::to_model_json output. The MSE is unknown until the law is re-evaluated (left as NaN); complexity is recomputed from the tree.

Errors

Returns crate::PhopError::Parse if the JSON is not a valid serialized EML tree.

pub fn analyze(&self, wrt: usize, series_order: usize) -> Analysis

Symbolically analyze the discovered law via the oxieml CAS: derivative, antiderivative, Maclaurin series, and the +∞ limit, all w.r.t. variable wrt (see crate::analyze()).

pub fn certified_root( &self, wrt: usize, others: &[f64], lo: f64, hi: f64, ) -> Result<RootCertificate>

Find a certified root of the law in [lo, hi] along variable wrt (interval Newton/Krawczyk verification). others fixes the remaining variables (&[] for 1-D).

Errors

Returns crate::PhopError if the verifier errors.

pub fn certified_range(&self, domain: &[(f64, f64)]) -> (f64, f64)

A guaranteed interval enclosure of the law’s range over an axis-aligned domain ([lo, hi] per variable): f(x) ∈ [returned.0, returned.1] for all x in the box.

pub fn compile_rust(&self, fn_name: &str) -> String

Generate a standalone, canonical Rust function for the law (lowered + simplified over the full elementary algebra via oxieml), suitable for embedding/deployment. This differs from Self::rust_code, which emits the raw eml-form; here the recovered law is simplified to ordinary exp/ln/+/-/… first.

pub fn dominates(&self, other: &Solution) -> bool

Does this solution (weakly) Pareto-dominate other?

Domination minimizes both complexity and MSE, with strict improvement in at least one.

Trait Implementations

impl Clone for Solution

fn clone(&self) -> Solution

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Solution

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.