Merge remote-tracking branch 'origin/trigonometric-ops' into f/arduino-sine

neil-tan · neil-tan · commit 21499a0b66b9 · 2020-11-11T23:03:00.000+08:00
diff --git a/src/uTensor.h b/src/uTensor.h
@@ -27,7 +27,7 @@
 #include "uTensor/ops/symmetric_quantization/convolution2d.hpp"
 #include "uTensor/ops/symmetric_quantization/depthwise_separable_convolution.hpp"
 #include "uTensor/ops/symmetric_quantization/fully_connected.hpp"
-#include "uTensor/ops/tanh.hpp"
+#include "uTensor/ops/trigonometric.hpp"
 
 /*
  * Tensors
diff --git a/src/uTensor/ops/Arithmetic.hpp b/src/uTensor/ops/Arithmetic.hpp
@@ -23,6 +23,20 @@ class AddOperator : public OperatorInterface<2, 1> {
   }
 };
 
-}
+template <typename T>
+class MulOperator : public OperatorInterface<2, 1> {
+ public:
+  enum names_in : uint8_t { a, b };
+  enum names_out : uint8_t { c };
+  // AddOperator(FixedTensorMap<2> inputs, FixedTensorMap<1> outputs) :
+  // OperatorBase(inputs, outputs) {}
+
+ protected:
+  virtual void compute() {
+    mul_kernel<T>(outputs[c].tensor(), inputs[a].tensor(), inputs[b].tensor());
+  }
+};
+
+}  // namespace ReferenceOperators
 }  // namespace uTensor
 #endif
diff --git a/src/uTensor/ops/Arithmetic_kernels.hpp b/src/uTensor/ops/Arithmetic_kernels.hpp
@@ -16,5 +16,18 @@ void add_kernel(Tensor& c, const Tensor& a, const Tensor& b) {
     c(i) = static_cast<T>(static_cast<T>(a(i)) + static_cast<T>(b(i)));
 }
 
+template <typename T>
+void mul_kernel(Tensor& c, const Tensor& a, const Tensor& b) {
+  // Decide on c shape
+  TensorShape c_shape = c->get_shape();
+  uint32_t c_size = c_shape.get_linear_size();
+  // TensorInterface& C = reinterpret_cast<TensorInterface*>(*c);
+  // const TensorInterface& A = reinterpret_cast<TensorInterface*>(*a);
+  // const TensorInterface& B = reinterpret_cast<TensorInterface*>(*b);
+
+  for (uint32_t i = 0; i < c_size; i++)
+    c(i) = static_cast<T>(static_cast<T>(a(i)) * static_cast<T>(b(i)));
+}
+
 }  // namespace uTensor
 #endif
diff --git a/src/uTensor/ops/trigonometric.hpp b/src/uTensor/ops/trigonometric.hpp
@@ -1,5 +1,5 @@
-#ifndef UTENSOR_TANH_H
-#define UTENSOR_TANH_H
+#ifndef UTENSOR_TRIGONOMETRIC_H
+#define UTENSOR_TRIGONOMETRIC_H
 #include <math.h>
 
 #include "uTensor/core/context.hpp"
@@ -44,6 +44,39 @@ class TanhOperator : public OperatorInterface<1, 1> {
   }
 };
 
+template <typename OutputT, typename InputT>
+class SinOperator : public OperatorInterface<1, 1> {
+ public:
+  enum names_in : uint8_t { act_in };
+  enum names_out : uint8_t { act_out };
+
+ protected:
+  virtual void compute() {
+    Tensor& in = inputs[act_in].tensor();
+    Tensor& out = outputs[act_out].tensor();
+
+    const uint32_t flat_size = in->get_shape().get_linear_size();
+
+    int32_t in_zero_point =
+        in->get_quantization_params().get_zeroP_for_channel(0);
+    float in_scale = in->get_quantization_params().get_scale_for_channel(0);
+
+    int32_t out_zero_point =
+        out->get_quantization_params().get_zeroP_for_channel(0);
+    float out_scale = out->get_quantization_params().get_scale_for_channel(0);
+
+    for (uint32_t i = 0; i < flat_size; i++) {
+      const int32_t in_val = static_cast<InputT>(in(i));
+      float float_in_val = static_cast<float>(
+          in_scale * static_cast<float>((in_val - in_zero_point)));
+      float element_activation = sin(float_in_val);
+      OutputT result =
+          static_cast<OutputT>(element_activation / out_scale + out_zero_point);
+      out(i) = result;
+    }
+  }
+};
+
 }  // namespace ReferenceOperators
 }  // namespace uTensor
-#endif
+#endif  // UTENSOR_TRIGONOMETRIC_H
