std::nan added,

Author: behnamasadi

README.md

@@ -165,7 +165,7 @@ This change ensures that VSCode uses the "Ninja Multi-Config" generator by defau
       * [stack, queue, priority_queue, deque](docs/stack_queue_priority_queue_deque.md) 
    * [Const, Constexpr and Mutable](docs/const_constexpr_mutable.md)    
    * [Immutable Objects](docs/immutable_objects.md)  
-   * [Data Types, Numerical Limits, Machine Epsilon, Precision](docs/primitive_data_types_numerical_limits_machine_epsilon_precision.md)    
+   * [Data Types, Numerical Limits, Machine Epsilon, Precision, std::nan](docs/primitive_data_types_numerical_limits_machine_epsilon_precision.md)    
    * [Data Types Conversions, Casting, Type Coercion](docs/type_conversions_casting_type_coercion.md)  
    * [Decay](docs/decay.md)  
    * [Dynamic Memory Allocation in C](docs/dynamic_memory_allocation.md)  

docs/algorithms.md

@@ -25,74 +25,100 @@ The `<algorithm>` header in C++20 includes a wide range of functions that are es
    - `std::sort`: Sort elements in a range.
    - `std::stable_sort`: Stable sort elements.
    - `std::partial_sort`: Partially sort elements in a range, up to the `K'th` element.
-```cpp
-  int Kth = 4;
-  std::vector<int> arr = {5, 812, 4, 74, 68, 7, 48, 45};
-  std::partial_sort(arr.begin(), arr.begin() + Kth, arr.end());
-```
-   
+	```cpp
+	  int Kth = 4;
+	  std::vector<int> arr = {5, 812, 4, 74, 68, 7, 48, 45};
+	  std::partial_sort(arr.begin(), arr.begin() + Kth, arr.end());
+	```
+   - `std::partial_sort_copy`: Copies elements from an input range to an output range, Simultaneously sorts the elements copied to the output range. Only the first `n` elements of the output range are guaranteed to be sorted. is efficient for finding a specific number of smallest or largest elements without sorting the entire input range.
+	```cpp
+	  int Kth = 4;
+	  std::vector<int> numbers = {64, 25, 12, 22, 11, 90};
+	  std::vector<int> result(Kth); // We want the 4 smallest elements
+
+	  std::partial_sort_copy(numbers.begin(), numbers.end(), result.begin(),result.end());
+	```
    - `std::nth_element`:  partially sorts a range of elements. It rearranges the elements such that the element at the specified nth position is the one that would be at that position if the entire range were sorted. It is efficient for finding specific elements (like **median, kth smallest/largest**) without sorting the entire container.
-```cpp
-    std::vector<int> numbers = {3, 7, 4, 9, 2, 5, 8, 1, 6};
-
-    // Find the median
-    auto middle = numbers.begin() + numbers.size() / 2;
-    std::nth_element(numbers.begin(), middle, numbers.end());
+	```cpp
+	    std::vector<int> numbers = {3, 7, 4, 9, 2, 5, 8, 1, 6};
 
-    std::cout << "Median: " << *middle << std::endl;   
-```
-
-- `std::partial_sort_copy`: Copies elements from an input range to an output range, Simultaneously sorts the elements copied to the output range. Only the first `n` elements of the output range are guaranteed to be sorted.
+	    // Find the median
+	    auto middle = numbers.begin() + numbers.size() / 2;
+	    std::nth_element(numbers.begin(), middle, numbers.end());
 
-**Syntax:**
-
-```cpp
-std::partial_sort_copy(first, last, result_first, result_last);
-```
-
-* `first` and `last`: Iterators defining the range of elements to be copied.
-* `result_first` and `result_last`: Iterators defining the range of elements to be copied to.
-
-**Example:**
-
-```cpp
-#include <iostream>
-#include <vector>
-#include <algorithm>
-
-int main() {
-    std::vector<int> numbers = { 64, 25, 12, 22, 11, 90 };
-    std::vector<int> result(3); // We want the 3 smallest elements
-
-    std::partial_sort_copy(numbers.begin(), numbers.end(), result.begin(), result.end());
-
-    std::cout << "Original numbers: ";
-    for (int num : numbers) {
-        std::cout << num << " ";
-    }
-    std::cout << std::endl;
-
-    std::cout << "Smallest 3 numbers: ";
-    for (int num : result) {
-        std::cout << num << " ";
-    }
-    std::cout << std::endl;
-
-    return 0;
-}
-```
-
-**Key points:**
-* `std::partial_sort_copy` is efficient for finding a specific number of smallest or largest elements without sorting the entire input range.
-* The output range must be large enough to hold at least as many elements as the number of elements you want to copy.
-* The elements beyond the first `n` elements in the output range are not guaranteed to be sorted.
+	    std::cout << "Median: " << *middle << std::endl;
+	``` 
+   - `std::priority_queue`: use heap for finding max/min value
+    
+	```cpp
+		std::priority_queue<int, std::vector<int>, std::greater<int>> q2;
+		for (int n : {1, 8, 5, 6, 3, 4, 0, 9, 7, 2})
+			q2.push(n);
+			
+	```
+ 
+	using custom_comparator:
+    	
+	```cpp
+	    	
+		  auto comparator = [](int left, int right) {
+		    return (left ^ 1) < (right ^ 1);
+		  };
+
+		  std::priority_queue<int, std::vector<int>, decltype(comparator)>
+		      q_custom_comparator(comparator);
+		  for (int n : {1, 8, 5, 6, 3, 4, 0, 9, 7, 2})
+		    q_custom_comparator.push(n);
+	```
+	
+	Here `decltype` is used to deduce the type of the comparator function (the lambda) so that it can be used as the third template 	argument when defining the
+	
+	#### Why `decltype` is Needed:
+
+	1. **Lambda Functions Have Unique Types:**
+	   - Lambda functions in C++ have unique, unnamed types generated by the compiler. These types are not directly accessible by name, so you cannot simply specify the type of the lambda in the template parameters of `std::priority_queue`.
+
+	2. **Specifying the Comparator Type:**
+	   - The `std::priority_queue` requires the type of the comparator as its third template argument to define how the elements should be ordered. Since the type of a lambda is unnamed and complex, `decltype` is used to deduce and retrieve this type.
+
+	#### How `decltype` Works Here:
+
+	- **`decltype(comparator)`**:
+	  - `decltype` is used to deduce the exact type of the `comparator` lambda function. This allows `std::priority_queue` to know the type of the comparator it should use.
+
+	- **Initialization**:
+	  - When you initialize the `std::priority_queue`, you need to pass the `comparator` to its constructor so that it knows how to compare the elements.
+	  - Using `decltype(comparator)` allows the `std::priority_queue` to correctly store and use the lambda for comparison.
+
+
+	
+    	
+	using custom struct:
+    	
+	```cpp
+	// Define the cell struct
+	struct cell {
+	    int index;
+	    float cost;
+	};
+
+	// Define a custom comparison functor
+	struct CompareCell {
+	    bool operator()(const cell &a, const cell &b) {
+		return a.cost > b.cost; // Min-heap: smallest cost has highest priority
+	    }
+	};
+	```
+	In your main:
+	- The first parameter is the type of elements stored (cell).
+	- The second parameter is the underlying container type (std::vector<cell>).
+	- The third parameter is the comparison functor (CompareCell).
+	 
+	```cpp
+	  std::priority_queue<cell, std::vector<cell>, CompareCell> pq;
+	```
 
-**Additional notes:**
-* You can use custom comparison functions with `std::partial_sort_copy` to sort elements based on different criteria.
-* For more complex sorting scenarios, consider using `std::stable_partition` or writing custom sorting algorithms.
 
-By understanding `std::partial_sort_copy`, you can effectively handle situations where you need to extract a sorted subset of elements from a larger unsorted collection without modifying the original data.
- 
 
 5. **Binary Search Operations (on sorted ranges):**
    - `std::lower_bound` and `std::upper_bound`: Find bounds in a sorted range.