You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@mxnet.apache.org by zh...@apache.org on 2019/07/19 03:42:23 UTC

[incubator-mxnet] 03/28: add op

This is an automated email from the ASF dual-hosted git repository.

zhasheng pushed a commit to tag v1.1
in repository https://gitbox.apache.org/repos/asf/incubator-mxnet.git

commit 0f341fa1826425d1722fa9b87fc61ec5caeff58b
Author: tqchen <ti...@gmail.com>
AuthorDate: Thu Apr 10 13:53:41 2014 -0700

    add op
---
 example/exp-template/Makefile            |  3 +-
 example/exp-template/exp_template_op.cpp | 84 ++++++++++++++++++++++++++++++++
 2 files changed, 86 insertions(+), 1 deletion(-)

diff --git a/example/exp-template/Makefile b/example/exp-template/Makefile
index 68d6168..9063989 100644
--- a/example/exp-template/Makefile
+++ b/example/exp-template/Makefile
@@ -3,7 +3,7 @@ export CC  = gcc
 export CXX = g++
 export CFLAGS = -Wall -O3 
 # specify tensor path
-BIN = exp_lazy exp_template
+BIN = exp_lazy exp_template exp_template_op
 
 .PHONY: clean all
 
@@ -11,6 +11,7 @@ all: $(BIN)
 
 exp_lazy: exp_lazy.cpp
 exp_template: exp_template.cpp
+exp_template_op: exp_template_op.cpp
 
 $(BIN) :
 	$(CXX) $(CFLAGS) -o $@ $(filter %.cpp %.o %.c, $^)
diff --git a/example/exp-template/exp_template_op.cpp b/example/exp-template/exp_template_op.cpp
new file mode 100644
index 0000000..4399936
--- /dev/null
+++ b/example/exp-template/exp_template_op.cpp
@@ -0,0 +1,84 @@
+// Example code, expression template
+// with binary operator definition and extension
+// for simplicity, we use struct and make all members public
+
+#include <cstdio>
+
+// this is expression, all expressions must inheritate it, and put their type in subtype
+template<typename SubType>
+struct Exp{
+    // returns const reference of the actual type of this expression
+    inline const SubType& self(void) const{
+        return *static_cast<const SubType*>(this);
+    }
+};
+
+// binary operators
+struct mul{
+    inline static float Map(float a, float b){
+        return a * b;
+    } 
+};
+
+// binary add expression
+// note how it is inheritates from Exp
+// and put its own type into the template argument
+template<typename OP,typename TLhs, typename TRhs>
+struct BinaryMapExp: public Exp< BinaryMapExp<OP,TLhs,TRhs> >{
+    const TLhs& lhs;
+    const TRhs& rhs;
+    BinaryMapExp(const TLhs& lhs, const TRhs& rhs):lhs(lhs),rhs(rhs){}
+    // evaluation function, evaluate this expression at position i
+    inline float Eval( int i ) const{
+        return OP::Map( lhs.Eval(i), rhs.Eval(i) );
+    }
+};
+// no constructor and destructor to allocate and de-allocate memory, allocation done by user
+struct Vec: public Exp<Vec>{
+    int len;
+    float* dptr;
+    Vec (void){}
+    Vec (float *dptr, int len):len(len),dptr(dptr){}
+    // here is where evaluation happens
+    template<typename EType>
+    inline Vec& operator= (const Exp<EType>& src_){
+        const EType &src = src_.self();
+        for( int i=0; i < len; ++i ){
+            dptr[i] = src.Eval(i);
+        }
+        return *this;
+    }    
+    // evaluation function, evaluate this expression at position i
+    inline float Eval( int i ) const{
+        return dptr[i];
+    }
+};
+// template add, works for any expressions
+template<typename OP,typename TLhs, typename TRhs>
+inline BinaryMapExp<OP,TLhs,TRhs> F(const Exp<TLhs>& lhs, const Exp<TRhs>& rhs){
+    return BinaryMapExp<OP,TLhs,TRhs>(lhs.self(), rhs.self());
+}
+
+template<typename TLhs, typename TRhs>
+inline BinaryMapExp<mul,TLhs,TRhs> operator* (const Exp<TLhs>& lhs, const Exp<TRhs>& rhs){
+    return F<mul>(lhs, rhs);
+}
+
+// user defined operation
+struct maximum{
+    inline static float Map(float a, float b){
+        return a > b ? a : b;  
+    }
+};
+
+const int n = 3; 
+int main( void ){
+    float sa[n]={1,2,3},sb[n]={2,3,4},sc[n]={3,4,5};
+    Vec A(sa,n), B(sb,n), C(sc,n);
+    // run expression, this expression is longer:)
+    A = B * F<maximum>(C, B);
+    for( int i = 0; i < n; ++ i ){
+        printf("%d:%f==%f*max(%f,%f)\n", i, A.dptr[i], B.dptr[i], C.dptr[i], B.dptr[i] );
+    }
+    return 0;
+}