Even more modernization and snippets

Author: ckormanyos

code_snippets/chapter12/chapter12.sh

@@ -36,9 +36,12 @@ $GCC -std=$STD  -Wall -Wextra -Wpedantic -Werror -O3 -m64 -fsanitize=address -fs
 $GCC -std=$STD  -Wall -Wextra -Wpedantic -Werror -O3 -m64 -fsanitize=address -fsanitize=shift -fsanitize=shift-exponent -fsanitize=shift-base -fsanitize=integer-divide-by-zero -fsanitize=null -fsanitize=signed-integer-overflow -fsanitize=bounds -fsanitize=alignment -fsanitize=float-divide-by-zero -fsanitize=float-cast-overflow -fsanitize=enum ./chapter12_04-004_euler_gamma_approx.cpp    -o ./bin/chapter12_04-004_euler_gamma_approx.exe
 $GCC -std=$STD  -Wall -Wextra -Wpedantic -Werror -O3 -m64 -fsanitize=address -fsanitize=shift -fsanitize=shift-exponent -fsanitize=shift-base -fsanitize=integer-divide-by-zero -fsanitize=null -fsanitize=signed-integer-overflow -fsanitize=bounds -fsanitize=alignment -fsanitize=float-divide-by-zero -fsanitize=float-cast-overflow -fsanitize=enum ./chapter12_05-001_complex.cpp               -o ./bin/chapter12_05-001_complex.exe
 $GCC -std=$STD  -Wall -Wextra -Wpedantic -Werror -O3 -m64 -fsanitize=address -fsanitize=shift -fsanitize=shift-exponent -fsanitize=shift-base -fsanitize=integer-divide-by-zero -fsanitize=null -fsanitize=signed-integer-overflow -fsanitize=bounds -fsanitize=alignment -fsanitize=float-divide-by-zero -fsanitize=float-cast-overflow -fsanitize=enum ./chapter12_05-002_complex.cpp               -o ./bin/chapter12_05-002_complex.exe
-$GCC -std=$STD  -Wall -Wextra -Wpedantic -Werror -O3 -m64 -fsanitize=address -fsanitize=shift -fsanitize=shift-exponent -fsanitize=shift-base -fsanitize=integer-divide-by-zero -fsanitize=null -fsanitize=signed-integer-overflow -fsanitize=bounds -fsanitize=alignment -fsanitize=float-divide-by-zero -fsanitize=float-cast-overflow -fsanitize=enum ./chapter12_05-003_complex_sinc_function.cpp -o ./bin/chapter12_05-003_complex_sinc_function.exe
+$GCC -std=$STD  -Wall -Wextra -Wpedantic -Werror -O3 -m64 -fsanitize=address -fsanitize=shift -fsanitize=shift-exponent -fsanitize=shift-base -fsanitize=integer-divide-by-zero -fsanitize=null -fsanitize=signed-integer-overflow -fsanitize=bounds -fsanitize=alignment -fsanitize=float-divide-by-zero -fsanitize=float-cast-overflow -fsanitize=enum ./chapter12_05-003_complex.cpp               -o ./bin/chapter12_05-003_complex.exe
+$GCC -std=$STD  -Wall -Wextra -Wpedantic -Werror -O3 -m64 -fsanitize=address -fsanitize=shift -fsanitize=shift-exponent -fsanitize=shift-base -fsanitize=integer-divide-by-zero -fsanitize=null -fsanitize=signed-integer-overflow -fsanitize=bounds -fsanitize=alignment -fsanitize=float-divide-by-zero -fsanitize=float-cast-overflow -fsanitize=enum ./chapter12_05-004_complex_sinc_function.cpp -o ./bin/chapter12_05-004_complex_sinc_function.exe
 $GCC -std=$STD  -Wall -Wextra -Wpedantic -Werror -O3 -m64 -fsanitize=address -fsanitize=shift -fsanitize=shift-exponent -fsanitize=shift-base -fsanitize=integer-divide-by-zero -fsanitize=null -fsanitize=signed-integer-overflow -fsanitize=bounds -fsanitize=alignment -fsanitize=float-divide-by-zero -fsanitize=float-cast-overflow -fsanitize=enum ./chapter12_06-001_constexpr_sine.cpp        -o ./bin/chapter12_06-001_constexpr_sine.exe
 $GCC -std=$STD  -Wall -Wextra -Wpedantic -Werror -O3 -m64 -fsanitize=address -fsanitize=shift -fsanitize=shift-exponent -fsanitize=shift-base -fsanitize=integer-divide-by-zero -fsanitize=null -fsanitize=signed-integer-overflow -fsanitize=bounds -fsanitize=alignment -fsanitize=float-divide-by-zero -fsanitize=float-cast-overflow -fsanitize=enum ./chapter12_07-001_derivative.cpp            -o ./bin/chapter12_07-001_derivative.exe
+$GCC -std=$STD  -Wall -Wextra -Wpedantic -Werror -O3 -m64 -fsanitize=address -fsanitize=shift -fsanitize=shift-exponent -fsanitize=shift-base -fsanitize=integer-divide-by-zero -fsanitize=null -fsanitize=signed-integer-overflow -fsanitize=bounds -fsanitize=alignment -fsanitize=float-divide-by-zero -fsanitize=float-cast-overflow -fsanitize=enum ./chapter12_07-002_deriv_quadratic.cpp       -o ./bin/chapter12_07-002_deriv_quadratic.exe
+$GCC -std=$STD  -Wall -Wextra -Wpedantic -Werror -O3 -m64 -fsanitize=address -fsanitize=shift -fsanitize=shift-exponent -fsanitize=shift-base -fsanitize=integer-divide-by-zero -fsanitize=null -fsanitize=signed-integer-overflow -fsanitize=bounds -fsanitize=alignment -fsanitize=float-divide-by-zero -fsanitize=float-cast-overflow -fsanitize=enum ./chapter12_07-003_integral_j2.cpp           -o ./bin/chapter12_07-003_integral_j2.exe
 
 ls -la \
 ./bin/chapter12_01-001_area_of_circle.exe           \
@@ -53,9 +56,12 @@ ls -la \
 ./bin/chapter12_04-004_euler_gamma_approx.exe       \
 ./bin/chapter12_05-001_complex.exe                  \
 ./bin/chapter12_05-002_complex.exe                  \
-./bin/chapter12_05-003_complex_sinc_function.exe    \
+./bin/chapter12_05-003_complex.exe                  \
+./bin/chapter12_05-004_complex_sinc_function.exe    \
 ./bin/chapter12_06-001_constexpr_sine.exe           \
-./bin/chapter12_07-001_derivative.exe
+./bin/chapter12_07-001_derivative.exe               \
+./bin/chapter12_07-002_deriv_quadratic.exe          \
+./bin/chapter12_07-003_integral_j2.exe
 
 result_ls=$?
 

code_snippets/chapter12/chapter12_05-003_complex.cpp

@@ -0,0 +1,38 @@
+///////////////////////////////////////////////////////////////////////////////
+//  Copyright Christopher Kormanyos 2017 - 2025.
+//  Distributed under the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt
+//  or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// chapter12_05-003_complex.cpp
+
+#include <complex>
+#include <iomanip>
+#include <iostream>
+#include <limits>
+#include <sstream>
+
+auto main() -> int;
+
+auto main() -> int
+{
+  std::complex<float> z { }; // (0 + 0 I)
+
+  z.real(1.23F); // Set the real part.
+  z.imag(3.45F); // Set the imag part.
+
+  const float zr { z.real() }; // Get the real part, 1.23.
+  const float zi { z.imag() }; // Get the imag part, 3.45.
+
+  static_cast<void>(zr);
+  static_cast<void>(zi);
+
+  const float nz { std::norm(z) }; // 13.4154
+
+  std::stringstream strm { };
+
+  strm << "nz: " << std::setprecision(std::numeric_limits<float>::digits10) << nz << '\n';
+
+  std::cout << strm.str() << std::endl;
+}

…apter12_05-003_complex_sinc_function.cpp …apter12_05-004_complex_sinc_function.cppcode_snippets/chapter12/chapter12_05-003_complex_sinc_function.cpp renamed to code_snippets/chapter12/chapter12_05-004_complex_sinc_function.cpp code_snippets/chapter12/chapter12_05-003_complex_sinc_function.cpp renamed to code_snippets/chapter12/chapter12_05-004_complex_sinc_function.cpp

@@ -7,7 +7,7 @@
 
 // chapter12_07-001_derivative.cpp
 
-// See also https://godbolt.org/z/cra4qo4ab
+// See also https://godbolt.org/z/baWzcrd1T
 
 #include <cmath>
 #include <iomanip>
@@ -43,10 +43,7 @@ auto derivative(const ValueType x,
   return ((fifteen_m1 - six_m2) + m3) / ten_dx1;
 }
 
-template<typename T>
-constexpr T pi = static_cast<T>(3.1415926535'8979323846'2643383279L);
-
-const auto x = static_cast<float>(pi<float> / static_cast<float>(3.0L));
+const auto x = static_cast<float>(std::numbers::pi_v<float> / static_cast<float>(3.0L));
 
 // Should be very near 0.5.
 const auto y =

code_snippets/chapter12/chapter12_07-001_derivative.cpp

@@ -0,0 +1,92 @@
+///////////////////////////////////////////////////////////////////////////////
+//  Copyright Christopher Kormanyos 2017 - 2025.
+//  Distributed under the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt
+//  or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// chapter12_07-002_deriv_quadratic.cpp
+
+#include <cmath>
+#include <iomanip>
+#include <iostream>
+#include <limits>
+#include <sstream>
+
+template<typename ValueType,
+         typename FunctionType>
+auto derivative(const ValueType x,
+                const ValueType dx,
+                FunctionType function) -> ValueType
+{
+  using value_type = ValueType;
+
+  // Compute the derivative using a three point
+  // central difference rule of O(dx^6).
+
+  const auto dx1 = dx;
+  const auto dx2 = static_cast<value_type>(dx1 * 2);
+  const auto dx3 = static_cast<value_type>(dx1 * 3);
+
+  const auto m1 = static_cast<value_type>((function(x + dx1) - function(x - dx1)) / 2);
+
+  const auto m2 = static_cast<value_type>((function(x + dx2) - function(x - dx2)) / 4);
+
+  const auto m3 = static_cast<value_type>((function(x + dx3) - function(x - dx3)) / 6);
+
+  const auto fifteen_m1 = static_cast<value_type>(15 * m1);
+  const auto six_m2     = static_cast<value_type>( 6 * m2);
+  const auto ten_dx1    = static_cast<value_type>(10 * dx1);
+
+  return ((fifteen_m1 - six_m2) + m3) / ten_dx1;
+}
+
+template<typename T>
+class quadratic
+{
+public:
+  const T a;
+  const T b;
+  const T c;
+
+  quadratic(const T& a_,
+            const T& b_,
+            const T& c_) : a(a_),
+                           b(b_),
+                           c(c_) { }
+
+  auto operator()(const T& x) const -> T
+  {
+    return ((a * x + b) * x) + c;
+  }
+};
+
+const float x { 0.5F };
+
+// Should be very near 4.6.
+const float y =
+  derivative(x,
+             0.01F,
+             quadratic<float>(1.2F, 3.4F, 5.6F));
+
+auto main() -> int;
+
+auto main() -> int
+{
+  std::stringstream strm { };
+
+  // 4.6
+  strm << std::setprecision(std::numeric_limits<float>::digits10) << y << '\n';
+
+  using std::fabs;
+
+  const auto delta = fabs(static_cast<float>(1.0L) - static_cast<float>(y / static_cast<float>(4.6L)));
+
+  const auto result_close_fraction_is_ok = (delta < static_cast<float>(std::numeric_limits<float>::epsilon() * 128));
+
+  strm << "result_close_fraction_is_ok: " << std::boolalpha << result_close_fraction_is_ok << '\n';
+
+  std::cout << strm.str() << std::endl;
+
+  return (result_close_fraction_is_ok ? 0 : -1);
+}

code_snippets/chapter12/chapter12_07-002_deriv_quadratic.cpp

@@ -0,0 +1,109 @@
+///////////////////////////////////////////////////////////////////////////////
+//  Copyright Christopher Kormanyos 2017 - 2025.
+//  Distributed under the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt
+//  or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// chapter12_07-003_integral_j2.cpp
+
+#include <cmath>
+#include <cstdint>
+#include <iomanip>
+#include <iostream>
+#include <limits>
+#include <numbers>
+#include <sstream>
+
+template<typename real_value_type,
+         typename real_function_type>
+auto integral(
+  const real_value_type& a,
+  const real_value_type& b,
+  const real_value_type& tol,
+  real_function_type real_function) -> real_value_type
+{
+  std::uint_fast32_t n2(1);
+
+  real_value_type step = ((b - a) / 2U);
+
+  real_value_type result =
+    (real_function(a) + real_function(b)) * step;
+
+  const std::uint_fast8_t k_max = UINT8_C(32);
+
+  for(std::uint_fast8_t k(0U); k < k_max; ++k)
+  {
+    real_value_type sum(0);
+
+    for(std::uint_fast32_t j(0U); j < n2; ++j)
+    {
+      const std::uint_fast32_t two_j_plus_one =
+        (j * UINT32_C(2)) + UINT32_C(1);
+
+      sum +=
+        real_function(a + (step * two_j_plus_one));
+    }
+
+    const real_value_type tmp = result;
+
+    result = (result / 2U) + (step * sum);
+
+    const real_value_type ratio =
+      std::abs(tmp / result);
+
+    const real_value_type delta = std::abs(ratio - 1U);
+
+    if((k > UINT8_C(1)) && (delta < tol))
+    {
+      break;
+    }
+
+    n2 *= 2U;
+
+    step /= 2U;
+  }
+
+  return result;
+}
+
+template<typename float_type>
+auto cyl_bessel_j(const std::uint_fast8_t n,
+                  const float_type& x) -> float_type
+{
+  constexpr float_type eps
+    { std::numeric_limits<float_type>::epsilon() };
+
+  const float_type tol { std::sqrt(eps) };
+
+  const float_type jn =
+    integral
+    (
+      float_type(0),
+      std::numbers::pi_v<float_type>,
+      tol,
+      [&x,&n](const float_type& t) -> float_type
+      {
+        return std::cos(x * std::sin(t) - (n * t));
+      }
+    )
+    / std::numbers::pi_v<float_type>;
+
+  return jn;
+}
+
+auto main() -> int;
+
+auto main() -> int
+{
+  const float j2 { cyl_bessel_j(UINT8_C(2), 1.23F) };
+
+  // Computed result: 0.166369
+  // Known value:     0.1663693837...
+
+  std::stringstream strm { };
+
+  strm << "j2: " << std::setprecision(std::numeric_limits<float>::digits10) << j2 << '\n';
+
+  std::cout << strm.str() << std::endl;
+}

code_snippets/chapter12/chapter12_07-003_integral_j2.cpp

@@ -6,10 +6,10 @@ This folder contains the code snippets for Chapter 12.
 ## Try it at _godbolt_
 
 <p align="center">
-    <a href="https://godbolt.org/z/cra4qo4ab" alt="godbolt">
+    <a href="https://godbolt.org/z/baWzcrd1T" alt="godbolt">
         <img src="https://img.shields.io/badge/try%20it%20on-godbolt-green" /></a>
 </p>
 
 Try the [`chapter12_07-001_derivative.cpp`](./chapter12_07-001_derivative.cpp)
 program at this
-[short link](https://godbolt.org/z/cra4qo4ab) to [godbolt](https://godbolt.org/).
+[short link](https://godbolt.org/z/baWzcrd1T) to [godbolt](https://godbolt.org/).