Metadata-Version: 2.1
Name: algebraML
Version: 0.0.5
Summary: This package performs basic algebraic operations
Home-page: https://github.com/cbarros7/ml_engineer_nanodegree
Author: Carlos Barros
Author-email: cj.barros@gmail.com
License: UNKNOWN
Project-URL: Bug Tracker, https://github.com/cbarros7/ml_engineer_nanodegree/issues
Description: ## Basic algebra for Machine Learning
        This package performs basic operations between two matrices that are used in the field of machine learning such as: *addition, subtraction, multiplication and division*. It can also perform single matrix operations such as: *dot product, inverse matrix finding and determinant*.
        
        ### Installation
        Run the following command in your terminal: 
        
        ```
        $ pip install -i https://test.pypi.org/simple/ basic-algebra-ml==0.0.1 
        ```
        
        ### Usage
        
        The package is composed of two classes:
        <h4>1) Basic_Operations</h4> Parent class that has the following methods:
        
        * **check_type_matrix:** checks if the parameters are a matrix of type ```<<numpy.ndarray>>```.
        
        * **addition:** adds two matrices together. For example:
        ```
        # Declare the matrix
        [In]:   from basic_operations import Basic_Operations
        
                # Declare the matrix
                matrix1 = ([1, 6, 5], [6, 14, 34], [21, 12, 4])
                matrix2 = ([3, 2, 54], [21, 12, 9], [1, 6, 5])
              
                # Instantiate the class
                test = Basic_Operations(matrix1, matrix2)
        
        
                print(test.addition())
        
        [Out]:  [[ 4.  8. 59.]
                [27. 26. 43.]
                [22. 18.  9.]]
        
        ```
        
        * **subtraction:** subtraction of two matrices. With the matrices of the previous example, then we have the following result:
        ```
        
        [In]:   print(test.subtraction())
        
        [Out]:  [[ -2.   4. -49.]
                [-15.   2.  25.]
                [ 20.   6.  -1.]]
        
        ```
        
        <br>
        
        * **multiplication:** multiply two matrices.
        
        *Note: Remember that to perform multiplication between matrices the number of rows must match the number of columns.*  
        
        ```
        [In]:   matrix3 = ([8, 56, 7], [6, 14, 34], [9, 63, 5])
                matrix4 = ([36, 1, 2], [94, 9, 12], [3, 66, 1])
        
                test2 = Basic_Operations(matrix3, matrix4)
        
                print(test2.multiplication())
        
        [Out]:  [[ 288.   56.   14.]
                [ 564.  126.  408.]
                [  27. 4158.    5.]]
        
        ```
        Note the following example where the dimensions do not match between more matrices. The program will give a message indicating the error.
        
        ```
        [In]:   matrix3 = ([8, 56, 7], [6, 14, 34], [9, 63, 5])
                matrix4 = ([36, 1, 2], [94, 9, 12])
        
                print(test2.multiplication())
        
        [Out]:  Error: operands could not be broadcast together with shapes (3,3) (2,3)
        
        ```
        
        <br>
        
        * **division:** divide two matrices. See the following example:
        
        
        
        Below are several examples of how you can use this package: 
        
        ```
        [In]:   print(test2.division())
        
        [Out]:  [[ 0.22222222 56.          3.5       ]
                [ 0.06382979  1.55555556  2.83333333]
                [ 3.          0.95454545  5.        ]]
        
        ```
        
        <br>
        
        * **dot:** Dot product of two arrays. See the following example:
        
        ```
        [In]:   matrix5 = ([8, 56, 7], [6, 14, 34], [9, 63, 5])
                matrix6 = ([3, 2, 54], [21, 12, 9], [1, 6, 5])
        
                test3 = Basic_Operations(matrix5, matrix6)
        
                print(test3.dot())
        
        [Out]:  [[1207.  730.  971.]
                [ 346.  384.  620.]
                [1355.  804. 1078.]]
        ```
        
        <h4>2) Operations_One_Matrix: </h4> 
        
        Child class that inherits from **Basic_Operations**.  With this class you can perform the following operations with a matrix: 
        
        * **scalar:** multiply a matrix by a scalar
        
        ```
        [In]:   from matrix_manipulations import Operations_One_Matrix
        
        
                matrix = ([36, 1, 2], [94, 9, 12], [3, 66, 1])
                
                test = Operations_One_Matrix(matrix)
        
                print(test.scalar(2))
        
        
        [Out]:  [[ 72.   2.   4.]
                [188.  18.  24.]
                [  6. 132.   2.]]
        ```
        
        * **shape:** checks the dimensions of a matrix.
        ```
        [In]:   print(test.scalar(2))
        
        
        [Out]:  (3, 3)
        ```
        
        * **inverse:** calculate the inverse of a matrix
        
        
        
        * **transpose:** Invert or permute the axes of a matrix
Platform: UNKNOWN
Classifier: Programming Language :: Python :: 3
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: OS Independent
Requires-Python: >=3.6
Description-Content-Type: text/markdown
