Merge branch 'main' into add-data-visualization-in-UX

Author: AnamolR

content/ai/concepts/search-algorithms/terms/beam-search/beam-search.md

@@ -2,19 +2,20 @@
 Title: 'BEAM Search'
 Description: 'A graph searching algorithm that is a variant of breadth-first search.'
 Subjects:
-  - 'Data Science'
   - 'AI'
+  - 'Data Science'
 Tags:
-  - 'Search Algorithms'
   - 'AI'
+  - 'Algorithms'
+  - 'Search Algorithms'
 CatalogContent:
   - 'learn-python-3'
-  - 'paths/machine-learning-ai-engineering-foundations'
+  - 'paths/computer-science'
 ---
 
 **BEAM Search**, a variant of [breadth-first Search](https://www.codecademy.com/resources/docs/ai/search-algorithms/breadth-first-search), is an algorithm that searches a weighted graph for an optimal path from some start node **S** to some goal node **G**. The difference between BEAM search and breadth-first search is that at every level of the search tree, only the top _β_ candidates are chosen for further exploration. Here, β is known as the _beam width_. The reasoning behind this is that a path from **S** to **G** is likely to pass through some top number of most promising nodes. This leads to an algorithm that is fast and memory-efficient because it can disregard many nodes that may appear to be too far from the goal. This, however, sometimes causes the algorithm to overlook a potential shortest path because a candidate node is greater than the beam width. This renders the algorithm as _incomplete_, meaning that finding the shortest path is not guaranteed. Since the algorithm can find a reasonably short path, trading completeness for efficiency is accepted. Much like [A\* search](https://www.codecademy.com/resources/docs/ai/search-algorithms/a-star-search) and [best-first search](https://www.codecademy.com/resources/docs/ai/search-algorithms/best-first-search), an evaluation function is used to evaluate the candidacy of nodes for further exploration.
 
-## The Algorithm
+## How the Beam Search Algorithm Works
 
 Similar to A\* search, the algorithm uses an **open list** and a **closed list** for the exploration of nodes. In this algorithm, the open list is an ordinary queue. The algorithm begins with a start node **S**, which also serves as the root node for the search tree.
 
@@ -58,10 +59,67 @@ It is in this step that node **G** has been found:
 Trace the path from **S** to **G**:
 ![Final-path](https://raw.githubusercontent.com/Codecademy/docs/main/media/BEAM-Search-final-path.png)
 
-## Advantages and Disadvantages
+## Pseudocode for Beam Search Algorithm
+
+```plaintext
+function BEAM_SEARCH(start_node, goal_test, beam_width, max_depth):
+    current_level ← [start_node]
+    depth ← 0
+
+    while current_level is not empty AND depth < max_depth:
+        all_successors ← []
+
+        // Generate all successors from current level
+        for each node in current_level:
+            if goal_test(node):
+                return SUCCESS (node)
+
+            successors ← get_successors(node)
+            for each successor in successors:
+                successor.score ← evaluation_function(successor)
+                all_successors.append(successor)
+
+        if all_successors is empty:
+            return FAILURE
+
+        // Sort all successors by their scores (best first)
+        sorted_successors ← sort(all_successors, by=score, descending=True)
+
+        // Keep only top beam_width candidates for next level
+        current_level ← sorted_successors[0 : beam_width]
+        depth ← depth + 1
+
+    // Check final level for goal
+    for each node in current_level:
+        if goal_test(node):
+            return SUCCESS (node)
+
+    return FAILURE
+```
+
+## Advantages and Disadvantages of Beam Search
 
 As stated before, the advantage of BEAM search is that it is efficient both in time and memory. The disadvantage can be seen from the example in that a possible shortest path from **S** to **G** was overlooked. This can be somewhat corrected by varying the beam width to include more nodes. This, however, would reduce the efficiency of the algorithm. Selecting the optimal beam width is problem-specific and usually requires further insight into the problem.
 
 ## Applications of BEAM Search
 
 The BEAM search algorithm is commonly used in natural language processing and machine translation. An encoder is used to process the text from the source language and BEAM search selects the most probable words (the beam width) in the target language. The evaluation function in this context is the conditional probability of a word in the target language.
+
+## Frequently Asked Questions
+
+### 1. Is ChatGPT using beam search?
+
+No, ChatGPT (and most large language models from OpenAI) doesn't use beam search during inference. It uses sampling-based decoding methods like top-k sampling, top-p (nucleus) sampling, or temperature-controlled sampling to generate text.
+
+### 2. Where is beam search used?
+
+Beam search is widely used in natural language processing (NLP) tasks where sequential predictions are needed:
+
+- Machine translation (e.g., translating English to French)
+- Speech recognition
+- Text generation (in some models)
+- Optical character recognition (OCR)
+
+### 3. What are the benefits of beam search?
+
+Beam search is faster and more memory-efficient than exhaustive search. It explores only the most promising paths, giving better results than greedy search while still being customizable through the beam width. However, it might miss the optimal path.

content/c-sharp/concepts/math-functions/terms/abs/abs.md

@@ -1,74 +1,182 @@
 ---
-Title: '.Abs()'
-Description: 'Computes the non-negative value of a number regardless of its sign.'
+Title: 'Abs()'
+Description: 'Returns the absolute value of a specified number.'
 Subjects:
-  - 'Code Foundations'
   - 'Computer Science'
+  - 'Web Development'
 Tags:
+  - 'Functions'
+  - 'Math'
   - 'Methods'
   - 'Numbers'
-  - 'Arithmetic'
-  - 'Functions'
 CatalogContent:
   - 'learn-c-sharp'
   - 'paths/computer-science'
 ---
 
-The **`Math.Abs()`** class method returns the absolute value of a given number.
+The C# **`Math.Abs()`** method is a static method that returns the absolute value of a specified number. The absolute value of a number is its distance from zero on the number line, always expressed as a positive value or zero.
 
-## Syntax
+## Syntax of C# `Math.Abs()`
 
 ```pseudo
 Math.Abs(number);
 ```
 
-The `Math.Abs()` method takes only one parameter, `number`, a `decimal`, `double` or `integer` type number. The method returns the absolute value of the `number` with the same type as the `number`, except if the value of `number` equals:
+**Parameters:**
+
+- `number`: The numeric value for which to calculate the absolute value. This can be of type `decimal`, `double`, `float`, `int`, `long`, `sbyte`, `short`, or `IntPtr`.
+
+**Return value:**
 
-- `NaN` (not a number), then it returns `NaN`
-- `NegativeInfinity`, then it returns `PositiveInfinity`
-- `PositiveInfinity`, then it also returns `PositiveInfinity`
+Returns the absolute value of the specified number with the same data type as the input parameter. Special cases include:
 
-## Example
+- If the input is `NaN` (Not a Number), returns `NaN`
+- If the input is negative infinity, returns positive infinity
+- If the input is positive infinity, returns positive infinity
 
-The following example uses the `Math.Abs()` method to return the absolute value of a `decimal` and a `double` type number. Then, the `Console.WriteLine()` function prints the results to the console:
+## Example 1: Basic Usage of C# `Math.Abs()`
+
+This example demonstrates the fundamental use of the `Math.Abs()` method with different numeric types to show how it returns the non-negative equivalent of the number:
 
 ```cs
 using System;
 
-public class Example {
-  public static void Main() {
-    decimal num1 = -1.23M;
-    double num2 = 6.674E-11;
+public class BasicAbsExample
+{
+  public static void Main()
+  {
+    // Integer examples
+    int negativeInt = -42;
+    int positiveInt = 15;
+
+    // Decimal examples
+    decimal negativeDecimal = -3.14m;
+    decimal positiveDecimal = 2.71m;
+
+    // Calculate absolute values
+    int absInt1 = Math.Abs(negativeInt);
+    int absInt2 = Math.Abs(positiveInt);
+    decimal absDecimal1 = Math.Abs(negativeDecimal);
+    decimal absDecimal2 = Math.Abs(positiveDecimal);
+
+    // Display results
+    Console.WriteLine($"Math.Abs({negativeInt}) = {absInt1}");
+    Console.WriteLine($"Math.Abs({positiveInt}) = {absInt2}");
+    Console.WriteLine($"Math.Abs({negativeDecimal}) = {absDecimal1}");
+    Console.WriteLine($"Math.Abs({positiveDecimal}) = {absDecimal2}");
+  }
+}
+```
+
+The output of this code is as follows:
+
+```shell
+Math.Abs(-42) = 42
+Math.Abs(15) = 15
+Math.Abs(-3.14) = 3.14
+Math.Abs(2.71) = 2.71
+```
+
+## Example 2: Calculating Temperature Difference using `Math.Abs()`
+
+This example shows how `Math.Abs()` can be used in a real-world scenario to calculate the temperature difference between two values, which is always expressed as a positive number:
 
-    decimal abs1 = Math.Abs(num1);
-    double abs2 = Math.Abs(num2);
+```cs
+using System;
 
-    Console.WriteLine("The absolute value of " + num1 + " is: " + abs1);
-    Console.WriteLine("The absolute value of " + num2 + " is: " + abs2);
+public class TemperatureDifference
+{
+  public static void Main()
+  {
+    // Temperature readings in Celsius
+    double morningTemp = -5.2;
+    double afternoonTemp = 18.7;
+    double eveningTemp = 12.3;
+
+    // Calculate temperature differences
+    double morningAfternoonDiff = Math.Abs(afternoonTemp - morningTemp);
+    double afternoonEveningDiff = Math.Abs(eveningTemp - afternoonTemp);
+    double morningEveningDiff = Math.Abs(eveningTemp - morningTemp);
+
+    // Display results
+    Console.WriteLine("Temperature Analysis:");
+    Console.WriteLine($"Morning: {morningTemp}C");
+    Console.WriteLine($"Afternoon: {afternoonTemp}C");
+    Console.WriteLine($"Evening: {eveningTemp}C");
+    Console.WriteLine();
+    Console.WriteLine("Temperature Differences:");
+    Console.WriteLine($"Morning to Afternoon: {morningAfternoonDiff}C");
+    Console.WriteLine($"Afternoon to Evening: {afternoonEveningDiff}C");
+    Console.WriteLine($"Morning to Evening: {morningEveningDiff}C");
   }
 }
 ```
 
-The example will result in the following output:
+The output of this code is as follows:
 
 ```shell
-The absolute value of -1.23 is: 1.23
-The absolute value of 6.674E-11 is: 6.674E-11
+Temperature Analysis:
+Morning: -5.2°C
+Afternoon: 18.7°C
+Evening: 12.3°C
+
+Temperature Differences:
+Morning to Afternoon: 23.9°C
+Afternoon to Evening: 6.4°C
+Morning to Evening: 17.5°C
 ```
 
-## Codebyte Example
+## Codebyte Example: Financial Loss Calculator Using `Math.Abs()`
 
-The following example is runnable and returns the absolute value of a `double` type number:
+This example demonstrates using `Math.Abs()` in financial applications to calculate the magnitude of profit or loss, regardless of whether the value is positive or negative:
 
 ```codebyte/csharp
 using System;
 
-public class Example {
+public class FinancialLossCalculator
+{
+  public static void Main()
+  {
+    // Investment performance data
+    decimal[] monthlyReturns = { 150.75m, -89.50m, 245.30m, -175.25m, 95.60m };
+    string[] months = { "January", "February", "March", "April", "May" };
+
+    decimal totalAbsoluteChange = 0;
+
+    Console.WriteLine("Monthly Investment Performance:");
+    Console.WriteLine("Month\t\tReturn\t\tAbsolute Change");
+    Console.WriteLine("-----------------------------------------------");
 
-  public static void Main() {
-    double number = 299792458;
+    for (int i = 0; i < monthlyReturns.Length; i++)
+    {
+      decimal absoluteChange = Math.Abs(monthlyReturns[i]);
+      totalAbsoluteChange += absoluteChange;
 
-    Console.WriteLine("The absolute value of " + number + " is: " + Math.Abs(number));
+      string returnType = monthlyReturns[i] >= 0 ? "Profit" : "Loss";
+      Console.WriteLine($"{months[i]}\t\t${monthlyReturns[i]:F2}\t\t${absoluteChange:F2} ({returnType})");
+    }
+
+    Console.WriteLine("-----------------------------------------------");
+    Console.WriteLine($"Total Absolute Change: ${totalAbsoluteChange:F2}");
+    Console.WriteLine($"Average Absolute Change: ${totalAbsoluteChange / monthlyReturns.Length:F2}");
   }
 }
 ```
+
+## Frequently Asked Questions
+
+### 1. What happens if I pass a positive number to `Math.Abs()`?
+
+The method returns the same positive number unchanged. For example, `Math.Abs(5)` returns 5.
+
+### 2. Can `Math.Abs()` handle floating-point numbers?
+
+Yes, `Math.Abs()` supports all numeric types including `float`, `double`, and `decimal`. It preserves the data type of the input.
+
+### 3. What does `Math.Abs()` return for zero?
+
+`Math.Abs(0)` returns 0, as the absolute value of zero is zero.
+
+### 4. Can `Math.Abs()` cause overflow exceptions?
+
+Yes, with certain integer types like `Int32.MinValue`, calling `Math.Abs()` can throw an `OverflowException` because the absolute value exceeds the maximum positive value for that type.