gate_logic.hpp

Go to the documentation of this file.

#pragma once
 
#include <pulp/signal/detail/modular_sequencing_common.hpp>
#include <pulp/signal/trigger_kit.hpp>
 
namespace pulp::signal {
 
// ── Gate combinators ──────────────────────────────────────────────────────

enum class GateOp {
    logic_and,
    logic_or,
    logic_xor,
    logic_nand,
    logic_nor,
    logic_xnor,
};

template <typename SampleType = float>
class GateLogicT {
public:
    static constexpr double kLevelThreshold = kTriggerHighThreshold;
 
    void prepare(double) {}
 
    void set_op(GateOp op) { op_ = op; }
    GateOp op() const { return op_; }
 
    void apply_reset_edge() {}
    void reset() {}
 
    static constexpr int latency_samples() { return 0; }
 
    bool process(bool a, bool b) const {
        switch (op_) {
            case GateOp::logic_and: return a && b;
            case GateOp::logic_or: return a || b;
            case GateOp::logic_xor: return a != b;
            case GateOp::logic_nand: return !(a && b);
            case GateOp::logic_nor: return !(a || b);
            case GateOp::logic_xnor: return a == b;
        }
        return false;
    }

    bool process(const bool* gates, int count) const {
        bool all = true;
        bool any = false;
        bool parity = false;
        for (int i = 0; i < count; ++i) {
            all = all && gates[i];
            any = any || gates[i];
            parity = parity != gates[i];
        }
        switch (op_) {
            case GateOp::logic_and: return all;
            case GateOp::logic_or: return any;
            case GateOp::logic_xor: return parity;
            case GateOp::logic_nand: return !all;
            case GateOp::logic_nor: return !any;
            case GateOp::logic_xnor: return !parity;
        }
        return false;
    }

    SampleType process_levels(SampleType a, SampleType b) const {
        const bool ha = static_cast<double>(a) >= kLevelThreshold;
        const bool hb = static_cast<double>(b) >= kLevelThreshold;
        return process(ha, hb) ? SampleType{1} : SampleType{0};
    }
 
private:
    GateOp op_ = GateOp::logic_and;
};
 
using GateLogic = GateLogicT<float>;
using GateLogic64 = GateLogicT<double>;
 
}  // namespace pulp::signal