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;
+}