rebind python swig

.vscode/settings.json

@@ -1,5 +1,5 @@
 {
-    "python.pythonPath": "C:\\ProgramData\\Anaconda3\\python.exe",
+    "python.pythonPath": "C:\\Users\\wangjun\\AppData\\Local\\Programs\\Python\\Python37\\python.exe",
     "files.associations": {
         "algorithm": "cpp",
         "array": "cpp",

CMakeLists.txt

@@ -23,7 +23,7 @@ endif()
 
 
 # languge feature
-set(ENABLE_PYTHON FALSE CACHE BOOL "Language: Python")
+set(ENABLE_PYTHON True CACHE BOOL "Language: Python")
 
 # gpgpu feature
 set(ENABLE_CUDA FALSE CACHE BOOL "Feature: OPENCL")

build.py

@@ -7,7 +7,7 @@ import subprocess
 def main(argv):
     system_type = platform.system()
     machine_type = platform.machine()
-    is_debug = True
+    is_debug = False
 
     traph_build = argv[0]
     traph_root, build_file = os.path.split(traph_build)
@@ -16,17 +16,21 @@ def main(argv):
     os.chdir(traph_root + "/build")
     
     if machine_type == 'AMD64':
+        # -DCMAKE_BUILD_TYPE=Debug
         if is_debug:
             subprocess.run("cmake -DCMAKE_BUILD_TYPE=Debug -G \"Visual Studio 15 2017 Win64\" ../")
+            subprocess.run("cmake --build . --config Debug")
         else:
             subprocess.run("cmake -DCMAKE_BUILD_TYPE=Release -G \"Visual Studio 15 2017 Win64\" ../")
-        subprocess.run("cmake --build .")
+            subprocess.run("cmake --build . --config Release")
+        
     elif machine_type == 'x86':
         if is_debug:
             subprocess.run("cmake -DCMAKE_BUILD_TYPE=Debug -G \"Visual Studio 15 2017\" ../")
+            subprocess.run("cmake --build . --config Debug")
         else:
             subprocess.run("cmake -DCMAKE_BUILD_TYPE=Release -G \"Visual Studio 15 2017\" ../")
-        subprocess.run("cmake --build .")
+            subprocess.run("cmake --build . --config Release")
     else:
         print('unsupport machine')
 

python/demo.py

@@ -1,4 +1,5 @@
-import pytraph as pt
+import pytraph
  
-t = pt.float
-a = pt.zeros(4,2)
+
+a = pytraph.core.tensor.ones((4,2))
+print(a)

python/pytraph/__init__.py

@@ -1,3 +1,4 @@
 # -*- coding: utf-8 -*-
-from pytraph.core.tensor import Tensor
-from pytraph.core.dtype import float, double, half, uint8, int16, int32, int64
+import pytraph.core
+
+__all__ = ["core"]

python/pytraph/core/__init__.py

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+import pytraph.core.dtype
+import pytraph.core.tensor
+__all__ = ["dtype", "tensor"]

python/pytraph/core/tensor.py

@@ -1,22 +1,59 @@
-import traph_tensor
-import dtype
+import pytraph.core.dtype
+import pytraph.core.traph_tensor
+
 
 class Storage(object):
     pass
 
 class Tensor(object):
     def __init__(self):
-        self.inner_tensor = traph_tensor.tensor_f32()
+        self._inner_tensor = None
+    
+    def __str__(self):
+        if self._inner_tensor is not None:
+            return self._inner_tensor.to_string()
+        else:
+            return "None"
+
+class FloatTensor(Tensor):
+    def __init__(self):
+        self._inner_tensor = pytraph.core.traph_tensor.FloatTensor()
     
 
-def tensor(obj, dtype=dtype.float):
+def tensor(obj):
     if type(obj) == list:
         pass
     else:
         print('unsupported obj type')
 
-def zeros(*args):
-    pass
+def zeros(shape):
+    if type(shape) != tuple:
+        raise RuntimeError('The type of shape shall be tuple.')
+    
+    ret = FloatTensor()
+
+    dim = pytraph.core.traph_tensor.DimVector()
+    for each in shape:
+        dim.push_back(each)
+    
+    ret._inner_tensor = pytraph.core.traph_tensor.FloatTensor(dim)
+    ret._inner_tensor.fill_(0)
+
+    return ret
+    
+
+def ones(shape):
+    if type(shape) != tuple:
+        raise RuntimeError('The type of shape shall be tuple.')
+    
+    ret = FloatTensor()
+
+    dim = pytraph.core.traph_tensor.DimVector()
+    for each in shape:
+        dim.push_back(each)
+    
+    ret._inner_tensor = pytraph.core.traph_tensor.FloatTensor(dim)
+    ret._inner_tensor.fill_(1)
 
-def ones(*args):
-    pass
+    return ret
+    

python/pytraph/core/traph_tensor.py

@@ -109,6 +109,9 @@ class DimVector(_object):
         except __builtin__.Exception:
             self.this = this
 
+    def erase(self, idx):
+        return _traph_tensor.DimVector_erase(self, idx)
+
     def push_back(self, idx):
         return _traph_tensor.DimVector_push_back(self, idx)
 
@@ -117,179 +120,14 @@ class DimVector(_object):
 
     def size(self):
         return _traph_tensor.DimVector_size(self)
+
+    def flat_size(self):
+        return _traph_tensor.DimVector_flat_size(self)
     __swig_destroy__ = _traph_tensor.delete_DimVector
     __del__ = lambda self: None
 DimVector_swigregister = _traph_tensor.DimVector_swigregister
 DimVector_swigregister(DimVector)
 
-class ByteTensor(_object):
-    __swig_setmethods__ = {}
-    __setattr__ = lambda self, name, value: _swig_setattr(self, ByteTensor, name, value)
-    __swig_getmethods__ = {}
-    __getattr__ = lambda self, name: _swig_getattr(self, ByteTensor, name)
-    __repr__ = _swig_repr
-
-    def __init__(self, *args):
-        this = _traph_tensor.new_ByteTensor(*args)
-        try:
-            self.this.append(this)
-        except __builtin__.Exception:
-            self.this = this
-
-    def reshape(self, dims):
-        return _traph_tensor.ByteTensor_reshape(self, dims)
-
-    def index(self, dims):
-        return _traph_tensor.ByteTensor_index(self, dims)
-    __swig_destroy__ = _traph_tensor.delete_ByteTensor
-    __del__ = lambda self: None
-ByteTensor_swigregister = _traph_tensor.ByteTensor_swigregister
-ByteTensor_swigregister(ByteTensor)
-
-class CharTensor(_object):
-    __swig_setmethods__ = {}
-    __setattr__ = lambda self, name, value: _swig_setattr(self, CharTensor, name, value)
-    __swig_getmethods__ = {}
-    __getattr__ = lambda self, name: _swig_getattr(self, CharTensor, name)
-    __repr__ = _swig_repr
-
-    def __init__(self, *args):
-        this = _traph_tensor.new_CharTensor(*args)
-        try:
-            self.this.append(this)
-        except __builtin__.Exception:
-            self.this = this
-
-    def reshape(self, dims):
-        return _traph_tensor.CharTensor_reshape(self, dims)
-
-    def index(self, dims):
-        return _traph_tensor.CharTensor_index(self, dims)
-    __swig_destroy__ = _traph_tensor.delete_CharTensor
-    __del__ = lambda self: None
-CharTensor_swigregister = _traph_tensor.CharTensor_swigregister
-CharTensor_swigregister(CharTensor)
-
-class ShortTensor(_object):
-    __swig_setmethods__ = {}
-    __setattr__ = lambda self, name, value: _swig_setattr(self, ShortTensor, name, value)
-    __swig_getmethods__ = {}
-    __getattr__ = lambda self, name: _swig_getattr(self, ShortTensor, name)
-    __repr__ = _swig_repr
-
-    def __init__(self, *args):
-        this = _traph_tensor.new_ShortTensor(*args)
-        try:
-            self.this.append(this)
-        except __builtin__.Exception:
-            self.this = this
-
-    def reshape(self, dims):
-        return _traph_tensor.ShortTensor_reshape(self, dims)
-
-    def index(self, dims):
-        return _traph_tensor.ShortTensor_index(self, dims)
-    __swig_destroy__ = _traph_tensor.delete_ShortTensor
-    __del__ = lambda self: None
-ShortTensor_swigregister = _traph_tensor.ShortTensor_swigregister
-ShortTensor_swigregister(ShortTensor)
-
-class IntTensor(_object):
-    __swig_setmethods__ = {}
-    __setattr__ = lambda self, name, value: _swig_setattr(self, IntTensor, name, value)
-    __swig_getmethods__ = {}
-    __getattr__ = lambda self, name: _swig_getattr(self, IntTensor, name)
-    __repr__ = _swig_repr
-
-    def __init__(self, *args):
-        this = _traph_tensor.new_IntTensor(*args)
-        try:
-            self.this.append(this)
-        except __builtin__.Exception:
-            self.this = this
-
-    def reshape(self, dims):
-        return _traph_tensor.IntTensor_reshape(self, dims)
-
-    def index(self, dims):
-        return _traph_tensor.IntTensor_index(self, dims)
-    __swig_destroy__ = _traph_tensor.delete_IntTensor
-    __del__ = lambda self: None
-IntTensor_swigregister = _traph_tensor.IntTensor_swigregister
-IntTensor_swigregister(IntTensor)
-
-class LongTensor(_object):
-    __swig_setmethods__ = {}
-    __setattr__ = lambda self, name, value: _swig_setattr(self, LongTensor, name, value)
-    __swig_getmethods__ = {}
-    __getattr__ = lambda self, name: _swig_getattr(self, LongTensor, name)
-    __repr__ = _swig_repr
-
-    def __init__(self, *args):
-        this = _traph_tensor.new_LongTensor(*args)
-        try:
-            self.this.append(this)
-        except __builtin__.Exception:
-            self.this = this
-
-    def reshape(self, dims):
-        return _traph_tensor.LongTensor_reshape(self, dims)
-
-    def index(self, dims):
-        return _traph_tensor.LongTensor_index(self, dims)
-    __swig_destroy__ = _traph_tensor.delete_LongTensor
-    __del__ = lambda self: None
-LongTensor_swigregister = _traph_tensor.LongTensor_swigregister
-LongTensor_swigregister(LongTensor)
-
-class FloatTensor(_object):
-    __swig_setmethods__ = {}
-    __setattr__ = lambda self, name, value: _swig_setattr(self, FloatTensor, name, value)
-    __swig_getmethods__ = {}
-    __getattr__ = lambda self, name: _swig_getattr(self, FloatTensor, name)
-    __repr__ = _swig_repr
-
-    def __init__(self, *args):
-        this = _traph_tensor.new_FloatTensor(*args)
-        try:
-            self.this.append(this)
-        except __builtin__.Exception:
-            self.this = this
-
-    def reshape(self, dims):
-        return _traph_tensor.FloatTensor_reshape(self, dims)
-
-    def index(self, dims):
-        return _traph_tensor.FloatTensor_index(self, dims)
-    __swig_destroy__ = _traph_tensor.delete_FloatTensor
-    __del__ = lambda self: None
-FloatTensor_swigregister = _traph_tensor.FloatTensor_swigregister
-FloatTensor_swigregister(FloatTensor)
-
-class DoubleTensor(_object):
-    __swig_setmethods__ = {}
-    __setattr__ = lambda self, name, value: _swig_setattr(self, DoubleTensor, name, value)
-    __swig_getmethods__ = {}
-    __getattr__ = lambda self, name: _swig_getattr(self, DoubleTensor, name)
-    __repr__ = _swig_repr
-
-    def __init__(self, *args):
-        this = _traph_tensor.new_DoubleTensor(*args)
-        try:
-            self.this.append(this)
-        except __builtin__.Exception:
-            self.this = this
-
-    def reshape(self, dims):
-        return _traph_tensor.DoubleTensor_reshape(self, dims)
-
-    def index(self, dims):
-        return _traph_tensor.DoubleTensor_index(self, dims)
-    __swig_destroy__ = _traph_tensor.delete_DoubleTensor
-    __del__ = lambda self: None
-DoubleTensor_swigregister = _traph_tensor.DoubleTensor_swigregister
-DoubleTensor_swigregister(DoubleTensor)
-
 class ByteStorage(_object):
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, ByteStorage, name, value)
@@ -304,6 +142,12 @@ class ByteStorage(_object):
         except __builtin__.Exception:
             self.this = this
 
+    def clone(self):
+        return _traph_tensor.ByteStorage_clone(self)
+
+    def data_ptr(self, *args):
+        return _traph_tensor.ByteStorage_data_ptr(self, *args)
+
     def size(self):
         return _traph_tensor.ByteStorage_size(self)
 
@@ -312,6 +156,9 @@ class ByteStorage(_object):
 
     def resize_(self, size):
         return _traph_tensor.ByteStorage_resize_(self, size)
+
+    def fill_(self, v):
+        return _traph_tensor.ByteStorage_fill_(self, v)
     __swig_destroy__ = _traph_tensor.delete_ByteStorage
     __del__ = lambda self: None
 ByteStorage_swigregister = _traph_tensor.ByteStorage_swigregister
@@ -331,6 +178,12 @@ class CharStorage(_object):
         except __builtin__.Exception:
             self.this = this
 
+    def clone(self):
+        return _traph_tensor.CharStorage_clone(self)
+
+    def data_ptr(self, *args):
+        return _traph_tensor.CharStorage_data_ptr(self, *args)
+
     def size(self):
         return _traph_tensor.CharStorage_size(self)
 
@@ -339,6 +192,9 @@ class CharStorage(_object):
 
     def resize_(self, size):
         return _traph_tensor.CharStorage_resize_(self, size)
+
+    def fill_(self, v):
+        return _traph_tensor.CharStorage_fill_(self, v)
     __swig_destroy__ = _traph_tensor.delete_CharStorage
     __del__ = lambda self: None
 CharStorage_swigregister = _traph_tensor.CharStorage_swigregister
@@ -358,6 +214,12 @@ class ShortStorage(_object):
         except __builtin__.Exception:
             self.this = this
 
+    def clone(self):
+        return _traph_tensor.ShortStorage_clone(self)
+
+    def data_ptr(self, *args):
+        return _traph_tensor.ShortStorage_data_ptr(self, *args)
+
     def size(self):
         return _traph_tensor.ShortStorage_size(self)
 
@@ -366,6 +228,9 @@ class ShortStorage(_object):
 
     def resize_(self, size):
         return _traph_tensor.ShortStorage_resize_(self, size)
+
+    def fill_(self, v):
+        return _traph_tensor.ShortStorage_fill_(self, v)
     __swig_destroy__ = _traph_tensor.delete_ShortStorage
     __del__ = lambda self: None
 ShortStorage_swigregister = _traph_tensor.ShortStorage_swigregister
@@ -385,6 +250,12 @@ class IntStorage(_object):
         except __builtin__.Exception:
             self.this = this
 
+    def clone(self):
+        return _traph_tensor.IntStorage_clone(self)
+
+    def data_ptr(self, *args):
+        return _traph_tensor.IntStorage_data_ptr(self, *args)
+
     def size(self):
         return _traph_tensor.IntStorage_size(self)
 
@@ -393,6 +264,9 @@ class IntStorage(_object):
 
     def resize_(self, size):
         return _traph_tensor.IntStorage_resize_(self, size)
+
+    def fill_(self, v):
+        return _traph_tensor.IntStorage_fill_(self, v)
     __swig_destroy__ = _traph_tensor.delete_IntStorage
     __del__ = lambda self: None
 IntStorage_swigregister = _traph_tensor.IntStorage_swigregister
@@ -412,6 +286,12 @@ class LongStorage(_object):
         except __builtin__.Exception:
             self.this = this
 
+    def clone(self):
+        return _traph_tensor.LongStorage_clone(self)
+
+    def data_ptr(self, *args):
+        return _traph_tensor.LongStorage_data_ptr(self, *args)
+
     def size(self):
         return _traph_tensor.LongStorage_size(self)
 
@@ -420,6 +300,9 @@ class LongStorage(_object):
 
     def resize_(self, size):
         return _traph_tensor.LongStorage_resize_(self, size)
+
+    def fill_(self, v):
+        return _traph_tensor.LongStorage_fill_(self, v)
     __swig_destroy__ = _traph_tensor.delete_LongStorage
     __del__ = lambda self: None
 LongStorage_swigregister = _traph_tensor.LongStorage_swigregister
@@ -439,6 +322,12 @@ class FloatStorage(_object):
         except __builtin__.Exception:
             self.this = this
 
+    def clone(self):
+        return _traph_tensor.FloatStorage_clone(self)
+
+    def data_ptr(self, *args):
+        return _traph_tensor.FloatStorage_data_ptr(self, *args)
+
     def size(self):
         return _traph_tensor.FloatStorage_size(self)
 
@@ -447,6 +336,9 @@ class FloatStorage(_object):
 
     def resize_(self, size):
         return _traph_tensor.FloatStorage_resize_(self, size)
+
+    def fill_(self, v):
+        return _traph_tensor.FloatStorage_fill_(self, v)
     __swig_destroy__ = _traph_tensor.delete_FloatStorage
     __del__ = lambda self: None
 FloatStorage_swigregister = _traph_tensor.FloatStorage_swigregister
@@ -466,6 +358,12 @@ class DoubleStorage(_object):
         except __builtin__.Exception:
             self.this = this
 
+    def clone(self):
+        return _traph_tensor.DoubleStorage_clone(self)
+
+    def data_ptr(self, *args):
+        return _traph_tensor.DoubleStorage_data_ptr(self, *args)
+
     def size(self):
         return _traph_tensor.DoubleStorage_size(self)
 
@@ -474,11 +372,602 @@ class DoubleStorage(_object):
 
     def resize_(self, size):
         return _traph_tensor.DoubleStorage_resize_(self, size)
+
+    def fill_(self, v):
+        return _traph_tensor.DoubleStorage_fill_(self, v)
     __swig_destroy__ = _traph_tensor.delete_DoubleStorage
     __del__ = lambda self: None
 DoubleStorage_swigregister = _traph_tensor.DoubleStorage_swigregister
 DoubleStorage_swigregister(DoubleStorage)
 
+class ByteTensor(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, ByteTensor, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, ByteTensor, name)
+    __repr__ = _swig_repr
+
+    def __init__(self, *args):
+        this = _traph_tensor.new_ByteTensor(*args)
+        try:
+            self.this.append(this)
+        except __builtin__.Exception:
+            self.this = this
+
+    def add_(self, other):
+        return _traph_tensor.ByteTensor_add_(self, other)
+
+    def apply_(self, f):
+        return _traph_tensor.ByteTensor_apply_(self, f)
+
+    def clone(self):
+        return _traph_tensor.ByteTensor_clone(self)
+
+    def cos_(self):
+        return _traph_tensor.ByteTensor_cos_(self)
+
+    def create_grad(self):
+        return _traph_tensor.ByteTensor_create_grad(self)
+
+    def data_ptr(self, *args):
+        return _traph_tensor.ByteTensor_data_ptr(self, *args)
+
+    def device(self):
+        return _traph_tensor.ByteTensor_device(self)
+
+    def fill_(self, value):
+        return _traph_tensor.ByteTensor_fill_(self, value)
+
+    def item(self):
+        return _traph_tensor.ByteTensor_item(self)
+
+    def offset(self):
+        return _traph_tensor.ByteTensor_offset(self)
+
+    def order(self):
+        return _traph_tensor.ByteTensor_order(self)
+
+    def platform(self):
+        return _traph_tensor.ByteTensor_platform(self)
+
+    def reduce_(self, f):
+        return _traph_tensor.ByteTensor_reduce_(self, f)
+
+    def reduce_dim(self, dim, f):
+        return _traph_tensor.ByteTensor_reduce_dim(self, dim, f)
+
+    def reshape_(self, dims):
+        return _traph_tensor.ByteTensor_reshape_(self, dims)
+
+    def resize_(self, dims):
+        return _traph_tensor.ByteTensor_resize_(self, dims)
+
+    def sin_(self):
+        return _traph_tensor.ByteTensor_sin_(self)
+
+    def size(self, *args):
+        return _traph_tensor.ByteTensor_size(self, *args)
+
+    def storage(self):
+        return _traph_tensor.ByteTensor_storage(self)
+
+    def stride(self, *args):
+        return _traph_tensor.ByteTensor_stride(self, *args)
+
+    def sum(self):
+        return _traph_tensor.ByteTensor_sum(self)
+
+    def to_string(self):
+        return _traph_tensor.ByteTensor_to_string(self)
+    __swig_destroy__ = _traph_tensor.delete_ByteTensor
+    __del__ = lambda self: None
+ByteTensor_swigregister = _traph_tensor.ByteTensor_swigregister
+ByteTensor_swigregister(ByteTensor)
+
+class CharTensor(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, CharTensor, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, CharTensor, name)
+    __repr__ = _swig_repr
+
+    def __init__(self, *args):
+        this = _traph_tensor.new_CharTensor(*args)
+        try:
+            self.this.append(this)
+        except __builtin__.Exception:
+            self.this = this
+
+    def add_(self, other):
+        return _traph_tensor.CharTensor_add_(self, other)
+
+    def apply_(self, f):
+        return _traph_tensor.CharTensor_apply_(self, f)
+
+    def clone(self):
+        return _traph_tensor.CharTensor_clone(self)
+
+    def cos_(self):
+        return _traph_tensor.CharTensor_cos_(self)
+
+    def create_grad(self):
+        return _traph_tensor.CharTensor_create_grad(self)
+
+    def data_ptr(self, *args):
+        return _traph_tensor.CharTensor_data_ptr(self, *args)
+
+    def device(self):
+        return _traph_tensor.CharTensor_device(self)
+
+    def fill_(self, value):
+        return _traph_tensor.CharTensor_fill_(self, value)
+
+    def item(self):
+        return _traph_tensor.CharTensor_item(self)
+
+    def offset(self):
+        return _traph_tensor.CharTensor_offset(self)
+
+    def order(self):
+        return _traph_tensor.CharTensor_order(self)
+
+    def platform(self):
+        return _traph_tensor.CharTensor_platform(self)
+
+    def reduce_(self, f):
+        return _traph_tensor.CharTensor_reduce_(self, f)
+
+    def reduce_dim(self, dim, f):
+        return _traph_tensor.CharTensor_reduce_dim(self, dim, f)
+
+    def reshape_(self, dims):
+        return _traph_tensor.CharTensor_reshape_(self, dims)
+
+    def resize_(self, dims):
+        return _traph_tensor.CharTensor_resize_(self, dims)
+
+    def sin_(self):
+        return _traph_tensor.CharTensor_sin_(self)
+
+    def size(self, *args):
+        return _traph_tensor.CharTensor_size(self, *args)
+
+    def storage(self):
+        return _traph_tensor.CharTensor_storage(self)
+
+    def stride(self, *args):
+        return _traph_tensor.CharTensor_stride(self, *args)
+
+    def sum(self):
+        return _traph_tensor.CharTensor_sum(self)
+
+    def to_string(self):
+        return _traph_tensor.CharTensor_to_string(self)
+    __swig_destroy__ = _traph_tensor.delete_CharTensor
+    __del__ = lambda self: None
+CharTensor_swigregister = _traph_tensor.CharTensor_swigregister
+CharTensor_swigregister(CharTensor)
+
+class ShortTensor(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, ShortTensor, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, ShortTensor, name)
+    __repr__ = _swig_repr
+
+    def __init__(self, *args):
+        this = _traph_tensor.new_ShortTensor(*args)
+        try:
+            self.this.append(this)
+        except __builtin__.Exception:
+            self.this = this
+
+    def add_(self, other):
+        return _traph_tensor.ShortTensor_add_(self, other)
+
+    def apply_(self, f):
+        return _traph_tensor.ShortTensor_apply_(self, f)
+
+    def clone(self):
+        return _traph_tensor.ShortTensor_clone(self)
+
+    def cos_(self):
+        return _traph_tensor.ShortTensor_cos_(self)
+
+    def create_grad(self):
+        return _traph_tensor.ShortTensor_create_grad(self)
+
+    def data_ptr(self, *args):
+        return _traph_tensor.ShortTensor_data_ptr(self, *args)
+
+    def device(self):
+        return _traph_tensor.ShortTensor_device(self)
+
+    def fill_(self, value):
+        return _traph_tensor.ShortTensor_fill_(self, value)
+
+    def item(self):
+        return _traph_tensor.ShortTensor_item(self)
+
+    def offset(self):
+        return _traph_tensor.ShortTensor_offset(self)
+
+    def order(self):
+        return _traph_tensor.ShortTensor_order(self)
+
+    def platform(self):
+        return _traph_tensor.ShortTensor_platform(self)
+
+    def reduce_(self, f):
+        return _traph_tensor.ShortTensor_reduce_(self, f)
+
+    def reduce_dim(self, dim, f):
+        return _traph_tensor.ShortTensor_reduce_dim(self, dim, f)
+
+    def reshape_(self, dims):
+        return _traph_tensor.ShortTensor_reshape_(self, dims)
+
+    def resize_(self, dims):
+        return _traph_tensor.ShortTensor_resize_(self, dims)
+
+    def sin_(self):
+        return _traph_tensor.ShortTensor_sin_(self)
+
+    def size(self, *args):
+        return _traph_tensor.ShortTensor_size(self, *args)
+
+    def storage(self):
+        return _traph_tensor.ShortTensor_storage(self)
+
+    def stride(self, *args):
+        return _traph_tensor.ShortTensor_stride(self, *args)
+
+    def sum(self):
+        return _traph_tensor.ShortTensor_sum(self)
+
+    def to_string(self):
+        return _traph_tensor.ShortTensor_to_string(self)
+    __swig_destroy__ = _traph_tensor.delete_ShortTensor
+    __del__ = lambda self: None
+ShortTensor_swigregister = _traph_tensor.ShortTensor_swigregister
+ShortTensor_swigregister(ShortTensor)
+
+class IntTensor(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, IntTensor, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, IntTensor, name)
+    __repr__ = _swig_repr
+
+    def __init__(self, *args):
+        this = _traph_tensor.new_IntTensor(*args)
+        try:
+            self.this.append(this)
+        except __builtin__.Exception:
+            self.this = this
+
+    def add_(self, other):
+        return _traph_tensor.IntTensor_add_(self, other)
+
+    def apply_(self, f):
+        return _traph_tensor.IntTensor_apply_(self, f)
+
+    def clone(self):
+        return _traph_tensor.IntTensor_clone(self)
+
+    def cos_(self):
+        return _traph_tensor.IntTensor_cos_(self)
+
+    def create_grad(self):
+        return _traph_tensor.IntTensor_create_grad(self)
+
+    def data_ptr(self, *args):
+        return _traph_tensor.IntTensor_data_ptr(self, *args)
+
+    def device(self):
+        return _traph_tensor.IntTensor_device(self)
+
+    def fill_(self, value):
+        return _traph_tensor.IntTensor_fill_(self, value)
+
+    def item(self):
+        return _traph_tensor.IntTensor_item(self)
+
+    def offset(self):
+        return _traph_tensor.IntTensor_offset(self)
+
+    def order(self):
+        return _traph_tensor.IntTensor_order(self)
+
+    def platform(self):
+        return _traph_tensor.IntTensor_platform(self)
+
+    def reduce_(self, f):
+        return _traph_tensor.IntTensor_reduce_(self, f)
+
+    def reduce_dim(self, dim, f):
+        return _traph_tensor.IntTensor_reduce_dim(self, dim, f)
+
+    def reshape_(self, dims):
+        return _traph_tensor.IntTensor_reshape_(self, dims)
+
+    def resize_(self, dims):
+        return _traph_tensor.IntTensor_resize_(self, dims)
+
+    def sin_(self):
+        return _traph_tensor.IntTensor_sin_(self)
+
+    def size(self, *args):
+        return _traph_tensor.IntTensor_size(self, *args)
+
+    def storage(self):
+        return _traph_tensor.IntTensor_storage(self)
+
+    def stride(self, *args):
+        return _traph_tensor.IntTensor_stride(self, *args)
+
+    def sum(self):
+        return _traph_tensor.IntTensor_sum(self)
+
+    def to_string(self):
+        return _traph_tensor.IntTensor_to_string(self)
+    __swig_destroy__ = _traph_tensor.delete_IntTensor
+    __del__ = lambda self: None
+IntTensor_swigregister = _traph_tensor.IntTensor_swigregister
+IntTensor_swigregister(IntTensor)
+
+class LongTensor(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, LongTensor, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, LongTensor, name)
+    __repr__ = _swig_repr
+
+    def __init__(self, *args):
+        this = _traph_tensor.new_LongTensor(*args)
+        try:
+            self.this.append(this)
+        except __builtin__.Exception:
+            self.this = this
+
+    def add_(self, other):
+        return _traph_tensor.LongTensor_add_(self, other)
+
+    def apply_(self, f):
+        return _traph_tensor.LongTensor_apply_(self, f)
+
+    def clone(self):
+        return _traph_tensor.LongTensor_clone(self)
+
+    def cos_(self):
+        return _traph_tensor.LongTensor_cos_(self)
+
+    def create_grad(self):
+        return _traph_tensor.LongTensor_create_grad(self)
+
+    def data_ptr(self, *args):
+        return _traph_tensor.LongTensor_data_ptr(self, *args)
+
+    def device(self):
+        return _traph_tensor.LongTensor_device(self)
+
+    def fill_(self, value):
+        return _traph_tensor.LongTensor_fill_(self, value)
+
+    def item(self):
+        return _traph_tensor.LongTensor_item(self)
+
+    def offset(self):
+        return _traph_tensor.LongTensor_offset(self)
+
+    def order(self):
+        return _traph_tensor.LongTensor_order(self)
+
+    def platform(self):
+        return _traph_tensor.LongTensor_platform(self)
+
+    def reduce_(self, f):
+        return _traph_tensor.LongTensor_reduce_(self, f)
+
+    def reduce_dim(self, dim, f):
+        return _traph_tensor.LongTensor_reduce_dim(self, dim, f)
+
+    def reshape_(self, dims):
+        return _traph_tensor.LongTensor_reshape_(self, dims)
+
+    def resize_(self, dims):
+        return _traph_tensor.LongTensor_resize_(self, dims)
+
+    def sin_(self):
+        return _traph_tensor.LongTensor_sin_(self)
+
+    def size(self, *args):
+        return _traph_tensor.LongTensor_size(self, *args)
+
+    def storage(self):
+        return _traph_tensor.LongTensor_storage(self)
+
+    def stride(self, *args):
+        return _traph_tensor.LongTensor_stride(self, *args)
+
+    def sum(self):
+        return _traph_tensor.LongTensor_sum(self)
+
+    def to_string(self):
+        return _traph_tensor.LongTensor_to_string(self)
+    __swig_destroy__ = _traph_tensor.delete_LongTensor
+    __del__ = lambda self: None
+LongTensor_swigregister = _traph_tensor.LongTensor_swigregister
+LongTensor_swigregister(LongTensor)
+
+class FloatTensor(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, FloatTensor, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, FloatTensor, name)
+    __repr__ = _swig_repr
+
+    def __init__(self, *args):
+        this = _traph_tensor.new_FloatTensor(*args)
+        try:
+            self.this.append(this)
+        except __builtin__.Exception:
+            self.this = this
+
+    def add_(self, other):
+        return _traph_tensor.FloatTensor_add_(self, other)
+
+    def apply_(self, f):
+        return _traph_tensor.FloatTensor_apply_(self, f)
+
+    def clone(self):
+        return _traph_tensor.FloatTensor_clone(self)
+
+    def cos_(self):
+        return _traph_tensor.FloatTensor_cos_(self)
+
+    def create_grad(self):
+        return _traph_tensor.FloatTensor_create_grad(self)
+
+    def data_ptr(self, *args):
+        return _traph_tensor.FloatTensor_data_ptr(self, *args)
+
+    def device(self):
+        return _traph_tensor.FloatTensor_device(self)
+
+    def fill_(self, value):
+        return _traph_tensor.FloatTensor_fill_(self, value)
+
+    def item(self):
+        return _traph_tensor.FloatTensor_item(self)
+
+    def offset(self):
+        return _traph_tensor.FloatTensor_offset(self)
+
+    def order(self):
+        return _traph_tensor.FloatTensor_order(self)
+
+    def platform(self):
+        return _traph_tensor.FloatTensor_platform(self)
+
+    def reduce_(self, f):
+        return _traph_tensor.FloatTensor_reduce_(self, f)
+
+    def reduce_dim(self, dim, f):
+        return _traph_tensor.FloatTensor_reduce_dim(self, dim, f)
+
+    def reshape_(self, dims):
+        return _traph_tensor.FloatTensor_reshape_(self, dims)
+
+    def resize_(self, dims):
+        return _traph_tensor.FloatTensor_resize_(self, dims)
+
+    def sin_(self):
+        return _traph_tensor.FloatTensor_sin_(self)
+
+    def size(self, *args):
+        return _traph_tensor.FloatTensor_size(self, *args)
+
+    def storage(self):
+        return _traph_tensor.FloatTensor_storage(self)
+
+    def stride(self, *args):
+        return _traph_tensor.FloatTensor_stride(self, *args)
+
+    def sum(self):
+        return _traph_tensor.FloatTensor_sum(self)
+
+    def to_string(self):
+        return _traph_tensor.FloatTensor_to_string(self)
+    __swig_destroy__ = _traph_tensor.delete_FloatTensor
+    __del__ = lambda self: None
+FloatTensor_swigregister = _traph_tensor.FloatTensor_swigregister
+FloatTensor_swigregister(FloatTensor)
+
+class DoubleTensor(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, DoubleTensor, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, DoubleTensor, name)
+    __repr__ = _swig_repr
+
+    def __init__(self, *args):
+        this = _traph_tensor.new_DoubleTensor(*args)
+        try:
+            self.this.append(this)
+        except __builtin__.Exception:
+            self.this = this
+
+    def add_(self, other):
+        return _traph_tensor.DoubleTensor_add_(self, other)
+
+    def apply_(self, f):
+        return _traph_tensor.DoubleTensor_apply_(self, f)
+
+    def clone(self):
+        return _traph_tensor.DoubleTensor_clone(self)
+
+    def cos_(self):
+        return _traph_tensor.DoubleTensor_cos_(self)
+
+    def create_grad(self):
+        return _traph_tensor.DoubleTensor_create_grad(self)
+
+    def data_ptr(self, *args):
+        return _traph_tensor.DoubleTensor_data_ptr(self, *args)
+
+    def device(self):
+        return _traph_tensor.DoubleTensor_device(self)
+
+    def fill_(self, value):
+        return _traph_tensor.DoubleTensor_fill_(self, value)
+
+    def item(self):
+        return _traph_tensor.DoubleTensor_item(self)
+
+    def offset(self):
+        return _traph_tensor.DoubleTensor_offset(self)
+
+    def order(self):
+        return _traph_tensor.DoubleTensor_order(self)
+
+    def platform(self):
+        return _traph_tensor.DoubleTensor_platform(self)
+
+    def reduce_(self, f):
+        return _traph_tensor.DoubleTensor_reduce_(self, f)
+
+    def reduce_dim(self, dim, f):
+        return _traph_tensor.DoubleTensor_reduce_dim(self, dim, f)
+
+    def reshape_(self, dims):
+        return _traph_tensor.DoubleTensor_reshape_(self, dims)
+
+    def resize_(self, dims):
+        return _traph_tensor.DoubleTensor_resize_(self, dims)
+
+    def sin_(self):
+        return _traph_tensor.DoubleTensor_sin_(self)
+
+    def size(self, *args):
+        return _traph_tensor.DoubleTensor_size(self, *args)
+
+    def storage(self):
+        return _traph_tensor.DoubleTensor_storage(self)
+
+    def stride(self, *args):
+        return _traph_tensor.DoubleTensor_stride(self, *args)
+
+    def sum(self):
+        return _traph_tensor.DoubleTensor_sum(self)
+
+    def to_string(self):
+        return _traph_tensor.DoubleTensor_to_string(self)
+    __swig_destroy__ = _traph_tensor.delete_DoubleTensor
+    __del__ = lambda self: None
+DoubleTensor_swigregister = _traph_tensor.DoubleTensor_swigregister
+DoubleTensor_swigregister(DoubleTensor)
+
 # This file is compatible with both classic and new-style classes.
 
 

traph/include/traph/tensor/tensor.h

@@ -7,6 +7,7 @@
 #include <functional>
 #include <stdexcept>
 #include <algorithm>
+#include <string>
 
 
 #include<traph/core/type.h>
@@ -262,7 +263,7 @@ namespace traph
     template<typename T>
     Tensor<T>::Tensor(const T& t)
         :_rep(new TensorStorage<T>),
-        _dimensions(), _offset(0), strides(), _order(order)
+        _dimensions(), _offset(0), _strides(), _order(layout_type::column_major)
     {
         _dimensions.resize(1);
         auto_strides();

traph/include/traph/tensor/tensor_storage.h

@@ -1,6 +1,7 @@
 #ifndef TRAPH_TENSOR_TENSOR_STORAGE_H_
 #define TRAPH_TENSOR_TENSOR_STORAGE_H_
 
+#include<traph/core/type.h>
 #include<traph/core/tensor_storage.h>
 
 namespace traph

traph/source/interface/CMakeLists.txt

@@ -20,5 +20,7 @@ IF(ENABLE_PYTHON)
     SWIG_ADD_LIBRARY(traph_tensor LANGUAGE python SOURCES traph_tensor.i)
     SWIG_LINK_LIBRARIES(traph_tensor ${PYTHON_LIBRARIES})
     SWIG_LINK_LIBRARIES(traph_tensor traph-core)
+    SWIG_LINK_LIBRARIES(traph_tensor traph-tensor)
+    SWIG_LINK_LIBRARIES(traph_tensor traph-nn)
 ENDIF()
 

traph/source/interface/traph_tensor.i

@@ -1,11 +1,22 @@
 %module traph_tensor
+
+%begin %{
+#ifdef _MSC_VER
+#define SWIG_PYTHON_INTERPRETER_NO_DEBUG
+#endif
+%}
+
 %{
+    #include <string>
     #include<traph/core/type.h>
+    #include<traph/core/index.h>
     #include<traph/tensor/tensor.h>
-    #include<traph/tensor/index.h>
+    #include<traph/tensor/tensor_storage.h>
+    
     using namespace traph;
 %}
 
+
 typedef float f32;
 typedef double f64;
 typedef std::int8_t i8;
@@ -35,12 +46,17 @@ typedef i32 size_type;
   $result = PyInt_FromLong($1);
 }
 
+%typemap(in) std::string {
+  PyObject* bytes = PyUnicode_AsUTF8String($input);
+  $1 = PyBytes_AsString(bytes);
+}
+
+%typemap(out) std::string {
+  $result = PyUnicode_FromString($1.data());
+}
+
 class DimVector
 {
-private:
-    std::unique_ptr<idx_type[]> data;
-    idx_type stack_data[DIMVECTOR_SMALL_VECTOR_OPTIMIZATION];
-    idx_type dim_num;
 public:
     DimVector();
     DimVector(idx_type size);
@@ -48,49 +64,87 @@ public:
     DimVector(DimVector&& other);
     DimVector& operator=(const DimVector& other) noexcept;
     DimVector& operator=(DimVector&& other) noexcept;
+    void erase(idx_type idx);
     void push_back(idx_type idx);
     void resize(idx_type size);
     idx_type size() const;
+    idx_type flat_size() const;
     idx_type& operator[](idx_type dim);
     idx_type operator[](idx_type dim) const;
 };
 
-template<class T>
+template<typename T>
 class TensorStorage
 {
-private:
-    std::unique_ptr<T[]> data;
-    idx_type len;
 public:
     TensorStorage();
     TensorStorage(const TensorStorage& other);
     TensorStorage(TensorStorage&& other);
+
     TensorStorage& operator=(const TensorStorage& other);
     TensorStorage& operator=(TensorStorage&& other);
 
-    idx_type size() const;
-    size_type element_size() const;
-    void resize_(idx_type size);
+    virtual std::shared_ptr<StorageBase<T>> clone() const override;
+    virtual T* data_ptr() override;
+    virtual const T* data_ptr() const override;
+    virtual idx_type size() const override;
+    virtual size_type element_size() const override;
+
+    virtual void resize_(idx_type size) override;
+
+    // fill
+    virtual void fill_(T v) override;
 };
 
+%template(ByteStorage) TensorStorage<u8>;
+%template(CharStorage) TensorStorage<i8>;
+%template(ShortStorage) TensorStorage<i16>;
+%template(IntStorage) TensorStorage<i32>;
+%template(LongStorage) TensorStorage<i64>;
+%template(FloatStorage) TensorStorage<f32>;
+%template(DoubleStorage) TensorStorage<f64>;
+
 template<class T>
 class Tensor
 {
-private:
-    std::unique_ptr<TensorStorage<T>> rep;
-    DimVector dimensions;
-    idx_type offset;
-    DimVector strides;
-    layout_type order;
 public:
-    Tensor();
-    Tensor(const DimVector& dimensions);
-    Tensor(const DimVector& dimensions, layout_type order);
-    Tensor(const DimVector& dimensions, const DimVector& strides);
-    Tensor(const DimVector& dimensions, const DimVector& strides, layout_type order);
-
-    void reshape(const DimVector& dims);
-    T& index(const DimVector& dims);
+  Tensor();
+  explicit Tensor(const DimVector& dimensions);
+  explicit Tensor(const DimVector& dimensions, layout_type order);
+  explicit Tensor(const DimVector& dimensions, const DimVector& strides);
+  explicit Tensor(const DimVector& dimensions, const DimVector& strides, layout_type order);
+  Tensor(const T& t);
+
+  Tensor(const Tensor& other) = delete;
+  Tensor(Tensor&& other) = delete;
+  Tensor& operator= (const Tensor& other) = delete;
+  Tensor& operator= (Tensor&& other) = delete;
+
+  virtual void add_(TensorInterfacePtr other) override;
+  virtual void apply_(std::function<T(T)> f) override;
+  virtual TensorInterfacePtr clone() const override;
+  virtual void cos_() override;
+  virtual std::shared_ptr<TensorBase<f32>> create_grad() override;
+  virtual T* data_ptr() override;
+  virtual const T* data_ptr() const override;
+  virtual device_id device() override;
+  virtual void fill_(T value) override;
+  virtual T item() const override;
+  virtual idx_type offset() const override;
+  virtual layout_type order() const override;
+  virtual platform_type platform() override;
+  virtual T reduce_(std::function<T(T,T)> f) const override;
+  virtual TensorInterfacePtr reduce_dim(idx_type dim, std::function<T(T,T)> f) const override;
+  virtual void reshape_(const DimVector& dims) override;
+  virtual void resize_(const DimVector& dims) override;
+  virtual void sin_() override;
+  virtual DimVector size() const override;
+  virtual idx_type size(idx_type i) const override;
+  virtual std::shared_ptr<StorageBase<T>> storage() const override;
+  virtual DimVector stride() const override;
+  virtual idx_type stride(idx_type i) const override;
+  virtual TensorInterfacePtr sum() const override;
+  virtual std::string to_string() const override;
 };
 
 %template(ByteTensor) Tensor<u8>;
@@ -101,10 +155,4 @@ public:
 %template(FloatTensor) Tensor<f32>;
 %template(DoubleTensor) Tensor<f64>;
 
-%template(ByteStorage) TensorStorage<u8>;
-%template(CharStorage) TensorStorage<i8>;
-%template(ShortStorage) TensorStorage<i16>;
-%template(IntStorage) TensorStorage<i32>;
-%template(LongStorage) TensorStorage<i64>;
-%template(FloatStorage) TensorStorage<f32>;
-%template(DoubleStorage) TensorStorage<f64>;
+