Added functions documentation pages.

Author: michaeleg21

docs/conf.py

@@ -24,6 +24,7 @@
     'sphinx.ext.doctest',
     'sphinx.ext.autodoc',
     'sphinx.ext.mathjax',
+    'sphinx_collapse',
 ]
 
 templates_path = ['_templates']
@@ -36,6 +37,6 @@
 
 html_theme = 'sphinxawesome_theme'
 html_static_path = ['_static']
-
+html_permalinks = False
 
 

docs/functions.rst

@@ -1,35 +1,122 @@
 Functions
 =========
 
+Documentation grouped by category:
 
 
-Introduction
-------------
+.. collapse:: Arrayfire Classes
 
-This is the introductory section of File 1.
+    .. list-table::
 
-Modules
--------
+        * - Class 1
+            - Description of Class 1
 
-Here is some content for the first section.
 
-Mod
-~~~
+.. collapse:: Arrayfire Functions
 
-This is a subsection under Section 1.
+    .. list-table::
 
-Mod1
-~~~~
+        * - :doc:`af.array() <functions/array>`
+            - Creates an array from a list or other data structure.
+        * - :doc:`af.zeros() <functions/zeros>`
+            - Creates an array filled with zeros.
+        * - :doc:`af.ones() <functions/ones>`
+            - Creates an array filled with ones.
+        * - :doc:`af.randu() <functions/randu>`
+            - Creates an array with random uniform values.
+        * - :doc:`af.randn() <functions/randn>`
+            - Creates an array with random normal values.
+        * - :doc:`af.transpose() <functions/transpose>`
+            - Transposes an array.
+        * - :doc:`af.reshape() <functions/reshape>`
+            - Reshapes an array.
+        * - :doc:`af.reorder() <functions/reorder>`
+            - Reorders dimensions of an array.
+        * - :doc:`af.slice() <functions/slice>`
+            - Extracts a slice of an array.
+        * - :doc:`af.join() <functions/join>`
+            - Joins arrays along a specified dimension.
+        * - :doc:`af.add() <functions/add>`
+            - Performs element-wise addition.
+        * - :doc:`af.subtract() <functions/subtract>`
+            - Performs element-wise subtraction.
+        * - :doc:`af.multiply() <functions/multiply>`
+            - Performs element-wise multiplication.
+        * - :doc:`af.divide() <functions/divide>`
+            - Performs element-wise division.
+        * - :doc:`af.dot() <functions/dot>`
+            - Computes the dot product of two arrays.
+        * - :doc:`af.exp() <functions/exp>`
+            - Computes the exponential of each element.
+        * - :doc:`af.log() <functions/log>`
+            - Computes the natural logarithm of each element.
+        * - :doc:`af.sqrt() <functions/sqrt>`
+            - Computes the square root of each element.
+        * - :doc:`af.matmul() <functions/matmul>`
+            - Matrix multiplication.
+        * - :doc:`af.inv() <functions/inv>`
+            - Computes the inverse of a matrix.
+        * - :doc:`af.det() <functions/det>`
+            - Computes the determinant of a matrix.
+        * - :doc:`af.eig() <functions/eig>`
+            - Computes eigenvalues and eigenvectors.
+        * - :doc:`af.fft() <functions/fft>`
+            - Computes the Fast Fourier Transform.
+        * - :doc:`af.ifft() <functions/ifft>`
+            - Computes the Inverse Fast Fourier Transform.
+        * - :doc:`af.mean() <functions/mean>`
+            - Computes the mean of elements.
+        * - :doc:`af.stdev() <functions/sttdev>`
+            - Computes the standard deviation.
+        * - :doc:`af.median() <functions/median>`
+            - Computes the median value.
+        * - :doc:`af.sum() <functions/sum>`
+            - Computes the sum of elements.
+        * - :doc:`af.prod() <functions/prod>`
+            - Computes the product of elements.
+        * - :doc:`af.device() <functions/device>`
+            - Returns the device identifier.
+        * - :doc:`af.get_device() <functions/get_device>`
+            - Matrix multiplication.
+        * - :doc:`af.set_device() <functions/set_device>`
+            - Gets the current device.
+        * - :doc:`af.get() <functions/get>`
+            - Copies data from the GPU to the CPU.
+        * - :doc:`af.min() <functions/min>`
+            - Finds the minimum value.
+        * - :doc:`af.max() <functions/max>`
+            - Finds the maximum value.
 
-More content for the second section.
 
-Mod2
-~~~~
+.. collapse:: Arrayfire Functions by Category
 
-This concludes the content of File 1.
+    .. list-table::
 
-Mod3
-~~~~
+            * - **Array Creation**
+                - Functions in this category are used to initialize arrays with specific values or patterns.
+            * - **Array Manipulation**
+                - These functions help modify the structure or arrangement of arrays.
+            * - **Mathematical Operations**
+                - Functions for performing fundamental arithmetic and mathematical operations on arrays.
+            * - **Linear Algebra**
+                - Functions for performing linear algebra operations, essential in many scientific and engineering tasks.
+            * - **Fourier Transforms**
+                - Functions for performing Fourier analysis, essential for signal processing and frequency analysis.
+            * - **Statistics**
+                - Functions for computing statistical metrics and analyzing data distributions.
+            * - **Data Reduction**
+                - Functions for aggregating and reducing data to summarize or condense information.
+            * - **Utilities**
+                - General-purpose functions for managing arrays and devices.
+            * - **Special Functions**
+                - Functions for creating and applying specific types of filters, commonly used in signal processing and analysis.
 
-Mod4
-~~~~
+
+.. collapse:: Graphics
+
+    .. list-table::
+
+            * - **Rendering Function**
+                - Rendering Function to draw images, plots etc
+            * - **Window Function**
+                - Window Creation, modification and destruction of functions

docs/functions/add.rst

@@ -0,0 +1,30 @@
+add
+===
+The 'af.add()' function in ArrayFire is used to perform element-wise addition between arrays. This function enables you to add corresponding elements of two arrays or an array and a scalar, resulting in a new array where each element is the sum of the respective elements from the input arrays or the scalar.
+
+
+Function
+--------
+:literal:`af.add()`
+    - Python interface used to perform element-wise addition.
+
+Detailed Description
+--------------------
+The 'af.add()' function computes the sum of two arrays or an array and a scalar, element by element. When adding two arrays, both must have the same dimensions, or be broadcastable to a common shape. For array-scalar addition, the scalar value is added to each element of the array. This function is particularly useful for operations requiring element-wise arithmetic.
+
+Function Documentation
+----------------------
+.. sidebar:: af.add()
+
+    Syntax:
+        af.add(array1, array2)
+        af.add(array, scalar)
+    
+    Parameters:
+        'array1': The first ArrayFire array in the addition operation.
+        'array2': The second ArrayFire array with the same dimensions as 'array1', or compatible for broadcasting.
+        'array': An ArrayFire array to which the scalar is added.
+        'scalar': A scalar value to be added to each element of 'array'.
+        
+    Returns:
+        An ArrayFire array containing the element-wise sum of the inputs.

docs/functions/array.rst

@@ -0,0 +1,30 @@
+array
+=====
+The 'af.array()' function is part of the ArrayFire library, which provides a powerful framework for performing high-performance numerical computations. This function is designed to create an ArrayFire array from various data structures, such as Python lists or other iterable collections.
+
+Function
+--------
+:literal:`af.array()`
+    - Python interface to form an array.
+
+
+Detailed Description
+--------------------
+The 'af.array()' function allows you to convert a data structure, such as a Python list or tuple, into an ArrayFire array. This conversion is essential for leveraging ArrayFire's optimized computational capabilities. By creating an array from a list or another iterable, you can perform efficient mathematical operations, matrix manipulations, and other numerical computations using ArrayFire's APIs.
+
+The function supports multiple data types and can handle multi-dimensional arrays. The ability to create an ArrayFire array from native Python structures makes it easier to integrate ArrayFire into Python-based workflows.
+
+Function Documentation
+----------------------
+.. sidebar:: af.array()
+
+    Syntax:
+        af.array(data)
+    
+    Parameters:
+        'data': A list, tuple, or another iterable containing the elements to be converted into an ArrayFire array. The data should be in a format that ArrayFire can interpret, such as nested lists for multi-dimensional arrays.
+
+    Returns:
+        An ArrayFire array containing the elements from the input data structure.
+
+

docs/functions/det.rst

@@ -0,0 +1,25 @@
+det
+===
+The 'af.det()' function in ArrayFire computes the determinant of a square matrix. The determinant is a scalar value that provides important properties of the matrix, such as whether it is invertible. It is a fundamental operation in linear algebra with applications in areas such as system of equations, matrix inversion, and eigenvalue problems.
+
+Function
+--------
+:literal:`af.det()`
+    - Python interface to find determinant of a square matrix.
+
+Detailed Description
+--------------------
+The 'af.det()' function calculates the determinant of a square matrix. The matrix must be square, meaning the number of rows must be equal to the number of columns. The determinant of a matrix is a scalar that can provide information about the matrix, such as its invertibility. If the determinant is zero, the matrix is singular (non-invertible); if it is non-zero, the matrix is invertible.
+
+Function Documentation
+----------------------
+.. sidebar:: af.det()
+
+    Syntax:
+        af.det(matrix)
+    
+    Parameters:
+        'matrix': A 2D ArrayFire array (matrix) whose determinant is to be calculated. The matrix must be square, i.e., the number of rows must be equal to the number of columns.
+
+    Returns:
+        A scalar value representing the determinant of the input matrix. The type of the result will be the same as the input matrix data type.

docs/functions/device.rst

@@ -0,0 +1,42 @@
+device
+======
+The 'af.device()' function in the ArrayFire library is used to get or set the current device or device properties. This function provides an interface to interact with the GPU or CPU device being used for computations. It allows you to select a particular device from available options or query the properties of the current device.
+
+Function
+--------
+:literal:`af.device()`
+    - Python interface to get or set device properties.
+
+Detailed Description
+--------------------
+The 'af.device()' function is useful for managing and querying the device that ArrayFire is using for computations. This function can perform various tasks related to device management, such as:
+
+- Getting the Current Device: Retrieve the index of the currently selected device.
+- Setting the Current Device: Select a specific device for computations.
+- Querying Device Properties: Obtain information about the current device.
+This functionality is important for applications that need to explicitly choose between multiple GPUs or check device capabilities.
+
+Function Documentation
+----------------------
+.. sidebar:: af.device()
+
+    Syntax:
+        af.device(option=None, value=None)
+    
+    Parameters:
+        'option' (optional): Specifies the type of information or action. Can be one of the following:
+
+        - "device": Get the current device index.
+        - "set": Set the current device index.
+        - "count": Get the number of available devices.
+        - "name": Get the name of the current device.
+        - "info": Get detailed information about the current device.
+
+        'value (optional)': The index of the device to set. Used only when the option is "set". If option is "set", this parameter should be an integer representing the device index.
+
+    Returns:
+        Depending on the option, the function returns various types of information:
+        - If 'option' is "device": The index of the current device.
+        - If 'option' is "count": The number of available devices.
+        - If 'option' is "name": The name of the current device.
+        - If 'option' is "info": Detailed information about the current device.

docs/functions/divide.rst

@@ -0,0 +1,36 @@
+divide
+======
+The 'af.divide()' function in the ArrayFire library performs element-wise division of two arrays. This function allows you to divide one array by another, or to divide each element of an array by a scalar value. It supports operations on arrays of the same shape or on a scalar and an array.
+
+Function
+--------
+:literal:`af.divide`
+    - Python interface for dividing one array by another.
+
+Detailed Description
+--------------------
+The af.divide() function is used to perform element-wise division of arrays or between an array and a scalar. This operation divides each element of the first array by the corresponding element of the second array, or divides each element of the array by the scalar value.
+
+**Element-wise Division:** When dividing two arrays, the function performs the division for each corresponding element of the arrays.
+
+**Scalar Division:** When dividing an array by a scalar, the function divides each element of the array by the scalar value.
+
+The function handles broadcasting automatically when the dimensions of the arrays are compatible.
+
+Function Documentation
+----------------------
+.. sidebar:: af.divide
+
+    Syntax:
+        af.divide(array1, array2)
+        af.divide(array, scalar)
+
+    
+    Parameters:
+        - array1: The first ArrayFire array (numerator) in the division operation.
+        - array2: The second ArrayFire array (denominator) in the division operation. Must have the same shape as array1 or be a scalar.
+        - array: The ArrayFire array to be divided by a scalar.
+        - scalar: The scalar value used to divide each element of array.
+
+    Returns:
+        An ArrayFire array containing the results of the element-wise division. The resulting array will have the same shape as the input arrays.

docs/functions/dot.rst

@@ -0,0 +1,31 @@
+dot
+===
+The 'af.dot()' function in ArrayFire computes the dot product of two arrays. This function is used for calculating the scalar product of two vectors or the matrix multiplication when applied to matrices. It is a fundamental operation in linear algebra with applications in various fields such as machine learning, physics, and numerical computing.
+
+Function
+--------
+:literal:`af.dot()`
+    - Python interface to compute dot product of two arrays.
+
+Detailed Description
+--------------------
+The af.dot() function computes the dot product, which can refer to different operations depending on the type of input:
+
+**Dot Product of Two Vectors:** For 1D arrays (vectors), the function calculates the scalar product. This is the sum of the products of corresponding elements of the vectors.
+
+**Matrix Multiplication:** For 2D arrays (matrices), it performs matrix multiplication, which is also referred to as the dot product in this context.
+
+Function Documentation
+----------------------
+.. sidebar:: af.dot()
+
+    Syntax:
+        af.dot(array1, array2)
+    
+    Parameters:
+        'array1': The first ArrayFire array (vector or matrix) in the dot product operation.
+        'array2': The second ArrayFire array (vector or matrix) in the dot product operation. Must be compatible with 'array1' for dot product or matrix multiplication.
+
+    Returns:
+        - For vectors: A scalar value representing the dot product of the vectors.
+        - For matrices: An ArrayFire array representing the result of matrix multiplication.

docs/functions/eig.rst

@@ -0,0 +1,37 @@
+eig
+===
+The 'af.eig()' function in ArrayFire computes the eigenvalues and eigenvectors of a square matrix. This function is essential in linear algebra for analyzing matrices and is used in various applications including machine learning, physics, and numerical analysis.
+
+Function
+--------
+:literal:`af.eig()`
+    - Python interface for computing the eigenvalues and eigenvectors of a square matrix.
+
+Detailed Description
+--------------------
+The 'af.eig()' function computes the eigenvalues and eigenvectors of a square matrix. For a given matrix 
+A, eigenvalues and eigenvectors are defined such that:
+
+𝐴𝑣 = 𝜆𝑣
+
+
+where:
+- λ represents an eigenvalue.
+- v represents the corresponding eigenvector.
+The function returns two arrays:
+- An array containing the eigenvalues of the matrix.
+- An array containing the eigenvectors of the matrix. Each column in this array corresponds to an eigenvector.
+
+Function Documentation
+----------------------
+.. sidebar:: af.eig()
+
+    Syntax:
+        eigenvalues, eigenvectors = af.eig(matrix)
+    
+    Parameters:
+        'matrix': A 2D ArrayFire array (matrix) for which eigenvalues and eigenvectors are to be computed. The matrix must be square (i.e., the number of rows must be equal to the number of columns).
+
+    Returns:
+        - eigenvalues: An ArrayFire array containing the eigenvalues of the input matrix.
+        - eigenvectors: An ArrayFire array containing the eigenvectors of the input matrix. Each column of this array is an eigenvector corresponding to the eigenvalues.