Add backward functions for ReLU, Sigmoid and Tanh

Context

Add some backward functions that were missing.

Detailed modifications

• Use a protype for backward function that may fit all the needs : input, output and grad_output are needed to compute grad_input in the general case (input was missing, output is kept to save computation). This may lead to unused parameters, but it is probably not an issue ?

• Add missing backward functions for Sigmoid and Tanh.

• Use input instead of output for testing the sign in ReLU (both codes should give same results, but the use of input is preferred).

TODO

For this merge request :

• Fell free to adapt the proposed modifications to match code requirements.
• Check if my understanding of the way the forward methods should work is correct.

For future :

• Check the forward function for Sqrt operator that seems not to be correct.
• Homogenize the way forward and backward are coded for all available operators.

include/aidge/backend/cpu/operator/ReLUImpl_backward_kernels.hpp

@@ -18,15 +18,15 @@
 #include "aidge/utils/Registrar.hpp"
 
 namespace Aidge {
-template <class O, class GI, class GO>
+template <class I, class GI, class GO>
 void ReLUImpl_cpu_backward_kernel(const std::size_t inputLenght,
-                                  const void* output_, const void* grad_output_,
-                                  void* grad_input_) {
-    const O* output = static_cast<const O*>(output_);
+                                  const void* input_, const void* grad_output_,
+				  void* grad_input_) {
+    const I* input = static_cast<const I*>(input_);
     const GO* grad_output = static_cast<const GO*>(grad_output_);
     GI* grad_input = static_cast<GI*>(grad_input_);
     for (std::size_t i = 0; i < inputLenght; ++i) {
-        grad_input[i] = (output[i] > GO(0)) ? GI(grad_output[i]) : GI(0);
+        grad_input[i] = (input[i] > 0) ? grad_output[i] : 0;
     }
 }