[Add] broadcasting for Arithmetic Operators

This merge request is dedicated to enabling broadcasting on binary operators (Add, Mul, Div, Sub, Pow). The expected behaviour is the same as numpy

Here are examples of supported broadcasting

Tensor_A shape	3	2	1	3
Tensor_B shape	1	2	4	3
Output shape	3	2	4	3

Tensor_A shape	3	2	1	3
Tensor_C shape				3
Output shape	3	2	1	3

include/aidge/backend/TensorImpl.hpp

@@ -12,8 +12,12 @@
 #ifndef AIDGE_TENSORIMPL_H_
 #define AIDGE_TENSORIMPL_H_
 
-#include <cstddef>
-#include <cstdio>
+#include <numeric>     // std::accumulate
+#include <cstddef>     // std::size_t
+#include <functional>  // std::multiplies
+#include <vector>
+#include <utility>     // std::pair, std::make_pair
+
 #include "aidge/data/Data.hpp"
 #include "aidge/utils/Types.h"
 #include "aidge/utils/ErrorHandling.hpp"
@@ -59,23 +63,42 @@ private:
 */
 
 /**
- * This class manages the raw data storage of a Tensor and provide generic copy
+ * @class TensorImpl
+ * @brief Class to manage the raw data storage of a Tensor and provide generic copy
  * primitives from other devices and from/to host.
- * It can own the data or not (use setRawPtr() to set an external data owner).
- * It only knows the data type and data capacity, but does not handle anything else.
+ * @note It can own the data or not (use ``setRawPtr()`` to set an external data owner).
+ * @note It only knows the data type and data capacity, but does not handle anything else.
 */
 class TensorImpl {
+protected:
+
+    const char *mBackend;
+    /// @brief Device id.
+    const DeviceIdx_t mDevice;
+    /// Number of elements (to be) stored.
+    NbElts_t mNbElts;
+
 public:
     TensorImpl() = delete;
-    TensorImpl(const char *backend, DeviceIdx_t device, std::vector<DimSize_t> dims) : mBackend(backend), mDevice(device) 
+
+    TensorImpl(const char *backend, DeviceIdx_t device, std::vector<DimSize_t> dims)
+        : mBackend(backend),
+          mDevice(device)
     {
         resize(dims);
     };
 
+    virtual ~TensorImpl() = default;
+
+    virtual bool operator==(const TensorImpl &othImpl) const = 0;
+
+public:
     /**
      * Return the (backend, device) pair for this implementation.
     */
-    std::pair<std::string, DeviceIdx_t> device() const { return std::make_pair(mBackend, mDevice); }
+    std::pair<std::string, DeviceIdx_t> device() const noexcept {
+        return std::make_pair(std::string(mBackend), mDevice);
+    }
 
     /**
      * Copy data from the same device.
@@ -151,11 +174,7 @@ public:
      * Set the size, in number of elements, that must be stored.
     */
     virtual void resize(std::vector<DimSize_t> dims) {
-        size_t product = 1;
-        for (size_t num : dims) {
-            product *= num;
-        }
-        mNbElts = product;
+        mNbElts = std::accumulate(dims.cbegin(), dims.cend(), std::size_t(1), std::multiplies<std::size_t>());
     }
 
     /**
@@ -168,23 +187,15 @@ public:
     */
     virtual std::size_t scalarSize() const noexcept = 0;
     constexpr const char *backend() const { return mBackend; }
-    virtual ~TensorImpl() = default;
-    virtual bool operator==(const TensorImpl &othImpl) const = 0;
 
     /**
-     * Copy from another backend.
+     * @brief Copy from another backend.
      * @param srcImpl Source TensorImpl to copy from.
      * @param length Number of elements of size scalarSize() to copy
      * @param srcOffset Source offset (in number of elements).
      * @param dstOffset Destination offset (in number of elements).
     */
     void copyFrom(const TensorImpl& srcImpl, NbElts_t length, NbElts_t srcOffset = 0, NbElts_t dstOffset = 0);
-
-protected:
-    const char *mBackend;
-    const DeviceIdx_t mDevice;
-    /// Number of elements (to be) stored
-    NbElts_t mNbElts;
 };
 
 } // namespace Aidge