Merge pull request #85 from MadAlex1997/remove-out-dtype

Removing out_dtype, and minor doc fixes

Author: shivasankarka

new_tests/test_sort.mojo

@@ -0,0 +1,26 @@
+import numojo as nm
+from time import now
+from python import Python, PythonObject
+from utils_for_test import check, check_is_close
+
+def test_sort_1d():
+    arr = nm.NDArray(25,random=True)
+    var np = Python.import_module("numpy")
+    arr_sorted = arr.sort()
+    np_arr_sorted  = np.sort(arr.to_numpy())
+    return check(arr_sorted,np_arr_sorted, "quick sort is broken")
+
+# ND sorting currently works differently than numpy which has an on axis
+
+# def test_sort_2d():
+#     arr = nm.NDArray(5,5,random=True)
+#     var np = Python.import_module("numpy")
+#     arr_sorted = arr.sort()
+#     print(arr_sorted)
+#     np_arr_sorted  = np.sort(arr.to_numpy())
+#     print(np_arr_sorted)
+#     return check(arr_sorted,np_arr_sorted, "quick sort is broken")
+
+# def main():
+#     test_sort_1d()
+#     # test_sort_2d()

numojo/core/array_creation_routines.mojo

@@ -63,7 +63,7 @@ fn arange[
     )
     for idx in range(num):
         result.data[idx] = (
-            start.cast[dtype]() + step.cast[dtype]() * idx
+            start + step * idx
         )
 
     return result
@@ -113,11 +113,11 @@ fn linspace[
     constrained[not dtype.is_integral()]()
     if parallel:
         return _linspace_parallel[dtype](
-            start.cast[dtype](), stop.cast[dtype](), num, endpoint
+            start, stop, num, endpoint
         )
     else:
         return _linspace_serial[dtype](
-            start.cast[dtype](), stop.cast[dtype](), num, endpoint
+            start, stop, num, endpoint
         )
 
 
@@ -245,18 +245,18 @@ fn logspace[
     #     )
     if parallel:
         return _logspace_parallel[dtype](
-            start.cast[dtype](),
-            stop.cast[dtype](),
+            start,
+            stop,
             num,
-            base.cast[dtype](),
+            base,
             endpoint,
         )
     else:
         return _logspace_serial[dtype](
-            start.cast[dtype](),
-            stop.cast[dtype](),
+            start,
+            stop,
             num,
-            base.cast[dtype](),
+            base,
             endpoint,
         )
 
@@ -382,22 +382,22 @@ fn geomspace[
     #         "Both input and output datatypes cannot be integers. If the input is a float, the output must also be a float."
     #     )
 
-    var a: Scalar[dtype] = start.cast[dtype]()
+    var a: Scalar[dtype] = start
 
     if endpoint:
         var result: NDArray[dtype] = NDArray[dtype](NDArrayShape(num))
         var r: Scalar[dtype] = (
-            stop.cast[dtype]() / start.cast[dtype]()
-        ) ** (1 / (num - 1)).cast[dtype]()
+            stop / start
+        ) ** (1 / (num - 1))
         for i in range(num):
             result.data[i] = a * r**i
         return result
 
     else:
         var result: NDArray[dtype] = NDArray[dtype](NDArrayShape(num))
         var r: Scalar[dtype] = (
-            stop.cast[dtype]() / start.cast[dtype]()
-        ) ** (1 / (num)).cast[dtype]()
+            stop / start
+        ) ** (1 / (num))
         for i in range(num):
             result.data[i] = a * r**i
         return result
@@ -537,7 +537,7 @@ fn full[
     Returns:
         A NDArray of `dtype` with given `shape`.
     """
-    var tens_value: SIMD[dtype, 1] = SIMD[dtype, 1](fill_value).cast[dtype]()
+    var tens_value: SIMD[dtype, 1] = SIMD[dtype, 1](fill_value)
     return NDArray[dtype](shape, fill=tens_value)
 
 

numojo/core/datatypes.mojo

@@ -31,46 +31,3 @@ alias f32 = DType.float32
 """Data type alias for DType.float32"""
 alias f64 = DType.float64
 """Data type alias for DType.float64"""
-
-
-fn cvtdtype[
-    in_dtype: DType, out_dtype: DType, width: Int = 1
-](value: SIMD[in_dtype, width]) -> SIMD[out_dtype, width]:
-    """
-    Converts datatype of a value from in_dtype to out_dtype at run time.
-
-    Parameters:
-        in_dtype: The input datatype.
-        out_dtype: The output dataytpe.
-        width: The width of the SIMD vector.
-
-    Args:
-        value: The SIMD value to be converted.
-
-    Returns:
-        The `value` with its dtype cast as out_dtype.
-
-    """
-    return value.cast[out_dtype]()
-
-
-fn cvtdtype[
-    in_dtype: DType,
-    out_dtype: DType,
-    width: Int = 1,
-    value: SIMD[in_dtype, width] = SIMD[in_dtype](),
-]() -> SIMD[out_dtype, width]:
-    """
-    Converts datatype of a value from in_dtype to out_dtype at compile time.
-
-    Parameters:
-        in_dtype: The input datatype.
-        out_dtype: The output dataytpe.
-        width: The width of the SIMD vector.
-        value: The SIMD value to be converted.
-
-    Returns:
-        The `value` with its dtype cast as out_dtype.
-
-    """
-    return value.cast[out_dtype]()

numojo/core/sort.mojo

@@ -164,8 +164,8 @@ fn quick_sort[
 
 
 fn binary_sort[
-    in_dtype: DType, out_dtype: DType = DType.float64
-](array: NDArray[in_dtype]) raises -> NDArray[out_dtype]:
+     dtype: DType = DType.float64
+](array: NDArray[ dtype]) raises -> NDArray[dtype]:
     """
     Binary sorting of NDArray.
 
@@ -177,24 +177,27 @@ fn binary_sort[
         ```
 
     Parameters:
-        in_dtype: The input element type.
-        out_dtype: The output element type.
+         dtype: The element type.
 
     Args:
         array: A NDArray.
 
     Returns:
-        The sorted NDArray of type `out_dtype`.
+        The sorted NDArray of type `dtype`.
     """
-    var result: NDArray[out_dtype] = NDArray[out_dtype](array.shape())
+    @parameter
+    if dtype != array.dtype:
+        alias dtype = array.dtype
+
+    var result: NDArray[dtype] = NDArray[dtype](array.shape())
     for i in range(array.ndshape.ndsize):
-        result.store(i, array.get_scalar(i).cast[out_dtype]())
+        result.store(i, array.get_scalar(i).cast[dtype]())
 
     var n = array.num_elements()
     for end in range(n, 1, -1):
         for i in range(1, end):
             if result[i - 1] > result[i]:
-                var temp: Scalar[out_dtype] = result.get_scalar(i - 1)
+                var temp: Scalar[dtype] = result.get_scalar(i - 1)
                 result[i - 1] = result[i]
                 result.store(i, temp)
     return result

numojo/math/arithmetic.mojo

@@ -198,14 +198,13 @@ fn sub[
 
 
 fn diff[
-    in_dtype: DType, out_dtype: DType = in_dtype
-](array: NDArray[in_dtype], n: Int) raises -> NDArray[out_dtype]:
+     dtype: DType =  DType.float64
+](array: NDArray[ dtype], n: Int) raises -> NDArray[dtype]:
     """
     Compute the n-th order difference of the input array.
 
     Parameters:
-        in_dtype: Input data type.
-        out_dtype: Output data type, defaults to float32.
+        dtype: The element type.
 
     Args:
         array: A array.
@@ -215,19 +214,19 @@ fn diff[
         The n-th order difference of the input array.
     """
 
-    var array1: NDArray[out_dtype] = NDArray[out_dtype](
+    var array1: NDArray[dtype] = NDArray[dtype](
         NDArrayShape(array.num_elements())
     )
     for i in range(array.num_elements()):
-        array1.store(i, array.get_scalar(i).cast[out_dtype]())
+        array1.store(i, array.get_scalar(i))
 
     for num in range(n):
-        var result: NDArray[out_dtype] = NDArray[out_dtype](
+        var result: NDArray[dtype] = NDArray[dtype](
             NDArrayShape(array.num_elements() - (num + 1))
         )
         for i in range(array1.num_elements() - 1):
             result.store(
-                i, (array1.load[1](i + 1) - array1.load[1](i)).cast[out_dtype]()
+                i, (array1.load[1](i + 1) - array1.load[1](i))
             )
         array1 = result
     return array1

numojo/math/calculus/differentiation.mojo

@@ -34,25 +34,16 @@ fn gradient[
     Returns:
         The integral of y over x using the trapezoidal rule.
     """
-    # var result: NDArray[dtype] = NDArray[dtype](x.shape(), random=False)
-    # var space: NDArray[dtype] =  NDArray[dtype](x.shape(), random=False)
-    # if spacing.isa[NDArray[dtype]]():
-    #     for i in range(x.num_elements()):
-    #         space[i] = spacing._get_ptr[NDArray[dtype]]()[][i].cast[dtype]()
-
-    # elif spacing.isa[Scalar[dtype]]():
-    #     var int: Scalar[dtype] = spacing._get_ptr[Scalar[dtype]]()[]
-    #     space = numojo.arange[dtype, dtype](1, x.num_elements(), step=int)
-
+    
     var result: NDArray[dtype] = NDArray[dtype](x.shape(), random=False)
     var space: NDArray[dtype] = core.arange[dtype](
-        1, x.num_elements() + 1, step=spacing.cast[dtype]()
+        1, x.num_elements() + 1, step=spacing
     )
     var hu: Scalar[dtype] = space.get_scalar(1)
     var hd: Scalar[dtype] = space.get_scalar(0)
     result.store(
         0,
-        (x.get_scalar(1).cast[dtype]() - x.get_scalar(0).cast[dtype]())
+        (x.get_scalar(1) - x.get_scalar(0))
         / (hu - hd),
     )
 
@@ -61,8 +52,8 @@ fn gradient[
     result.store(
         x.num_elements() - 1,
         (
-            x.get_scalar(x.num_elements() - 1).cast[dtype]()
-            - x.get_scalar(x.num_elements() - 2).cast[dtype]()
+            x.get_scalar(x.num_elements() - 1)
+            - x.get_scalar(x.num_elements() - 2)
         )
         / (hu - hd),
     )
@@ -75,9 +66,9 @@ fn gradient[
             i - 1
         )
         var fi: Scalar[dtype] = (
-            hd**2 * x.get_scalar(i + 1).cast[dtype]()
-            + (hu**2 - hd**2) * x.get_scalar(i).cast[dtype]()
-            - hu**2 * x.get_scalar(i - 1).cast[dtype]()
+            hd**2 * x.get_scalar(i + 1)
+            + (hu**2 - hd**2) * x.get_scalar(i)
+            - hu**2 * x.get_scalar(i - 1)
         ) / (hu * hd * (hu + hd))
         result.store(i, fi)
 

numojo/math/calculus/integral.mojo

@@ -13,14 +13,13 @@ from algorithm import Static2DTileUnitFunc as Tile2DFunc
 
 # naive loop implementation, optimize later
 fn trapz[
-    in_dtype: DType, out_dtype: DType = DType.float32
-](y: NDArray[in_dtype], x: NDArray[in_dtype]) raises -> SIMD[out_dtype, 1]:
+     dtype: DType = DType.float64
+](y: NDArray[ dtype], x: NDArray[ dtype]) raises -> SIMD[dtype, 1]:
     """
     Compute the integral of y over x using the trapezoidal rule.
 
     Parameters:
-        in_dtype: Input data type.
-        out_dtype: Output data type, defaults to float32.
+        dtype: The element type.
 
     Args:
         y: An array.
@@ -37,16 +36,16 @@ fn trapz[
         raise Error("x and y must have the same shape")
 
     # move this check to compile time using constrained?
-    if is_inttype[in_dtype]() and not is_floattype[out_dtype]():
+    if is_inttype[ dtype]() and not is_floattype[dtype]():
         raise Error(
             "output dtype `Fdtype` must be a floating-point type if input dtype"
             " `Idtype` is not a floating-point type"
         )
 
-    var integral: SIMD[out_dtype] = 0.0
+    var integral: SIMD[dtype] = 0.0
     for i in range(x.num_elements() - 1):
-        var temp = (x.get_scalar(i + 1) - x.get_scalar(i)).cast[out_dtype]() * (
+        var temp = (x.get_scalar(i + 1) - x.get_scalar(i)) * (
             y.get_scalar(i) + y.get_scalar(i + 1)
-        ).cast[out_dtype]() / 2.0
+        ) / 2.0
         integral += temp
     return integral

numojo/math/linalg/linalg.mojo

@@ -15,16 +15,15 @@ from algorithm import Static2DTileUnitFunc as Tile2DFunc
 
 
 fn cross[
-    in_dtype: DType, out_dtype: DType = DType.float32
-](array1: NDArray[in_dtype], array2: NDArray[in_dtype]) raises -> NDArray[
-    out_dtype
+     dtype: DType = DType.float64
+](array1: NDArray[ dtype], array2: NDArray[ dtype]) raises -> NDArray[
+    dtype
 ]:
     """
     Compute the cross product of two arrays.
 
     Parameters
-        in_dtype: Input data type.
-        out_dtype: Output data type, defaults to float32.
+        dtype: The element type.
 
     Args:
         array1: A array.
@@ -38,27 +37,27 @@ fn cross[
     """
 
     if array1.ndshape.ndlen == array2.ndshape.ndlen == 3:
-        var array3: NDArray[out_dtype] = NDArray[out_dtype](NDArrayShape(3))
+        var array3: NDArray[dtype] = NDArray[dtype](NDArrayShape(3))
         array3.store(
             0,
             (
                 array1.get_scalar(1) * array2.get_scalar(2)
                 - array1.get_scalar(2) * array2.get_scalar(1)
-            ).cast[out_dtype](),
+            ),
         )
         array3.store(
             1,
             (
                 array1.get_scalar(2) * array2.get_scalar(0)
                 - array1.get_scalar(0) * array2.get_scalar(2)
-            ).cast[out_dtype](),
+            ),
         )
         array3.store(
             2,
             (
                 array1.get_scalar(0) * array2.get_scalar(1)
                 - array1.get_scalar(1) * array2.get_scalar(0)
-            ).cast[out_dtype](),
+            ),
         )
         return array3
     else: