Merge branch 'main' into numpy-mean

Author: Sriparno08

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

@@ -0,0 +1,80 @@
+---
+Title: 'Acosh()'
+Description: 'Returns the inverse hyperbolic cosine of a specified number.'
+Subjects:
+  - 'Computer Science'
+  - 'Web Development'
+Tags:
+  - 'Functions'
+  - 'Math'
+  - 'Methods'
+  - 'Numbers'
+CatalogContent:
+  - 'learn-c-sharp'
+  - 'paths/computer-science'
+---
+
+The **`Math.Acosh()`** method returns the inverse hyperbolic cosine (also known as hyperbolic arccosine) of a specified number. It computes the value whose hyperbolic cosine equals the given number.
+
+## Syntax
+
+```pseudo
+Math.Acosh(number);
+```
+
+**Parameters:**
+
+- `number`: A double-precision floating-point value greater than or equal to `1`, for which to compute the inverse hyperbolic cosine.
+
+**Return value:**
+
+- The inverse hyperbolic cosine of the specified number in radians as a `double`.
+- `NaN` if the input is less than `1` or `NaN`.
+
+## Example: Basic Usage of `Math.Acosh()`
+
+This example calculates the inverse hyperbolic cosine of a number using `Math.Acosh()` and displays the result in radians:
+
+```cs
+using System;
+
+public class Example
+{
+  public static void Main()
+  {
+    double number = 1.5;
+    double result = Math.Acosh(number);
+    Console.WriteLine($"Math.Acosh({number}) = {result} radians");
+  }
+}
+```
+
+This example outputs the following:
+
+```shell
+Math.Acosh(1.5) = 0.9624236501192069 radians
+```
+
+## Codebyte Example
+
+In this example, the `Math.Acosh()` method is used to calculate the inverse hyperbolic cosine of a specified number in radians and degrees:
+
+```codebyte/csharp
+using System;
+
+public class Example {
+  public static void Main() {
+    double number = 100.0;
+
+    // Calculate Acosh in radians
+    double resultRadians = Math.Acosh(number);
+
+    // Convert radians to degrees
+    double resultDegrees = resultRadians * (180.0 / Math.PI);
+
+    // Display results
+    Console.WriteLine($"Math.Acosh({number}) = {resultRadians} radians");
+    Console.WriteLine($"Math.Acosh({number}) = {resultDegrees} degrees");
+  }
+}
+```

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

@@ -0,0 +1,93 @@
+---
+Title: 'Clamp()'
+Description: 'Restricts a value to lie within a specified minimum and maximum range.'
+Subjects:
+  - 'Code Foundations'
+  - 'Computer Science'
+Tags:
+  - 'Arithmetic'
+  - 'Method'
+  - 'Numbers'
+CatalogContent:
+  - 'learn-c-sharp'
+  - 'paths/computer-science'
+---
+
+The **`Math.Clamp()`** is a static method that returns the value clamped to the inclusive range of min and max.
+
+> **Note:** The static method `Math.Clamp()` was introduced in .NET Core 2.0.
+
+## Syntax
+
+```pseudo
+Math.Clamp(value, min, max);
+```
+
+**Parameters:**
+
+- `value`: The value to be clamped.
+- `min`: The lower bound of the result.
+- `max`: The upper bound of the result.
+
+**Return value:**
+
+Returns the value clamped to the inclusive range of min and max.
+
+> **Note:** If value is less than `min`, it returns `min`; if greater than `max`, it returns `max`; otherwise, it returns `value`.
+
+## Example
+
+The following example demonstrates the `Math.Clamp()` method and writes the result to the console.
+
+```cs
+using System;
+
+class Program
+{
+  static void Main()
+  {
+    int min = 2;
+    int max = 8;
+
+    int result = Math.Clamp(10, min, max);
+    Console.WriteLine(result);
+  }
+}
+```
+
+The example will result in the following output:
+
+```shell
+8
+```
+
+## Codebyte Example
+
+In this example, a random list of decimal numbers is generated, and `Math.Clamp()` ensures that all stored values stay within the defined range:
+
+```codebyte/csharp
+using System;
+
+class Example
+{
+  static void Main()
+  {
+    Random random = new Random();
+    double[] nums = new double[10];
+    int min = 1;
+    int max = 50;
+
+    for (int i = 0; i < nums.Length; i++)
+    {
+      double range = random.NextDouble() * 70 - 10; // -10 to 60
+      double limit = Math.Clamp(range, min, max);
+      nums[i] = limit;
+    }
+
+    foreach (double num in nums)
+    {
+      Console.WriteLine(num);
+    }
+  }
+}
+```

content/cpp/concepts/deque/terms/at/at.md

@@ -0,0 +1,130 @@
+---
+Title: '.at()'
+Description: 'Accesses an element at a specified index in a deque with bounds checking.'
+Subjects:
+  - 'Computer Science'
+  - 'Game Development'
+Tags:
+  - 'Containers'
+  - 'Deques'
+  - 'Methods'
+  - 'STL'
+CatalogContent:
+  - 'learn-c-plus-plus'
+  - 'paths/computer-science'
+---
+
+The C++ **`.at()`** [function](https://www.codecademy.com/resources/docs/cpp/functions) accesses the element at a given index in a deque while performing bounds checking. If the index is out of range, the function throws an `std::out_of_range` [exception](https://www.codecademy.com/resources/docs/cpp/exceptions). This makes it a safer alternative to the subscript operator `[]`, which offers no safety checks.
+
+## Syntax
+
+```pseudo
+deque.at(pos)
+```
+
+**Parameters:**
+
+- `pos`: A zero-based index of the element to access. Must be within the valid range of the deque.
+
+**Return value:**
+
+Returns a reference to the element at the given position.
+
+**Exceptions:**
+
+Throws `std::out_of_range` if `pos` is invalid.
+
+## Example 1: Accessing Elements Safely
+
+In this example, `.at()` retrieves elements from valid positions in the deque:
+
+```cpp
+#include <iostream>
+#include <deque>
+using namespace std;
+
+int main() {
+  deque<int> numbers = {10, 20, 30, 40};
+
+  cout << "Element at index 2: " << numbers.at(2) << endl;
+  cout << "Element at index 0: " << numbers.at(0) << endl;
+
+  return 0;
+}
+```
+
+The output of this code is:
+
+```shell
+Element at index 2: 30
+Element at index 0: 10
+```
+
+The `.at()` function returns elements at positions 2 and 0 with built-in bounds checking.
+
+## Example 2: Handling Out-of-Range Access
+
+In this example, accessing index 5 triggers an exception because the index is outside the deque's valid range:
+
+```cpp
+#include <iostream>
+#include <deque>
+using namespace std;
+
+int main() {
+  deque<string> names = {"Ava", "Mira", "Leo"};
+
+  try {
+    cout << names.at(5) << endl;
+  } catch (const out_of_range& e) {
+    cout << "Error: " << e.what() << endl;
+  }
+
+  return 0;
+}
+```
+
+The output of this code is:
+
+```shell
+Error: deque::_M_range_check: __n (which is 5)>= this->size() (which is 3)
+```
+
+## Codebyte Example
+
+This example demonstrates safe element access and shows how `.at()` behaves when an invalid index is used:
+
+```codebyte/cpp
+#include <iostream>
+#include <deque>
+using namespace std;
+
+int main() {
+  deque<char> letters = {'A', 'B', 'C', 'D'};
+
+  cout << "First element: " << letters.at(0) << endl;
+  cout << "Third element: " << letters.at(2) << endl;
+
+  try {
+    cout << letters.at(10) << endl;
+  } catch (const out_of_range& e) {
+    cout << "Caught exception: " << e.what() << endl;
+  }
+
+  return 0;
+}
+```
+
+## Frequently Asked Questions
+
+### 1. What is the use of deque in C++?
+
+A deque (double-ended queue) stores elements in a dynamic sequence where insertions and deletions at both the front and back are efficient. It supports random access like a vector but provides faster operations at the beginning of the structure.
+
+### 2. What is a std::deque?
+
+`std::deque` is a standard container that provides a dynamic array-like structure with fast operations at both ends. It is implemented as segmented memory blocks, which allows it to grow without relocating all elements like a vector.
+
+### 3. How to check if deque is empty in C++?
+
+A deque can be checked for emptiness using the `.empty()` method, which returns `true` if it contains no elements and `false` otherwise. This check is constant time and works for all standard containers.

content/cpp/concepts/math-functions/terms/isgreater/isgreater.md

@@ -0,0 +1,88 @@
+---
+Title: 'isgreater()'
+Description: 'Compares two floating-point values and returns true if the first is strictly greater than the second.'
+Subjects:
+  - 'Computer Science'
+  - 'Data Science'
+  - 'Game Development'
+Tags:
+  - 'Functions'
+  - 'Comparison'
+  - 'Math'
+CatalogContent:
+  - 'learn-c-plus-plus'
+  - 'paths/computer-science'
+---
+
+The **`isgreater()`** [function](https://www.codecademy.com/resources/docs/cpp/functions) compares two floating-point values and returns `true` only when the first is strictly greater than the second. It follows IEEE-754 rules, never raises floating-point exceptions, and always returns `false` if either argument is `NaN`. Integer inputs are promoted to floating-point. The function is available through the `<cmath>` header.
+
+## Syntax
+
+```pseudo
+isgreater(x, y)
+```
+
+**Parameters:**
+
+- `x`, `y`: Arithmetic values (integers or floating-point types).
+
+> **Note:** Integer arguments are promoted to the appropriate floating-point type.
+
+**Return value:**
+
+The `isgreater()` function returns:
+
+- `true` if `x > y` and neither argument is `NaN`
+- `false` otherwise, including when either value is `NaN`
+
+## Example
+
+The following example checks whether one number is greater than another, including a comparison involving `NaN`:
+
+```cpp
+#include <iostream>
+#include <iostream>
+#include <cmath>
+
+using namespace std;
+
+int main() {
+  double x = 10.5;
+  double y = 5.2;
+  double z = nan("1");
+
+  cout << boolalpha;
+  cout << "isgreater(x, y): " << isgreater(x, y) << endl;
+  cout << "isgreater(x, z): " << isgreater(x, z) << " (NaN comparison)" << endl;
+
+  return 0;
+}
+```
+
+The output of this code is as follows:
+
+```shell
+isgreater(x, y): true
+isgreater(x, z): false (NaN comparison)
+```
+
+## Codebyte Example
+
+The following example is runnable and outputs whether one number is greater than another using `isgreater()`:
+
+```codebyte/cpp
+#include <iostream>
+#include <cmath>
+using namespace std;
+
+int main() {
+  double a = 7.5;
+  double b = 9.3;
+
+  cout << boolalpha;
+  cout << "isgreater(a, b): " << isgreater(a, b) << endl;
+  cout << "isgreater(b, a): " << isgreater(b, a) << endl;
+
+  return 0;
+}
+```