probability_gate.hpp

Go to the documentation of this file.

#pragma once
 
#include <pulp/signal/detail/modular_sequencing_common.hpp>
#include <pulp/signal/rng.hpp>
#include <pulp/signal/trigger_kit.hpp>
 
#include <algorithm>
#include <cmath>
#include <cstdint>
 
namespace pulp::signal {

template <typename SampleType = float>
class ProbGateT {
public:
    static constexpr double kDefaultProbability = 0.5;

    static constexpr std::uint32_t kProbSeed = 0x1234567u;
 
    ProbGateT() { rng_.set_seed(kProbSeed); }
 
    void prepare(double) {}
 
    void set_probability(double p) {
        if (std::isfinite(p)) probability_ = std::clamp(p, 0.0, 1.0);
    }
    double probability() const { return probability_; }
 
    void set_seed(std::uint32_t seed) { rng_.set_seed(seed); }

    void apply_reset_edge() { detector_.reset(); }

    void reset() {
        detector_.reset();
        rng_.reset();
        draws_ = 0;
    }
 
    static constexpr int latency_samples() { return 0; }

    std::uint32_t draw_count() const { return draws_; }

    bool process_edge(bool trigger_edge) {
        if (!trigger_edge) return false;
        ++draws_;
        return rng_.next_unit<double>() < probability_;
    }

    bool process(SampleType trigger) { return process_edge(detector_.process(trigger)); }
 
private:
    double probability_ = kDefaultProbability;
    std::uint32_t draws_ = 0;
    Xorshift32 rng_{kProbSeed};
    HystereticTriggerDetectT<SampleType> detector_{};
};
 
using ProbGate = ProbGateT<float>;
using ProbGate64 = ProbGateT<double>;
 
}  // namespace pulp::signal