C++优化曲线方法

数据平滑处理

包括去差值、线性平滑

去差值

五点去差值法是一种常用的数据平滑处理方法，它的基本思想是选取周围五个点，去掉最大值和最小值，然后求剩余三个点的平均值，使得相邻点变得平滑。先找到这五个元素中的最大值和最小值，然后将它们从这五个元素中移除，最后计算剩余三个元素的平均值。

#include <algorithm>
#include <vector>

void fivePointDifference(std::vector<double>& data) {
    std::vector<double> result(data.size());
    for (int i = 2; i < data.size() - 2; i++) {
        std::vector<double> temp(data.begin() + i - 2, data.begin() + i + 3);
        std::sort(temp.begin(), temp.end());
        result[i] = (temp[1] + temp[2] + temp[3]) / 3.0;
    }
    data = result;
}

这个函数现在会处理data中的每一个元素，包括前两个和最后两个元素。对于每一个元素，它都会取出该元素及其周围最多四个元素，并将它们存储在临时向量temp中。然后，它会对temp进行排序，并计算中间元素的平均值。如果temp中只有三个或四个元素（即当我们处理数组的前两个和最后两个元素时），我们就计算这些元素（除了最大值）的平均值。

#include <algorithm>
#include <vector>

void fivePointDifference(std::vector<double>& data) {
    std::vector<double> result(data.size());
    for (int i = 0; i < data.size(); i++) {
        std::vector<double> temp;
        for (int j = std::max(0, i - 2); j <= std::min(static_cast<int>(data.size()) - 1, i + 2); j++) {
            temp.push_back(data[j]);
        }
        std::sort(temp.begin(), temp.end());
        if (temp.size() == 5) {
            result[i] = (temp[1] + temp[2] + temp[3]) / 3.0;
        } else {
            result[i] = temp[0];
            for (int j = 1; j < temp.size() - 1; j++) {
                result[i] += temp[j];
            }
            result[i] /= temp.size() - 1;
        }
    }
    data = result;
}

十点去差值法同理，选择周围十个点，去掉最大值和最小值，然后求剩余八个点的平均值。

#include <algorithm>
#include <vector>

void tenPointDifference(std::vector<double>& data) {
    std::vector<double> result(data.size());
    for (int i = 0; i < data.size(); i++) {
        std::vector<double> temp;
        for (int j = std::max(0, i - 5); j <= std::min(static_cast<int>(data.size()) - 1, i + 5); j++) {
            temp.push_back(data[j]);
        }
        std::sort(temp.begin(), temp.end());
        if (temp.size() == 11) {
            result[i] = 0;
            for (int j = 1; j < temp.size() - 1; j++) {
                result[i] += temp[j];
            }
            result[i] /= 8.0;
        } else {
            result[i] = temp[0];
            for (int j = 1; j < temp.size() - 1; j++) {
                result[i] += temp[j];
            }
            result[i] /= temp.size() - 2;
        }
    }
    data = result;
}

这是100点去差值法，根据你的实际情况来应用不同的数据处理场景。

#include <algorithm>
#include <vector>

void hundredPointDifference(std::vector<double>& data) {
    std::vector<double> result(data.size());
    for (int i = 49; i < data.size() - 49; i++) {
        std::vector<double> temp(data.begin() + i - 49, data.begin() + i + 50);
        std::sort(temp.begin(), temp.end());
        double sum = 0;
        for (int j = 1; j < temp.size() - 1; j++) {
            sum += temp[j];
        }
        result[i] = sum / 98.0;
    }
    for (int i = 0; i < 49; i++) {
        result[i] = data[i];
        result[data.size() - 1 - i] = data[data.size() - 1 - i];
    }
    
    data = result;
}

线性平滑

线性五点平滑是一种常用的数据平滑处理方法，它的基本思想是对每个数据点及其周围四个点进行加权平均，使得相邻点变得平滑。然后遍历数组中的每个元素，并对每个元素及其周围的四个元素进行处理。你可以先找到这五个元素中的最大值和最小值，然后将它们从这五个元素中移除，最后计算剩余三个元素的加权平均值。

#include <vector>

void linearFivePointSmoothing(std::vector<double>& data) {
    std::vector<double> result(data.size());
    for (int i = 2; i < data.size() - 2; i++) {
        result[i] = (data[i - 2] + data[i - 1]*2 + data[i]*3 + data[i + 1]*2 + data[i + 2]) / 9.0;
    }
    result[0] = data[0];
    result[1] = (data[0] + data[1]*2 + data[2]*3) / 6.0;
    result[data.size() - 2] = (data[data.size() - 3]*3 + data[data.size() - 2]*2 + data[data.size() - 1]) / 6.0;
    result[data.size() - 1] = data[data.size() - 1];
    
    data = result;
}

十点平滑同理，每个数据点及其周围九个点进行加权平均，使得相邻点变得平滑，遍历数组中的每个元素，并对每个元素及其周围的九个元素进行处理。具体来说，找到这十个元素中的最大值和最小值，然后将它们从这十个元素中移除，最后计算剩余八个元素的加权平均值。

#include <vector>

void linearTenPointSmoothing(std::vector<double>& data) {
    std::vector<double> result(data.size());
    for (int i = 4; i < data.size() - 4; i++) {
        result[i] = (data[i - 4] + data[i - 3]*2 + data[i - 2]*3 + data[i - 1]*4 + data[i]*5 + data[i + 1]*4 + data[i + 2]*3 + data[i + 3]*2 + data[i + 4]) / 25.0;
    }
    result[0] = data[0];
    result[1] = (data[0] + data[1]*2 + data[2]*3 + data[3]*4) / 10.0;
    result[2] = (data[0] + data[1]*2 + data[2]*3 + data[3]*4 + data[4]*5) / 15.0;
    result[3] = (data[0] + data[1]*2 + data[2]*3 + data[3]*4 + data[4]*5 + data[5]*4) / 19.0;
    result[data.size() - 4] = (data[data.size() - 6]*4 + data[data.size() - 5]*5 + data[data.size() - 4]*4 + data[data.size() - 3]*3 + data[data.size() - 2]*2 + data[data.size() - 1]) / 19.0;
    result[data.size() - 3] = (data[data.size() - 5]*5 + data[data.size() - 4]*4 + data[data.size() - 3]*3 + data[data.size() - 2]*2 + data[data.size() - 1]) / 15.0;
    result[data.size() - 2] = (data[data.size() - 4]*4 + data[data.size() - 3]*3 + data[data.size() - 2]*2 + data[data.size() - 1]) / 10.0;
    result[data.size() - 1] = data[data.size() - 1];
    
    data = result;
}

一百点平滑，遍历数组中的每个元素，并对每个元素及其周围的九十九个元素进行处理。具体来说，先找到这一百个元素中的最大值和最小值，然后将它们从这一百个元素中移除，最后计算剩余九十八个元素的加权平均值。

#include <vector>

void linearHundredPointSmoothing(std::vector<double>& data) {
    std::vector<double> result(data.size());
    for (int i = 49; i < data.size() - 49; i++) {
        double sum = 0;
        for (int j = i - 49; j <= i + 49; j++) {
            sum += data[j];
        }
        result[i] = sum / 99.0;
    }
    for (int i = 0; i < 49; i++) {
        result[i] = data[i];
        result[data.size() - 1 - i] = data[data.size() - 1 - i];
    }
    data = result;
}