Add helper function to simplify and change register count

CHANGELOG.md

@@ -1,3 +1,9 @@
+# 0.3.4 (unreleased)
+- Add `GenericVmFunction::simplify_with` to simultaneously simplify a function
+  and pick a new register count for the resulting tape
+- Add bidirectional conversions between `JitFunction` and `GenericVmFunction`
+  (exposing the inner data member)
+
 # 0.3.3
 - `Function` and evaluator types now produce multiple outputs
     - `MathFunction::new` now takes a slice of nodes, instead of a single node

fidget/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "fidget"
-version = "0.3.3"
+version = "0.3.4"
 edition = "2021"
 license = "MPL-2.0"
 repository = "https://github.com/mkeeter/fidget"

fidget/src/core/vm/mod.rs

@@ -135,6 +135,17 @@ impl<const N: usize> GenericVmFunction<N> {
     pub fn choice_count(&self) -> usize {
         self.0.choice_count()
     }
+
+    /// Simplifies the function with the given trace and a new register count
+    pub fn simplify_with<const M: usize>(
+        &self,
+        trace: &VmTrace,
+        storage: VmData<M>,
+        workspace: &mut VmWorkspace<M>,
+    ) -> Result<GenericVmFunction<M>, Error> {
+        let d = self.0.simplify::<M>(trace.as_slice(), workspace, storage)?;
+        Ok(GenericVmFunction(Arc::new(d)))
+    }
 }
 
 impl<const N: usize> Function for GenericVmFunction<N> {
@@ -166,8 +177,7 @@ impl<const N: usize> Function for GenericVmFunction<N> {
         storage: Self::Storage,
         workspace: &mut Self::Workspace,
     ) -> Result<Self, Error> {
-        let d = self.0.simplify(trace.as_slice(), workspace, storage)?;
-        Ok(Self(Arc::new(d)))
+        self.simplify_with(trace, storage, workspace)
     }
 
     fn recycle(self) -> Option<Self::Storage> {

fidget/src/jit/mod.rs

@@ -926,6 +926,24 @@ impl RenderHints for JitFunction {
     }
 }
 
+impl MathFunction for JitFunction {
+    fn new(ctx: &Context, nodes: &[Node]) -> Result<Self, Error> {
+        GenericVmFunction::new(ctx, nodes).map(JitFunction)
+    }
+}
+
+impl From<GenericVmFunction<REGISTER_LIMIT>> for JitFunction {
+    fn from(v: GenericVmFunction<REGISTER_LIMIT>) -> Self {
+        Self(v)
+    }
+}
+
+impl<'a> From<&'a JitFunction> for &'a GenericVmFunction<REGISTER_LIMIT> {
+    fn from(v: &'a JitFunction) -> Self {
+        &v.0
+    }
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 
 // Selects the calling convention based on platform; this is forward-looking for
@@ -1278,12 +1296,6 @@ impl BulkEvaluator for JitGradSliceEval {
     }
 }
 
-impl MathFunction for JitFunction {
-    fn new(ctx: &Context, nodes: &[Node]) -> Result<Self, Error> {
-        GenericVmFunction::new(ctx, nodes).map(JitFunction)
-    }
-}
-
 /// A [`Shape`](crate::shape::Shape) which uses the JIT evaluator
 pub type JitShape = crate::shape::Shape<JitFunction>;