dspx 0.1.1-alpha.0

package/src/native/core/WampFilter.h

@@ -0,0 +1,101 @@
+#pragma once
+
+#include "../utils/SlidingWindowFilter.h"
+#include "Policies.h"
+#include <cmath>   // For std::abs
+#include <utility> // For std::pair
+#include <vector>
+
+namespace dsp::core
+{
+    template <typename T>
+    class WampFilter
+    {
+    public:
+        /**
+         * @brief Constructs a new Wamp Filter.
+         * @param window_size The number of samples to consider in the sliding window.
+         * @param threshold The amplitude change threshold to detect.
+         */
+        explicit WampFilter(size_t window_size, T threshold)
+            : m_filter(window_size), m_threshold(threshold), m_previous_sample(0.0), m_is_initialized(false) {}
+
+        // Delete copy constructor and copy assignment
+        WampFilter(const WampFilter &) = delete;
+        WampFilter &operator=(const WampFilter &) = delete;
+
+        // Enable move semantics
+        WampFilter(WampFilter &&) noexcept = default;
+        WampFilter &operator=(WampFilter &&) noexcept = default;
+
+        /**
+         * @brief Adds a new sample to the filter.
+         * @param newValue The new sample value to add.
+         * @return T The updated WAMP count over the window.
+         */
+        T addSample(T newValue)
+        {
+            bool did_exceed = false;
+            if (m_is_initialized)
+            {
+                did_exceed = std::abs(newValue - m_previous_sample) > m_threshold;
+            }
+
+            m_previous_sample = newValue;
+            m_is_initialized = true;
+
+            // Add the boolean to the window, get the count back
+            // Cast count (size_t) to T (float/double)
+            return static_cast<T>(m_filter.addSample(did_exceed));
+        }
+
+        /**
+         * @brief Clears all samples from the filter and resets state.
+         */
+        void clear()
+        {
+            m_filter.clear();
+            m_previous_sample = 0.0;
+            m_is_initialized = false;
+        }
+
+        /**
+         * @brief Exports the complete filter state (buffer + previous sample).
+         * @return A pair containing the buffer contents and previous sample.
+         */
+        auto getState() const
+        {
+            return std::make_pair(m_filter.getState(), m_previous_sample);
+        }
+
+        /**
+         * @brief Restores the complete filter state (buffer + previous sample).
+         * @param buffer The buffer contents to restore.
+         * @param count The count of 'true' entries in the buffer.
+         * @param prevSample The previous sample value to restore.
+         * @return void
+         */
+        void setState(const std::vector<bool> &buffer, size_t count, T prevSample)
+        {
+            m_filter.setState(buffer, count);
+            m_previous_sample = prevSample;
+            m_is_initialized = true;
+        }
+
+        /**
+         * @brief Gets const access to the internal SlidingWindowFilter.
+         * @return const SlidingWindowFilter<bool, CounterPolicy>& Reference to the internal filter
+         */
+        const dsp::utils::SlidingWindowFilter<bool, CounterPolicy> &getInternalFilter() const
+        {
+            return m_filter;
+        }
+
+    private:
+        dsp::utils::SlidingWindowFilter<bool, CounterPolicy> m_filter;
+        T m_threshold;
+        T m_previous_sample;
+        bool m_is_initialized;
+    };
+
+} // namespace dsp::core

package/src/native/core/WaveformLengthFilter.cc

@@ -0,0 +1,17 @@
+/**
+ * @file WaveformLengthFilter.cc
+ * @brief Implementation file for WaveformLengthFilter (now header-only with policy-based design)
+ * This file now only contains explicit template instantiations.
+ * The actual implementation is in the header file WaveformLengthFilter.h,
+ * which delegates to SlidingWindowFilter<T, SumPolicy<T>>.
+ */
+
+#include "WaveformLengthFilter.h"
+
+// Explicit template instantiation for float type
+namespace dsp::core
+{
+    template class WaveformLengthFilter<float>;
+    template class WaveformLengthFilter<double>;
+
+}

package/src/native/core/WaveformLengthFilter.h

@@ -0,0 +1,98 @@
+#pragma once
+
+#include "../utils/SlidingWindowFilter.h"
+#include "Policies.h"
+#include <cmath>   // For std::abs
+#include <utility> // For std::pair
+#include <vector>
+
+namespace dsp::core
+{
+    template <typename T>
+    class WaveformLengthFilter
+    {
+    public:
+        /**
+         * @brief Constructs a new Waveform Length Filter.
+         * @param window_size The number of samples to consider in the sliding window.
+         */
+        explicit WaveformLengthFilter(size_t window_size)
+            : m_filter(window_size), m_previous_sample(0.0f), m_is_initialized(false) {}
+
+        // Delete copy constructor and copy assignment
+        WaveformLengthFilter(const WaveformLengthFilter &) = delete;
+        WaveformLengthFilter &operator=(const WaveformLengthFilter &) = delete;
+
+        // Enable move semantics
+        WaveformLengthFilter(WaveformLengthFilter &&) noexcept = default;
+        WaveformLengthFilter &operator=(WaveformLengthFilter &&) noexcept = default;
+
+        /**
+         * @brief Adds a new sample to the filter.
+         * @param newValue The new sample value to add.
+         * @return T The updated waveform length over the window.
+         */
+        T addSample(float newValue)
+        {
+            T diff = 0.0;
+            if (m_is_initialized)
+            {
+                diff = std::abs(newValue - m_previous_sample);
+            }
+
+            m_previous_sample = newValue;
+            m_is_initialized = true;
+
+            // Add the difference to the window, get the sum of diffs back
+            return m_filter.addSample(diff);
+        }
+
+        /**
+         * @brief Clears all samples from the filter and resets state.
+         */
+        void clear()
+        {
+            m_filter.clear();
+            m_previous_sample = 0.0;
+            m_is_initialized = false;
+        }
+
+        /**
+         * @brief Exports the complete filter state (buffer + previous sample).
+         * @return A pair containing the buffer contents, running sum, and previous sample.
+         */
+        std::pair<std::pair<std::vector<T>, double>, T> getState() const
+        {
+            // Returns: { {buffer_of_diffs, running_sum}, previous_sample }
+            return std::make_pair(m_filter.getState(), m_previous_sample);
+        }
+
+        /**
+         * @brief Restores the complete filter state (buffer + previous sample).
+         * @param buffer The buffer of differences to restore.
+         * @param runningSum The running sum of differences to restore.
+         * @param prevSample The previous sample value to restore.
+         * @return void
+         */
+        void setState(const std::vector<T> &buffer, double runningSum, T prevSample)
+        {
+            m_filter.setState(buffer, runningSum);
+            m_previous_sample = prevSample;
+            m_is_initialized = true; // Assume if state is set, we are init'd
+        }
+
+        /**
+         * @brief Gets const access to the internal SlidingWindowFilter.
+         * @return const SlidingWindowFilter<float, SumPolicy<float>>& Reference to the internal filter
+         */
+        const dsp::utils::SlidingWindowFilter<T, SumPolicy<T>> &getInternalFilter() const
+        {
+            return m_filter;
+        }
+
+    private:
+        dsp::utils::SlidingWindowFilter<T, SumPolicy<T>> m_filter;
+        T m_previous_sample;
+        bool m_is_initialized;
+    };
+}

package/src/native/utils/CircularBufferArray.cc

@@ -0,0 +1,336 @@
+#include "CircularBufferArray.h"
+#include <algorithm>
+#include <stdexcept>
+#include <memory>
+
+using namespace dsp::utils;
+
+// -----------------------------------------------------------------------------
+// Constructor
+// Initializes the circular buffer with a specified size using std::make_unique
+// @ param size - The size of the circular buffer
+// @ param windowDuration_ms - Optional window duration for time-based expiration (0 = disabled)
+// @ return void
+// -----------------------------------------------------------------------------
+template <typename T>
+CircularBufferArray<T>::CircularBufferArray(size_t size, double windowDuration_ms)
+    : buffer(std::make_unique<T[]>(std::max(size, static_cast<size_t>(1)))),
+      timestamps(windowDuration_ms > 0.0 ? std::make_unique<double[]>(std::max(size, static_cast<size_t>(1))) : nullptr),
+      head(0),
+      tail(0),
+      capacity(std::max(size, static_cast<size_t>(1))),
+      count(0),
+      windowDuration_ms(windowDuration_ms)
+{
+    // Buffers are automatically initialized by make_unique
+}
+
+// Note: Move constructor and move assignment operator are now defaulted in the header
+// std::unique_ptr handles move semantics correctly by default
+
+// -----------------------------------------------------------------------------
+// Method: push
+// Adds an item to the circular buffer
+// @ param item - The item to add
+// @ return bool - True if the item was added, false if the buffer is full
+// -----------------------------------------------------------------------------
+template <typename T>
+bool CircularBufferArray<T>::push(const T &item)
+{
+    if (isFull())
+    {
+        return false; // Buffer is full
+    }
+
+    this->buffer[this->head] = item;
+    this->head = (this->head + 1) % this->capacity;
+    this->count++;
+    return true;
+}
+
+// -----------------------------------------------------------------------------
+// Method: pop
+// Removes an item from the circular buffer
+// @ param item - The item to remove
+// @ return bool - True if the item was removed, false if the buffer is empty
+// -----------------------------------------------------------------------------
+template <typename T>
+bool CircularBufferArray<T>::pop(T &item) noexcept
+{
+    if (isEmpty())
+    {
+        return false; // Buffer is empty
+    }
+
+    item = this->buffer[this->tail];
+    this->tail = (this->tail + 1) % this->capacity;
+    this->count--;
+    return true;
+}
+
+// -----------------------------------------------------------------------------
+
+// Method: clear
+// Clears the circular buffer
+// @ param void
+// @ return void
+// -----------------------------------------------------------------------------
+template <typename T>
+void CircularBufferArray<T>::clear() noexcept
+{
+    this->head = 0;
+    this->tail = 0;
+    this->count = 0;
+}
+
+// -----------------------------------------------------------------------------
+// Method: pushOverwrite
+// Adds an item to the circular buffer, overwriting the oldest item if full
+// @ param item - The item to add
+// @ return bool - Always returns true
+template <typename T>
+void CircularBufferArray<T>::pushOverwrite(const T &item)
+{
+    if (isFull())
+        this->tail = (this->tail + 1) % this->capacity;
+    this->buffer[this->head] = item;
+    this->head = (this->head + 1) % this->capacity;
+    if (this->count < this->capacity)
+        ++this->count;
+}
+
+// -----------------------------------------------------------------------------
+// Getter: getCapacity
+// @ param void
+// @ return size_t - The capacity of the circular buffer
+// -----------------------------------------------------------------------------
+template <typename T>
+size_t CircularBufferArray<T>::getCapacity() const noexcept
+{
+    return this->capacity;
+}
+
+// -----------------------------------------------------------------------------
+// Getter: getCount
+// @ param void
+// @ return size_t - The number of elements in the circular buffer
+// -----------------------------------------------------------------------------
+template <typename T>
+size_t CircularBufferArray<T>::getCount() const noexcept
+{
+    return this->count;
+}
+
+// -----------------------------------------------------------------------------
+// Getter: isEmpty
+// @ param void
+// @ return bool - True if the buffer is empty, false otherwise
+// -----------------------------------------------------------------------------
+template <typename T>
+bool CircularBufferArray<T>::isEmpty() const noexcept
+{
+    return this->count == 0;
+}
+
+// -----------------------------------------------------------------------------
+// Getter: isFull
+// @ param void
+// @ return bool - True if the buffer is full, false otherwise
+// -----------------------------------------------------------------------------
+template <typename T>
+bool CircularBufferArray<T>::isFull() const noexcept
+{
+    return this->count == this->capacity;
+}
+
+// -----------------------------------------------------------------------------
+// Method: peek
+// Returns the item at the head of the circular buffer without removing it
+// @ param void
+// @ return T - The item at the head of the buffer
+template <typename T>
+T CircularBufferArray<T>::peek() const
+{
+    if (isEmpty())
+    {
+        throw std::runtime_error("Buffer is empty");
+    }
+
+    return this->buffer[this->tail];
+}
+
+// -----------------------------------------------------------------------------
+// Method: toVector
+// Exports the buffer contents in order (oldest to newest) as a vector
+// @ return std::vector<T> - The buffer contents in order
+// -----------------------------------------------------------------------------
+template <typename T>
+std::vector<T> CircularBufferArray<T>::toVector() const
+{
+    std::vector<T> result;
+    result.reserve(this->count);
+
+    for (size_t i = 0; i < this->count; ++i)
+    {
+        size_t index = (this->tail + i) % this->capacity;
+        result.push_back(this->buffer[index]);
+    }
+
+    return result;
+}
+
+// -----------------------------------------------------------------------------
+// Method: fromVector
+// Imports buffer contents from a vector, maintaining order
+// @ param data - The vector containing the data to import
+// -----------------------------------------------------------------------------
+template <typename T>
+void CircularBufferArray<T>::fromVector(const std::vector<T> &data)
+{
+    clear();
+
+    for (const auto &item : data)
+    {
+        pushOverwrite(item);
+    }
+}
+
+// -----------------------------------------------------------------------------
+// Method: pushWithTimestamp
+// Adds an item with a timestamp to the buffer (requires time-aware mode)
+// @ param item - The item to add
+// @ param timestamp - The timestamp in milliseconds
+// -----------------------------------------------------------------------------
+template <typename T>
+void CircularBufferArray<T>::pushWithTimestamp(const T &item, double timestamp)
+{
+    if (!isTimeAware())
+    {
+        throw std::runtime_error("pushWithTimestamp requires time-aware mode (windowDuration > 0)");
+    }
+
+    if (isFull())
+    {
+        return; // Buffer is full
+    }
+
+    buffer[head] = item;
+    timestamps[head] = timestamp;
+    head = (head + 1) % capacity;
+    count++;
+}
+
+// -----------------------------------------------------------------------------
+// Method: pushOverwriteWithTimestamp
+// Adds an item with timestamp, overwriting oldest if full (requires time-aware mode)
+// @ param item - The item to add
+// @ param timestamp - The timestamp in milliseconds
+// -----------------------------------------------------------------------------
+template <typename T>
+void CircularBufferArray<T>::pushOverwriteWithTimestamp(const T &item, double timestamp)
+{
+    if (!isTimeAware())
+    {
+        throw std::runtime_error("pushOverwriteWithTimestamp requires time-aware mode (windowDuration > 0)");
+    }
+
+    if (isFull())
+    {
+        tail = (tail + 1) % capacity;
+    }
+
+    buffer[head] = item;
+    timestamps[head] = timestamp;
+    head = (head + 1) % capacity;
+
+    if (count < capacity)
+    {
+        ++count;
+    }
+}
+
+// -----------------------------------------------------------------------------
+// Method: expireOld
+// Removes samples older than windowDuration from the current timestamp
+// @ param currentTimestamp - The current timestamp in milliseconds
+// @ return size_t - Number of samples expired
+// -----------------------------------------------------------------------------
+template <typename T>
+size_t CircularBufferArray<T>::expireOld(double currentTimestamp)
+{
+    if (!isTimeAware() || isEmpty())
+    {
+        return 0;
+    }
+
+    size_t expired_count = 0;
+    double cutoff_time = currentTimestamp - windowDuration_ms;
+
+    // Remove samples from tail while they're older than cutoff
+    while (count > 0 && timestamps[tail] < cutoff_time)
+    {
+        tail = (tail + 1) % capacity;
+        --count;
+        ++expired_count;
+    }
+
+    return expired_count;
+}
+
+// -----------------------------------------------------------------------------
+// Method: toVectorWithTimestamps
+// Exports the buffer contents with timestamps (requires time-aware mode)
+// @ return std::vector<std::pair<double, T>> - The buffer contents with timestamps
+// -----------------------------------------------------------------------------
+template <typename T>
+std::vector<std::pair<double, T>> CircularBufferArray<T>::toVectorWithTimestamps() const
+{
+    if (!isTimeAware())
+    {
+        throw std::runtime_error("toVectorWithTimestamps requires time-aware mode");
+    }
+
+    std::vector<std::pair<double, T>> result;
+    result.reserve(count);
+
+    for (size_t i = 0; i < count; ++i)
+    {
+        size_t index = (tail + i) % capacity;
+        result.push_back({timestamps[index], buffer[index]});
+    }
+
+    return result;
+}
+
+// -----------------------------------------------------------------------------
+// Method: fromVectorWithTimestamps
+// Imports buffer contents with timestamps (requires time-aware mode)
+// @ param data - The vector containing (timestamp, value) pairs
+// -----------------------------------------------------------------------------
+template <typename T>
+void CircularBufferArray<T>::fromVectorWithTimestamps(const std::vector<std::pair<double, T>> &data)
+{
+    if (!isTimeAware())
+    {
+        throw std::runtime_error("fromVectorWithTimestamps requires time-aware mode");
+    }
+
+    clear();
+
+    for (const auto &[timestamp, value] : data)
+    {
+        pushOverwriteWithTimestamp(value, timestamp);
+    }
+}
+
+// Note: Destructor is now defaulted in the header
+// std::unique_ptr automatically cleans up the buffers
+
+// Explicit template instantiation for common types
+namespace dsp::utils
+{
+    template class CircularBufferArray<int>;
+    template class CircularBufferArray<float>;
+    template class CircularBufferArray<double>;
+    template class CircularBufferArray<bool>;
+}

package/src/native/utils/CircularBufferArray.h

@@ -0,0 +1,62 @@
+#pragma once
+
+#include <vector>
+#include <stdexcept>
+#include <memory>
+
+namespace dsp::utils
+{
+
+    template <typename T>
+
+    class CircularBufferArray
+    {
+    public:
+        // constructors
+        explicit CircularBufferArray(size_t size, double windowDuration_ms = 0.0);
+        CircularBufferArray(const CircularBufferArray &other) = delete;            // disable copy to avoid shallow copy
+        CircularBufferArray &operator=(const CircularBufferArray &other) = delete; // disable copy assignment to avoid shallow copy
+
+        // move semantics (defaulted - compiler generated is now safe with unique_ptr)
+        CircularBufferArray(CircularBufferArray &&other) noexcept = default;
+        CircularBufferArray &operator=(CircularBufferArray &&other) noexcept = default;
+
+        // methods
+        bool push(const T &item);
+        bool pop(T &item) noexcept;
+        void clear() noexcept;
+        void pushOverwrite(const T &item);
+
+        // Time-aware methods (require timestamps to be enabled)
+        void pushWithTimestamp(const T &item, double timestamp);
+        void pushOverwriteWithTimestamp(const T &item, double timestamp);
+        size_t expireOld(double currentTimestamp);
+
+        // getters
+        size_t getCapacity() const noexcept;
+        size_t getCount() const noexcept;
+        bool isEmpty() const noexcept;
+        bool isFull() const noexcept;
+        T peek() const;
+        bool isTimeAware() const noexcept { return windowDuration_ms > 0.0; }
+        double getWindowDuration() const noexcept { return windowDuration_ms; }
+
+        // state management
+        std::vector<T> toVector() const;
+        void fromVector(const std::vector<T> &data);
+        std::vector<std::pair<double, T>> toVectorWithTimestamps() const;
+        void fromVectorWithTimestamps(const std::vector<std::pair<double, T>> &data);
+
+        // destructor (defaulted - unique_ptr handles cleanup automatically)
+        ~CircularBufferArray() = default;
+
+    private:
+        std::unique_ptr<T[]> buffer;
+        std::unique_ptr<double[]> timestamps; // Optional timestamp array (nullptr if not time-aware)
+        size_t head;
+        size_t tail;
+        size_t capacity;
+        size_t count;
+        double windowDuration_ms; // Maximum age of samples (0 = disabled)
+    };
+} // namespace dsp::utils