Merge branch 'main' into lastIndexOf

Author: avdhoottt

CONTRIBUTING.md

@@ -158,10 +158,6 @@ git rebase upstream main
 git push
 ```
 
-## Additional Resources
-
-- [How to Contribute to Docs](https://dev.to/codecademy/how-to-contribute-to-codecademy-docs-1a77) article
-
-Remember, if you ever have any questions at all, we're always here to help in the [Codecademy Forums](https://discuss.codecademy.com/c/community/community-docs/2205) and [Codecademy Discord](https://discord.com/invite/codecademy).
+Remember, if you ever have any questions at all, we're always here to help in the [Codecademy Forums](https://community.codecademy.com/).
 
 If you find any bugs or errors in the content, feel free to file an issue [here](https://github.com/Codecademy/docs/issues/new?assignees=Name+here&labels=bug&template=bug_reports.yml&title=%5BBug%2FError%5D+Subject%3A+Entry+Name)! 🖖

README.md

@@ -56,7 +56,7 @@ Here's how you can contribute to Codecademy Docs:
 - Submit your work:
   - Submit a Pull Request of your entry for your assigned Issue.
 - Collaborate and provide feedback:
-  - Reply to the thread on [Possible Content Discussion](https://discuss.codecademy.com/t/find-a-starting-point-possible-content-discussion/745868) to share ideas and collaborate with other contributors, maintainers, or super users to determine good future issues.
+  - Reply to the thread on [Possible Content Discussion](https://community.codecademy.com/) to share ideas and collaborate with other contributors, maintainers, or super users to determine good future issues.
   - Share your thoughts in this [Docs feedback form](https://codecademyready.typeform.com/to/hzVIWDgz) to tell us how we can improve Docs!
 
 Whether you are a code newbie or a seasoned hacker, there's something for you!

bin/concept-of-the-week.txt

@@ -1 +1 @@
-content/kotlin/concepts/operators/operators.md
+content/kotlin/concepts/variables/variables.md

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

@@ -1,5 +1,5 @@
 ---
-Title: 'Abs()'
+Title: '.Abs()'
 Description: 'Returns the absolute value of a specified number.'
 Subjects:
   - 'Computer Science'

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/atanh/atanh.md

@@ -0,0 +1,82 @@
+---
+Title: 'Atanh()'
+Description: 'Returns the inverse hyperbolic tangent of a number.'
+Subjects:
+  - 'Computer Science'
+  - 'Code Foundations'
+Tags:
+  - 'Arithmetic'
+  - 'Methods'
+  - 'Numbers'
+CatalogContent:
+  - 'learn-c-sharp'
+  - 'paths/computer-science'
+---
+
+The **`Math.Atanh()`** method returns the inverse hyperbolic tangent (hyperbolic arctangent) of a specified number. The inverse hyperbolic tangent is the value whose hyperbolic tangent is the input number.
+
+## Syntax
+
+```pseudo
+Math.Atanh(value);
+```
+
+**Parameters:**
+
+- `value`: A double-precision floating-point number in the range `-1` to `1`, representing the hyperbolic tangent value.
+
+**Return value:**
+
+The `Math.Atanh()` method returns the inverse hyperbolic tangent of the given `value` as a `double`.
+
+It returns:
+
+- `NaN` (Not a Number) if the `value` is less than `-1` or greater than `1`.
+- `NegativeInfinity` if the `value` is exactly `-1`.
+- `PositiveInfinity` if the `value` is exactly `1`.
+
+## Example: Basic Usage of `Math.Atanh()`
+
+The following example demonstrates the basic usage of `Math.Atanh()`:
+
+```cs
+using System;
+
+class Program
+{
+  static void Main()
+  {
+    double value = 0.5;
+    double result = Math.Atanh(value);
+    Console.WriteLine($"Atanh({value}) = {result}");
+  }
+}
+```
+
+This will output:
+
+```shell
+Atanh(0.5) = 0.5493061443340548
+```
+
+## Codebyte Example
+
+In this example, different values are passed to `Math.Atanh()` to observe how the result changes:
+
+```codebyte/csharp
+using System;
+
+class Program
+{
+  static void Main()
+  {
+    double[] testValues = { 0.25, 0.5, 0.75, 0.9, -0.5 };
+
+    foreach (double value in testValues)
+    {
+      double result = Math.Atanh(value);
+      Console.WriteLine($"Atanh({value}) = {result:F4}");
+    }
+  }
+}
+```

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

@@ -0,0 +1,86 @@
+---
+Title: '.BigMul()'
+Description: 'Multiplies two integer values and returns the full extended result to prevent overflow.'
+Subjects:
+  - 'Computer Science'
+  - 'Code Foundations'
+Tags:
+  - 'Methods'
+  - 'Numbers'
+  - 'Arithmetic'
+CatalogContent:
+  - 'learn-c-sharp'
+  - 'paths/computer-science'
+---
+
+The **`Math.BigMul()`** method multiplies two integer values and returns the full extended result to avoid overflow. It ensures that the product fits within a larger data type when the operands are 32-bit or 64-bit integers.
+
+## Syntax
+
+```pseudo
+Math.BigMul(x, y);
+```
+
+**Parameters:**
+
+- `x`, `y`: The integers to be multiplied. These can be of type `int`, `uint`, `long`, or `ulong`.
+
+**Return value:**
+
+Returns the full product of `x` and `y` as a single 64-bit or 128-bit integer, depending on the input type:
+
+- If `x` and `y` are of type `int` or `uint`, the return type is `long` and `ulong`, respectively.
+- If `x` and `y` are of type `long` or `ulong`, the return type is `Int128` and `UInt128`, respectively.
+
+> **Note:** The `Int128` and `UInt128` types were introduced in .NET 7. In earlier versions, `Math.BigMul(long, long, out long high)` can be used to obtain the high and low 64-bit parts of the product.
+
+## Example: Basic Usage
+
+In this example, the full product of two `int` values is calculated without overflow:
+
+```cs
+using System;
+
+public class Example {
+  public static void Main() {
+    // Integer values (32-bit)
+    int intX = 100000;
+    int intY = 500000;
+
+    // Compute the product safely
+    long intResult = Math.BigMul(intX, intY);
+
+    Console.WriteLine($"Math.BigMul({intX}, {intY}) = {intResult}");
+  }
+}
+```
+
+This example outputs the following:
+
+```shell
+Math.BigMul(100000, 500000) = 50000000000
+```
+
+## Codebyte Example
+
+The following example demonstrates the use of `Math.BigMul()` to calculate the product of two integers that would normally cause an overflow with standard multiplication:
+
+```codebyte/csharp
+using System;
+
+public class Example {
+  public static void Main (string[] args) {
+    int x = 200000;
+    int y = 300000;
+
+    // Normal multiplication (overflow)
+    int normalResult = x * y;
+
+    // Math.BigMul() (no overflow)
+    long bigMulResult = Math.BigMul(x, y);
+
+    Console.WriteLine($"Normal multiplication (overflow): {normalResult}");
+    Console.WriteLine($"BigMul (no overflow): {bigMulResult}");
+  }
+}
+```

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

@@ -0,0 +1,85 @@
+---
+Title: 'Cbrt()'
+Description: 'Returns the cube root of the given number.'
+Subjects:
+  - 'Code Foundations'
+  - 'Computer Science'
+Tags:
+  - 'Arithmetic'
+  - 'Methods'
+  - 'Numbers'
+CatalogContent:
+  - 'learn-c-sharp'
+  - 'paths/computer-science'
+---
+
+The **`Math.Cbrt()`** [method](https://www.codecademy.com/resources/docs/c-sharp/methods) in C# returns the cube root of a given number. It handles positive, negative, and special floating-point values such as `NaN` and infinities.
+
+## Syntax
+
+```pseudo
+Math.Cbrt(double x)
+```
+
+**Parameters:**
+
+- `x` (double): The number whose cube root is to be calculated.
+
+**Return value:**
+
+The method will return a value of [type](https://www.codecademy.com/resources/docs/c-sharp/data-types) `double` unless the value passed is one of the following:
+
+- If `x` is `NaN`, the method will return `NaN`.
+- If `x` is `PositiveInfinity`, the method will return `PositiveInfinity`.
+- If `x` is `NegativeInfinity`, the method will return `NegativeInfinity`.
+- If `x` is negative, the method will return the real cube root (a negative number).
+
+## Example
+
+In this example, different numeric values are passed to `Math.Cbrt()` to calculate their cube roots:
+
+```cs
+using System;
+
+namespace MyCubeRoot {
+  public class Example {
+    public static void Main(string[] args) {
+      double a = Math.Cbrt(27);
+      double b = Math.Cbrt(-8);
+      double c = Math.Cbrt(1000);
+      double d = Math.Cbrt(0.125);
+
+      Console.WriteLine(a);
+      Console.WriteLine(b);
+      Console.WriteLine(c);
+      Console.WriteLine(d);
+    }
+  }
+}
+```
+
+This example results in the following output:
+
+```shell
+3.0000000000000004
+-2
+10
+0.49999999999999994
+```
+
+## Codebyte Example
+
+In this example, the cube root of 64 is calculated using `Math.Cbrt()` and printed to the console:
+
+```codebyte/csharp
+using System;
+
+public class Example {
+  public static void Main() {
+    double number = 64;
+    double cubeRoot = Math.Cbrt(number);
+
+    Console.WriteLine("The cube root of " + number + " is " + cubeRoot);
+  }
+}
+```