diff --git a/include/tim/vx/ops/elementwise.h b/include/tim/vx/ops/elementwise.h
index a60b0cd..17a8cde 100644
--- a/include/tim/vx/ops/elementwise.h
+++ b/include/tim/vx/ops/elementwise.h
@@ -29,36 +29,25 @@ namespace tim {
 namespace vx {
 namespace ops {
 
-#define DELCATE_ELEMENTWISE_OP(NAME) \
+#define DECLARE_ELEMENTWISE_OP(NAME) \
   class NAME : public Operation {    \
    public:                           \
     NAME(Graph* graph);              \
   };
 
-DELCATE_ELEMENTWISE_OP(Abs)
-DELCATE_ELEMENTWISE_OP(Sin)
-// TODO(jiangbo): enable it when internal ops supports `Cos`
-//DELCATE_ELEMENTWISE_OP(Cos)
-DELCATE_ELEMENTWISE_OP(Exp)
-DELCATE_ELEMENTWISE_OP(Log)
-DELCATE_ELEMENTWISE_OP(Sqrt)
-DELCATE_ELEMENTWISE_OP(Rsqrt)
-DELCATE_ELEMENTWISE_OP(Square)
-DELCATE_ELEMENTWISE_OP(LogicalNot)
-
-DELCATE_ELEMENTWISE_OP(Minimum)
-DELCATE_ELEMENTWISE_OP(Maximum)
-DELCATE_ELEMENTWISE_OP(Add)
-DELCATE_ELEMENTWISE_OP(Sub)
-DELCATE_ELEMENTWISE_OP(Div)
-DELCATE_ELEMENTWISE_OP(Pow)
+DECLARE_ELEMENTWISE_OP(Minimum)
+DECLARE_ELEMENTWISE_OP(Maximum)
+DECLARE_ELEMENTWISE_OP(Add)
+DECLARE_ELEMENTWISE_OP(Sub)
+DECLARE_ELEMENTWISE_OP(Div)
+DECLARE_ELEMENTWISE_OP(Pow)
 
 class Multiply : public Operation {
   public:
     Multiply(Graph* graph, float scale = 1.0f);
 };
 
-#undef DELCATE_ELEMENTWISE_OP
+#undef DECLARE_ELEMENTWISE_OP
 
 }  // namespace ops
 }  // namespace vx
diff --git a/include/tim/vx/ops/logical.h b/include/tim/vx/ops/logical.h
index 57fb6cc..38e370c 100644
--- a/include/tim/vx/ops/logical.h
+++ b/include/tim/vx/ops/logical.h
@@ -29,19 +29,19 @@ namespace tim {
 namespace vx {
 namespace ops {
 
-#define DELCATE_LOGICAL_OP(NAME)           \
+#define DECLARE_LOGICAL_OP(NAME)           \
   class Logical##NAME : public Operation { \
    public:                                 \
     Logical##NAME(Graph* graph);           \
   };
 
-DELCATE_LOGICAL_OP(And);
-DELCATE_LOGICAL_OP(Or);
+DECLARE_LOGICAL_OP(And);
+DECLARE_LOGICAL_OP(Or);
 
-#undef DELCATE_LOGICAL_OP
+#undef DECLARE_LOGICAL_OP
 
 }  // namespace ops
 }  // namespace vx
 }  // namespace tim
 
-#endif /* TIM_VX_OPS_ACTIVATIONS_H_ */
\ No newline at end of file
+#endif /* TIM_VX_OPS_ACTIVATIONS_H_ */
diff --git a/include/tim/vx/ops/reduce.h b/include/tim/vx/ops/reduce.h
index db6c310..1c7f381 100644
--- a/include/tim/vx/ops/reduce.h
+++ b/include/tim/vx/ops/reduce.h
@@ -29,7 +29,7 @@ namespace tim {
 namespace vx {
 namespace ops {
 
-#define DELCATE_REDUCE_OP(NAME)                                  \
+#define DECLARE_REDUCE_OP(NAME)                                  \
   class Reduce##NAME : public Operation {                        \
    public:                                                       \
     Reduce##NAME(Graph* graph, const std::vector<int32_t>& axis, \
@@ -40,13 +40,13 @@ namespace ops {
     bool keep_dims_;                                             \
   };
 
-DELCATE_REDUCE_OP(Min);
-DELCATE_REDUCE_OP(Max);
-DELCATE_REDUCE_OP(Any);
-DELCATE_REDUCE_OP(Prod);
-DELCATE_REDUCE_OP(Mean);
+DECLARE_REDUCE_OP(Min);
+DECLARE_REDUCE_OP(Max);
+DECLARE_REDUCE_OP(Any);
+DECLARE_REDUCE_OP(Prod);
+DECLARE_REDUCE_OP(Mean);
 
-#undef DELCATE_REDUCE_OP
+#undef DECLARE_REDUCE_OP
 
 }  // namespace ops
 }  // namespace vx
diff --git a/include/tim/vx/ops/simple_operations.h b/include/tim/vx/ops/simple_operations.h
index 95a40da..14633fe 100644
--- a/include/tim/vx/ops/simple_operations.h
+++ b/include/tim/vx/ops/simple_operations.h
@@ -37,6 +37,16 @@ namespace ops {
 
 DECLARE_SIMPLE_OP(DataConvert)
 DECLARE_SIMPLE_OP(Neg)
+DECLARE_SIMPLE_OP(Abs)
+DECLARE_SIMPLE_OP(Sin)
+// TODO(jiangbo): enable it when internal ops supports `Cos`
+//DECLARE_SIMPLE_OP(Cos)
+DECLARE_SIMPLE_OP(Exp)
+DECLARE_SIMPLE_OP(Log)
+DECLARE_SIMPLE_OP(Sqrt)
+DECLARE_SIMPLE_OP(Rsqrt)
+DECLARE_SIMPLE_OP(Square)
+DECLARE_SIMPLE_OP(LogicalNot)
 
 #undef DECLARE_SIMPLE_OP
 
diff --git a/src/tim/vx/ops/elementwise.cc b/src/tim/vx/ops/elementwise.cc
index cf6f6bf..3cfa7c4 100644
--- a/src/tim/vx/ops/elementwise.cc
+++ b/src/tim/vx/ops/elementwise.cc
@@ -30,33 +30,17 @@ namespace tim {
 namespace vx {
 namespace ops {
 
-#define DEFINE_ELEMENTWISE_UNARY_OP(NAME, VSI_OP_CODE) \
-  NAME::NAME(Graph* graph) : Operation(graph, VSI_OP_CODE) {}
-
-DEFINE_ELEMENTWISE_UNARY_OP(Abs, VSI_NN_OP_ABS)
-DEFINE_ELEMENTWISE_UNARY_OP(Sin, VSI_NN_OP_SIN)
-// TODO(jiangbo): enable it when ovxlib supports `Cos`
-//DEFINE_ELEMENTWISE_UNARY_OP(Cos, VSI_NN_OP_COS)
-DEFINE_ELEMENTWISE_UNARY_OP(Exp, VSI_NN_OP_EXP)
-DEFINE_ELEMENTWISE_UNARY_OP(Log, VSI_NN_OP_LOG)
-DEFINE_ELEMENTWISE_UNARY_OP(Sqrt, VSI_NN_OP_SQRT)
-DEFINE_ELEMENTWISE_UNARY_OP(Rsqrt, VSI_NN_OP_RSQRT)
-DEFINE_ELEMENTWISE_UNARY_OP(Square, VSI_NN_OP_SQUARE)
-DEFINE_ELEMENTWISE_UNARY_OP(LogicalNot, VSI_NN_OP_LOGICAL_NOT)
-
-#undef DEFINE_ELEMENTWISE_UNARY_OP
-
-#define DEFINE_ELEMENTWISE_BINARY_OP(NAME, VSI_OP_CODE) \
+#define DEFINE_ELEMENTWISE_OP(NAME, VSI_OP_CODE) \
   NAME::NAME(Graph* graph) : Operation(graph, VSI_OP_CODE, 2, 1) {}
 
-DEFINE_ELEMENTWISE_BINARY_OP(Minimum, VSI_NN_OP_MINIMUM)
-DEFINE_ELEMENTWISE_BINARY_OP(Maximum, VSI_NN_OP_MAXIMUM)
-DEFINE_ELEMENTWISE_BINARY_OP(Add, VSI_NN_OP_ADD)
-DEFINE_ELEMENTWISE_BINARY_OP(Sub, VSI_NN_OP_SUBTRACT)
-DEFINE_ELEMENTWISE_BINARY_OP(Div, VSI_NN_OP_DIVIDE)
-DEFINE_ELEMENTWISE_BINARY_OP(Pow, VSI_NN_OP_POW)
+DEFINE_ELEMENTWISE_OP(Minimum, VSI_NN_OP_MINIMUM)
+DEFINE_ELEMENTWISE_OP(Maximum, VSI_NN_OP_MAXIMUM)
+DEFINE_ELEMENTWISE_OP(Add, VSI_NN_OP_ADD)
+DEFINE_ELEMENTWISE_OP(Sub, VSI_NN_OP_SUBTRACT)
+DEFINE_ELEMENTWISE_OP(Div, VSI_NN_OP_DIVIDE)
+DEFINE_ELEMENTWISE_OP(Pow, VSI_NN_OP_POW)
 
-#undef DEFINE_ELEMENTWISE_BINARY_OP
+#undef DEFINE_ELEMENTWISE_OP
 
 Multiply::Multiply(Graph* graph, float scale)
   : Operation(graph, VSI_NN_OP_MULTIPLY, 2, 1) {
diff --git a/src/tim/vx/ops/simple_operations.cc b/src/tim/vx/ops/simple_operations.cc
index 235f20a..39561c3 100644
--- a/src/tim/vx/ops/simple_operations.cc
+++ b/src/tim/vx/ops/simple_operations.cc
@@ -34,6 +34,16 @@ namespace ops {
 
 DEFINE_SIMPLE_OP(DataConvert, VSI_NN_OP_DATACONVERT)
 DEFINE_SIMPLE_OP(Neg, VSI_NN_OP_NEG)
+DEFINE_SIMPLE_OP(Abs, VSI_NN_OP_ABS)
+DEFINE_SIMPLE_OP(Sin, VSI_NN_OP_SIN)
+// TODO(jiangbo): enable it when ovxlib supports `Cos`
+//DEFINE_SIMPLE_OP(Cos, VSI_NN_OP_COS)
+DEFINE_SIMPLE_OP(Exp, VSI_NN_OP_EXP)
+DEFINE_SIMPLE_OP(Log, VSI_NN_OP_LOG)
+DEFINE_SIMPLE_OP(Sqrt, VSI_NN_OP_SQRT)
+DEFINE_SIMPLE_OP(Rsqrt, VSI_NN_OP_RSQRT)
+DEFINE_SIMPLE_OP(Square, VSI_NN_OP_SQUARE)
+DEFINE_SIMPLE_OP(LogicalNot, VSI_NN_OP_LOGICAL_NOT)
 
 #undef DEFINE_SIMPLE_OP