Merge pull request #89 from Mojo-Numerics-and-Algorithms-group/experimental

Experimental to main for V0.2

Author: shivasankarka

.gitignore

@@ -2,4 +2,13 @@
 /build
 /dist
 /local
-/.vscode
+/.vscode
+.DS_Store
+*.html
+*.css
+*.py
+mojo
+numojo.mojopkg
+.gitignore
+bench.mojo
+test_ndarray.ipynb

CONTRIBUTING.md

@@ -10,6 +10,8 @@ Please follow the Mojo standard library style guide for all contributions. Consi
 - Write concise, well-documented code.
 - Adhere to formatting conventions for indentation, spacing, and line breaks.
 
+Additionally refer to `style guide.md` for docstring and nameing conventions.
+
 ## Pull Requests
 
 When submitting pull requests:

README.MD

@@ -14,6 +14,8 @@
     <br />
     <!-- when we create docs -->
     <a href="https://github.com/Mojo-Numerics-and-Algorithms-group/NuMojo-Examples-and-Benchmarks/blob/main/docs/README.md"><strong>Explore the docs» </strong></a>
+    <br>
+    <a href="https://discord.com/channels/1149778565756366939/1149778566603620455"><strong>Check out our Discord» </strong></a>
     <br />
     <!-- <br /> -->
     <!-- <a href="">View Demo</a>
@@ -53,8 +55,8 @@
 
 NuMojo intends to capture a wide swath of numerics capability present in the Python packages NumPy, SciPy and Scikit.
 
-NuMojo intends to try and get the most out of the capabilities of Mojo including vectorization, parallelization, and GPU acceleration(once available). Currently, NuMojo extends (most of) the standard library math functions to work on tensor inputs.
-NuMojo intends to try and get the most out of the capabilities of Mojo including vectorization, parallelization, and GPU acceleration(once available). Currently, NuMojo extends (most of) the standard library math functions to work on tensor inputs.
+NuMojo intends to try and get the most out of the capabilities of Mojo including vectorization, parallelization, and GPU acceleration(once available). Currently, NuMojo extends (most of) the standard library math functions to work on array inputs.
+NuMojo intends to try and get the most out of the capabilities of Mojo including vectorization, parallelization, and GPU acceleration(once available). Currently, NuMojo extends (most of) the standard library math functions to work on array inputs.
 
 NuMojo intends to be a building block for other Mojo packages that need fast math under the hood without the added weight of a ML back and forward propagation system
 

Roadmap.md

@@ -6,16 +6,16 @@ With that in mind NuMojo as a project is in an early stage of development. If yo
 
 ## TASKS
 
-* Implement tensor version all SIMDable standard library math functions (mostly done waiting on std lib [issue 2492](https://github.com/modularml/mojo/issues/2492))
+* Implement array version all SIMDable standard library math functions (mostly done waiting on std lib [issue 2492](https://github.com/modularml/mojo/issues/2492))
 * Build statistics functions
 * Build optimizers (newton raphson, bisection,etc)
 * Build function approximators
 
 ## N-dimensional Arrays
 
-Now that Modular has decided to no longer support Tensor and to open source and deprecate it NuMojo intends to take Tensor and Make it our own Once they do.
+Now that Modular has decided to no longer support array and to open source and deprecate it NuMojo intends to take array and Make it our own Once they do.
 
-Which means that we will be trying to add many of the features from numpy.array that tensor currently lacks, while not sacrificing performance.
+Which means that we will be trying to add many of the features from numpy.array that array currently lacks, while not sacrificing performance.
 
 ## Notional organization of functions and features
 

numojo/__init__.mojo

@@ -1,14 +1,12 @@
 """
-# ===----------------------------------------------------------------------=== #
-A Mathematics and Algorithm Library for Mojo.
-# ===----------------------------------------------------------------------=== #
+An Array Mathematics library for Mojo.
 """
 
 from .core import *
 from .math import *
 from .math.statistics import stats
 
-# from  .comparison import *
-# from .tensor_func_bit_ops import * #Doesn't work yet due to type issues
-# from .constants import Constants
-# var pi: Float64 = 3.14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555954930381966446229489
+# Constants
+alias pi = core.constants.Constants.pi
+alias e = core.constants.Constants.e
+alias c = core.constants.Constants.c

numojo/core/_array_funcs.mojo

@@ -7,24 +7,24 @@ Implementing backend for array keeping it simple for now
 """
 
 
-fn _math_func_1_array_in_one_array_out[
+fn math_func_1_array_in_one_array_out[
     dtype: DType,
     func: fn[type: DType, simd_w: Int] (SIMD[type, simd_w]) -> SIMD[
         type, simd_w
     ],
 ](array: NDArray[dtype]) raises -> NDArray[dtype]:
     """
-    Apply a SIMD function of one variable and one return to a NDArray
+    Apply a SIMD compatible function to a NDArray and returns a new NDArray.
 
     Parameters:
-        dtype: The element type.
-        func: the SIMD function to to apply.
+        dtype: The NDArray element type.
+        func: The SIMD compatible function to act on the NDArray.
 
     Args:
-        array: A NDArray
+        array: A NDArray.
 
     Returns:
-        A a new NDArray that is NDArray with the function func applied.
+        A new NDArray that is the result of applying the function to the NDArray.
     """
     var result_array: NDArray[dtype] = NDArray[dtype](array.shape())
     alias opt_nelts = simdwidthof[dtype]()
@@ -41,28 +41,28 @@ fn _math_func_1_array_in_one_array_out[
     return result_array
 
 
-fn _math_func_2_array_in_one_array_out[
+fn math_func_2_array_in_one_array_out[
     dtype: DType,
     func: fn[type: DType, simd_w: Int] (
         SIMD[type, simd_w], SIMD[type, simd_w]
     ) -> SIMD[type, simd_w],
 ](array1: NDArray[dtype], array2: NDArray[dtype]) raises -> NDArray[dtype]:
     """
-    Apply a SIMD function of two variable and one return to a NDArray
+    Apply a SIMD compatible function to two NDArrays and returns a new NDArray.
 
-    Constraints:
-        Both arrays must have the same shape
+    Raises:
+        Error if the two arrays do not have the same shape.
 
     Parameters:
-        dtype: The element type.
-        func: the SIMD function to to apply.
+        dtype: The NDArray element type.
+        func: The SIMD compatible function to act on the NDArrays.
 
     Args:
-        array1: A NDArray
-        array2: A NDArray
+        array1: A NDArray.
+        array2: A NDArray.
 
     Returns:
-        A a new NDArray that is NDArray with the function func applied.
+        A new NDArray that is the result of applying the function to the input NDArrays.
     """
 
     if array1.shape() != array2.shape():
@@ -83,28 +83,25 @@ fn _math_func_2_array_in_one_array_out[
     return result_array
 
 
-fn _math_func_one_array_one_SIMD_in_one_array_out[
+fn math_func_one_array_one_SIMD_in_one_array_out[
     dtype: DType,
     func: fn[type: DType, simd_w: Int] (
         SIMD[type, simd_w], SIMD[type, simd_w]
     ) -> SIMD[type, simd_w],
 ](array: NDArray[dtype], scalar: SIMD[dtype, 1]) raises -> NDArray[dtype]:
     """
-    Apply a SIMD function of two variable and one return to a NDArray
-
-    Constraints:
-        Both arrays must have the same shape
+    Apply a SIMD compatible function to a NDArray and a SIMD value and returns a new NDArray.
 
     Parameters:
-        dtype: The element type.
-        func: the SIMD function to to apply.
+        dtype: The NDArray element type.
+        func: The SIMD compatible function to act on the NDArray and SIMD value.
 
     Args:
-        array: A NDArray
-        scalar: scalar value
+        array: A NDArray.
+        scalar: A scalar value.
 
     Returns:
-        A a new NDArray that is NDArray with the function func applied.
+        A new NDArray that is the result of applying the function to the input NDArray and SIMD value.
     """
 
     var result_array: NDArray[dtype] = NDArray[dtype](array.shape())