Added another version of multiply()

dlib/dnn/cpu_dlib.cpp

@@ -26,6 +26,23 @@ namespace dlib
                 d[i] *= s[i];
         }
 
+    // -----------------------------------------------------------------------------------
+
+        void multiply (
+            tensor& dest,
+            const tensor& src1,
+            const tensor& src2
+        )
+        {
+            DLIB_CASSERT(dest.size()==src1.size(),"");
+            DLIB_CASSERT(dest.size()==src2.size(),"");
+            const auto d = dest.host();
+            const auto s1 = src1.host();
+            const auto s2 = src2.host();
+            for (size_t i = 0; i < src1.size(); ++i)
+                d[i] = s1[i]*s2[i];
+        }
+
     // -----------------------------------------------------------------------------------
 
         void affine_transform(

dlib/dnn/cpu_dlib.h

@@ -20,6 +20,12 @@ namespace dlib
             const tensor& src
         );
 
+        void multiply (
+            tensor& dest,
+            const tensor& src1,
+            const tensor& src2
+        );
+
     // -----------------------------------------------------------------------------------
 
         void affine_transform(

dlib/dnn/cuda_dlib.cu

@@ -46,6 +46,27 @@ namespace dlib
             _cuda_multiply<<<512,512>>>(dest.device(), src.device(), src.size());
         }
 
+    // -----------------------------------------------------------------------------------
+
+        __global__ void _cuda_multiply(float* d, const float* s1, const float* s2, size_t n)
+        {
+            for (auto i : grid_stride_range(0, n))
+            {
+                d[i] = s1[i]*s2[i];
+            }
+        }
+
+        void multiply (
+            tensor& dest,
+            const tensor& src1,
+            const tensor& src2
+        )
+        {
+            DLIB_CASSERT(dest.size()==src1.size(),"");
+            DLIB_CASSERT(dest.size()==src2.size(),"");
+            _cuda_multiply<<<512,512>>>(dest.device(), src1.device(), src2.device(), src1.size());
+        }
+
     // -----------------------------------------------------------------------------------
 
         __global__ void _cuda_affine_transform(float* d, const float* s, size_t n, float A, float B)

dlib/dnn/cuda_dlib.h

@@ -29,6 +29,12 @@ namespace dlib
             const tensor& src
         );
 
+        void multiply (
+            tensor& dest,
+            const tensor& src1,
+            const tensor& src2
+        );
+
     // -----------------------------------------------------------------------------------
 
         void affine_transform(

dlib/dnn/tensor_tools.cpp

@@ -108,6 +108,24 @@ namespace dlib { namespace tt
 
     }
 
+// ----------------------------------------------------------------------------------------
+
+    void multiply (
+        tensor& dest,
+        const tensor& src1,
+        const tensor& src2
+    )
+    {
+        DLIB_CASSERT(have_same_dimensions(dest,src1) == true,"");
+        DLIB_CASSERT(have_same_dimensions(dest,src2) == true,"");
+#ifdef DLIB_USE_CUDA
+        cuda::multiply(dest, src1, src2);
+#else
+        cpu::multiply(dest, src1, src2);
+#endif
+
+    }
+
 // ----------------------------------------------------------------------------------------
 
     void affine_transform(

dlib/dnn/tensor_tools.h

@@ -105,6 +105,23 @@ namespace dlib { namespace tt
                 #dest.host()[i] == dest.host()[i]*src.host()[i]
     !*/
 
+// ----------------------------------------------------------------------------------------
+
+    void multiply (
+        tensor& dest,
+        const tensor& src1,
+        const tensor& src2
+    );
+    /*!
+        requires
+            - have_same_dimensions(dest,src1) == true
+            - have_same_dimensions(dest,src2) == true
+        ensures
+            - #dest == src1*src2
+              That is, for all valid i:
+                #dest.host()[i] == src1.host()[i]*src2.host()[i]
+    !*/
+
 // ----------------------------------------------------------------------------------------
 
     void affine_transform(