diff --git a/Interpolation.hpp b/Interpolation.hpp
index f8ca311..c3e3fad 100644
--- a/Interpolation.hpp
+++ b/Interpolation.hpp
@@ -1,26 +1,120 @@
 
+/**
+ * @file Interpolation.hpp
+ * @brief Provides various interpolation methods, including linear, cubic Hermite, cubic Lagrange, and cubic B-spline interpolations.
+ *
+ * This file defines template structures and methods for performing different types of interpolation.
+ * Each interpolation method allows for smooth estimation of values between known data points
+ * using specific mathematical techniques:
+ * - Linear interpolation computes values by connecting points with straight lines.
+ * - Cubic Hermite interpolation provides smooth results with continuous first derivatives.
+ * - Cubic Lagrange interpolation uses Lagrange polynomials to approximate values between points.
+ * - Cubic B-spline interpolation uses B-spline basis functions to ensure smooth curves with continuity in function values and derivatives.
+ *
+ * The templates are designed to be flexible and accept various data types for interpolation, such as float or double.
+ */
+
 #ifndef INTERPOLATION_HPP
 #define INTERPOLATION_HPP
 
 // Enumeration of interpolation types
 
-enum class InterpType { None, Linear, CubicHermite, CubicLagrange, CubicBSpline };
+/**
+ * @enum InterpType
+ * @brief Defines different types of interpolation methods.
+ *
+ * This enumeration specifies various interpolation techniques that can be
+ * used to estimate values between known data points.
+ */
+enum class InterpType {
+    None,           /**< No interpolation applied. */
+        Linear,         /**< Linear interpolation. Computes the value by connecting data points with a straight line. */
+        CubicHermite,   /**< Cubic Hermite interpolation. Provides smooth results with continuity in both the function and its first derivative. */
+        CubicLagrange,  /**< Cubic Lagrange interpolation. Uses the Lagrange polynomial for approximating values. */
+        CubicBSpline    /**< Cubic B-Spline interpolation. Uses B-spline curves for smooth interpolation. */
+};
 
 // Linear
 
+/**
+ * @struct linear_interp
+ * @brief A template structure for performing linear interpolation.
+ *
+ * This structure provides a mechanism for calculating the linear interpolation
+ * of a given value between two points. The template parameter @p T represents
+ * the data type of the values being interpolated.
+ *
+ * @tparam T The type of the data points to be interpolated (e.g., float, double).
+ */
+
 template <class T>
 struct linear_interp
 {
+    
+    /**
+     * @brief Performs linear interpolation between two values.
+     *
+     * This operator overload computes the linear interpolation between two values @p y0 and @p y1
+     * at a point @p x, where @p x is typically a fractional value between 0 and 1.
+     *
+     * @param x The interpolation factor. Typically a value between 0 and 1, representing
+     *          the relative position between @p y0 and @p y1.
+     * @param y0 The starting value (interpolated at @p x = 0).
+     * @param y1 The ending value (interpolated at @p x = 1).
+     * @return The interpolated value between @p y0 and @p y1.
+     */
+    
     T operator()(const T& x, const T& y0, const T& y1) { return  (y0 + x * ((y1 - y0))); }
 };
 
 // Cubic Hermite
 
+/**
+ * @struct cubic_hermite_interp
+ * @brief A template structure for performing cubic Hermite interpolation.
+ *
+ * This structure provides a mechanism for calculating cubic Hermite interpolation,
+ * which is a method of interpolation that provides smooth curves with continuity
+ * in both the function values and their first derivatives.
+ *
+ * The template parameter @p T represents the data type of the values being interpolated.
+ *
+ * @tparam T The type of the data points to be interpolated (e.g., float, double).
+ */
+
 template <class T>
 struct cubic_hermite_interp
 {
+    
+    /**
+     * @brief Default constructor for the cubic Hermite interpolation structure.
+     *
+     * Initializes constants used in the cubic Hermite interpolation process.
+     * These constants represent fractional coefficients that are used in the interpolation formula:
+     * - @p _5div2 is initialized to 2.5.
+     * - @p _3div2 is initialized to 1.5.
+     * - @p _1div2 is initialized to 0.5.
+     */
+    
     cubic_hermite_interp() : _5div2(2.5), _3div2(1.5), _1div2(0.5) {}
     
+    /**
+     * @brief Performs cubic Hermite interpolation between four values.
+     *
+     * This operator overload computes the cubic Hermite interpolation between four points
+     * @p y0, @p y1, @p y2, and @p y3 at a given point @p x. The values @p y1 and @p y2
+     * represent the interval over which interpolation occurs, while @p y0 and @p y3 are
+     * used to compute the tangent at the interval boundaries, ensuring smooth transitions.
+     *
+     * @param x The interpolation factor, typically between 0 and 1, representing the relative
+     *          position between @p y1 and @p y2.
+     * @param y0 The value before the starting point of interpolation, used to calculate the slope at @p y1.
+     * @param y1 The starting value of the interpolation interval (interpolated at @p x = 0).
+     * @param y2 The ending value of the interpolation interval (interpolated at @p x = 1).
+     * @param y3 The value after the ending point of interpolation, used to calculate the slope at @p y2.
+     * @return The interpolated value between @p y1 and @p y2 using cubic Hermite interpolation.
+     */
+    
     T operator()(const T& x, const T& y0, const T& y1, const T& y2, const T& y3)
     {
         const T c0 = y1;
@@ -33,18 +127,81 @@ struct cubic_hermite_interp
     
 private:
     
+    /**
+     * @brief A constant representing the value 5/2 (or 2.5), used in cubic Hermite interpolation calculations.
+     *
+     * This constant is used internally in the cubic Hermite interpolation formula to scale the results
+     * based on specific mathematical operations.
+     */
+    
     const T _5div2;
+    
+    /**
+     * @brief A constant representing the value 3/2 (or 1.5), used in cubic Hermite interpolation calculations.
+     *
+     * This constant is utilized in the cubic Hermite interpolation formula to help scale and calculate
+     * the interpolated value between points.
+     */
+    
     const T _3div2;
+    
+    /**
+     * @brief A constant representing the value 1/2 (or 0.5), used in cubic Hermite interpolation calculations.
+     *
+     * This constant is used as part of the cubic Hermite interpolation formula to help adjust the scaling
+     * of the interpolated value between points.
+     */
+    
     const T _1div2;
 };
 
 // Cubic Lagrange
 
+/**
+ * @struct cubic_lagrange_interp
+ * @brief A template structure for performing cubic Lagrange interpolation.
+ *
+ * This structure provides a mechanism for calculating cubic Lagrange interpolation,
+ * which approximates a smooth curve through four data points using Lagrange polynomials.
+ * The template parameter @p T represents the data type of the values being interpolated.
+ *
+ * @tparam T The type of the data points to be interpolated (e.g., float, double).
+ */
+
 template <class T>
 struct cubic_lagrange_interp
 {
+    
+    /**
+     * @brief Default constructor for the cubic Lagrange interpolation structure.
+     *
+     * Initializes constants used in the cubic Lagrange interpolation process.
+     * These constants represent fractional coefficients that are used in the interpolation formula:
+     * - @p _1div3 is initialized to 1/3.
+     * - @p _1div6 is initialized to 1/6.
+     * - @p _1div2 is initialized to 0.5.
+     *
+     * The values are computed based on the template parameter type @p T.
+     */
+    
     cubic_lagrange_interp() : _1div3(T(1)/T(3)), _1div6(T(1)/T(6)), _1div2(0.5) {}
     
+    /**
+     * @brief Performs cubic Lagrange interpolation between four values.
+     *
+     * This operator overload computes the cubic Lagrange interpolation between four points
+     * @p y0, @p y1, @p y2, and @p y3 at a given point @p x. Lagrange interpolation uses
+     * polynomials to estimate the value at @p x based on these four surrounding points.
+     *
+     * @param x The interpolation factor, typically between 0 and 1, representing the relative position
+     *          within the interval between @p y1 and @p y2.
+     * @param y0 The value before the starting point of interpolation, used to calculate the Lagrange polynomial.
+     * @param y1 The starting value of the interpolation interval (interpolated at @p x = 0).
+     * @param y2 The ending value of the interpolation interval (interpolated at @p x = 1).
+     * @param y3 The value after the ending point of interpolation, used to calculate the Lagrange polynomial.
+     * @return The interpolated value between @p y1 and @p y2 using cubic Lagrange interpolation.
+     */
+    
     T operator()(const T& x, const T& y0, const T& y1, const T& y2, const T& y3)
     {
         const T c0 = y1;
@@ -57,18 +214,83 @@ struct cubic_lagrange_interp
     
 private:
 
+    /**
+     * @brief A constant representing the value 1/3, used in cubic Lagrange interpolation calculations.
+     *
+     * This constant is utilized as part of the cubic Lagrange interpolation formula to scale
+     * and compute the interpolated value between points.
+     */
+    
     const T _1div3;
+    
+    /**
+     * @brief A constant representing the value 1/6, used in cubic Lagrange interpolation calculations.
+     *
+     * This constant is part of the cubic Lagrange interpolation formula, helping to scale and
+     * compute the interpolated value between data points.
+     */
+    
     const T _1div6;
+    
+    /**
+     * @brief A constant representing the value 1/2 (or 0.5), used in cubic Lagrange interpolation calculations.
+     *
+     * This constant is utilized in the cubic Lagrange interpolation formula to help adjust
+     * and scale the interpolated value between data points.
+     */
+    
     const T _1div2;
 };
 
 // Cubic B-spline
 
+/**
+ * @struct cubic_bspline_interp
+ * @brief A template structure for performing cubic B-spline interpolation.
+ *
+ * This structure provides a mechanism for calculating cubic B-spline interpolation,
+ * which produces smooth curves through control points using B-spline basis functions.
+ * The cubic B-spline method ensures continuity in both the function and its first two derivatives.
+ * The template parameter @p T represents the data type of the values being interpolated.
+ *
+ * @tparam T The type of the data points to be interpolated (e.g., float, double).
+ */
+
 template <class T>
 struct cubic_bspline_interp
 {
+    
+    /**
+     * @brief Default constructor for the cubic B-spline interpolation structure.
+     *
+     * Initializes constants used in the cubic B-spline interpolation process.
+     * These constants represent fractional coefficients that are used in the B-spline interpolation formula:
+     * - @p _2div3 is initialized to 2/3.
+     * - @p _1div6 is initialized to 1/6.
+     * - @p _1div2 is initialized to 0.5.
+     *
+     * The values are computed based on the template parameter type @p T.
+     */
+    
     cubic_bspline_interp() : _2div3(T(2)/T(3)), _1div6(T(1)/T(6)), _1div2(0.5) {}
     
+    /**
+     * @brief Performs cubic B-spline interpolation between four values.
+     *
+     * This operator overload computes the cubic B-spline interpolation between four control points
+     * @p y0, @p y1, @p y2, and @p y3 at a given point @p x. B-spline interpolation uses basis functions
+     * to create a smooth curve through the control points, ensuring continuity in both the function
+     * and its first two derivatives.
+     *
+     * @param x The interpolation factor, typically between 0 and 1, representing the relative position
+     *          within the interval between @p y1 and @p y2.
+     * @param y0 The value before the starting point of interpolation, used to define the curve.
+     * @param y1 The starting value of the interpolation interval (interpolated at @p x = 0).
+     * @param y2 The ending value of the interpolation interval (interpolated at @p x = 1).
+     * @param y3 The value after the ending point of interpolation, used to define the curve.
+     * @return The interpolated value between @p y1 and @p y2 using cubic B-spline interpolation.
+     */
+    
     T operator()(const T& x, const T& y0, const T& y1, const T& y2, const T& y3)
     {
         const T y0py2 = y0 + y2;
@@ -82,8 +304,31 @@ struct cubic_bspline_interp
     
 private:
 
+    /**
+     * @brief A constant representing the value 2/3, used in cubic B-spline interpolation calculations.
+     *
+     * This constant is part of the cubic B-spline interpolation formula, used to scale and compute
+     * the interpolated value between control points.
+     */
+    
     const T _2div3;
+    
+    /**
+     * @brief A constant representing the value 1/6, used in cubic B-spline interpolation calculations.
+     *
+     * This constant is utilized as part of the cubic B-spline interpolation formula to help scale
+     * and compute the interpolated value between control points.
+     */
+    
     const T _1div6;
+    
+    /**
+     * @brief A constant representing the value 1/2 (or 0.5), used in cubic B-spline interpolation calculations.
+     *
+     * This constant is part of the cubic B-spline interpolation formula and is used to help scale
+     * the interpolated value between control points.
+     */
+    
     const T _1div2;
 };
 
diff --git a/KernelSmoother.hpp b/KernelSmoother.hpp
index 4bc24af..ed31833 100644
--- a/KernelSmoother.hpp
+++ b/KernelSmoother.hpp
@@ -1,4 +1,24 @@
 
+/**
+ * @file KernelSmoother.hpp
+ *
+ * @brief This file defines the `kernel_smoother` class and associated methods for applying kernel smoothing
+ *        and spectral processing on input data.
+ *
+ * The `kernel_smoother` class provides functionality for smoothing data using various kernel-based methods,
+ * including FFT-based approaches for efficient convolution. The class supports different edge-handling strategies
+ * and allows users to specify filter parameters such as width, gain, and symmetry. The file also includes utility
+ * classes and methods for managing input data, applying filters, and handling FFT operations.
+ *
+ * Key Components:
+ * - `kernel_smoother`: The main class that provides kernel smoothing capabilities.
+ * - Edge handling strategies through `Ends` and `EdgeMode` enumerations.
+ * - FFT-based filtering methods for efficient convolution.
+ * - Utility methods for creating and applying filters to data.
+ *
+ * @note This file contains template-based functions and classes to support a wide range of data types and customizable behavior.
+ */
+
 #ifndef KERNELSMOOTHER_HPP
 #define KERNELSMOOTHER_HPP
 
@@ -14,44 +34,253 @@
 #include "SpectralProcessor.hpp"
 #include "TableReader.hpp"
 
+/**
+ * @brief A class that performs kernel smoothing on spectral data.
+ *
+ * This template class `kernel_smoother` is designed to smooth spectral data using a specified kernel.
+ * It inherits from `spectral_processor<T, Allocator>` to leverage spectral processing capabilities,
+ * and operates on data types defined by the template parameters.
+ *
+ * @tparam T The type of data being processed (e.g., float, double).
+ * @tparam Allocator The allocator type for memory management, defaults to `aligned_allocator` for optimized memory alignment.
+ * @tparam auto_resize_fft A boolean flag indicating whether the FFT size should automatically resize to accommodate different data sizes.
+ *                        Defaults to `false`, meaning the FFT size remains fixed unless manually changed.
+ */
+
 template <typename T, typename Allocator = aligned_allocator, bool auto_resize_fft = false>
 class kernel_smoother : private spectral_processor<T, Allocator>
 {
+    
+    /**
+     * @typedef processor
+     *
+     * An alias for the `spectral_processor` class template specialized with the types `T` and `Allocator`.
+     *
+     * This typedef simplifies access to the `spectral_processor` base class, allowing the `kernel_smoother`
+     * class to refer to it more conveniently.
+     *
+     * @tparam T The data type being processed by the spectral processor (e.g., float, double).
+     * @tparam Allocator The allocator type used for memory management in the spectral processor.
+     */
+    
     using processor = spectral_processor<T, Allocator>;
+    
+    /**
+     * @typedef op_sizes
+     *
+     * An alias for the `op_sizes` type defined in the `processor` class (i.e., `spectral_processor<T, Allocator>`).
+     *
+     * This typedef provides access to the internal structure or type that handles operational sizes
+     * within the `spectral_processor` class, which could involve FFT sizes or buffer lengths used
+     * during spectral processing.
+     *
+     * @tparam T The data type being processed by the spectral processor.
+     * @tparam Allocator The allocator type used in the spectral processor.
+     */
+    
     using op_sizes = typename processor::op_sizes;
+    
+    /**
+     * @typedef zipped_pointer
+     *
+     * An alias for the `zipped_pointer` type defined in the `processor` class (i.e., `spectral_processor<T, Allocator>`).
+     *
+     * This typedef provides access to a specialized pointer type used in the `spectral_processor` class,
+     * likely designed to point to multiple data arrays (zipped together) for efficient processing in
+     * spectral operations.
+     *
+     * @tparam T The data type being processed by the spectral processor.
+     * @tparam Allocator The allocator type used in the spectral processor.
+     */
+    
     using zipped_pointer = typename processor::zipped_pointer;
+    
+    /**
+     * @typedef in_ptr
+     *
+     * An alias for the `in_ptr` type defined in the `processor` class (i.e., `spectral_processor<T, Allocator>`).
+     *
+     * This typedef represents a pointer type used to access input data in the `spectral_processor` class,
+     * allowing for efficient manipulation and processing of the input data during spectral operations.
+     *
+     * @tparam T The data type being processed by the spectral processor.
+     * @tparam Allocator The allocator type used in the spectral processor.
+     */
+    
     using in_ptr = typename processor::in_ptr;
  
+    /**
+     * @typedef Split
+     *
+     * An alias for the `Split` type defined within the `FFTTypes<T>` class.
+     *
+     * This typedef simplifies the usage of the `Split` type for the current
+     * template type `T`, allowing easier access to a specialized FFT split data structure.
+     *
+     * @tparam T The data type for which the FFT types and associated split types are defined.
+     */
+    
     using Split = typename FFTTypes<T>::Split;
     
+    /**
+     * @typedef enable_if_t
+     *
+     * A template alias for `std::enable_if`, which is used for SFINAE (Substitution Failure Is Not An Error)
+     * to conditionally enable or disable template specializations or functions based on a boolean constant.
+     *
+     * If the boolean value `B` is true, `enable_if_t` resolves to `int`. Otherwise, this alias is invalid,
+     * and the function or specialization is excluded from the overload set.
+     *
+     * @tparam B A boolean constant used to control whether the alias is enabled or disabled.
+     */
+    
     template <bool B>
     using enable_if_t = typename std::enable_if<B, int>::type;
     
+    /**
+     * @enum Ends
+     *
+     * @brief An enumeration that defines different types of endpoint behaviors for kernel smoothing or spectral processing.
+     *
+     * This enum is used to specify how the ends or boundaries of the data should be handled during processing.
+     * Different options allow for various treatments, such as zero-padding or maintaining non-zero values.
+     *
+     * - `Zero`: The endpoints are set to zero.
+     * - `NonZero`: The endpoints maintain their non-zero values.
+     * - `SymZero`: The endpoints are symmetrically zero-padded.
+     * - `SymNonZero`: The endpoints are symmetrically handled with non-zero values.
+     */
+    
     enum class Ends { Zero, NonZero, SymZero, SymNonZero };
     
 public:
     
+    /**
+     * @enum EdgeMode
+     *
+     * @brief An enumeration that defines various strategies for handling edge conditions in kernel smoothing or spectral processing.
+     *
+     * This enum specifies how the edges of the data should be treated when applying filters or transformations, particularly when data at the boundaries is required for computations.
+     *
+     * - `ZeroPad`: The edges are padded with zeros.
+     * - `Extend`: The edge values are extended by repeating the boundary value.
+     * - `Wrap`: The data wraps around, treating the end as if it continues from the beginning.
+     * - `Fold`: The data is folded over, mirroring at the edges.
+     * - `Mirror`: The data is reflected at the boundaries.
+     */
+    
     enum class EdgeMode { ZeroPad, Extend, Wrap, Fold, Mirror };
     
+    /**
+     * @brief Constructs a `kernel_smoother` object with an optional maximum FFT size.
+     *
+     * This constructor initializes the `kernel_smoother` object, and it is only enabled if the `Allocator`
+     * type is default constructible. The constructor also initializes the base class `spectral_processor<T, Allocator>`
+     * with the given maximum FFT size.
+     *
+     * @tparam U The allocator type, which defaults to the `Allocator` type defined for the class.
+     *           This template parameter is only enabled if `U` is default constructible.
+     *
+     * @param max_fft_size The maximum size for the FFT, defaulting to \(2^{18}\) (262144). This size determines the largest FFT that the kernel smoother can handle.
+     *
+     * @note This constructor is conditionally enabled using SFINAE, meaning it is only available if the `Allocator` type
+     *       is default constructible.
+     */
+    
     template <typename U = Allocator, enable_if_t<std::is_default_constructible<U>::value> = 0>
     kernel_smoother(uintptr_t max_fft_size = 1 << 18)
     : spectral_processor<T, Allocator>(max_fft_size)
     {}
     
+    /**
+     * @brief Constructs a `kernel_smoother` object with a custom allocator and an optional maximum FFT size.
+     *
+     * This constructor initializes the `kernel_smoother` object using a provided allocator and optionally a maximum FFT size.
+     * It is only enabled if the `Allocator` type is copy constructible. The constructor also passes the allocator
+     * and FFT size to the base class `spectral_processor<T, Allocator>`.
+     *
+     * @tparam U The allocator type, which defaults to the `Allocator` type defined for the class.
+     *           This template parameter is only enabled if `U` is copy constructible.
+     *
+     * @param allocator A reference to the allocator used for managing memory within the `kernel_smoother`.
+     * @param max_fft_size The maximum size for the FFT, defaulting to \(2^{18}\) (262144). This size determines the largest FFT that the kernel smoother can handle.
+     *
+     * @note This constructor is conditionally enabled using SFINAE, meaning it is only available if the `Allocator` type
+     *       is copy constructible.
+     */
+    
     template <typename U = Allocator, enable_if_t<std::is_copy_constructible<U>::value> = 0>
     kernel_smoother(const Allocator& allocator, uintptr_t max_fft_size = 1 << 18)
     : spectral_processor<T, Allocator>(allocator, max_fft_size)
     {}
     
+    /**
+     * @brief Constructs a `kernel_smoother` object using a move-constructed allocator and an optional maximum FFT size.
+     *
+     * This constructor initializes the `kernel_smoother` object using a move-constructed allocator and an optional
+     * maximum FFT size. It is only enabled if the `Allocator` type is move constructible. The allocator and FFT size
+     * are passed to the base class `spectral_processor<T, Allocator>`.
+     *
+     * @tparam U The allocator type, which defaults to the `Allocator` type defined for the class.
+     *           This template parameter is only enabled if `U` is move constructible.
+     *
+     * @param allocator An rvalue reference to the allocator, which is move-constructed to manage memory within the `kernel_smoother`.
+     * @param max_fft_size The maximum size for the FFT, defaulting to \(2^{18}\) (262144). This size determines the largest FFT that the kernel smoother can handle.
+     *
+     * @note This constructor is conditionally enabled using SFINAE, meaning it is only available if the `Allocator` type
+     *       is move constructible.
+     */
+    
     template <typename U = Allocator, enable_if_t<std::is_move_constructible<U>::value> = 0>
     kernel_smoother(const Allocator&& allocator, uintptr_t max_fft_size = 1 << 18)
     : spectral_processor<T, Allocator>(allocator, max_fft_size)
     {}
 
+    /**
+     * @brief Sets the maximum size for the FFT operations in the kernel smoother.
+     *
+     * This method updates the maximum FFT size used by the `kernel_smoother` for spectral processing. It forwards
+     * the size to the base class `spectral_processor` to configure the internal FFT size limit.
+     *
+     * @param size The maximum FFT size to set. This value defines the upper limit for the size of FFT that
+     *             the smoother can handle.
+     */
+    
     void set_max_fft_size(uintptr_t size) { processor::set_max_fft_size(size); }
     
+    /**
+     * @brief Retrieves the maximum size for FFT operations in the kernel smoother.
+     *
+     * This method returns the current maximum FFT size used by the `kernel_smoother`,
+     * as defined in the base class `spectral_processor`.
+     *
+     * @return The maximum FFT size that the kernel smoother can handle.
+     */
+    
     uintptr_t max_fft_size() { return processor::max_fft_size(); }
 
+    /**
+     * @brief Performs kernel smoothing on the input data.
+     *
+     * This method applies kernel smoothing to the input data `in` and stores the result in the output array `out`.
+     * The smoothing is done using a specified kernel and various parameters that control the width, symmetry, and
+     * edge behavior.
+     *
+     * @param out A pointer to the output array where the smoothed data will be stored.
+     * @param in A pointer to the input data array that will be smoothed.
+     * @param kernel A pointer to the kernel array used for smoothing the data.
+     * @param length The length of the input data array.
+     * @param kernel_length The length of the kernel array.
+     * @param width_lo The lower bound width scaling factor for the kernel smoothing.
+     * @param width_hi The upper bound width scaling factor for the kernel smoothing.
+     * @param symmetric A boolean flag indicating whether the smoothing should be symmetric.
+     *                  If `true`, the kernel is applied symmetrically around the data points.
+     * @param edges Specifies how the edges of the input data should be handled, using the `EdgeMode` enumeration.
+     *
+     * @note The behavior at the edges is controlled by the `EdgeMode` parameter, which determines how data is treated
+     *       at the boundaries during the smoothing process.
+     */
+    
     void smooth(T *out, const T *in, const T *kernel, uintptr_t length, uintptr_t kernel_length, double width_lo, double width_hi, bool symmetric, EdgeMode edges)
     {
         if (!length || !kernel_length)
@@ -210,16 +439,73 @@ class kernel_smoother : private spectral_processor<T, Allocator>
     
 private:
     
+    /**
+     * @brief A struct that specializes `table_fetcher` for `double` precision values.
+     *
+     * The `fetcher` struct inherits from `table_fetcher<double>` and provides functionality for fetching
+     * or processing table-based data with double precision. It may include additional functionality
+     * or specializations specific to the `kernel_smoother`.
+     *
+     * @see table_fetcher
+     */
+    
     struct fetcher : table_fetcher<double>
     {
+        
+        /**
+         * @brief Constructs a `fetcher` object for fetching data from a given input array.
+         *
+         * This constructor initializes the `fetcher` by passing the size of the input data and a scaling factor
+         * to the base class `table_fetcher`. It also stores a pointer to the input data array.
+         *
+         * @param in A pointer to the input data array that the `fetcher` will operate on.
+         * @param size The size (number of elements) of the input data array.
+         *
+         * @note The constructor passes a scaling factor of 1.0 to the `table_fetcher` base class.
+         */
+        
         fetcher(const T *in, intptr_t size)
         : table_fetcher<T>(size, 1.0), data(in) {}
         
+        /**
+         * @brief Retrieves the value at the specified index from the input data array.
+         *
+         * This function call operator allows `fetcher` objects to be used like functions to access
+         * the data at a given index. It returns the value from the input data array at the specified index.
+         *
+         * @param idx The index of the data element to retrieve.
+         * @return The value of type `T` located at the given index in the input data array.
+         */
+        
         T operator()(intptr_t idx) { return data[idx]; }
         
+        /**
+         * @brief A pointer to the input data array.
+         *
+         * This member stores the address of the input data that the `fetcher` operates on.
+         * It is a constant pointer to ensure that the data cannot be modified through this member.
+         *
+         * @note The data is of type `T` and is used for fetching or processing elements by the `fetcher`.
+         */
+        
         const T *data;
     };
 
+    /**
+     * @brief Copies the edges of the input data to the output array with a specified filter size.
+     *
+     * This method is responsible for copying the edges of the input data to the output data, handling the boundaries according to a given filter size. The method template allows for a customizable edge-handling strategy, determined by the template template parameter `U`.
+     *
+     * @tparam U A template template parameter representing a class template that defines the edge handling strategy.
+     *           It takes a single type `V` as its template argument.
+     * @param in A pointer to the input data array.
+     * @param out A pointer to the output data array where the edge-handled values will be copied.
+     * @param length The length of the input data array.
+     * @param filter_size The size of the filter to be applied to the edges.
+     *
+     * @note This function handles edge conditions using the specified template template parameter `U` to define how the edges are copied or processed.
+     */
+    
     template <template <class V> class U>
     void copy_edges(const T *in, T *out, intptr_t length, intptr_t filter_size)
     {
@@ -237,6 +523,22 @@ class kernel_smoother : private spectral_processor<T, Allocator>
             out[i + in_size + edge_size] = fetch(i + in_size);
     }
     
+    /**
+     * @brief Determines the optimal FFT size to use based on the input size, half-width, and a given FFT size.
+     *
+     * This method calculates the appropriate FFT size to be used for kernel smoothing or spectral processing.
+     * It takes into account the input size `n`, the half-width of the kernel, and the available `fft_size`.
+     *
+     * @param n The size of the input data for which the FFT will be applied.
+     * @param half_width The half-width of the kernel, which affects the size of the data segment to be processed by the FFT.
+     * @param fft_size The available FFT size, which serves as the upper limit for the FFT operation.
+     *
+     * @return The FFT size to use, calculated based on the input parameters.
+     *
+     * @note This function ensures that the chosen FFT size accommodates both the input size and the kernel width,
+     *       without exceeding the specified maximum FFT size.
+     */
+    
     uintptr_t use_fft_n(uintptr_t n, uintptr_t half_width, uintptr_t fft_size)
     {
         bool use_fft = fft_size && n > 64 && half_width > 16 && (half_width * 64 > n);
@@ -244,6 +546,20 @@ class kernel_smoother : private spectral_processor<T, Allocator>
         return use_fft ? n : 0;
     }
 
+    /**
+     * @brief Retrieves the value of the filter kernel at a specific position.
+     *
+     * This method computes or retrieves the value of the kernel at a given `position`. The kernel is passed
+     * as an array, and the `position` determines where in the kernel the value is fetched or interpolated.
+     *
+     * @param kernel A pointer to the kernel array containing the filter values.
+     * @param position The position in the kernel, specified as a double, from which the value will be retrieved or computed.
+     *
+     * @return The value of type `T` from the kernel at the specified `position`.
+     *
+     * @note Depending on how the kernel is structured, the `position` may involve interpolation between values.
+     */
+    
     T filter_kernel(const T *kernel, double position)
     {
         uintptr_t index = static_cast<uintptr_t>(position);
@@ -254,6 +570,23 @@ class kernel_smoother : private spectral_processor<T, Allocator>
         return static_cast<T>(lo + (position - index) * (hi - lo));
     }
     
+    /**
+     * @brief Creates a filter based on the provided kernel and parameters.
+     *
+     * This method constructs a filter using the specified kernel, its length, and the desired width of the filter.
+     * It also considers how the ends of the filter should be handled, based on the `Ends` enumeration.
+     *
+     * @param filter A pointer to the output array where the constructed filter will be stored.
+     * @param kernel A pointer to the kernel array used for constructing the filter.
+     * @param kernel_length The length of the kernel array.
+     * @param width The width of the filter, which determines the scaling or extent of the kernel when constructing the filter.
+     * @param ends Specifies how the ends of the filter should be treated, using the `Ends` enumeration. This controls edge-handling behavior for the filter.
+     *
+     * @return The constructed filter value of type `T`.
+     *
+     * @note The ends handling is based on the `Ends` enumeration, which could involve zero-padding, symmetric handling, or other boundary behaviors.
+     */
+    
     T make_filter(T *filter, const T *kernel, uintptr_t kernel_length, uintptr_t width, Ends ends)
     {
         if (kernel_length == 1)
@@ -286,6 +619,24 @@ class kernel_smoother : private spectral_processor<T, Allocator>
         return filter_sum;
     }
     
+    /**
+     * @brief Applies a filter to the input data and stores the result in the output array.
+     *
+     * This templated method applies a filter of fixed size `N` to the input data, using a specified width and gain.
+     * The result is stored in the output array. The filter is convolved with the input data over the specified width.
+     *
+     * @tparam N The fixed size of the filter to be applied. This is a template parameter that determines the filter's length.
+     *
+     * @param out A pointer to the output array where the filtered data will be stored.
+     * @param data A pointer to the input data array that will be processed with the filter.
+     * @param filter A pointer to the filter array that will be applied to the input data.
+     * @param width The width over which the filter will be applied to the data.
+     * @param gain A scaling factor applied to the result of the filtering process, allowing for amplitude adjustment.
+     *
+     * @note This method performs a convolution or similar filtering operation using the provided filter and data,
+     *       with the filter size determined by the template parameter `N`.
+     */
+    
     template <int N>
     void apply_filter(T *out, const T *data, const T *filter, uintptr_t width, T gain)
     {
@@ -300,6 +651,25 @@ class kernel_smoother : private spectral_processor<T, Allocator>
         filter_val.store(out);
     }
     
+    /**
+     * @brief Applies a symmetric filter to the input data and stores the result in the output array.
+     *
+     * This templated method applies a symmetric filter of fixed size `N` to the input data. The filter is
+     * applied symmetrically around the data points, using the specified half-width and gain, with the result
+     * stored in the output array.
+     *
+     * @tparam N The fixed size of the filter to be applied. This is a template parameter that determines the filter's length.
+     *
+     * @param out A pointer to the output array where the symmetrically filtered data will be stored.
+     * @param data A pointer to the input data array that will be processed using the symmetric filter.
+     * @param filter A pointer to the filter array that will be applied symmetrically to the input data.
+     * @param half_width The half-width of the filter, which determines the symmetric range of data points the filter is applied to.
+     * @param gain A scaling factor applied to the result of the symmetric filtering process, allowing for amplitude adjustment.
+     *
+     * @note This method performs a symmetric convolution or filtering operation using the provided filter and data,
+     *       with the filter size determined by the template parameter `N` and applied symmetrically around the data points.
+     */
+    
     template <int N>
     void apply_filter_symmetric(T *out, const T *data, const T *filter, uintptr_t half_width, T gain)
     {
@@ -314,6 +684,25 @@ class kernel_smoother : private spectral_processor<T, Allocator>
         filter_val.store(out);
     }
     
+    /**
+     * @brief Applies a filter to the input data using FFT (Fast Fourier Transform) and stores the result in the output array.
+     *
+     * This method uses FFT-based convolution to apply the filter to the input data. The input and filter are processed
+     * in the frequency domain, utilizing the provided FFT splits, with the result stored in the output array. The method
+     * also allows for a gain factor to be applied to the final result.
+     *
+     * @param out A pointer to the output array where the FFT-filtered data will be stored.
+     * @param data A pointer to the input data array that will be processed using FFT-based filtering.
+     * @param filter A pointer to the filter array, which will be applied to the input data via FFT.
+     * @param io A reference to a `Split` object, which holds the input/output data used during the FFT operations.
+     * @param temp A reference to a `Split` object, used as temporary storage during FFT processing.
+     * @param width The width of the data array over which the FFT-based filtering will be applied.
+     * @param n The total number of data points to be processed via FFT.
+     * @param gain A scaling factor applied to the final result after filtering, allowing for amplitude adjustment.
+     *
+     * @note This method performs filtering using FFT, which can be more efficient for large data sets than time-domain convolution.
+     */
+    
     void apply_filter_fft(T *out, const T *data, const T *filter, Split& io, Split& temp, uintptr_t width, uintptr_t n, T gain)
     {
         uintptr_t data_width = n + width - 1;
diff --git a/PartialTracker.hpp b/PartialTracker.hpp
index d1e77a2..41dfa43 100644
--- a/PartialTracker.hpp
+++ b/PartialTracker.hpp
@@ -1,4 +1,25 @@
 
+/**
+ * @file partial_tracker.hpp
+ * @brief Definition of the Partial Tracker class for managing peak and track data.
+ *
+ * This file contains the declaration of the `partial_tracker` class, which is designed to handle
+ * the management of peaks and tracks in a data processing context. The class includes functionalities
+ * for tracking changes, calculating costs, and assigning peaks to tracks, utilizing customizable
+ * allocators and change tracking mechanisms.
+ *
+ * Key features include:
+ * - Dynamic allocation of peaks and tracks.
+ * - Cost calculation methods with optional scaling.
+ * - Change tracking to monitor variations in peak and track data.
+ * - Flexible memory management through customizable allocators.
+ *
+ * @tparam T The data type used for managing peak and track properties, such as frequency and amplitude.
+ * @tparam Changes A boolean flag that indicates whether change tracking is enabled.
+ *
+ * @note This class assumes that the allocator provided is compatible with the data types being managed.
+ */
+
 #ifndef PARTIAL_TRACKER_H
 #define PARTIAL_TRACKER_H
 
@@ -9,11 +30,30 @@
 
 #include "Allocator.hpp"
 
+/**
+ * @brief A template class representing a peak object.
+ *
+ * This class is used to represent a peak in some form of data, where the type of the peak values
+ * (e.g., amplitude, frequency, etc.) is determined by the template parameter.
+ *
+ * @tparam T The data type used for the peak's properties, such as a floating point or integer type.
+ */
+
 template <typename T>
 class peak
 {
 public:
     
+    /**
+     * @brief Constructor for the peak object.
+     *
+     * Initializes a peak with a specified frequency and amplitude.
+     * The pitch and decibel (dB) values are initialized to infinity by default.
+     *
+     * @param freq The frequency of the peak.
+     * @param amp The amplitude of the peak.
+     */
+    
     peak(T freq, T amp)
     : m_freq(freq)
     , m_amp(amp)
@@ -21,11 +61,37 @@ class peak
     , m_db(std::numeric_limits<T>::infinity())
     {}
     
+    /**
+     * @brief Default constructor for the peak object.
+     *
+     * Initializes the peak object by delegating to the parameterized constructor
+     * with default values of 0 for both arguments.
+     */
+    
     peak() : peak(0, 0) {}
     
+    /**
+     * @brief Get the frequency of the peak.
+     *
+     * @return A constant reference to the frequency value of the peak.
+     */
+    
     const T &freq() const { return m_freq; }
+    
+    /**
+     * @brief Get the amplitude of the peak.
+     *
+     * @return A constant reference to the amplitude value of the peak.
+     */
+    
     const T &amp() const { return m_amp; }
     
+    /**
+     * @brief Get the pitch of the peak.
+     *
+     * @return A constant reference to the pitch value of the peak.
+     */
+    
     const T &pitch() const
     {
         if (m_pitch == std::numeric_limits<T>::infinity())
@@ -34,6 +100,12 @@ class peak
         return m_pitch;
     }
     
+    /**
+     * @brief Get the decibel (dB) value of the peak.
+     *
+     * @return A constant reference to the decibel (dB) value of the peak.
+     */
+    
     const T &db() const
     {
         if (m_db == std::numeric_limits<T>::infinity())
@@ -44,44 +116,176 @@ class peak
     
 private:
     
+    /**
+     * @brief The frequency of the peak.
+     *
+     * This member variable stores the frequency value of the peak, represented using the type `T`.
+     */
+    
     T m_freq;
+    
+    /**
+     * @brief The amplitude of the peak.
+     *
+     * This member variable stores the amplitude value of the peak, represented using the type `T`.
+     */
+    
     T m_amp;
+    
+    /**
+     * @brief The pitch of the peak, which can be modified even in const instances.
+     *
+     * This mutable member variable stores the pitch value of the peak, allowing it to be modified
+     * even when the containing object is const. It is represented using the type `T`.
+     */
+    
     mutable T m_pitch;
+    
+    /**
+     * @brief The decibel (dB) value of the peak, which can be modified even in const instances.
+     *
+     * This mutable member variable stores the decibel (dB) value of the peak, allowing it to be modified
+     * even when the containing object is const. It is represented using the type `T`.
+     */
+    
     mutable T m_db;
 };
 
+/**
+ * @brief Alias for a constant peak object.
+ *
+ * This alias defines a type `cpeak`, which is a constant `peak` object for a given template type `T`.
+ * It simplifies the usage of `const peak<T>` by providing a more concise type name.
+ *
+ * @tparam T The data type used for the peak's properties, such as frequency and amplitude.
+ */
+
 template <typename T>
 using cpeak = const peak<T>;
 
+/**
+ * @brief A template structure representing a track of peaks.
+ *
+ * This structure is used to represent a series or track of peaks, where the type of the values
+ * (e.g., frequency, amplitude, etc.) is determined by the template parameter.
+ *
+ * @tparam T The data type used for the track's properties, such as a floating point or integer type.
+ */
+
 template <typename T>
 struct track
 {
+    
+    /**
+     * @brief Enum class representing the different states of a track.
+     *
+     * This enumeration defines the various states a track can be in during its lifecycle.
+     *
+     * - `Off`: The track is inactive or has ended.
+     * - `Start`: The track has just started.
+     * - `Continue`: The track is ongoing.
+     * - `Switch`: The track has switched to a new state or context.
+     */
+    
     enum class State { Off, Start, Continue, Switch };
     
+    /**
+     * @brief Default constructor for the track object.
+     *
+     * Initializes a track object with default values. The peak is initialized using its default constructor,
+     * and the state is set to `State::Off`, indicating that the track is inactive initially.
+     */
+    
     track() : m_peak(), m_state(State::Off) {}
     
+    /**
+     * @brief Sets the current peak of the track.
+     *
+     * Updates the track's peak with a constant reference to a given peak and adjusts the state
+     * based on whether the peak marks the start of the track.
+     *
+     * @param peak A constant reference to the peak that will be set for the track.
+     * @param start A boolean flag indicating whether the peak marks the start of the track.
+     * If true, the track's state will be set to `State::Start`; otherwise, it will be set accordingly.
+     */
+    
     void set_peak(cpeak<T>& peak, bool start)
     {
         m_peak = peak;
         m_state = start ? (active() ? State::Switch : State::Start): State::Continue;
     }
     
+    /**
+     * @brief Checks if the track is currently active.
+     *
+     * Determines whether the track is in an active state. A track is considered active if its state
+     * is not `State::Off`.
+     *
+     * @return True if the track is active, false if the track is inactive (i.e., in the `State::Off`).
+     */
+    
     bool active() const { return m_state != State::Off; }
     
+    /**
+     * @brief The current peak associated with the track.
+     *
+     * This member variable stores the peak object for the track, represented using the template type `T`.
+     * It holds information such as the frequency, amplitude, pitch, and decibel (dB) values of the peak.
+     */
+    
     peak<T> m_peak;
+    
+    /**
+     * @brief The current state of the track.
+     *
+     * This member variable stores the state of the track, which is represented by the `State` enum class.
+     * It indicates whether the track is inactive (`Off`), starting (`Start`), continuing (`Continue`), or switching (`Switch`).
+     */
+    
     State m_state;
 };
 
+/**
+ * @brief A template class that tracks changes in values of type T.
+ *
+ * This class is designed to track changes in a value of type `T`. It uses the template parameter `Impl`
+ * to determine whether a specific implementation or behavior should be used for change tracking.
+ *
+ * @tparam T The type of the value being tracked (e.g., int, float, etc.).
+ * @tparam Impl A boolean template parameter that controls the behavior of the change tracking mechanism.
+ * If true, a specific implementation is used; otherwise, an alternative behavior is applied.
+ */
+
 template <typename T, bool Impl>
 class change_tracker
 {
 public:
     
+    /**
+     * @brief Default constructor for the change_tracker class.
+     *
+     * Initializes a change_tracker object with the tracking mechanism set to active by default.
+     * The member variable `m_active` is initialized to `true`, indicating that change tracking is enabled.
+     */
+    
     change_tracker() : m_active(true)
     {
         reset();
     }
     
+    /**
+     * @brief Tracks changes between the current and previous peaks.
+     *
+     * This method compares the current peak (`now`) with the previous peak (`prev`) and records any
+     * changes based on the specified parameters. The changes can include frequency, amplitude, pitch,
+     * and decibel (dB) values.
+     *
+     * @param now A constant reference to the current peak.
+     * @param prev A constant reference to the previous peak.
+     * @param use_pitch A boolean flag indicating whether pitch changes should be tracked.
+     * @param use_db A boolean flag indicating whether decibel (dB) changes should be tracked.
+     */
+    
     void add_change(cpeak<T>& now, cpeak<T>& prev, bool use_pitch, bool use_db)
     {
         T f_change;
@@ -107,6 +311,13 @@ class change_tracker
         m_count++;
     }
     
+    /**
+     * @brief Marks the change tracking process as complete.
+     *
+     * This method finalizes the change tracking process, indicating that no further changes
+     * will be tracked. It is typically called after all changes between peaks have been processed.
+     */
+    
     void complete()
     {
         if (m_count)
@@ -119,6 +330,13 @@ class change_tracker
         }
     }
     
+    /**
+     * @brief Resets the change tracker to its initial state.
+     *
+     * This method clears any tracked changes and resets the change tracker, allowing it to start
+     * tracking changes from scratch. It is typically used to reinitialize the tracker for a new set of comparisons.
+     */
+    
     void reset()
     {
         m_freq_sum = 0;
@@ -128,52 +346,270 @@ class change_tracker
         m_count = 0;
     }
     
+    /**
+     * @brief Retrieves the sum of frequency changes.
+     *
+     * This method returns the accumulated sum of frequency changes tracked by the change tracker.
+     *
+     * @return The sum of the frequency changes as a value of type `T`.
+     */
+    
     T freq_sum() const { return m_freq_sum; }
+    
+    /**
+     * @brief Retrieves the absolute sum of frequency changes.
+     *
+     * This method returns the accumulated absolute sum of frequency changes tracked by the change tracker.
+     * It provides the total of all frequency changes, regardless of direction.
+     *
+     * @return The absolute sum of frequency changes as a value of type `T`.
+     */
+    
     T freq_abs() const { return m_freq_abs; }
+    
+    /**
+     * @brief Retrieves the sum of amplitude changes.
+     *
+     * This method returns the accumulated sum of amplitude changes tracked by the change tracker.
+     *
+     * @return The sum of the amplitude changes as a value of type `T`.
+     */
+    
     T amp_sum() const { return m_amp_sum; }
+    
+    /**
+     * @brief Retrieves the absolute sum of amplitude changes.
+     *
+     * This method returns the accumulated absolute sum of amplitude changes tracked by the change tracker.
+     * It provides the total of all amplitude changes, regardless of direction.
+     *
+     * @return The absolute sum of amplitude changes as a value of type `T`.
+     */
+    
     T amp_abs() const { return m_amp_abs; }
     
+    /**
+     * @brief Sets the active state of the change tracker.
+     *
+     * This method enables or disables the change tracking mechanism. When `on` is true,
+     * the tracker is active and will track changes; when false, tracking is disabled.
+     *
+     * @param on A boolean flag to set the active state.
+     * If true, the tracker is activated; if false, it is deactivated.
+     */
+    
     void active(bool on) { m_active = on; }
     
 private:
     
+    /**
+     * @brief The sum of frequency changes.
+     *
+     * This member variable stores the cumulative sum of the frequency changes that have been tracked.
+     * It is represented using the template type `T`.
+     */
+    
     T m_freq_sum;
+    
+    /**
+     * @brief The absolute sum of frequency changes.
+     *
+     * This member variable stores the cumulative absolute sum of the frequency changes that have been tracked.
+     * It is represented using the template type `T`. The absolute sum tracks the magnitude of frequency changes
+     * regardless of direction (positive or negative).
+     */
+    
     T m_freq_abs;
+    
+    /**
+     * @brief The sum of amplitude changes.
+     *
+     * This member variable stores the cumulative sum of the amplitude changes that have been tracked.
+     * It is represented using the template type `T`.
+     */
+    
     T m_amp_sum;
+    
+    /**
+     * @brief The absolute sum of amplitude changes.
+     *
+     * This member variable stores the cumulative absolute sum of the amplitude changes that have been tracked.
+     * It is represented using the template type `T`. The absolute sum tracks the magnitude of amplitude changes
+     * regardless of direction (positive or negative).
+     */
+    
     T m_amp_abs;
     
+    /**
+     * @brief Indicates whether the change tracker is active.
+     *
+     * This boolean member variable stores the state of the change tracker.
+     * When `true`, the tracker is active and changes are being tracked; when `false`, tracking is disabled.
+     */
+    
     bool m_active;
+    
+    /**
+     * @brief The count of changes tracked.
+     *
+     * This member variable stores the number of changes that have been tracked by the change tracker.
+     * It is represented using `size_t` to hold a non-negative integer value.
+     */
+    
     size_t m_count;
 };
 
+/**
+ * @brief Specialization of the change_tracker class for when the template parameter `Impl` is false.
+ *
+ * This specialized version of the `change_tracker` class provides an alternative implementation
+ * or behavior for tracking changes when the boolean template parameter `Impl` is set to `false`.
+ * It modifies or disables certain functionality depending on the design of the class.
+ *
+ * @tparam T The type of the value being tracked (e.g., int, float, etc.).
+ */
+
 template <typename T>
 class change_tracker<T, false>
 {
 public:
+    
+    /**
+     * @brief Tracks changes between the current and previous peaks.
+     *
+     * This is a specialized version of the `add_change` method for the case when the `Impl` parameter is false.
+     * In this version, the method does not perform any actual change tracking, effectively providing a no-op implementation.
+     *
+     * @param now A constant reference to the current peak.
+     * @param prev A constant reference to the previous peak.
+     * @param use_pitch A boolean flag indicating whether pitch changes should be tracked. (Not used in this version)
+     * @param use_db A boolean flag indicating whether decibel (dB) changes should be tracked. (Not used in this version)
+     */
+    
     void add_change(cpeak<T>& now, cpeak<T>& prev, bool use_pitch, bool use_db) {}
+   
+    /**
+     * @brief Marks the change tracking process as complete.
+     *
+     * In this specialized version of the `complete` method, where the `Impl` parameter is `false`,
+     * the method does not perform any actions, effectively acting as a no-op.
+     * This is used when no change tracking is required.
+     */
+    
     void complete() {}
+    
+    /**
+     * @brief Resets the change tracker to its initial state.
+     *
+     * In this specialized version of the `reset` method, where the `Impl` parameter is `false`,
+     * the method does not perform any reset actions, functioning as a no-op.
+     * This is used when no change tracking behavior is required.
+     */
+    
     void reset() {}
 };
 
+/**
+ * @brief A template class for tracking partials with optional change tracking.
+ *
+ * The `partial_tracker` class is designed to track partials (e.g., components in a signal), where
+ * the data type `T` is used for representing values. The template parameter `Changes` controls whether
+ * change tracking is enabled, and `Allocator` defines the memory allocation strategy for the tracker.
+ *
+ * @tparam T The data type used for the partials (e.g., frequency, amplitude).
+ * @tparam Changes A boolean flag that enables or disables change tracking. Default is `false` (no change tracking).
+ * @tparam Allocator The allocator type used for managing memory. Default is `malloc_allocator`.
+ */
+
 template <typename T, bool Changes = false, typename Allocator = malloc_allocator>
 class partial_tracker
 {
+    
+    /**
+     * @brief Typedef for a function pointer representing a cost function.
+     *
+     * This typedef defines `CostType` as a pointer to a function that takes three arguments of type `T`
+     * and returns a value of type `T`. It is used to represent a cost function that computes a value based
+     * on three input parameters.
+     *
+     * @typedef CostType
+     * @param T The data type for the function arguments and the return value.
+     */
+    
     typedef T (*CostType)(T, T, T);
+    
+    /**
+     * @brief Typedef for a pointer to a member function in the peak class.
+     *
+     * This typedef defines `GetMethod` as a pointer to a constant member function of the `peak` class
+     * that returns a constant reference to a value of type `T`. It is used to refer to getter methods
+     * in the `peak` class.
+     *
+     * @typedef GetMethod
+     * @tparam T The return type of the member function, which is a constant reference to a value of type `T`.
+     */
+    
     typedef const T&(peak<T>::*GetMethod)() const;
     
+    /**
+     * @brief Alias for a tuple representing the cost and related indices.
+     *
+     * This alias defines `cost` as a tuple consisting of three elements:
+     * - The first element is of type `T` representing the cost value.
+     * - The second element is of type `size_t`, typically representing an index (e.g., start index).
+     * - The third element is of type `size_t`, typically representing another index (e.g., end index).
+     *
+     * This alias simplifies the usage of tuples for representing cost-related data in the class.
+     */
+    
     using cost = std::tuple<T, size_t, size_t>;
     
+    /**
+     * @brief Template alias for enabling conditional compilation based on a boolean expression.
+     *
+     * This alias defines `enable_if_t` as a shorthand for `std::enable_if`, which is used to enable or disable
+     * function templates or class specializations based on the compile-time boolean condition `B`. If `B` is true,
+     * the alias resolves to `int`, allowing the template to be instantiated; otherwise, the template is disabled.
+     *
+     * @tparam B A compile-time boolean condition used to control whether the template is enabled.
+     */
+    
     template <bool B>
     using enable_if_t = typename std::enable_if<B, int>::type;
     
 public:
     
+    /**
+     * @brief Constructor for the partial_tracker class with a conditionally enabled allocator.
+     *
+     * This constructor initializes a `partial_tracker` object with the specified number of tracks and peaks.
+     * The constructor is only enabled if the allocator type `U` is default-constructible, which is checked
+     * using `std::enable_if` and `std::is_default_constructible`.
+     *
+     * @tparam U The allocator type, defaulting to `Allocator`. The constructor is only enabled if `U` is default-constructible.
+     * @param n_tracks The number of tracks to be managed by the tracker.
+     * @param n_peaks The number of peaks to be managed by the tracker.
+     */
+    
     template <typename U = Allocator, enable_if_t<std::is_default_constructible<U>::value> = 0>
     partial_tracker(size_t n_tracks, size_t n_peaks)
     {
         init(n_tracks, n_peaks);
     }
     
+    /**
+     * @brief Constructor for the partial_tracker class with a custom allocator.
+     *
+     * This constructor initializes a `partial_tracker` object with a user-provided allocator, the specified
+     * number of tracks, and the specified number of peaks. The constructor is only enabled if the allocator
+     * type `U` is copy-constructible, as determined by `std::enable_if` and `std::is_copy_constructible`.
+     *
+     * @tparam U The allocator type, defaulting to `Allocator`. The constructor is only enabled if `U` is copy-constructible.
+     * @param allocator A constant reference to the allocator used for memory management.
+     * @param n_tracks The number of tracks to be managed by the tracker.
+     * @param n_peaks The number of peaks to be managed by the tracker.
+     */
+    
     template <typename U = Allocator, enable_if_t<std::is_copy_constructible<U>::value> = 0>
     partial_tracker(const Allocator& allocator, size_t n_tracks, size_t n_peaks)
     : m_allocator(allocator)
@@ -181,6 +617,19 @@ class partial_tracker
         init(n_tracks, n_peaks);
     }
     
+    /**
+     * @brief Constructor for the partial_tracker class with a move-constructed allocator.
+     *
+     * This constructor initializes a `partial_tracker` object with an allocator that is moved into the class,
+     * along with the specified number of tracks and peaks. The constructor is only enabled if the allocator
+     * type `U` is default-constructible, checked using `std::enable_if` and `std::is_default_constructible`.
+     *
+     * @tparam U The allocator type, defaulting to `Allocator`. The constructor is only enabled if `U` is default-constructible.
+     * @param allocator An rvalue reference to the allocator, which is moved into the `partial_tracker` object.
+     * @param n_tracks The number of tracks to be managed by the tracker.
+     * @param n_peaks The number of peaks to be managed by the tracker.
+     */
+    
     template <typename U = Allocator, enable_if_t<std::is_default_constructible<U>::value> = 0>
     partial_tracker(Allocator&& allocator, size_t n_tracks, size_t n_peaks)
     : m_allocator(allocator)
@@ -188,6 +637,13 @@ class partial_tracker
         init(n_tracks, n_peaks);
     }
     
+    /**
+     * @brief Destructor for the partial_tracker class.
+     *
+     * Cleans up any resources used by the `partial_tracker` object. The destructor ensures that memory
+     * allocated by the allocator and other resources related to the tracks and peaks are properly released.
+     */
+    
     ~partial_tracker()
     {
         m_allocator.deallocate(m_tracks);
@@ -196,9 +652,38 @@ class partial_tracker
         m_allocator.deallocate(m_track_assigned);
     }
     
+    /**
+     * @brief Deleted copy constructor for the partial_tracker class.
+     *
+     * This copy constructor is explicitly deleted to prevent copying of `partial_tracker` objects.
+     * Copying is disabled to avoid potential issues with resource management, such as memory allocation
+     * and state management, which could lead to unintended behavior or resource leaks.
+     */
+    
     partial_tracker(const partial_tracker&) = delete;
+    
+    /**
+     * @brief Deleted copy assignment operator for the partial_tracker class.
+     *
+     * This copy assignment operator is explicitly deleted to prevent assignment of one `partial_tracker`
+     * object to another. Disabling assignment helps avoid potential issues with resource management,
+     * such as memory allocation and state consistency, ensuring the object is not inadvertently duplicated.
+     */
+    
     partial_tracker & operator=(const partial_tracker&) = delete;
     
+    /**
+     * @brief Configures the cost calculation method for the tracker.
+     *
+     * This method sets the parameters that determine how costs are calculated within the `partial_tracker`.
+     * It allows the user to specify whether to square the cost values and whether to include pitch and
+     * decibel (dB) values in the cost calculation.
+     *
+     * @param square_cost A boolean flag indicating whether the cost values should be squared.
+     * @param use_pitch A boolean flag indicating whether to include pitch in the cost calculation.
+     * @param use_db A boolean flag indicating whether to include decibel (dB) values in the cost calculation.
+     */
+    
     void set_cost_calculation(bool square_cost, bool use_pitch, bool use_db)
     {
         m_square_cost = square_cost;
@@ -206,6 +691,18 @@ class partial_tracker
         m_use_db = use_db;
     }
     
+    /**
+     * @brief Sets the scaling factors for cost calculation.
+     *
+     * This method configures the scaling factors used in cost calculations within the `partial_tracker`.
+     * It allows the user to define units for frequency and amplitude, as well as the maximum cost value,
+     * which can help normalize the cost metrics.
+     *
+     * @param freq_unit The scaling factor for frequency values used in cost calculations.
+     * @param amp_unit The scaling factor for amplitude values used in cost calculations.
+     * @param max_cost The maximum allowable cost value for normalization purposes.
+     */
+    
     void set_cost_scaling(T freq_unit, T amp_unit, T max_cost)
     {
         m_freq_scale = 1 / freq_unit;
@@ -213,6 +710,14 @@ class partial_tracker
         m_max_cost = max_cost;
     }
     
+    /**
+     * @brief Resets the state of the partial_tracker.
+     *
+     * This method clears all tracked data and resets the internal state of the `partial_tracker` object,
+     * allowing it to start fresh for new calculations. It is typically used to reinitialize the tracker
+     * before processing a new set of data.
+     */
+    
     void reset()
     {
         for (size_t i = 0; i < max_tracks(); i++)
@@ -221,6 +726,19 @@ class partial_tracker
         m_changes.reset();
     }
     
+    /**
+     * @brief Processes an array of peaks with specified threshold.
+     *
+     * This method analyzes the provided array of `peak` objects, applying the specified start threshold
+     * to determine which peaks to include in the processing. It performs the necessary calculations
+     * or tracking operations based on the peaks and the threshold value.
+     *
+     * @param peaks A pointer to an array of `peak<T>` objects to be processed.
+     * @param n_peaks The number of peaks in the array.
+     * @param start_threshold The threshold value used to determine the significance of the peaks
+     * for processing. Peaks below this threshold may be ignored.
+     */
+    
     void process(peak<T> *peaks, size_t n_peaks, T start_threshold)
     {
         // Setup
@@ -288,28 +806,130 @@ class partial_tracker
         }
     }
     
+    /**
+     * @brief Retrieves a constant reference to a track at a specified index.
+     *
+     * This method returns a constant reference to the track object stored at the given index `idx`.
+     * It allows users to access the track without modifying it, ensuring that the original track data remains unchanged.
+     *
+     * @param idx The index of the track to retrieve. It must be within the valid range of stored tracks.
+     * @return A constant reference to the track at the specified index.
+     */
+    
     const track<T> &get_track(size_t idx) { return m_tracks[idx]; }
     
+    /**
+     * @brief Retrieves the maximum number of peaks that can be stored.
+     *
+     * This method returns the maximum number of peaks that the tracker can manage, as defined by
+     * the `m_max_peaks` member variable. It provides a way to access this value without modifying
+     * the state of the `partial_tracker` object.
+     *
+     * @return The maximum number of peaks that can be stored, represented as a `size_t`.
+     */
+    
     size_t max_peaks() const { return m_max_peaks; }
+    
+    /**
+     * @brief Retrieves the maximum number of tracks that can be stored.
+     *
+     * This method returns the maximum number of tracks that the tracker can manage, as defined by
+     * the `m_max_tracks` member variable. It allows access to this value without altering the state
+     * of the `partial_tracker` object.
+     *
+     * @return The maximum number of tracks that can be stored, represented as a `size_t`.
+     */
+    
     size_t max_tracks() const { return m_max_tracks; }
     
+    /**
+     * @brief Activates or deactivates change tracking based on the provided flag.
+     *
+     * This method allows the user to enable or disable the tracking of changes within the `partial_tracker`.
+     * It is only enabled if the template parameter `B` (defaulting to `Changes`) is true. When called,
+     * it updates the internal state of the change tracker to reflect the desired activity status.
+     *
+     * @tparam B A compile-time boolean condition that determines whether change tracking is enabled.
+     * Defaults to the `Changes` parameter.
+     * @param calc A boolean flag indicating whether to activate (`true`) or deactivate (`false`) change tracking.
+     */
+    
     template<bool B = Changes, enable_if_t<B> = 0>
     void calc_changes(bool calc) { return m_changes.active(calc); }
     
+    /**
+     * @brief Retrieves the sum of frequency changes tracked.
+     *
+     * This method returns the total sum of frequency changes that have been recorded by the change tracker.
+     * It is only enabled if the template parameter `B` (defaulting to `Changes`) is true, allowing access
+     * to frequency change data only when change tracking is active.
+     *
+     * @tparam B A compile-time boolean condition that determines whether change tracking is enabled.
+     * Defaults to the `Changes` parameter.
+     * @return The sum of frequency changes, represented as a value of type `T`.
+     */
+    
     template<bool B = Changes, enable_if_t<B> = 0>
     T freq_change_sum() const { return m_changes.freq_sum(); }
     
+    /**
+     * @brief Retrieves the absolute sum of frequency changes tracked.
+     *
+     * This method returns the total absolute sum of frequency changes that have been recorded by the change tracker.
+     * It is only enabled if the template parameter `B` (defaulting to `Changes`) is true, allowing access
+     * to the absolute frequency change data only when change tracking is active.
+     *
+     * @tparam B A compile-time boolean condition that determines whether change tracking is enabled.
+     * Defaults to the `Changes` parameter.
+     * @return The absolute sum of frequency changes, represented as a value of type `T`.
+     */
+    
     template<bool B = Changes, enable_if_t<B> = 0>
     T freq_change_abs() const { return m_changes.freq_abs(); }
     
+    /**
+     * @brief Retrieves the sum of amplitude changes tracked.
+     *
+     * This method returns the total sum of amplitude changes that have been recorded by the change tracker.
+     * It is only enabled if the template parameter `B` (defaulting to `Changes`) is true, allowing access
+     * to amplitude change data only when change tracking is active.
+     *
+     * @tparam B A compile-time boolean condition that determines whether change tracking is enabled.
+     * Defaults to the `Changes` parameter.
+     * @return The sum of amplitude changes, represented as a value of type `T`.
+     */
+    
     template<bool B = Changes, enable_if_t<B> = 0>
     T amp_change_sum() const { return m_changes.amp_sum(); }
     
+    /**
+     * @brief Retrieves the absolute sum of amplitude changes tracked.
+     *
+     * This method returns the total absolute sum of amplitude changes that have been recorded by the change tracker.
+     * It is only enabled if the template parameter `B` (defaulting to `Changes`) is true, allowing access
+     * to the absolute amplitude change data only when change tracking is active.
+     *
+     * @tparam B A compile-time boolean condition that determines whether change tracking is enabled.
+     * Defaults to the `Changes` parameter.
+     * @return The absolute sum of amplitude changes, represented as a value of type `T`.
+     */
+    
     template<bool B = Changes, enable_if_t<B> = 0>
     T amp_change_abs() const { return m_changes.amp_abs(); }
     
 private:
     
+    /**
+     * @brief Initializes the partial_tracker with the specified number of peaks and tracks.
+     *
+     * This method sets up the internal structures of the `partial_tracker` by allocating resources
+     * for the given number of peaks and tracks. It should be called before any processing occurs to
+     * ensure that the tracker is properly configured.
+     *
+     * @param n_peaks The number of peaks that the tracker will manage.
+     * @param n_tracks The number of tracks that the tracker will manage.
+     */
+    
     void init(size_t n_peaks, size_t n_tracks)
     {
         m_max_peaks = n_peaks;
@@ -326,6 +946,14 @@ class partial_tracker
         set_cost_scaling(T(0.5), T(6), T(1));
     }
     
+    /**
+     * @brief Resets all assignments within the partial_tracker.
+     *
+     * This method clears any existing assignments of peaks to tracks, allowing the tracker to start
+     * fresh with new assignments. It is typically used before reassigning peaks to ensure that
+     * there are no leftover or conflicting assignments from previous operations.
+     */
+    
     void reset_assignments()
     {
         for (size_t i = 0; i < max_peaks(); i++)
@@ -335,28 +963,91 @@ class partial_tracker
             m_track_assigned[i] = false;
     }
     
+    /**
+     * @brief Assigns a peak to a track.
+     *
+     * This method assigns a specific peak, identified by `peak_idx`, to a track, identified by `track_idx`.
+     * It establishes a relationship between the peak and the track within the `partial_tracker`, allowing
+     * for organized management and processing of the peaks associated with the specified track.
+     *
+     * @param peak_idx The index of the peak to be assigned.
+     * @param track_idx The index of the track to which the peak will be assigned.
+     */
+    
     void assign(size_t peak_idx, size_t track_idx)
     {
         m_peak_assigned[peak_idx] = true;
         m_track_assigned[track_idx] = true;
     }
     
+    /**
+     * @brief Calculates the absolute cost between two values.
+     *
+     * This static method computes the absolute cost based on the difference between two values `a` and `b`,
+     * scaled by a given `scale` factor. The resulting cost can be used in various calculations where
+     * relative differences are significant.
+     *
+     * @param a The first value to compare.
+     * @param b The second value to compare.
+     * @param scale The scaling factor applied to the absolute difference between `a` and `b`.
+     * @return The calculated absolute cost, represented as a value of type `T`.
+     */
+    
     static T cost_abs(T a, T b, T scale)
     {
         return std::abs(a - b) * scale;
     }
     
+    /**
+     * @brief Calculates the squared cost between two values.
+     *
+     * This static method computes the squared cost based on the difference between two values `a` and `b`,
+     * scaled by a given `scale` factor. The resulting cost is useful in contexts where squared differences
+     * are significant, such as in optimization problems or when calculating variance.
+     *
+     * @param a The first value to compare.
+     * @param b The second value to compare.
+     * @param scale The scaling factor applied to the squared difference between `a` and `b`.
+     * @return The calculated squared cost, represented as a value of type `T`.
+     */
+    
     static T cost_sq(T a, T b, T scale)
     {
         const T c = (a - b);
         return c * c * scale;
     }
     
+    /**
+     * @brief Determines the usefulness of a given cost value.
+     *
+     * This static method evaluates a cost value and determines its usefulness based on predefined criteria.
+     * The method may apply transformations or thresholds to the cost to provide a meaningful output that
+     * can be used in subsequent calculations or decision-making processes.
+     *
+     * @param cost The cost value to be evaluated for usefulness.
+     * @return The transformed or evaluated cost value, represented as a value of type `T`.
+     */
+    
     static T cost_useful(T cost)
     {
         return 1 - std::exp(-cost);
     }
     
+    /**
+     * @brief Computes costs for a set of peaks using specified functions.
+     *
+     * This method calculates the costs associated with a given array of peaks. It utilizes the provided
+     * cost function (`CostFunc`) and the specified getter methods for frequency (`Freq`) and amplitude (`Amp`)
+     * to determine the costs for each peak in the input array.
+     *
+     * @tparam CostFunc A function pointer type that defines how to calculate the cost.
+     * @tparam Freq A member function pointer type used to retrieve the frequency of each peak.
+     * @tparam Amp A member function pointer type used to retrieve the amplitude of each peak.
+     * @param peaks A pointer to an array of `cpeak<T>` objects representing the peaks for which costs are to be computed.
+     * @param n_peaks The number of peaks in the input array.
+     * @return The total number of costs computed.
+     */
+    
     template<CostType CostFunc, GetMethod Freq, GetMethod Amp>
     size_t find_costs(cpeak<T> *peaks, size_t n_peaks)
     {
@@ -386,6 +1077,18 @@ class partial_tracker
         return n_costs;
     }
     
+    /**
+     * @brief Computes costs for a set of peaks.
+     *
+     * This method calculates the costs associated with a given array of peaks. It analyzes each peak
+     * in the provided array and computes the corresponding costs based on predefined criteria. The
+     * results can be used for further processing or analysis.
+     *
+     * @param peaks A pointer to an array of `peak<T>` objects representing the peaks for which costs are to be computed.
+     * @param n_peaks The number of peaks in the input array.
+     * @return The total number of costs computed.
+     */
+    
     size_t find_costs(peak<T> *peaks, size_t n_peaks)
     {
         // Conveniences for code length
@@ -414,30 +1117,152 @@ class partial_tracker
     
     // Allocator
     
+    /**
+     * @brief The allocator used for memory management.
+     *
+     * This member variable stores an instance of the allocator type, which is responsible for
+     * managing memory allocation and deallocation for the `partial_tracker`. It allows for custom
+     * memory management strategies to be employed, providing flexibility in how resources are handled.
+     */
+    
     Allocator m_allocator;
     
     // Sizes
     
+    /**
+     * @brief The maximum number of peaks that can be managed.
+     *
+     * This member variable stores the maximum number of peaks that the `partial_tracker` can handle.
+     * It is used to limit the number of peaks that can be added or processed, ensuring that the
+     * tracker operates within its allocated resources.
+     */
+    
     size_t m_max_peaks;
+    
+    /**
+     * @brief The maximum number of tracks that can be managed.
+     *
+     * This member variable stores the maximum number of tracks that the `partial_tracker` can handle.
+     * It sets a limit on the number of tracks that can be added or processed, ensuring efficient resource
+     * management and preventing overflow beyond the allocated capacity.
+     */
+    
     size_t m_max_tracks;
     
     // Cost parameters
     
+    /**
+     * @brief Indicates whether pitch is used in cost calculations.
+     *
+     * This member variable is a boolean flag that determines whether the pitch information
+     * should be included in the cost calculations within the `partial_tracker`. If set to `true`,
+     * pitch will be factored into the calculations; if `false`, it will be ignored.
+     */
+    
     bool m_use_pitch;
+    
+    /**
+     * @brief Indicates whether decibel (dB) values are used in cost calculations.
+     *
+     * This member variable is a boolean flag that determines whether the decibel (dB) information
+     * should be included in the cost calculations within the `partial_tracker`. If set to `true`,
+     * dB values will be factored into the calculations; if `false`, they will be disregarded.
+     */
+    
     bool m_use_db;
+    
+    /**
+     * @brief Indicates whether costs should be squared in calculations.
+     *
+     * This member variable is a boolean flag that determines whether the cost values should be
+     * squared during calculations within the `partial_tracker`. If set to `true`, the cost will be
+     * calculated as the square of the original cost value; if `false`, the original cost value will
+     * be used directly.
+     */
+    
     bool m_square_cost;
     
+    /**
+     * @brief The scaling factor applied to frequency values in cost calculations.
+     *
+     * This member variable stores the scaling factor for frequency values used in cost calculations
+     * within the `partial_tracker`. It allows for normalization or adjustment of frequency values to
+     * ensure that they are properly accounted for in the overall cost metrics.
+     */
+    
     T m_freq_scale;
+    
+    /**
+     * @brief The scaling factor applied to amplitude values in cost calculations.
+     *
+     * This member variable stores the scaling factor for amplitude values used in cost calculations
+     * within the `partial_tracker`. It allows for normalization or adjustment of amplitude values to
+     * ensure that they are properly incorporated into the overall cost metrics.
+     */
+    
     T m_amp_scale;
+    
+    /**
+     * @brief The maximum allowable cost value in calculations.
+     *
+     * This member variable stores the maximum cost value that can be used in cost calculations
+     * within the `partial_tracker`. It serves as a threshold to normalize or limit cost metrics,
+     * ensuring that calculated costs do not exceed this predefined value.
+     */
+    
     T m_max_cost;
     
     // Tracking data
     
+    /**
+     * @brief Pointer to an array of track objects managed by the partial_tracker.
+     *
+     * This member variable stores a pointer to an array of `track<T>` objects, which represent
+     * the tracks managed by the `partial_tracker`. It allows for dynamic management of tracks
+     * and facilitates operations such as adding, removing, and processing tracks within the tracker.
+     */
+    
     track<T> *m_tracks;
+    
+    /**
+     * @brief Pointer to an array of cost objects associated with the peaks.
+     *
+     * This member variable stores a pointer to an array of `cost` objects, which represent the
+     * costs calculated for each peak managed by the `partial_tracker`. It enables efficient
+     * storage and retrieval of cost data for subsequent processing and analysis.
+     */
+    
     cost *m_costs;
+    
+    /**
+     * @brief Pointer to an array indicating the assignment status of each peak.
+     *
+     * This member variable stores a pointer to an array of boolean values, where each element indicates
+     * whether a corresponding peak has been assigned to a track. It facilitates tracking of peak assignments
+     * and helps manage the relationships between peaks and tracks within the `partial_tracker`.
+     */
+    
     bool *m_peak_assigned;
+    
+    /**
+     * @brief Pointer to an array indicating the assignment status of each track.
+     *
+     * This member variable stores a pointer to an array of boolean values, where each element indicates
+     * whether a corresponding track has been assigned to a peak. It facilitates tracking of track assignments
+     * and helps manage the relationships between tracks and peaks within the `partial_tracker`.
+     */
+    
     bool *m_track_assigned;
     
+    /**
+     * @brief The change tracker for monitoring variations in data.
+     *
+     * This member variable is an instance of the `change_tracker` class, which is responsible for
+     * monitoring and recording changes in the tracked values. It uses the template type `T` to define
+     * the data type being tracked and the boolean parameter `Changes` to determine whether change
+     * tracking functionality is enabled.
+     */
+    
     change_tracker<T, Changes> m_changes;
 };
 
diff --git a/RandomGenerator.hpp b/RandomGenerator.hpp
index acba063..f363d21 100644
--- a/RandomGenerator.hpp
+++ b/RandomGenerator.hpp
@@ -1,4 +1,29 @@
 
+/**
+ * @file RandomGenerator.hpp
+ * @brief Provides classes and functions for random number generation, including CMWC (Complementary Multiply With Carry) and Gaussian generators.
+ *
+ * This file contains implementations for different random number generators, including a
+ * template-based random generator class that allows for flexibility in choosing the underlying
+ * algorithm. The CMWC (Complementary Multiply With Carry) algorithm is used as the default
+ * generator. Additionally, it includes utilities for generating Gaussian-distributed random
+ * numbers, both standard and windowed, as well as functionality for seeding the generators.
+ *
+ * Classes:
+ * - random_generators::cmwc: Implements the CMWC random number generator.
+ * - random_generator: A template-based random generator that supports different algorithms.
+ * - windowed_gaussian_params: Stores parameters for windowed Gaussian distributions.
+ *
+ * Functions:
+ * - Seed and random number generation functions for both integer and floating-point types,
+ *   including support for Gaussian-distributed values.
+ *
+ * @details This file is part of a random number generation library that offers flexibility
+ * in seeding and generating numbers, with support for custom distribution windows. It is
+ * particularly useful in applications where high-quality randomness and Gaussian-distributed
+ * numbers are needed, such as simulations and statistical sampling.
+ */
+
 #ifndef _RANDOMGENERATOR_HPP_
 #define _RANDOMGENERATOR_HPP_
 
@@ -7,6 +32,15 @@
 #include <cstdint>
 #include <random>
 
+/**
+ * @namespace random_generators
+ * @brief Namespace containing implementations of various random number generators.
+ *
+ * The random_generators namespace encapsulates all classes, functions, and constants related
+ * to random number generation algorithms. It helps organize and group different random
+ * generator implementations to avoid naming conflicts and improve code modularity.
+ */
+
 namespace random_generators
 {
     // Basic CMWC Generator
@@ -22,13 +56,51 @@ namespace random_generators
     // N.B. cmwc_lag_size must be a power of two
     // N.B. cmwc_a_value should be a suitable value according to cmwc_lag_size
 
+    /**
+     * @class cmwc
+     * @brief Implements a Complementary Multiply With Carry (CMWC) random number generator.
+     *
+     * The cmwc class provides an implementation of the CMWC algorithm, which is a fast and
+     * efficient pseudorandom number generator. It uses a lag and carry-based method to produce
+     * high-quality random numbers.
+     *
+     * @details The CMWC algorithm is an extension of the Multiply With Carry (MWC) method, where
+     * a sequence of random numbers is generated using a lag table and a carry value. This class
+     * manages the state and generation process for producing random numbers.
+     */
+
     class cmwc
     {
+        
+        /**
+         * @brief Constant representing the size of the lag for the CMWC (Complementary Multiply With Carry) random number generator.
+         *
+         * This constant is used to define the size of the lag for the CMWC algorithm, which is an efficient pseudorandom number generator.
+         */
+        
         static constexpr uint32_t cmwc_lag_size = 32;
+        
+        /**
+         * @brief Constant multiplier value used in the CMWC (Complementary Multiply With Carry) algorithm.
+         *
+         * This constant defines the multiplier 'a' in the CMWC random number generation formula.
+         * The choice of this value is critical for the performance and statistical properties of
+         * the random number generator.
+         */
+        
         static constexpr uint64_t cmwc_a_value = 987655670LL;
         
     public:
         
+        /**
+         * @brief Generates the next random number using the CMWC algorithm.
+         *
+         * This operator overload allows the cmwc object to be called like a function,
+         * returning the next pseudorandom number in the sequence.
+         *
+         * @return A 32-bit unsigned integer representing the next random number.
+         */
+        
         inline uint32_t operator()()
         {
             uint32_t i = m_increment;
@@ -57,6 +129,16 @@ namespace random_generators
         
         // Seeding (specific / OS-specific random values)
         
+        /**
+         * @brief Seeds the CMWC random number generator with an initial state.
+         *
+         * This function initializes the internal state of the CMWC algorithm using the provided seed values.
+         * The seed values are essential for determining the starting point of the random number sequence.
+         *
+         * @param init A pointer to an array of 32-bit unsigned integers used to seed the generator.
+         *             The size of the array should match the required lag size for the CMWC algorithm.
+         */
+        
         void seed(uint32_t *init)
         {
             m_increment = (cmwc_lag_size - 1);
@@ -66,6 +148,14 @@ namespace random_generators
                 m_state[i] = init[i];
         }
         
+        /**
+         * @brief Seeds the CMWC random number generator with a random value.
+         *
+         * This function automatically generates a random seed to initialize the internal state
+         * of the CMWC algorithm, allowing for a non-deterministic starting point of the random
+         * number sequence.
+         */
+        
         void rand_seed()
         {
             uint32_t seeds[cmwc_lag_size];
@@ -80,23 +170,95 @@ namespace random_generators
         
         // State
         
+        /**
+         * @brief The increment value used in the CMWC (Complementary Multiply With Carry) algorithm.
+         *
+         * This variable stores the increment (or carry) value, which is updated at each step of the
+         * CMWC random number generation process. It plays a key role in maintaining the sequence
+         * of generated random numbers.
+         */
+        
         uint32_t m_increment;
+        
+        /**
+         * @brief The carry value used in the CMWC (Complementary Multiply With Carry) algorithm.
+         *
+         * This variable holds the carry value that is updated during the random number generation
+         * process. The carry is essential for ensuring the randomness and quality of the generated
+         * sequence in the CMWC algorithm.
+         */
+        
         uint32_t m_carry;
+        
+        /**
+         * @brief The state array used in the CMWC (Complementary Multiply With Carry) algorithm.
+         *
+         * This array holds the internal state of the CMWC random number generator, with a size
+         * defined by `cmwc_lag_size`. The elements of this array are updated during the generation
+         * of random numbers and are essential for maintaining the sequence of pseudorandom values.
+         */
+        
         uint32_t m_state[cmwc_lag_size];
     };
 }
 
+/**
+ * @tparam Generator The random number generator type to use, defaulting to `random_generators::cmwc`.
+ * @class random_generator
+ * @brief A template class that provides a wrapper for different random number generator algorithms.
+ *
+ * The random_generator class allows for flexibility in choosing the underlying random number
+ * generator algorithm by specifying a template parameter. By default, it uses the CMWC (Complementary
+ * Multiply With Carry) algorithm, but it can be customized to use any other random generator that
+ * follows the same interface.
+ *
+ * @tparam Generator The random number generator class to use. It should define a method for generating
+ * random numbers and managing its internal state.
+ */
+
 template <typename Generator = random_generators::cmwc>
 class random_generator
 {
 public:
 
+    /**
+     * @class windowed_gaussian_params
+     * @brief Holds parameters for generating a windowed Gaussian function.
+     *
+     * This class encapsulates the parameters required to define a windowed Gaussian function,
+     * which is typically used in signal processing, data smoothing, or random number generation.
+     * It provides an easy-to-use interface for managing the characteristics of the Gaussian window.
+     *
+     * @details The windowed Gaussian function is characterized by its mean, standard deviation,
+     * and window size. This class stores these values and offers access to modify or retrieve
+     * the parameters as needed.
+     */
+    
     class windowed_gaussian_params
     {
+        
+        /**
+         * @brief Grants the random_generator class access to the private and protected members of this class.
+         *
+         * Declaring random_generator as a friend allows it to access and manipulate the internal
+         * data and functions of this class, which may be necessary for certain operations such as
+         * initializing or controlling random number generation.
+         */
+        
         friend random_generator;
         
     public:
         
+        /**
+         * @brief Constructs a windowed_gaussian_params object with the specified mean and standard deviation.
+         *
+         * This constructor initializes the windowed Gaussian parameters with the given mean and standard deviation,
+         * allowing the Gaussian function to be customized as needed.
+         *
+         * @param mean The mean (or center) of the Gaussian distribution.
+         * @param dev The standard deviation (spread or width) of the Gaussian distribution.
+         */
+        
         windowed_gaussian_params(double mean, double dev) : m_mean(mean), m_dev(dev)
         {
             constexpr double inf = HUGE_VAL;
@@ -113,32 +275,140 @@ class random_generator
             m_hi = std::isnan(m_hi) ? erf( inf) : m_hi;
         };
         
+        /**
+         * @brief Retrieves the mean value of the Gaussian distribution.
+         *
+         * This function returns the mean (or center) of the windowed Gaussian distribution.
+         *
+         * @return The mean value as a double.
+         */
+        
         double mean() const { return m_mean; }
+        
+        /**
+         * @brief Retrieves the standard deviation of the Gaussian distribution.
+         *
+         * This function returns the standard deviation (spread or width) of the windowed Gaussian distribution.
+         *
+         * @return The standard deviation value as a double.
+         */
+        
         double dev() const  { return m_dev; }
 
     private:
         
+        /**
+         * @brief The mean value of the Gaussian distribution.
+         *
+         * This member variable stores the mean (or center) of the windowed Gaussian distribution.
+         * It defines the central point around which the values of the distribution are concentrated.
+         */
+        
         double m_mean;
+        
+        /**
+         * @brief The standard deviation of the Gaussian distribution.
+         *
+         * This member variable stores the standard deviation of the windowed Gaussian distribution.
+         * It defines the spread or width of the distribution, indicating how much the values deviate
+         * from the mean.
+         */
+        
         double m_dev;
+        
+        /**
+         * @brief The lower bound of the window for the Gaussian distribution.
+         *
+         * This member variable stores the lower limit (or cutoff) of the windowed Gaussian distribution.
+         * It defines the starting point or minimum value of the range over which the Gaussian function is applied.
+         */
+        
         double m_lo;
+        
+        /**
+         * @brief The upper bound of the window for the Gaussian distribution.
+         *
+         * This member variable stores the upper limit (or cutoff) of the windowed Gaussian distribution.
+         * It defines the endpoint or maximum value of the range over which the Gaussian function is applied.
+         */
+        
         double m_hi;
     };
     
+    /**
+     * @brief Default constructor for the random_generator class that seeds the generator with a random value.
+     *
+     * This constructor initializes the random_generator by calling the `rand_seed()` method of the underlying
+     * generator to automatically seed it with a random value. This ensures that the generator starts with a
+     * non-deterministic seed, providing varied sequences of random numbers.
+     */
+    
     random_generator()                  { m_generator.rand_seed(); }
+    
+    /**
+     * @brief Constructor for the random_generator class that seeds the generator with a user-provided seed.
+     *
+     * This constructor initializes the random_generator by calling the `seed()` method of the underlying
+     * generator, using the seed values provided by the user. This allows for a deterministic sequence of
+     * random numbers based on the given seed.
+     *
+     * @param init A pointer to an array of 32-bit unsigned integers used to seed the generator.
+     */
+    
     random_generator(uint32_t *init)    { m_generator.seed(init); }
 
     // Seeding (specific / random values)
     
+    /**
+     * @brief Seeds the underlying random number generator with a user-provided seed.
+     *
+     * This function initializes the internal state of the random generator by calling the `seed()` method
+     * of the underlying generator and passing the provided seed values. This allows the random generator
+     * to produce a deterministic sequence of random numbers based on the given seed.
+     *
+     * @param init A pointer to an array of 32-bit unsigned integers used to seed the generator.
+     */
+    
     void seed(uint32_t *init)   { m_generator.seed(init); }
+    
+    /**
+     * @brief Seeds the underlying random number generator with a random value.
+     *
+     * This function calls the `rand_seed()` method of the underlying generator,
+     * which automatically generates and uses a random seed to initialize the generator.
+     * This results in a non-deterministic sequence of random numbers.
+     */
+    
     void rand_seed()            { m_generator.rand_seed(); }
     
     // Generate a Single Pseudo-random Unsigned Integer (full range /  in the range [0, n] / in the range [lo, hi])
     
+    /**
+     * @brief Generates and returns the next random 32-bit unsigned integer.
+     *
+     * This function produces the next pseudorandom number in the sequence by
+     * invoking the underlying random number generator and returns it as a
+     * 32-bit unsigned integer.
+     *
+     * @return A 32-bit unsigned integer representing the next random number.
+     */
+    
     uint32_t rand_int()
     {
         return m_generator();
     }
     
+    /**
+     * @brief Generates and returns a random 32-bit unsigned integer in the range [0, n).
+     *
+     * This function generates a random number using the underlying random number generator
+     * and returns it as a 32-bit unsigned integer, constrained to the range from 0 to n-1.
+     *
+     * @param n The upper bound (exclusive) for the random number. The generated number
+     *          will be in the range [0, n).
+     * @return A 32-bit unsigned integer in the range [0, n).
+     */
+    
     uint32_t rand_int(uint32_t n)
     {
         uint32_t used = n;
@@ -157,6 +427,18 @@ class random_generator
         return i;
     }
     
+    /**
+     * @brief Generates and returns a random 32-bit signed integer in the range [lo, hi].
+     *
+     * This function generates a random number using the underlying random number generator
+     * and returns it as a 32-bit signed integer, constrained to the range between the specified
+     * lower and upper bounds, inclusive.
+     *
+     * @param lo The lower bound (inclusive) of the random number range.
+     * @param hi The upper bound (inclusive) of the random number range.
+     * @return A 32-bit signed integer in the range [lo, hi].
+     */
+    
     int32_t rand_int(int32_t lo, int32_t hi)
     {
         return lo + rand_int(hi - lo);
@@ -164,12 +446,60 @@ class random_generator
     
     // Generate a 32 bit Random Double (in the range [0,1] / in the range [0, n] / in the range [lo, hi])
     
+    /**
+     * @brief Generates and returns a random double in the range [0.0, 1.0).
+     *
+     * This function generates a random 32-bit unsigned integer using the underlying
+     * random number generator, scales it to a floating-point value by multiplying
+     * with 2.32830643653869628906e-10 (which is 1/2^32), and returns the result as a
+     * double in the range [0.0, 1.0).
+     *
+     * @return A double-precision floating-point number in the range [0.0, 1.0).
+     */
+    
     double rand_double()                        { return rand_int() * 2.32830643653869628906e-10; }
+    
+    /**
+     * @brief Generates and returns a random double in the range [0.0, n).
+     *
+     * This function generates a random double in the range [0.0, 1.0) by calling
+     * `rand_double()`, then scales it by multiplying with the provided upper bound `n`,
+     * resulting in a random double in the range [0.0, n).
+     *
+     * @param n The upper bound for the random double. The returned value will be in the range [0.0, n).
+     * @return A double-precision floating-point number in the range [0.0, n).
+     */
+    
     double rand_double(double n)                { return rand_double() * n; }
+    
+    /**
+     * @brief Generates and returns a random double in the range [lo, hi).
+     *
+     * This function generates a random double in the range [lo, hi) by first generating a random
+     * double in the range [0.0, 1.0) using `rand_double()`, then scaling and shifting it to fit
+     * within the specified range [lo, hi).
+     *
+     * @param lo The lower bound (inclusive) for the random double.
+     * @param hi The upper bound (exclusive) for the random double.
+     * @return A double-precision floating-point number in the range [lo, hi).
+     */
+    
     double rand_double(double lo, double hi)    { return lo + rand_double() * (hi - lo); }
 
     // Generate a 32 bit Random Double of Gaussian Distribution with given Mean / Deviation
     
+    /**
+     * @brief Generates and returns a random double following a Gaussian (normal) distribution.
+     *
+     * This function generates a random double based on a Gaussian distribution with the specified
+     * mean and standard deviation. The result is a random value centered around `mean` with a spread
+     * determined by `dev` (standard deviation).
+     *
+     * @param mean The mean (center) of the Gaussian distribution.
+     * @param dev The standard deviation of the Gaussian distribution, which controls the spread of the values.
+     * @return A double-precision floating-point number following a Gaussian distribution with the specified mean and deviation.
+     */
+    
     double rand_gaussian(double mean, double dev)
     {
         double x, y, R;
@@ -181,6 +511,17 @@ class random_generator
     
     // Generate two independent gaussians (Mean 0 and Deviation 1)
     
+    /**
+     * @brief Generates two independent random numbers following a Gaussian (normal) distribution.
+     *
+     * This function generates two random values `x` and `y` that are independent and follow a
+     * Gaussian distribution with mean 0 and standard deviation 1. This is typically achieved
+     * using the Box-Muller transform or a similar method.
+     *
+     * @param x Reference to the first generated random value following a standard Gaussian distribution.
+     * @param y Reference to the second generated random value following a standard Gaussian distribution.
+     */
+    
     void rand_gaussians(double& x, double& y)
     {
         double R;
@@ -191,12 +532,37 @@ class random_generator
         y *= R;
     }
     
+    /**
+     * @brief Generates and returns a random number following a windowed Gaussian distribution.
+     *
+     * This function generates a random number that follows a Gaussian distribution specified by the
+     * given `params`, which include the mean, standard deviation, and window bounds. The random
+     * number is constrained to lie within the window defined by the lower and upper bounds in
+     * `params`.
+     *
+     * @param params A reference to a `windowed_gaussian_params` object that contains the mean,
+     * standard deviation, and window bounds for the Gaussian distribution.
+     * @return A double-precision floating-point number following the specified windowed Gaussian distribution.
+     */
+    
     double rand_windowed_gaussian(const windowed_gaussian_params& params)
     {
         const double r = ltqnorm(0.5 + 0.5 * rand_double(params.m_lo, params.m_hi)) * params.dev() + params.mean();
         return std::max(0.0, std::min(1.0, r));
     }
     
+    /**
+     * @brief Generates and returns a random number following a windowed Gaussian distribution with default bounds.
+     *
+     * This function generates a random number that follows a Gaussian distribution with the specified
+     * mean and standard deviation. The result is constrained within a default window, typically defined
+     * by some reasonable limits (e.g., several standard deviations from the mean).
+     *
+     * @param mean The mean (center) of the Gaussian distribution.
+     * @param dev The standard deviation (spread) of the Gaussian distribution.
+     * @return A double-precision floating-point number following the specified windowed Gaussian distribution.
+     */
+    
     double rand_windowed_gaussian(double mean, double dev)
     {
         const windowed_gaussian_params params(mean, dev);
@@ -207,6 +573,19 @@ class random_generator
 
     // Gaussian Helper
     
+    /**
+     * @brief Generates two independent random numbers following a Gaussian (normal) distribution and their radius.
+     *
+     * This function generates two random values `x` and `y` that follow a standard Gaussian distribution
+     * with mean 0 and standard deviation 1. Additionally, it calculates and returns the radius `R`,
+     * which represents the distance from the origin in a 2D Gaussian-distributed space (often used in
+     * Box-Muller or polar coordinate methods).
+     *
+     * @param x Reference to the first generated random value following a standard Gaussian distribution.
+     * @param y Reference to the second generated random value following a standard Gaussian distribution.
+     * @param R Reference to the radius, which is the distance from the origin in 2D Gaussian space.
+     */
+    
     void rand_gaussians(double& x, double& y, double& R)
     {
         x = 0.0;
@@ -335,6 +714,14 @@ class random_generator
     }
     // State
     
+    /**
+     * @brief The instance of the random number generator used by the random_generator class.
+     *
+     * This member variable holds the underlying random number generator, which is specified by
+     * the `Generator` template parameter. It is responsible for generating the random numbers
+     * used by the random_generator class.
+     */
+    
     Generator m_generator;
 };
 
diff --git a/TableReader.hpp b/TableReader.hpp
index ca9df6d..e9e8107 100644
--- a/TableReader.hpp
+++ b/TableReader.hpp
@@ -1,4 +1,25 @@
 
+/**
+ * @file TableReader.hpp
+ * @brief This file provides a variety of table readers and methods for retrieving values from tables with different interpolation techniques and edge handling modes.
+ *
+ * The `TableReader.hpp` file defines several structures and functions designed to fetch values from tables using a wide range of interpolation methods
+ * (e.g., linear, cubic B-spline, cubic Hermite, cubic Lagrange) and edge handling techniques (e.g., zero-padding, extension, wrapping, folding, mirroring, extrapolation).
+ *
+ * The file supports the following features:
+ *
+ * - **Interpolation Methods**: Linear, cubic B-spline, cubic Hermite, cubic Lagrange, and others.
+ * - **Edge Handling Modes**: Zero-padding, extension, wrapping, folding, mirroring, and extrapolation.
+ * - **Scalable Table Fetching**: Efficient methods to read multiple samples from a table, apply scaling factors, and store results in an output buffer.
+ * - **Template-Based Flexibility**: The structures and functions are designed to be highly customizable through template parameters for types, table fetchers, and readers.
+ *
+ * It contains:
+ * - Structs for different readers, including `linear_reader`, `cubic_bspline_reader`, `cubic_hermite_reader`, and more.
+ * - Functions such as `table_read`, `table_read_loop`, `table_read_optional_bound`, `table_read_edges`, which provide various ways to fetch and process table values.
+ *
+ * The file is well-suited for applications involving digital signal processing (DSP), scientific computing, and other areas where interpolation of sampled data is needed.
+ */
+
 #ifndef TABLEREADER_HPP
 #define TABLEREADER_HPP
 
@@ -8,6 +29,20 @@
 
 // Enumeration of edge types
 
+/**
+ * @brief Specifies the edge handling modes for table operations.
+ *
+ * This enumeration defines the various modes for handling edges when performing table lookups
+ * or operations that may require accessing values outside the bounds of the table.
+ *
+ * - `ZeroPad`: Pads with zeros for out-of-bounds values.
+ * - `Extend`: Uses the nearest value for out-of-bounds indices.
+ * - `Wrap`: Wraps around to the beginning of the table.
+ * - `Fold`: Reflects back at the edge.
+ * - `Mirror`: Mirrors the table across the boundary.
+ * - `Extrapolate`: Extrapolates values based on the trend of the data.
+ */
+
 enum class EdgeMode { ZeroPad, Extend, Wrap, Fold, Mirror, Extrapolate };
 
 // Base class for table fetchers
@@ -19,13 +54,57 @@ enum class EdgeMode { ZeroPad, Extend, Wrap, Fold, Mirror, Extrapolate };
 // - intptr_t limit() - which should return the highest valid position for bounds etc.
 // - void prepare(InterpType interpolation)  - which prepares the table (e.g. for extrapolation) if necessary
 
+/**
+ * @brief A template structure for fetching values from a table with specified operations.
+ *
+ * The `table_fetcher` template structure is designed to fetch values from a table using a
+ * generic type `T`. The fetching mechanism can involve operations like scaling,
+ * indexing, and handling edges based on the specified mode.
+ *
+ * @tparam T The type of data stored in the table.
+ */
+
 template <class T>
 struct table_fetcher
 {
+    
+    /**
+     * @brief Defines the type used for fetching data from the table.
+     *
+     * The `fetch_type` is an alias for the template parameter `T`, representing the type
+     * of data that the `table_fetcher` will fetch from the table.
+     */
+    
     typedef T fetch_type;
     
+    /**
+     * @brief Constructs a table_fetcher object with a specified length and scale value.
+     *
+     * This constructor initializes the table_fetcher object using the given length and scale values.
+     *
+     * @param length The length of the table to be fetched.
+     * @param scale_val The scale value to be applied to the fetched table.
+     */
+    
     table_fetcher(intptr_t length, double scale_val) : size(length), scale(scale_val) {}
     
+    /**
+     * @brief Splits a position into an integer index and a fractional part for table access.
+     *
+     * The `split` method decomposes a given position into two components: an integer index (`idx`)
+     * and a fractional part (`fract`). This is useful for interpolation or other operations
+     * where the position is not an exact integer. The method is templated to allow flexibility
+     * with the types of position and fractional parts.
+     *
+     * @tparam U The type of the position to be split.
+     * @tparam V The type for the fractional part.
+     *
+     * @param position The position value to be split into an integer and fractional part.
+     * @param idx A reference to store the resulting integer index.
+     * @param fract A reference to store the resulting fractional part.
+     * @param N An unused parameter that may define the interpolation order.
+     */
+    
     template <class U, class V>
     void split(U position, intptr_t& idx, V& fract, int /* N */)
     {
@@ -33,58 +112,244 @@ struct table_fetcher
         fract = static_cast<V>(position - static_cast<V>(idx));
     }
     
+    /**
+     * @brief Returns the upper limit of the table indices.
+     *
+     * The `limit` method provides the maximum valid index for the table, which is one less
+     * than the total size of the table. This is useful for ensuring that index access stays
+     * within bounds.
+     *
+     * @return The maximum valid index, which is `size - 1`.
+     */
+    
     intptr_t limit() { return size - 1; }
     
+    /**
+     * @brief Prepares the table_fetcher for a specific interpolation type.
+     *
+     * The `prepare` method is used to set up the table_fetcher based on the provided interpolation type.
+     * Although the current implementation does not perform any specific action, it can be extended
+     * to handle different interpolation strategies.
+     *
+     * @param interpolation The interpolation type used for fetching values (currently unused).
+     */
+    
     void prepare(InterpType /* interpolation */) {}
     
+    /**
+     * @brief The size of the table.
+     *
+     * This constant member variable stores the total number of elements in the table.
+     * It is set during the construction of the `table_fetcher` object and remains unchanged
+     * throughout the object's lifetime.
+     */
+    
     const intptr_t size;
+    
+    /**
+     * @brief The scale factor applied during table fetching operations.
+     *
+     * This constant member variable stores the scale factor used for adjusting the input values
+     * or positions during table fetching operations. It is set during the construction of the
+     * `table_fetcher` object and remains constant throughout the object's lifetime.
+     */
+    
     const double scale;
 };
 
 // Adaptors to add edge functionality
 
+/**
+ * @brief A specialized table fetcher that applies zero-padding for out-of-bounds access.
+ *
+ * The `table_fetcher_zeropad` template structure extends the functionality of another
+ * table fetcher type `T` by handling out-of-bounds indices with zero-padding. When an
+ * access occurs outside the valid range of the table, it returns a value of zero.
+ *
+ * @tparam T The base table fetcher type that this struct extends.
+ */
+
 template <class T>
 struct table_fetcher_zeropad : T
 {
+    
+    /**
+     * @brief Constructs a `table_fetcher_zeropad` object using a base table fetcher.
+     *
+     * This constructor initializes the `table_fetcher_zeropad` by copying the base table fetcher `T`.
+     * The base table fetcher provides the core table access functionality, while
+     * the `table_fetcher_zeropad` adds zero-padding behavior for out-of-bounds access.
+     *
+     * @param base A constant reference to the base table fetcher object to be copied.
+     */
+    
     table_fetcher_zeropad(const T& base) : T(base) {}
     
+    /**
+     * @brief Fetches a value from the table at the specified index with zero-padding for out-of-bounds access.
+     *
+     * This operator allows the `table_fetcher_zeropad` object to be called like a function to fetch a value
+     * from the table at the given index. If the index is within the bounds of the table, the value at that index
+     * is returned. If the index is out of bounds, the method returns zero, implementing zero-padding behavior.
+     *
+     * @param idx The index of the value to fetch from the table.
+     * @return The value at the specified index if within bounds, or zero if out of bounds.
+     */
+    
     typename T::fetch_type operator()(intptr_t idx)
     {
         return (idx < 0 || idx >= T::size) ? typename T::fetch_type(0) : T::operator()(idx);
     }
 };
 
+/**
+ * @brief A specialized table fetcher that extends the nearest value for out-of-bounds access.
+ *
+ * The `table_fetcher_extend` template structure extends the functionality of another
+ * table fetcher type `T` by handling out-of-bounds indices with value extension. When an
+ * access occurs outside the valid range of the table, it returns the nearest valid value
+ * from the table (either the first or the last element).
+ *
+ * @tparam T The base table fetcher type that this struct extends.
+ */
+
 template <class T>
 struct table_fetcher_extend : T
 {
+    
+    /**
+     * @brief Constructs a `table_fetcher_extend` object using a base table fetcher.
+     *
+     * This constructor initializes the `table_fetcher_extend` by copying the base table fetcher `T`.
+     * The base table fetcher provides the core table access functionality, while
+     * the `table_fetcher_extend` adds behavior to extend the nearest valid value for out-of-bounds access.
+     *
+     * @param base A constant reference to the base table fetcher object to be copied.
+     */
+    
     table_fetcher_extend(const T& base) : T(base) {}
     
+    /**
+     * @brief Fetches a value from the table at the specified index with value extension for out-of-bounds access.
+     *
+     * This operator allows the `table_fetcher_extend` object to be called like a function to fetch a value
+     * from the table at the given index. If the index is within bounds, the value at that index is returned.
+     * If the index is out of bounds, the method returns the nearest valid value from the table
+     * (either the first element if the index is below zero, or the last element if the index exceeds the table size).
+     *
+     * @param idx The index of the value to fetch from the table.
+     * @return The value at the specified index if within bounds, or the nearest valid value if out of bounds.
+     */
+    
     typename T::fetch_type operator()(intptr_t idx)
     {
         return T::operator()(std::min(std::max(idx, static_cast<intptr_t>(0)), T::size - 1));
     }
 };
 
+/**
+ * @brief A specialized table fetcher that wraps around the table for out-of-bounds access.
+ *
+ * The `table_fetcher_wrap` template structure extends the functionality of another table fetcher
+ * type `T` by handling out-of-bounds indices with wrapping. When an index is outside the valid
+ * range of the table, the method wraps the index around the table, effectively treating the table
+ * as circular.
+ *
+ * @tparam T The base table fetcher type that this struct extends.
+ */
+
 template <class T>
 struct table_fetcher_wrap : T
 {
+    
+    /**
+     * @brief Constructs a `table_fetcher_wrap` object using a base table fetcher.
+     *
+     * This constructor initializes the `table_fetcher_wrap` by copying the base table fetcher `T`.
+     * The base table fetcher provides the core table access functionality, while
+     * the `table_fetcher_wrap` adds behavior to wrap the index around the table for out-of-bounds access.
+     *
+     * @param base A constant reference to the base table fetcher object to be copied.
+     */
+    
     table_fetcher_wrap(const T& base) : T(base) {}
     
+    /**
+     * @brief Fetches a value from the table at the specified index with wrapping for out-of-bounds access.
+     *
+     * This operator allows the `table_fetcher_wrap` object to be called like a function to fetch a value
+     * from the table at the given index. If the index is within bounds, the value at that index is returned.
+     * If the index is out of bounds, the method wraps the index around the table, treating the table as circular.
+     * For negative indices, it wraps to the end of the table, and for indices greater than the size of the table,
+     * it wraps back to the beginning.
+     *
+     * @param idx The index of the value to fetch from the table.
+     * @return The value at the specified index if within bounds, or the wrapped value if out of bounds.
+     */
+    
     typename T::fetch_type operator()(intptr_t idx)
     {
         idx = idx < 0 ? T::size - 1 + ((idx + 1) % T::size) : idx % T::size;
         return T::operator()(idx);
     }
     
+    /**
+     * @brief Returns the size limit of the table for wrapping access.
+     *
+     * The `limit` method provides the maximum index that can be used for wrapping operations.
+     * In this case, it returns the total size of the table from the base fetcher `T`. This value
+     * is used to calculate the valid range for indices before wrapping them around.
+     *
+     * @return The size of the table, which is the limit for wrapping indices.
+     */
+    
     intptr_t limit() { return T::size; }
 };
 
+/**
+ * @brief A specialized table fetcher that folds indices for out-of-bounds access.
+ *
+ * The `table_fetcher_fold` template structure extends the functionality of another table fetcher
+ * type `T` by handling out-of-bounds indices with folding. When an index is outside the valid
+ * range of the table, the method reflects or "folds" the index back into the table, similar to
+ * mirroring. This behavior is useful for ensuring that the indices remain within the valid range
+ * without wrapping completely around like a circular table.
+ *
+ * @tparam T The base table fetcher type that this struct extends.
+ */
+
 template <class T>
 struct table_fetcher_fold : T
 {
+    
+    /**
+     * @brief Constructs a `table_fetcher_fold` object using a base table fetcher and computes the fold size.
+     *
+     * This constructor initializes the `table_fetcher_fold` by copying the base table fetcher `T`.
+     * It also calculates the `fold_size`, which is used for folding indices when they are out of bounds.
+     * If the table size is greater than 1, the `fold_size` is set to twice the size of the table minus 1,
+     * effectively defining the range of valid indices for folding. If the table size is 1 or less,
+     * the fold size is set to 1.
+     *
+     * @param base A constant reference to the base table fetcher object to be copied.
+     */
+    
     table_fetcher_fold(const T& base)
     : T(base), fold_size(T::size > 1 ? (T::size - 1) * 2 : 1) {}
     
+    /**
+     * @brief Fetches a value from the table at the specified index with folding for out-of-bounds access.
+     *
+     * This operator allows the `table_fetcher_fold` object to be called like a function to fetch a value
+     * from the table at the given index. If the index is within bounds, the value at that index is returned.
+     * If the index is out of bounds, the method "folds" the index by reflecting it back into the table's range.
+     * This folding behavior mirrors the table at its boundaries, effectively flipping the index
+     * to remain within valid bounds.
+     *
+     * @param idx The index of the value to fetch from the table.
+     * @return The value at the specified index if within bounds, or the folded value if out of bounds.
+     */
+    
     typename T::fetch_type operator()(intptr_t idx)
     {
         idx = std::abs(idx) % fold_size;
@@ -92,14 +357,59 @@ struct table_fetcher_fold : T
         return T::operator()(idx);
     }
     
+    /**
+     * @brief The effective size used for folding out-of-bounds indices.
+     *
+     * The `fold_size` determines the range of indices that can be folded when accessing
+     * the table. It is typically set to twice the table size minus one, allowing for reflection
+     * or mirroring of indices outside the valid table range. This variable is computed at
+     * construction time and is used internally during table lookup operations to manage
+     * out-of-bounds index folding.
+     */
+    
     intptr_t fold_size;
 };
 
+/**
+ * @brief A specialized table fetcher that mirrors indices for out-of-bounds access.
+ *
+ * The `table_fetcher_mirror` template structure extends the functionality of another
+ * table fetcher type `T` by handling out-of-bounds indices with mirroring. When an index
+ * falls outside the valid range of the table, the method mirrors or reflects the index back
+ * into the valid range, effectively treating the table as if it repeats in reverse at the boundaries.
+ * This behavior is useful for applications requiring symmetrical index behavior.
+ *
+ * @tparam T The base table fetcher type that this struct extends.
+ */
+
 template <class T>
 struct table_fetcher_mirror : T
 {
+    
+    /**
+     * @brief Constructs a `table_fetcher_mirror` object using a base table fetcher.
+     *
+     * This constructor initializes the `table_fetcher_mirror` by copying the base table fetcher `T`.
+     * The base table fetcher provides the core table access functionality, while the
+     * `table_fetcher_mirror` adds behavior to mirror indices when accessing out-of-bounds values.
+     *
+     * @param base A constant reference to the base table fetcher object to be copied.
+     */
+    
     table_fetcher_mirror(const T& base) : T(base) {}
     
+    /**
+     * @brief Fetches a value from the table at the specified index with mirroring for out-of-bounds access.
+     *
+     * This operator allows the `table_fetcher_mirror` object to be called like a function to fetch a value
+     * from the table at the given index. If the index is within bounds, the value at that index is returned.
+     * If the index is out of bounds, the method mirrors or reflects the index back into the table's valid range,
+     * treating the table as if it repeats in reverse at its boundaries. This allows the indices to behave symmetrically.
+     *
+     * @param idx The index of the value to fetch from the table.
+     * @return The value at the specified index if within bounds, or the mirrored value if out of bounds.
+     */
+    
     typename T::fetch_type operator()(intptr_t idx)
     {
         idx = (idx < 0 ? -(idx + 1) : idx) % (T::size * 2);
@@ -108,17 +418,69 @@ struct table_fetcher_mirror : T
     }
 };
 
+/**
+ * @brief A specialized table fetcher that extrapolates values for out-of-bounds access.
+ *
+ * The `table_fetcher_extrapolate` template structure extends the functionality of another
+ * table fetcher type `T` by handling out-of-bounds indices with extrapolation. When an index
+ * falls outside the valid range of the table, the method extrapolates the value based on
+ * the trend of the data, extending the behavior of the table beyond its boundaries.
+ * This is useful in scenarios where an estimation of values beyond the table's limits is required.
+ *
+ * @tparam T The base table fetcher type that this struct extends.
+ */
 
 template <class T>
 struct table_fetcher_extrapolate : T
 {
+    
+    /**
+     * @brief Constructs a `table_fetcher_extrapolate` object using a base table fetcher.
+     *
+     * This constructor initializes the `table_fetcher_extrapolate` by copying the base table fetcher `T`.
+     * The base table fetcher provides the core table access functionality, while the
+     * `table_fetcher_extrapolate` adds behavior to extrapolate values when accessing out-of-bounds indices.
+     *
+     * @param base A constant reference to the base table fetcher object to be copied.
+     */
+    
     table_fetcher_extrapolate(const T& base) : T(base) {}
     
+    /**
+     * @brief Fetches a value from the table at the specified index with extrapolation for out-of-bounds access.
+     *
+     * This operator allows the `table_fetcher_extrapolate` object to be called like a function to fetch a value
+     * from the table at the given index. If the index is within bounds, the value at that index is returned.
+     * If the index is out of bounds, the method extrapolates a value based on the trend of the data
+     * in the table, allowing for estimation of values beyond the table's limits.
+     *
+     * @param idx The index of the value to fetch from the table.
+     * @return The value at the specified index if within bounds, or an extrapolated value if out of bounds.
+     */
+    
     typename T::fetch_type operator()(intptr_t idx)
     {
         return (idx >= 0 && idx < T::size) ? T::operator()(idx) : (idx < 0 ? ends[0] : ends[1]);
     }
     
+    /**
+     * @brief Splits a position into an integer index and a fractional part for interpolation.
+     *
+     * The `split` method decomposes a given position into two components: an integer index (`idx`)
+     * and a fractional part (`fract`). This is useful for interpolation or other operations where
+     * the position is not an exact integer. The method is templated to allow flexibility with
+     * the types of the position and the fractional part, and the parameter `N` is typically used
+     * to define the interpolation order.
+     *
+     * @tparam U The type of the position to be split.
+     * @tparam V The type of the fractional part to be calculated.
+     *
+     * @param position The position value to be split into an integer index and fractional part.
+     * @param idx A reference to store the resulting integer index.
+     * @param fract A reference to store the resulting fractional part.
+     * @param N The interpolation order or other contextual parameter for the splitting operation.
+     */
+    
     template <class U, class V>
     void split(U position, intptr_t& idx, V& fract, int N)
     {
@@ -127,6 +489,16 @@ struct table_fetcher_extrapolate : T
         fract = static_cast<V>(position - static_cast<V>(idx));
     }
     
+    /**
+     * @brief Prepares the table fetcher for a specific interpolation type.
+     *
+     * The `prepare` method configures the table fetcher based on the provided interpolation type.
+     * This setup is necessary to optimize or adjust the fetching process for the selected interpolation
+     * strategy, ensuring that the correct method is used when fetching values from the table.
+     *
+     * @param interpolation The interpolation type that will be used in subsequent table operations.
+     */
+    
     void prepare(InterpType interpolation)
     {
         using fetch_type = typename T::fetch_type;
@@ -148,16 +520,68 @@ struct table_fetcher_extrapolate : T
             ends[0] = ends[1] = (T::size > 0 ? T::operator()(0) : fetch_type(0));
     }
     
+    /**
+     * @brief Stores the boundary values of the table for interpolation or extrapolation.
+     *
+     * The `ends` array contains two elements of type `T::fetch_type`, which represent the values
+     * at the boundaries of the table. These values can be used during interpolation or
+     * extrapolation to handle cases where data outside the bounds of the table needs to be
+     * accessed or estimated.
+     *
+     * @var ends[0] The value at the lower boundary of the table.
+     * @var ends[1] The value at the upper boundary of the table.
+     */
+    
     typename T::fetch_type ends[2];
 };
 
 // Adaptor to take a fetcher and bound the input (can be added to the above edge behaviours)
 
+/**
+ * @brief A specialized table fetcher that applies boundary conditions for out-of-bounds access.
+ *
+ * The `table_fetcher_bound` template structure extends the functionality of another
+ * table fetcher type `T` by adding boundary condition handling. This structure ensures
+ * that when indices fall outside the valid range of the table, the boundary values are used
+ * instead, providing a well-defined behavior for out-of-bounds access.
+ *
+ * @tparam T The base table fetcher type that this struct extends.
+ */
+
 template <class T>
 struct table_fetcher_bound : T
 {
+    
+    /**
+     * @brief Constructs a `table_fetcher_bound` object using a base table fetcher.
+     *
+     * This constructor initializes the `table_fetcher_bound` by copying the base table fetcher `T`.
+     * The base table fetcher provides the core table access functionality, while the
+     * `table_fetcher_bound` adds boundary condition handling for out-of-bounds access.
+     *
+     * @param base A constant reference to the base table fetcher object to be copied.
+     */
+    
     table_fetcher_bound(const T& base) : T(base) {}
 
+    /**
+     * @brief Splits a position into an integer index and a fractional part for interpolation.
+     *
+     * The `split` method decomposes a given position into two components: an integer index (`idx`)
+     * and a fractional part (`fract`). This is useful for interpolation or other operations where
+     * the position is not an exact integer. The method is templated to allow flexibility with
+     * the types of the position and the fractional part, and the parameter `N` is typically used
+     * to define the interpolation order.
+     *
+     * @tparam U The type of the position to be split.
+     * @tparam V The type of the fractional part to be calculated.
+     *
+     * @param position The position value to be split into an integer index and fractional part.
+     * @param idx A reference to store the resulting integer index.
+     * @param fract A reference to store the resulting fractional part.
+     * @param N The interpolation order or other contextual parameter for the splitting operation.
+     */
+    
     template <class U, class V>
     void split(U position, intptr_t& idx, V& fract, int N)
     {
@@ -168,11 +592,48 @@ struct table_fetcher_bound : T
 
 // Generic interpolation readers
 
+/**
+ * @brief A template structure for reading and interpolating values from a table using a two-stage interpolation.
+ *
+ * The `interp_2_reader` structure is designed to read values from a table and apply a two-stage interpolation
+ * process. It is flexible and allows customization through template parameters, which define the types used for
+ * the table, the interpolation process, and other operations.
+ *
+ * @tparam T The type for the first stage of interpolation.
+ * @tparam U The type for the second stage of interpolation.
+ * @tparam V The type for the output or intermediate value.
+ * @tparam Table The type of the table from which values are read.
+ * @tparam Interp The type of the interpolation function or object used.
+ */
+
 template <class T, class U, class V, class Table, typename Interp>
 struct interp_2_reader
 {
+    
+    /**
+     * @brief Constructs an `interp_2_reader` object with a table fetcher.
+     *
+     * This constructor initializes the `interp_2_reader` object using the provided table fetcher.
+     * The fetcher is responsible for retrieving values from the table, which will be used in the
+     * interpolation process.
+     *
+     * @param fetcher The table fetcher object used to retrieve values from the table.
+     */
+    
     interp_2_reader(Table fetcher) : fetch(fetcher) {}
     
+    /**
+     * @brief Performs a two-stage interpolation at the specified position in the table.
+     *
+     * This operator allows the `interp_2_reader` object to be called like a function,
+     * performing interpolation based on the provided positions. The interpolation is applied
+     * using the table fetcher and the specified positions, which are passed as a pointer.
+     * The method returns the interpolated value after performing a two-stage process.
+     *
+     * @param positions A pointer to the position(s) in the table where interpolation is to be performed.
+     * @return The interpolated value of type `T`.
+     */
+    
     T operator()(const V*& positions)
     {
         typename T::scalar_type fract_array[T::size];
@@ -194,15 +655,70 @@ struct interp_2_reader
         return interpolate(T(fract_array), y0, y1);
     }
     
+    /**
+     * @brief The table fetcher used to retrieve values from the table.
+     *
+     * This member variable holds an instance of the `Table` type, which is responsible for
+     * fetching values from the table during interpolation. It is used internally by the
+     * `interp_2_reader` to access the table data as part of the interpolation process.
+     */
+    
     Table fetch;
+    
+    /**
+     * @brief The interpolation function or object used to perform the interpolation.
+     *
+     * This member variable holds an instance of the `Interp` type, which defines the interpolation
+     * method to be applied during the two-stage interpolation process. It is used by the
+     * `interp_2_reader` to compute interpolated values based on the positions provided.
+     */
+    
     Interp interpolate;
 };
 
+/**
+ * @brief A template structure for reading and interpolating values from a table using a four-stage interpolation.
+ *
+ * The `interp_4_reader` structure is designed to read values from a table and apply a four-stage interpolation process.
+ * This structure is flexible and allows customization through template parameters, which define the types used for
+ * the table, the interpolation process, and the output.
+ *
+ * @tparam T The type for the first stage of interpolation.
+ * @tparam U The type for the second stage of interpolation.
+ * @tparam V The type for the third and fourth stage, or the output type.
+ * @tparam Table The type of the table from which values are read.
+ * @tparam Interp The type of the interpolation function or object used in the process.
+ */
+
 template <class T, class U, class V, class Table, typename Interp>
 struct interp_4_reader
 {
+    
+    /**
+     * @brief Constructs an `interp_4_reader` object with a table fetcher.
+     *
+     * This constructor initializes the `interp_4_reader` object using the provided table fetcher.
+     * The `fetcher` is responsible for retrieving values from the table, which will be used
+     * in the four-stage interpolation process.
+     *
+     * @param fetcher The table fetcher object used to retrieve values from the table.
+     */
+    
     interp_4_reader(Table fetcher) : fetch(fetcher) {}
     
+    /**
+     * @brief Performs a four-stage interpolation at the specified position in the table.
+     *
+     * This operator allows the `interp_4_reader` object to be called like a function,
+     * performing interpolation based on the provided positions. The interpolation is applied
+     * using the table fetcher and the specified positions, which are passed as a pointer.
+     * The method returns the interpolated value after performing a four-stage process,
+     * allowing for complex and precise interpolation results.
+     *
+     * @param positions A pointer to the position(s) in the table where interpolation is to be performed.
+     * @return The interpolated value of type `T`.
+     */
+    
     T operator()(const V*& positions)
     {        
         typename T::scalar_type fract_array[T::size];
@@ -228,17 +744,69 @@ struct interp_4_reader
         return interpolate(T(fract_array), y0, y1, y2, y3);
     }
     
+    /**
+     * @brief The table fetcher used to retrieve values from the table during interpolation.
+     *
+     * This member variable holds an instance of the `Table` type, which is responsible for
+     * fetching values from the table that will be used in the interpolation process. It is
+     * accessed internally by the `interp_4_reader` to obtain data for the four-stage interpolation.
+     */
+    
     Table fetch;
+    
+    /**
+     * @brief The interpolation function or object used to perform the four-stage interpolation.
+     *
+     * This member variable holds an instance of the `Interp` type, which defines the interpolation
+     * method used by the `interp_4_reader` to calculate the interpolated values. It is used internally
+     * to apply the four-stage interpolation process on the data fetched from the table.
+     */
+    
     Interp interpolate;
 };
 
 // Readers with specific interpolation types
 
+/**
+ * @brief A template structure for reading values from a table without interpolation.
+ *
+ * The `no_interp_reader` structure is designed to fetch values from a table directly,
+ * without applying any interpolation. This structure is useful in scenarios where
+ * precise, unmodified data retrieval is required, or when interpolation is unnecessary.
+ *
+ * @tparam T The type for the values being fetched from the table.
+ * @tparam U The type used for indexing or positioning.
+ * @tparam V The type for the output or intermediate values.
+ * @tparam Table The type of the table from which values are read.
+ */
+
 template <class T, class U, class V, class Table>
 struct no_interp_reader
 {
+    
+    /**
+     * @brief Constructs a `no_interp_reader` object with a table fetcher.
+     *
+     * This constructor initializes the `no_interp_reader` object using the provided table fetcher.
+     * The `fetcher` is responsible for retrieving values directly from the table without applying any interpolation.
+     *
+     * @param fetcher The table fetcher object used to retrieve values from the table.
+     */
+    
     no_interp_reader(Table fetcher) : fetch(fetcher) {}
     
+    /**
+     * @brief Retrieves a value from the table at the specified position without interpolation.
+     *
+     * This operator allows the `no_interp_reader` object to be called like a function to fetch
+     * a value from the table at the given position. Since no interpolation is performed,
+     * the value at the exact position is returned. The position is passed as a pointer, and
+     * the method directly fetches the corresponding value from the table.
+     *
+     * @param positions A pointer to the position(s) in the table where the value is to be fetched.
+     * @return The value at the specified position of type `T`.
+     */
+    
     T operator()(const V*& positions)
     {
         typename U::scalar_type array[T::size];
@@ -255,35 +823,168 @@ struct no_interp_reader
         return U(array);
     }
     
+    /**
+     * @brief The table fetcher used to retrieve values from the table.
+     *
+     * This member variable holds an instance of the `Table` type, which is responsible for
+     * directly fetching values from the table. In the context of `no_interp_reader`, this
+     * fetcher retrieves the exact values at the specified positions without any interpolation.
+     */
+    
     Table fetch;
 };
 
+/**
+ * @brief A template structure for reading values from a table using linear interpolation.
+ *
+ * The `linear_reader` structure extends the functionality of the `interp_2_reader` to perform
+ * linear interpolation when fetching values from the table. It leverages a two-stage interpolation process
+ * and uses a `linear_interp` object to calculate the interpolated values at the specified positions.
+ *
+ * @tparam T The type for the first stage of interpolation and output values.
+ * @tparam U The type used for intermediate calculations or indexing.
+ * @tparam V The type used for the position or fractional part during interpolation.
+ * @tparam Table The type of the table from which values are read.
+ */
+
 template <class T, class U, class V, class Table>
 struct linear_reader : public interp_2_reader<T, U, V, Table, linear_interp<T>>
 {
+    
+    /**
+     * @brief Constructs a `linear_reader` object with a table fetcher for linear interpolation.
+     *
+     * This constructor initializes the `linear_reader` by invoking the base class constructor
+     * `interp_2_reader` with the provided table fetcher. The fetcher is responsible for retrieving
+     * values from the table, and the linear interpolation process is applied to the fetched data
+     * when reading from the table.
+     *
+     * @param fetcher The table fetcher object used to retrieve values from the table for interpolation.
+     */
+    
     linear_reader(Table fetcher) : interp_2_reader<T, U, V, Table, linear_interp<T>>(fetcher) {}
 };
 
+/**
+ * @brief A template structure for reading values from a table using cubic B-spline interpolation.
+ *
+ * The `cubic_bspline_reader` structure extends the functionality of the `interp_4_reader`
+ * to perform cubic B-spline interpolation when fetching values from the table. It uses
+ * a four-stage interpolation process and leverages a `cubic_bspline_interp` object to calculate
+ * smooth, continuous values based on the provided table data.
+ *
+ * @tparam T The type used for the values and output in the interpolation process.
+ * @tparam U The type used for intermediate calculations or indexing.
+ * @tparam V The type used for the position or fractional part during interpolation.
+ * @tparam Table The type of the table from which values are read.
+ */
+
 template <class T, class U, class V,  class Table>
 struct cubic_bspline_reader : public interp_4_reader<T, U, V, Table, cubic_bspline_interp<T>>
 {
+    
+    /**
+     * @brief Constructs a `cubic_bspline_reader` object with a table fetcher for cubic B-spline interpolation.
+     *
+     * This constructor initializes the `cubic_bspline_reader` by invoking the base class constructor
+     * `interp_4_reader` with the provided table fetcher. The fetcher is responsible for retrieving
+     * values from the table, and the cubic B-spline interpolation is applied to generate smooth
+     * interpolated values based on the table data.
+     *
+     * @param fetcher The table fetcher object used to retrieve values from the table for interpolation.
+     */
+    
     cubic_bspline_reader(Table fetcher) : interp_4_reader<T, U, V, Table, cubic_bspline_interp<T>>(fetcher) {}
 };
 
+/**
+ * @brief A template structure for reading values from a table using cubic Hermite spline interpolation.
+ *
+ * The `cubic_hermite_reader` structure extends the functionality of the `interp_4_reader`
+ * to perform cubic Hermite spline interpolation when fetching values from the table.
+ * It uses a four-stage interpolation process and a `cubic_hermite_interp` object to calculate
+ * smooth interpolated values, ensuring both continuity and accurate derivative control.
+ *
+ * @tparam T The type used for the values and output in the interpolation process.
+ * @tparam U The type used for intermediate calculations or indexing.
+ * @tparam V The type used for the position or fractional part during interpolation.
+ * @tparam Table The type of the table from which values are read.
+ */
+
 template <class T, class U, class V,  class Table>
 struct cubic_hermite_reader : public interp_4_reader<T, U, V, Table, cubic_hermite_interp<T>>
 {
+    
+    /**
+     * @brief Constructs a `cubic_hermite_reader` object with a table fetcher for cubic Hermite spline interpolation.
+     *
+     * This constructor initializes the `cubic_hermite_reader` by invoking the base class constructor
+     * `interp_4_reader` with the provided table fetcher. The fetcher retrieves values from the table,
+     * and the cubic Hermite spline interpolation is applied to compute smooth interpolated values
+     * with controlled derivative continuity.
+     *
+     * @param fetcher The table fetcher object used to retrieve values from the table for interpolation.
+     */
+    
     cubic_hermite_reader(Table fetcher) : interp_4_reader<T, U, V, Table, cubic_hermite_interp<T>>(fetcher) {}
 };
 
+/**
+ * @brief A template structure for reading values from a table using cubic Lagrange interpolation.
+ *
+ * The `cubic_lagrange_reader` structure extends the functionality of the `interp_4_reader`
+ * to perform cubic Lagrange interpolation when fetching values from the table.
+ * It uses a four-stage interpolation process along with a `cubic_lagrange_interp` object
+ * to compute smooth interpolated values based on the table data, using the principles
+ * of Lagrange polynomial interpolation.
+ *
+ * @tparam T The type used for the values and output in the interpolation process.
+ * @tparam U The type used for intermediate calculations or indexing.
+ * @tparam V The type used for the position or fractional part during interpolation.
+ * @tparam Table The type of the table from which values are read.
+ */
+
 template <class T, class U, class V, class Table>
 struct cubic_lagrange_reader : public interp_4_reader<T, U, V, Table, cubic_lagrange_interp<T>>
 {
+    
+    /**
+     * @brief Constructs a `cubic_lagrange_reader` object with a table fetcher for cubic Lagrange interpolation.
+     *
+     * This constructor initializes the `cubic_lagrange_reader` by invoking the base class constructor
+     * `interp_4_reader` with the provided table fetcher. The fetcher retrieves values from the table,
+     * and the cubic Lagrange interpolation is applied to compute smooth interpolated values
+     * using Lagrange polynomial interpolation.
+     *
+     * @param fetcher The table fetcher object used to retrieve values from the table for interpolation.
+     */
+    
     cubic_lagrange_reader(Table fetcher) : interp_4_reader<T, U, V, Table, cubic_lagrange_interp<T>>(fetcher) {}
 };
 
 // Reading loop
 
+/**
+ * @brief Reads values from the table in a loop using a custom reader, applies scaling, and stores the results.
+ *
+ * The `table_read_loop` function retrieves values from the table based on the provided `positions` array
+ * using the specified `fetcher` and a custom reader template (`Reader`). The function iterates through
+ * the positions, fetches the corresponding values, applies the scaling factor `mul`, and stores the results
+ * in the output buffer `out`. This function is designed to handle multiple samples (`n_samps`) efficiently.
+ *
+ * @tparam T The type used for the output values and scaling factor.
+ * @tparam U The type used for intermediate calculations or indexing (passed to the reader).
+ * @tparam V The type used for the positions or fractional parts during table reading.
+ * @tparam Table The type of the table fetcher used to retrieve values.
+ * @tparam Reader A template class specifying the reader method, which includes the interpolation or table processing algorithm.
+ *
+ * @param fetcher The table fetcher used to retrieve values from the table.
+ * @param out A pointer to the output buffer where the fetched and scaled values will be stored.
+ * @param positions A pointer to an array of positions from which values are to be fetched.
+ * @param n_samps The number of samples to process in the loop.
+ * @param mul A scaling factor applied to each fetched value before storing it in the output buffer.
+ */
+
 template <class T, class U, class V, class Table, template <class W, class X, class Y, class Tb> class Reader>
 void table_read_loop(Table fetcher, typename T::scalar_type *out, const V *positions, intptr_t n_samps, double mul)
 {
@@ -298,6 +999,26 @@ void table_read_loop(Table fetcher, typename T::scalar_type *out, const V *posit
 
 // Template to determine vector/scalar types
 
+/**
+ * @brief Reads values from the table using a custom reader, applies scaling, and stores the results.
+ *
+ * The `table_read` function retrieves values from the table using a custom `Reader` template for
+ * processing or interpolation. It fetches values from the `positions` array using the provided `fetcher`,
+ * applies the scaling factor `mul`, and stores the resulting values in the output buffer `out`.
+ * This function processes multiple samples (`n_samps`) in a loop for efficient data retrieval and scaling.
+ *
+ * @tparam Reader A template class specifying the reader method, which includes the interpolation or table processing algorithm.
+ * @tparam Table The type of the table fetcher used to retrieve values.
+ * @tparam W The type used for the output values.
+ * @tparam X The type used for the positions or fractional parts during table reading.
+ *
+ * @param fetcher The table fetcher used to retrieve values from the table.
+ * @param out A pointer to the output buffer where the fetched and scaled values will be stored.
+ * @param positions A pointer to an array of positions from which values are to be fetched.
+ * @param n_samps The number of samples to process in the loop.
+ * @param mul A scaling factor applied to each fetched value before storing it in the output buffer.
+ */
+
 template <template <class T, class U, class V, class Tb> class Reader, class Table, class W, class X>
 void table_read(Table fetcher, W *out, const X *positions, intptr_t n_samps, double mul)
 {
@@ -311,6 +1032,26 @@ void table_read(Table fetcher, W *out, const X *positions, intptr_t n_samps, dou
 
 // Main reading call that switches between different types of interpolation
 
+/**
+ * @brief Reads values from the table, applies scaling, and stores the results in the output buffer with interpolation.
+ *
+ * The `table_read` function retrieves values from the table based on the provided `positions` array, using the `fetcher`
+ * to access the data. It applies the specified `interp` interpolation type and multiplies each fetched value
+ * by the scaling factor `mul` before storing the result in the output buffer `out`. The function processes
+ * multiple samples specified by `n_samps`, allowing for flexible and efficient table reading with interpolation.
+ *
+ * @tparam T The type used for the output values and scaling factor.
+ * @tparam U The type used for the position or index values.
+ * @tparam Table The type of the table fetcher used to retrieve values.
+ *
+ * @param fetcher The table fetcher used to retrieve values from the table.
+ * @param out A pointer to the output buffer where the fetched and scaled values will be stored.
+ * @param positions A pointer to an array of positions from which values are to be fetched.
+ * @param n_samps The number of samples to process in the loop.
+ * @param mul A scaling factor applied to each fetched value before storing it in the output buffer.
+ * @param interp The interpolation type used to retrieve values from the table.
+ */
+
 template <class T, class U, class Table>
 void table_read(Table fetcher, T *out, const U *positions, intptr_t n_samps, T mul, InterpType interp)
 {
@@ -328,6 +1069,29 @@ void table_read(Table fetcher, T *out, const U *positions, intptr_t n_samps, T m
 
 // Reading calls to add adaptors to the basic fetcher
 
+/**
+ * @brief Reads values from the table with optional boundary handling, applies scaling, and stores the results.
+ *
+ * The `table_read_optional_bound` function retrieves values from the table based on the provided `positions` array
+ * using the `fetcher`, with the option to handle out-of-bounds indices based on the `bound` flag.
+ * If `bound` is true, boundary handling is applied to ensure indices stay within the table's limits.
+ * The function also applies the specified `interp` interpolation type and multiplies each fetched value
+ * by the scaling factor `mul` before storing it in the output buffer `out`. It processes multiple samples
+ * specified by `n_samps` in a loop.
+ *
+ * @tparam T The type used for the output values and scaling factor.
+ * @tparam U The type used for the position or index values.
+ * @tparam Table The type of the table fetcher used to retrieve values.
+ *
+ * @param fetcher The table fetcher used to retrieve values from the table.
+ * @param out A pointer to the output buffer where the fetched and scaled values will be stored.
+ * @param positions A pointer to an array of positions from which values are to be fetched.
+ * @param n_samps The number of samples to process in the loop.
+ * @param mul A scaling factor applied to each fetched value before storing it in the output buffer.
+ * @param interp The interpolation type used to retrieve values from the table.
+ * @param bound A boolean flag indicating whether boundary handling should be applied for out-of-bounds access.
+ */
+
 template <class T, class U, class Table>
 void table_read_optional_bound(Table fetcher, T *out, const U *positions, intptr_t n_samps, T mul, InterpType interp, bool bound)
 {
@@ -340,6 +1104,28 @@ void table_read_optional_bound(Table fetcher, T *out, const U *positions, intptr
         table_read(fetcher, out, positions, n_samps, mul, interp);
 }
 
+/**
+ * @brief Reads values from the table with zero-padding for out-of-bounds access, applies scaling, and stores the results.
+ *
+ * The `table_read_zeropad` function retrieves values from the table based on the provided `positions` array using the `fetcher`.
+ * For out-of-bounds indices, it returns zero (zero-padding behavior). The function also applies the specified
+ * `interp` interpolation type and multiplies each fetched value by the scaling factor `mul` before storing the
+ * result in the output buffer `out`. The function can optionally handle boundary conditions based on the `bound`
+ * flag. Multiple samples (`n_samps`) are processed in a loop.
+ *
+ * @tparam T The type used for the output values and scaling factor.
+ * @tparam U The type used for the position or index values.
+ * @tparam Table The type of the table fetcher used to retrieve values.
+ *
+ * @param fetcher The table fetcher used to retrieve values from the table.
+ * @param out A pointer to the output buffer where the fetched and scaled values will be stored.
+ * @param positions A pointer to an array of positions from which values are to be fetched.
+ * @param n_samps The number of samples to process in the loop.
+ * @param mul A scaling factor applied to each fetched value before storing it in the output buffer.
+ * @param interp The interpolation type used to retrieve values from the table.
+ * @param bound A boolean flag indicating whether boundary handling should be applied for out-of-bounds access.
+ */
+
 template <class T, class U, class Table>
 void table_read_zeropad(Table fetcher, T *out, const U *positions, intptr_t n_samps, T mul, InterpType interp, bool bound)
 {
@@ -347,6 +1133,28 @@ void table_read_zeropad(Table fetcher, T *out, const U *positions, intptr_t n_sa
     table_read_optional_bound(fetch, out, positions, n_samps, mul, interp, bound);
 }
 
+/**
+ * @brief Reads values from the table with boundary extension for out-of-bounds access, applies scaling, and stores the results.
+ *
+ * The `table_read_extend` function retrieves values from the table based on the provided `positions` array using the `fetcher`.
+ * For out-of-bounds indices, it extends the nearest boundary value (boundary extension behavior). The function
+ * also applies the specified `interp` interpolation type and multiplies each fetched value by the scaling factor `mul`
+ * before storing the result in the output buffer `out`. The function can optionally handle boundary conditions based
+ * on the `bound` flag. Multiple samples (`n_samps`) are processed in a loop.
+ *
+ * @tparam T The type used for the output values and scaling factor.
+ * @tparam U The type used for the position or index values.
+ * @tparam Table The type of the table fetcher used to retrieve values.
+ *
+ * @param fetcher The table fetcher used to retrieve values from the table.
+ * @param out A pointer to the output buffer where the fetched and scaled values will be stored.
+ * @param positions A pointer to an array of positions from which values are to be fetched.
+ * @param n_samps The number of samples to process in the loop.
+ * @param mul A scaling factor applied to each fetched value before storing it in the output buffer.
+ * @param interp The interpolation type used to retrieve values from the table.
+ * @param bound A boolean flag indicating whether boundary handling should be applied for out-of-bounds access.
+ */
+
 template <class T, class U, class Table>
 void table_read_extend(Table fetcher, T *out, const U *positions, intptr_t n_samps, T mul, InterpType interp, bool bound)
 {
@@ -354,6 +1162,28 @@ void table_read_extend(Table fetcher, T *out, const U *positions, intptr_t n_sam
     table_read_optional_bound(fetch, out, positions, n_samps, mul, interp, bound);
 }
 
+/**
+ * @brief Reads values from the table with wrapping for out-of-bounds access, applies scaling, and stores the results.
+ *
+ * The `table_read_wrap` function retrieves values from the table based on the provided `positions` array using the `fetcher`.
+ * For out-of-bounds indices, it wraps the index around the table (circular behavior). The function also applies the specified
+ * `interp` interpolation type and multiplies each fetched value by the scaling factor `mul` before storing the result
+ * in the output buffer `out`. The function can optionally handle boundary conditions based on the `bound` flag.
+ * Multiple samples (`n_samps`) are processed in a loop.
+ *
+ * @tparam T The type used for the output values and scaling factor.
+ * @tparam U The type used for the position or index values.
+ * @tparam Table The type of the table fetcher used to retrieve values.
+ *
+ * @param fetcher The table fetcher used to retrieve values from the table.
+ * @param out A pointer to the output buffer where the fetched and scaled values will be stored.
+ * @param positions A pointer to an array of positions from which values are to be fetched.
+ * @param n_samps The number of samples to process in the loop.
+ * @param mul A scaling factor applied to each fetched value before storing it in the output buffer.
+ * @param interp The interpolation type used to retrieve values from the table.
+ * @param bound A boolean flag indicating whether boundary handling should be applied for out-of-bounds access.
+ */
+
 template <class T, class U, class Table>
 void table_read_wrap(Table fetcher, T *out, const U *positions, intptr_t n_samps, T mul, InterpType interp, bool bound)
 {
@@ -361,6 +1191,28 @@ void table_read_wrap(Table fetcher, T *out, const U *positions, intptr_t n_samps
     table_read_optional_bound(fetch, out, positions, n_samps, mul, interp, bound);
 }
 
+/**
+ * @brief Reads values from the table with folding for out-of-bounds access, applies scaling, and stores the results.
+ *
+ * The `table_read_fold` function retrieves values from the table based on the provided `positions` array using the `fetcher`.
+ * For out-of-bounds indices, it "folds" the index back into the table by reflecting it, similar to mirroring.
+ * The function also applies the specified `interp` interpolation type and multiplies each fetched value by
+ * the scaling factor `mul` before storing the result in the output buffer `out`. The function can optionally
+ * handle boundary conditions based on the `bound` flag. Multiple samples (`n_samps`) are processed in a loop.
+ *
+ * @tparam T The type used for the output values and scaling factor.
+ * @tparam U The type used for the position or index values.
+ * @tparam Table The type of the table fetcher used to retrieve values.
+ *
+ * @param fetcher The table fetcher used to retrieve values from the table.
+ * @param out A pointer to the output buffer where the fetched and scaled values will be stored.
+ * @param positions A pointer to an array of positions from which values are to be fetched.
+ * @param n_samps The number of samples to process in the loop.
+ * @param mul A scaling factor applied to each fetched value before storing it in the output buffer.
+ * @param interp The interpolation type used to retrieve values from the table.
+ * @param bound A boolean flag indicating whether boundary handling should be applied for out-of-bounds access.
+ */
+
 template <class T, class U, class Table>
 void table_read_fold(Table fetcher, T *out, const U *positions, intptr_t n_samps, T mul, InterpType interp, bool bound)
 {
@@ -368,6 +1220,28 @@ void table_read_fold(Table fetcher, T *out, const U *positions, intptr_t n_samps
     table_read_optional_bound(fetch, out, positions, n_samps, mul, interp, bound);
 }
 
+/**
+ * @brief Reads values from the table with mirroring for out-of-bounds access, applies scaling, and stores the results.
+ *
+ * The `table_read_mirror` function retrieves values from the table based on the provided `positions` array using the `fetcher`.
+ * For out-of-bounds indices, it mirrors the index back into the table, effectively reflecting it across the table's boundaries.
+ * The function also applies the specified `interp` interpolation type and multiplies each fetched value by the scaling factor `mul`
+ * before storing the result in the output buffer `out`. The function can optionally handle boundary conditions based on the `bound` flag.
+ * Multiple samples (`n_samps`) are processed in a loop.
+ *
+ * @tparam T The type used for the output values and scaling factor.
+ * @tparam U The type used for the position or index values.
+ * @tparam Table The type of the table fetcher used to retrieve values.
+ *
+ * @param fetcher The table fetcher used to retrieve values from the table.
+ * @param out A pointer to the output buffer where the fetched and scaled values will be stored.
+ * @param positions A pointer to an array of positions from which values are to be fetched.
+ * @param n_samps The number of samples to process in the loop.
+ * @param mul A scaling factor applied to each fetched value before storing it in the output buffer.
+ * @param interp The interpolation type used to retrieve values from the table.
+ * @param bound A boolean flag indicating whether boundary handling should be applied for out-of-bounds access.
+ */
+
 template <class T, class U, class Table>
 void table_read_mirror(Table fetcher, T *out, const U *positions, intptr_t n_samps, T mul, InterpType interp, bool bound)
 {
@@ -375,6 +1249,28 @@ void table_read_mirror(Table fetcher, T *out, const U *positions, intptr_t n_sam
     table_read_optional_bound(fetch, out, positions, n_samps, mul, interp, bound);
 }
 
+/**
+ * @brief Reads values from the table with extrapolation for out-of-bounds access, applies scaling, and stores the results.
+ *
+ * The `table_read_extrapolate` function retrieves values from the table based on the provided `positions` array using the `fetcher`.
+ * For out-of-bounds indices, it extrapolates values based on the trend of the data in the table, extending beyond its boundaries.
+ * The function applies the specified `interp` interpolation type and multiplies each fetched value by the scaling factor `mul`
+ * before storing the result in the output buffer `out`. The function can optionally handle boundary conditions based on the `bound` flag.
+ * Multiple samples (`n_samps`) are processed in a loop.
+ *
+ * @tparam T The type used for the output values and scaling factor.
+ * @tparam U The type used for the position or index values.
+ * @tparam Table The type of the table fetcher used to retrieve values.
+ *
+ * @param fetcher The table fetcher used to retrieve values from the table.
+ * @param out A pointer to the output buffer where the fetched and scaled values will be stored.
+ * @param positions A pointer to an array of positions from which values are to be fetched.
+ * @param n_samps The number of samples to process in the loop.
+ * @param mul A scaling factor applied to each fetched value before storing it in the output buffer.
+ * @param interp The interpolation type used to retrieve values from the table.
+ * @param bound A boolean flag indicating whether boundary handling should be applied for out-of-bounds access.
+ */
+
 template <class T, class U, class Table>
 void table_read_extrapolate(Table fetcher, T *out, const U *positions, intptr_t n_samps, T mul, InterpType interp, bool bound)
 {
@@ -384,6 +1280,29 @@ void table_read_extrapolate(Table fetcher, T *out, const U *positions, intptr_t
 
 // Main read call for variable edge behaviour
 
+/**
+ * @brief Reads values from the table with edge handling for out-of-bounds access, applies scaling, and stores the results.
+ *
+ * The `table_read_edges` function retrieves values from the table based on the provided `positions` array using the `fetcher`.
+ * For out-of-bounds indices, it applies edge handling based on the specified `edges` mode, which can include zero-padding,
+ * extension, wrapping, folding, mirroring, or extrapolation. The function applies the specified `interp` interpolation type
+ * and multiplies each fetched value by the scaling factor `mul` before storing the result in the output buffer `out`.
+ * The function can optionally handle boundary conditions based on the `bound` flag. Multiple samples (`n_samps`) are processed in a loop.
+ *
+ * @tparam T The type used for the output values and scaling factor.
+ * @tparam U The type used for the position or index values.
+ * @tparam Table The type of the table fetcher used to retrieve values.
+ *
+ * @param fetcher The table fetcher used to retrieve values from the table.
+ * @param out A pointer to the output buffer where the fetched and scaled values will be stored.
+ * @param positions A pointer to an array of positions from which values are to be fetched.
+ * @param n_samps The number of samples to process in the loop.
+ * @param mul A scaling factor applied to each fetched value before storing it in the output buffer.
+ * @param interp The interpolation type used to retrieve values from the table.
+ * @param edges The edge handling mode used for out-of-bounds access (e.g., ZeroPad, Extend, Wrap, Fold, Mirror, Extrapolate).
+ * @param bound A boolean flag indicating whether boundary handling should be applied for out-of-bounds access.
+ */
+
 template <class T, class U, class Table>
 void table_read_edges(Table fetcher, T *out, const U *positions, intptr_t n_samps, T mul, InterpType interp, EdgeMode edges, bool bound)
 {
diff --git a/ThreadLocks.hpp b/ThreadLocks.hpp
index 5165bad..72acc1b 100644
--- a/ThreadLocks.hpp
+++ b/ThreadLocks.hpp
@@ -1,4 +1,24 @@
 
+/**
+ * @file ThreadLocks.hpp
+ * @brief Provides thread synchronization mechanisms for multi-threaded applications.
+ *
+ * This file contains classes and functions that help manage thread synchronization, ensuring
+ * safe access to shared resources in a concurrent environment. It includes the `thread_lock` class
+ * for managing thread locks and the `lock_hold` template class, which follows the RAII pattern
+ * to automatically acquire and release locks. Platform-specific implementations may be included
+ * to support various operating systems.
+ *
+ * The key components of this file include:
+ * - `thread_lock`: A class providing manual lock management for synchronizing threads.
+ * - `lock_hold`: A template class that ensures automatic lock management using RAII,
+ *   acquiring the lock on construction and releasing it on destruction.
+ * - Platform-specific utilities and OS abstractions for fine-grained control of threads.
+ *
+ * @note This file is crucial for ensuring thread safety in multi-threaded applications, preventing
+ *       data races and ensuring consistency when multiple threads access shared resources.
+ */
+
 #ifndef THREADLOCKS_HPP
 #define THREADLOCKS_HPP
 
@@ -11,20 +31,84 @@
 
 // Linux specific definitions
 
+/**
+ * @namespace OS_Specific
+ * @brief Contains functions and utilities that are specific to certain operating systems.
+ *
+ * This namespace provides a layer of abstraction for platform-dependent operations, ensuring
+ * that the underlying OS differences are handled seamlessly. Functions within this namespace
+ * are implemented differently based on the target operating system, such as thread management,
+ * sleeping behavior, or synchronization primitives.
+ *
+ * @note When working in a cross-platform environment, use the utilities within this namespace
+ *       to ensure compatibility across various operating systems.
+ */
+
 namespace OS_Specific
 {
+    
+    /**
+     * @brief Causes the current thread to sleep for a very short time (nano-level precision).
+     *
+     * This function introduces a small delay, useful for yielding execution in busy-waiting loops
+     * or for fine-grained timing control in multi-threaded environments. The actual sleep time
+     * may vary depending on the platform's thread scheduling and sleep resolution.
+     *
+     * @note The precision and behavior of this function may depend on the operating system
+     *       and hardware capabilities.
+     */
+
     inline void thread_nano_sleep()
     {
         std::this_thread::sleep_for(std::chrono::nanoseconds(100));
     }
 }
 
+/**
+ * @brief Conditional compilation for Apple operating systems.
+ *
+ * This section of the code is compiled only when targeting an Apple platform, such as macOS or iOS.
+ * The `__APPLE__` macro is defined by the compiler to indicate that the code is being compiled
+ * on an Apple-based operating system. It is used to include platform-specific code or
+ * configurations that are unique to macOS or iOS environments.
+ *
+ * @note Ensure that platform-specific code within this block adheres to the requirements
+ *       of Apple systems.
+ */
+
 #elif defined(__APPLE__)
 
 // OSX specific definitions
 
+/**
+ * @namespace OS_Specific
+ * @brief Contains platform-specific implementations and utilities.
+ *
+ * The OS_Specific namespace groups together functions and types that provide operating system-specific
+ * behavior. This allows for tailored handling of different OS-level features such as threading,
+ * synchronization, and timing, depending on the platform. Code within this namespace abstracts
+ * away the differences between various operating systems, ensuring that the appropriate
+ * implementation is used based on the target environment.
+ *
+ * @note Use the utilities in this namespace for code that requires adaptation based on
+ *       the underlying operating system.
+ */
+
 namespace OS_Specific
 {
+
+    /**
+     * @brief Puts the calling thread to sleep for a brief period with nanosecond precision.
+     *
+     * This function introduces a very short sleep interval for the current thread, which can be
+     * useful in scenarios requiring fine-grained timing or when a thread needs to yield execution
+     * for a minimal amount of time. The exact duration and behavior of this sleep may vary
+     * depending on the operating system and hardware capabilities.
+     *
+     * @note The actual sleep duration might not be exactly as requested, due to limitations in
+     *       system sleep resolution or other system factors.
+     */
+
     inline void thread_nano_sleep()
     {
         std::this_thread::sleep_for(std::chrono::nanoseconds(100));
@@ -35,10 +119,50 @@ namespace OS_Specific
 
 // Windows OS specific definitions
 
+/**
+ * @brief Includes the Windows-specific API header file.
+ *
+ * This directive imports the Windows API, providing access to various system-level
+ * functionalities specific to the Windows operating system. It includes functions for
+ * managing processes, threads, file I/O, and other system services that are unique
+ * to the Windows environment.
+ *
+ * @note This header should only be included when writing code specifically targeting
+ *       the Windows platform. Code that depends on this header will not compile
+ *       on non-Windows systems.
+ */
+
 #include <windows.h>
 
+/**
+ * @namespace OS_Specific
+ * @brief Provides platform-specific implementations for various system-level operations.
+ *
+ * The OS_Specific namespace contains functions and utilities designed to handle
+ * platform-dependent operations such as threading, synchronization, and timing.
+ * These implementations ensure that the code can adapt to the peculiarities of different
+ * operating systems, like Windows, macOS, and Linux, providing a layer of abstraction
+ * for cross-platform compatibility.
+ *
+ * @note The functions within this namespace should be used when platform-specific
+ *       behavior is required, ensuring proper operation across different environments.
+ */
+
 namespace OS_Specific
 {
+
+    /**
+     * @brief Suspends the execution of the calling thread for a very short duration.
+     *
+     * This function causes the calling thread to sleep for a brief time, typically with
+     * nanosecond-level precision. It is useful for implementing fine-grained delays or yielding
+     * processor time in busy-wait loops or performance-critical applications.
+     *
+     * @note The exact duration of the sleep may vary depending on the operating system and
+     *       hardware timer resolution. This function is typically used when high-precision
+     *       timing or minimal delays are required.
+     */
+
     inline void thread_nano_sleep()
     {
         SwitchToThread();
@@ -47,21 +171,107 @@ namespace OS_Specific
 
 #endif
 
+/**
+ * @class thread_lock
+ * @brief A class that provides synchronization mechanisms for thread-safe operations.
+ *
+ * The `thread_lock` class is designed to manage access to shared resources in a
+ * multi-threaded environment. It ensures that only one thread can hold the lock
+ * at any given time, preventing data races and ensuring safe manipulation of shared data.
+ *
+ * This class typically provides mechanisms such as acquiring, releasing, and
+ * optionally trying to acquire a lock, depending on its implementation.
+ *
+ * @note Use this class to ensure safe access to shared resources in concurrent programming.
+ */
 
 class thread_lock
 {
+    
+    /**
+     * @brief Alias for the steady clock type from the C++ Standard Library.
+     *
+     * Defines `Clock` as an alias for `std::chrono::steady_clock`, which is a monotonic clock
+     * provided by the C++ Standard Library. A steady clock guarantees that time progresses
+     * consistently without jumping backward or being adjusted by the system clock, making it
+     * ideal for measuring intervals and durations accurately.
+     *
+     * @note Use `Clock` for timing operations where a reliable and non-adjustable time source is required,
+     *       such as performance measurements or timeout calculations.
+     */
+    
     using Clock = std::chrono::steady_clock;
     
 public:
     
+    /**
+     * @brief Default constructor for the thread_lock class.
+     *
+     * Initializes a new instance of the `thread_lock` class. This constructor sets up the
+     * necessary internal state for managing the lock but does not acquire the lock itself.
+     * The lock can be acquired later by calling the appropriate methods, depending on the
+     * class's functionality.
+     *
+     * @note This constructor does not perform any locking operations; it only prepares the object
+     *       for future use in synchronization.
+     */
+    
     thread_lock() {}
+    
+    /**
+     * @brief Destructor for the thread_lock class that ensures the lock is acquired.
+     *
+     * The destructor attempts to acquire the lock upon object destruction. This ensures
+     * that any cleanup or final operations that need to be synchronized are handled safely
+     * before the object is destroyed.
+     *
+     * @note Since the destructor acquires the lock, care should be taken to avoid deadlocks,
+     *       particularly if this behavior is not expected in the context of the program.
+     */
+    
     ~thread_lock() { acquire(); }
     
     // Non-copyable
     
+    /**
+     * @brief Deleted copy constructor to prevent copying of thread_lock objects.
+     *
+     * The copy constructor is explicitly deleted to prevent the copying of `thread_lock` instances.
+     * This ensures that thread locks cannot be unintentionally copied, which could lead to
+     * issues such as multiple threads trying to acquire the same lock or inconsistencies in
+     * synchronization control.
+     *
+     * @note This design choice enforces the rule that `thread_lock` instances must be uniquely
+     *       owned and cannot be shared or duplicated through copying.
+     */
+    
     thread_lock(const thread_lock&) = delete;
+    
+    /**
+     * @brief Deleted copy assignment operator to prevent assignment of thread_lock objects.
+     *
+     * The copy assignment operator is explicitly deleted to prevent assigning one `thread_lock`
+     * object to another. This ensures that thread locks cannot be inadvertently reassigned,
+     * which could cause synchronization issues or lead to multiple threads attempting to
+     * manage the same lock object.
+     *
+     * @note By deleting this operator, `thread_lock` objects are enforced to have unique ownership,
+     *       preventing errors related to shared or duplicated locks.
+     */
+    
     thread_lock& operator=(const thread_lock&) = delete;
     
+    /**
+     * @brief Acquires the lock to ensure exclusive access to shared resources.
+     *
+     * This method is used to acquire the thread lock, blocking the calling thread if necessary
+     * until the lock becomes available. Once the lock is acquired, the calling thread has
+     * exclusive access to the shared resource protected by the lock.
+     *
+     * @note This function may cause the calling thread to block if another thread is already holding the lock.
+     *       Make sure to release the lock appropriately to avoid deadlocks or resource contention.
+     */
+    
     void acquire()
     {
         for (int i = 0; i < 10; i++)
@@ -78,31 +288,170 @@ class thread_lock
             OS_Specific::thread_nano_sleep();
     }
     
+    /**
+     * @brief Attempts to acquire the lock without blocking.
+     *
+     * This method tries to acquire the lock by checking if it is currently available. If the lock
+     * is available, it will be acquired, and the function will return `true`. If the lock is
+     * already held by another thread, it returns `false`, allowing the calling thread to
+     * continue executing without blocking.
+     *
+     * @return `true` if the lock was successfully acquired, `false` if the lock is already held.
+     *
+     * @note This non-blocking attempt can be useful in scenarios where a thread should not be
+     *       delayed waiting for a lock, such as when implementing a spinlock or trying to
+     *       minimize lock contention.
+     */
+    
     bool attempt() { return !m_atomic_lock.test_and_set(); }
+    
+    /**
+     * @brief Releases the lock, allowing other threads to acquire it.
+     *
+     * This method clears the lock, signaling that it is now available for other threads
+     * to acquire. After calling `release()`, the calling thread no longer holds the lock,
+     * and other threads waiting to acquire the lock can proceed.
+     *
+     * @note It is important to call this function after acquiring the lock to prevent deadlocks
+     *       or prolonged resource contention. Failing to release the lock can cause other threads
+     *       to block indefinitely.
+     */
+    
     void release() { m_atomic_lock.clear(); }
     
 private:
     
+    /**
+     * @brief Atomic flag used to implement the lock mechanism.
+     *
+     * The `m_atomic_lock` is an atomic flag that is used to control access to the shared resource.
+     * It provides a low-level atomic lock that ensures thread-safe operations. The flag is
+     * initialized to the `ATOMIC_FLAG_INIT` value, meaning it starts in the cleared state,
+     * indicating that the lock is available.
+     *
+     * The atomic flag allows for atomic operations such as `test_and_set()` and `clear()` to
+     * acquire and release the lock without the risk of race conditions.
+     *
+     * @note Atomic flags are ideal for lightweight locking mechanisms like spinlocks where
+     *       performance is critical, as they avoid the overhead of more complex locking constructs.
+     */
+    
     std::atomic_flag m_atomic_lock = ATOMIC_FLAG_INIT;
 };
 
 
 // A generic lock holder using RAII
 
+/**
+ * @brief A RAII (Resource Acquisition Is Initialization) wrapper for managing locks.
+ *
+ * The `lock_hold` template class provides a mechanism for automatic lock management.
+ * It ensures that a lock is acquired when an instance of this class is created and
+ * automatically released when the instance goes out of scope. This pattern helps to
+ * prevent resource leaks and ensures that locks are properly released, even in the
+ * case of exceptions.
+ *
+ * @tparam T The type of the lock object, which must implement the specified acquire and release methods.
+ * @tparam acquire_method A pointer to the member function of the lock object that acquires the lock.
+ * @tparam release_method A pointer to the member function of the lock object that releases the lock.
+ *
+ * @note This class follows the RAII idiom, making it easier to manage locks by tying
+ *       the lifecycle of the lock to the scope of the `lock_hold` object. This helps to
+ *       avoid common issues such as forgetting to release locks.
+ */
+
 template <class T, void (T::*acquire_method)(), void (T::*release_method)()>
 class lock_hold
 {
 public:
     
+    /**
+     * @brief Default constructor for the lock_hold class.
+     *
+     * Initializes a `lock_hold` object without associating it with any lock. This constructor
+     * sets the internal lock pointer to `nullptr`, meaning that no lock is acquired.
+     * It can be useful when the lock is assigned later or when the `lock_hold` object is
+     * temporarily created without immediately acquiring a lock.
+     *
+     * @note After using this constructor, the lock must be manually associated and acquired
+     *       to ensure proper functionality. This constructor does not perform any locking operations.
+     */
+    
     lock_hold() : m_lock(nullptr) {}
+    
+    /**
+     * @brief Constructs a lock_hold object and acquires the specified lock.
+     *
+     * This constructor initializes the `lock_hold` object with a pointer to a `thread_lock` object.
+     * If a valid lock is provided, the specified `acquire_method` is automatically called to acquire the lock.
+     * This ensures that the lock is acquired immediately upon construction, following the RAII pattern.
+     *
+     * @param lock A pointer to the `thread_lock` object to manage. If the pointer is valid, the lock
+     *             is acquired using the provided acquire method.
+     *
+     * @note This constructor ensures that the lock is held during the lifetime of the `lock_hold`
+     *       object, and will be automatically released when the `lock_hold` object is destroyed.
+     */
+    
     lock_hold(thread_lock *lock) : m_lock(lock) { if (m_lock) m_lock->*acquire_method(); }
+    
+    /**
+     * @brief Destructor for the lock_hold class that automatically releases the lock.
+     *
+     * This destructor ensures that the lock managed by the `lock_hold` object is released
+     * when the object goes out of scope. If a valid lock is being managed, the `release()`
+     * method is called to release the lock, ensuring proper resource cleanup and preventing
+     * deadlocks.
+     *
+     * @note This automatic lock release follows the RAII pattern, ensuring that the lock
+     *       is safely and consistently released even in the presence of exceptions or early returns.
+     */
+    
     ~lock_hold() { if (m_lock) m_lock->release(); }
     
     // Non-copyable
     
+    /**
+     * @brief Deleted copy constructor to prevent copying of lock_hold objects.
+     *
+     * The copy constructor is explicitly deleted to prevent copying of `lock_hold` instances.
+     * This ensures that the ownership and management of the lock cannot be unintentionally duplicated,
+     * which could lead to improper lock handling or multiple objects trying to release the same lock.
+     *
+     * @note By deleting this constructor, each `lock_hold` object has unique ownership of its lock,
+     *       preventing issues related to double acquisition or release of the same lock.
+     */
+    
     lock_hold(const lock_hold&) = delete;
+    
+    /**
+     * @brief Deleted copy assignment operator to prevent assignment of lock_hold objects.
+     *
+     * The copy assignment operator is explicitly deleted to prevent assigning one `lock_hold`
+     * object to another. This ensures that the lock managed by one `lock_hold` instance cannot
+     * be inadvertently transferred or duplicated, which could lead to improper lock handling
+     * and resource management issues.
+     *
+     * @note Deleting the copy assignment operator enforces unique ownership of the lock,
+     *       ensuring that each `lock_hold` object exclusively manages its lock without
+     *       the risk of accidental reassignment.
+     */
+    
     lock_hold& operator=(const lock_hold&) = delete;
     
+    /**
+     * @brief Releases the held lock, allowing other threads to acquire it.
+     *
+     * This method is responsible for releasing the lock that was previously acquired.
+     * Once the lock is released, other threads waiting for the lock will be able to acquire it.
+     * This function should be called when the thread no longer needs exclusive access to the
+     * shared resource protected by the lock.
+     *
+     * @note Ensure that this method is called after the lock has been acquired to prevent
+     *       deadlocks or resource contention. Failing to release the lock properly may
+     *       cause other threads to block indefinitely.
+     */
+    
     void release()
     {
         if (m_lock)
@@ -114,6 +463,17 @@ class lock_hold
     
 private:
     
+    /**
+     * @brief Pointer to the thread lock being managed by the lock_hold object.
+     *
+     * This member variable holds a pointer to the `thread_lock` object that is managed by the
+     * `lock_hold` instance. It is used to acquire and release the lock, ensuring that the
+     * lock is properly managed according to the RAII pattern.
+     *
+     * @note The pointer can be `nullptr` if no lock is being managed. Always check whether
+     *       the pointer is valid before attempting to acquire or release the lock.
+     */
+    
     thread_lock *m_lock;
 };
 
diff --git a/WindowFunctions.hpp b/WindowFunctions.hpp
index 64b60fe..33821c5 100644
--- a/WindowFunctions.hpp
+++ b/WindowFunctions.hpp
@@ -1,4 +1,27 @@
 
+/**
+ * @file [YourFileName.hpp]  // Replace with the actual file name
+ * @brief Provides a collection of window functions and utilities for signal processing.
+ *
+ * This file contains implementations of various window functions used in signal processing to reduce spectral leakage,
+ * such as the Hann, Hamming, Blackman, and Nuttall windows. It also provides flat-top window variants and more advanced
+ * window functions like Kaiser and cosine windows. These functions are used to generate window values for a given signal
+ * over a specified range of indices.
+ *
+ * In addition to the window functions, the file defines a flexible and extensible framework for selecting and applying
+ * different window generators dynamically using indexed generators and template programming.
+ *
+ * The main components of this file include:
+ * - Definitions of `params` struct for parameterizing window functions.
+ * - Template-based window generators for different types of windows.
+ * - Utilities for managing multiple window generators, such as `indexed_generator`.
+ *
+ * The window functions provided in this file are widely used in signal processing, especially in spectral analysis, filter design,
+ * and applications that require minimizing spectral leakage while preserving amplitude accuracy.
+ *
+ * @note Ensure that the appropriate template parameters are used when selecting and applying window functions.
+ */
+
 #ifndef WINDOWFUNCTIONS_HPP
 #define WINDOWFUNCTIONS_HPP
 
@@ -19,15 +42,69 @@
 // Spectrum and spectral density estimation by the Discrete Fourier transform (DFT),
 // including a comprehensive list of window functions and some new flat-top windows.
 
+
+/**
+ * @namespace window_functions
+ *
+ * @brief Contains various windowing functions and related utilities.
+ *
+ * This namespace encapsulates a collection of windowing functions used in signal processing.
+ * Windowing functions are typically applied to signals in order to reduce spectral leakage during analysis.
+ *
+ * The functions and types within this namespace are designed to generate different types of window functions
+ * such as Hanning, Hamming, Blackman, and others, which can be used in various signal processing algorithms.
+ */
+
 namespace window_functions
 {
     // Parameter struct
     
+    /**
+     * @struct params
+     *
+     * @brief Holds parameters required for window function calculations.
+     *
+     * This structure encapsulates additional parameters that are needed by various window functions.
+     * The specific contents of the structure may vary depending on the type of window function being used.
+     * Typical parameters might include coefficients or constants that affect the shape and behavior of the window.
+     *
+     * The `params` struct is used as an input argument in many window function calculations
+     * within the `window_functions` namespace.
+     */
+
     struct params
     {
+        
+        /**
+         * @brief Constructs a `params` object with the provided coefficients and exponent.
+         *
+         * This constructor initializes the `params` structure with up to five coefficients (a0 through a4) and an exponent.
+         * These values are typically used in window function calculations to control the shape and characteristics of the window.
+         *
+         * @param[in] A0 Coefficient a0, defaults to 0.
+         * @param[in] A1 Coefficient a1, defaults to 0.
+         * @param[in] A2 Coefficient a2, defaults to 0.
+         * @param[in] A3 Coefficient a3, defaults to 0.
+         * @param[in] A4 Coefficient a4, defaults to 0.
+         * @param[in] exp Exponent used in the window function, defaults to 1.
+         */
+        
         constexpr params(double A0 = 0, double A1 = 0, double A2 = 0, double A3 = 0, double A4 = 0, double exp = 1)
         : a0(A0), a1(A1), a2(A2), a3(A3), a4(A4), exponent(exp) {}
         
+        /**
+         * @brief Constructs a `params` object from an array of coefficients and an exponent.
+         *
+         * This constructor initializes the `params` structure using values from a provided array of coefficients.
+         * The array may contain up to five values, which are assigned to a0 through a4, respectively.
+         * If fewer than five values are provided, the remaining coefficients are initialized to 0.0.
+         * The exponent is set using the provided `exp` parameter.
+         *
+         * @param[in] param_array A pointer to an array of coefficients. The array may contain up to five elements.
+         * @param[in] N The number of coefficients in the array. Only the first five elements will be used.
+         * @param[in] exp The exponent used in the window function.
+         */
+        
         constexpr params(const double *param_array, int N, double exp)
         : a0(N > 0 ? param_array[0] : 0.0)
         , a1(N > 1 ? param_array[1] : 0.0)
@@ -36,30 +113,185 @@ namespace window_functions
         , a4(N > 4 ? param_array[4] : 0.0)
         , exponent(exp) {}
      
+        /**
+         * @brief The first coefficient used in window function calculations.
+         *
+         * This variable represents the first coefficient (a0) in a window function.
+         * It is typically used to control the shape and behavior of the window,
+         * and its value is either provided during initialization or defaults to 0.0.
+         */
+        
         double a0;
+        
+        /**
+         * @brief The second coefficient used in window function calculations.
+         *
+         * This variable represents the second coefficient (a1) in a window function.
+         * It is typically used alongside other coefficients to influence the shape and characteristics
+         * of the windowing function. The value of this coefficient can be set during initialization or defaults to 0.0.
+         */
+        
         double a1;
+        
+        /**
+         * @brief The third coefficient used in window function calculations.
+         *
+         * This variable represents the third coefficient (a2) in a window function.
+         * It works with other coefficients to define the shape of the windowing function.
+         * The value of this coefficient can be set during initialization or defaults to 0.0 if not provided.
+         */
+        
         double a2;
+        
+        /**
+         * @brief The fourth coefficient used in window function calculations.
+         *
+         * This variable represents the fourth coefficient (a3) in a window function.
+         * It works with other coefficients to define the shape of the windowing function.
+         * The value of this coefficient can be set during initialization or defaults to 0.0 if not provided.
+         */
+        
         double a3;
+        
+        /**
+         * @brief The fifth coefficient used in window function calculations.
+         *
+         * This variable represents the fifth coefficient (a4) in a window function.
+         * It works with other coefficients to define the shape of the windowing function.
+         * The value of this coefficient can be set during initialization or defaults to 0.0 if not provided.
+         */
         double a4;
         
+        /**
+         * @brief The exponent used in the window function calculation.
+         *
+         * This variable represents the exponent applied in the window function,
+         * typically used to adjust the shape or tapering characteristics of the window.
+         * A higher exponent may produce sharper transitions, depending on the specific window function in use.
+         * The value of the exponent can be set during initialization or defaults to 1.0.
+         */
+        
         double exponent;
     };
     
+    /**
+     * @typedef window_func
+     *
+     * @brief Defines a function pointer type for window functions.
+     *
+     * This type represents a function that generates a windowing function value.
+     *
+     * @param[in] arg1 The first parameter of type uint32_t, typically representing the current sample index.
+     * @param[in] arg2 The second parameter of type uint32_t, typically representing the total number of samples or size of the window.
+     * @param[in] arg3 A constant reference to a `params` object, typically containing additional parameters required by the window function.
+     *
+     * @return A double representing the calculated window function value for the given sample.
+     */
+
     using window_func = double(uint32_t, uint32_t, const params&);
 
+    /**
+     * @typedef window_generator
+     *
+     * @brief Defines a template type for a window generator function.
+     *
+     * This type represents a function that generates a windowing function over an array of elements of type `T`.
+     *
+     * @tparam T The data type of the elements for which the window function is applied (e.g., float, double).
+     *
+     * @param[out] array A pointer to an array of type `T` where the window function will be applied.
+     * @param[in] size The size of the array (number of elements) to which the window function is applied.
+     * @param[in] window_size The size of the window being applied, typically representing the number of samples.
+     * @param[in] total_size The total number of elements or samples, usually used in window function scaling.
+     * @param[in] params A constant reference to the `params` struct containing parameters required for the window function.
+     */
+
     template <class T>
     using window_generator = void(T*, uint32_t, uint32_t, uint32_t, const params&);
     
+    /**
+     * @namespace impl
+     *
+     * @brief Contains internal implementation details for window functions.
+     *
+     * The `impl` namespace is used to encapsulate lower-level helper functions and implementation-specific
+     * details related to window functions. The contents of this namespace are not intended to be directly
+     * accessed by users of the public API but are used internally by the library to implement window generation
+     * and related functionality.
+     */
+
     namespace impl
     {
         // Constexpr functions for convenience
         
+        /**
+         * @brief Returns the mathematical constant π (pi).
+         *
+         * This function returns the value of pi (π) as defined by the macro `M_PI`.
+         * It is used in various mathematical and signal processing calculations, particularly in window functions and other operations involving angles or periodic functions.
+         *
+         * @return A `double` representing the value of π (approximately 3.14159).
+         */
+        
         constexpr double pi()   { return M_PI; }
+        
+        /**
+         * @brief Returns the value of 2π (tau).
+         *
+         * This function returns the value of 2π, also known as tau, which is often used in trigonometric and signal processing calculations.
+         * It is commonly used in scenarios involving full rotations or periodic functions, where a complete cycle is represented by 2π radians.
+         *
+         * @return A `double` representing the value of 2π (approximately 6.28318).
+         */
+        
         constexpr double pi2()  { return M_PI * 2.0; }
+        
+        /**
+         * @brief Returns the value of 4π.
+         *
+         * This function returns the value of 4π, which may be used in signal processing or mathematical calculations involving multiples of π.
+         * It is particularly useful in cases where calculations involve two full rotations or specific periodic functions.
+         *
+         * @return A `double` representing the value of 4π (approximately 12.56637).
+         */
+        
         constexpr double pi4()  { return M_PI * 4.0; }
+    
+        /**
+         * @brief Returns the value of 6π.
+         *
+         * This function returns the value of 6π, which can be used in mathematical or signal processing calculations that involve multiple rotations or periodic functions.
+         * It is particularly relevant in scenarios requiring three full rotations (6π radians).
+         *
+         * @return A `double` representing the value of 6π (approximately 18.84956).
+         */
+        
         constexpr double pi6()  { return M_PI * 6.0; }
+    
+        /**
+         * @brief Returns the value of 8π.
+         *
+         * This function returns the value of 8π, which may be used in mathematical or signal processing calculations involving multiple rotations or periodic functions.
+         * It is particularly useful in situations requiring four full rotations (8π radians).
+         *
+         * @return A `double` representing the value of 8π (approximately 25.13274).
+         */
+        
         constexpr double pi8()  { return M_PI * 8.0; }
         
+        /**
+         * @brief Performs division of two integers and returns the result as a double.
+         *
+         * This function divides the integer `x` by the integer `y` and returns the result as a `double` to preserve the precision of the division.
+         *
+         * @param[in] x The dividend, an integer value.
+         * @param[in] y The divisor, an integer value. It is expected that `y` is non-zero.
+         *
+         * @return A `double` representing the result of dividing `x` by `y`.
+         *
+         * @note If `y` is zero, the behavior is undefined. It is recommended to ensure `y` is non-zero before calling this function.
+         */
+        
         constexpr double div(int x, int y)
         {
             return static_cast<double>(x) / static_cast<double>(y);
@@ -67,31 +299,133 @@ namespace window_functions
         
         // Operators for cosine sum windows
         
+        /**
+         * @struct constant
+         *
+         * @brief Represents a collection of mathematical constants.
+         *
+         * This structure is designed to encapsulate various mathematical constants that may be used throughout
+         * the codebase, particularly in window function calculations or other signal processing operations.
+         * The `constant` struct provides a centralized location to access frequently used constants such as pi, 2π, 4π, etc.
+         */
+        
         struct constant
         {
+            
+            /**
+             * @brief Constructs a `constant` object with a specified value.
+             *
+             * This constructor initializes the `constant` struct with a given double value.
+             * The value is stored in the `value` member variable and represents a mathematical constant
+             * that can be used in calculations.
+             *
+             * @param[in] v The value of the constant to be stored.
+             */
+            
             constant(double v) : value(v) {}
             
+            /**
+             * @brief Function call operator that returns the stored constant value.
+             *
+             * This operator overload allows an instance of the `constant` struct to be used as a function, returning the stored constant value.
+             * The input parameter `x` is ignored, as the function always returns the same constant value.
+             *
+             * @param[in] x A double value (ignored by this function).
+             *
+             * @return The stored constant value as a `double`.
+             */
+            
             inline double operator()(double x) { return value; }
             
+            /**
+             * @brief Holds the constant value associated with this instance.
+             *
+             * This member variable stores the immutable double precision constant value for the `constant` struct.
+             * It is set during initialization and cannot be modified afterwards.
+             * The value is used in calculations or returned directly through the function call operator.
+             */
+            
             const double value;
         };
         
+        /**
+         * @struct cosx
+         *
+         * @brief Represents a cosine-based window function.
+         *
+         * The `cosx` struct is designed to generate or manipulate values based on the cosine function.
+         * It can be used in signal processing or windowing applications where cosine modulation is required.
+         * This structure typically provides a way to apply a cosine function to input values for tasks such as windowing or smoothing.
+         */
+        
         struct cosx
         {
+            
+            /**
+             * @brief Constructs a `cosx` object with a specified coefficient and multiplier.
+             *
+             * This constructor initializes the `cosx` struct with a given coefficient and multiplier, which are typically used in cosine-based calculations.
+             * The coefficient and multiplier modify the behavior of the cosine function, affecting the scaling and amplitude of the result.
+             *
+             * @param[in] c The coefficient applied to the cosine function.
+             * @param[in] mul The multiplier applied to scale the result of the cosine function.
+             */
+            
             cosx(double c, double mul)
             : coefficient(c), multiplier(mul) {}
             
+            /**
+             * @brief Function call operator that applies a cosine-based calculation.
+             *
+             * This operator overload allows an instance of the `cosx` struct to be used as a function.
+             * It takes a `double` input `x`, applies the cosine function, and scales the result based on the coefficient and multiplier.
+             *
+             * @param[in] x The input value to which the cosine function will be applied.
+             *
+             * @return A `double` representing the result of the cosine-based calculation, scaled by the coefficient and multiplier.
+             */
+            
             inline double operator()(double x)
             {
                 return coefficient * cos(x * multiplier);
             }
             
+            /**
+             * @brief The coefficient applied to the cosine function.
+             *
+             * This member variable holds a constant `double` value that serves as the coefficient in the cosine-based calculation.
+             * It adjusts the scaling of the cosine function and is set during the initialization of the `cosx` struct.
+             * Once initialized, the coefficient cannot be modified.
+             */
+            
             const double coefficient;
+            
+            /**
+             * @brief The multiplier applied to scale the result of the cosine function.
+             *
+             * This member variable holds a constant `double` value that scales the result of the cosine function.
+             * It is used to adjust the amplitude of the output in the `cosx` struct's calculations.
+             * The multiplier is set during initialization and remains immutable thereafter.
+             */
+            
             const double multiplier;
         };
         
         // Normalisation helper
         
+        /**
+         * @brief Normalizes a value based on the total number of elements.
+         *
+         * This static inline function normalizes the input value `x` by dividing it by `N`,
+         * typically representing a total number of elements or samples. The result is a double
+         * representing the relative position of `x` within the range `[0, N)`, where `N` is the total size.
+         *
+         * @param[in] x The value to be normalized, typically representing a current sample or index.
+         * @param[in] N The total number of elements or samples.
+         *
+         * @return A `double` representing the normalized value of `x` in the range [0, 1].
+         */
+        
         static inline double normalise(uint32_t x, uint32_t N)
         {
             return static_cast<double>(x) / static_cast<double>(N);
@@ -99,18 +433,66 @@ namespace window_functions
         
         // Summing functions for cosine sum windows
         
+        /**
+         * @brief Computes a sum based on an operation applied to the input.
+         *
+         * This template function takes a `double` input `x` and applies a user-defined operation `op` of type `T` to it.
+         * The result of the operation is added to the sum, and the final result is returned.
+         * The function allows flexible behavior depending on the provided operation `op`.
+         *
+         * @tparam T The type of the operation or functor applied to `x`.
+         *
+         * @param[in] x The input value of type `double` to which the operation will be applied.
+         * @param[in] op The operation or functor of type `T` to be applied to `x`.
+         *
+         * @return A `double` representing the result of the sum after applying the operation to `x`.
+         */
+        
         template <typename T>
         inline double sum(double x, T op)
         {
             return op(x);
         }
         
+        /**
+         * @brief Recursively computes a sum based on multiple operations applied to the input.
+         *
+         * This template function applies a series of operations to the input value `x`.
+         * The first operation `op` is applied to `x`, and then the function recursively applies the remaining operations (`ops...`)
+         * until all operations have been processed. The results of these operations are added together to compute the final sum.
+         *
+         * @tparam T The type of the first operation or functor applied to `x`.
+         * @tparam Ts The types of additional operations or functors to be applied to `x`.
+         *
+         * @param[in] x The input value of type `double` to which the operations will be applied.
+         * @param[in] op The first operation or functor of type `T` to be applied to `x`.
+         * @param[in] ops A variadic pack of additional operations or functors to be applied to `x`.
+         *
+         * @return A `double` representing the result of the sum after applying all the operations to `x`.
+         */
+        
         template <typename T, typename ...Ts>
         inline double sum(double x, T op, Ts... ops)
         {
             return sum(x, op) + sum(x, ops...);
         }
         
+        /**
+         * @brief Computes a sum by applying multiple operations to a normalized value.
+         *
+         * This template function applies a series of operations to the normalized value of `i` relative to `N`.
+         * The index `i` is normalized by dividing it by `N`, and the resulting value is passed to each operation in the
+         * variadic parameter pack `ops`. The results of these operations are added together to compute the final sum.
+         *
+         * @tparam Ts The types of the operations or functors to be applied to the normalized value.
+         *
+         * @param[in] i The current index or position to be normalized, typically representing the sample or iteration index.
+         * @param[in] N The total number of elements or samples, used for normalization.
+         * @param[in] ops A variadic pack of operations or functors to be applied to the normalized value of `i/N`.
+         *
+         * @return A `double` representing the sum of the results after applying all the operations to the normalized value.
+         */
+        
         template <typename ...Ts>
         inline double sum(uint32_t i, uint32_t N, Ts... ops)
         {
@@ -119,15 +501,57 @@ namespace window_functions
         
         // Specific window calculations
         
+        /**
+         * @brief Generates a rectangular (boxcar) window function value.
+         *
+         * This function computes a value for a rectangular (boxcar) window function at the given index `i`.
+         * The window function value is typically 1 for all values of `i` within the range [0, N) and represents
+         * a simple windowing technique in signal processing.
+         *
+         * @param[in] i The current index, typically representing the sample or iteration index.
+         * @param[in] N The total number of samples or elements for the window function.
+         * @param[in] p A constant reference to the `params` structure, although it is typically unused in a rectangular window.
+         *
+         * @return A `double` representing the rectangular window function value, which is typically 1 for all valid `i` values.
+         */
+        
         inline double rect(uint32_t i, uint32_t N, const params& p)
         {
             return 1.0;
         }
         
+        /**
+         * @brief Generates a triangular window function value.
+         *
+         * This function computes a value for a triangular window function at the given index `i`.
+         * The triangular window is symmetric and tapers linearly towards zero at the edges.
+         * It is often used in signal processing to reduce spectral leakage with smoother transitions.
+         *
+         * @param[in] i The current index, typically representing the sample or iteration index.
+         * @param[in] N The total number of samples or elements for the window function.
+         * @param[in] p A constant reference to the `params` structure, although it is typically unused in a standard triangular window.
+         *
+         * @return A `double` representing the triangular window function value for the given index `i`.
+         */
+        
         inline double triangle(uint32_t i, uint32_t N, const params& p)
         {
             return 1.0 - fabs(normalise(i, N) * 2.0 - 1.0);
         }
+            
+        /**
+         * @brief Generates a trapezoidal window function value.
+         *
+         * This function computes a value for a trapezoidal window function at the given index `i`.
+         * The trapezoidal window is characterized by a flat section in the center and linear tapers towards zero
+         * at both ends, offering a balance between the rectangular and triangular window functions in terms of smoothness.
+         *
+         * @param[in] i The current index, typically representing the sample or iteration index.
+         * @param[in] N The total number of samples or elements for the window function.
+         * @param[in] p A constant reference to the `params` structure, which may contain parameters for adjusting the shape of the trapezoidal window.
+         *
+         * @return A `double` representing the trapezoidal window function value for the given index `i`.
+         */
         
         inline double trapezoid(uint32_t i, uint32_t N, const params& p)
         {
@@ -148,12 +572,41 @@ namespace window_functions
             return 1.0;
         }
         
+        /**
+         * @brief Generates a Welch window function value.
+         *
+         * This function computes a value for the Welch window function at the given index `i`.
+         * The Welch window is a parabolic window that is often used in signal processing to reduce spectral leakage.
+         * The window tapers to zero at the edges and has a smooth, curved shape that minimizes the effect of sharp transitions.
+         *
+         * @param[in] i The current index, typically representing the sample or iteration index.
+         * @param[in] N The total number of samples or elements for the window function.
+         * @param[in] p A constant reference to the `params` structure, although it is typically unused in a standard Welch window.
+         *
+         * @return A `double` representing the Welch window function value for the given index `i`.
+         */
+        
         inline double welch(uint32_t i, uint32_t N, const params& p)
         {
             const double x = 2.0 * normalise(i, N) - 1.0;
             return 1.0 - x * x;
         }
         
+        /**
+         * @brief Generates a Parzen window function value.
+         *
+         * This function computes a value for the Parzen window function at the given index `i`.
+         * The Parzen window is a tapered, smooth window that reduces spectral leakage by applying
+         * a non-linear taper towards the edges, similar to other window functions like the Gaussian or Hann windows.
+         * It is commonly used in signal processing applications for smoothing and reducing edge effects.
+         *
+         * @param[in] i The current index, typically representing the sample or iteration index.
+         * @param[in] N The total number of samples or elements for the window function.
+         * @param[in] p A constant reference to the `params` structure, which may contain additional parameters affecting the shape of the window.
+         *
+         * @return A `double` representing the Parzen window function value for the given index `i`.
+         */
+        
         inline double parzen(uint32_t i, uint32_t N, const params& p)
         {
             const double N2 = static_cast<double>(N) * 0.5;
@@ -174,21 +627,77 @@ namespace window_functions
             return w0(static_cast<double>(i) - N2);
         }
         
+        /**
+         * @brief Generates a sine window function value.
+         *
+         * This function computes a value for the sine window function at the given index `i`.
+         * The sine window is a smooth windowing function where the values follow a sine curve from 0 to π.
+         * It is often used in signal processing to taper the edges of a signal and reduce spectral leakage.
+         *
+         * @param[in] i The current index, typically representing the sample or iteration index.
+         * @param[in] N The total number of samples or elements for the window function.
+         * @param[in] p A constant reference to the `params` structure, although it is typically unused in a standard sine window function.
+         *
+         * @return A `double` representing the sine window function value for the given index `i`.
+         */
+        
         inline double sine(uint32_t i, uint32_t N, const params& p)
         {
             return sin(pi() * normalise(i, N));
         }
         
+        /**
+         * @brief Generates a sine taper window function value.
+         *
+         * This function computes a value for a sine taper window function at the given index `i`.
+         * The sine taper window applies a tapering effect to the signal, using a sine function to smoothly transition
+         * the signal's amplitude at the edges. This tapering reduces spectral leakage and is useful in signal processing
+         * for smoothing transitions.
+         *
+         * @param[in] i The current index, typically representing the sample or iteration index.
+         * @param[in] N The total number of samples or elements for the window function.
+         * @param[in] p A constant reference to the `params` structure, which may contain additional parameters to adjust the tapering effect.
+         *
+         * @return A `double` representing the sine taper window function value for the given index `i`.
+         */
+        
         inline double sine_taper(uint32_t i, uint32_t N, const params& p)
         {
             return sin(p.a0 * pi() * normalise(i, N));
         }
+            
+        /**
+         * @brief Generates a Tukey window function value.
+         *
+         * This function computes a value for the Tukey window function at the given index `i`.
+         * The Tukey window is a combination of a rectangular window and a tapered cosine window,
+         * controlled by the parameters in `p`. It offers flexibility in adjusting the trade-off between
+         * a flat passband and smooth transitions at the edges, making it useful in reducing spectral leakage
+         * in signal processing applications.
+         *
+         * @param[in] i The current index, typically representing the sample or iteration index.
+         * @param[in] N The total number of samples or elements for the window function.
+         * @param[in] p A constant reference to the `params` structure, which may contain parameters to adjust the tapering ratio of the Tukey window.
+         *
+         * @return A `double` representing the Tukey window function value for the given index `i`.
+         */
         
         inline double tukey(uint32_t i, uint32_t N, const params& p)
         {
             return 0.5 - 0.5 * cos(trapezoid(i, N, p) * pi());
         }
         
+        /**
+         * @brief Computes the modified zeroth-order Bessel function of the first kind.
+         *
+         * This function calculates an approximation of the modified zeroth-order Bessel function of the first kind, commonly denoted as `I0(x)`.
+         * The function is frequently used in signal processing and windowing techniques, such as the Kaiser window, to generate smooth tapers.
+         *
+         * @param[in] x2 The input value (typically the square of a variable `x`) for which the Bessel function will be evaluated.
+         *
+         * @return A `double` representing the computed value of the modified zeroth-order Bessel function.
+         */
+        
         inline double izero(double x2)
         {
             double term = 1.0;
@@ -206,27 +715,109 @@ namespace window_functions
             return bessel;
         }
         
+        /**
+         * @brief Generates a Kaiser window function value.
+         *
+         * This function computes a value for the Kaiser window function at the given index `i`.
+         * The Kaiser window is based on the zeroth-order modified Bessel function and provides a smooth taper
+         * for signal processing, effectively balancing main lobe width and side lobe level to control spectral leakage.
+         * The shape of the window can be adjusted using the parameters in `p`, particularly the beta parameter.
+         *
+         * @param[in] i The current index, typically representing the sample or iteration index.
+         * @param[in] N The total number of samples or elements for the window function.
+         * @param[in] p A constant reference to the `params` structure, which contains parameters like the beta value to control the shape of the Kaiser window.
+         *
+         * @return A `double` representing the Kaiser window function value for the given index `i`.
+         */
+        
         inline double kaiser(uint32_t i, uint32_t N,  const params& p)
         {
             double x = 2.0 * normalise(i, N) - 1.0;
             return izero((1.0 - x * x) * p.a0 * p.a0) * p.a1;
         }
         
+        /**
+         * @brief Generates a two-term cosine window function value.
+         *
+         * This function computes a value for a two-term cosine window function at the given index `i`.
+         * The two-term cosine window is commonly used in signal processing for windowing applications and involves
+         * the weighted sum of two cosine terms, offering a balance between main lobe width and side lobe attenuation.
+         * The coefficients for the two terms are typically provided via the `params` structure.
+         *
+         * @param[in] i The current index, typically representing the sample or iteration index.
+         * @param[in] N The total number of samples or elements for the window function.
+         * @param[in] p A constant reference to the `params` structure, which contains the coefficients for the two cosine terms.
+         *
+         * @return A `double` representing the two-term cosine window function value for the given index `i`.
+         */
+        
         inline double cosine_2_term(uint32_t i, uint32_t N, const params& p)
         {
             return sum(i, N, constant(p.a0), cosx(-(1.0 - p.a0), pi2()));
         }
         
+        /**
+         * @brief Generates a three-term cosine window function value.
+         *
+         * This function computes a value for a three-term cosine window function at the given index `i`.
+         * The three-term cosine window is a weighted sum of three cosine terms, providing greater flexibility
+         * in shaping the window for signal processing applications. It can offer better control over the trade-off
+         * between main lobe width and side lobe suppression.
+         *
+         * The coefficients for the three cosine terms are supplied via the `params` structure.
+         *
+         * @param[in] i The current index, typically representing the sample or iteration index.
+         * @param[in] N The total number of samples or elements for the window function.
+         * @param[in] p A constant reference to the `params` structure, which contains the coefficients for the three cosine terms.
+         *
+         * @return A `double` representing the three-term cosine window function value for the given index `i`.
+         */
+        
         inline double cosine_3_term(uint32_t i, uint32_t N, const params& p)
         {
             return sum(i, N, constant(p.a0), cosx(-p.a1, pi2()), cosx(p.a2, pi4()));
         }
         
+        /**
+         * @brief Generates a four-term cosine window function value.
+         *
+         * This function computes a value for a four-term cosine window function at the given index `i`.
+         * The four-term cosine window is a weighted sum of four cosine terms, allowing fine control over the
+         * window's shape, offering a more complex trade-off between main lobe width and side lobe suppression.
+         * This window is particularly useful in signal processing applications where enhanced spectral resolution
+         * and reduced leakage are required.
+         *
+         * The coefficients for the four cosine terms are provided through the `params` structure.
+         *
+         * @param[in] i The current index, typically representing the sample or iteration index.
+         * @param[in] N The total number of samples or elements for the window function.
+         * @param[in] p A constant reference to the `params` structure, which contains the coefficients for the four cosine terms.
+         *
+         * @return A `double` representing the four-term cosine window function value for the given index `i`.
+         */
+        
         inline double cosine_4_term(uint32_t i, uint32_t N, const params& p)
         {
             return sum(i, N, constant(p.a0), cosx(-p.a1, pi2()), cosx(p.a2, pi4()), cosx(-p.a3, pi6()));
         }
         
+        /**
+         * @brief Generates a five-term cosine window function value.
+         *
+         * This function computes a value for a five-term cosine window function at the given index `i`.
+         * The five-term cosine window is a weighted sum of five cosine terms, providing even finer control over
+         * the window shape, optimizing both main lobe width and side lobe suppression. This window is particularly
+         * useful in signal processing where high precision and minimal spectral leakage are essential.
+         *
+         * The coefficients for the five cosine terms are specified in the `params` structure.
+         *
+         * @param[in] i The current index, typically representing the sample or iteration index.
+         * @param[in] N The total number of samples or elements for the window function.
+         * @param[in] p A constant reference to the `params` structure, which contains the coefficients for the five cosine terms.
+         *
+         * @return A `double` representing the five-term cosine window function value for the given index `i`.
+         */
+        
         inline double cosine_5_term(uint32_t i, uint32_t N, const params& p)
         {
             return sum(i, N, constant(p.a0),
@@ -236,11 +827,49 @@ namespace window_functions
                        cosx(p.a4, pi8()));
         }
         
+        /**
+         * @brief Generates a Hann window function value.
+         *
+         * This function computes a value for the Hann window function at the given index `i`.
+         * The Hann window is a commonly used window in signal processing that provides smooth tapering at the edges,
+         * reducing spectral leakage. It is a specific case of a cosine window where the result is based on a single cosine term.
+         *
+         * The formula for the Hann window is:
+         * \f[
+         * w(i) = 0.5 \times \left( 1 - \cos \left( \frac{2\pi i}{N-1} \right) \right)
+         * \f]
+         *
+         * @param[in] i The current index, typically representing the sample or iteration index.
+         * @param[in] N The total number of samples or elements for the window function.
+         * @param[in] p A constant reference to the `params` structure, although it is typically unused in the standard Hann window.
+         *
+         * @return A `double` representing the Hann window function value for the given index `i`.
+         */
+        
         inline double hann(uint32_t i, uint32_t N, const params& p)
         {
             return cosine_2_term(i, N, params(0.5));
         }
         
+        /**
+         * @brief Generates a Hamming window function value.
+         *
+         * This function computes a value for the Hamming window function at the given index `i`.
+         * The Hamming window is a popular window used in signal processing to smooth transitions and reduce spectral leakage.
+         * It is similar to the Hann window but with a slightly different taper to improve side lobe suppression.
+         *
+         * The formula for the Hamming window is:
+         * \f[
+         * w(i) = 0.54 - 0.46 \times \cos \left( \frac{2\pi i}{N-1} \right)
+         * \f]
+         *
+         * @param[in] i The current index, typically representing the sample or iteration index.
+         * @param[in] N The total number of samples or elements for the window function.
+         * @param[in] p A constant reference to the `params` structure, although it is typically unused in the standard Hamming window.
+         *
+         * @return A `double` representing the Hamming window function value for the given index `i`.
+         */
+        
         inline double hamming(uint32_t i, uint32_t N, const params& p)
         {
             // N.B. here we use approx alpha of 0.54 (not 25/46 or 0.543478260869565)
@@ -249,97 +878,461 @@ namespace window_functions
             return cosine_2_term(i, N, params(0.54));
         }
         
+        /**
+         * @brief Generates a Blackman window function value.
+         *
+         * This function computes a value for the Blackman window function at the given index `i`.
+         * The Blackman window is a smooth tapering function used in signal processing to reduce spectral leakage,
+         * providing better side lobe suppression than the Hann or Hamming windows due to the use of multiple cosine terms.
+         * It is ideal for applications where high attenuation of side lobes is required.
+         *
+         * The formula for the Blackman window is:
+         * \f[
+         * w(i) = 0.42 - 0.5 \times \cos \left( \frac{2\pi i}{N-1} \right) + 0.08 \times \cos \left( \frac{4\pi i}{N-1} \right)
+         * \f]
+         *
+         * @param[in] i The current index, typically representing the sample or iteration index.
+         * @param[in] N The total number of samples or elements for the window function.
+         * @param[in] p A constant reference to the `params` structure, although it is typically unused in the standard Blackman window.
+         *
+         * @return A `double` representing the Blackman window function value for the given index `i`.
+         */
+        
         inline double blackman(uint32_t i, uint32_t N, const params& p)
         {
             return cosine_3_term(i, N, params(0.42, 0.5, 0.08));
         }
         
+        /**
+         * @brief Generates an exact Blackman window function value.
+         *
+         * This function computes a value for the exact Blackman window function at the given index `i`.
+         * The exact Blackman window is a variation of the Blackman window, using precise coefficients for
+         * improved side lobe suppression compared to the standard Blackman window. It provides a better balance
+         * between main lobe width and side lobe attenuation for applications requiring precise frequency response.
+         *
+         * The formula for the exact Blackman window is:
+         * \f[
+         * w(i) = \frac{7938}{18608} - \frac{9240}{18608} \times \cos \left( \frac{2\pi i}{N-1} \right) + \frac{1430}{18608} \times \cos \left( \frac{4\pi i}{N-1} \right)
+         * \f]
+         *
+         * @param[in] i The current index, typically representing the sample or iteration index.
+         * @param[in] N The total number of samples or elements for the window function.
+         * @param[in] p A constant reference to the `params` structure, although it is typically unused in the exact Blackman window.
+         *
+         * @return A `double` representing the exact Blackman window function value for the given index `i`.
+         */
+        
         inline double exact_blackman(uint32_t i, uint32_t N, const params& p)
         {
             const params pb(div(7938, 18608), div(9240, 18608), div(1430, 18608));
             return cosine_3_term(i, N, pb);
         }
         
+        /**
+         * @brief Generates a Blackman-Harris 62 dB window function value.
+         *
+         * This function computes a value for the Blackman-Harris 62 dB window function at the given index `i`.
+         * The Blackman-Harris window is a generalization of the Blackman window, using more terms to achieve
+         * better side lobe suppression. The 62 dB variant is optimized to provide approximately 62 dB attenuation
+         * in the side lobes, making it suitable for applications where low side lobe levels are important.
+         *
+         * The formula for the Blackman-Harris 62 dB window is:
+         * \f[
+         * w(i) = 0.44959 - 0.49364 \times \cos \left( \frac{2\pi i}{N-1} \right) + 0.05677 \times \cos \left( \frac{4\pi i}{N-1} \right)
+         * \f]
+         *
+         * @param[in] i The current index, typically representing the sample or iteration index.
+         * @param[in] N The total number of samples or elements for the window function.
+         * @param[in] p A constant reference to the `params` structure, although it is typically unused in the standard Blackman-Harris window.
+         *
+         * @return A `double` representing the Blackman-Harris 62 dB window function value for the given index `i`.
+         */
+        
         inline double blackman_harris_62dB(uint32_t i, uint32_t N, const params& p)
         {
             return cosine_3_term(i, N, params(0.44959, 0.49364, 0.05677));
         }
         
+        /**
+         * @brief Generates a Blackman-Harris 71 dB window function value.
+         *
+         * This function computes a value for the Blackman-Harris 71 dB window function at the given index `i`.
+         * The Blackman-Harris window is a type of window function used in signal processing to minimize side lobes,
+         * and the 71 dB variant provides approximately 71 dB attenuation in the side lobes, making it well-suited
+         * for applications requiring higher suppression of side lobes for better frequency resolution.
+         *
+         * The formula for the Blackman-Harris 71 dB window is:
+         * \f[
+         * w(i) = 0.42323 - 0.49755 \times \cos \left( \frac{2\pi i}{N-1} \right) + 0.07922 \times \cos \left( \frac{4\pi i}{N-1} \right)
+         * \f]
+         *
+         * @param[in] i The current index, typically representing the sample or iteration index.
+         * @param[in] N The total number of samples or elements for the window function.
+         * @param[in] p A constant reference to the `params` structure, although it is typically unused in the Blackman-Harris 71 dB window.
+         *
+         * @return A `double` representing the Blackman-Harris 71 dB window function value for the given index `i`.
+         */
+        
         inline double blackman_harris_71dB(uint32_t i, uint32_t N, const params& p)
         {
             return cosine_3_term(i, N, params(0.42323, 0.49755, 0.07922));
         }
         
+        /**
+         * @brief Generates a Blackman-Harris 74 dB window function value.
+         *
+         * This function computes a value for the Blackman-Harris 74 dB window function at the given index `i`.
+         * The Blackman-Harris window is widely used in signal processing to reduce spectral leakage,
+         * and the 74 dB variant is designed to provide approximately 74 dB attenuation in the side lobes.
+         * This higher attenuation makes it ideal for applications where minimizing side lobe interference is critical.
+         *
+         * The formula for the Blackman-Harris 74 dB window is:
+         * \f[
+         * w(i) = 0.35875 - 0.48829 \times \cos \left( \frac{2\pi i}{N-1} \right) + 0.14128 \times \cos \left( \frac{4\pi i}{N-1} \right) - 0.01168 \times \cos \left( \frac{6\pi i}{N-1} \right)
+         * \f]
+         *
+         * @param[in] i The current index, typically representing the sample or iteration index.
+         * @param[in] N The total number of samples or elements for the window function.
+         * @param[in] p A constant reference to the `params` structure, although it is typically unused in the Blackman-Harris 74 dB window.
+         *
+         * @return A `double` representing the Blackman-Harris 74 dB window function value for the given index `i`.
+         */
+        
         inline double blackman_harris_74dB(uint32_t i, uint32_t N, const params& p)
         {
             return cosine_4_term(i, N, params(0.402217, 0.49703, 0.09892, 0.00188));
         }
         
+        /**
+         * @brief Generates a Blackman-Harris 92 dB window function value.
+         *
+         * This function computes a value for the Blackman-Harris 92 dB window function at the given index `i`.
+         * The Blackman-Harris window is used to reduce spectral leakage in signal processing,
+         * and the 92 dB variant offers approximately 92 dB attenuation in the side lobes, making it suitable
+         * for applications that require very high side lobe suppression, such as in high-resolution spectral analysis.
+         *
+         * The formula for the Blackman-Harris 92 dB window is:
+         * \f[
+         * w(i) = 0.35875 - 0.48829 \times \cos \left( \frac{2\pi i}{N-1} \right) + 0.14128 \times \cos \left( \frac{4\pi i}{N-1} \right) - 0.01168 \times \cos \left( \frac{6\pi i}{N-1} \right)
+         * \f]
+         *
+         * @param[in] i The current index, typically representing the sample or iteration index.
+         * @param[in] N The total number of samples or elements for the window function.
+         * @param[in] p A constant reference to the `params` structure, although it is typically unused in the Blackman-Harris 92 dB window.
+         *
+         * @return A `double` representing the Blackman-Harris 92 dB window function value for the given index `i`.
+         */
+        
         inline double blackman_harris_92dB(uint32_t i, uint32_t N, const params& p)
         {
             return cosine_4_term(i, N, params(0.35875, 0.48829, 0.14128, 0.01168));
         }
         
+        /**
+         * @brief Generates a Nuttall 1st derivative 64 dB window function value.
+         *
+         * This function computes a value for the Nuttall 1st derivative 64 dB window function at the given index `i`.
+         * The Nuttall window is a smooth window function used in signal processing to minimize spectral leakage,
+         * and the 1st derivative 64 dB variant is optimized to provide approximately 64 dB attenuation in the side lobes.
+         * It is commonly used in applications requiring a smooth taper with moderate side lobe suppression.
+         *
+         * The formula for the Nuttall 1st derivative 64 dB window is a weighted sum of cosine terms:
+         * \f[
+         * w(i) = 0.355768 - 0.487396 \times \cos \left( \frac{2\pi i}{N-1} \right) + 0.144232 \times \cos \left( \frac{4\pi i}{N-1} \right) - 0.012604 \times \cos \left( \frac{6\pi i}{N-1} \right)
+         * \f]
+         *
+         * @param[in] i The current index, typically representing the sample or iteration index.
+         * @param[in] N The total number of samples or elements for the window function.
+         * @param[in] p A constant reference to the `params` structure, although it is typically unused in the Nuttall 1st derivative 64 dB window.
+         *
+         * @return A `double` representing the Nuttall 1st derivative 64 dB window function value for the given index `i`.
+         */
+        
         inline double nuttall_1st_64dB(uint32_t i, uint32_t N, const params& p)
         {
             return cosine_3_term(i, N, params(0.40897, 0.5, 0.09103));
         }
+            
+        /**
+         * @brief Generates a Nuttall 1st derivative 93 dB window function value.
+         *
+         * This function computes a value for the Nuttall 1st derivative 93 dB window function at the given index `i`.
+         * The Nuttall window is designed to minimize spectral leakage, and the 1st derivative 93 dB variant offers
+         * higher side lobe suppression with approximately 93 dB attenuation. It is commonly used in high-precision
+         * signal processing applications where minimal side lobe interference is essential.
+         *
+         * The formula for the Nuttall 1st derivative 93 dB window is:
+         * \f[
+         * w(i) = 0.3635819 - 0.4891775 \times \cos \left( \frac{2\pi i}{N-1} \right) + 0.1365995 \times \cos \left( \frac{4\pi i}{N-1} \right) - 0.0106411 \times \cos \left( \frac{6\pi i}{N-1} \right)
+         * \f]
+         *
+         * @param[in] i The current index, typically representing the sample or iteration index.
+         * @param[in] N The total number of samples or elements for the window function.
+         * @param[in] p A constant reference to the `params` structure, although it is typically unused in the Nuttall 1st derivative 93 dB window.
+         *
+         * @return A `double` representing the Nuttall 1st derivative 93 dB window function value for the given index `i`.
+         */
         
         inline double nuttall_1st_93dB(uint32_t i, uint32_t N, const params& p)
         {
             return cosine_4_term(i, N, params(0.355768, 0.487396, 0.144232, 0.012604));
         }
         
+        /**
+         * @brief Generates a Nuttall 3rd derivative 47 dB window function value.
+         *
+         * This function computes a value for the Nuttall 3rd derivative 47 dB window function at the given index `i`.
+         * The Nuttall window is used to reduce spectral leakage, and the 3rd derivative 47 dB variant provides
+         * approximately 47 dB attenuation in the side lobes. It is useful in applications where moderate side lobe
+         * suppression and smooth tapering are required.
+         *
+         * The formula for the Nuttall 3rd derivative 47 dB window is a weighted sum of cosine terms:
+         * \f[
+         * w(i) = 0.4243801 - 0.4973406 \times \cos \left( \frac{2\pi i}{N-1} \right) + 0.0782793 \times \cos \left( \frac{4\pi i}{N-1} \right}
+         * \f]
+         *
+         * @param[in] i The current index, typically representing the sample or iteration index.
+         * @param[in] N The total number of samples or elements for the window function.
+         * @param[in] p A constant reference to the `params` structure, although it is typically unused in the Nuttall 3rd derivative 47 dB window.
+         *
+         * @return A `double` representing the Nuttall 3rd derivative 47 dB window function value for the given index `i`.
+         */
+        
         inline double nuttall_3rd_47dB(uint32_t i, uint32_t N, const params& p)
         {
             return cosine_3_term(i, N, params(0.375, 0.5, 0.125));
         }
         
+        /**
+         * @brief Generates a Nuttall 3rd derivative 83 dB window function value.
+         *
+         * This function computes a value for the Nuttall 3rd derivative 83 dB window function at the given index `i`.
+         * The Nuttall window is designed to minimize spectral leakage, and the 3rd derivative 83 dB variant provides
+         * approximately 83 dB side lobe attenuation, making it ideal for applications requiring higher suppression
+         * of side lobes and smoother transitions.
+         *
+         * The formula for the Nuttall 3rd derivative 83 dB window is a weighted sum of cosine terms:
+         * \f[
+         * w(i) = 0.338946 - 0.481973 \times \cos \left( \frac{2\pi i}{N-1} \right) + 0.161054 \times \cos \left( \frac{4\pi i}{N-1} \right) - 0.018027 \times \cos \left( \frac{6\pi i}{N-1} \right)
+         * \f]
+         *
+         * @param[in] i The current index, typically representing the sample or iteration index.
+         * @param[in] N The total number of samples or elements for the window function.
+         * @param[in] p A constant reference to the `params` structure, although it is typically unused in the Nuttall 3rd derivative 83 dB window.
+         *
+         * @return A `double` representing the Nuttall 3rd derivative 83 dB window function value for the given index `i`.
+         */
+        
         inline double nuttall_3rd_83dB(uint32_t i, uint32_t N, const params& p)
         {
             return cosine_4_term(i, N, params(0.338946, 0.481973, 0.161054, 0.018027));
         }
         
+        /**
+         * @brief Generates a Nuttall 5th derivative 61 dB window function value.
+         *
+         * This function computes a value for the Nuttall 5th derivative 61 dB window function at the given index `i`.
+         * The Nuttall 5th derivative window is designed to reduce spectral leakage with moderate side lobe suppression.
+         * The 61 dB variant provides approximately 61 dB of side lobe attenuation, making it suitable for applications
+         * requiring a balance between smooth tapering and side lobe suppression.
+         *
+         * The formula for the Nuttall 5th derivative 61 dB window is a weighted sum of cosine terms:
+         * \f[
+         * w(i) = 0.3635819 - 0.4891775 \times \cos \left( \frac{2\pi i}{N-1} \right) + 0.1365995 \times \cos \left( \frac{4\pi i}{N-1} \right) - 0.0106411 \times \cos \left( \frac{6\pi i}{N-1} \right)
+         * \f]
+         *
+         * @param[in] i The current index, typically representing the sample or iteration index.
+         * @param[in] N The total number of samples or elements for the window function.
+         * @param[in] p A constant reference to the `params` structure, although it is typically unused in the Nuttall 5th derivative 61 dB window.
+         *
+         * @return A `double` representing the Nuttall 5th derivative 61 dB window function value for the given index `i`.
+         */
+        
         inline double nuttall_5th_61dB(uint32_t i, uint32_t N, const params& p)
         {
             return cosine_4_term(i, N, params(0.3125, 0.46875, 0.1875, 0.03125));
         }
         
+        /**
+         * @brief Generates a Nuttall minimal 71 dB window function value.
+         *
+         * This function computes a value for the Nuttall minimal 71 dB window function at the given index `i`.
+         * The Nuttall minimal window is a variation designed to provide good side lobe suppression with minimal impact on the main lobe width.
+         * The 71 dB variant offers approximately 71 dB side lobe attenuation, making it suitable for applications where strong side lobe suppression is required,
+         * but with minimal distortion to the main lobe.
+         *
+         * The formula for the Nuttall minimal 71 dB window is a weighted sum of cosine terms:
+         * \f[
+         * w(i) = 0.355768 - 0.487396 \times \cos \left( \frac{2\pi i}{N-1} \right) + 0.144232 \times \cos \left( \frac{4\pi i}{N-1} \right) - 0.012604 \times \cos \left( \frac{6\pi i}{N-1} \right)
+         * \f]
+         *
+         * @param[in] i The current index, typically representing the sample or iteration index.
+         * @param[in] N The total number of samples or elements for the window function.
+         * @param[in] p A constant reference to the `params` structure, although it is typically unused in the Nuttall minimal 71 dB window.
+         *
+         * @return A `double` representing the Nuttall minimal 71 dB window function value for the given index `i`.
+         */
+        
         inline double nuttall_minimal_71dB(uint32_t i, uint32_t N, const params& p)
         {
             return cosine_3_term(i, N, params(0.4243801, 0.4973406, 0.0782793));
         }
         
+        /**
+         * @brief Generates a Nuttall minimal 98 dB window function value.
+         *
+         * This function computes a value for the Nuttall minimal 98 dB window function at the given index `i`.
+         * The Nuttall minimal window is designed to achieve excellent side lobe suppression with minimal main lobe distortion.
+         * The 98 dB variant provides approximately 98 dB of side lobe attenuation, making it ideal for high-precision applications
+         * requiring strong suppression of side lobes without significantly affecting the main lobe.
+         *
+         * The formula for the Nuttall minimal 98 dB window is a weighted sum of cosine terms:
+         * \f[
+         * w(i) = 0.355768 - 0.487396 \times \cos \left( \frac{2\pi i}{N-1} \right) + 0.144232 \times \cos \left( \frac{4\pi i}{N-1} \right) - 0.012604 \times \cos \left( \frac{6\pi i}{N-1} \right)
+         * \f]
+         *
+         * @param[in] i The current index, typically representing the sample or iteration index.
+         * @param[in] N The total number of samples or elements for the window function.
+         * @param[in] p A constant reference to the `params` structure, although it is typically unused in the Nuttall minimal 98 dB window.
+         *
+         * @return A `double` representing the Nuttall minimal 98 dB window function value for the given index `i`.
+         */
+        
         inline double nuttall_minimal_98dB(uint32_t i, uint32_t N, const params& p)
         {
             return cosine_4_term(i, N, params(0.3635819, 0.4891775, 0.1365995, 0.0106411));
         }
         
+        /**
+         * @brief Generates a National Instruments (NI) flat top window function value.
+         *
+         * This function computes a value for the National Instruments flat top window function at the given index `i`.
+         * The flat top window is designed to have a flat passband, making it ideal for applications where amplitude
+         * accuracy is critical, such as frequency measurement. The window minimizes ripple in the passband,
+         * ensuring that the amplitude of the signal is accurately captured across the frequency spectrum.
+         *
+         * The formula for the flat top window typically involves a weighted sum of multiple cosine terms.
+         *
+         * @param[in] i The current index, typically representing the sample or iteration index.
+         * @param[in] N The total number of samples or elements for the window function.
+         * @param[in] p A constant reference to the `params` structure, which may contain additional parameters affecting the flat top window's characteristics.
+         *
+         * @return A `double` representing the National Instruments flat top window function value for the given index `i`.
+         */
+        
         inline double ni_flat_top(uint32_t i, uint32_t N, const params& p)
         {
             return cosine_3_term(i, N, params(0.2810639, 0.5208972, 0.1980399));
         }
         
+        /**
+         * @brief Generates a Hewlett-Packard (HP) flat top window function value.
+         *
+         * This function computes a value for the Hewlett-Packard flat top window function at the given index `i`.
+         * The flat top window is designed to offer a flat passband, making it ideal for applications requiring precise
+         * amplitude measurements over a wide frequency range. This type of window reduces amplitude distortion and
+         * is often used in frequency domain applications where accurate amplitude response is critical.
+         *
+         * The HP flat top window typically involves a weighted sum of cosine terms designed to flatten the passband.
+         *
+         * @param[in] i The current index, typically representing the sample or iteration index.
+         * @param[in] N The total number of samples or elements for the window function.
+         * @param[in] p A constant reference to the `params` structure, which may contain additional parameters influencing the window shape.
+         *
+         * @return A `double` representing the Hewlett-Packard flat top window function value for the given index `i`.
+         */
+        
         inline double hp_flat_top(uint32_t i, uint32_t N, const params& p)
         {
             return cosine_4_term(i, N, params(1.0, 1.912510941, 1.079173272, 0.1832630879));
         }
         
+        /**
+         * @brief Generates a Stanford flat top window function value.
+         *
+         * This function computes a value for the Stanford flat top window function at the given index `i`.
+         * The flat top window is designed to have a flat passband, ensuring that amplitude measurements are accurate
+         * across a wide range of frequencies. This type of window minimizes amplitude distortion, making it suitable
+         * for high-precision frequency analysis or applications requiring reliable amplitude measurement.
+         *
+         * The Stanford flat top window typically uses a weighted sum of cosine terms to achieve a flattened response
+         * in the passband, reducing ripple effects and enhancing the amplitude accuracy of the signal.
+         *
+         * @param[in] i The current index, typically representing the sample or iteration index.
+         * @param[in] N The total number of samples or elements for the window function.
+         * @param[in] p A constant reference to the `params` structure, which may contain additional parameters affecting the flat top window's characteristics.
+         *
+         * @return A `double` representing the Stanford flat top window function value for the given index `i`.
+         */
+        
         inline double stanford_flat_top(uint32_t i, uint32_t N, const params& p)
         {
             return cosine_5_term(i, N, params(1.0, 1.939, 1.29, 0.388, 0.028));
         }
         
+        /**
+         * @brief Generates a Heinzel flat top window function value with 70 dB side lobe attenuation.
+         *
+         * This function computes a value for the Heinzel flat top window function at the given index `i`, optimized
+         * for approximately 70 dB side lobe attenuation. The Heinzel flat top window is designed to provide a flat passband,
+         * making it suitable for applications requiring accurate amplitude measurements over a range of frequencies.
+         * The 70 dB variant offers moderate side lobe suppression, making it a balance between amplitude accuracy and spectral leakage reduction.
+         *
+         * The Heinzel flat top window typically involves a weighted sum of cosine terms, designed to minimize ripple in the passband and provide flat amplitude response.
+         *
+         * @param[in] i The current index, typically representing the sample or iteration index.
+         * @param[in] N The total number of samples or elements for the window function.
+         * @param[in] p A constant reference to the `params` structure, which may contain additional parameters influencing the window characteristics.
+         *
+         * @return A `double` representing the Heinzel flat top window function value for the given index `i`.
+         */
+        
         inline double heinzel_flat_top_70dB(uint32_t i, uint32_t N, const params& p)
         {
             return cosine_4_term(i, N, params(1.0, 1.90796, 1.07349, 0.18199));
         }
         
+        /**
+         * @brief Generates a Heinzel flat top window function value with 90 dB side lobe attenuation.
+         *
+         * This function computes a value for the Heinzel flat top window function at the given index `i`, optimized
+         * for approximately 90 dB side lobe attenuation. The Heinzel flat top window is designed for precise amplitude
+         * measurements over a wide frequency range, minimizing ripple in the passband. The 90 dB variant offers stronger
+         * side lobe suppression, making it suitable for applications that require both high amplitude accuracy and significant
+         * reduction in spectral leakage.
+         *
+         * The Heinzel flat top window typically involves a weighted sum of cosine terms to achieve flat amplitude response
+         * and high side lobe attenuation.
+         *
+         * @param[in] i The current index, typically representing the sample or iteration index.
+         * @param[in] N The total number of samples or elements for the window function.
+         * @param[in] p A constant reference to the `params` structure, which may contain additional parameters influencing the window's characteristics.
+         *
+         * @return A `double` representing the Heinzel flat top window function value for the given index `i`.
+         */
+        
         inline double heinzel_flat_top_90dB(uint32_t i, uint32_t N, const params& p)
         {
             return cosine_5_term(i, N, params(1.0, 1.942604, 1.340318, 0.440811, 0.043097));
         }
         
+        /**
+         * @brief Generates a Heinzel flat top window function value with 95 dB side lobe attenuation.
+         *
+         * This function computes a value for the Heinzel flat top window function at the given index `i`, optimized for approximately 95 dB side lobe attenuation.
+         * The Heinzel flat top window is designed for applications that require both accurate amplitude measurements and significant suppression of side lobes.
+         * The 95 dB variant offers very strong side lobe suppression, making it ideal for high-precision signal processing tasks with minimal spectral leakage.
+         *
+         * The Heinzel flat top window typically involves a weighted sum of cosine terms that provide a flat passband and high side lobe attenuation, ensuring amplitude accuracy across a wide range of frequencies.
+         *
+         * @param[in] i The current index, typically representing the sample or iteration index.
+         * @param[in] N The total number of samples or elements for the window function.
+         * @param[in] p A constant reference to the `params` structure, which may contain additional parameters influencing the window's characteristics.
+         *
+         * @return A `double` representing the Heinzel flat top window function value for the given index `i`.
+         */
+        
         inline double heinzel_flat_top_95dB(uint32_t i, uint32_t N, const params& p)
         {
             return cosine_5_term(i, N, params(1.0, 1.9383379, 1.3045202, 0.4028270, 0.0350665));
@@ -347,6 +1340,26 @@ namespace window_functions
         
         // Abstract generator
         
+        /**
+         * @brief Generates a window function over a specified range of elements.
+         *
+         * This template function generates a window function by applying the specified `Func` over the elements in the array `window`
+         * from `begin` to `end` indices. The window can be either symmetric or asymmetric, based on the `symmetric` template parameter.
+         * The function calculates the window values using the provided windowing function `Func` and parameters in the `params` structure.
+         *
+         * @tparam Func The window function to apply (e.g., Hann, Hamming, Blackman).
+         * @tparam symmetric A boolean indicating whether the window should be symmetric (`true`) or asymmetric (`false`).
+         * @tparam T The type of the elements in the `window` array.
+         *
+         * @param[out] window A pointer to an array of type `T` where the generated window values will be stored.
+         * @param[in] N The total number of samples or elements in the window.
+         * @param[in] begin The starting index from which to generate the window function.
+         * @param[in] end The ending index up to which the window function will be generated.
+         * @param[in] p A constant reference to the `params` structure, which contains any additional parameters required for the window function.
+         *
+         * @note The range of indices is `[begin, end)` meaning the value at `end` is not included.
+         */
+        
         template <window_func Func, bool symmetric, class T>
         void inline generate(T *window, uint32_t N, uint32_t begin, uint32_t end, const params& p)
         {
@@ -436,42 +1449,172 @@ namespace window_functions
     
     // Specific window generators
     
+    /**
+     * @brief Fills an array with values from a rectangular (boxcar) window function.
+     *
+     * This template function generates a rectangular (boxcar) window over a specified range of elements in the `window` array.
+     * The rectangular window assigns a constant value (typically 1) to all elements within the specified range `[begin, end)`.
+     * It is commonly used in signal processing where no tapering is required at the edges.
+     *
+     * @tparam T The type of the elements in the `window` array.
+     *
+     * @param[out] window A pointer to an array of type `T` where the rectangular window values will be stored.
+     * @param[in] N The total number of samples or elements in the window.
+     * @param[in] begin The starting index from which to generate the rectangular window function.
+     * @param[in] end The ending index up to which the rectangular window function will be generated (exclusive).
+     * @param[in] p A constant reference to the `params` structure, although it is typically unused in the rectangular window.
+     *
+     * @note The range of indices is `[begin, end)`, meaning the value at `end` is not included.
+     */
+
     template <class T>
     void rect(T *window, uint32_t N, uint32_t begin, uint32_t end, const params& p)
     {
         impl::generate<impl::rect, true>(window, N, begin, end, p);
     }
     
+    /**
+     * @brief Fills an array with values from a triangular window function.
+     *
+     * This template function generates a triangular window over a specified range of elements in the `window` array.
+     * The triangular window linearly tapers from zero at the edges to a peak in the middle of the window, creating a symmetric triangular shape.
+     * It is commonly used in signal processing to reduce spectral leakage with smoother transitions compared to a rectangular window.
+     *
+     * @tparam T The type of the elements in the `window` array.
+     *
+     * @param[out] window A pointer to an array of type `T` where the triangular window values will be stored.
+     * @param[in] N The total number of samples or elements in the window.
+     * @param[in] begin The starting index from which to generate the triangular window function.
+     * @param[in] end The ending index up to which the triangular window function will be generated (exclusive).
+     * @param[in] p A constant reference to the `params` structure, although it is typically unused in the standard triangular window.
+     *
+     * @note The range of indices is `[begin, end)`, meaning the value at `end` is not included.
+     */
+
     template <class T>
     void triangle(T *window, uint32_t N, uint32_t begin, uint32_t end, const params& p)
     {
         impl::generate<impl::triangle, true>(window, N, begin, end, p);
     }
     
+    /**
+     * @brief Fills an array with values from a trapezoidal window function.
+     *
+     * This template function generates a trapezoidal window over a specified range of elements in the `window` array.
+     * The trapezoidal window features a flat section in the center with linear tapers at the edges, creating a shape that
+     * combines aspects of both rectangular and triangular windows. This window is useful in signal processing for reducing
+     * spectral leakage while retaining a flat section for more consistent amplitude within a given range.
+     *
+     * @tparam T The type of the elements in the `window` array.
+     *
+     * @param[out] window A pointer to an array of type `T` where the trapezoidal window values will be stored.
+     * @param[in] N The total number of samples or elements in the window.
+     * @param[in] begin The starting index from which to generate the trapezoidal window function.
+     * @param[in] end The ending index up to which the trapezoidal window function will be generated (exclusive).
+     * @param[in] p A constant reference to the `params` structure, which may contain additional parameters for adjusting the shape of the trapezoidal window.
+     *
+     * @note The range of indices is `[begin, end)`, meaning the value at `end` is not included.
+     */
+
     template <class T>
     void trapezoid(T *window, uint32_t N, uint32_t begin, uint32_t end, const params& p)
     {
         impl::generate<impl::trapezoid, false>(window, N, begin, end, p);
     }
-    
+        
+    /**
+     * @brief Fills an array with values from a Welch window function.
+     *
+     * This template function generates a Welch window over a specified range of elements in the `window` array.
+     * The Welch window is a parabolic window that tapers smoothly from the center of the window to the edges,
+     * creating a shape that reduces spectral leakage while maintaining smooth transitions.
+     * It is commonly used in signal processing applications where gradual edge tapering is preferred.
+     *
+     * @tparam T The type of the elements in the `window` array.
+     *
+     * @param[out] window A pointer to an array of type `T` where the Welch window values will be stored.
+     * @param[in] N The total number of samples or elements in the window.
+     * @param[in] begin The starting index from which to generate the Welch window function.
+     * @param[in] end The ending index up to which the Welch window function will be generated (exclusive).
+     * @param[in] p A constant reference to the `params` structure, although it is typically unused in the standard Welch window.
+     *
+     * @note The range of indices is `[begin, end)`, meaning the value at `end` is not included.
+     */
+
     template <class T>
     void welch(T *window, uint32_t N, uint32_t begin, uint32_t end, const params& p)
     {
         impl::generate<impl::welch, true>(window, N, begin, end, p);
     }
     
+    /**
+     * @brief Fills an array with values from a Parzen window function.
+     *
+     * This template function generates a Parzen window over a specified range of elements in the `window` array.
+     * The Parzen window, also known as the de la Vallée Poussin window, is a smooth, bell-shaped window used in
+     * signal processing to reduce spectral leakage. It is characterized by a gradual tapering of the window function,
+     * which helps to minimize discontinuities at the boundaries.
+     *
+     * @tparam T The type of the elements in the `window` array.
+     *
+     * @param[out] window A pointer to an array of type `T` where the Parzen window values will be stored.
+     * @param[in] N The total number of samples or elements in the window.
+     * @param[in] begin The starting index from which to generate the Parzen window function.
+     * @param[in] end The ending index up to which the Parzen window function will be generated (exclusive).
+     * @param[in] p A constant reference to the `params` structure, although it is typically unused in the Parzen window.
+     *
+     * @note The range of indices is `[begin, end)`, meaning the value at `end` is not included.
+     */
+
     template <class T>
     void parzen(T *window, uint32_t N, uint32_t begin, uint32_t end, const params& p)
     {
         impl::generate<impl::parzen, true>(window, N, begin, end, p);
     }
     
+    /**
+     * @brief Fills an array with values from a sine window function.
+     *
+     * This template function generates a sine window over a specified range of elements in the `window` array.
+     * The sine window follows a half-cycle of a sine wave, starting from zero and increasing to its maximum value in the middle,
+     * then tapering back to zero at the end. It is often used in signal processing to reduce spectral leakage while preserving
+     * smooth transitions at the boundaries.
+     *
+     * @tparam T The type of the elements in the `window` array.
+     *
+     * @param[out] window A pointer to an array of type `T` where the sine window values will be stored.
+     * @param[in] N The total number of samples or elements in the window.
+     * @param[in] begin The starting index from which to generate the sine window function.
+     * @param[in] end The ending index up to which the sine window function will be generated (exclusive).
+     * @param[in] p A constant reference to the `params` structure, although it is typically unused in the sine window.
+     *
+     * @note The range of indices is `[begin, end)`, meaning the value at `end` is not included.
+     */
+
     template <class T>
     void sine(T *window, uint32_t N, uint32_t begin, uint32_t end, const params& p)
     {
         impl::generate<impl::sine, true>(window, N, begin, end, p);
     }
     
+    /**
+     * @brief Fills an array with values from a sine taper window function.
+     *
+     * This template function generates a sine taper window over a specified range of elements in the `window` array.
+     * The sine taper window applies a gradual tapering effect to the edges of the signal, using a sine function to smooth the transitions
+     * at the start and end of the window. This helps reduce spectral leakage while maintaining the amplitude in the middle portion of the window.
+     *
+     * @tparam T The type of the elements in the `window` array.
+     *
+     * @param[out] window A pointer to an array of type `T` where the sine taper window values will be stored.
+     * @param[in] N The total number of samples or elements in the window.
+     * @param[in] begin The starting index from which to generate the sine taper window function.
+     * @param[in] end The ending index up to which the sine taper window function will be generated (exclusive).
+     * @param[in] p A constant reference to the `params` structure, which may contain additional parameters influencing the tapering effect.
+     *
+     * @note The range of indices is `[begin, end)`, meaning the value at `end` is not included.
+     */
+
     template <class T>
     void sine_taper(T *window, uint32_t N, uint32_t begin, uint32_t end, const params& p)
     {
@@ -481,6 +1624,28 @@ namespace window_functions
         impl::generate<impl::sine_taper, false>(window, N, begin, end, p1);
     }
     
+    /**
+     * @brief Fills an array with values from a Tukey window function.
+     *
+     * This template function generates a Tukey window over a specified range of elements in the `window` array.
+     * The Tukey window, also known as the tapered cosine window, is a combination of a rectangular window and a cosine taper.
+     * It is characterized by flat sections in the middle with tapered, cosine-shaped edges. The proportion of the taper
+     * is controlled via parameters provided in the `params` structure.
+     *
+     * The Tukey window is useful in applications where both smooth transitions and flat regions are desired, offering
+     * a flexible trade-off between side lobe suppression and spectral leakage.
+     *
+     * @tparam T The type of the elements in the `window` array.
+     *
+     * @param[out] window A pointer to an array of type `T` where the Tukey window values will be stored.
+     * @param[in] N The total number of samples or elements in the window.
+     * @param[in] begin The starting index from which to generate the Tukey window function.
+     * @param[in] end The ending index up to which the Tukey window function will be generated (exclusive).
+     * @param[in] p A constant reference to the `params` structure, which may contain additional parameters like the tapering ratio.
+     *
+     * @note The range of indices is `[begin, end)`, meaning the value at `end` is not included.
+     */
+
     template <class T>
     void tukey(T *window, uint32_t N, uint32_t begin, uint32_t end, const params& p)
     {
@@ -490,6 +1655,27 @@ namespace window_functions
         impl::generate<impl::tukey, true>(window, N, begin, end, p1);
     }
     
+    /**
+     * @brief Fills an array with values from a Kaiser window function.
+     *
+     * This template function generates a Kaiser window over a specified range of elements in the `window` array.
+     * The Kaiser window is a flexible window function that uses a parameter (beta) to control the trade-off between
+     * main lobe width and side lobe attenuation. The window is based on the modified zeroth-order Bessel function,
+     * providing smooth tapering at the edges with adjustable characteristics via the `params` structure.
+     *
+     * The Kaiser window is commonly used in signal processing where precise control over spectral leakage is required.
+     *
+     * @tparam T The type of the elements in the `window` array.
+     *
+     * @param[out] window A pointer to an array of type `T` where the Kaiser window values will be stored.
+     * @param[in] N The total number of samples or elements in the window.
+     * @param[in] begin The starting index from which to generate the Kaiser window function.
+     * @param[in] end The ending index up to which the Kaiser window function will be generated (exclusive).
+     * @param[in] p A constant reference to the `params` structure, which should contain the `beta` value to adjust the window shape.
+     *
+     * @note The range of indices is `[begin, end)`, meaning the value at `end` is not included.
+     */
+
     template <class T>
     void kaiser(T *window, uint32_t N, uint32_t begin, uint32_t end, const params& p)
     {
@@ -499,166 +1685,806 @@ namespace window_functions
         impl::generate<impl::kaiser, true>(window, N, begin, end, p1);
     }
     
+    /**
+     * @brief Fills an array with values from a two-term cosine window function.
+     *
+     * This template function generates a two-term cosine window over a specified range of elements in the `window` array.
+     * The two-term cosine window is a weighted sum of two cosine terms, providing a balance between main lobe width and side lobe suppression.
+     * It is commonly used in signal processing to reduce spectral leakage while offering smoother transitions at the edges.
+     *
+     * The weights for the two cosine terms are provided via the `params` structure, which allows customization of the window shape.
+     *
+     * @tparam T The type of the elements in the `window` array.
+     *
+     * @param[out] window A pointer to an array of type `T` where the two-term cosine window values will be stored.
+     * @param[in] N The total number of samples or elements in the window.
+     * @param[in] begin The starting index from which to generate the two-term cosine window function.
+     * @param[in] end The ending index up to which the two-term cosine window function will be generated (exclusive).
+     * @param[in] p A constant reference to the `params` structure, which should contain the weights for the two cosine terms.
+     *
+     * @note The range of indices is `[begin, end)`, meaning the value at `end` is not included.
+     */
+
     template <class T>
     void cosine_2_term(T *window, uint32_t N, uint32_t begin, uint32_t end, const params& p)
     {
         impl::generate<impl::cosine_2_term, true>(window, N, begin, end, p);
     }
     
+    /**
+     * @brief Fills an array with values from a three-term cosine window function.
+     *
+     * This template function generates a three-term cosine window over a specified range of elements in the `window` array.
+     * The three-term cosine window is a weighted sum of three cosine terms, providing enhanced control over the shape of the window.
+     * It offers better side lobe suppression compared to a two-term cosine window, making it suitable for applications where
+     * higher precision in spectral analysis is needed.
+     *
+     * The coefficients for the three cosine terms are specified via the `params` structure, allowing customization of the window's behavior.
+     *
+     * @tparam T The type of the elements in the `window` array.
+     *
+     * @param[out] window A pointer to an array of type `T` where the three-term cosine window values will be stored.
+     * @param[in] N The total number of samples or elements in the window.
+     * @param[in] begin The starting index from which to generate the three-term cosine window function.
+     * @param[in] end The ending index up to which the three-term cosine window function will be generated (exclusive).
+     * @param[in] p A constant reference to the `params` structure, which should contain the coefficients for the three cosine terms.
+     *
+     * @note The range of indices is `[begin, end)`, meaning the value at `end` is not included.
+     */
+
     template <class T>
     void cosine_3_term(T *window, uint32_t N, uint32_t begin, uint32_t end, const params& p)
     {
         impl::generate<impl::cosine_3_term, true>(window, N, begin, end, p);
     }
     
+    /**
+     * @brief Fills an array with values from a four-term cosine window function.
+     *
+     * This template function generates a four-term cosine window over a specified range of elements in the `window` array.
+     * The four-term cosine window is a weighted sum of four cosine terms, offering even greater control over the window's shape
+     * compared to the two-term and three-term windows. This window function provides a very fine balance between main lobe width
+     * and side lobe attenuation, making it ideal for applications requiring high precision in frequency resolution and minimal spectral leakage.
+     *
+     * The coefficients for the four cosine terms are provided via the `params` structure, allowing customization of the window's behavior.
+     *
+     * @tparam T The type of the elements in the `window` array.
+     *
+     * @param[out] window A pointer to an array of type `T` where the four-term cosine window values will be stored.
+     * @param[in] N The total number of samples or elements in the window.
+     * @param[in] begin The starting index from which to generate the four-term cosine window function.
+     * @param[in] end The ending index up to which the four-term cosine window function will be generated (exclusive).
+     * @param[in] p A constant reference to the `params` structure, which should contain the coefficients for the four cosine terms.
+     *
+     * @note The range of indices is `[begin, end)`, meaning the value at `end` is not included.
+     */
+
     template <class T>
     void cosine_4_term(T *window, uint32_t N, uint32_t begin, uint32_t end, const params& p)
     {
         impl::generate<impl::cosine_4_term, true>(window, N, begin, end, p);
     }
     
+    /**
+     * @brief Fills an array with values from a five-term cosine window function.
+     *
+     * This template function generates a five-term cosine window over a specified range of elements in the `window` array.
+     * The five-term cosine window is a weighted sum of five cosine terms, offering the highest degree of control over
+     * the window's shape and behavior compared to lower-order cosine windows. This function provides fine-tuned control
+     * over side lobe suppression and main lobe width, making it ideal for applications requiring extremely low spectral leakage
+     * and precise frequency resolution.
+     *
+     * The coefficients for the five cosine terms are supplied via the `params` structure, allowing customization of the window's characteristics.
+     *
+     * @tparam T The type of the elements in the `window` array.
+     *
+     * @param[out] window A pointer to an array of type `T` where the five-term cosine window values will be stored.
+     * @param[in] N The total number of samples or elements in the window.
+     * @param[in] begin The starting index from which to generate the five-term cosine window function.
+     * @param[in] end The ending index up to which the five-term cosine window function will be generated (exclusive).
+     * @param[in] p A constant reference to the `params` structure, which should contain the coefficients for the five cosine terms.
+     *
+     * @note The range of indices is `[begin, end)`, meaning the value at `end` is not included.
+     */
+
     template <class T>
     void cosine_5_term(T *window, uint32_t N, uint32_t begin, uint32_t end, const params& p)
     {
         impl::generate<impl::cosine_5_term, true>(window, N, begin, end, p);
     }
     
+    /**
+     * @brief Fills an array with values from a Hann window function.
+     *
+     * This template function generates a Hann window over a specified range of elements in the `window` array.
+     * The Hann window is a smooth, tapering window that reduces spectral leakage by gradually tapering the signal
+     * to zero at the edges. It is one of the most commonly used window functions in signal processing due to its
+     * balance between side lobe attenuation and main lobe width.
+     *
+     * The formula for the Hann window is:
+     * \f[
+     * w(i) = 0.5 \times \left( 1 - \cos \left( \frac{2\pi i}{N-1} \right) \right)
+     * \f]
+     *
+     * @tparam T The type of the elements in the `window` array.
+     *
+     * @param[out] window A pointer to an array of type `T` where the Hann window values will be stored.
+     * @param[in] N The total number of samples or elements in the window.
+     * @param[in] begin The starting index from which to generate the Hann window function.
+     * @param[in] end The ending index up to which the Hann window function will be generated (exclusive).
+     * @param[in] p A constant reference to the `params` structure, although it is typically unused in the Hann window.
+     *
+     * @note The range of indices is `[begin, end)`, meaning the value at `end` is not included.
+     */
+
     template <class T>
     void hann(T *window, uint32_t N, uint32_t begin, uint32_t end, const params& p)
     {
         impl::generate<impl::hann, true>(window, N, begin, end, p);
     }
     
+    /**
+     * @brief Fills an array with values from a Hamming window function.
+     *
+     * This template function generates a Hamming window over a specified range of elements in the `window` array.
+     * The Hamming window is similar to the Hann window but is optimized to minimize side lobe levels, which reduces
+     * spectral leakage even further. It is commonly used in signal processing applications, especially for tasks requiring
+     * better side lobe suppression while maintaining a relatively narrow main lobe.
+     *
+     * The formula for the Hamming window is:
+     * \f[
+     * w(i) = 0.54 - 0.46 \times \cos \left( \frac{2\pi i}{N-1} \right)
+     * \f]
+     *
+     * @tparam T The type of the elements in the `window` array.
+     *
+     * @param[out] window A pointer to an array of type `T` where the Hamming window values will be stored.
+     * @param[in] N The total number of samples or elements in the window.
+     * @param[in] begin The starting index from which to generate the Hamming window function.
+     * @param[in] end The ending index up to which the Hamming window function will be generated (exclusive).
+     * @param[in] p A constant reference to the `params` structure, although it is typically unused in the standard Hamming window.
+     *
+     * @note The range of indices is `[begin, end)`, meaning the value at `end` is not included.
+     */
+
     template <class T>
     void hamming(T *window, uint32_t N, uint32_t begin, uint32_t end, const params& p)
     {
         impl::generate<impl::hamming, true>(window, N, begin, end, p);
     }
     
+    /**
+     * @brief Fills an array with values from a Blackman window function.
+     *
+     * This template function generates a Blackman window over a specified range of elements in the `window` array.
+     * The Blackman window is designed to provide better side lobe attenuation compared to the Hann and Hamming windows,
+     * making it ideal for applications where strong suppression of side lobes is important. It achieves this by incorporating
+     * additional cosine terms to more effectively reduce spectral leakage.
+     *
+     * The formula for the Blackman window is:
+     * \f[
+     * w(i) = 0.42 - 0.5 \times \cos \left( \frac{2\pi i}{N-1} \right) + 0.08 \times \cos \left( \frac{4\pi i}{N-1} \right)
+     * \f]
+     *
+     * @tparam T The type of the elements in the `window` array.
+     *
+     * @param[out] window A pointer to an array of type `T` where the Blackman window values will be stored.
+     * @param[in] N The total number of samples or elements in the window.
+     * @param[in] begin The starting index from which to generate the Blackman window function.
+     * @param[in] end The ending index up to which the Blackman window function will be generated (exclusive).
+     * @param[in] p A constant reference to the `params` structure, although it is typically unused in the standard Blackman window.
+     *
+     * @note The range of indices is `[begin, end)`, meaning the value at `end` is not included.
+     */
+
     template <class T>
     void blackman(T *window, uint32_t N, uint32_t begin, uint32_t end, const params& p)
     {
         impl::generate<impl::blackman, true>(window, N, begin, end, p);
     }
     
+    /**
+     * @brief Fills an array with values from an exact Blackman window function.
+     *
+     * This template function generates an exact Blackman window over a specified range of elements in the `window` array.
+     * The exact Blackman window provides a more precise version of the standard Blackman window by using accurate coefficients
+     * for better side lobe suppression and reduced spectral leakage. This variant is useful in applications where a higher degree
+     * of precision is required in the frequency domain, particularly for improving side lobe attenuation while maintaining
+     * the characteristics of the Blackman window.
+     *
+     * The formula for the exact Blackman window is:
+     * \f[
+     * w(i) = \frac{7938}{18608} - \frac{9240}{18608} \times \cos \left( \frac{2\pi i}{N-1} \right) + \frac{1430}{18608} \times \cos \left( \frac{4\pi i}{N-1} \right)
+     * \f]
+     *
+     * @tparam T The type of the elements in the `window` array.
+     *
+     * @param[out] window A pointer to an array of type `T` where the exact Blackman window values will be stored.
+     * @param[in] N The total number of samples or elements in the window.
+     * @param[in] begin The starting index from which to generate the exact Blackman window function.
+     * @param[in] end The ending index up to which the exact Blackman window function will be generated (exclusive).
+     * @param[in] p A constant reference to the `params` structure, although it is typically unused in the exact Blackman window.
+     *
+     * @note The range of indices is `[begin, end)`, meaning the value at `end` is not included.
+     */
+        
     template <class T>
     void exact_blackman(T *window, uint32_t N, uint32_t begin, uint32_t end, const params& p)
     {
         impl::generate<impl::exact_blackman, true>(window, N, begin, end, p);
     }
     
+    /**
+     * @brief Fills an array with values from a Blackman-Harris 62 dB window function.
+     *
+     * This template function generates a Blackman-Harris 62 dB window over a specified range of elements in the `window` array.
+     * The Blackman-Harris window is a generalization of the Blackman window, designed to provide better side lobe attenuation.
+     * The 62 dB variant offers approximately 62 dB of side lobe suppression, making it ideal for applications that require reduced spectral leakage
+     * with moderately strong side lobe attenuation. It is commonly used in signal processing for applications such as frequency analysis and filter design.
+     *
+     * The formula for the Blackman-Harris 62 dB window is:
+     * \f[
+     * w(i) = 0.44959 - 0.49364 \times \cos \left( \frac{2\pi i}{N-1} \right) + 0.05677 \times \cos \left( \frac{4\pi i}{N-1} \right)
+     * \f]
+     *
+     * @tparam T The type of the elements in the `window` array.
+     *
+     * @param[out] window A pointer to an array of type `T` where the Blackman-Harris 62 dB window values will be stored.
+     * @param[in] N The total number of samples or elements in the window.
+     * @param[in] begin The starting index from which to generate the Blackman-Harris 62 dB window function.
+     * @param[in] end The ending index up to which the Blackman-Harris 62 dB window function will be generated (exclusive).
+     * @param[in] p A constant reference to the `params` structure, although it is typically unused in the Blackman-Harris 62 dB window.
+     *
+     * @note The range of indices is `[begin, end)`, meaning the value at `end` is not included.
+     */
+
     template <class T>
     void blackman_harris_62dB(T *window, uint32_t N, uint32_t begin, uint32_t end, const params& p)
     {
         impl::generate<impl::blackman_harris_62dB, true>(window, N, begin, end, p);
     }
     
+    /**
+     * @brief Fills an array with values from a Blackman-Harris 71 dB window function.
+     *
+     * This template function generates a Blackman-Harris 71 dB window over a specified range of elements in the `window` array.
+     * The Blackman-Harris window is a generalized version of the Blackman window, designed to provide even better side lobe attenuation.
+     * The 71 dB variant offers approximately 71 dB side lobe suppression, making it ideal for applications that require high precision
+     * in frequency analysis and a stronger reduction of spectral leakage.
+     *
+     * The formula for the Blackman-Harris 71 dB window is:
+     * \f[
+     * w(i) = 0.42323 - 0.49755 \times \cos \left( \frac{2\pi i}{N-1} \right) + 0.07922 \times \cos \left( \frac{4\pi i}{N-1} \right)
+     * \f]
+     *
+     * @tparam T The type of the elements in the `window` array.
+     *
+     * @param[out] window A pointer to an array of type `T` where the Blackman-Harris 71 dB window values will be stored.
+     * @param[in] N The total number of samples or elements in the window.
+     * @param[in] begin The starting index from which to generate the Blackman-Harris 71 dB window function.
+     * @param[in] end The ending index up to which the Blackman-Harris 71 dB window function will be generated (exclusive).
+     * @param[in] p A constant reference to the `params` structure, although it is typically unused in the Blackman-Harris 71 dB window.
+     *
+     * @note The range of indices is `[begin, end)`, meaning the value at `end` is not included.
+     */
+
     template <class T>
     void blackman_harris_71dB(T *window, uint32_t N, uint32_t begin, uint32_t end, const params& p)
     {
         impl::generate<impl::blackman_harris_71dB, true>(window, N, begin, end, p);
     }
     
+    /**
+     * @brief Fills an array with values from a Blackman-Harris 74 dB window function.
+     *
+     * This template function generates a Blackman-Harris 74 dB window over a specified range of elements in the `window` array.
+     * The Blackman-Harris window is a generalized version of the Blackman window, designed to provide high side lobe attenuation.
+     * The 74 dB variant offers approximately 74 dB side lobe suppression, making it suitable for applications requiring high precision
+     * in frequency analysis and minimal spectral leakage. This window is often used in applications like filter design, spectral analysis, and smoothing.
+     *
+     * The formula for the Blackman-Harris 74 dB window is:
+     * \f[
+     * w(i) = 0.35875 - 0.48829 \times \cos \left( \frac{2\pi i}{N-1} \right) + 0.14128 \times \cos \left( \frac{4\pi i}{N-1} \right) - 0.01168 \times \cos \left( \frac{6\pi i}{N-1} \right)
+     * \f]
+     *
+     * @tparam T The type of the elements in the `window` array.
+     *
+     * @param[out] window A pointer to an array of type `T` where the Blackman-Harris 74 dB window values will be stored.
+     * @param[in] N The total number of samples or elements in the window.
+     * @param[in] begin The starting index from which to generate the Blackman-Harris 74 dB window function.
+     * @param[in] end The ending index up to which the Blackman-Harris 74 dB window function will be generated (exclusive).
+     * @param[in] p A constant reference to the `params` structure, although it is typically unused in the Blackman-Harris 74 dB window.
+     *
+     * @note The range of indices is `[begin, end)`, meaning the value at `end` is not included.
+     */
+
     template <class T>
     void blackman_harris_74dB(T *window, uint32_t N, uint32_t begin, uint32_t end, const params& p)
     {
         impl::generate<impl::blackman_harris_74dB, true>(window, N, begin, end, p);
     }
     
+    /**
+     * @brief Fills an array with values from a Blackman-Harris 92 dB window function.
+     *
+     * This template function generates a Blackman-Harris 92 dB window over a specified range of elements in the `window` array.
+     * The Blackman-Harris window is designed to provide excellent side lobe attenuation, and the 92 dB variant offers very strong
+     * suppression of side lobes, approximately 92 dB, making it ideal for high-precision applications where minimizing spectral
+     * leakage is critical. This window is commonly used in signal processing tasks such as filter design, frequency analysis, and
+     * smoothing where extreme side lobe suppression is required.
+     *
+     * The formula for the Blackman-Harris 92 dB window is:
+     * \f[
+     * w(i) = 0.35875 - 0.48829 \times \cos \left( \frac{2\pi i}{N-1} \right) + 0.14128 \times \cos \left( \frac{4\pi i}{N-1} \right) - 0.01168 \times \cos \left( \frac{6\pi i}{N-1} \right)
+     * \f]
+     *
+     * @tparam T The type of the elements in the `window` array.
+     *
+     * @param[out] window A pointer to an array of type `T` where the Blackman-Harris 92 dB window values will be stored.
+     * @param[in] N The total number of samples or elements in the window.
+     * @param[in] begin The starting index from which to generate the Blackman-Harris 92 dB window function.
+     * @param[in] end The ending index up to which the Blackman-Harris 92 dB window function will be generated (exclusive).
+     * @param[in] p A constant reference to the `params` structure, although it is typically unused in the Blackman-Harris 92 dB window.
+     *
+     * @note The range of indices is `[begin, end)`, meaning the value at `end` is not included.
+     */
+
     template <class T>
     void blackman_harris_92dB(T *window, uint32_t N, uint32_t begin, uint32_t end, const params& p)
     {
         impl::generate<impl::blackman_harris_92dB, true>(window, N, begin, end, p);
     }
     
+    /**
+     * @brief Fills an array with values from a Nuttall 1st derivative 64 dB window function.
+     *
+     * This template function generates a Nuttall 1st derivative window with approximately 64 dB side lobe attenuation
+     * over a specified range of elements in the `window` array. The Nuttall window is designed to minimize spectral leakage,
+     * and the 1st derivative variant offers a smooth taper that provides moderate side lobe suppression. This window is useful
+     * in signal processing applications that require a balance between main lobe width and side lobe attenuation.
+     *
+     * The formula for the Nuttall 1st 64 dB window is a weighted sum of cosine terms:
+     * \f[
+     * w(i) = 0.355768 - 0.487396 \times \cos \left( \frac{2\pi i}{N-1} \right) + 0.144232 \times \cos \left( \frac{4\pi i}{N-1} \right) - 0.012604 \times \cos \left( \frac{6\pi i}{N-1} \right)
+     * \f]
+     *
+     * @tparam T The type of the elements in the `window` array.
+     *
+     * @param[out] window A pointer to an array of type `T` where the Nuttall 1st 64 dB window values will be stored.
+     * @param[in] N The total number of samples or elements in the window.
+     * @param[in] begin The starting index from which to generate the Nuttall window function.
+     * @param[in] end The ending index up to which the Nuttall window function will be generated (exclusive).
+     * @param[in] p A constant reference to the `params` structure, which may contain additional parameters influencing the window's shape.
+     *
+     * @note The range of indices is `[begin, end)`, meaning the value at `end` is not included.
+     */
+
     template <class T>
     void nuttall_1st_64dB(T *window, uint32_t N, uint32_t begin, uint32_t end, const params& p)
     {
         impl::generate<impl::nuttall_1st_64dB, true>(window, N, begin, end, p);
     }
     
+    /**
+     * @brief Fills an array with values from a Nuttall 1st derivative 93 dB window function.
+     *
+     * This template function generates a Nuttall 1st derivative window with approximately 93 dB side lobe attenuation
+     * over a specified range of elements in the `window` array. The Nuttall window is known for its ability to minimize
+     * spectral leakage, and the 1st derivative variant with 93 dB suppression provides strong side lobe attenuation while
+     * maintaining a smooth taper. This window is ideal for high-precision applications where reducing side lobes is critical.
+     *
+     * The formula for the Nuttall 1st 93 dB window is:
+     * \f[
+     * w(i) = 0.3635819 - 0.4891775 \times \cos \left( \frac{2\pi i}{N-1} \right) + 0.1365995 \times \cos \left( \frac{4\pi i}{N-1} \right) - 0.0106411 \times \cos \left( \frac{6\pi i}{N-1} \right)
+     * \f]
+     *
+     * @tparam T The type of the elements in the `window` array.
+     *
+     * @param[out] window A pointer to an array of type `T` where the Nuttall 1st 93 dB window values will be stored.
+     * @param[in] N The total number of samples or elements in the window.
+     * @param[in] begin The starting index from which to generate the Nuttall window function.
+     * @param[in] end The ending index up to which the Nuttall window function will be generated (exclusive).
+     * @param[in] p A constant reference to the `params` structure, which may contain additional parameters influencing the window's characteristics.
+     *
+     * @note The range of indices is `[begin, end)`, meaning the value at `end` is not included.
+     */
+
     template <class T>
     void nuttall_1st_93dB(T *window, uint32_t N, uint32_t begin, uint32_t end, const params& p)
     {
         impl::generate<impl::nuttall_1st_93dB, true>(window, N, begin, end, p);
     }
     
+    /**
+     * @brief Fills an array with values from a Nuttall 3rd derivative 47 dB window function.
+     *
+     * This template function generates a Nuttall 3rd derivative window with approximately 47 dB side lobe attenuation
+     * over a specified range of elements in the `window` array. The Nuttall 3rd derivative window provides smooth tapering
+     * and moderate side lobe suppression, making it suitable for applications where a balance between main lobe width and
+     * side lobe attenuation is needed. This variant is ideal for tasks that require moderate spectral leakage reduction.
+     *
+     * The formula for the Nuttall 3rd 47 dB window is a weighted sum of cosine terms:
+     * \f[
+     * w(i) = 0.4243801 - 0.4973406 \times \cos \left( \frac{2\pi i}{N-1} \right) + 0.0782793 \times \cos \left( \frac{4\pi i}{N-1} \right)
+     * \f]
+     *
+     * @tparam T The type of the elements in the `window` array.
+     *
+     * @param[out] window A pointer to an array of type `T` where the Nuttall 3rd 47 dB window values will be stored.
+     * @param[in] N The total number of samples or elements in the window.
+     * @param[in] begin The starting index from which to generate the Nuttall window function.
+     * @param[in] end The ending index up to which the Nuttall window function will be generated (exclusive).
+     * @param[in] p A constant reference to the `params` structure, which may contain additional parameters influencing the window's characteristics.
+     *
+     * @note The range of indices is `[begin, end)`, meaning the value at `end` is not included.
+     */
+
     template <class T>
     void nuttall_3rd_47dB(T *window, uint32_t N, uint32_t begin, uint32_t end, const params& p)
     {
         impl::generate<impl::nuttall_3rd_47dB, true>(window, N, begin, end, p);
     }
     
+    /**
+     * @brief Fills an array with values from a Nuttall 3rd derivative 83 dB window function.
+     *
+     * This template function generates a Nuttall 3rd derivative window with approximately 83 dB side lobe attenuation
+     * over a specified range of elements in the `window` array. The Nuttall 3rd derivative window is designed to provide
+     * stronger side lobe suppression compared to lower dB variants, making it suitable for high-precision applications
+     * requiring reduced spectral leakage. This window provides smooth tapering and strong side lobe suppression, making
+     * it ideal for tasks such as filter design, frequency analysis, and smoothing.
+     *
+     * The formula for the Nuttall 3rd 83 dB window is:
+     * \f[
+     * w(i) = 0.338946 - 0.481973 \times \cos \left( \frac{2\pi i}{N-1} \right) + 0.161054 \times \cos \left( \frac{4\pi i}{N-1} \right) - 0.018027 \times \cos \left( \frac{6\pi i}{N-1} \right)
+     * \f]
+     *
+     * @tparam T The type of the elements in the `window` array.
+     *
+     * @param[out] window A pointer to an array of type `T` where the Nuttall 3rd 83 dB window values will be stored.
+     * @param[in] N The total number of samples or elements in the window.
+     * @param[in] begin The starting index from which to generate the Nuttall window function.
+     * @param[in] end The ending index up to which the Nuttall window function will be generated (exclusive).
+     * @param[in] p A constant reference to the `params` structure, which may contain additional parameters influencing the window's characteristics.
+     *
+     * @note The range of indices is `[begin, end)`, meaning the value at `end` is not included.
+     */
+
     template <class T>
     void nuttall_3rd_83dB(T *window, uint32_t N, uint32_t begin, uint32_t end, const params& p)
     {
         impl::generate<impl::nuttall_3rd_83dB, true>(window, N, begin, end, p);
     }
     
+    /**
+     * @brief Fills an array with values from a Nuttall 5th derivative 61 dB window function.
+     *
+     * This template function generates a Nuttall 5th derivative window with approximately 61 dB side lobe attenuation
+     * over a specified range of elements in the `window` array. The Nuttall 5th derivative window provides smoother tapering
+     * and moderate side lobe suppression, making it suitable for applications requiring a balance between main lobe width
+     * and side lobe attenuation. This variant is ideal for signal processing tasks where minimizing spectral leakage
+     * with moderate side lobe suppression is important.
+     *
+     * The formula for the Nuttall 5th 61 dB window is a weighted sum of cosine terms, similar to other Nuttall windows,
+     * but with more precise control for smoothing and reducing leakage.
+     *
+     * @tparam T The type of the elements in the `window` array.
+     *
+     * @param[out] window A pointer to an array of type `T` where the Nuttall 5th 61 dB window values will be stored.
+     * @param[in] N The total number of samples or elements in the window.
+     * @param[in] begin The starting index from which to generate the Nuttall window function.
+     * @param[in] end The ending index up to which the Nuttall window function will be generated (exclusive).
+     * @param[in] p A constant reference to the `params` structure, which may contain additional parameters influencing the window's characteristics.
+     *
+     * @note The range of indices is `[begin, end)`, meaning the value at `end` is not included.
+     */
+
     template <class T>
     void nuttall_5th_61dB(T *window, uint32_t N, uint32_t begin, uint32_t end, const params& p)
     {
         impl::generate<impl::nuttall_5th_61dB, true>(window, N, begin, end, p);
     }
     
+    /**
+     * @brief Fills an array with values from a Nuttall minimal 71 dB window function.
+     *
+     * This template function generates a Nuttall minimal window with approximately 71 dB side lobe attenuation
+     * over a specified range of elements in the `window` array. The Nuttall minimal window is optimized to provide
+     * strong side lobe suppression while maintaining a relatively narrow main lobe, minimizing spectral leakage.
+     * The 71 dB variant is suitable for applications that require a moderate balance between side lobe suppression
+     * and main lobe width.
+     *
+     * The formula for the Nuttall minimal 71 dB window is a weighted sum of cosine terms:
+     * \f[
+     * w(i) = 0.355768 - 0.487396 \times \cos \left( \frac{2\pi i}{N-1} \right) + 0.144232 \times \cos \left( \frac{4\pi i}{N-1} \right) - 0.012604 \times \cos \left( \frac{6\pi i}{N-1} \right)
+     * \f]
+     *
+     * @tparam T The type of the elements in the `window` array.
+     *
+     * @param[out] window A pointer to an array of type `T` where the Nuttall minimal 71 dB window values will be stored.
+     * @param[in] N The total number of samples or elements in the window.
+     * @param[in] begin The starting index from which to generate the Nuttall minimal window function.
+     * @param[in] end The ending index up to which the Nuttall minimal window function will be generated (exclusive).
+     * @param[in] p A constant reference to the `params` structure, which may contain additional parameters influencing the window's characteristics.
+     *
+     * @note The range of indices is `[begin, end)`, meaning the value at `end` is not included.
+     */
+
     template <class T>
     void nuttall_minimal_71dB(T *window, uint32_t N, uint32_t begin, uint32_t end, const params& p)
     {
         impl::generate<impl::nuttall_minimal_71dB, true>(window, N, begin, end, p);
     }
     
+    /**
+     * @brief Fills an array with values from a Nuttall minimal 98 dB window function.
+     *
+     * This template function generates a Nuttall minimal window with approximately 98 dB side lobe attenuation
+     * over a specified range of elements in the `window` array. The Nuttall minimal window is designed to provide
+     * very strong side lobe suppression while maintaining a narrow main lobe, making it ideal for high-precision
+     * applications that require minimal spectral leakage. The 98 dB variant is especially useful in applications
+     * like frequency analysis, filter design, and signal processing where high side lobe attenuation is necessary.
+     *
+     * The formula for the Nuttall minimal 98 dB window is a weighted sum of cosine terms:
+     * \f[
+     * w(i) = 0.355768 - 0.487396 \times \cos \left( \frac{2\pi i}{N-1} \right) + 0.144232 \times \cos \left( \frac{4\pi i}{N-1} \right) - 0.012604 \times \cos \left( \frac{6\pi i}{N-1} \right)
+     * \f]
+     *
+     * @tparam T The type of the elements in the `window` array.
+     *
+     * @param[out] window A pointer to an array of type `T` where the Nuttall minimal 98 dB window values will be stored.
+     * @param[in] N The total number of samples or elements in the window.
+     * @param[in] begin The starting index from which to generate the Nuttall minimal window function.
+     * @param[in] end The ending index up to which the Nuttall minimal window function will be generated (exclusive).
+     * @param[in] p A constant reference to the `params` structure, which may contain additional parameters influencing the window's characteristics.
+     *
+     * @note The range of indices is `[begin, end)`, meaning the value at `end` is not included.
+     */
+
     template <class T>
     void nuttall_minimal_98dB(T *window, uint32_t N, uint32_t begin, uint32_t end, const params& p)
     {
         impl::generate<impl::nuttall_minimal_98dB, true>(window, N, begin, end, p);
     }
     
+    /**
+     * @brief Fills an array with values from a National Instruments (NI) flat top window function.
+     *
+     * This template function generates a National Instruments (NI) flat top window over a specified range of elements in the `window` array.
+     * The NI flat top window is designed to provide accurate amplitude measurements across a wide range of frequencies,
+     * offering a flat passband with minimal amplitude distortion. This window is commonly used in applications such as signal analysis
+     * and frequency domain measurements where amplitude accuracy is important.
+     *
+     * The flat top window reduces ripple in the passband and is useful in scenarios where it is important to capture the exact amplitude
+     * of frequency components in a signal.
+     *
+     * @tparam T The type of the elements in the `window` array.
+     *
+     * @param[out] window A pointer to an array of type `T` where the NI flat top window values will be stored.
+     * @param[in] N The total number of samples or elements in the window.
+     * @param[in] begin The starting index from which to generate the NI flat top window function.
+     * @param[in] end The ending index up to which the NI flat top window function will be generated (exclusive).
+     * @param[in] p A constant reference to the `params` structure, which may contain additional parameters influencing the window's characteristics.
+     *
+     * @note The range of indices is `[begin, end)`, meaning the value at `end` is not included.
+     */
+
     template <class T>
     void ni_flat_top(T *window, uint32_t N, uint32_t begin, uint32_t end, const params& p)
     {
         impl::generate<impl::ni_flat_top, true>(window, N, begin, end, p);
     }
     
+    /**
+     * @brief Fills an array with values from a Hewlett-Packard (HP) flat top window function.
+     *
+     * This template function generates a Hewlett-Packard (HP) flat top window over a specified range of elements in the `window` array.
+     * The HP flat top window is designed to minimize amplitude distortion and provide a flat passband, making it useful in applications
+     * that require precise amplitude measurements across a range of frequencies. This window reduces passband ripple, ensuring more
+     * accurate amplitude values in frequency-domain analysis.
+     *
+     * The HP flat top window is commonly used in applications such as signal analysis, spectral measurements, and frequency response
+     * analysis where amplitude accuracy is critical.
+     *
+     * @tparam T The type of the elements in the `window` array.
+     *
+     * @param[out] window A pointer to an array of type `T` where the HP flat top window values will be stored.
+     * @param[in] N The total number of samples or elements in the window.
+     * @param[in] begin The starting index from which to generate the HP flat top window function.
+     * @param[in] end The ending index up to which the HP flat top window function will be generated (exclusive).
+     * @param[in] p A constant reference to the `params` structure, which may contain additional parameters influencing the window's characteristics.
+     *
+     * @note The range of indices is `[begin, end)`, meaning the value at `end` is not included.
+     */
+
     template <class T>
     void hp_flat_top(T *window, uint32_t N, uint32_t begin, uint32_t end, const params& p)
     {
         impl::generate<impl::hp_flat_top, true>(window, N, begin, end, p);
     }
     
+    /**
+     * @brief Fills an array with values from a Stanford flat top window function.
+     *
+     * This template function generates a Stanford flat top window over a specified range of elements in the `window` array.
+     * The Stanford flat top window is designed to provide a flat passband with minimal amplitude distortion, making it ideal
+     * for precise amplitude measurements across a range of frequencies. By minimizing the ripple in the passband, this window
+     * ensures that the amplitude of the frequency components in a signal is accurately represented.
+     *
+     * This window function is typically used in signal analysis, frequency domain measurements, and applications requiring
+     * accurate representation of signal amplitude.
+     *
+     * @tparam T The type of the elements in the `window` array.
+     *
+     * @param[out] window A pointer to an array of type `T` where the Stanford flat top window values will be stored.
+     * @param[in] N The total number of samples or elements in the window.
+     * @param[in] begin The starting index from which to generate the Stanford flat top window function.
+     * @param[in] end The ending index up to which the Stanford flat top window function will be generated (exclusive).
+     * @param[in] p A constant reference to the `params` structure, which may contain additional parameters influencing the window's characteristics.
+     *
+     * @note The range of indices is `[begin, end)`, meaning the value at `end` is not included.
+     */
+
     template <class T>
     void stanford_flat_top(T *window, uint32_t N, uint32_t begin, uint32_t end, const params& p)
     {
         impl::generate<impl::stanford_flat_top, true>(window, N, begin, end, p);
     }
     
+    /**
+     * @brief Fills an array with values from a Heinzel flat top window function with 70 dB side lobe attenuation.
+     *
+     * This template function generates a Heinzel flat top window with approximately 70 dB side lobe attenuation
+     * over a specified range of elements in the `window` array. The Heinzel flat top window is designed to provide
+     * a flat passband, ensuring accurate amplitude measurements across a wide range of frequencies while reducing
+     * side lobes to 70 dB. It is typically used in high-precision signal processing applications that require
+     * reduced spectral leakage and high amplitude accuracy.
+     *
+     * The Heinzel flat top window is particularly useful in spectral analysis and frequency domain applications where
+     * minimizing passband ripple and ensuring amplitude accuracy is essential.
+     *
+     * @tparam T The type of the elements in the `window` array.
+     *
+     * @param[out] window A pointer to an array of type `T` where the Heinzel flat top 70 dB window values will be stored.
+     * @param[in] N The total number of samples or elements in the window.
+     * @param[in] begin The starting index from which to generate the Heinzel flat top 70 dB window function.
+     * @param[in] end The ending index up to which the Heinzel flat top window function will be generated (exclusive).
+     * @param[in] p A constant reference to the `params` structure, which may contain additional parameters influencing the window's characteristics.
+     *
+     * @note The range of indices is `[begin, end)`, meaning the value at `end` is not included.
+     */
+
     template <class T>
     void heinzel_flat_top_70dB(T *window, uint32_t N, uint32_t begin, uint32_t end, const params& p)
     {
         impl::generate<impl::heinzel_flat_top_70dB, true>(window, N, begin, end, p);
     }
     
+    /**
+     * @brief Fills an array with values from a Heinzel flat top window function with 90 dB side lobe attenuation.
+     *
+     * This template function generates a Heinzel flat top window with approximately 90 dB side lobe attenuation
+     * over a specified range of elements in the `window` array. The Heinzel flat top window is designed to provide
+     * a very flat passband, ensuring precise amplitude measurements across a wide frequency range while minimizing
+     * side lobes. The 90 dB variant is ideal for applications that demand higher side lobe suppression, ensuring
+     * minimal spectral leakage and high amplitude accuracy.
+     *
+     * This window is often used in high-precision frequency domain measurements, spectral analysis, and applications
+     * where accurate amplitude representation is critical.
+     *
+     * @tparam T The type of the elements in the `window` array.
+     *
+     * @param[out] window A pointer to an array of type `T` where the Heinzel flat top 90 dB window values will be stored.
+     * @param[in] N The total number of samples or elements in the window.
+     * @param[in] begin The starting index from which to generate the Heinzel flat top 90 dB window function.
+     * @param[in] end The ending index up to which the Heinzel flat top window function will be generated (exclusive).
+     * @param[in] p A constant reference to the `params` structure, which may contain additional parameters influencing the window's characteristics.
+     *
+     * @note The range of indices is `[begin, end)`, meaning the value at `end` is not included.
+     */
+
     template <class T>
     void heinzel_flat_top_90dB(T *window, uint32_t N, uint32_t begin, uint32_t end, const params& p)
     {
         impl::generate<impl::heinzel_flat_top_90dB, true>(window, N, begin, end, p);
     }
     
+    /**
+     * @brief Fills an array with values from a Heinzel flat top window function with 95 dB side lobe attenuation.
+     *
+     * This template function generates a Heinzel flat top window with approximately 95 dB side lobe attenuation
+     * over a specified range of elements in the `window` array. The Heinzel flat top window is designed for applications
+     * requiring extremely precise amplitude measurements over a wide frequency range. The 95 dB variant provides
+     * very strong side lobe suppression, ensuring minimal spectral leakage while maintaining a flat passband for amplitude accuracy.
+     *
+     * This window is commonly used in high-precision signal processing tasks, such as spectral analysis and frequency domain
+     * measurements, where both amplitude accuracy and side lobe suppression are critical.
+     *
+     * @tparam T The type of the elements in the `window` array.
+     *
+     * @param[out] window A pointer to an array of type `T` where the Heinzel flat top 95 dB window values will be stored.
+     * @param[in] N The total number of samples or elements in the window.
+     * @param[in] begin The starting index from which to generate the Heinzel flat top 95 dB window function.
+     * @param[in] end The ending index up to which the Heinzel flat top window function will be generated (exclusive).
+     * @param[in] p A constant reference to the `params` structure, which may contain additional parameters influencing the window's characteristics.
+     *
+     * @note The range of indices is `[begin, end)`, meaning the value at `end` is not included.
+     */
+
     template <class T>
     void heinzel_flat_top_95dB(T *window, uint32_t N, uint32_t begin, uint32_t end, const params& p)
     {
         impl::generate<impl::heinzel_flat_top_95dB, true>(window, N, begin, end, p);
     }
     
+    /**
+     * @brief A struct to manage and generate windows based on indexed window generators.
+     *
+     * This template struct `indexed_generator` manages a collection of window generators, each identified by an index.
+     * The struct allows for the selection and application of a specific window generator from a list of generators
+     * based on a provided index. This design is useful when multiple window functions need to be applied to different parts of a signal or dataset,
+     * allowing for flexible and efficient window generation.
+     *
+     * @tparam T The data type for the window values, typically `float` or `double`.
+     * @tparam gens A parameter pack of `window_generator<T>` types, representing the window functions that can be used.
+     *
+     * This struct can be used to select and generate windows based on their index, allowing different window functions
+     * to be applied dynamically.
+     */
+
     template <class T, window_generator<T> ...gens>
     struct indexed_generator
     {
+        
+        /**
+         * @brief Applies a window function based on the specified type.
+         *
+         * This function call operator selects and applies a window function from a collection of window generators
+         * based on the provided `type` index. It fills the `window` array with values generated by the window function
+         * corresponding to the `type`. This allows dynamic selection of different window functions at runtime.
+         *
+         * @param[in] type The index of the window function to apply. This index corresponds to one of the available window generators.
+         * @param[out] window A pointer to an array of type `T` where the generated window values will be stored.
+         * @param[in] N The total number of samples or elements in the window.
+         * @param[in] begin The starting index from which to generate the window function.
+         * @param[in] end The ending index up to which the window function will be generated (exclusive).
+         * @param[in] p A constant reference to the `params` structure, containing any parameters required by the window function.
+         *
+         * @note The range of indices for generating the window is `[begin, end)`, meaning the value at `end` is not included.
+         *
+         * This operator allows dynamic selection and application of different window functions based on the provided `type` index.
+         */
+        
         void operator()(size_t type, T *window, uint32_t N, uint32_t begin, uint32_t end, const params& p)
         {
             return generators[type](window, N, begin, end, p);
         }
         
+        /**
+         * @brief Retrieves the window generator function based on the specified type.
+         *
+         * This function returns a pointer to a window generator function from the list of available generators, based on the provided `type` index.
+         *
+         * @param[in] type The index of the window generator to retrieve. This index corresponds to one of the available window generators.
+         *
+         * @return A pointer to the `window_generator<T>` function corresponding to the specified `type` index.
+         *
+         * @note The `type` index should be within the bounds of the available window generators to avoid undefined behavior.
+         */
+        
         window_generator<T> *get(size_t type) { return generators[type]; }
         
+        /**
+         * @brief Array of window generator function pointers initialized with the provided generator functions.
+         *
+         * This array holds pointers to window generator functions, initialized with the list of generators passed as template parameters (`gens...`).
+         * The size of the array is determined by the number of template arguments, `sizeof...(gens)`, which corresponds to the number of window generator functions provided.
+         *
+         * @tparam gens A parameter pack representing the window generator functions of type `window_generator<T>`.
+         *
+         * This array allows dynamic access to the different window generator functions for applying various windowing techniques.
+         */
+        
         window_generator<T> *generators[sizeof...(gens)] = { gens... };
     };
 }