CutoffDiscretization.hpp

Go to the documentation of this file.

 
#pragma once
#include <vector>
#include "lib/Exception.hpp"
 
#pragma region CutoffIterator
 
struct CutoffIterator
{
public:
    CutoffIterator(float* p) : _pointer(p) {};
 
    float operator*() const
    {
        return *_pointer;
    }
 
    bool operator==(const CutoffIterator& rhs) const
    {
        return _pointer == rhs._pointer;
    }
    
    bool operator!=(const CutoffIterator& rhs) const
    {
        return _pointer != rhs._pointer;
    }
    
    CutoffIterator& operator++()
    {
        ++_pointer;
        return *this;
    }
 
private:
    float *_pointer; 
};
#pragma endregion
 
struct CutoffDiscretization
{
public:
    CutoffDiscretization(const std::vector<float> &values)
    {
        //Ensure that discretization contains sufficiently many cutoff values
        if (values.size() < 2) throw Exception(Exception::Type::ArgumentError, "CutoffDiscretization must contain at least two frequency values");
 
        _size = int(values.size());
        _data = new float[values.size()];
        memcpy(_data, values.data(), values.size() * sizeof(float));
    }
 
    ~CutoffDiscretization()
    {
        delete[] _data;
    }
 
    CutoffIterator begin() const
    {
        return CutoffIterator(_data);
    }
 
    CutoffIterator last() const
    {
        return CutoffIterator(_data + _size - 1);
    }
 
    CutoffIterator end() const
    {
        return CutoffIterator(_data + _size);
    }
 
    CutoffIterator find(const float cutoff) const
    {
        for (int i = 0; i < _size; ++i)
        {
            if (_data[i] == cutoff) return CutoffIterator(_data + i);
        }
        return end();
    }
 
private:
    int _size; 
    float *_data; 
};