update doc, add exampels to build (#20)

Co-authored-by: Artur Bać <artur@ebasoft.com.pl>

Author: arturbac

docs/index.md

@@ -42,6 +42,11 @@ See [documentation of division](division.md) for more details.
 - `auto operator /(supported_type1 lh, supported_type2 rh) noexcept`: Operator overload for division.
 - `fixed_t & operator /=(fixed_t &lh, supported_type rh) noexcept`: Division assignment.
 
+### Modulo
+
+- `auto operator %(supported_type1 lh, supported_type2 rh) noexcept`: Operator overload for modulo.
+- `fixed_t & operator %=(fixed_t &lh, supported_type rh) noexcept`: modulo assignment.
+
 ## Bitwise Operations
 
 See [documentation of bitwise operations](bitwise_operations.md) for more details.
@@ -75,6 +80,12 @@ See [documentation of conversion between fixed and arithmetic types](conversion_
 - `fixed_t angle_to_radians(integral_type angle) noexcept`: Converts angle 0 - 360 to radians.
 - `fixed_t sqrt(fixed_t value) noexcept`: Returns the square root of `value`.
 - `fixed_t hypot(fixed_t lh, fixed_t rh) noexcept`: Returns the hypotenuse of `lh` and `rh`.
+- `fixed_t fmod(fixed_t value) noexcept`: Returns the modulo of `value`.
+- `from_string(std::string_view str) noexcept` : Returns `std::optional<fixed_t>` defined in `fixedmath/fixed_string.h`
+- `to_string(fixed_t value, int precision) noexcept` : Returns `std::string` representation of fixed value defined in `fixedmath/fixed_string.h`
+- `std::formatter<fixedmath::fixed_t>` defined in `fixedmath/std_formatter.h`
+- `operator<<(std::ostream & outstr, fixed_t src)` defined in `fixedmath/iostream.h`
+- `operator>>(std::istream & instr, fixed_t & dst)` defined in `fixedmath/iostream.h`
 
 ## FixedMath Applications and Use Cases
 

examples/CMakeLists.txt

@@ -2,3 +2,11 @@ add_executable(brief-usage EXCLUDE_FROM_ALL)
 target_sources(brief-usage PRIVATE brief-usage.cc)
 target_link_libraries(brief-usage PRIVATE fixed_math )
 
+add_executable(iostream EXCLUDE_FROM_ALL)
+target_sources(iostream PRIVATE iostream.cc)
+target_link_libraries(iostream PRIVATE fixed_math )
+
+add_executable(string_conversion EXCLUDE_FROM_ALL)
+target_sources(string_conversion PRIVATE string_conversion.cc)
+target_link_libraries(string_conversion PRIVATE fixed_math )
+

examples/iostream_example.cpp renamed to examples/iostream.cc

@@ -5,24 +5,24 @@
 #include <iomanip>
 #include <vector>
 
-int main() 
-{
+int main()
+  {
   using namespace fixedmath;
-  
+
   std::cout << "Fixed Math I/O Stream Example" << std::endl;
   std::cout << "==============================" << std::endl;
-  
+
   // Output stream examples
   std::cout << "\n1. Output Stream Examples:" << std::endl;
-  
+
   // Create some fixed_t values
   fixed_t pi = fixed_t{3.14159265};
   fixed_t negative = fixed_t{-42.5};
   fixed_t large = fixed_t{123456.789};
   fixed_t small = fixed_t{0.000125};
   fixed_t zero = fixed_t{0};
   fixed_t nan = quiet_NaN_result();
-  
+
   // Output with different precision settings
   std::cout << "Default precision:" << std::endl;
   std::cout << "  Pi: " << pi << std::endl;
@@ -31,68 +31,62 @@ int main()
   std::cout << "  Small: " << small << std::endl;
   std::cout << "  Zero: " << zero << std::endl;
   std::cout << "  NaN: " << nan << std::endl;
-  
+
   // Set different precision
   std::cout << "\nPrecision 2:" << std::endl;
   std::cout << std::setprecision(2);
   std::cout << "  Pi: " << pi << std::endl;
   std::cout << "  Negative: " << negative << std::endl;
   std::cout << "  Large: " << large << std::endl;
-  
+
   std::cout << "\nPrecision 10:" << std::endl;
   std::cout << std::setprecision(10);
   std::cout << "  Pi: " << pi << std::endl;
   std::cout << "  Small: " << small << std::endl;
-  
+
   // Input stream examples
   std::cout << "\n2. Input Stream Examples:" << std::endl;
-  
+
   // Use string streams for testing, simulating user input
-  const std::vector<std::string> test_inputs = {
-    "3.14159",
-    "-42.5",
-    "0",
-    "123.456",
-    "NaN",
-    "nan",
-    "invalid"
-  };
-  
-  for (const auto& input : test_inputs) {
+  std::vector<std::string> const test_inputs = {"3.14159", "-42.5", "0", "123.456", "NaN", "nan", "invalid"};
+
+  for(auto const & input: test_inputs)
+    {
     std::istringstream iss(input);
     fixed_t value;
-    
+
     std::cout << "Parsing \"" << input << "\": ";
-    if (iss >> value) {
+    if(iss >> value)
       std::cout << "Success, value: " << value << std::endl;
-    } else {
+    else
       std::cout << "Failed to parse" << std::endl;
     }
-  }
-  
+
   // User input example
   std::cout << "\n3. User Input Example:" << std::endl;
   std::cout << "Enter a fixed point number (or NaN): ";
-  
+
   fixed_t user_input;
-  if (std::cin >> user_input) {
+  if(std::cin >> user_input)
+    {
     std::cout << "You entered: " << user_input << std::endl;
-    
+
     // Demonstrate some operations
     std::cout << "Double: " << (user_input * 2) << std::endl;
     std::cout << "Square: " << (user_input * user_input) << std::endl;
-    
+
     // Check if it's NaN
-    if (fobj::isnan(user_input)) {
+    if(fobj::isnan(user_input))
       std::cout << "The value is NaN" << std::endl;
     }
-  } else {
+  else
+    {
     std::cout << "Invalid input" << std::endl;
     // Clear error state
     std::cin.clear();
     // Ignore remainder of the line
     std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
-  }
-  
+    }
+
   return 0;
-} 
+  }

examples/string_conversion_example.cpp renamed to examples/string_conversion.cc

@@ -4,82 +4,83 @@
 #include <string>
 #include <iomanip>
 
-int main() 
-{
+int main()
+  {
   using namespace fixedmath;
-  
+
   std::cout << "Fixed Math String Conversion Example (Pure Integer Implementation)" << std::endl;
   std::cout << "=============================================================" << std::endl;
-  
+
   // Convert string to fixed_t
   std::string input = "3.99994";
   auto fixed_pi = from_string(input);
-  
-  if (fixed_pi) {
+
+  if(fixed_pi)
+    {
     std::cout << "Converted string \"" << input << "\" to fixed_t: " << *fixed_pi << std::endl;
-    
+
     // Perform some operations
     auto doubled = *fixed_pi * 2;
     std::cout << "Doubled value: " << doubled << std::endl;
-    
+
     // Convert back to string with different precisions
     std::cout << "String representations with different precisions:" << std::endl;
     std::cout << "  2 digits: " << to_string(*fixed_pi, 2) << std::endl;
     std::cout << "  4 digits: " << to_string(*fixed_pi, 4) << std::endl;
     std::cout << "  6 digits: " << to_string(*fixed_pi, 6) << std::endl;
-  } else {
+    }
+  else
+    {
     std::cout << "Failed to convert \"" << input << "\" to fixed_t" << std::endl;
-  }
-  
+    }
+
   std::cout << "\nExact Fraction Representation:" << std::endl;
-  
+
   // Test exact binary fractions
   fixed_t binary_fractions[] = {
-    fixed_t{0.5},      // 1/2
-    fixed_t{0.25},     // 1/4
-    fixed_t{0.125},    // 1/8
-    fixed_t{0.0625},   // 1/16
+    fixed_t{0.5},                 // 1/2
+    fixed_t{0.25},                // 1/4
+    fixed_t{0.125},               // 1/8
+    fixed_t{0.0625},              // 1/16
     fixed_t{0.0000152587890625},  // 1/65536
   };
-  
-  for (const auto& value : binary_fractions) {
-    std::cout << "  Value: " << std::setw(10) << value 
-              << " | String: " << std::setw(10) << to_string(value, 20) << std::endl;
-  }
-  
+
+  for(auto const & value: binary_fractions)
+    std::cout << "  Value: " << std::setw(10) << value << " | String: " << std::setw(10) << to_string(value, 20)
+              << std::endl;
+
   std::cout << "\nDisadvantaged Decimal Fractions:" << std::endl;
-  
+
   // Test decimal fractions that don't have exact binary representations
   fixed_t decimal_fractions[] = {
     fixed_t{0.1},      // 1/10
     fixed_t{0.01},     // 1/100
     fixed_t{0.001},    // 1/1000
     fixed_t{0.33333},  // ~1/3
   };
-  
-  for (const auto& value : decimal_fractions) {
-    std::cout << "  Value: " << std::setw(10) << value 
-              << " | String: " << std::setw(10) << to_string(value, 6) << std::endl;
-  }
-  
+
+  for(auto const & value: decimal_fractions)
+    std::cout << "  Value: " << std::setw(10) << value << " | String: " << std::setw(10) << to_string(value, 6)
+              << std::endl;
+
   std::cout << "\nEdge Cases:" << std::endl;
-  
+
   // Test some invalid inputs
   auto invalid = from_string("not a number");
   std::cout << "  Conversion of \"not a number\": " << (invalid ? "succeeded" : "failed") << std::endl;
-  
+
   // Test various values
   fixed_t large_number{12345.6789};
   std::cout << "  Large number: " << to_string(large_number) << std::endl;
-  
+
   fixed_t negative{-42.5};
   std::cout << "  Negative number: " << to_string(negative) << std::endl;
-  
+
   fixed_t zero{0};
   std::cout << "  Zero: " << to_string(zero) << std::endl;
-  
+
   auto nan_value = quiet_NaN_result();
   std::cout << "  NaN value: " << to_string(nan_value) << std::endl;
-  
+
   return 0;
-} 
+  }