Merge branch 'develop' of https://github.com/XuhuaHuang/EmbeddedProgramming into develop

Author: XuhuaHuang

CMakeLists.txt

@@ -41,4 +41,4 @@ add_subdirectory("VariadicTemplateParameter")
 add_subdirectory("Vector")
 add_subdirectory("View")
 add_subdirectory("VirtualPointer")
-add_subdirectory("WriteAccessStructralBinding")
+add_subdirectory("WriteAccessStructuralBinding")

Util/type_name.hh

@@ -0,0 +1,40 @@
+/**
+ * @file type_name.hh
+ * @author Xuhua Huang
+ * @brief
+ * @version 0.1
+ * @date 2025-09-23
+ *
+ * @copyright Copyright (c) 2025
+ *
+ */
+
+#ifndef TYPE_NAME_HH
+#define TYPE_NAME_HH
+
+#include <string_view>
+
+namespace util {
+namespace type {
+
+template <typename T> constexpr std::string_view type_name() {
+#if defined(__clang__)
+  std::string_view p = __PRETTY_FUNCTION__;
+  return p.substr(p.find('=') + 2, p.rfind(']') - p.find('=') - 2);
+#elif defined(__GNUC__)
+  std::string_view p = __PRETTY_FUNCTION__;
+  return p.substr(p.find('=') + 2, p.rfind(']') - p.find('=') - 2);
+#elif defined(_MSC_VER)
+  std::string_view p = __FUNCSIG__;
+  auto start = p.find("type_name<") + 10;
+  auto end = p.find(">(void)");
+  return p.substr(start, end - start);
+#else
+#error "Unsupported compiler"
+#endif
+}
+
+} // namespace type
+} // namespace util
+
+#endif //! TYPE_NAME_HH

ValArray/valarray_notes.cpp

@@ -15,111 +15,138 @@
  *
  */
 
-#include <algorithm>
 #include <cassert>
-#include <concepts>
+#include <cstdint>
 #include <iostream>
-#include <limits>
+#include <memory>
 #include <span>
+#include <string>
 #include <type_traits>
+#include <typeinfo>
 #include <valarray>
 
+#if defined(__GNUC__)
+#include <cxxabi.h>
+
+template <typename T> [[nodiscard]] std::string type_name() {
+  int status = 0;
+  std::unique_ptr<char, void (*)(void *)> res{
+      abi::__cxa_demangle(typeid(T).name(), nullptr, nullptr, &status),
+      std::free};
+  return (status == 0) ? res.get() : typeid(T).name();
+}
+#endif
+
 #ifndef log
 #define log std::cout << __LINE__ << ": " << std::boolalpha
 #endif
 
 template <typename T>
-    requires std::is_arithmetic_v<T> && (!std::is_pointer_v<T>) && (!std::is_reference_v<T>)
-inline std::ostream& operator<<(std::ostream& os, const std::valarray<T>& values) noexcept {
-    os << "[";
-    if (values.size() >= 1) [[likely]] {
-        for (const T* it = std::begin(values); it < std::end(values) - 1; it++) {
-            os << *it << ", ";
-        }
-        os << values[values.size() - 1];
+  requires std::is_arithmetic_v<T> && (!std::is_pointer_v<T>) &&
+           (!std::is_reference_v<T>)
+inline std::ostream &operator<<(std::ostream &os,
+                                const std::valarray<T> &values) noexcept {
+  os << "[";
+  if (values.size() >= 1) [[likely]] {
+    for (const T *it = std::begin(values); it < std::end(values) - 1; it++) {
+      os << *it << ", ";
     }
-    os << "]";
-    return os;
+    os << values[values.size() - 1];
+  }
+  os << "]";
+  return os;
 }
 
 template <>
-inline std::ostream& operator<<(std::ostream& os, const std::valarray<std::uint8_t>& values) noexcept = delete;
+inline std::ostream &
+operator<<(std::ostream &os,
+           const std::valarray<std::uint8_t> &values) noexcept = delete;
 
 int main() {
-    static_assert(std::is_arithmetic_v<std::uint8_t>);
-
-    // log << std::is_arithmetic_v<std::uint8_t> << "\n";
-    // log << std::numeric_limits<std::uint16_t>::min() << "\n";
-    // log << std::numeric_limits<std::uint16_t>::max() << "\n";
-
-    // create an empty valarray
-    std::valarray<float_t> val;
-    log << val << "\n";
-    log << val.size() << "\n";
-    val.resize(1);
-    val[0] = 3.14;
-    log << val << "\n";
-
-    val.resize(2);
-    val[1] = 2.71;
-    log << val << "\n";
-
-    // create a valarray of size 5, initialized with values 0, 1, 2, 3, 4
-    std::valarray<int> v{0, 1, 2, 3, 4};
-
-    // print the elements of the valarray
-    log << v << "\n";
-
-    // apply a function to each element of the valarray
-    auto f  = [](int x) { return x * x; };
-    auto v2 = std::valarray<int>(v.apply(f));
-
-    log << v2 << "\n";
-
-    // perform mathematical operations on the valarray
-    std::valarray v3 = v + v2;
-    log << "v3 is of type std::valarray<int>: " << std::is_same_v<decltype(v3), std::valarray<int>> << "\n";
-    log << v3 << "\n";
-
-    auto v4 = v3.apply([](int x) { return x / 2; });
-    log << "v4 is of type std::valarray<int>: " << std::is_same_v<decltype(v4), std::valarray<int>> << "\n";
-    log << v4 << "\n";
-
-    // increment the value in v
-    v += 1;
-    log << v << "\n";
-
-    // compute the sum of the valarray
-    int sum = v.sum();
-    log << "sum of v: " << sum << "\n";
-
-    // compute the square of each element of the valarray
-    std::valarray<int> v_squared = v * v;
-    log << v_squared << "\n";
-
-    // compute the dot product of v and v_squared
-    int dot_product = (v * v_squared).sum();
-    log << "dot product of v and v_squared: " << dot_product << "\n";
-
-    v = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
-    log << v << "\n";
-
-    // create a slice with start index 2, length 3, and stride 2
-    // s[2] = 3
-    // s[2 + 2] == s[4] = 5
-    // s[2 + 2 + 2] == s[6] = 7
-    std::slice s{2, 3, 2};
-    log << typeid(s).name() << "\n"; // class std::slice
-
-    // use the slice to create a new valarray
-    std::valarray<int> result = v[s];
-    // print the new valarray
-    log << result << "\n";
-
-    // change the value of the original valarray
-    v[s] = 0;
-    // print the original valarray
-    log << v << "\n";
-
-    return 0;
+  static_assert(std::is_arithmetic_v<std::uint8_t>);
+
+  // log << std::is_arithmetic_v<std::uint8_t> << "\n";
+  // log << std::numeric_limits<std::uint16_t>::min() << "\n";
+  // log << std::numeric_limits<std::uint16_t>::max() << "\n";
+
+  // create an empty valarray
+  std::valarray<float_t> val;
+  log << val << "\n";
+  log << val.size() << "\n";
+  val.resize(1);
+  val[0] = 3.14F;
+  log << val << "\n";
+
+  val.resize(2);
+  val[1] = 2.71F;
+  log << val << "\n";
+
+  // create a valarray of size 5, initialized with values 0, 1, 2, 3, 4
+  std::valarray<int> v{0, 1, 2, 3, 4};
+
+  // print the elements of the valarray
+  log << v << "\n";
+
+  // apply a function to each element of the valarray
+  auto f = [](int x) -> int { return x * x; };
+  std::valarray v2 = std::valarray<int>(v.apply(f));
+
+  log << v2 << "\n";
+
+  // perform mathematical operations on the valarray
+  std::valarray v3 = v + v2;
+  log << "v3 is of type std::valarray<int>: "
+      << std::is_same_v<decltype(v3), std::valarray<int>> << "\n";
+  log << v3 << "\n";
+
+  auto v4 = v3.apply([](int x) -> int { return x / 2; });
+  log << "v4 is of type std::valarray<int>: "
+      << std::is_same_v<decltype(v4), std::valarray<int>> << "\n";
+  log << typeid(v4).name() << "\n"; // class std::valarray<int>
+#if defined(__GNUC__)
+  log << type_name<decltype(v4)>() << "\n";
+#elif defined(_MSC_VER)
+  log << v4 << "\n";
+#endif
+
+  // increment the value in v
+  v += 1;
+  log << v << "\n";
+
+  // compute the sum of the valarray
+  int sum = v.sum();
+  log << "sum of v: " << sum << "\n";
+
+  // compute the square of each element of the valarray
+  std::valarray<int> v_squared = v * v;
+  log << v_squared << "\n";
+
+  // compute the dot product of v and v_squared
+  int dot_product = (v * v_squared).sum();
+  log << "dot product of v and v_squared: " << dot_product << "\n";
+
+  v = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+  log << v << "\n";
+
+  // create a slice with start index 2, length 3, and stride 2
+  // s[2] = 3
+  // s[2 + 2] == s[4] = 5
+  // s[2 + 2 + 2] == s[6] = 7
+  std::slice s{2, 3, 2};
+  log << typeid(s).name() << "\n"; // class std::slice
+#if defined(__GNUC__)
+  log << type_name<decltype(s)>() << "\n";
+#endif
+
+  // use the slice to create a new valarray
+  std::valarray<int> result = v[s];
+  // print the new valarray
+  log << result << "\n";
+
+  // change the value of the original valarray
+  v[s] = 0;
+  // print the original valarray
+  log << v << "\n";
+
+  return 0;
 }