[Edit] Python: NumPy - .sqrt() (#6502)

* [Edit] Python: NumPy - .sqrt()

* Update sqrt.md

---------

Author: mamtawardhani

content/numpy/concepts/math-methods/terms/sqrt/sqrt.md

@@ -1,61 +1,160 @@
 ---
 Title: '.sqrt()'
-Description: 'Calculates the square root of each element in an array.'
+Description: 'Computes the positive square root of all elements in the input array.'
 Subjects:
   - 'Computer Science'
   - 'Data Science'
 Tags:
   - 'Arrays'
   - 'Functions'
+  - 'Math'
   - 'NumPy'
 CatalogContent:
   - 'learn-python-3'
-  - 'paths/computer-science'
+  - 'paths/data-science'
 ---
 
-In NumPy, the **`.sqrt()`** method is used to calculate the positive square root of a number or the elements of an array. It is commonly employed in mathematical computations such as solving quadratic equations, applying the Pythagorean Theorem, modelling normal distributions, and more.
+The **`.sqrt()`** function computes the positive square root of all elements in the input array. As a [universal function (ufunc)](https://www.codecademy.com/article/what-are-ufuncs-in-numpy), it operates element-wise and returns an array of the same shape with square root values.
+
+Widely used in fields like statistics, physics, engineering, and machine learning, `.sqrt()` is a powerful tool for performing efficient mathematical operations on numerical arrays of various shapes and data types.
 
 ## Syntax
 
 ```pseudo
-numpy.sqrt(array, out=None, where=True)
+numpy.sqrt(x, out=None, where=True, casting='same_kind', order='K', dtype=None)
 ```
 
-- `array`: A number or array-like structure containing the elements to which the method is to be applied.
-- `out` (Optional): The array where the result is to be stored. If not provided, a new array is created and used for storing the results.
-- `where` (Optional): The condition (array of boolean values) that determines the elements on which the method is to be applied.
-  - If the condition is `True` for a particular element, the square root is computed for that element.
-  - If the condition is `False` for a particular element, the square root is not computed for that element and the original element is retained.
-  - If not provided, the square root is computed for all elements.
+**Parameters:**
+
+- `x`: The input array or scalar value for which to compute the square root.
+- `out` (Optional): The output array where the result will be stored. Must have the same shape as input if provided.
+- `where` (Optional): Boolean array or condition indicating where to calculate the sqrt. By default, it computes the sqrt for all elements (True).
+- `casting` (Optional): Controls what kind of data casting may occur during computation.
+- `order` (Optional): Memory layout of the output array.
+- `dtype` (Optional): Data type of the output array.
+
+**Return value:**
+
+The function returns an array of the same shape as `x`, containing the positive square root of each element in the input array.
 
-## Example
+## Example 1: Basic Square Root Calculation
 
-The below example shows the `.sqrt()` method in use:
+This example demonstrates how to use NumPy's `.sqrt()` function to calculate the square root of each element in a 1D array:
 
 ```py
-# Importing the 'numpy' library as 'np'
 import numpy as np
 
-# Computing the square root of only those elements in the array which is greater than or equal to 5
-result = np.sqrt([9,-4,25], where=np.array([9,-4,25]) >= 5)
+# Create a 1D array
+array1 = np.array([4, 9, 16, 25])
 
-print(result)
+# Calculate square root of each element
+result = np.sqrt(array1)
+
+# Display the result
+print("Original array:", array1)
+print("Square root result:", result)
 ```
 
-The output of the above code is shown below:
+The output generated by this code is:
 
 ```shell
-[3.00000000e+000 6.50227506e-310 5.00000000e+000]
+Original array: [ 4  9 16 25]
+Square root result: [2. 3. 4. 5.]
 ```
 
-## Codebyte Example
+The `.sqrt()` function processes each element independently, computing the square root and returning a new array with the results. Note that the output array contains floating-point numbers even if the input contains integers.
 
-In this codebyte example, the `.sqrt()` method only computes the square root of the elements of the array which are greater than 0:
+## Example 2: Computing Standard Deviation with `.sqrt()`
 
-```codebyte/python
+This example shows how to use the `.sqrt()` function in statistical calculations, specifically to compute the [standard deviation](https://www.codecademy.com/resources/docs/numpy/built-in-functions/std) of a dataset:
+
+```py
 import numpy as np
 
-result = np.sqrt([144,-10,16], where=np.array([144,-10,16]) >= 0)
+# Sample data points
+data = np.array([2, 4, 6, 8])
 
-print(result)
+# Calculate the mean
+mean = np.mean(data)
+
+# Calculate deviations from the mean
+deviations = data - mean
+
+# Square the deviations
+squared_dev = deviations ** 2
+
+# Calculate the variance (mean of squared deviations)
+variance = np.mean(squared_dev)
+
+# Compute standard deviation using sqrt()
+std_deviation = np.sqrt(variance)
+
+print("Dataset:", data)
+print("Mean:", mean)
+print("Variance:", variance)
+print("Standard Deviation:", std_deviation)
+
+# Compare with NumPy's built-in function
+print("NumPy's std function result:", np.std(data))
 ```
+
+The output of this code is:
+
+```shell
+Dataset: [2 4 6 8]
+Mean: 5.0
+Variance: 5.0
+Standard Deviation: 2.236067977499790
+NumPy's std function result: 2.236067977499790
+```
+
+This example demonstrates how the `.sqrt()` function is used in computing standard deviation, a common statistical measure that indicates how spread out values are from the mean.
+
+## Codebyte Example: Working with Complex and Negative Numbers
+
+This code demonstrates how NumPy's `.sqrt()` function operates on 2D arrays, negative values, and with conditional application using the `where` parameter:
+
+```codebyte/python
+import numpy as np
+
+# Create a 2D array
+array2d = np.array([[1, 4, 9], [16, 25, 36]])
+print("Original 2D array:")
+print(array2d)
+
+# Calculate square root of each element in the 2D array
+result2d = np.sqrt(array2d)
+print("\nSquare root of 2D array:")
+print(result2d)
+
+# Handle negative values
+neg_array = np.array([-1, -4, -9])
+complex_result = np.sqrt(neg_array)
+print("\nSquare root of negative values:")
+print(complex_result)
+
+# Use where parameter to calculate sqrt only for values >= 0
+mixed_array = np.array([-4, 0, 4, 9, -16])
+filtered_result = np.sqrt(mixed_array, where=mixed_array >= 0)
+print("\nSelective square root calculation:")
+print(filtered_result)
+```
+
+The example shows that `.sqrt()` works element-wise on 2D arrays, maintaining their shape. For negative numbers, it returns `nan` along with a warning, unless complex handling is specified. The `where` parameter allows selective square root computation based on a condition, such as non-negative values.
+
+## FAQs
+
+<details>
+<summary>1. What happens when I apply `.sqrt()` to negative numbers?</summary>  
+<p>By default, NumPy's `.sqrt()` returns `nan` and raises a warning when applied to negative numbers in real-valued arrays. To compute square roots of negative numbers, convert the input to a complex data type.</p>
+</details>
+
+<details>
+<summary>2. Can I use `.sqrt()` with arrays of different data types?</summary>
+<p>Yes, NumPy automatically promotes data types as needed. However, be aware that the return type might differ from the input type, typically returning floating-point numbers.</p>
+</details>
+
+<details>
+<summary>3. What's the difference between [`math.sqrt()`](https://www.codecademy.com/resources/docs/python/math-module/math-sqrt) and `numpy.sqrt()`?</summary>
+<p>`math.sqrt()` works only on scalar values, while `numpy.sqrt()` works on both scalars and arrays, applying the operation element-wise to arrays.</p>
+</details>