Add an AD unit test

Author: hsutter

regression-tests/pure2-autodiff.cpp2

@@ -277,6 +277,23 @@ write_output_reverse: (func: std::string, x: double, inout x_b: double, y: doubl
     y_b = 0.0;
 }
 
+ad_test_2: @autodiff<"order=2"> @print type = {
+    f: (x: double) -> (y: double) = {
+        if x < -3
+        {
+            y = x * x;
+        }
+        else if x < 3
+        {
+            y = x + sin(x) + 10;
+        }
+        else
+        {
+            y = sin(x) * x*x;
+        }
+    }
+}
+
 main: () = {
 
     x:   double = 2.0;

regression-tests/test-results/msvc-2022-c++latest/pure2-autodiff.cpp.output

@@ -1 +1,15 @@
 pure2-autodiff.cpp
+C:\github\cppfront\include\cpp2util.h(1250): error C7595: 'std::source_location::current': call to immediate function is not a constant expression
+C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.43.34808\include\source_location(37): note: failure was caused by attempting to access a member on an object of dynamic type 'std::source_location' in which the member is not defined
+C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.43.34808\include\source_location(37): note: see usage of 'std::source_location::source_location'
+C:\github\cppfront\include\cpp2util.h(1250): note: the call stack of the evaluation (the oldest call first) is
+C:\github\cppfront\include\cpp2util.h(1250): note: while evaluating function 'std::source_location std::source_location::current(const uint_least32_t,const uint_least32_t,const char *const ,const char *const ) noexcept'
+C:\github\cppfront\include\cpp2util.h(1250): note: the template instantiation context (the oldest one first) is
+pure2-autodiff.cpp2(282): note: see reference to class template instantiation 'cpp2::taylor<double,2>' being compiled
+cpp2taylor.h2(16): note: while compiling class template member function 'cpp2::taylor<double,2>::taylor(const std::initializer_list<R> &)'
+        with
+        [
+            R=double
+        ]
+pure2-autodiff.cpp2(298): note: see the first reference to 'cpp2::taylor<double,2>::taylor' in 'ad_test_2::f_d'
+cpp2taylor.h2(35): note: while compiling class template member function 'void cpp2::taylor<double,2>::set(const int,const double) &'

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

@@ -1,6 +1,7 @@
 
 #define CPP2_IMPORT_STD          Yes
 #include "cpp2ad_stack.h"
+#include "cpp2taylor.h"
 
 //=== Cpp2 type declarations ====================================================
 
@@ -28,6 +29,10 @@ class ad_test_reverse;
 class ad_test_twice;
 
 
+#line 280 "pure2-autodiff.cpp2"
+class ad_test_2;
+    
+
 //=== Cpp2 type definitions and function declarations ===========================
 
 #line 1 "pure2-autodiff.cpp2"
@@ -532,6 +537,24 @@ auto write_output(cpp2::impl::in<std::string> func, cpp2::impl::in<double> x, cp
 auto write_output_reverse(cpp2::impl::in<std::string> func, cpp2::impl::in<double> x, double& x_b, cpp2::impl::in<double> y, double& y_b, double& r_b, auto const& ret) -> void;
 
 #line 280 "pure2-autodiff.cpp2"
+class ad_test_2 {
+using f_ret = double;
+
+#line 281 "pure2-autodiff.cpp2"
+    public: [[nodiscard]] static auto f(cpp2::impl::in<double> x) -> f_ret;
+struct f_d_ret { double y; cpp2::taylor<double,2> y_d; };
+
+
+    public: [[nodiscard]] static auto f_d(cpp2::impl::in<double> x, cpp2::impl::in<cpp2::taylor<double,2>> x_d) -> f_d_ret;
+
+    public: ad_test_2() = default;
+    public: ad_test_2(ad_test_2 const&) = delete; /* No 'that' constructor, suppress copy */
+    public: auto operator=(ad_test_2 const&) -> void = delete;
+
+
+#line 295 "pure2-autodiff.cpp2"
+};
+
 auto main() -> int;
 
 //=== Cpp2 function definitions =================================================
@@ -1552,7 +1575,56 @@ auto write_output_reverse(cpp2::impl::in<std::string> func, cpp2::impl::in<doubl
     y_b = 0.0;
 }
 
-#line 280 "pure2-autodiff.cpp2"
+#line 281 "pure2-autodiff.cpp2"
+    [[nodiscard]] auto ad_test_2::f(cpp2::impl::in<double> x) -> f_ret{
+            cpp2::impl::deferred_init<double> y;
+#line 282 "pure2-autodiff.cpp2"
+        if (cpp2::impl::cmp_less(x,-3)) 
+        {
+            y.construct(x * x);
+        }
+        else {if (cpp2::impl::cmp_less(x,3)) 
+        {
+            y.construct(x + sin(x) + 10);
+        }
+        else 
+        {
+            y.construct(sin(x) * x * x);
+        }}return std::move(y.value()); 
+    }
+
+    [[nodiscard]] auto ad_test_2::f_d(cpp2::impl::in<double> x, cpp2::impl::in<cpp2::taylor<double,2>> x_d) -> f_d_ret{
+                                                                                                                                     double y {0.0};
+                                                                                                                                     cpp2::taylor<double,2> y_d {0.0};if (cpp2::impl::cmp_less(x,-3)) {
+    y_d = x_d.mul(x_d, x, x);
+    y = x * x;
+    }
+    else {
+    if (cpp2::impl::cmp_less(x,3)) {
+
+    cpp2::taylor<double,2> temp_1_d {CPP2_UFCS(sin)(x_d, x)}; 
+
+    double temp_1 {sin(x)}; 
+    y_d = x_d + cpp2::move(temp_1_d);
+    y = x + cpp2::move(temp_1) + 10;
+    }
+    else {
+
+    cpp2::taylor<double,2> temp_3_d {CPP2_UFCS(sin)(x_d, x)}; 
+
+    double temp_3 {sin(x)}; 
+
+    auto temp_4_d {cpp2::move(temp_3_d).mul(x_d, temp_3, x)}; 
+
+    auto temp_4 {cpp2::move(temp_3) * x}; 
+    y_d = cpp2::move(temp_4_d).mul(x_d, temp_4, x);
+    y = cpp2::move(temp_4) * x;
+    }
+    }
+    return  { std::move(y), std::move(y_d) }; 
+    }
+
+#line 297 "pure2-autodiff.cpp2"
 auto main() -> int{
 
     double x {2.0}; 

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

@@ -1386,5 +1386,64 @@ ad_test_twice:/* @autodiff @autodiff<"suffix=_d2"> @print */ type =
         return;
     }
 }
+
+
+ad_test_2:/* @autodiff<"order=2"> @print */ type = 
+{
+    f:(in x: double, ) -> (out y: double, ) = 
+    {
+        if x < -3
+        {
+            y = x * x;
+        }
+        else 
+        {
+            if x < 3
+            {
+                y = x + sin(x) + 10;
+            }
+            else 
+            {
+                y = sin(x) * x * x;
+            }
+        }
+        return;
+    }
+
+    f_d:(
+        in x: double, 
+        in x_d: cpp2::taylor<double, 2>, 
+    ) -> (
+            out y: double = 0.0, 
+            out y_d: cpp2::taylor<double, 2> = 0.0, 
+        ) = 
+    {
+        if x < -3
+        {
+            y_d = x_d..mul(x_d, x, x);
+            y = x * x;
+        }
+        else 
+        {
+            if x < 3
+            {
+                temp_1_d: cpp2::taylor<double, 2> = x_d.sin(x);
+                temp_1: double = sin(x);
+                y_d = x_d + temp_1_d;
+                y = x + temp_1 + 10;
+            }
+            else 
+            {
+                temp_3_d: cpp2::taylor<double, 2> = x_d.sin(x);
+                temp_3: double = sin(x);
+                temp_4_d: _ = temp_3_d..mul(x_d, temp_3, x);
+                temp_4: _ = temp_3 * x;
+                y_d = temp_4_d..mul(x_d, temp_4, x);
+                y = temp_4 * x;
+            }
+        }
+        return;
+    }
+}
  ok (all Cpp2, passes safety checks)