Recursive case somewhat working, correct math primitive in ForwardADSignalTransform .

Author: sletz

compiler/transform/forwardADSignalTransform.cpp

@@ -21,43 +21,41 @@
 
 #include "forwardADSignalTransform.hh"
 #include <string>  // For std::string and std::string::find
+#include "description.hh"
 #include "global.hh"
 #include "list.hh"
 #include "ppsig.hh"
 #include "signalVisitor.hh"  // For DependencyVisitor
 #include "xtended.hh"
 
 /**
- * @brief Parses the label of a UI control to check for the [autodiff:false] tag.
+ * @brief Parses the label of a UI control to check for the [autodiff:xxx] tag.
  *
  * Faust UI element labels can contain metadata in the form of `[key:value]`.
  * This function checks for the specific tag that disables automatic differentiation
  * for a given parameter.
  *
- * @param label_path_tree The 'path' Tree associated with a UI element like hslider.
+ * @param label The 'path' Tree associated with a UI element like hslider.
  * This is expected to be a list, where the head is the local label.
- * @return true if the "[autodiff:false]" tag is found in the label string, false otherwise.
+ * @return false if the "[autodiff:false]" tag is found in the label string, true otherwise.
  */
-static bool hasAutodiffFalseTag(Tree label_path_tree)
+static bool hasAutodiff(Tree label)
 {
-    if (!label_path_tree || isNil(label_path_tree)) {
-        return false;
-    }
-    try {
-        // The label path is a list of symbols. The local label is the first element.
-        // We convert its symbol node to a string to inspect it.
-        const char* label_str = tree2str(hd(label_path_tree));
-        if (label_str) {
-            // Perform a simple substring search for the metadata tag.
-            return std::string(label_str).find("[autodiff:false]") != std::string::npos;
+    std::map<std::string, std::set<std::string>> metadata;
+    std::string                                  simplifiedLabel;
+
+    extractMetadata(tree2str(hd(label)), simplifiedLabel, metadata);
+
+    // Look for [autodiff:false]
+    for (const auto& i : metadata) {
+        if (i.first == "autodiff") {
+            const std::set<std::string>& values = i.second;
+            for (const auto& j : values) {
+                return (j == "true");
+            }
         }
-    } catch (const faustexception& e) {
-        // tree2str can throw an exception if the tree is not a symbol,
-        // which can happen with complex/computed labels. In that case,
-        // we assume no tag is present.
-        return false;
     }
-    return false;
+    return true;
 }
 
 /**
@@ -82,13 +80,10 @@ struct ADDependencyVisitor : public SignalVisitor {
         if (isSigVSlider(sig, path, c, x, y, z) || isSigHSlider(sig, path, c, x, y, z) ||
             isSigNumEntry(sig, path, c, x, y, z)) {
             // Check the label for the [autodiff:false] tag.
-            if (!hasAutodiffFalseTag(path)) {
-                // If the tag is not present, add this control to the set of
-                // parameters that will be differentiated.
+            if (hasAutodiff(path)) {
                 fControls.insert(sig);
             }
             // If the tag is present, we do nothing, effectively excluding it.
-
         } else {
             // For all other signal types, continue the traversal to visit children.
             SignalVisitor::visit(sig);
@@ -100,7 +95,7 @@ struct ADDependencyVisitor : public SignalVisitor {
  * @brief Extracts the first element (head) of each pair in a list of pairs.
  * * Given a list of dual numbers `((p1, t1), (p2, t2), ...)` this function
  * returns a new list containing only the primal components: `(p1, p2, ...)`.
- * * @param list_of_pairs A Tree representing a list of pairs.
+ * @param list_of_pairs A Tree representing a list of pairs.
  * @return A new Tree representing the list of first elements.
  */
 static Tree mapHd(Tree list_of_pairs)
@@ -122,7 +117,7 @@ static Tree mapHd(Tree list_of_pairs)
  * @brief Extracts the second element (head of the tail) of each pair in a list of pairs.
  * * Given a list of dual numbers `((p1, t1), (p2, t2), ...)` this function
  * returns a new list containing only the tangent components: `(t1, t2, ...)`.
- * * @param list_of_pairs A Tree representing a list of pairs.
+ * @param list_of_pairs A Tree representing a list of pairs.
  * @return A new Tree representing the list of second elements.
  */
 static Tree mapHdTl(Tree list_of_pairs)
@@ -166,13 +161,15 @@ Tree ForwardADSignalTransform::transformation(Tree sig)
     // Handle constants: The derivative of any constant is zero.
     if (isSigReal(sig, &r_val)) {
         // Return the dual number (constant_real, 0.0)
-        return cons(sig, cons(sigReal(0.0), gGlobal->nil));
-    } else if (isSigInt(sig, &i_val) || isSigInt64(sig, &i64_val)) {
+        return dual(sig, sigReal(0.0));
+    }
+
+    if (isSigInt(sig, &i_val) || isSigInt64(sig, &i64_val)) {
         // Return the dual number (constant_int, 0)
         // Note: While derivatives are floats, we create a typed integer zero
         // which will be cast to float automatically by arithmetic operations.
         // A more robust implementation might cast to float immediately.
-        return cons(sig, cons(sigInt(0), gGlobal->nil));
+        return dual(sig, sigInt(0));
     }
 
     // Handle differentiable UI controls (sliders, nentries).
@@ -182,13 +179,13 @@ Tree ForwardADSignalTransform::transformation(Tree sig)
         // its derivative is 1. Otherwise, it's treated as a constant, so its derivative is 0.
         Tree tangent = (sig == fDiffControl) ? sigReal(1.0) : sigReal(0.0);
         // Return the dual number (control, 1.0 or 0.0)
-        return cons(sig, cons(tangent, gGlobal->nil));
+        return dual(sig, tangent);
     }
 
     // Handle non-differentiable UI elements like buttons. Their derivative is 0.
     if (isSigButton(sig, label) || isSigCheckbox(sig, label)) {
         // Return the dual number (button, 0.0)
-        return cons(sig, cons(sigReal(0.0), gGlobal->nil));
+        return dual(sig, sigReal(0.0));
     }
 
     // Math primitives
@@ -202,33 +199,34 @@ Tree ForwardADSignalTransform::transformation(Tree sig)
         if (ext == gGlobal->gPowPrim || ext == gGlobal->gFmodPrim ||
             ext == gGlobal->gRemainderPrim || ext == gGlobal->gMaxPrim ||
             ext == gGlobal->gMinPrim) {
-            
-            // Derivative of these primitives require f, g, f' and g'.
             Tree dual_x = self(sig->branch(0));  // This will be (primal_x, tangent_x)
             Tree dual_y = self(sig->branch(1));  // This will be (primal_y, tangent_y)
 
-            Tree primal_x  = hd(dual_x);
-            Tree tangent_x = hd(tl(dual_x));
+            Tree primal_x  = primal(dual_x);
+            Tree tangent_x = tangent(dual_x);
 
-            Tree primal_y  = hd(dual_y);
-            Tree tangent_y = hd(tl(dual_y));
+            Tree primal_y  = primal(dual_y);
+            Tree tangent_y = tangent(dual_y);
 
             std::vector<Tree> primal_args;
             primal_args.push_back(primal_x);
             primal_args.push_back(primal_y);
             Tree new_primal = ext->computeSigOutput(primal_args);
 
+            // Derivative of these primitives require f, g, f' and g'.
             std::vector<Tree> tangent_args;
+            tangent_args.push_back(primal_x);
+            tangent_args.push_back(primal_y);
             tangent_args.push_back(tangent_x);
             tangent_args.push_back(tangent_y);
             Tree new_tangent = ext->diff(tangent_args);
 
-            return cons(new_primal, cons(new_tangent, gGlobal->nil));
+            return dual(new_primal, new_tangent);
         } else {
             // chain rule for unary function: f(g(x))' = f'(g(x)) * g'(x)
             Tree dual_x    = self(sig->branch(0));
-            Tree primal_x  = hd(dual_x);
-            Tree tangent_x = hd(tl(dual_x));
+            Tree primal_x  = primal(dual_x);
+            Tree tangent_x = tangent(dual_x);
 
             std::vector<Tree> primal_args;
             primal_args.push_back(primal_x);
@@ -238,7 +236,7 @@ Tree ForwardADSignalTransform::transformation(Tree sig)
             tangent_args.push_back(primal_x);
             Tree new_tangent = sigMul(ext->diff(tangent_args), tangent_x);
 
-            return cons(new_primal, cons(new_tangent, gGlobal->nil));
+            return dual(new_primal, new_tangent);
         }
     }
 
@@ -249,10 +247,10 @@ Tree ForwardADSignalTransform::transformation(Tree sig)
         Tree dual_y = self(y);  // This will be (primal_y, tangent_y)
 
         // Deconstruct the dual number lists to get their components.
-        Tree primal_x  = hd(dual_x);
-        Tree tangent_x = hd(tl(dual_x));
-        Tree primal_y  = hd(dual_y);
-        Tree tangent_y = hd(tl(dual_y));
+        Tree primal_x  = primal(dual_x);
+        Tree tangent_x = tangent(dual_x);
+        Tree primal_y  = primal(dual_y);
+        Tree tangent_y = tangent(dual_y);
 
         // The new primal is the same operation applied to the children's primals.
         Tree new_primal = sigBinOp(opt_op, primal_x, primal_y);
@@ -285,32 +283,37 @@ Tree ForwardADSignalTransform::transformation(Tree sig)
                 break;
         }
         // Return the newly constructed dual number signal.
-        return cons(new_primal, cons(new_tangent, gGlobal->nil));
+        return dual(new_primal, new_tangent);
     }
 
     // Handle one-sample delay. The derivative of a delay is the delay of the derivative.
     if (isSigDelay1(sig, u_tree)) {
         Tree dual_u    = self(u_tree);
-        Tree primal_u  = hd(dual_u);
-        Tree tangent_u = hd(tl(dual_u));
+        Tree primal_u  = primal(dual_u);
+        Tree tangent_u = tangent(dual_u);
         // Apply delay to both the primal and tangent signals.
         Tree new_primal  = sigDelay1(primal_u);
         Tree new_tangent = sigDelay1(tangent_u);
-        return cons(new_primal, cons(new_tangent, gGlobal->nil));
+        return dual(new_primal, new_tangent);
     }
 
     // Handle variable-length delay.
     // For this to be mathematically meaningful, the underlying implementation of the
     // variable delay must be interpolating and differentiable.
     if (isSigDelay(sig, u_tree, d_tree)) {
+        Node n = d_tree->node();
+        if (isZero(n)) {
+            return self(u_tree);
+        }
+
         // Recursively get dual signals for the input signal 'u' and delay time 'd'.
         Tree dual_u = self(u_tree);
         Tree dual_d = self(d_tree);
 
-        Tree primal_u  = hd(dual_u);
-        Tree tangent_u = hd(tl(dual_u));  // This is u'
-        Tree primal_d  = hd(dual_d);
-        Tree tangent_d = hd(tl(dual_d));  // This is d'
+        Tree primal_u  = primal(dual_u);
+        Tree tangent_u = tangent(dual_u);  // This is u'
+        Tree primal_d  = primal(dual_d);
+        Tree tangent_d = tangent(dual_d);  // This is d'
 
         // The new primal is the variable delay applied to the primal signal.
         Tree new_primal = sigDelay(primal_u, primal_d);
@@ -335,79 +338,79 @@ Tree ForwardADSignalTransform::transformation(Tree sig)
         // The final tangent is the sum of the two terms.
         Tree new_tangent = sigAdd(term1, term2);
 
-        return cons(new_primal, cons(new_tangent, gGlobal->nil));
+        return dual(new_primal, new_tangent);
     }
 
     // Handle conditional selection (multiplexer).
     Tree sel, tx, ty;
     if (isSigSelect2(sig, sel, tx, ty)) {
-        Tree dual_sel = self(sel);
-        Tree dual_x   = self(tx);
-        Tree dual_y   = self(ty);
-
-        Tree primal_sel  = hd(dual_sel);
-        Tree new_primal  = sigSelect2(primal_sel, hd(dual_x), hd(dual_y));
-        Tree new_tangent = sigSelect2(primal_sel, hd(tl(dual_x)), hd(tl(dual_y)));
-
-        return cons(new_primal, cons(new_tangent, gGlobal->nil));
+        Tree dual_sel    = self(sel);
+        Tree dual_x      = self(tx);
+        Tree dual_y      = self(ty);
+        Tree primal_sel  = primal(dual_sel);
+        Tree new_primal  = sigSelect2(primal_sel, primal(dual_x), primal(dual_y));
+        Tree new_tangent = sigSelect2(primal_sel, tangent(dual_x), tangent(dual_y));
+        return dual(new_primal, new_tangent);
     }
 
     // Handle prefix operator (one-sample initialization).
     if (isSigPrefix(sig, x, y)) {
-        Tree dual_x = self(x);
-        Tree dual_y = self(y);
-
-        Tree new_primal  = sigPrefix(hd(dual_x), hd(dual_y));
-        Tree new_tangent = sigPrefix(hd(tl(dual_x)), hd(tl(dual_y)));
-
-        return cons(new_primal, cons(new_tangent, gGlobal->nil));
+        Tree dual_x      = self(x);
+        Tree dual_y      = self(y);
+        Tree new_primal  = sigPrefix(primal(dual_x), primal(dual_y));
+        Tree new_tangent = sigPrefix(tangent(dual_x), tangent(dual_y));
+        return dual(new_primal, new_tangent);
     }
 
     // Handle type casting.
     if (isSigFloatCast(sig, x)) {
         Tree dual_x      = self(x);
-        Tree new_primal  = sigFloatCast(hd(dual_x));
-        Tree new_tangent = sigFloatCast(hd(tl(dual_x)));
-        return cons(new_primal, cons(new_tangent, gGlobal->nil));
+        Tree new_primal  = sigFloatCast(primal(dual_x));
+        Tree new_tangent = sigFloatCast(tangent(dual_x));
+        return dual(new_primal, new_tangent);
     }
 
     if (isSigIntCast(sig, x)) {
         Tree dual_x      = self(x);
-        Tree new_primal  = sigIntCast(hd(dual_x));
+        Tree new_primal  = sigIntCast(primal(dual_x));
         Tree new_tangent = sigReal(0.0);
-        return cons(new_primal, cons(new_tangent, gGlobal->nil));
+        return dual(new_primal, new_tangent);
     }
 
     // Handle recursion (rec/proj).
     // Based on the rule (rec(u))' = rec(u'), we differentiate 'through' the recursion.
-    Tree rec_block;
-    if (isRec(sig, x, y)) {
-        /*
-        if (getUserData(sig)) {
-            return getUserData(sig);
-        }
-        */
+    Tree rec_block, var, body;
+    if (isRec(sig, var, body)) {
+        if (isNil(body)) {
+            // we are already visiting this recursive group
+            return dual(sig, sig);
+        } else {
+            // first visit
+            rec(var, gGlobal->nil);  // to avoid infinite recursions
 
-        Tree dual_list           = mapself(y);
-        Tree primal_expressions  = mapHd(dual_list);
-        Tree tangent_expressions = mapHdTl(dual_list);
+            // compute the recursion
+            Tree dual_list           = mapselfRec(body);
+            Tree primal_expressions  = mapHd(dual_list);
+            Tree tangent_expressions = mapHdTl(dual_list);
 
-        Tree primal_rec  = rec(x, primal_expressions);
-        Tree tangent_rec = rec(x, tangent_expressions);
+            // new symbol for differentiated rec
+            Tree dvar(tree(unique("DW")));
 
-        Tree result = cons(primal_rec, cons(tangent_rec, gGlobal->nil));
-        // setUserData(sig, result);
-        return result;
+            Tree primal_rec  = rec(var, primal_expressions);
+            Tree tangent_rec = rec(dvar, tangent_expressions);
+            return dual(primal_rec, tangent_rec);
+        }
     }
 
     int rec_idx;
     if (isProj(sig, &rec_idx, rec_block)) {
         Tree dual_rec_block = self(rec_block);
-        Tree primal_rec     = hd(dual_rec_block);
-        Tree tangent_rec    = hd(tl(dual_rec_block));
+        Tree primal_rec     = primal(dual_rec_block);
+        Tree tangent_rec    = tangent(dual_rec_block);
         Tree new_primal     = sigProj(rec_idx, primal_rec);
         Tree new_tangent    = sigProj(rec_idx, tangent_rec);
-        return cons(new_primal, cons(new_tangent, gGlobal->nil));
+
+        return dual(new_primal, new_tangent);
     }
 
     // Handle output nodes.
@@ -416,7 +419,7 @@ Tree ForwardADSignalTransform::transformation(Tree sig)
     }
 
     // Fallback for any unhandled signal types. Treat them as constants.
-    return cons(sig, cons(sigReal(0.0), gGlobal->nil));
+    return dual(sig, sigReal(0.0));
 }
 
 /**
@@ -452,7 +455,7 @@ siglist generateADSignals(const siglist& outputs_list_aux)
             Tree dual_signal = ad_transform.self(out_sig);
 
             // The result is a dual number (primal, tangent). We only need the tangent part.
-            Tree derivative_signal = hd(tl(dual_signal));
+            Tree derivative_signal = tangent(dual_signal);
 
             // Add the new derivative signal to our master list of signals.
             all_signals = cons(derivative_signal, all_signals);