ArduinoDatalogger/SmartArray.cpp at master · rihteri/ArduinoDatalogger · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
#include "Arduino.h"

#include "SmartArray.h"

SmartArray::SmartArray(int size) :
    _size(size),
    _isFull(false),
    _currentIndex(-1)
{
    _values = new double[_size];
}

SmartArray::SmartArray(int size, SmartArray* initial_data) :
    _size(size),
    _isFull(false),
    _currentIndex(-1)
{
    _values = new double[_size];

    int until = initial_data->getValueCount();

    if (until >= _size)
    {
        until = _size;
        _isFull = true;
    }

    for (int i = 0; i < until; i++)
    {
        pushValue(initial_data->getValue(_currentIndex));
    }
}

SmartArray::~SmartArray()
{
    delete _values;
}

boolean SmartArray::isLooping()
{
    return _currentIndex == 0 && isFull();
}

int SmartArray::getValue(int i)
{
    int index = _currentIndex - i;

    if (index < 0)
    {
        index = _size + index;
    }

    return _values[index];
}

boolean SmartArray::isFull()
{
    return _isFull;
}

void SmartArray::pushValue(double value)
{
    _currentIndex++;

    if (_currentIndex >= _size)
    {
        _currentIndex = 0;
        _isFull = true;
    }

    _values[_currentIndex] = value;
}

int SmartArray::getValueCount()
{
    int count = _size;

    if (!_isFull) count = _currentIndex + 1;

    return count;
}

double SmartArray::getAvg(double values[], int count)
{
    double sum = 0;
    for (int i = 0; i < count; i++)
    {
        sum += values[i];
    }

    if (count == 0) return 0;

    return sum / count;
}

double SmartArray::getAvg()
{
    int count = getValueCount();
    return getAvg(_values, count);
}

double SmartArray::getStdDev()
{
    int upperLimit = getValueCount();
    double avg = getAvg();

    double* devs = new double[upperLimit];

    for (int i = 0; i < upperLimit; i++)
    {
        double dev = _values[i] - avg;
        devs[i] = dev * dev;
    }

    double stdDev = sqrt(getAvg(devs, upperLimit));

    delete devs;

    return stdDev;
}

void SmartArray::clear()
{
    _isFull = false;
    _currentIndex = 0;
}