Refine isunordered function documentation

Updated the description of the isunordered function for clarity and added detailed parameter and return value sections. Enhanced examples to demonstrate usage with NaN values.

Author: mamtawardhani

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

@@ -1,8 +1,9 @@
 ---
 Title: 'isunordered()'
-Description: 'Returns true if one or both of the arguments is a NaN value'
+Description: 'Checks whether either of two floating-point values is NaN, returning true if the comparison between them is unordered.'
 Subjects:
   - 'Computer Science'
+  - 'Game Development'
 Tags:
   - 'Arithmetic'
   - 'Functions'
@@ -12,65 +13,76 @@ CatalogContent:
   - 'paths/computer-science'
 ---
 
-When comparing two floating-point numbers, the comparison behaves as unordered if one of them is a `NaN` (Not a Number). The function **`isunordered()`** receives two floating-point numbers and checks if either of them is a `NaN`. `isunordered()` returns `true` if one or both of the arguments is `NaN`, and returns `false` only if both arguments are normal floating-point numbers. 
+The **`isunordered()`** function returns `true` if either of the two floating-point values is `NaN`, meaning the comparison is unordered because no meaningful relational comparison (such as `<`, `>`, or `==`) can be made.
 
 ## Syntax
 
 ```pseudo
 isunordered(a, b)
 ```
-The function `isunordered(a, b)` receives two arguments `a` and `b`, of type `double`, `float`, or `long double` data types and returns `true` if either `a` or `b` is `NaN`. It will return `false` only if both `a` and `b` are normal floating-point numbers. 
+
+**Parameters:**
+
+- `a`: A floating-point value.
+- `b`: A floating-point value.
+
+Both arguments may be `float`, `double`, `long double`, or mixed arithmetic types (due to overloads).
+
+**Return value:**
+
+- Returns `true` if either `a` or `b` is `NaN`, which makes the comparison unordered (no meaningful `<`, `>`, or `==` relationship exists).
+- Returns `false` otherwise.
 
 ## Example
 
+In this example several value pairs are tested with `isunordered()` to demonstrate when comparisons involving NaN are unordered:
+
 ```cpp
 #include <iostream>
 #include <cmath>
 using namespace std;
 
 int main()
 {
-	cout << (isunordered(3.0, NAN)?"true":"false") << endl;
-		// returns true
-	cout << (isunordered(NAN, 3.0)?"true":"false") << endl;
-		// returns true
-	cout << (isunordered(NAN, 3.0)?"true":"false") << endl;
-		// returns true
-	cout << (isunordered(3.0, 4.0)?"true":"false") << endl;
-		// returns false 
+  cout << (isunordered(3.0, NAN)?"true":"false") << endl;
+  cout << (isunordered(NAN, 3.0)?"true":"false") << endl;
+  cout << (isunordered(3.0, 4.0)?"true":"false") << endl;
 }
 ```
 
+The output of this code is:
+
+```shell
+true
+true
+false
+```
+
 ## Codebyte Example
 
-The following example is runnable and shows what the function `isunordered()` resolves to, when given different kinds of arguments. In the example the helper function `checkNaN()` takes in two double arguments `a` and `b` and passes them to `isunordered()` and outputs the appropriate message depending on the condition `isunordered()` returns. the `main()` function calls `checkNaN()` multiple times with different arguments. For simplicity, `checkNaN()` only takes arguments with `double` data type. 
+In this example a helper function prints whether two doubles can be compared or if their comparison is unordered because of `NaN` involvement:
 
 ```codebyte/cpp
 #include <iostream>
 #include <cmath>
 using namespace std;
 
 void checkNaN(double a, double b) {
-	if (isunordered(a, b))
-		cout << a << " is NOT comparable with " << b << endl;
-	else
-		cout << a << " is comparable with " << b << endl;
+  if (isunordered(a, b))
+    cout << a << " is NOT comparable with " << b << endl;
+  else
+    cout << a << " is comparable with " << b << endl;
 }
 
-
 int main()
 {
-	double nan = NAN; // a NaN (Not a Number) value
-	double pi = 3.14; // a regular double number
-	double c = 2.99792458e8; // a regular double number
-
-	checkNaN(nan, nan); 
-	// outputs: nan is NOT comparable with nan
-	checkNaN(nan, pi);
-	// outputs: nan is NOT comparable with 3.14
-	checkNaN(c, nan);
-	// outputs: 2.99792e+08 is NOT comparable with nan
-	checkNaN(c, pi);
-	// outputs: 2.99792e+08 is comparable with 3.14
+  double nan = NAN; // a NaN (Not a Number) value
+  double pi = 3.14; // a regular double number
+  double c = 2.99792458e8; // a regular double number
+
+  checkNaN(nan, nan);
+  checkNaN(nan, pi);
+  checkNaN(c, nan);
+  checkNaN(c, pi);
 }
-```
+```