Higher order handling for special functions.

Author: MaxSagebaum

regression-tests/pure2-autodiff-higher-order.cpp2

@@ -51,6 +51,18 @@ ad_test: @autodiff<"order=6"> @print type = {
     add_mul: (x: double, y: double) -> (r: double) = {
         r = x + x * y;
     }
+
+    func: (x: double, y: double) -> (r: double) = {
+      r = x + y;
+    }
+
+    func_call: (x: double, y: double) -> (r: double) = {
+      r = x * func(x, y);
+    }
+
+    sin_call: (x: double, y: double) -> (r: double) = {
+      r = sin(x - y);
+    }
 }
 
 write_output: (func: std::string, x: double, x_d: ad_type, y: double, y_d: ad_type, ret) = {
@@ -82,8 +94,8 @@ main: () = {
     write_output("x * y / x", x, x_d, y, y_d, ad_test::mul_div_2_d(x, x_d, y, y_d));
     write_output("x * (x + y)", x, x_d, y, y_d, ad_test::mul_add_d(x, x_d, y, y_d));
     write_output("x + x * y", x, x_d, y, y_d, ad_test::add_mul_d(x, x_d, y, y_d));
-//    write_output("x * func(x, y)", x, x_d, y, y_d, ad_test::func_call_d(x, x_d, y, y_d));
-//    write_output("sin(x + y)", x, x_d, y, y_d, ad_test::sin_call_d(x, x_d, y, y_d));
+    write_output("x * func(x, y)", x, x_d, y, y_d, ad_test::func_call_d(x, x_d, y, y_d));
+    write_output("sin(x - y)", x, x_d, y, y_d, ad_test::sin_call_d(x, x_d, y, y_d));
 //    write_output("if branch", x, x_d, y, y_d, ad_test::if_branch_d(x, x_d, y, y_d));
 //    write_output("if else branch", x, x_d, y, y_d, ad_test::if_else_branch_d(x, x_d, y, y_d));
 //    write_output("direct return", x, x_d, y, y_d, ad_test::direct_return_d(x, x_d, y, y_d));

regression-tests/pure2-autodiff.cpp2

@@ -182,7 +182,7 @@ main: () = {
     write_output("x * (x + y)", x, x_d, y, y_d, ad_test::mul_add_d(x, x_d, y, y_d));
     write_output("x + x * y", x, x_d, y, y_d, ad_test::add_mul_d(x, x_d, y, y_d));
     write_output("x * func(x, y)", x, x_d, y, y_d, ad_test::func_call_d(x, x_d, y, y_d));
-    write_output("sin(x + y)", x, x_d, y, y_d, ad_test::sin_call_d(x, x_d, y, y_d));
+    write_output("sin(x - y)", x, x_d, y, y_d, ad_test::sin_call_d(x, x_d, y, y_d));
     write_output("if branch", x, x_d, y, y_d, ad_test::if_branch_d(x, x_d, y, y_d));
     write_output("if else branch", x, x_d, y, y_d, ad_test::if_else_branch_d(x, x_d, y, y_d));
     write_output("direct return", x, x_d, y, y_d, ad_test::direct_return_d(x, x_d, y, y_d));

regression-tests/test-results/gcc-13-c++2b/pure2-autodiff-higher-order.cpp.execution

@@ -94,3 +94,19 @@ diff(x + x * y) at (x = 2.000000, x_d = ( 1.000000 0.000000 0.000000 0.000000 0.
   d4 = 0.000000
   d5 = 0.000000
   d6 = 0.000000
+diff(x * func(x, y)) at (x = 2.000000, x_d = ( 1.000000 0.000000 0.000000 0.000000 0.000000 0.000000 ), y = 3.000000, y_d = ( 2.000000 0.000000 0.000000 0.000000 0.000000 0.000000 )):
+  r = 10.000000
+  d1 = 11.000000
+  d2 = 6.000000
+  d3 = 0.000000
+  d4 = 0.000000
+  d5 = 0.000000
+  d6 = 0.000000
+diff(sin(x - y)) at (x = 2.000000, x_d = ( 1.000000 0.000000 0.000000 0.000000 0.000000 0.000000 ), y = 3.000000, y_d = ( 2.000000 0.000000 0.000000 0.000000 0.000000 0.000000 )):
+  r = -0.841471
+  d1 = -0.540302
+  d2 = 0.841471
+  d3 = 0.540302
+  d4 = -0.841471
+  d5 = -0.540302
+  d6 = 0.841471

regression-tests/test-results/gcc-13-c++2b/pure2-autodiff.cpp.execution

@@ -11,7 +11,7 @@ diff(x * y / x) at (x = 2.000000, x_d = 1.000000, y = 3.000000, y_d = 2.000000)
 diff(x * (x + y)) at (x = 2.000000, x_d = 1.000000, y = 3.000000, y_d = 2.000000) = (r = 10.000000, r_d = 11.000000)
 diff(x + x * y) at (x = 2.000000, x_d = 1.000000, y = 3.000000, y_d = 2.000000) = (r = 8.000000, r_d = 8.000000)
 diff(x * func(x, y)) at (x = 2.000000, x_d = 1.000000, y = 3.000000, y_d = 2.000000) = (r = 10.000000, r_d = 11.000000)
-diff(sin(x + y)) at (x = 2.000000, x_d = 1.000000, y = 3.000000, y_d = 2.000000) = (r = -0.841471, r_d = -0.540302)
+diff(sin(x - y)) at (x = 2.000000, x_d = 1.000000, y = 3.000000, y_d = 2.000000) = (r = -0.841471, r_d = -0.540302)
 diff(if branch) at (x = 2.000000, x_d = 1.000000, y = 3.000000, y_d = 2.000000) = (r = 2.000000, r_d = 1.000000)
 diff(if else branch) at (x = 2.000000, x_d = 1.000000, y = 3.000000, y_d = 2.000000) = (r = 2.000000, r_d = 1.000000)
 diff(direct return) at (x = 2.000000, x_d = 1.000000, y = 3.000000, y_d = 2.000000) = (r = 5.000000, r_d = 3.000000)

regression-tests/test-results/pure2-autodiff-higher-order.cpp

@@ -82,6 +82,21 @@ using add_mul_ret = double;
 
 #line 51 "pure2-autodiff-higher-order.cpp2"
     public: [[nodiscard]] static auto add_mul(cpp2::impl::in<double> x, cpp2::impl::in<double> y) -> add_mul_ret;
+using func_ret = double;
+
+
+#line 55 "pure2-autodiff-higher-order.cpp2"
+    public: [[nodiscard]] static auto func(cpp2::impl::in<double> x, cpp2::impl::in<double> y) -> func_ret;
+using func_call_ret = double;
+
+
+#line 59 "pure2-autodiff-higher-order.cpp2"
+    public: [[nodiscard]] static auto func_call(cpp2::impl::in<double> x, cpp2::impl::in<double> y) -> func_call_ret;
+using sin_call_ret = double;
+
+
+#line 63 "pure2-autodiff-higher-order.cpp2"
+    public: [[nodiscard]] static auto sin_call(cpp2::impl::in<double> x, cpp2::impl::in<double> y) -> sin_call_ret;
 struct add_1_d_ret { double r; cpp2::taylor<double,6> r_d; };
 
 
@@ -131,17 +146,29 @@ struct add_mul_d_ret { double r; cpp2::taylor<double,6> r_d; };
 
 public: [[nodiscard]] static auto add_mul_d(cpp2::impl::in<double> x, cpp2::impl::in<cpp2::taylor<double,6>> x_d, cpp2::impl::in<double> y, cpp2::impl::in<cpp2::taylor<double,6>> y_d) -> add_mul_d_ret;
 
+struct func_d_ret { double r; cpp2::taylor<double,6> r_d; };
+
+public: [[nodiscard]] static auto func_d(cpp2::impl::in<double> x, cpp2::impl::in<cpp2::taylor<double,6>> x_d, cpp2::impl::in<double> y, cpp2::impl::in<cpp2::taylor<double,6>> y_d) -> func_d_ret;
+
+struct func_call_d_ret { double r; cpp2::taylor<double,6> r_d; };
+
+public: [[nodiscard]] static auto func_call_d(cpp2::impl::in<double> x, cpp2::impl::in<cpp2::taylor<double,6>> x_d, cpp2::impl::in<double> y, cpp2::impl::in<cpp2::taylor<double,6>> y_d) -> func_call_d_ret;
+
+struct sin_call_d_ret { double r; cpp2::taylor<double,6> r_d; };
+
+public: [[nodiscard]] static auto sin_call_d(cpp2::impl::in<double> x, cpp2::impl::in<cpp2::taylor<double,6>> x_d, cpp2::impl::in<double> y, cpp2::impl::in<cpp2::taylor<double,6>> y_d) -> sin_call_d_ret;
+
     public: ad_test() = default;
     public: ad_test(ad_test const&) = delete; /* No 'that' constructor, suppress copy */
     public: auto operator=(ad_test const&) -> void = delete;
 
 
-#line 54 "pure2-autodiff-higher-order.cpp2"
+#line 66 "pure2-autodiff-higher-order.cpp2"
 };
 
 auto write_output(cpp2::impl::in<std::string> func, cpp2::impl::in<double> x, cpp2::impl::in<ad_type> x_d, cpp2::impl::in<double> y, cpp2::impl::in<ad_type> y_d, auto const& ret) -> void;
 
-#line 65 "pure2-autodiff-higher-order.cpp2"
+#line 77 "pure2-autodiff-higher-order.cpp2"
 auto main() -> int;
 
 //=== Cpp2 function definitions =================================================
@@ -232,6 +259,27 @@ auto main() -> int;
         r.construct(x + x * y);
     return std::move(r.value()); }
 
+#line 55 "pure2-autodiff-higher-order.cpp2"
+    [[nodiscard]] auto ad_test::func(cpp2::impl::in<double> x, cpp2::impl::in<double> y) -> func_ret{
+          cpp2::impl::deferred_init<double> r;
+#line 56 "pure2-autodiff-higher-order.cpp2"
+      r.construct(x + y);
+    return std::move(r.value()); }
+
+#line 59 "pure2-autodiff-higher-order.cpp2"
+    [[nodiscard]] auto ad_test::func_call(cpp2::impl::in<double> x, cpp2::impl::in<double> y) -> func_call_ret{
+          cpp2::impl::deferred_init<double> r;
+#line 60 "pure2-autodiff-higher-order.cpp2"
+      r.construct(x * func(x, y));
+    return std::move(r.value()); }
+
+#line 63 "pure2-autodiff-higher-order.cpp2"
+    [[nodiscard]] auto ad_test::sin_call(cpp2::impl::in<double> x, cpp2::impl::in<double> y) -> sin_call_ret{
+          cpp2::impl::deferred_init<double> r;
+#line 64 "pure2-autodiff-higher-order.cpp2"
+      r.construct(sin(x - y));
+    return std::move(r.value()); }
+
     [[nodiscard]] auto ad_test::add_1_d(cpp2::impl::in<double> x, cpp2::impl::in<cpp2::taylor<double,6>> x_d, cpp2::impl::in<double> y, cpp2::impl::in<cpp2::taylor<double,6>> y_d) -> add_1_d_ret{
                                                                                                                                                                       double r {0.0};
                                                                                                                                                                       cpp2::taylor<double,6> r_d {0.0};r_d = x_d + y_d;
@@ -330,25 +378,56 @@ auto temp_1_d {CPP2_UFCS(mul)(x_d, y_d, x, y)};
     return  { std::move(r), std::move(r_d) }; 
     }
 
-#line 56 "pure2-autodiff-higher-order.cpp2"
+    [[nodiscard]] auto ad_test::func_d(cpp2::impl::in<double> x, cpp2::impl::in<cpp2::taylor<double,6>> x_d, cpp2::impl::in<double> y, cpp2::impl::in<cpp2::taylor<double,6>> y_d) -> func_d_ret{
+                                                                                                                                                                     double r {0.0};
+                                                                                                                                                                     cpp2::taylor<double,6> r_d {0.0};r_d = x_d + y_d;
+    r = x + y;
+    return  { std::move(r), std::move(r_d) }; 
+    }
+
+    [[nodiscard]] auto ad_test::func_call_d(cpp2::impl::in<double> x, cpp2::impl::in<cpp2::taylor<double,6>> x_d, cpp2::impl::in<double> y, cpp2::impl::in<cpp2::taylor<double,6>> y_d) -> func_call_d_ret{
+                                                                                                                                                                          double r {0.0};
+                                                                                                                                                                          cpp2::taylor<double,6> r_d {0.0};
+auto temp_2 {func_d(x, x_d, y, y_d)}; 
+
+    auto temp_1 {temp_2.r}; 
+
+    auto temp_1_d {cpp2::move(temp_2).r_d}; 
+    r_d = CPP2_UFCS(mul)(x_d, cpp2::move(temp_1_d), x, temp_1);
+    r = x * cpp2::move(temp_1);
+    return  { std::move(r), std::move(r_d) }; 
+    }
+
+    [[nodiscard]] auto ad_test::sin_call_d(cpp2::impl::in<double> x, cpp2::impl::in<cpp2::taylor<double,6>> x_d, cpp2::impl::in<double> y, cpp2::impl::in<cpp2::taylor<double,6>> y_d) -> sin_call_d_ret{
+                                                                                                                                                                         double r {0.0};
+                                                                                                                                                                         cpp2::taylor<double,6> r_d {0.0};
+auto temp_1_d {x_d - y_d}; 
+
+    auto temp_1 {x - y}; 
+    r_d = CPP2_UFCS(sin)(cpp2::move(temp_1_d), temp_1);
+    r = sin(cpp2::move(temp_1));
+    return  { std::move(r), std::move(r_d) }; 
+    }
+
+#line 68 "pure2-autodiff-higher-order.cpp2"
 auto write_output(cpp2::impl::in<std::string> func, cpp2::impl::in<double> x, cpp2::impl::in<ad_type> x_d, cpp2::impl::in<double> y, cpp2::impl::in<ad_type> y_d, auto const& ret) -> void{
     std::cout << "diff(" + cpp2::to_string(func) + ") at (x = " + cpp2::to_string(x) + ", x_d = " + cpp2::to_string(x_d) + ", y = " + cpp2::to_string(y) + ", y_d = " + cpp2::to_string(y_d) + "):" << std::endl;
     std::cout << "  r = " + cpp2::to_string(ret.r) + "" << std::endl;
 {
 auto i{1};
 
-#line 60 "pure2-autodiff-higher-order.cpp2"
+#line 72 "pure2-autodiff-higher-order.cpp2"
     for( ; cpp2::impl::cmp_less_eq(i,ad_order); i += 1 ) {
       std::cout << "  d" + cpp2::to_string(i) + " = " + cpp2::to_string(CPP2_ASSERT_IN_BOUNDS(ret.r_d, i)) + "" << std::endl;
     }
 }
-#line 63 "pure2-autodiff-higher-order.cpp2"
+#line 75 "pure2-autodiff-higher-order.cpp2"
 }
 
-#line 65 "pure2-autodiff-higher-order.cpp2"
+#line 77 "pure2-autodiff-higher-order.cpp2"
 auto main() -> int{
 
-#line 68 "pure2-autodiff-higher-order.cpp2"
+#line 80 "pure2-autodiff-higher-order.cpp2"
     double x {2.0}; 
     ad_type x_d {1.0}; 
     double y {3.0}; 
@@ -365,9 +444,9 @@ auto main() -> int{
     write_output("x / y / y", x, x_d, y, y_d, ad_test::div_2_d(x, x_d, y, y_d));
     write_output("x * y / x", x, x_d, y, y_d, ad_test::mul_div_2_d(x, x_d, y, y_d));
     write_output("x * (x + y)", x, x_d, y, y_d, ad_test::mul_add_d(x, x_d, y, y_d));
-    write_output("x + x * y", x, x_d, y, y_d, ad_test::add_mul_d(cpp2::move(x), cpp2::move(x_d), cpp2::move(y), cpp2::move(y_d)));
-//    write_output("x * func(x, y)", x, x_d, y, y_d, ad_test::func_call_d(x, x_d, y, y_d));
-//    write_output("sin(x + y)", x, x_d, y, y_d, ad_test::sin_call_d(x, x_d, y, y_d));
+    write_output("x + x * y", x, x_d, y, y_d, ad_test::add_mul_d(x, x_d, y, y_d));
+    write_output("x * func(x, y)", x, x_d, y, y_d, ad_test::func_call_d(x, x_d, y, y_d));
+    write_output("sin(x - y)", x, x_d, y, y_d, ad_test::sin_call_d(cpp2::move(x), cpp2::move(x_d), cpp2::move(y), cpp2::move(y_d)));
 //    write_output("if branch", x, x_d, y, y_d, ad_test::if_branch_d(x, x_d, y, y_d));
 //    write_output("if else branch", x, x_d, y, y_d, ad_test::if_else_branch_d(x, x_d, y, y_d));
 //    write_output("direct return", x, x_d, y, y_d, ad_test::direct_return_d(x, x_d, y, y_d));

regression-tests/test-results/pure2-autodiff-higher-order.cpp2.output

@@ -110,6 +110,33 @@ ad_test:/* @autodiff<"order=6"> @print */ type =
         return;
     }
 
+    func:(
+        in x: double, 
+        in y: double, 
+    ) -> (out r: double, ) = 
+    {
+        r = x + y;
+        return;
+    }
+
+    func_call:(
+        in x: double, 
+        in y: double, 
+    ) -> (out r: double, ) = 
+    {
+        r = x * func(x, y);
+        return;
+    }
+
+    sin_call:(
+        in x: double, 
+        in y: double, 
+    ) -> (out r: double, ) = 
+    {
+        r = sin(x - y);
+        return;
+    }
+
     add_1_d:(
         in x: double, 
         in x_d: cpp2::taylor<double, 6>, 
@@ -299,6 +326,56 @@ ad_test:/* @autodiff<"order=6"> @print */ type =
         r = x + temp_1;
         return;
     }
+
+    func_d:(
+        in x: double, 
+        in x_d: cpp2::taylor<double, 6>, 
+        in y: double, 
+        in y_d: cpp2::taylor<double, 6>, 
+    ) -> (
+            out r: double = 0.0, 
+            out r_d: cpp2::taylor<double, 6> = 0.0, 
+        ) = 
+    {
+        r_d = x_d + y_d;
+        r = x + y;
+        return;
+    }
+
+    func_call_d:(
+        in x: double, 
+        in x_d: cpp2::taylor<double, 6>, 
+        in y: double, 
+        in y_d: cpp2::taylor<double, 6>, 
+    ) -> (
+            out r: double = 0.0, 
+            out r_d: cpp2::taylor<double, 6> = 0.0, 
+        ) = 
+    {
+        temp_2: _ = func_d(x, x_d, y, y_d);
+        temp_1: _ = temp_2.r;
+        temp_1_d: _ = temp_2.r_d;
+        r_d = x_d.mul(temp_1_d, x, temp_1);
+        r = x * temp_1;
+        return;
+    }
+
+    sin_call_d:(
+        in x: double, 
+        in x_d: cpp2::taylor<double, 6>, 
+        in y: double, 
+        in y_d: cpp2::taylor<double, 6>, 
+    ) -> (
+            out r: double = 0.0, 
+            out r_d: cpp2::taylor<double, 6> = 0.0, 
+        ) = 
+    {
+        temp_1_d: _ = x_d - y_d;
+        temp_1: _ = x - y;
+        r_d = temp_1_d.sin(temp_1);
+        r = sin(temp_1);
+        return;
+    }
 }
  ok (all Cpp2, passes safety checks)
 

regression-tests/test-results/pure2-autodiff.cpp

@@ -878,7 +878,7 @@ auto main() -> int{
     write_output("x * (x + y)", x, x_d, y, y_d, ad_test::mul_add_d(x, x_d, y, y_d));
     write_output("x + x * y", x, x_d, y, y_d, ad_test::add_mul_d(x, x_d, y, y_d));
     write_output("x * func(x, y)", x, x_d, y, y_d, ad_test::func_call_d(x, x_d, y, y_d));
-    write_output("sin(x + y)", x, x_d, y, y_d, ad_test::sin_call_d(x, x_d, y, y_d));
+    write_output("sin(x - y)", x, x_d, y, y_d, ad_test::sin_call_d(x, x_d, y, y_d));
     write_output("if branch", x, x_d, y, y_d, ad_test::if_branch_d(x, x_d, y, y_d));
     write_output("if else branch", x, x_d, y, y_d, ad_test::if_else_branch_d(x, x_d, y, y_d));
     write_output("direct return", x, x_d, y, y_d, ad_test::direct_return_d(x, x_d, y, y_d));