Struct CodeGen 

pub struct CodeGen { /* private fields */ }

Builder for generating Rust source code from symbolic expressions.

Collects multiple functions (scalar and matrix) and writes them all to a single output file with shared preamble (cfg-gated math module, etc.).

Implementations

impl CodeGen

pub fn new() -> Self

Create a new CodeGen builder with default options.

pub fn options(self, options: CodegenOptions) -> Self

Set custom code generation options.

Every registered function is emitted with these options. The special-function runtime (mod symplex_rt, needed by gamma, lambertw, Bessel functions, …) is emitted once at the top of the file when CodegenOptions::emit_runtime is true (the default) and at least one function needs it. Set emit_runtime: false to leave it out entirely — e.g. when several generated files share one copy of CodegenOptions::runtime_module:

use symplex::matrix::{CodegenOptions, MathBackend};
use symplex::prelude::*;
use symplex_build::CodeGen;

let ctx = Context::new();
let x = ctx.symbol("x");
let opts = CodegenOptions {
    math_backend: MathBackend::CfgGated,
    emit_runtime: false,
    ..Default::default()
};
let body = CodeGen::new()
    .options(opts.clone())
    .add_scalar_fn("g", &x.gamma(), &["x"])
    .add_scalar_fn("w", &x.lambertw(), &["x"])
    .generate()
    .unwrap();
std::fs::write("robot_math.rs", body).unwrap();
std::fs::write("symplex_rt.rs", opts.runtime_module()).unwrap();

pub fn no_std(self, enabled: bool) -> Self

Enable or disable no_std-compatible output (uses the CfgGated math backend).

pub fn precision_f32(self) -> Self

Use f32 precision for generated code.

pub fn inline(self, enabled: bool) -> Self

Set whether to emit #[inline] annotations on generated functions.

pub fn add_scalar_fn(self, name: &str, expr: &Ex, params: &[&str]) -> Self

Add a scalar function to the output.

The generated function will take the named parameters as f64 (or f32) arguments and return the scalar result.

pub fn add_matrix_fn(self, name: &str, matrix: &Matrix, params: &[&str]) -> Self

Add a matrix function to the output.

The generated function will take the named parameters and return a flat array [f64; rows*cols] in row-major order.

pub fn with_tests(self, enabled: bool) -> Self

Enable or disable companion test generation.

When enabled, a #[cfg(test)] mod generated_tests { ... } block is appended with test functions that evaluate at any configured test points.

pub fn add_test_point(self, point: &[f64]) -> Self

Add a test evaluation point.

Each test point is a slice of f64 values corresponding to the function parameters in order. During test generation, each function is called with each test point to verify it produces a finite result.

pub fn generate(&self) -> Result<String, Box<dyn Error>>

Generate the full source file as a String.

1. If the math backend is CfgGated, emits the cfg-gated math module (once; the per-function copies are stripped).
2. If CodegenOptions::emit_runtime is set and any registered function uses a special function, emits the mod symplex_rt runtime once, containing exactly the helpers the file needs.
3. For each registered function, calls the appropriate symplex codegen method.
4. If test generation is enabled, emits a #[cfg(test)] module.

pub fn write_to_out_dir(&self, filename: &str) -> Result<(), Box<dyn Error>>

Generate code and write it to $OUT_DIR/<filename>.

Also prints cargo:rerun-if-changed=build.rs so Cargo knows when to re-run the build script.

pub fn write_to_path( &self, path: impl AsRef<Path>, ) -> Result<(), Box<dyn Error>>

Generate code and write it to an explicit path.

Trait Implementations

impl Default for CodeGen

fn default() -> Self

Returns the “default value” for a type.