impl new tensor apply

CMakeLists.txt

@@ -1,10 +1,10 @@
 cmake_minimum_required(VERSION 3.0)
 
-if(DEFINED ENV{VCPKG_ROOT} AND NOT DEFINED CMAKE_TOOLCHAIN_FILE)
-  	set(CMAKE_TOOLCHAIN_FILE "$ENV{VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake"
-	  CACHE STRING "")
-	MESSAGE(STATUS "Using vcpkg")
-endif()
+# if(DEFINED ENV{VCPKG_ROOT} AND NOT DEFINED CMAKE_TOOLCHAIN_FILE)
+#   	set(CMAKE_TOOLCHAIN_FILE "$ENV{VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake"
+# 	  CACHE STRING "")
+# 	MESSAGE(STATUS "Using vcpkg")
+# endif()
 
 project(traph)
 
@@ -28,7 +28,17 @@ endif()
 
 
 # languge feature
-set(ENABLE_PYTHON True CACHE BOOL "Language: Python")
+set(ENABLE_PYTHON False CACHE BOOL "Language: Python")
+
+
+# thread feature
+FIND_PACKAGE(OpenMP REQUIRED)
+if(OPENMP_FOUND)
+	message("OPENMP FOUND")
+	set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${OpenMP_C_FLAGS}")
+	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}")
+	set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${OpenMP_EXE_LINKER_FLAGS}")
+endif()
 
 # gpgpu feature
 set(ENABLE_CUDA FALSE CACHE BOOL "Feature: OPENCL")

traph/include/traph/core/tensor.h

@@ -157,7 +157,8 @@ namespace traph
         return true;
     }
 
-    inline std::shared_ptr<TensorInterface> sort_strides(std::shared_ptr<TensorInterface> t)
+    template<class T>
+    std::shared_ptr<TensorBase<T>> sort_strides(std::shared_ptr<TensorBase<T>> t)
     {
         DimVector indices(t->ndimension());
         for (idx_type i = 0; i < t->ndimension(); i++)

traph/include/traph/tensor/tensor.h

@@ -108,24 +108,60 @@ namespace traph
     // TODO: macros
     // apply apply2 reduce...
 
-#define TENSOR_APPLY(TYPE, TENSOR, CODE)
-	{
-        std::function<void(idx_type, idx_type>)> apply_impl =
-        [&](idx_type dim, idx_type idx){
-            idx_type dim_size = TENSOR->_dimensions.size();
-            
-            for(idx_type i = 0; i < TENSOR->_dimensions[dim]; ++i)
-            {
-                if(dim_idx == dim_size - 1)
-                    CODE
-                else
-                    apply_impl(dim_idx + 1, idx, f);
-                idx += TENSOR->_strides[dim];
-            }
-        };
+#define TENSOR_APPLY_CONTIGUOUS(TYPE, TENSOR, CODE) \
+    {                                               \
+        TYPE *element_ptr = TENSOR->data_ptr();     \
+        idx_type len = TENSOR->storage()->size();   \
+        TYPE *end_ptr = element_ptr + len;          \
+        while (element_ptr < end_ptr)               \
+        {                                           \
+            CODE;                                   \
+            element_ptr++;                          \
+        }                                           \
+    }
 
-        apply_impl(0, _offset);
-	}
+#define MEMORY_APPLY_CONTIGUOUS(TYPE, PTR, LEN, CODE) \
+    {                                                 \
+        TYPE *end_ptr = PTR + LEN;                    \
+        while (PTR < end_ptr)                         \
+        {                                             \
+            CODE;                                     \
+            PTR++;                                    \
+        }                                             \
+    }
+
+#define TENSOR_APPLY(TYPE, TENSOR, CODE)                                                                                        \
+    {                                                                                                                           \
+        idx_type dim_size = TENSOR->ndimension();                                                                               \
+        std::function<void(idx_type, TYPE *)> apply_impl =                                                                      \
+            [&](idx_type dim, TYPE *element_ptr) {                                                                              \
+                idx_type contiguous_dim = dim;                                                                                  \
+                while (contiguous_dim < dim_size - 1 &&                                                                         \
+                       TENSOR->stride(contiguous_dim + 1) * TENSOR->size(contiguous_dim + 1) == TENSOR->stride(contiguous_dim)) \
+                {                                                                                                               \
+                    contiguous_dim++;                                                                                           \
+                }                                                                                                               \
+                                                                                                                                \
+                int step_num = 1;                                                                                               \
+                for (idx_type i = contiguous_dim; i >= dim; --i)                                                                \
+                    step_num *= TENSOR->size(i);                                                                                \
+                                                                                                                                \
+                if (contiguous_dim == dim_size - 1)                                                                             \
+                {                                                                                                               \
+                    MEMORY_APPLY_CONTIGUOUS(TYPE, element_ptr, step_num, CODE);                                                 \
+                }                                                                                                               \
+                else                                                                                                            \
+                {                                                                                                               \
+                    for (idx_type i = 0; i < step_num; ++i)                                                                     \
+                    {                                                                                                           \
+                        apply_impl(contiguous_dim + 1, element_ptr);                                                            \
+                        element_ptr += TENSOR->stride(contiguous_dim);                                                          \
+                    }                                                                                                           \
+                }                                                                                                               \
+            };                                                                                                                  \
+                                                                                                                                \
+        apply_impl(0, TENSOR->data_ptr() + TENSOR->offset());                                                                   \
+    }
 }
 
 #endif // !TRAPH_TENSOR

traph/source/demo/main.cpp

@@ -5,6 +5,7 @@
 #include <traph/nn/layers/linear.h>
 #include <traph/nn/layers/loss.h>
 #include <traph/core/tensor.h>
+#include <traph/tensor/float_tensor.h>
 #include <traph/nn/optim.h>
 
 #include <iostream>
@@ -88,7 +89,7 @@ int main()
 
 	int batch_size = 16;
 	
-	auto x = traph::ones<traph::f32>({ batch_size,32 });
+	auto x = traph::randn<traph::f32>({ batch_size,32 });
 	auto y = traph::ones<traph::f32>({ batch_size,2 });
 
 	MyModel model;
@@ -122,6 +123,24 @@ int main()
 	//auto d = sum(c);
 	//d->backward();
 	//std::cout << a->grad()->to_string();
+
+	/*
+	DimVector dim;
+	dim.push_back(3);
+	dim.push_back(4);
+	auto a = std::make_shared<traph::FloatTensor>(dim);
+	auto b = std::make_shared<traph::FloatTensor>(dim);
+
+	a->fill_(0);
+	SliceVector slice(2);
+	slice[0] = Slice(0, 2);
+	slice[1] = Slice(0, 2);
+
+	auto selected = std::dynamic_pointer_cast<traph::FloatTensor>(a->select(slice));
+	TENSOR_APPLY(float, selected, (*element_ptr)++);
+	std::cout << a->to_string();
+	*/
+
 	
     return 0;
 }

traph/source/tensor/arithmetic.cpp

@@ -29,8 +29,8 @@ namespace traph
 		std::shared_ptr<Tensor<u8>> result(new Tensor<u8>(dim));
 
 		// copy data
-		Eigen::Map<const Eigen::Matrix<u8, Eigen::Dynamic, Eigen::Dynamic>> eigen_a(a.data_ptr() + a.offset(), a.size()[0], a.size()[1]);
-		Eigen::Map<const Eigen::Matrix<u8, Eigen::Dynamic, Eigen::Dynamic>> eigen_b(b.data_ptr() + b.offset(), b.size()[0], b.size()[1]);
+		Eigen::Map<const Eigen::Matrix<u8, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>> eigen_a(a.data_ptr() + a.offset(), a.size()[0], a.size()[1]);
+		Eigen::Map<const Eigen::Matrix<u8, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>> eigen_b(b.data_ptr() + b.offset(), b.size()[0], b.size()[1]);
 
 		Eigen::Matrix<u8, Eigen::Dynamic, Eigen::Dynamic> eigen_c = eigen_a * eigen_b;
 		// copy to result
@@ -49,8 +49,8 @@ namespace traph
 		std::shared_ptr<Tensor<i8>> result(new Tensor<i8>(dim));
 
 		// copy data
-		Eigen::Map<const Eigen::Matrix<i8, Eigen::Dynamic, Eigen::Dynamic>> eigen_a(a.data_ptr() + a.offset(), a.size()[0], a.size()[1]);
-		Eigen::Map<const Eigen::Matrix<i8, Eigen::Dynamic, Eigen::Dynamic>> eigen_b(b.data_ptr() + b.offset(), b.size()[0], b.size()[1]);
+		Eigen::Map<const Eigen::Matrix<i8, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>> eigen_a(a.data_ptr() + a.offset(), a.size()[0], a.size()[1]);
+		Eigen::Map<const Eigen::Matrix<i8, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>> eigen_b(b.data_ptr() + b.offset(), b.size()[0], b.size()[1]);
 
 		Eigen::Matrix<i8, Eigen::Dynamic, Eigen::Dynamic> eigen_c = eigen_a * eigen_b;
 		// copy to result
@@ -69,8 +69,8 @@ namespace traph
 		std::shared_ptr<Tensor<i16>> result(new Tensor<i16>(dim));
 
 		// copy data
-		Eigen::Map<const Eigen::Matrix<i16, Eigen::Dynamic, Eigen::Dynamic>> eigen_a(a.data_ptr() + a.offset(), a.size()[0], a.size()[1]);
-		Eigen::Map<const Eigen::Matrix<i16, Eigen::Dynamic, Eigen::Dynamic>> eigen_b(b.data_ptr() + b.offset(), b.size()[0], b.size()[1]);
+		Eigen::Map<const Eigen::Matrix<i16, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>> eigen_a(a.data_ptr() + a.offset(), a.size()[0], a.size()[1]);
+		Eigen::Map<const Eigen::Matrix<i16, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>> eigen_b(b.data_ptr() + b.offset(), b.size()[0], b.size()[1]);
 
 		Eigen::Matrix<i16, Eigen::Dynamic, Eigen::Dynamic> eigen_c = eigen_a * eigen_b;
 		// copy to result
@@ -89,8 +89,8 @@ namespace traph
 		std::shared_ptr<Tensor<i32>> result(new Tensor<i32>(dim));
 
 		// copy data
-		Eigen::Map<const Eigen::Matrix<i32, Eigen::Dynamic, Eigen::Dynamic>> eigen_a(a.data_ptr() + a.offset(), a.size()[0], a.size()[1]);
-		Eigen::Map<const Eigen::Matrix<i32, Eigen::Dynamic, Eigen::Dynamic>> eigen_b(b.data_ptr() + b.offset(), b.size()[0], b.size()[1]);
+		Eigen::Map<const Eigen::Matrix<i32, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>> eigen_a(a.data_ptr() + a.offset(), a.size()[0], a.size()[1]);
+		Eigen::Map<const Eigen::Matrix<i32, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>> eigen_b(b.data_ptr() + b.offset(), b.size()[0], b.size()[1]);
 
 		Eigen::Matrix<i32, Eigen::Dynamic, Eigen::Dynamic> eigen_c = eigen_a * eigen_b;
 		// copy to result
@@ -109,8 +109,8 @@ namespace traph
 		std::shared_ptr<Tensor<i64>> result(new Tensor<i64>(dim));
 
 		// copy data
-		Eigen::Map<const Eigen::Matrix<i64, Eigen::Dynamic, Eigen::Dynamic>> eigen_a(a.data_ptr() + a.offset(), a.size()[0], a.size()[1]);
-		Eigen::Map<const Eigen::Matrix<i64, Eigen::Dynamic, Eigen::Dynamic>> eigen_b(b.data_ptr() + b.offset(), b.size()[0], b.size()[1]);
+		Eigen::Map<const Eigen::Matrix<i64, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>> eigen_a(a.data_ptr() + a.offset(), a.size()[0], a.size()[1]);
+		Eigen::Map<const Eigen::Matrix<i64, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>> eigen_b(b.data_ptr() + b.offset(), b.size()[0], b.size()[1]);
 
 		Eigen::Matrix<i64, Eigen::Dynamic, Eigen::Dynamic> eigen_c = eigen_a * eigen_b;
 		// copy to result
@@ -130,8 +130,8 @@ namespace traph
 
 #ifdef TRAPH_BUILD_EIGEN
 		// copy data
-		Eigen::Map<const Eigen::Matrix<f32, Eigen::Dynamic, Eigen::Dynamic>> eigen_a(a.data_ptr() + a.offset(), a.size()[0], a.size()[1]);
-		Eigen::Map<const Eigen::Matrix<f32, Eigen::Dynamic, Eigen::Dynamic>> eigen_b(b.data_ptr() + b.offset(), b.size()[0], b.size()[1]);
+		Eigen::Map<const Eigen::Matrix<f32, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>> eigen_a(a.data_ptr() + a.offset(), a.size()[0], a.size()[1]);
+		Eigen::Map<const Eigen::Matrix<f32, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>> eigen_b(b.data_ptr() + b.offset(), b.size()[0], b.size()[1]);
 
 		Eigen::Matrix<f32, Eigen::Dynamic, Eigen::Dynamic> eigen_c = eigen_a * eigen_b;
 		// copy to result
@@ -169,8 +169,8 @@ namespace traph
 
 #ifdef TRAPH_BUILD_EIGEN
 		// copy data
-		Eigen::Map<const Eigen::Matrix<f64, Eigen::Dynamic, Eigen::Dynamic>> eigen_a(a.data_ptr() + a.offset(), a.size()[0], a.size()[1]);
-		Eigen::Map<const Eigen::Matrix<f64, Eigen::Dynamic, Eigen::Dynamic>> eigen_b(b.data_ptr() + b.offset(), b.size()[0], b.size()[1]);
+		Eigen::Map<const Eigen::Matrix<f64, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>> eigen_a(a.data_ptr() + a.offset(), a.size()[0], a.size()[1]);
+		Eigen::Map<const Eigen::Matrix<f64, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>> eigen_b(b.data_ptr() + b.offset(), b.size()[0], b.size()[1]);
 
 		Eigen::Matrix<f64, Eigen::Dynamic, Eigen::Dynamic> eigen_c = eigen_a * eigen_b;
 		// copy to result
@@ -203,9 +203,9 @@ namespace traph
 		std::shared_ptr<Tensor<f32>> result(new Tensor<f32>(a.size()[0], a.size()[1]));
 
 		// copy data
-		Eigen::Map<const Eigen::Matrix<f32, Eigen::Dynamic, Eigen::Dynamic>> eigen_a(a.data_ptr() + a.offset(), a.size()[0], a.size()[1]);
+		Eigen::Map<const Eigen::Matrix<f32, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>> eigen_a(a.data_ptr() + a.offset(), a.size()[0], a.size()[1]);
 
-		Eigen::Matrix<f32, Eigen::Dynamic, Eigen::Dynamic> eigen_c = eigen_a.inverse();
+		Eigen::Matrix<f32, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor> eigen_c = eigen_a.inverse();
 		// copy to result
 		std::copy(eigen_c.data(), eigen_c.data() + a.size()[0] * a.size()[1], result->data_ptr());
 		return result;
@@ -217,9 +217,9 @@ namespace traph
 		std::shared_ptr<Tensor<f64>> result(new Tensor<f64>(a.size()[0], a.size()[1]));
 
 		// copy data
-		Eigen::Map<const Eigen::Matrix<f64, Eigen::Dynamic, Eigen::Dynamic>> eigen_a(a.data_ptr() + a.offset(), a.size()[0], a.size()[1]);
+		Eigen::Map<const Eigen::Matrix<f64, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>> eigen_a(a.data_ptr() + a.offset(), a.size()[0], a.size()[1]);
 
-		Eigen::Matrix<f64, Eigen::Dynamic, Eigen::Dynamic> eigen_c = eigen_a.inverse();
+		Eigen::Matrix<f64, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor> eigen_c = eigen_a.inverse();
 		// copy to result
 		std::copy(eigen_c.data(), eigen_c.data() + a.size()[0] * a.size()[1], result->data_ptr());
 		return result;

traph/source/tensor/byte_tensor.cpp

@@ -9,7 +9,7 @@ namespace traph
         idx_type dim_num = _dimensions.size();
         _strides.resize(dim_num);
         idx_type stride = 1;
-        if(_order == layout_type::column_major)
+        if(_order == layout_type::row_major)
         {
             for (idx_type i = dim_num - 1; i >= 0; --i)
             {
@@ -86,13 +86,13 @@ namespace traph
     // public
     Tensor<u8>::Tensor()
         :_rep(new TensorStorage<u8>),
-        _dimensions(), _offset(0), _strides(), _order(layout_type::column_major)
+        _dimensions(), _offset(0), _strides(), _order(layout_type::row_major)
     {
     }
 
     Tensor<u8>::Tensor(const DimVector& dimensions)
         :_rep(new TensorStorage<u8>),
-        _dimensions(dimensions), _offset(0), _strides(), _order(layout_type::column_major)
+        _dimensions(dimensions), _offset(0), _strides(), _order(layout_type::row_major)
     {
         auto_strides();
         
@@ -110,7 +110,7 @@ namespace traph
 
     Tensor<u8>::Tensor(const DimVector& dimensions, const DimVector& strides)
         :_rep(new TensorStorage<u8>),
-        _dimensions(dimensions), _offset(0), _strides(strides), _order(layout_type::column_major)
+        _dimensions(dimensions), _offset(0), _strides(strides), _order(layout_type::row_major)
     {
         auto_strides();
 

traph/source/tensor/char_tensor.cpp

@@ -9,7 +9,7 @@ namespace traph
         idx_type dim_num = _dimensions.size();
         _strides.resize(dim_num);
         idx_type stride = 1;
-        if(_order == layout_type::column_major)
+        if(_order == layout_type::row_major)
         {
             for (idx_type i = dim_num - 1; i >= 0; --i)
             {
@@ -86,13 +86,13 @@ namespace traph
     // public
     Tensor<i8>::Tensor()
         :_rep(new TensorStorage<i8>),
-        _dimensions(), _offset(0), _strides(), _order(layout_type::column_major)
+        _dimensions(), _offset(0), _strides(), _order(layout_type::row_major)
     {
     }
 
     Tensor<i8>::Tensor(const DimVector& dimensions)
         :_rep(new TensorStorage<i8>),
-        _dimensions(dimensions), _offset(0), _strides(), _order(layout_type::column_major)
+        _dimensions(dimensions), _offset(0), _strides(), _order(layout_type::row_major)
     {
         auto_strides();
         
@@ -110,7 +110,7 @@ namespace traph
 
     Tensor<i8>::Tensor(const DimVector& dimensions, const DimVector& strides)
         :_rep(new TensorStorage<i8>),
-        _dimensions(dimensions), _offset(0), _strides(strides), _order(layout_type::column_major)
+        _dimensions(dimensions), _offset(0), _strides(strides), _order(layout_type::row_major)
     {
         auto_strides();
 

traph/source/tensor/double_tensor.cpp

@@ -9,7 +9,7 @@ namespace traph
         idx_type dim_num = _dimensions.size();
         _strides.resize(dim_num);
         idx_type stride = 1;
-        if(_order == layout_type::column_major)
+        if(_order == layout_type::row_major)
         {
             for (idx_type i = dim_num - 1; i >= 0; --i)
             {
@@ -86,13 +86,13 @@ namespace traph
     // public
     Tensor<f64>::Tensor()
         :_rep(new TensorStorage<f64>),
-        _dimensions(), _offset(0), _strides(), _order(layout_type::column_major)
+        _dimensions(), _offset(0), _strides(), _order(layout_type::row_major)
     {
     }
 
     Tensor<f64>::Tensor(const DimVector& dimensions)
         :_rep(new TensorStorage<f64>),
-        _dimensions(dimensions), _offset(0), _strides(), _order(layout_type::column_major)
+        _dimensions(dimensions), _offset(0), _strides(), _order(layout_type::row_major)
     {
         auto_strides();
         
@@ -110,7 +110,7 @@ namespace traph
 
     Tensor<f64>::Tensor(const DimVector& dimensions, const DimVector& strides)
         :_rep(new TensorStorage<f64>),
-        _dimensions(dimensions), _offset(0), _strides(strides), _order(layout_type::column_major)
+        _dimensions(dimensions), _offset(0), _strides(strides), _order(layout_type::row_major)
     {
         auto_strides();
 

traph/source/tensor/float_tensor.cpp

@@ -9,7 +9,7 @@ namespace traph
         idx_type dim_num = _dimensions.size();
         _strides.resize(dim_num);
         idx_type stride = 1;
-        if(_order == layout_type::column_major)
+        if(_order == layout_type::row_major)
         {
             for (idx_type i = dim_num - 1; i >= 0; --i)
             {
@@ -86,13 +86,13 @@ namespace traph
     // public
     Tensor<f32>::Tensor()
         :_rep(new TensorStorage<f32>),
-        _dimensions(), _offset(0), _strides(), _order(layout_type::column_major)
+        _dimensions(), _offset(0), _strides(), _order(layout_type::row_major)
     {
     }
 
     Tensor<f32>::Tensor(const DimVector& dimensions)
         :_rep(new TensorStorage<f32>),
-        _dimensions(dimensions), _offset(0), _strides(), _order(layout_type::column_major)
+        _dimensions(dimensions), _offset(0), _strides(), _order(layout_type::row_major)
     {
         auto_strides();
         
@@ -110,7 +110,7 @@ namespace traph
 
     Tensor<f32>::Tensor(const DimVector& dimensions, const DimVector& strides)
         :_rep(new TensorStorage<f32>),
-        _dimensions(dimensions), _offset(0), _strides(strides), _order(layout_type::column_major)
+        _dimensions(dimensions), _offset(0), _strides(strides), _order(layout_type::row_major)
     {
         auto_strides();
 

traph/source/tensor/int_tensor.cpp

@@ -9,7 +9,7 @@ namespace traph
         idx_type dim_num = _dimensions.size();
         _strides.resize(dim_num);
         idx_type stride = 1;
-        if(_order == layout_type::column_major)
+        if(_order == layout_type::row_major)
         {
             for (idx_type i = dim_num - 1; i >= 0; --i)
             {
@@ -86,13 +86,13 @@ namespace traph
     // public
     Tensor<i32>::Tensor()
         :_rep(new TensorStorage<i32>),
-        _dimensions(), _offset(0), _strides(), _order(layout_type::column_major)
+        _dimensions(), _offset(0), _strides(), _order(layout_type::row_major)
     {
     }
 
     Tensor<i32>::Tensor(const DimVector& dimensions)
         :_rep(new TensorStorage<i32>),
-        _dimensions(dimensions), _offset(0), _strides(), _order(layout_type::column_major)
+        _dimensions(dimensions), _offset(0), _strides(), _order(layout_type::row_major)
     {
         auto_strides();
         
@@ -110,7 +110,7 @@ namespace traph
 
     Tensor<i32>::Tensor(const DimVector& dimensions, const DimVector& strides)
         :_rep(new TensorStorage<i32>),
-        _dimensions(dimensions), _offset(0), _strides(strides), _order(layout_type::column_major)
+        _dimensions(dimensions), _offset(0), _strides(strides), _order(layout_type::row_major)
     {
         auto_strides();
 

traph/source/tensor/long_tensor.cpp

@@ -9,7 +9,7 @@ namespace traph
         idx_type dim_num = _dimensions.size();
         _strides.resize(dim_num);
         idx_type stride = 1;
-        if(_order == layout_type::column_major)
+        if(_order == layout_type::row_major)
         {
             for (idx_type i = dim_num - 1; i >= 0; --i)
             {
@@ -86,13 +86,13 @@ namespace traph
     // public
     Tensor<i64>::Tensor()
         :_rep(new TensorStorage<i64>),
-        _dimensions(), _offset(0), _strides(), _order(layout_type::column_major)
+        _dimensions(), _offset(0), _strides(), _order(layout_type::row_major)
     {
     }
 
     Tensor<i64>::Tensor(const DimVector& dimensions)
         :_rep(new TensorStorage<i64>),
-        _dimensions(dimensions), _offset(0), _strides(), _order(layout_type::column_major)
+        _dimensions(dimensions), _offset(0), _strides(), _order(layout_type::row_major)
     {
         auto_strides();
         
@@ -110,7 +110,7 @@ namespace traph
 
     Tensor<i64>::Tensor(const DimVector& dimensions, const DimVector& strides)
         :_rep(new TensorStorage<i64>),
-        _dimensions(dimensions), _offset(0), _strides(strides), _order(layout_type::column_major)
+        _dimensions(dimensions), _offset(0), _strides(strides), _order(layout_type::row_major)
     {
         auto_strides();
 

traph/source/tensor/short_tensor.cpp

@@ -9,7 +9,7 @@ namespace traph
         idx_type dim_num = _dimensions.size();
         _strides.resize(dim_num);
         idx_type stride = 1;
-        if(_order == layout_type::column_major)
+        if(_order == layout_type::row_major)
         {
             for (idx_type i = dim_num - 1; i >= 0; --i)
             {
@@ -86,13 +86,13 @@ namespace traph
     // public
     Tensor<i16>::Tensor()
         :_rep(new TensorStorage<i16>),
-        _dimensions(), _offset(0), _strides(), _order(layout_type::column_major)
+        _dimensions(), _offset(0), _strides(), _order(layout_type::row_major)
     {
     }
 
     Tensor<i16>::Tensor(const DimVector& dimensions)
         :_rep(new TensorStorage<i16>),
-        _dimensions(dimensions), _offset(0), _strides(), _order(layout_type::column_major)
+        _dimensions(dimensions), _offset(0), _strides(), _order(layout_type::row_major)
     {
         auto_strides();
         
@@ -110,7 +110,7 @@ namespace traph
 
     Tensor<i16>::Tensor(const DimVector& dimensions, const DimVector& strides)
         :_rep(new TensorStorage<i16>),
-        _dimensions(dimensions), _offset(0), _strides(strides), _order(layout_type::column_major)
+        _dimensions(dimensions), _offset(0), _strides(strides), _order(layout_type::row_major)
     {
         auto_strides();
 

traph/source/tensor/tensor.cpp

@@ -8,7 +8,7 @@ namespace traph
     template<typename T>
     Tensor<T>::Tensor()
         :_rep(new TensorStorage<T>),
-        _dimensions(), _offset(0), _strides(), _order(layout_type::column_major)
+        _dimensions(), _offset(0), _strides(), _order(layout_type::row_major)
     {
         throw std::runtime_error("No implement");
     }
@@ -17,7 +17,7 @@ namespace traph
     template<typename T>
     Tensor<T>::Tensor(const DimVector& dimensions)
         :_rep(new TensorStorage<T>),
-        _dimensions(dimensions), _offset(0), _strides(), _order(layout_type::column_major)
+        _dimensions(dimensions), _offset(0), _strides(), _order(layout_type::row_major)
     {
         throw std::runtime_error("No implement");
     }
@@ -33,7 +33,7 @@ namespace traph
     template<typename T>
     Tensor<T>::Tensor(const DimVector& dimensions, const DimVector& strides)
         :_rep(new TensorStorage<T>),
-        _dimensions(dimensions), _offset(0), _strides(strides), _order(layout_type::column_major)
+        _dimensions(dimensions), _offset(0), _strides(strides), _order(layout_type::row_major)
     {
         throw std::runtime_error("No implement");
     }
@@ -49,7 +49,7 @@ namespace traph
     template<typename T>
     Tensor<T>::Tensor(const T& t)
         :_rep(new TensorStorage<T>),
-        _dimensions(), _offset(0), _strides(), _order(layout_type::column_major)
+        _dimensions(), _offset(0), _strides(), _order(layout_type::row_major)
     {
         throw std::runtime_error("No implement");
     }