lookup_table.hpp

Go to the documentation of this file.

#pragma once

 
#include <vector>
#include <functional>
#include <cmath>
#include <algorithm>
 
namespace pulp::signal {

template <typename SampleType = float>
class LookupTableT {
public:
    LookupTableT() = default;

    LookupTableT(int size, SampleType min_input, SampleType max_input,
                 std::function<SampleType(SampleType)> generator)
        : min_(min_input), max_(max_input)
    {
        if (size <= 0) return;
 
        table_.resize(static_cast<size_t>(size));
 
        if (size == 1 || max_ == min_) {
            std::fill(table_.begin(), table_.end(), generator(min_));
            inv_range_ = SampleType{0.0f};
            return;
        }
 
        if (max_ < min_)
            std::swap(min_, max_);
 
        inv_range_ = static_cast<SampleType>(size - 1) / (max_ - min_);
 
        for (int i = 0; i < size; ++i) {
            SampleType x = min_ + (max_ - min_) * static_cast<SampleType>(i) /
                static_cast<SampleType>(size - 1);
            table_[static_cast<size_t>(i)] = generator(x);
        }
    }

    SampleType process(SampleType input) const {
        if (table_.empty()) return input;
 
        SampleType index = (std::clamp(input, min_, max_) - min_) * inv_range_;
        int i0 = static_cast<int>(index);
        int i1 = std::min(i0 + 1, static_cast<int>(table_.size()) - 1);
        SampleType frac = index - static_cast<SampleType>(i0);
 
        return table_[static_cast<size_t>(i0)] * (SampleType{1.0f} - frac)
             + table_[static_cast<size_t>(i1)] * frac;
    }

    void process(SampleType* data, int num_samples) const {
        for (int i = 0; i < num_samples; ++i) {
            data[i] = process(data[i]);
        }
    }

    SampleType operator[](int index) const {
        if (table_.empty()) return SampleType{0.0f};
 
        return table_[static_cast<size_t>(std::clamp(index, 0,
            static_cast<int>(table_.size()) - 1))];
    }
 
    int size() const { return static_cast<int>(table_.size()); }
    bool empty() const { return table_.empty(); }
 
private:
    std::vector<SampleType> table_;
    SampleType min_ = SampleType{0.0f};
    SampleType max_ = SampleType{1.0f};
    SampleType inv_range_ = SampleType{1.0f};
};
 
using LookupTable = LookupTableT<float>;
using LookupTable64 = LookupTableT<double>;
 
} // namespace pulp::signal