【C++】代码实现：数据线性平滑算法：3点线性平滑、5点（1次、2次、3次）线性平滑、7点（1次、2次）线性平滑

最新推荐文章于 2023-10-14 06:20:03 发布
最新推荐文章于 2023-10-14 06:20:03 发布
阅读量1w 收藏 86
点赞数 10
分类专栏： C++ 实战应用技巧 文章标签： 数据线性平滑 3点线性平滑 5点线性平滑 7点线性平滑
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kingkee/article/details/94389485
版权
  • 3点线性平滑：
//3点线性平滑
int LinearSmooth3(double* input, long size) {
	double *output = new double[size];
	long i(0);

	if (size < 3)
	{
		for (i = 0; i <= size - 1; i++)
		{
			output[i] = input[i];
		}
	}
	else
	{
		output[0] = (5.0 * input[0] + 2.0 * input[1] - input[2]) / 6.0;
		for (i = 1; i <= size - 2; i++)
		{
			output[i] = (input[i - 1] + input[i] + input[i + 1]) / 3.0;
		}
		output[size - 1] = (5.0 * input[size - 1] + 2.0 * input[size - 2] - input[size - 3]) / 6.0;
	}

	for (i = 0; i < size; i++)
	{
		input[i] = output[i];
	}

	delete[] output;

	return 0;
}
  • 5点线性平滑：
//5点线性平滑
int LinearSmooth5(double* input, long size) {
	double *output = new double[size];
	long i(0);

	if (size < 5)
	{
		for (i = 0; i <= size - 1; i++)
		{
			output[i] = input[i];
		}
	}
	else
	{
		output[0] = (3.0 * input[0] + 2.0 * input[1] + input[2] - input[4]) / 5.0;
		output[1] = (4.0 * input[0] + 3.0 * input[1] + 2 * input[2] + input[3]) / 10.0;
		for (i = 2; i <= size - 3; i++)
		{
			output[i] = (input[i - 2] + input[i - 1] + input[i] + input[i + 1] + input[i + 2]) / 5.0;
		}
		output[size - 2] = (4.0 * input[size - 1] + 3.0 * input[size - 2] + 2 * input[size - 3] + input[size - 4]) / 10.0;
		output[size - 1] = (3.0 * input[size - 1] + 2.0 * input[size - 2] + input[size - 3] - input[size - 5]) / 5.0;
	}

	for (i = 0; i < size; i++)
	{
		input[i] = output[i];
	}

	delete[] output;

	return 0;
}
  • 5点2次线性平滑：
//5点二次线性平滑
int LinearSmooth52(double* input, long size) {
	double *output = new double[size];
	long i(0);

	if (size < 5)
	{
		for (i = 0; i <= size - 1; i++)
		{
			output[i] = input[i];
		}
	}
	else
	{
		output[0] = (31.0 * input[0] + 9.0 * input[1] - 3.0 * input[2] - 5.0 * input[3] + 3.0 * input[4]) / 35.0;
		output[1] = (9.0 * input[0] + 13.0 * input[1] + 12 * input[2] + 6.0 * input[3] - 5.0 *input[4]) / 35.0;
		for (i = 2; i <= size - 3; i++)
		{
			output[i] = (-3.0 * (input[i - 2] + input[i + 2]) +
				12.0 * (input[i - 1] + input[i + 1]) + 17 * input[i]) / 35.0;
		}
		output[size - 2] = (9.0 * input[size - 1] + 13.0 * input[size - 2] + 12.0 * input[size - 3] + 6.0 * input[size - 4] - 5.0 * input[size - 5]) / 35.0;
		output[size - 1] = (31.0 * input[size - 1] + 9.0 * input[size - 2] - 3.0 * input[size - 3] - 5.0 * input[size - 4] + 3.0 * input[size - 5]) / 35.0;
	}

	for (i = 0; i < size; i++)
	{
		input[i] = output[i];
	}

	delete[] output;

	return 0;
}
  • 5点3次线性平滑：
//5点三次线性平滑
int LinearSmooth53(double* input, long size) {
	double *output = new double[size];
	long i(0);

	if (size < 5)
	{
		for (i = 0; i <= size - 1; i++)
			output[i] = input[i];
	}
	else
	{
		output[0] = (69.0 * input[0] + 4.0 * input[1] - 6.0 * input[2] + 4.0 * input[3] - input[4]) / 70.0;
		output[1] = (2.0 * input[0] + 27.0 * input[1] + 12.0 * input[2] - 8.0 * input[3] + 2.0 * input[4]) / 35.0;
		for (i = 2; i <= size - 3; i++)
		{
			output[i] = (-3.0 * (input[i - 2] + input[i + 2]) + 12.0 * (input[i - 1] + input[i + 1]) + 17.0 * input[i]) / 35.0;
		}
		output[size - 2] = (2.0 * input[size - 5] - 8.0 * input[size - 4] + 12.0 * input[size - 3] + 27.0 * input[size - 2] + 2.0 * input[size - 1]) / 35.0;
		output[size - 1] = (-input[size - 5] + 4.0 * input[size - 4] - 6.0 * input[size - 3] + 4.0 * input[size - 2] + 69.0 * input[size - 1]) / 70.0;
	}

	for (i = 0; i < size; i++)
	{
		input[i] = output[i];
	}

	delete[] output;

	return 0;
}
  • 7点线性平滑：
//7点线性平滑
int LinearSmooth7(double* input, long size) {
	double *output = new double[size];
	long i(0);

	if (size < 7)
	{
		for (i = 0; i <= size - 1; i++)
		{
			output[i] = input[i];
		}
	}
	else
	{
		output[0] = (13.0 * input[0] + 10.0 * input[1] + 7.0 * input[2] + 4.0 * input[3] +
			input[4] - 2.0 * input[5] - 5.0 * input[6]) / 28.0;
		output[1] = (5.0 * input[0] + 4.0 * input[1] + 3 * input[2] + 2 * input[3] +
			input[4] - input[6]) / 14.0;
		output[2] = (7.0 * input[0] + 6.0 * input[1] + 5.0 * input[2] + 4.0 * input[3] +
			3.0 * input[4] + 2.0 * input[5] + input[6]) / 28.0;
		for (i = 3; i <= size - 4; i++)
		{
			output[i] = (input[i - 3] + input[i - 2] + input[i - 1] + input[i] + input[i + 1] + input[i + 2] + input[i + 3]) / 7.0;
		}
		output[size - 3] = (7.0 * input[size - 1] + 6.0 * input[size - 2] + 5.0 * input[size - 3] +
			4.0 * input[size - 4] + 3.0 * input[size - 5] + 2.0 * input[size - 6] + input[size - 7]) / 28.0;
		output[size - 2] = (5.0 * input[size - 1] + 4.0 * input[size - 2] + 3.0 * input[size - 3] +
			2.0 * input[size - 4] + input[size - 5] - input[size - 7]) / 14.0;
		output[size - 1] = (13.0 * input[size - 1] + 10.0 * input[size - 2] + 7.0 * input[size - 3] +
			4 * input[size - 4] + input[size - 5] - 2 * input[size - 6] - 5 * input[size - 7]) / 28.0;
	}

	for (i = 0; i < size; i++)
	{
		input[i] = output[i];
	}

	delete[] output;

	return 0;
}
  • 7点2次线性平滑：
//7点二次线性平滑
int LinearSmooth72(double* input, long size) {
	double *output = new double[size];
	long i(0);

	if (size < 7)
	{
		for (i = 0; i <= size - 1; i++)
		{
			output[i] = input[i];
		}
	}
	else
	{
		output[0] = (32.0 * input[0] + 15.0 * input[1] + 3.0 * input[2] - 4.0 * input[3] -
			6.0 * input[4] - 3.0 * input[5] + 5.0 * input[6]) / 42.0;
		output[1] = (5.0 * input[0] + 4.0 * input[1] + 3.0 * input[2] + 2.0 * input[3] +
			input[4] - input[6]) / 14.0;
		output[2] = (1.0 * input[0] + 3.0 * input[1] + 4.0 * input[2] + 4.0 * input[3] +
			3.0 * input[4] + 1.0 * input[5] - 2.0 * input[6]) / 14.0;
		for (i = 3; i <= size - 4; i++)
		{
			output[i] = (-2.0 * (input[i - 3] + input[i + 3]) +
				3.0 * (input[i - 2] + input[i + 2]) +
				6.0 * (input[i - 1] + input[i + 1]) + 7.0 * input[i]) / 21.0;
		}
		output[size - 3] = (1.0 * input[size - 1] + 3.0 * input[size - 2] + 4.0 * input[size - 3] +
			4.0 * input[size - 4] + 3.0 * input[size - 5] + 1.0 * input[size - 6] - 2.0 * input[size - 7]) / 14.0;
		output[size - 2] = (5.0 * input[size - 1] + 4.0 * input[size - 2] + 3.0 * input[size - 3] +
			2.0 * input[size - 4] + input[size - 5] - input[size - 7]) / 14.0;
		output[size - 1] = (32.0 * input[size - 1] + 15.0 * input[size - 2] + 3.0 * input[size - 3] -
			4.0 * input[size - 4] - 6.0 * input[size - 5] - 3.0 * input[size - 6] + 5.0 * input[size - 7]) / 42.0;
	}

	for (i = 0; i < size; i++)
	{
		input[i] = output[i];
	}

	delete[] output;

	return 0;
}

 

kingkee
关注
  • 10
    点赞
  • 踩
  • 86
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
时间序列挖掘-预测算法-三次指数平滑法(Holt-Winters)
weixin_30731305的博客
04-01 4127
在时间序列中，我们需要基于该时间序列当前已有的数据来预测其在之后的走势，三次指数平滑(Triple/Three Order Exponential Smoothing,Holt-Winters)算法可以很好的进行时间序列的预测。 时间序列数据一般有以下几种特点：1.趋势(Trend) 2. 季节性(Seasonality)。 趋势描述的是时间序列的整体走势，比如总体上升或者总体下...
五点三次平滑滤波C语言程序
08-20
五点三次平滑滤波程序，可以滤掉波形的坏点，使波形平滑！！！
五点三次平滑算法
06-19
这里提供一个函数mean5_3(五点三次平滑算法)对数据进行平滑处理
曲线数据平滑（采用5点3次函数和7点3次函数实现）
09-02
采用5点3次函数和7点3次函数实现的数据平滑法，可直接调用应用，已验证。采用C++实现。
C++关于平滑滤波的一种算法
09-08
平滑滤波函数 效果出色 程序精炼 完全自研
2.参考线平滑算法解析及实现
weixin_56492465的博客
02-03 1325
Apollo 星火计划PNC专项 参考线平滑算法解析及实现
五点三次平滑的程序源代码
limingmcu的专栏
04-27 1万+
问题 用五点三次平滑公式对等距点上的观测数据进行平滑。 算法分析 设已知n个等距点，上的观测(或实验)数据为x0＜x1＜…＜xn－1，则可以在每个数据点的前后各取两个相邻的点，用三次多项式 Y=a0+a1x+a2x^2+a3x^3 进行逼近。 根据最小二乘原理确定出系数a0，a1，a2，a3，最后可得到五点三次平滑公式如下： 改公式要求数据点数n≥5，当数据点数多于5时，为对称考...
数据平滑算法
u014345526的专栏
02-14 4079
不多说了，下面贴代码。首先是线性拟合平滑处理的代码. 分别为三点线性平滑、五点线性平滑和七点线性平滑。 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
信号处理中简单实用的方法——对信号进行平滑处理
qq_42233059的博客
08-22 1万+
信号处理中简单实用的方法——对信号进行平滑处理
几个简单的数据点平滑处理算法
yixixi的专栏
01-07 1万+
原：http://blog.csdn.net/liyuanbhu/article/details/11119081 仅供自己学习参考。 几个简单的数据点平滑处理算法 2013-09-05 13:29 20581人阅读 评论(20) 收藏 举报 分类： 数值计算（19） 版权声明：本文为博主原创文章，未经博主允许不得转
lowess算法 的纯C ++实现_局部加权多项式回归_对数据进行平滑处理
06-09
该算法在二维中执行局部加权多项式回归，从而对数据进行平滑处理。这在数据中存在噪声时很有用。 该算法使用 x 周围最近点的加权回归来预测位置 x 处的 y 值。为了加快计算速度，回归仅在点的子集上计算 运行测试 ...
VC++三次样条插值&贝塞尔曲线&GDI+平滑曲线程序
02-05
CubicSplineInterpolation.cpp文件中实现了这一算法，通过线性代数求解一组线性方程组来得到三次样条函数的具体形式，使得曲线在给定点间平滑过渡。 其次，贝塞尔曲线是计算机图形学中广泛使用的参数曲线。它由一...
c++实现的二次B样条曲线绘制程序
03-26
二次B样条曲线是一种在计算机图形学、几何建模和工程计算中广泛应用的数学工具，它允许我们平滑地连接一系列离散数据点，形成连续的曲线。在C++中实现二次B样条曲线绘制程序涉及到对B样条理论的理解、坐标处理、图形...
3次b样条曲线
11-24
在压缩包中的Bezier.txt文件很可能包含了实现3次B样条曲线算法的代码或者数据。代码可能包括读取控制点、构建knot向量、计算基函数以及将结果绘制出来的过程。通过分析这个文件，我们可以深入理解如何在实际编程中...
C++数据结构分段线性插值
07-11
**C++数据结构分段线性插值** 在计算机科学中，线性插值是一种基本的数值分析技术，用于估算两个或多个数据点之间未知点的值。在C++编程中，分段线性插值是处理连续数据时常用的方法，特别是在数据可视化、图像处理...
SG平滑算法（又称多项式平滑算法）
热门推荐
schuffel的博客
12-24 5万+
今天是平安夜，闲来无事，那就来写一下SG平滑算法吧！ SG平滑算法是由Savizkg和Golag提出来的。基于最小二乘原理的多项式平滑算法，也称卷积平滑。为啥叫多项式平滑呢？且看下去。 下面使用五点平滑算法来说明平滑过程 原理很简单如图： 把光谱一段区间的等波长间隔的5个点记为X集合，多项式平滑就是利用在波长点为Xm-2,Xm-1,Xm,Xm+1,Xm+2的数据的多项式拟合值来取代X...
R - 时间序列数据的预测——指数平滑法（一次、二次、三次）详解附代码与公式
最新发布
Brandonn_Xu的博客
10-14 1万+
指数平滑法（Exponential Smoothing）是一种时间序列分析方法，用于处理时间序列数据的平滑和预测。它的核心思想是基于过去的观测值来预测未来的值，同时对过去的数据赋予不同的权重，最近的观测值被赋予更大的权重，从而捕捉到时间序列的趋势和季节性模式。指数平滑法的参数有3个——alpha、beta、gamma，分别对应数据、趋势、季节性。注意：参数值可以手动设定，参数值越大则模型越看重近期数据。若不设定参数，则软件会根据最大似然法计算得出参数值。
Apollo planning之参考线平滑算法
weixin_65089713的博客
02-02 5147
输入raw_reference_line，设置中间点（GetAnchorPoints），然后smooth，最后输出。lateral_bound、longitudinal_bound代表裕度，enforced代表是否是强约束。离散点平滑算法也是基于评价函数来做的，分别衡量。这里是对参考线平滑算法进行配置，对于平滑度的衡量有两种方式。参考线平滑算法主要有三种。同时还需要满足约束条件。这是中间点的配置文件。
基于三次拟合车道线的车道居中保持，斯坦利跟踪算法C++代码实现
07-20
斯坦利跟踪算法是一种常用的自动驾驶中的路径跟踪算法，它可以根据车辆当前位置和车道线信息来生成转向控制指令。以下是一个简单的C++实现示例： ```cpp #include <iostream> #include <vector> #include <cmath> // 定义多项式拟合函数 std::vector<double> polyfit(const std::vector<double>& x, const std::vector<double>& y, int degree) { int n = x.size(); int m = degree + 1; std::vector<double> X(n * m); std::vector<double> Y(n); for (int i = 0; i < n; i++) { double xi = x[i]; double yi = y[i]; for (int j = 0; j < m; j++) { X[i * m + j] = std::pow(xi, j); } Y[i] = yi; } std::vector<double> coeff(m); // 使用适当的方法求解多项式系数，这里简单地用最小二乘法求解 // ... return coeff; } // 模拟获取车道线坐标的函数，这里假设返回一组随机坐标 std::vector<double> getLaneCoordinates() { std::vector<double> x = {0, 1, 2, 3, 4, 5}; std::vector<double> y = {0.1, 0.2, 0.3, 0.4, 0.5, 0.6}; return y; } // 模拟获取车辆当前位置的函数，这里假设返回一个随机值 double getCurrentPosition() { return 2.5; } // 模拟斯坦利跟踪算法 void stanleyTracking() { while (true) { // 获取车道线坐标 std::vector<double> y = getLaneCoordinates(); // 进行多项式拟合，这里使用三次拟合 std::vector<double> coeff = polyfit(y, y, 3); // 获取车辆当前位置 double currentPosition = getCurrentPosition(); // 计算拟合曲线上与车辆当前位置最近的点的坐标 double nearestPoint = 0.0; double minDistance = std::numeric_limits<double>::max(); for (double i = 0.0; i <= 5.0; i += 0.1) { double distance = std::abs(coeff[3] * std::pow(i, 3) + coeff[2] * std::pow(i, 2) + coeff[1] * i + coeff[0] - currentPosition); if (distance < minDistance) { minDistance = distance; nearestPoint = i; } } // 计算横向偏移量 double offset = coeff[3] * std::pow(nearestPoint, 3) + coeff[2] * std::pow(nearestPoint, 2) + coeff[1] * nearestPoint + coeff[0] - currentPosition; // 计算转向控制指令 double headingError = std::atan(coeff[1] + 2 * coeff[2] * nearestPoint + 3 * coeff[3] * std::pow(nearestPoint, 2)); double crossTrackError = offset; double steerAngle = headingError + std::atan(1.0 / (crossTrackError + 0.0001)); // 避免除0错误 // 打印转向控制指令 std::cout << "Steer angle: " << steerAngle << std::endl; } } int main() { stanleyTracking(); return 0; } ``` 在实际应用中，你需要根据实际情况选择适当的多项式拟合方法，并进行参数调整和优化。此示例仅提供了一个简单的框架，你可以根据具体的需求进行进一步的开发和改进。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值