Feature/autodiff (#1413)

* Update for regex 20 lookbehind test.

Removed cpp file and added cpp2 file.

* Fix for name lookup issues with MSVC.

* Add missing files.

* Refactor of autodiff with generalized traversal.

Added test for autodiff.

* Handling of expression lists.

* Handling of expresson terms.

* Handling of function calls.

* Added special handling of math functions.

* Added declarations and statements to simple_traversal.

* Handling if/else statements.

* Added handling of direct return.

* Stub handling of value declarations.

* Added example for non differential variable.

* Added handling of while and do while loops.

* Handling of for loops and added special functions.

* Unified function call handling.

* Proper handling of initializer expressions.

* Fix initializer problem.

* Suffix can now be user defined.

* Added second order test.

* Remove initialization order workaround.

* Taylor polynomial propagation implementation.

* Basic handling of higher order derivatives and handling of add and minus.

* Added  handling for multiply and division.

* Higher order handling for special functions.

* Remaining tests for higher order derivatives.

* Declaration lookup and lookup of function return name.

* Basic changes for adding new things for the differentiation.

* Moved handling of types and functions to autodiff_declaration_handler.

* Added handling for differentiation of symbols outside of metafunction type declaration.

* Basic differentation for type and namespace value declarations.

* Refactor of autodiff_expression_handler.

The expression handler no longer generates the assignments. It stores
the primal and forward expression. The assignments can now be generated
with helper functions or by accessing the expressions.

* Handling of member access.

* Moved assignment handling code to proper traverse function.

* Added type differentiation for types without member functions.

* Handling of member function calls.

First basic setup for declared variable lookup.

* Handling of prefix + and -.

* Basic preperations for reverse mode AD.

* Refactor of diff string to structure.

Currently placeholder that defaults to the forward derivatives.

* Reverse handling of function declaration.

* Reverse differentiation of additive expressions.

* Basic handling of multiplication and division.

* Fix for to_string of expressions.

* Activity analysis for variables and functions.

* Update for tests and acitivity analysis.

* Added tests for combined binary expressions.

* Handling of special functions for reverse mode.

* Added handling of function calls for reverse.

* Handling of statement parameters for loops in forward mode.

* Reverse handling of for loops.

* Temp.

* Build clean with GCC 10 and Clang 21, and update regression test results

* Bugfix for passive variables in addition or subtraction statements.

* Add an AD unit test

---------

Co-authored-by: Herb Sutter <herb.sutter@gmail.com>

Author: MaxSagebaum

build_h2.bat

@@ -3,4 +3,5 @@ cd source
 cppfront reflect.h2 -verb %1
 cd ..\include
 cppfront cpp2regex.h2 -verb %1
+cppfront cpp2taylor.h2 -verb %1
 cd..

include/cpp2ad_stack.h

@@ -0,0 +1,38 @@
+#ifndef CPP2_CPP2AD_STACK_H
+#define CPP2_CPP2AD_STACK_H
+
+#include <vector>
+
+namespace cpp2 {
+
+struct ad_stack {
+
+    template<typename T>
+    static void push(T const& v) {
+        std::vector<T>& stack = get_stack<T>();
+
+        stack.push_back(v);
+    }
+
+    template<typename T>
+    static T pop() {
+        std::vector<T>& stack = get_stack<T>();
+
+        T v = stack.back();
+        stack.pop_back();
+
+        return v;
+    }
+
+    private:
+
+    template<typename T>
+    static std::vector<T>& get_stack() {
+        static std::vector<T> stack = {};
+
+        return stack;
+    }
+};
+} // cpp2 namespace
+
+#endif // CPP2_CPP2AD_STACK_H

include/cpp2regex.h

@@ -261,10 +261,10 @@ template<typename CharT, typename Iter, int max_groups> [[nodiscard]] auto make_
 #line 184 "cpp2regex.h2"
 //  Helpers for creating wrappers of the iterators.
 //
-template               <typename Iter> [[nodiscard]] auto make_forward_iterator(Iter const& pos) -> auto;
-template               <typename Iter> [[nodiscard]] auto make_forward_iterator(std::reverse_iterator<Iter> const& pos) -> auto;
-template               <typename Iter> [[nodiscard]] auto make_reverse_iterator(Iter const& pos) -> auto;
-template<typename Iter> [[nodiscard]] auto make_reverse_iterator(std::reverse_iterator<Iter> const& pos) -> auto;
+template                    <typename Iter> [[nodiscard]] auto cpp2_make_forward_iterator(Iter const& pos) -> auto;
+template<typename Iter> [[nodiscard]] auto cpp2_make_forward_iterator(std::reverse_iterator<Iter> const& pos) -> auto;
+template                    <typename Iter> [[nodiscard]] auto cpp2_make_reverse_iterator(Iter const& pos) -> auto;
+template<typename Iter> [[nodiscard]] auto cpp2_make_reverse_iterator(std::reverse_iterator<Iter> const& pos) -> auto;
 
 #line 192 "cpp2regex.h2"
 //  End function that returns a valid match.
@@ -927,13 +927,13 @@ template<typename CharT, typename Iter, int max_groups> [[nodiscard]] auto make_
 }
 
 #line 186 "cpp2regex.h2"
-template               <typename Iter> [[nodiscard]] auto make_forward_iterator(Iter const& pos) -> auto { return pos; }
+template                    <typename Iter> [[nodiscard]] auto cpp2_make_forward_iterator(Iter const& pos) -> auto { return pos; }
 #line 187 "cpp2regex.h2"
-template               <typename Iter> [[nodiscard]] auto make_forward_iterator(std::reverse_iterator<Iter> const& pos) -> auto { return CPP2_UFCS(base)(pos); }
+template<typename Iter> [[nodiscard]] auto cpp2_make_forward_iterator(std::reverse_iterator<Iter> const& pos) -> auto { return CPP2_UFCS(base)(pos);  }
 #line 188 "cpp2regex.h2"
-template               <typename Iter> [[nodiscard]] auto make_reverse_iterator(Iter const& pos) -> auto { return std::make_reverse_iterator(pos); }
+template                    <typename Iter> [[nodiscard]] auto cpp2_make_reverse_iterator(Iter const& pos) -> auto { return std::make_reverse_iterator(pos); }
 #line 189 "cpp2regex.h2"
-template<typename Iter> [[nodiscard]] auto make_reverse_iterator(std::reverse_iterator<Iter> const& pos) -> auto { return pos;  }
+template<typename Iter> [[nodiscard]] auto cpp2_make_reverse_iterator(std::reverse_iterator<Iter> const& pos) -> auto { return pos;  }
 
 #line 196 "cpp2regex.h2"
     [[nodiscard]] auto true_end_func::operator()(auto const& cur, auto& ctx) const& -> decltype(auto) { return ctx.pass(cur);  }
@@ -1153,7 +1153,7 @@ template<typename CharT, bool match_new_line> [[nodiscard]] auto line_start_toke
 #line 575 "cpp2regex.h2"
 template<typename CharT, bool positive> [[nodiscard]] auto lookahead_token_matcher(auto const& cur, auto& ctx, auto const& func) -> bool
 {
-    auto r {func(make_forward_iterator(cur), make_forward_match_context(ctx), true_end_func())}; 
+    auto r {func(cpp2_make_forward_iterator(cur), make_forward_match_context(ctx), true_end_func())}; 
     if (!(positive)) {
         r.matched = !(r.matched);
     }
@@ -1164,7 +1164,7 @@ template<typename CharT, bool positive> [[nodiscard]] auto lookahead_token_match
 #line 589 "cpp2regex.h2"
 template<typename CharT, bool positive> [[nodiscard]] auto lookbehind_token_matcher(auto const& cur, auto& ctx, auto const& func) -> bool
 {
-    auto r {func(make_reverse_iterator(cur), make_reverse_match_context(ctx), true_end_func())}; 
+    auto r {func(cpp2_make_reverse_iterator(cur), make_reverse_match_context(ctx), true_end_func())}; 
     if (!(positive)) {
         r.matched = !(r.matched);
     }

include/cpp2regex.h2

@@ -183,10 +183,10 @@ make_reverse_match_context: <CharT, Iter, max_groups: int> (inout ctx: reverse_m
 
 //  Helpers for creating wrappers of the iterators.
 //
-make_forward_iterator: <Iter> (pos: Iter)                        -> _ = pos;
-make_forward_iterator: <Iter> (pos: std::reverse_iterator<Iter>) -> _  = pos.base();
-make_reverse_iterator: <Iter> (pos: Iter)                        -> _ = std::make_reverse_iterator(pos);
-make_reverse_iterator: <Iter> (pos: std::reverse_iterator<Iter>) -> _ = pos;
+cpp2_make_forward_iterator: <Iter> (pos: Iter)                        -> _ = pos;
+cpp2_make_forward_iterator: <Iter> (pos: std::reverse_iterator<Iter>) -> _ = pos.base();
+cpp2_make_reverse_iterator: <Iter> (pos: Iter)                        -> _ = std::make_reverse_iterator(pos);
+cpp2_make_reverse_iterator: <Iter> (pos: std::reverse_iterator<Iter>) -> _ = pos;
 
 
 //  End function that returns a valid match.
@@ -574,7 +574,7 @@ line_start_token_matcher: <CharT, match_new_line: bool> (cur, inout ctx) -> bool
 //
 lookahead_token_matcher: <CharT, positive: bool> (cur, inout ctx, func) -> bool =
 {
-    r := func(make_forward_iterator(cur), make_forward_match_context(ctx), true_end_func());
+    r := func(cpp2_make_forward_iterator(cur), make_forward_match_context(ctx), true_end_func());
     if !positive {
         r.matched = !r.matched;
     }
@@ -588,7 +588,7 @@ lookahead_token_matcher: <CharT, positive: bool> (cur, inout ctx, func) -> bool
 //
 lookbehind_token_matcher: <CharT, positive: bool> (cur, inout ctx, func) -> bool =
 {
-    r := func(make_reverse_iterator(cur), make_reverse_match_context(ctx), true_end_func());
+    r := func(cpp2_make_reverse_iterator(cur), make_reverse_match_context(ctx), true_end_func());
     if !positive {
         r.matched = !r.matched;
     }