test changes

Author: BigNoobWasTaken

src/tensor_array/_core/tensor_bind.cc

@@ -186,9 +186,46 @@ PYBIND11_MODULE(tensor2, m)
 		pybind11::arg("dtype") = S_INT_32
 	);
 
+	m.def(
+		"add",
+		&tensor_array::value::add,
+		pybind11::arg("value_1"),
+		pybind11::arg("value_2")
+	);
+
+	m.def(
+		"multiply",
+		&tensor_array::value::multiply,
+		pybind11::arg("value_1"),
+		pybind11::arg("value_2")
+	);
+
+	m.def(
+		"divide",
+		&tensor_array::value::divide,
+		pybind11::arg("value_1"),
+		pybind11::arg("value_2")
+	);
+	
+	m.def(
+		"matmul",
+		&tensor_array::value::matmul,
+		pybind11::arg("value_1"),
+		pybind11::arg("value_2")
+	);
+
+	m.def(
+		"condition",
+		&tensor_array::value::condition,
+		pybind11::arg("condition_value"),
+		pybind11::arg("value_if_true"),
+		pybind11::arg("value_if_false")
+	);
+
 	pybind11::class_<Tensor>(m, "Tensor")
 		.def(pybind11::init())
 		.def(pybind11::init(&tensor_copying))
+		.def(pybind11::init(&convert_numpy_to_tensor_base<int>))
 		.def(pybind11::init(&convert_numpy_to_tensor_base<float>))
 		.def(pybind11::self + pybind11::self)
 		.def(pybind11::self - pybind11::self)
@@ -207,33 +244,27 @@ PYBIND11_MODULE(tensor2, m)
 		.def(+pybind11::self)
 		.def(-pybind11::self)
 		.def(hash(pybind11::self))
-		.def("transpose", &Tensor::transpose)
-		.def("calc_grad", &Tensor::calc_grad)
-		.def("get_grad", &Tensor::get_grad)
-		.def("sin", &Tensor::sin)
-		.def("sin", &Tensor::sin)
-		.def("cos", &Tensor::cos)
-		.def("tan", &Tensor::tan)
-		.def("sinh", &Tensor::sinh)
-		.def("cosh", &Tensor::cosh)
-		.def("tanh", &Tensor::tanh)
-		.def("log", &Tensor::log)
-		.def("clone", &Tensor::clone)
+		.def("transpose", &tensor_array::value::Tensor::transpose)
+		.def("calc_grad", &tensor_array::value::Tensor::calc_grad)
+		.def("get_grad", &tensor_array::value::Tensor::get_grad)
+		.def("sin", &tensor_array::value::Tensor::sin)
+		.def("cos", &tensor_array::value::Tensor::cos)
+		.def("tan", &tensor_array::value::Tensor::tan)
+		.def("sinh", &tensor_array::value::Tensor::sinh)
+		.def("cosh", &tensor_array::value::Tensor::cosh)
+		.def("tanh", &tensor_array::value::Tensor::tanh)
+		.def("log", &tensor_array::value::Tensor::log)
+		.def("clone", &tensor_array::value::Tensor::clone)
 		.def("cast", &tensor_cast_1)
-		.def("add", &add)
-		.def("multiply", &multiply)
-		.def("divide", &divide)
-		.def("matmul", &matmul)
-		.def("condition", &condition)
 		.def("numpy", &convert_tensor_to_numpy)
 		.def("shape", &tensor_shape)
 		.def("dtype", &tensor_type)
 		.def("__getitem__", &python_index)
 		.def("__getitem__", &python_slice)
 		.def("__getitem__", &python_tuple_slice)
 		.def("__len__", &python_len)
-		.def("__matmul__", &matmul)
-		.def("__rmatmul__", &matmul)
+		.def("__matmul__", &tensor_array::value::matmul)
+		.def("__rmatmul__", &tensor_array::value::matmul)
 		.def("__repr__", &tensor_to_string)
 		.def("__copy__", &tensor_copying);
 }

src/tensor_array/core/__init__.py

@@ -1,3 +1,4 @@
-from tensor_array.core.tensor2 import Tensor
-from tensor_array.core.tensor2 import zeros
-from tensor_array.core.tensor2 import DataType
+from .tensor import Tensor
+from .constants import *
+from .datatypes import DataTypes
+from .operator import *

src/tensor_array/core/constants.py

@@ -0,0 +1,6 @@
+from tensor_array.core.tensor2 import zeros as zerosWrapper
+from .tensor import Tensor
+from .datatypes import DataTypes
+
+def zeros(shape : Tensor, dtype : DataTypes = DataTypes.S_INT_32):
+    return zerosWrapper(shape, dtype)

src/tensor_array/core/datatypes.py

@@ -0,0 +1,17 @@
+from tensor_array.core.tensor2 import DataType as DataTypeWrapper
+from enum import Enum
+
+class DataTypes(Enum):
+    BOOL = DataTypeWrapper.BOOL
+    S_INT_8 = DataTypeWrapper.S_INT_8
+    S_INT_16 = DataTypeWrapper.S_INT_16
+    S_INT_32 = DataTypeWrapper.S_INT_32
+    S_INT_64 = DataTypeWrapper.S_INT_64
+    FLOAT = DataTypeWrapper.FLOAT
+    DOUBLE = DataTypeWrapper.DOUBLE
+    HALF = DataTypeWrapper.HALF
+    BFLOAT16 = DataTypeWrapper.BFLOAT16
+    U_INT_8 = DataTypeWrapper.U_INT_8
+    U_INT_16 = DataTypeWrapper.U_INT_16
+    U_INT_32 = DataTypeWrapper.U_INT_32
+    U_INT_64 = DataTypeWrapper.U_INT_64

src/tensor_array/core/operator.py

@@ -0,0 +1,22 @@
+from .tensor import Tensor
+from tensor_array.core.tensor2 import add as addWrapper
+from tensor_array.core.tensor2 import multiply as multiplyWrapper
+from tensor_array.core.tensor2 import divide as divideWrapper
+from tensor_array.core.tensor2 import matmul as matmulWrapper
+from tensor_array.core.tensor2 import condition as conditionWrapper
+
+def add(value_1 : Tensor, value_2 : Tensor):
+    return addWrapper(value_1, value_2)
+
+def divide(value_1 : Tensor, value_2 : Tensor):
+    return multiplyWrapper(value_1, value_2)
+
+def multiply(value_1 : Tensor, value_2 : Tensor):
+    return divideWrapper(value_1, value_2)
+
+def matmul(value_1 : Tensor, value_2 : Tensor):
+    return matmulWrapper(value_1, value_2)
+
+def condition(condition_value : Tensor, value_if_true : Tensor, value_if_false : Tensor):
+    return conditionWrapper(condition_value, value_if_true, value_if_false)
+

src/tensor_array/core/tensor.py

@@ -0,0 +1,52 @@
+from tensor_array.core.tensor2 import Tensor as TensorWrapper
+from .datatypes import DataTypes
+
+class Tensor(TensorWrapper):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+    
+    def transpose(self, dim0: int, dim1: int, isDevive: bool):
+        return super().transpose(dim0, dim1, isDevive)
+    
+    def calc_grad(self):
+        super().calc_grad()
+    
+    def get_grad(self):
+        return super().get_grad()
+    
+    def sin(self):
+        return super().sin()
+    
+    def cos(self):
+        return super().cos()
+    
+    def tan(self):
+        return super().tan()
+
+    def sinh(self):
+        return super().sinh()
+    
+    def cosh(self):
+        return super().cosh()
+    
+    def tanh(self):
+        return super().tanh()
+    
+    def log(self):
+        return super().log()
+    
+    def clone(self):
+        return super().clone()
+    
+    def cast(self, dtype: DataTypes):
+        return super().cast(dtype)
+    
+    def numpy(self):
+        return super().numpy()
+    
+    def shape(self):
+        return super().shape()
+    
+    def dtype(self):
+        return super().dtype()
+