Merge branch 'main' into size

Author: Sriparno08

bin/concept-of-the-week.txt

@@ -1 +1 @@
-content/uiux/concepts/convergent-thinking/convergent-thinking.md
+content/swift/concepts/ranges/ranges.md

content/c-sharp/concepts/arrays/arrays.md

@@ -24,11 +24,21 @@ type[] arrayName;
 // Create the array variable and initialize it with an array of N items:
 type[] arrayName = new type[N];
 
+// Classic Syntax
+
 // Create the array variable and initialize it by specifying the contents:
 type[] arrayName = new type[] { value1, value2, value3, ... valueN };
 
 // Alternative way of creating the array and specifying the contents:
 type[] arrayName = { value1, value2, value3, ... valueN };
+
+// Collection Expression Syntax (C# 12+)
+
+// Create an empty array:
+type[] arrayName = [];
+
+// Create the array variable and initialize it by specifying the contents:
+type[] arrayName = [ value1, value2, value3, ... valueN ];
 ```
 
 > **Note:** Arrays in C# have a set size, meaning the number of elements they hold cannot be changed once the array has been created.
@@ -44,8 +54,8 @@ public class Example
 {
   public static void Main(string[] args)
   {
-    char[] vowels = {'a', 'e', 'i', 'o', 'u'};
-    //      indexes:  0    1    2    3    4
+    char[] vowels = [ 'a', 'e', 'i', 'o', 'u' ];
+    //     indexes:    0    1    2    3    4
 
     Console.WriteLine(vowels[0]); // Output: a
 

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

@@ -0,0 +1,75 @@
+---
+Title: 'Asinh()'
+Description: 'Returns the inverse hyperbolic sine of a number, in radians.'
+Subjects:
+  - 'Code Foundations'
+  - 'Computer Science'
+Tags:
+  - 'Arithmetic'
+  - 'Methods'
+  - 'Numbers'
+CatalogContent:
+  - 'learn-c-sharp'
+  - 'paths/computer-science'
+---
+
+The **`Math.Asinh()`** [method](https://www.codecademy.com/resources/docs/c-sharp/methods) returns the inverse hyperbolic sine of a number, in radians. This method appears frequently in advanced mathematics, including physics, geometry, machine learning, and numerical analysis.
+
+> **Note:** The static method `Math.Asinh()` was introduced in .NET Core 2.1.
+
+## Syntax
+
+```pseudo
+Math.Asinh(value);
+```
+
+**Parameters:**
+
+- `value` (double): A real number. If value is `NaN`, the method returns `NaN`.
+
+**Return value:**
+
+Returns the inverse hyperbolic sine of `value`, in radians.
+
+## Example
+
+The following example demonstrates the `Math.Asinh()` method and writes the result to the console:
+
+```cs
+using System;
+class Program
+{
+  static void Main()
+  {
+    double x = 2;
+    double result = Math.Asinh(x);
+    Console.WriteLine(result);
+  }
+}
+```
+
+The example will result in the following output:
+
+```shell
+1.4436354751788103
+```
+
+## Codebyte Example
+
+The following codebyte example uses the `Math.PI` constant field to convert the result into degrees:
+
+```codebyte/csharp
+using System;
+class Program
+{
+  static void Main()
+  {
+    double x = 4;
+    double radians = Math.Asinh(x);
+    double degrees = radians * (180 / Math.PI);
+
+    Console.WriteLine($"Radians: {radians}");
+    Console.WriteLine($"Degrees: {degrees}");
+  }
+}
+```

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

@@ -0,0 +1,94 @@
+---
+Title: 'Log10()'
+Description: 'Returns the base-10 logarithm of a specified number.'
+Subjects:
+  - 'Computer Science'
+  - 'Web Development'
+Tags:
+  - 'Arithmetic'
+  - 'Functions'
+  - 'Math'
+  - 'Methods'
+CatalogContent:
+  - 'learn-c-sharp'
+  - 'paths/computer-science'
+---
+
+In C#, the **`Math.Log10()`** [method](https://www.codecademy.com/resources/docs/c-sharp/methods) calculates the base-10 logarithm of a given number. This logarithm represents the power to which 10 must be raised to obtain the input value. The method is defined in the `System` namespace.
+
+## Syntax
+
+```pseudo
+Math.Log10(number);
+```
+
+**Parameters:**
+
+- `number`: A `double` value whose base-10 logarithm is computed.
+
+**Return value:**
+
+Returns a `double` that represents the base-10 logarithm of `number`.
+
+Return values for different inputs:
+
+- If the input is a positive number, the method returns its base-10 logarithm.
+- If the input is `0`, the method returns `NegativeInfinity`.
+- If the input is a negative number, the method returns `NaN`.
+- If the input is `NaN`, the method returns `NaN`.
+- If the input is `PositiveInfinity`, the method returns `PositiveInfinity`.
+- If the input is `NegativeInfinity`, the method returns `NaN`.
+
+## Example
+
+The example below demonstrates the return values of `Math.Log10()` for different inputs:
+
+```cs
+using System;
+
+class Geeks {
+  public static void Main(String[] args) {
+    double a = 4.55;
+    double b = 0;
+    double c = -2.45;
+    double nan = Double.NaN;
+    double positiveInfinity = Double.PositiveInfinity;
+    double negativeInfinity = Double.NegativeInfinity;
+
+    Console.WriteLine(Math.Log10(a));
+    Console.WriteLine(Math.Log10(b));
+    Console.WriteLine(Math.Log10(c));
+    Console.WriteLine(Math.Log10(nan));
+    Console.WriteLine(Math.Log10(positiveInfinity));
+    Console.WriteLine(Math.Log10(negativeInfinity));
+  }
+}
+```
+
+The output of the code is:
+
+```shell
+0.658011396657112
+-Infinity
+NaN
+NaN
+Infinity
+NaN
+```
+
+## Codebyte Example
+
+This codebyte example calculates the base-10 logarithm of a given number and prints the result:
+
+```codebyte/csharp
+using System;
+
+class Program {
+  static void Main() {
+    double x = 10.0;
+    double result = Math.Log10(x);
+
+    Console.WriteLine($"The base-10 logarithm of {x} is {result}");
+  }
+}
+```

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

@@ -0,0 +1,125 @@
+---
+Title: 'fpclassify()'
+Description: 'Classifies a floating-point value into categories such as zero, normal, subnormal, infinite, or NaN.'
+Subjects:
+  - 'Computer Science'
+  - 'Data Science'
+Tags:
+  - 'Classification'
+  - 'Functions'
+  - 'Math'
+CatalogContent:
+  - 'learn-c-plus-plus'
+  - 'paths/computer-science'
+---
+
+The **`fpclassify()`** [function](https://www.codecademy.com/resources/docs/cpp/functions) in C++ returns an integer value indicating the classification of a floating-point number. It categorizes values as normal, subnormal, zero, infinite, or NaN (Not-a-Number). The function is available through the `<cmath>` header.
+
+## Syntax
+
+```pseudo
+fpclassify(x)
+```
+
+**Parameters:**
+
+- `x`: A floating-point value (can be `float`, `double`, or `long double`).
+
+**Return value:**
+
+The `fpclassify()` function returns one of the following integer constants:
+
+- `FP_INFINITE`: The value is positive or negative infinity.
+- `FP_NAN`: The value is NaN (Not-a-Number).
+- `FP_ZERO`: The value is zero.
+- `FP_SUBNORMAL`: The value is a subnormal (denormalized) number.
+- `FP_NORMAL`: The value is a normal finite non-zero number.
+
+## Example
+
+The following example demonstrates various classifications using `fpclassify()`:
+
+```cpp
+#include <iostream>
+#include <cmath>
+
+using namespace std;
+
+int main() {
+  double normal = 1.5;
+  double zero = 0.0;
+  double inf = INFINITY;
+  double nan = NAN;
+
+  cout << "Classification of " << normal << ": ";
+  if (fpclassify(normal) == FP_NORMAL) {
+    cout << "Normal" << endl;
+  }
+
+  cout << "Classification of " << zero << ": ";
+  if (fpclassify(zero) == FP_ZERO) {
+    cout << "Zero" << endl;
+  }
+
+  cout << "Classification of inf: ";
+  if (fpclassify(inf) == FP_INFINITE) {
+    cout << "Infinite" << endl;
+  }
+
+  cout << "Classification of nan: ";
+  if (fpclassify(nan) == FP_NAN) {
+    cout << "NaN" << endl;
+  }
+
+  return 0;
+}
+```
+
+The output of this code is:
+
+```shell
+Classification of 1.5: Normal
+Classification of 0: Zero
+Classification of inf: Infinite
+Classification of nan: NaN
+```
+
+## Codebyte Example
+
+The following runnable example shows how to use `fpclassify()` with different values:
+
+```codebyte/cpp
+#include <iostream>
+#include <cmath>
+
+using namespace std;
+
+int main() {
+  double values[] = {1.0, 0.0, INFINITY, NAN, -5.5};
+
+  for (double val : values) {
+    cout << "fpclassify(" << val << ") = ";
+
+    switch(fpclassify(val)) {
+      case FP_INFINITE:
+        cout << "Infinite";
+        break;
+      case FP_NAN:
+        cout << "NaN";
+        break;
+      case FP_ZERO:
+        cout << "Zero";
+        break;
+      case FP_SUBNORMAL:
+        cout << "Subnormal";
+        break;
+      case FP_NORMAL:
+        cout << "Normal";
+        break;
+    }
+    cout << endl;
+  }
+
+  return 0;
+}
+```