Add support for differentiating functors in forward mode

[parth-07]

This PR aims to add support for differentiating functors in the forward differentiation mode.

• Implicitly differentiate operator() member function when functor is passed
• Implicitly pass functor while executing derived function using CladFunction
• Add tests
• Add user-friendly errors using Sema diagnostics when an object of class without overloaded operator() or multiple overloads of call operator is passed to be differentiated.
• Add demo

By differentiating functors, I mean, differentiating the operator() member function when a functor is passed, and implicitly executing the derived function using the passed functor.

Functors can be passed to clad::differentiate both by reference and as pointers. For example:

Experiment E; // a functor
auto d_fn = clad::differentiate(&E, "i");
auto d_fnRef = clad::differentiate(E, "i");
...
...
std::cout<<d_fn.execute(1,  3)<<"\n"; // no need to pass object while executing derived function.

Implemented solution

The solution is implemented in 2 steps:

• Differentiate operator() member function whenever functor (class type object) is passed to be differentiated.
• Execute derived function through the functor object.

1st Step Implementation:

DiffPlanner getArgFunction is responsible for obtaining function to be differentiated from the call expression of clad differentiation functions.

It currently behaves as follows:

• Return DeclRefExpr node of the 1st argument (which is, the function to be differentiated), and update the RelevantAncestor parameter to the nearest ancestor of 1st argument which is of type ImplicitCastExpr or UnaryOperator.

getArgFunction has been modified such that, whenever a class type object is to be differentiated, it provides all the data for the operator() member function of the class type. By all the data, I am referring to DeclRefExpr of the operator() method, the correct nearest ancestor for the operator() method.

But since the operator() method hasn't actually passed, these nodes (DeclRefExpr and ancestors of the operator() method) does not actually exist, and needs to be created inside getArgFunction. This effectively converts calls to differentiate class type object to calls to differentiate a member function for the rest of the clad.

2nd Step Implementation:

CladFunction has been modified to save an object through which derived member functions should be called when the user does not explicitly pass an object while calling CladFunction::execute

This behaviour is summarised in the following code snippet:

SomeClass A, B;
auto d_memFn = clad::differentiate(&SomeClass::SomeMemberFn, "i");
d_memFn.setObject(&A); // set A as default object for executing derived fn
d_memFn.execute(1, 3); // calls A.derivedFn(1, 3);
d_memFn.execute(B, 1, 3); // calls B.derivedFn(1, 3);

When a functor object is passed to be differentiated, it is saved in the corresponding CladFunction object so that it can be automatically taken by the CladFunction::execute method to call the derived member function.

Modifications to clad::differentiate

clad::differentiate is modified to have 2 overloads, one for differentiating functions (and methods), and the other for differentiating functors.
2 separate overloads are required because function (and method) pointers need to be passed by value whereas objects need to be passed by reference (because we need to determine constness property (among others) of passed functor object)

[codecov]

Codecov Report

Merging #240 (ef9299b) into master (1016c27) will increase coverage by 0.63%.
The diff coverage is 100.00%.

@@            Coverage Diff             @@
##           master     #240      +/-   ##
==========================================
+ Coverage   84.39%   85.02%   +0.63%     
==========================================
  Files          21       21              
  Lines        2736     2832      +96     
==========================================
+ Hits         2309     2408      +99     
+ Misses        427      424       -3     

Impacted Files	Coverage Δ
lib/Differentiator/DiffPlanner.cpp	98.40% <100.00%> (+1.73%)	⬆️
lib/Differentiator/HessianModeVisitor.cpp	98.30% <0.00%> (-0.06%)	⬇️
lib/Differentiator/ForwardModeVisitor.cpp	88.92% <0.00%> (+0.36%)	⬆️
lib/Differentiator/VisitorBase.cpp	95.20% <0.00%> (+0.39%)	⬆️
include/clad/Differentiator/Compatibility.h	75.00% <0.00%> (+6.25%)	⬆️

Impacted Files	Coverage Δ
lib/Differentiator/DiffPlanner.cpp	98.40% <100.00%> (+1.73%)	⬆️
lib/Differentiator/HessianModeVisitor.cpp	98.30% <0.00%> (-0.06%)	⬇️
lib/Differentiator/ForwardModeVisitor.cpp	88.92% <0.00%> (+0.36%)	⬆️
lib/Differentiator/VisitorBase.cpp	95.20% <0.00%> (+0.39%)	⬆️
include/clad/Differentiator/Compatibility.h	75.00% <0.00%> (+6.25%)	⬆️

[vgvassilev]

Well done! LGTM!