GY-63_MS5611/libraries/Histogram/histogram.cpp
2021-11-04 12:32:04 +01:00

279 lines
5.7 KiB
C++

//
// FILE: Histogram.cpp
// AUTHOR: Rob Tillaart
// VERSION: 0.3.0
// PURPOSE: Histogram library for Arduino
// DATE: 2012-11-10
//
// HISTORY:
// 0.1.0 2012-11-10 initial version
// 0.1.1 2012-11-10 added PMF() and CDF()
// 0.1.2 2012-12-23 changed float to double; some comments
// 0.1.3 2013-09-29 testing a lot & refactoring
// 0.1.4 2015-03-06 stricter interface
// 0.1.5 2017-07-16 refactor, support for > 256 buckets; prevent alloc() errors
// 0.1.6 2017-07-27 revert double to float (issue #33)
// 0.2.0 2020-06-12 #pragma once, removed pre 1.0 support
// 0.2.1 2020-12-24 Arduino-CI + unit tests
// 0.3.0 2021-11-02 update build-CI, add badges
// refactor readability
// add parameter for clear(value = 0)
// add findMin(), findMax()
// add countAbove(), countLevel(), countBelow().
// add setBucket(),
// change length to uint16_t ==> 65534
#include "histogram.h"
Histogram::Histogram(const uint16_t length, float *bounds)
{
_bounds = bounds;
_length = length + 1;
_data = (int32_t *) malloc((_length) * sizeof(int32_t));
if (_data) clear();
else _length = 0;
_count = 0;
}
Histogram::~Histogram()
{
if (_data) free(_data);
}
// resets all counters to value (default 0)
void Histogram::clear(int32_t value)
{
for (uint16_t i = 0; i < _length; i++) _data[i] = value;
_count = 0;
}
// adds a new value to the histogram - increasing
void Histogram::add(const float value)
{
if (_length > 0)
{
uint16_t index = find(value);
_data[index]++;
_count++;
}
// could return index or count.
}
// adds a new value to the histogram - decreasing
void Histogram::sub(const float value)
{
if (_length > 0)
{
uint16_t index = find(value);
_data[index]--;
_count++;
}
// could return index or count.
}
// returns the count of a bucket
int32_t Histogram::bucket(const uint16_t index)
{
if (index > _length) return 0;
return _data[index];
}
// returns the relative frequency of a bucket
float Histogram::frequency(const uint16_t index)
{
if ((_count == 0) || (_length == 0)) return NAN;
if (index > _length) return 0; // differs from PMF()
return (1.0 * _data[index]) / _count;
}
// EXPERIMENTAL
// returns the probability of the bucket of a value
float Histogram::PMF(const float value)
{
if ((_count == 0) || (_length == 0)) return NAN;
uint16_t index = find(value);
return (1.0 * _data[index]) / _count;
}
// EXPERIMENTAL
// returns the cumulative probability of
// values <= value
float Histogram::CDF(const float value)
{
if ((_count == 0) || (_length == 0)) return NAN;
// TODO: could be done in one loop?
uint16_t index = find(value);
int32_t sum = 0;
for (uint16_t i = 0; i <= index; i++)
{
sum += _data[i];
}
return (1.0 * sum) / _count;
}
// EXPERIMENTAL
// returns the value of the original array for
// which the CDF is at least prob(ability).
float Histogram::VAL(const float prob)
{
if ((_count == 0) || (_length == 0)) return NAN;
float p = prob;
if (p < 0.0) p = 0.0;
if (p > 1.0) p = 1.0;
float probability = p * _count;
int32_t sum = 0;
for (uint16_t i = 0; i < _length; i++)
{
sum += _data[i];
if (sum >= probability && (i < (_length - 1)) )
{
return _bounds[i];
}
}
return INFINITY;
}
// returns the bucket number for value
// - binary search, more memory ; faster for #buckets > 20 ?
// uint16_t Histogram::find(const float value)
// {
// if (_length <= 0) return -1;
// uint16_t low = 0, high = _length;
// uint16_t mid;
// while (high - low > 1)
// {
// mid = (low + high)/2;
// if (_bounds[mid] > value)
// {
// high = mid;
// }
// else
// {
// low = mid;
// }
// }
// if (_bounds[mid] > value) return mid;
// return _length - 1;
// }
// returns the bucket number for value
uint16_t Histogram::find(const float value)
{
if (_length <= 0) return -1;
for (uint16_t i = 0; i < (_length - 1); i++)
{
if (_bounds[i] >= value)
{
return i;
}
}
return _length - 1;
}
// returns the (first) index of the bucket with minimum value.
uint16_t Histogram::findMin()
{
if (_length <= 0) return -1;
uint16_t index = 0;
for (uint16_t i = 1; i < _length; i++)
{
if (_data[i] < _data[index]) index = i;
}
return index;
}
// returns the (first) index of the bucket with maximum value.
uint16_t Histogram::findMax()
{
if (_length <= 0) return -1;
uint16_t index = 0;
for (uint16_t i = 1; i < _length; i++)
{
if (_data[i] > _data[index]) index = i;
}
return index;
}
// returns the number of buckets above a certain level.
uint16_t Histogram::countLevel(const int32_t level)
{
if (_length <= 0) return -1;
uint16_t buckets = 0;
for (uint16_t i = 0; i < _length; i++)
{
if (_data[i] == level) buckets++;
}
return buckets;
}
// returns the number of buckets above a certain level.
uint16_t Histogram::countAbove(const int32_t level)
{
if (_length <= 0) return -1;
uint16_t buckets = 0;
for (uint16_t i = 0; i < _length; i++)
{
if (_data[i] > level) buckets++;
}
return buckets;
}
// returns the number of buckets below a certain level.
uint16_t Histogram::countBelow(const int32_t level)
{
if (_length <= 0) return -1;
uint16_t buckets = 0;
for (uint16_t i = 0; i < _length; i++)
{
if (_data[i] < level) buckets++;
}
return buckets;
}
//////////////////////////////////////////////////////////////
//
// DERIVED CLASS
//
Histogram16::Histogram16(const uint16_t length, float *bounds) : Histogram(length, bounds)
{
};
Histogram8::Histogram8(const uint16_t length, float *bounds) : Histogram(length, bounds)
{
};
// -- END OF FILE --