FrequencyDiscretization.hpp

Go to the documentation of this file.

 
#pragma once
#include <vector>
#include <algorithm>
#include <cstdlib>
#include "lib/Exception.hpp"
#include "lib/Log.hpp"
#include "lib/Assert.hpp"
 
#pragma region FrequencyIterator
 
struct FrequencyIterator
{
    FrequencyIterator(float *p)
    {
        _pointer = p;
    }
 
    float operator*() const
    {
        return *_pointer;
    }
 
    bool operator==(const FrequencyIterator &rhs) const
    {
        return _pointer == rhs._pointer;
    }
 
    bool operator!=(const FrequencyIterator &rhs) const
    {
        return _pointer != rhs._pointer;
    }
 
    FrequencyIterator& operator++()
    {
        ++_pointer;
        return *this;
    }
 
    FrequencyIterator& operator--()
    {
        --_pointer;
        return *this;
    }
    
    FrequencyIterator operator+(const int rhs) const
    {
        return FrequencyIterator(_pointer + rhs);
    }
 
    FrequencyIterator operator-(const int rhs) const
    {
        return FrequencyIterator(_pointer - rhs);
    }
 
    bool operator>(const FrequencyIterator &rhs) const
    {
        return _pointer > rhs._pointer;
    }
    
    bool operator>=(const FrequencyIterator &rhs) const
    {
        return _pointer >= rhs._pointer;
    }
    
    bool operator<(const FrequencyIterator &rhs) const
    {
        return _pointer < rhs._pointer;
    }
    
    bool operator<=(const FrequencyIterator &rhs) const
    {
        return _pointer <= rhs._pointer;
    }
 
    float *_pointer; 
};
#pragma endregion
 
struct FrequencyDiscretization
{
public:
    FrequencyDiscretization(const std::vector<float> &values)
    {
        //Ensure that the frequency values are in ascending order
        ASSERT(std::is_sorted(values.begin(), values.end()));
 
        //Ensure that discretization contains sufficiently many frequencies
        if (values.size() < 2) throw Exception(Exception::Type::ArgumentError, "FrequencyDiscretization must contain at least two frequency values");
        
        //Allocate memory and store frequencies
        size = int(values.size());
        _dataNegative = new float[2 * size];
        _data = _dataNegative + size;
        
        for (int i = 0; i < size; ++i)
        {
            ASSERT(values[i] > 0);
            _data[-i- 1] = -values[i];
            _data[i] = values[i];
        }
 
        Log::log << Log::LogLevel::Debug<< "Initialized frequency grid with mesh values" << Log::endl;
        for (auto i = beginNegative(); i != end(); ++i) Log::log << "\t" << *i << Log::endl;
    }
 
    ~FrequencyDiscretization()
    {
        delete[] _dataNegative;
    }
 
    FrequencyIterator begin() const
    {
        return FrequencyIterator(_data);
    }
 
    FrequencyIterator beginNegative() const
    {
        return FrequencyIterator(_dataNegative);
    }
 
    FrequencyIterator last() const
    {
        return FrequencyIterator(_data + size - 1);
    }
 
    FrequencyIterator end() const
    {
        return FrequencyIterator(_data + size);
    }
 
    FrequencyIterator lesser(const float w) const
    {
        if (w < 0)
        {
            FrequencyIterator it = greater(-w);
            it._pointer = _data - (it._pointer - _data + 1);
            return it;
        }
        else
        {
            if (w <= _data[0]) return FrequencyIterator(_data);
            for (int i = 1; i < size; ++i)
            {
                if (_data[i] > w) return FrequencyIterator(_data + i - 1);
            }
            return FrequencyIterator(_data + size - 1);
        }
    }
 
    FrequencyIterator greater(const float w) const
    {
        if (w < 0)
        {
            FrequencyIterator it = lesser(-w);
            it._pointer = _data - (it._pointer - _data + 1);
            return it;
        }
        else
        {
            if (w <= _data[0]) return FrequencyIterator(_data);
            for (int i = 1; i < size; ++i)
            {
                if (_data[i] > w) return FrequencyIterator(_data + i);
            }
            return FrequencyIterator(_data + size - 1);
        }
    }
 
    int offset(const float w) const
    {
        ASSERT(w >= 0);
 
        if (w <= _data[0]) return 0;
        for (int i = 1; i < size; ++i)
        {
            if (_data[i] >= w) return i;
        }
        return size - 1;
    }   
 
    void interpolateOffset(const float w, int &lowerOffset, int &upperOffset, float &bias) const
    {
        ASSERT(w >= 0);
        ASSERT(&lowerOffset != &upperOffset)
 
        if (w <= _data[0])
        {
            lowerOffset = 0; 
            upperOffset = 0;
            bias = 0.0f;
            return;
        }
        for (int i = 1; i < size; ++i)
        {
            if (_data[i] > w)
            {
                upperOffset = i;
                lowerOffset = i - 1;
                bias = (w - _data[lowerOffset]) / (_data[upperOffset] - _data[lowerOffset]);
                return;
            }
        }
        lowerOffset = size - 1;
        upperOffset = size - 1;
        bias = 0.0f;
        return;
 
        ASSERT(lowerOffset >= 0 && lowerOffset < size);
        ASSERT(upperOffset >= 0 && upperOffset < size);
        ASSERT(bias >= 0.0f && bias <= 1.0f);
    }
 
    int size; 
    float *_data; 
    float *_dataNegative; 
};