mod_matrix.hpp

Go to the documentation of this file.

#pragma once

 
#include <array>
#include <algorithm>
#include <cmath>
#include <cstddef>
#include <span>
 
namespace pulp::signal {

template <int MaxSlots = 32, typename SampleType = float>
struct ModMatrixT {
    static constexpr int kMaxSlots = MaxSlots;

    struct Slot {
        int source = -1;
        int dest = -1;
        int via = -1;
        SampleType depth = SampleType{0};
    };
 
    std::array<Slot, MaxSlots> slots{};
 
    void clear() { slots.fill(Slot{}); }
 
    void clear_slot(int index) {
        if (index < 0 || index >= MaxSlots) return;
        slots[static_cast<std::size_t>(index)] = Slot{};
    }

    bool set_slot(int index, int source, int dest, SampleType depth, int via = -1) {
        if (index < 0 || index >= MaxSlots) return false;
        auto& slot = slots[static_cast<std::size_t>(index)];
        slot.source = source;
        slot.dest = dest;
        slot.depth = depth;
        slot.via = via;
        return true;
    }

    void evaluate(std::span<const SampleType> sources, std::span<SampleType> dests) const {
        const auto source_count = static_cast<int>(sources.size());
        const auto dest_count = static_cast<int>(dests.size());
        for (const auto& slot : slots) {
            // Two integer compares reject an inactive slot before any load of
            // the source arrays, which is what keeps an unused matrix free.
            if (slot.source < 0 || slot.dest < 0) continue;
            if (slot.depth == SampleType{0}) continue;
            if (slot.source >= source_count || slot.dest >= dest_count) continue;
            SampleType value = sources[static_cast<std::size_t>(slot.source)] * slot.depth;
            if (slot.via >= 0 && slot.via < source_count)
                value *= sources[static_cast<std::size_t>(slot.via)];
            dests[static_cast<std::size_t>(slot.dest)] += value;
        }
    }

    int active_count() const {
        int count = 0;
        for (const auto& slot : slots)
            if (slot.source >= 0 && slot.dest >= 0 && slot.depth != SampleType{0}) ++count;
        return count;
    }
};
 
using ModMatrix = ModMatrixT<32, float>;
using ModMatrix64 = ModMatrixT<32, double>;

template <std::size_t NumSources, std::size_t NumDestinations,
          typename SampleType = float>
class DenseModMatrixT {
public:
    static constexpr std::size_t kMaxRoutes = NumSources * NumDestinations;
    static constexpr std::size_t num_sources = NumSources;
    static constexpr std::size_t num_destinations = NumDestinations;
 
    bool add_route(std::size_t source, std::size_t destination, SampleType depth) {
        if (source >= NumSources || destination >= NumDestinations || count_ >= kMaxRoutes)
            return false;
        routes_[count_++] = Route{source, destination,
                                  std::clamp(depth, SampleType{-1}, SampleType{1})};
        return true;
    }
 
    void clear() { count_ = 0; }
    std::size_t route_count() const { return count_; }
 
    void set_source(std::size_t source, SampleType value) {
        if (source < NumSources) sources_[source] = value;
    }
 
    SampleType source(std::size_t index) const {
        return index < NumSources ? sources_[index] : SampleType{0};
    }
 
    void reset() {
        sources_.fill(SampleType{0});
        destinations_.fill(SampleType{0});
    }
 
    void process() {
        destinations_.fill(SampleType{0});
        for (std::size_t i = 0; i < count_; ++i) {
            const Route& route = routes_[i];
            destinations_[route.destination] += sources_[route.source] * route.depth;
        }
    }
 
    SampleType get(std::size_t destination) const {
        return destination < NumDestinations ? destinations_[destination] : SampleType{0};
    }
 
    SampleType worst_case_for(std::size_t destination) const {
        SampleType sum{0};
        for (std::size_t i = 0; i < count_; ++i)
            if (routes_[i].destination == destination) sum += std::abs(routes_[i].depth);
        return sum;
    }
 
private:
    struct Route {
        std::size_t source = 0;
        std::size_t destination = 0;
        SampleType depth = SampleType{0};
    };
 
    std::array<Route, kMaxRoutes> routes_{};
    std::array<SampleType, NumSources> sources_{};
    std::array<SampleType, NumDestinations> destinations_{};
    std::size_t count_ = 0;
};

namespace round2 {
template <std::size_t NumSources, std::size_t NumDestinations,
          typename SampleType = float>
using ModMatrixT = DenseModMatrixT<NumSources, NumDestinations, SampleType>;
}  // namespace round2
 
} // namespace pulp::signal