Merge pull request #8 from SteveBronder/feature/logger

Adds a logger for the c++ and python code

Author: SteveBronder

CMakeLists.txt

@@ -158,7 +158,7 @@ if (RICCATI_BUILD_PYTHON)
     target_link_libraries(pyriccaticpp PRIVATE pybind11::headers riccati Eigen3::Eigen)
 
     # This is passing in the version as a define just as an example
-    target_compile_definitions(pyriccaticpp PRIVATE VERSION_INFO=${PROJECT_VERSION})
+    target_compile_definitions(pyriccaticpp PRIVATE VERSION_INFO=${PROJECT_VERSION} RICCATI_PYTHON)
     if (NOT CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
         target_compile_options(pyriccaticpp PRIVATE -Wno-deprecated-declarations)
     endif()

include/riccati/chebyshev.hpp

@@ -2,6 +2,7 @@
 #define INCLUDE_RICCATI_CHEBYSHEV_HPP
 
 #include <riccati/arena_matrix.hpp>
+#include <riccati/logger.hpp>
 #include <riccati/memory.hpp>
 #include <riccati/utils.hpp>
 #include <unsupported/Eigen/FFT>

include/riccati/evolve.hpp

@@ -310,6 +310,8 @@ inline auto nonosc_evolve(SolverInfo &&info, Scalar xi, Scalar xf,
  * equations.
  * 6. @ref Eigen::Matrix<std::complex<Scalar>, -1, 1>: A vector containing the
  * interpolated solution at the specified `x_eval` The function returns these
+ * 7. An array of logging information for the solver process. This can be added with the
+ *  info() from the `SolverInfo` object to get the total log information.
  * vectors encapsulated in a standard tuple, providing comprehensive information
  * about the solution process, including where the solution was evaluated, the
  * values and derivatives of the solution at those points, success status of
@@ -319,15 +321,16 @@ template <typename SolverInfo, typename Scalar, typename Vec>
 inline auto evolve(SolverInfo &info, Scalar xi, Scalar xf,
                    std::complex<Scalar> yi, std::complex<Scalar> dyi,
                    Scalar eps, Scalar epsilon_h, Scalar init_stepsize,
-                   Vec &&x_eval, bool hard_stop = false) {
+                   Vec &&x_eval, bool hard_stop = false,
+                   LogLevel log_level = riccati::LogLevel::ERROR) {
   static_assert(std::is_floating_point<Scalar>::value,
                 "Scalar type must be a floating-point type.");
   using vectord_t = vector_t<Scalar>;
   Scalar direction = init_stepsize > 0 ? 1 : -1;
   if (init_stepsize * (xf - xi) < 0) {
     throw std::domain_error(
         "Direction of integration does not match stepsize sign,"
-        " adjusting it so that integration happens from xi to xf.");
+        " adjust the direction or stepsize so that integration happens from xi to xf.");
   }
   // Check that yeval and x_eval are right size
   constexpr bool dense_output = compile_size_v<Vec> != 0;
@@ -436,9 +439,9 @@ inline auto evolve(SolverInfo &info, Scalar xi, Scalar xf,
   matrixc_t y_eval;
   matrixc_t dy_eval;
   std::pair<complex_t, complex_t> a_pair;
+  std::array<std::pair<LogInfo, std::size_t>, 5> solver_counts = info.info();
   while (std::abs(xcurrent - xf) > Scalar(1e-8)
          && direction * xcurrent < direction * xf) {
-//    std::cout << "t = " << xcurrent << std::endl;
     Scalar phase{0.0};
     bool success = false;
     bool steptype = true;
@@ -447,7 +450,6 @@ inline auto evolve(SolverInfo &info, Scalar xi, Scalar xf,
     arena_matrix<vectorc_t> un(info.alloc_, omega_n.size(), 1);
     arena_matrix<vectorc_t> d_un(info.alloc_, omega_n.size(), 1);
     if (direction * hosc > direction * hslo){
-//        && (direction * hosc * wnext / (2.0 * pi<Scalar>()) > 1.0)) {
       if (hard_stop) {
         if (direction * (xcurrent + hosc) > direction * xf) {
           hosc = xf - xcurrent;
@@ -463,13 +465,27 @@ inline auto evolve(SolverInfo &info, Scalar xi, Scalar xf,
       std::tie(success, y, dy, err, phase, un, d_un, a_pair)
           = osc_step<dense_output>(info, omega_n, gamma_n, xcurrent, hosc,
                                    yprev, dyprev, eps);
-//      std::cout << "Attempted osc step with hosc = " << hosc << ", successful? " << success << std::endl;
       steptype = 1;
+      solver_counts[get_idx(LogInfo::RICCSTEP)].second++;
+    }
+    if (unlikely(log_level == LogLevel::INFO && !success)) {
+      info.logger().template log<LogLevel::INFO>(
+        std::string("[Non-oscillatory step][x = ") +
+        std::to_string(xcurrent) + std::string("][stepsize =") +
+        std::to_string(hslo) + std::string("]")
+      );
+    } else if (unlikely(log_level == LogLevel::INFO)) {
+      info.logger().template log<LogLevel::INFO>(
+        std::string("[Oscillatory step][x = ") +
+        std::to_string(xcurrent) + std::string("][stepsize =") +
+        std::to_string(hslo) + std::string("]")
+      );
     }
     while (!success) {
       std::tie(success, y, dy, err, y_eval, dy_eval, cheb_N)
           = nonosc_step(info, xcurrent, hslo, yprev, dyprev, eps);
-//      std::cout << "Attempted nonosc step with hslo = " << hslo << ", successful? " << success << std::endl;
+      solver_counts[get_idx(LogInfo::CHEBSTEP)].second++;
+      solver_counts[get_idx(LogInfo::LS)].second += cheb_N + 1;
       steptype = 0;
       if (!success) {
         hslo *= Scalar{0.5};
@@ -487,6 +503,13 @@ inline auto evolve(SolverInfo &info, Scalar xi, Scalar xf,
       std::tie(dense_start, dense_size)
           = get_slice(x_eval, xcurrent, (xcurrent + h));
       if (dense_size != 0) {
+        if (unlikely(log_level == LogLevel::INFO)) {
+          info.logger().template log<LogLevel::INFO>(
+            std::string("[Dense output][x_start = ") +
+            std::to_string(xcurrent) + std::string("][x_end =") +
+            std::to_string(xcurrent + h) + std::string("]")
+          );
+        }
         auto x_eval_map
             = Eigen::Map<vectord_t>(x_eval.data() + dense_start, dense_size);
         auto y_eval_map
@@ -564,11 +587,29 @@ inline auto evolve(SolverInfo &info, Scalar xi, Scalar xf,
     }
     info.alloc_.recover_memory();
   }
-  #ifdef RICCATI_DEBUG
-  std::cout << "Total riccati steps: " << successes.size() << std::endl;
-  #endif
+  if constexpr (!std::is_same_v<std::decay_t<decltype(info.logger())>, EmptyLogger>) {
+    if (unlikely(log_level == LogLevel::INFO)) {
+      std::size_t riccati_steps = 0;
+      std::size_t rk_steps = 0;
+      for (auto& success : successes) {
+        if (success) {
+          riccati_steps++;
+        } else {
+          rk_steps++;
+        }
+      }
+      info.logger().template log<LogLevel::INFO>(
+        std::string("Total Steps = ") + std::to_string(successes.size())
+      );
+      for (auto&& info_pair : solver_counts) {
+        info.logger().template log<LogLevel::INFO>(
+          std::string(to_string(info_pair.first)) + " = " + std::to_string(info_pair.second)
+        );
+      }
+    }
+  }
   return std::make_tuple(xs, ys, dys, successes, phases, steptypes, yeval,
-                         dyeval);
+                        dyeval, 1.0);
 }
 
 }  // namespace riccati

include/riccati/logger.hpp

@@ -0,0 +1,222 @@
+#ifndef INCLUDE_RICCATI_LOGGER_HPP
+#define INCLUDE_RICCATI_LOGGER_HPP
+
+#include <riccati/macros.hpp>
+#include <riccati/utils.hpp>
+#include <ctime>
+#include <fstream>
+#include <iomanip>
+#include <iostream>
+#include <memory>
+#include <sstream>
+#include <array>
+#include <utility>
+#include <stdexcept>
+
+namespace riccati {
+
+/**
+ * @brief Enumeration of different log levels for logging.
+ */
+enum class LogLevel {
+  ERROR,    // Error messages.
+  WARNING,  // Warning messages.
+  INFO,     // General information messages.
+  DEBUG,    // Detailed debug information.
+};
+
+/**
+ * @brief Enumeration of different logging information keys.
+ */
+enum class LogInfo {
+  CHEBNODES,  // Chebyshev nodes.
+  CHEBSTEP,   // Chebyshev steps.
+  CHEBITS,    // Chebyshev iterates.
+  LS,         // Linear system solves.
+  RICCSTEP    // Riccati steps.
+};
+
+/**
+ * @brief Converts a LogInfo enum value to its string representation.
+ *
+ * @param log_info The LogInfo enum value to convert.
+ * @return The string representation of the LogInfo value.
+ */
+inline constexpr auto to_string(const LogInfo& log_info) noexcept {
+  if (log_info == LogInfo::CHEBNODES) {
+    return "chebyshev_nodes";
+  } else if (log_info == LogInfo::CHEBSTEP) {
+    return "chebyshev_steps";
+  } else if (log_info == LogInfo::CHEBITS) {
+    return "chebyshev_iterates";
+  } else if (log_info == LogInfo::LS) {
+    return "linear_system_solves";
+  } else if (log_info == LogInfo::RICCSTEP) {
+    return "riccati_steps";
+  } else {
+    return "UNKNOWN_INFO";
+  }
+}
+/**
+ * @brief Get the index value for the log info in the default logger
+ */
+inline constexpr auto get_idx(const LogInfo& log_info) {
+  if (log_info == LogInfo::CHEBNODES) {
+    return 0;
+  } else if (log_info == LogInfo::CHEBSTEP) {
+    return 1;
+  } else if (log_info == LogInfo::CHEBITS) {
+    return 2;
+  } else if (log_info == LogInfo::LS) {
+    return 3;
+  } else if (log_info == LogInfo::RICCSTEP) {
+    return 4;
+  } else {
+    throw std::invalid_argument("Invalid LogInfo key!");
+    return 0;
+  }
+}
+
+/**
+ * @brief Retrieves the string representation of a LogLevel value.
+ *
+ * @tparam Level The LogLevel value.
+ * @return The string representation of the LogLevel.
+ */
+template <LogLevel Level>
+inline constexpr auto log_level() noexcept {
+  if constexpr (Level == LogLevel::DEBUG) {
+    return "[DEBUG]";
+  } else if constexpr (Level == LogLevel::INFO) {
+    return "[INFO]";
+  } else if constexpr (Level == LogLevel::WARNING) {
+    return "[WARNING]";
+  } else if constexpr (Level == LogLevel::ERROR) {
+    return "[ERROR]";
+  } else {
+    static_assert(1, "Invalid LogLevel!");
+  }
+}
+
+/**
+ * @brief Base class template for loggers.
+ *
+ * This class provides a common interface for logging and updating log
+ * information. All loggers in Riccati should inherit from this logger
+ * using the CRTP form `class Logger : public LoggerBase<Derived>`.
+ * See \ref `riccati::DefaultLogger` for an example.
+ *
+ * @tparam Derived The derived logger class.
+ */
+template <typename Derived>
+class LoggerBase {
+  inline Derived& underlying() noexcept { return static_cast<Derived&>(*this); }
+  inline Derived const& underlying() const noexcept {
+    return static_cast<Derived const&>(*this);
+  }
+
+ public:
+  /**
+   * @brief Logs a message with a specified log level.
+   *
+   * @tparam Level The log level.
+   * @tparam Types Variadic template parameter pack for message arguments.
+   * @param arg Message arguments to log.
+   */
+  template <LogLevel Level, typename... Types>
+  inline void log(Types&&... args) {
+    this->underlying().template log<Level>(std::forward<Types>(args)...);
+  }
+};
+
+/**
+ * @brief A deleter that performs no operation.
+ *
+ * This is used with smart pointers where no deletion is required.
+ */
+struct deleter_noop {
+  /**
+   * @brief No-op function call operator.
+   *
+   * @tparam T The type of the pointer.
+   * @param arg The pointer to which the deleter is applied.
+   */
+  template <typename T>
+  constexpr void operator()(T* arg) const {}
+};
+
+/**
+ * A logger class where all the operations are noops
+ */
+class EmptyLogger : public LoggerBase<EmptyLogger> {
+ public:
+  template <LogLevel Level, typename... Types>
+  inline constexpr void log(Types&&... args) const noexcept {}
+};
+
+/**
+ * @brief A simple logger class template.
+ *
+ * This class provides basic logging functionality with customizable output
+ * streams.
+ *
+ * @tparam Stream The type of the output stream.
+ * @tparam StreamDeleter The deleter type for the output stream.
+ */
+template <typename Ptr>
+class PtrLogger : public LoggerBase<PtrLogger<Ptr>> {
+ public:
+  /**
+   * @brief The output stream for logging messages.
+   */
+  Ptr output_{};
+
+  /**
+   * @brief Default constructor.
+   */
+  PtrLogger() = default;
+
+  /**
+   * @brief Constructor with a custom output stream.
+   *
+   * @param output The output stream to use for logging.
+   */
+  template <typename Stream, typename StreamDeleter>
+  RICCATI_NO_INLINE explicit PtrLogger(
+      std::unique_ptr<Stream, StreamDeleter>&& output)
+      : output_(std::move(output)) {}
+  template <typename Stream>
+  RICCATI_NO_INLINE explicit PtrLogger(const std::shared_ptr<Stream>& output)
+      : output_(output) {}
+
+  /**
+   * @brief Logs a message with a specified log level.
+   *
+   * @tparam Level The log level.
+   * @param msg The message to log.
+   */
+  template <LogLevel Level>
+  inline void log(std::string_view msg) {
+#ifdef RICCATI_DEBUG
+#define RICCATI_DEBUG_VAL true
+#else
+#define RICCATI_DEBUG_VAL false
+#endif
+    if constexpr (!RICCATI_DEBUG_VAL && Level == LogLevel::DEBUG) {
+      return;
+    }
+    std::string full_msg = log_level<Level>() + time_mi() + "[";
+    full_msg += msg;
+    full_msg += std::string("]");
+    *output_ << full_msg + "\n";
+  }
+};
+
+template <typename Stream, typename StreamDeleter = std::default_delete<Stream>>
+using DefaultLogger = PtrLogger<std::unique_ptr<Stream, StreamDeleter>>;
+template <typename Stream>
+using SharedLogger = PtrLogger<std::shared_ptr<Stream>>;
+
+}  // namespace riccati
+
+#endif

include/riccati/memory.hpp

@@ -322,6 +322,12 @@ struct arena_allocator {
   template <typename U, typename UArena>
   RICCATI_NO_INLINE arena_allocator(const arena_allocator<U, UArena>& rhs)
       : alloc_(rhs.alloc_), owns_alloc_(false) {}
+  template <typename U, typename UArena>
+  RICCATI_NO_INLINE arena_allocator(arena_allocator&& rhs)
+      : alloc_(rhs.alloc_), owns_alloc_(rhs.owns_alloc_ ? true : false) {
+        rhs.alloc_ = nullptr;
+        rhs.owns_alloc_ = false;
+      }
 
   ~arena_allocator() {
     if (owns_alloc_) {