Added dot.md (#7837)

* added dot.md

* Enhance documentation for ndarray.dot() method

Updated the dot product method documentation to clarify its behavior for different dimensional arrays and improved the syntax and example sections.

* Update dot.md with return value information

Added return value details for the dot product operation.

* Apply suggestion from @avdhoottt

* Apply suggestion from @avdhoottt

---------

Signed-off-by: Prakhar Sharma <prakharsharma_mc24b06_001@dtu.ac.in>

Author: Ananya44444

content/numpy/concepts/ndarray/terms/byteswap/byteswap.md

@@ -0,0 +1,29 @@
+---
+title: byteswap()
+description: "Converts the endianness of an array's data items, optionally in place."
+keywords: 
+  - numpy
+  - ndarray
+  - byteswap
+  - endianness
+  - byte order
+type: "function"
+---
+
+## Description
+
+The **`.byteswap()`** method reverses the byte order (or **endianness**) of the array’s data elements. This process essentially swaps the position of bytes within each multi-byte data item (like integers, floats, or complex numbers).
+
+This feature is primarily used when data must be moved between computer systems that use different byte ordering conventions: 
+
+* **Little-Endian (LE):** Stores the least significant byte first (e.g., Intel/AMD).
+* **Big-Endian (BE):** Stores the most significant byte first (e.g., older network protocols).
+
+The operation is performed **in place** if the `inplace` parameter is set to `True`, modifying the original array.
+
+---
+
+## Syntax
+
+```python
+ndarray.byteswap(inplace=False)

content/numpy/concepts/ndarray/terms/dot/dot.md

@@ -0,0 +1,101 @@
+---
+Title: '.dot()'
+Description: 'Computes the dot product of two arrays.'
+Subjects:
+  - 'Code Foundations'
+  - 'Computer Science'
+Tags:
+  - 'Arrays'
+  - 'Linear Algebra'
+  - 'Methods'
+  - 'NumPy'
+CatalogContent:
+  - 'learn-python-3'
+  - 'paths/computer-science'
+---
+
+The **`.dot()`** method computes the dot product of an array with another array or scalar. For one-dimensional arrays, it calculates the standard inner product of vectors. When applied to two-dimensional arrays, it performs matrix multiplication. For arrays with higher dimensions, it executes a sum-product over the last axis of the first array and the second-to-last axis of the second array.
+
+## Syntax
+
+```pseudo
+ndarray.dot(b, out=None)
+```
+
+**Parameters:**
+
+- `ndarray`: The first array (A) in the dot product operation (A $\cdot$ B).
+- `b`: The second array (B) or scalar in the dot product operation.
+- `out` (optional): An alternative output array to place the result in. It must have the same shape and buffer length as the expected output, but the type will be cast if necessary.
+
+**Return value:**
+
+Returns the dot product as a scalar, 2-D array, or ndarray, depending on the input dimensions.
+
+## Example
+
+This example shows how to use the `.dot()` method for matrix multiplication between two 2D NumPy arrays, `matrix_a` and `matrix_b`:
+
+```py
+# Import NumPy
+import numpy as np
+
+# Create the first 2x3 matrix
+matrix_a = np.array([[1, 2, 3],
+                     [4, 5, 6]])
+
+# Create the second 3x2 matrix
+matrix_b = np.array([[7, 8],
+                     [9, 10],
+                     [11, 12]])
+
+# Use the '.dot()' method for matrix multiplication (2x3 @ 3x2 = 2x2)
+result_matrix = matrix_a.dot(matrix_b)
+
+print("Matrix A:")
+print(matrix_a)
+print("\nMatrix B:")
+print(matrix_b)
+print("\nResult (A.dot(B)):")
+print(result_matrix)
+```
+
+The output of the above code will be:
+
+```shell
+Matrix A:
+[[1 2 3]
+ [4 5 6]]
+
+Matrix B:
+[[ 7  8]
+ [ 9 10]
+ [11 12]]
+
+Result (A.dot(B)):
+[[ 58  64]
+ [139 154]]
+```
+
+## Codebyte Example
+
+In the following codebyte example, the `.dot()` method is used to calculate the inner product (dot product) of two one-dimensional vectors, `vector_x` and `vector_y`:
+
+```codebyte/python
+import numpy as np
+
+# Create two 1-D arrays (vectors)
+vector_x = np.array([1, 2, 3])
+vector_y = np.array([5, 6, 7])
+
+# Calculate the inner product (dot product)
+dot_product = vector_x.dot(vector_y)
+
+print(f"Vector x: {vector_x}")
+print(f"Vector y: {vector_y}")
+print(f"Dot product (x.dot(y)): {dot_product}")
+```
+
+Calculation breakdown:
+
+$$\vec{x} \cdot \vec{y} = (1 \times 5) + (2 \times 6) + (3 \times 7) = 5 + 12 + 21 = 38$$