bigData/zad18.cpp at main · woycik/bigData · 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
#include <iostream>
#include <vector>
#include <cmath>
#include <iomanip>
#include <string>

struct Result {
    double mean;
    double variance;
};


Result calculateNaiveOnePass(const std::vector<double>& data) {
    if (data.size() < 2) return {0.0, 0.0};

    double n = static_cast<double>(data.size());
    double sum = 0.0;
    double sum_sq = 0.0;

    for (double x : data
    ) {
        sum += x;
        sum_sq += x * x;
    }

    double mean = sum / n;
    double variance = (sum_sq - (sum * sum) / n) / (n - 1);

    return {mean, variance};
}

Result calculateTwoPass(const std::vector<double>& data) {
    if (data.size() < 2) return {0.0, 0.0};

    double n = static_cast<double>(data.size());

    double sum = 0.0;
    for (double x : data) {
        sum += x;
    }
    double mean = sum / n;

    double sum_sq_diff = 0.0;
    for (double x : data) {
        sum_sq_diff += (x - mean) * (x - mean);
    }

    double variance = sum_sq_diff / (n - 1);

    return {mean, variance};
}


Result calculateWelford(const std::vector<double>& data) {
    if (data.size() < 2) return {0.0, 0.0};

    double m = 0.0;
    double s = 0.0;
    int count = 0;

    for (double x : data) {
        count++;
        double delta = x - m;
        m += delta / count;
        double delta2 = x - m;
        s += delta * delta2;
    }

    double variance = s / (count - 1);

    return {m, variance};
}

void runTest(std::string label, const std::vector<double>& data) {
    std::cout << "Test: " << label << " ---" << std::endl;

    double expected_variance = 30.0;

    Result r1 = calculateTwoPass(data);
    Result r2 = calculateNaiveOnePass(data);
    Result r3 = calculateWelford(data);

    std::cout << "Dwu-przebiegowa: " << r1.mean << ", " << r1.variance << " (oczekiwana wariancja: " << expected_variance << ")" << std::endl;
    std::cout << "Naiwna: " << r2.mean << ", " << r2.variance << " (oczekiwana wariancja: " << expected_variance << ")" << std::endl;
    std::cout << "Welford: "  << r3.mean << ", " << r3.variance << " (oczekiwana wariancja: " << expected_variance << ")" << std::endl;
    std::cout << std::endl;
}

int main() {

    std::vector<double> data = {4.0, 7.0, 13.0, 16.0};

    double shift1 = 100000000.0;
    std::vector<double> data2;
    for(double x : data)
    {
        data2.push_back(x + shift1);
    }

    double shift2 = 1000000000.0;
    std::vector<double> data3;
    for(double x : data)
    {
        data3.push_back(x + shift2);
    }

    runTest("{4, 7, 13, 16}", data);
    runTest("10^8 + ...", data2);
    runTest("10^9 + ...", data3);

    return 0;
}