C#数据平滑处理

最新推荐文章于 2024-06-19 21:44:09 发布
最新推荐文章于 2024-06-19 21:44:09 发布
阅读量4k 收藏 16
点赞数 1
文章标签： 算法
原文链接：https://blog.csdn.net/liyuanbhu/article/details/11119081?reload
版权
这篇博客介绍了线性、二次和三次函数拟合平滑数据的方法，提供了三个不同点数（3点、5点、7点）的线性平滑实现，并给出了二次和三次函数的5点和7点平滑函数实现。这些算法适用于信号处理和数据分析中减少噪声影响。
摘要由CSDN通过智能技术生成

分别为三点线性平滑、五点线性平滑和七点线性平滑。

线性拟合平滑

		public static double[] linearSmooth3(double[] in_arr, int N)
		{
            double[] out_arr = new double[in_arr.Length];
            int i; if (N < 3)
            {
                for (i = 0; i <= N - 1; i++) { out_arr[i] = in_arr[i]; }
            }
            else
            {
                out_arr[0] = (5.0 * in_arr[0] + 2.0 * in_arr[1] - in_arr[2]) / 6.0;
                for (i = 1; i <= N - 2; i++) { out_arr[i] = (in_arr[i - 1] + in_arr[i] + in_arr[i + 1]) / 3.0; }
                out_arr[N - 1] = (5.0 * in_arr[N - 1] + 2.0 * in_arr[N - 2] - in_arr[N - 3]) / 6.0;
            }
            return out_arr;
        }

        public static double[] linearSmooth5(double[] in_arr, int N)
        {
            double[] out_arr = new double[in_arr.Length];
            int i; if (N < 5)
            {
                for (i = 0; i <= N - 1; i++) { out_arr[i] = in_arr[i]; }
            }
            else
            {
                out_arr[0] = (3.0 * in_arr[0] + 2.0 * in_arr[1] + in_arr[2] - in_arr[4]) / 5.0; out_arr[1] = (4.0 * in_arr[0] + 3.0 * in_arr[1] + 2 * in_arr[2] + in_arr[3]) / 10.0;
                for (i = 2; i <= N - 3; i++)
                {
                    out_arr[i] = (in_arr[i - 2] + in_arr[i - 1] + in_arr[i] + in_arr[i + 1] + in_arr[i + 2]) / 5.0;
                }
                out_arr[N - 2] = (4.0 * in_arr[N - 1] + 3.0 * in_arr[N - 2] + 2 * in_arr[N - 3] + in_arr[N - 4]) / 10.0;
                out_arr[N - 1] = (3.0 * in_arr[N - 1] + 2.0 * in_arr[N - 2] + in_arr[N - 3] - in_arr[N - 5]) / 5.0;
            }
            return out_arr;
        }

        public static double[] linearSmooth7(double[] in_arr, int N)
        {
            double[] out_arr = new double[in_arr.Length];
            int i; if (N < 7) { for (i = 0; i <= N - 1; i++) { out_arr[i] = in_arr[i]; } }
            else
            {
                out_arr[0] = (13.0 * in_arr[0] + 10.0 * in_arr[1] + 7.0 * in_arr[2] + 4.0 * in_arr[3] + in_arr[4] - 2.0 * in_arr[5] - 5.0 * in_arr[6]) / 28.0;
                out_arr[1] = (5.0 * in_arr[0] + 4.0 * in_arr[1] + 3 * in_arr[2] + 2 * in_arr[3] + in_arr[4] - in_arr[6]) / 14.0;
                out_arr[2] = (7.0 * in_arr[0] + 6.0 * in_arr[1] + 5.0 * in_arr[2] + 4.0 * in_arr[3] + 3.0 * in_arr[4] + 2.0 * in_arr[5] + in_arr[6]) / 28.0;
                for (i = 3; i <= N - 4; i++) { out_arr[i] = (in_arr[i - 3] + in_arr[i - 2] + in_arr[i - 1] + in_arr[i] + in_arr[i + 1] + in_arr[i + 2] + in_arr[i + 3]) / 7.0; }
                out_arr[N - 3] = (7.0 * in_arr[N - 1] + 6.0 * in_arr[N - 2] + 5.0 * in_arr[N - 3] + 4.0 * in_arr[N - 4] + 3.0 * in_arr[N - 5] + 2.0 * in_arr[N - 6] + in_arr[N - 7]) / 28.0;
                out_arr[N - 2] = (5.0 * in_arr[N - 1] + 4.0 * in_arr[N - 2] + 3.0 * in_arr[N - 3] + 2.0 * in_arr[N - 4] + in_arr[N - 5] - in_arr[N - 7]) / 14.0;
                out_arr[N - 1] = (13.0 * in_arr[N - 1] + 10.0 * in_arr[N - 2] + 7.0 * in_arr[N - 3] + 4 * in_arr[N - 4] + in_arr[N - 5] - 2 * in_arr[N - 6] - 5 * in_arr[N - 7]) / 28.0;
            }
            return out_arr;
        }

利用二次函数拟合平滑。

    public double[] quadraticSmooth5(double[] in1, int N)
        {
            double[] out1 = new double[in1.Length];
            int i;
            if (N < 5)
            {
                for (i = 0; i <= N - 1; i++)
                {
                    out1[i] = in1[i];
                }
            }
            else
            {
                out1[0] = (31.0 * in1[0] + 9.0 * in1[1] - 3.0 * in1[2] - 5.0 * in1[3] + 3.0 * in1[4]) / 35.0;
                out1[1] = (9.0 * in1[0] + 13.0 * in1[1] + 12 * in1[2] + 6.0 * in1[3] - 5.0 * in1[4]) / 35.0;
                for (i = 2; i <= N - 3; i++)
                {
                    out1[i] = (-3.0 * (in1[i - 2] + in1[i + 2]) +
                              12.0 * (in1[i - 1] + in1[i + 1]) + 17 * in1[i]) / 35.0;
                }
                out1[N - 2] = (9.0 * in1[N - 1] + 13.0 * in1[N - 2] + 12.0 * in1[N - 3] + 6.0 * in1[N - 4] - 5.0 * in1[N - 5]) / 35.0;
                out1[N - 1] = (31.0 * in1[N - 1] + 9.0 * in1[N - 2] - 3.0 * in1[N - 3] - 5.0 * in1[N - 4] + 3.0 * in1[N - 5]) / 35.0;
            }
            return out1;
        }


        public double[] quadraticSmooth7(double[] in1, int N)
        {
            double[] out1 = new double[in1.Length];
            int i;
            if (N < 7)
            {
                for (i = 0; i <= N - 1; i++)
                {
                    out1[i] = in1[i];
                }
            }
            else
            {
                out1[0] = (32.0 * in1[0] + 15.0 * in1[1] + 3.0 * in1[2] - 4.0 * in1[3] -
                  6.0 * in1[4] - 3.0 * in1[5] + 5.0 * in1[6]) / 42.0;

                out1[1] = (5.0 * in1[0] + 4.0 * in1[1] + 3.0 * in1[2] + 2.0 * in1[3] +
                          in1[4] - in1[6]) / 14.0;

                out1[2] = (1.0 * in1[0] + 3.0 * in1[1] + 4.0 * in1[2] + 4.0 * in1[3] +
                          3.0 * in1[4] + 1.0 * in1[5] - 2.0 * in1[6]) / 14.0;
                for (i = 3; i <= N - 4; i++)
                {
                    out1[i] = (-2.0 * (in1[i - 3] + in1[i + 3]) +
                               3.0 * (in1[i - 2] + in1[i + 2]) +
                              6.0 * (in1[i - 1] + in1[i + 1]) + 7.0 * in1[i]) / 21.0;
                }
                out1[N - 3] = (1.0 * in1[N - 1] + 3.0 * in1[N - 2] + 4.0 * in1[N - 3] +
                                  4.0 * in1[N - 4] + 3.0 * in1[N - 5] + 1.0 * in1[N - 6] - 2.0 * in1[N - 7]) / 14.0;

                out1[N - 2] = (5.0 * in1[N - 1] + 4.0 * in1[N - 2] + 3.0 * in1[N - 3] +
                              2.0 * in1[N - 4] + in1[N - 5] - in1[N - 7]) / 14.0;

                out1[N - 1] = (32.0 * in1[N - 1] + 15.0 * in1[N - 2] + 3.0 * in1[N - 3] -
                              4.0 * in1[N - 4] - 6.0 * in1[N - 5] - 3.0 * in1[N - 6] + 5.0 * in1[N - 7]) / 42.0;
            }
            return out1;
        }

三次函数拟合平滑。

        public double[] cubicSmooth5(double[] in1, int N)
        {
            double[] out1 = new double[in1.Length];
            int i;
            if (N < 5)
            {
                for (i = 0; i <= N - 1; i++)
                    out1[i] = in1[i];
            }

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

        public double[] cubicSmooth7(double[] in1, int N)
        {
            double[] out1 = new double[in1.Length];
            int i;
            if (N < 7)
            {
                for (i = 0; i <= N - 1; i++)
                {
                    out1[i] = in1[i];
                }
            }
            else
            {
                out1[0] = (39.0 * in1[0] + 8.0 * in1[1] - 4.0 * in1[2] - 4.0 * in1[3] +
                  1.0 * in1[4] + 4.0 * in1[5] - 2.0 * in1[6]) / 42.0;
                out1[1] = (8.0 * in1[0] + 19.0 * in1[1] + 16.0 * in1[2] + 6.0 * in1[3] -
                  4.0 * in1[4] - 7.0 * in1[5] + 4.0 * in1[6]) / 42.0;
                out1[2] = (-4.0 * in1[0] + 16.0 * in1[1] + 19.0 * in1[2] + 12.0 * in1[3] +
                  2.0 * in1[4] - 4.0 * in1[5] + 1.0 * in1[6]) / 42.0;
                for (i = 3; i <= N - 4; i++)
                {
                    out1[i] = (-2.0 * (in1[i - 3] + in1[i + 3]) +
                       3.0 * (in1[i - 2] + in1[i + 2]) +
                      6.0 * (in1[i - 1] + in1[i + 1]) + 7.0 * in1[i]) / 21.0;
                }
                out1[N - 3] = (-4.0 * in1[N - 1] + 16.0 * in1[N - 2] + 19.0 * in1[N - 3] +
                                  12.0 * in1[N - 4] + 2.0 * in1[N - 5] - 4.0 * in1[N - 6] + 1.0 * in1[N - 7]) / 42.0;
                out1[N - 2] = (8.0 * in1[N - 1] + 19.0 * in1[N - 2] + 16.0 * in1[N - 3] +
                      6.0 * in1[N - 4] - 4.0 * in1[N - 5] - 7.0 * in1[N - 6] + 4.0 * in1[N - 7]) / 42.0;
                out1[N - 1] = (39.0 * in1[N - 1] + 8.0 * in1[N - 2] - 4.0 * in1[N - 3] -
                      4.0 * in1[N - 4] + 1.0 * in1[N - 5] + 4.0 * in1[N - 6] - 2.0 * in1[N - 7]) / 42.0;
            }
            return out1;
        }
烧饼丶
关注
曲线的平滑处理方法
AI天才研究院
06-26 6362
在生成损失函数等曲线时，由于噪声等高频点的波动导致曲线振荡明显。为了使曲线过渡更平滑，可以对曲线进行平滑处理。
C#平滑数据处理winform案例
07-05
C#平滑数据处理winform案例，基于最小二乘法。以五点三次平滑为例。取相邻的5个数据点，可以拟合出一条3次曲线来 包含五点线性平滑和七点线性平滑。
曲线平滑处理代码学习
最新发布
Fourglsl的博客
06-19 505
Math.Sin(dou) 是一个数学函数调用，用于计算给定角度（以弧度表示）的正弦值。
C# 数据的五点二次平滑算法
11-28
C# 五点二次 平滑算法 平滑数据 去除数据毛刺 C# 五点二次 平滑算法 平滑数据 去除数据毛刺
C#数字图象处理 平滑处理
06-10
C#数字图象处理 平滑处理
C#图谱曲线平滑滤波算法
10-05
C#图谱曲线平滑滤波算法，几个平滑直接用。其实平滑算法是触类旁通的。
数据平滑处理
06-10
调用smooth函数进行加噪数据的平滑处理；调用medfilt1函数对加噪正弦波信号进行平滑处理； 数据的标准化变换
c#数字图像处理(平滑、修正、锐化、增强等)
02-21
3. **平滑处理**：平滑操作用于减少图像噪声，通常通过滤波器实现。低通滤波器如均值滤波和高斯滤波，通过对邻近像素的平均处理来消除高频噪声，但可能导致边缘模糊。 4. **直方图修正**：直方图是图像亮度分布的...
C# winform 图形处理、图像平滑与去噪、打开图像，高斯滤波、均值与中值，灰度，小波
09-14
3. 图像平滑：平滑处理是减少图像噪声的一种方法，常见的有高斯滤波和均值滤波。高斯滤波器通过高斯核对图像进行卷积，有效地去除高频噪声，同时保持边缘清晰。均值滤波则是简单地用像素周围区域的平均值替换该像素...
C#高斯平滑算法 ：二维高斯卷积代码实例
weixin_46441425的博客
01-04 1293
//高斯平滑处理方法 //inputImage 输入图像 // outputImage 输出图像 //sigema 均方差 private void gaussSmooth(double[]inputImage,out double[] outputImage,double sigema) { //方差 double std2 = 2 * sigema * sigema; ...
C#实现 matlab smooth 的移动平滑滤波
04-10
C# 实现 yy = smooth(y) smooths the data in the column vector y using a moving average filter. Results are returned in the column vector yy. The default span for the moving average is 5. The first few elements of yy are given by yy(1) = y(1) yy(2) = (y(1) + y(2) + y(3))/3 yy(3) = (y(1) + y(2) + y(3) + y(4) + y(5))/5 yy(4) = (y(2) + y(3) + y(4) + y(5) + y(6))/5
C# 数据处理工具
06-30
这是自己写的小工具，支持sybase sqlserver oralce 数据库之间数据导入。 很小，只有一百多KB。附加代码。
指数平滑法介绍与C#实现
06-30
指数平滑法的计算中，关键是α的取值大小，但α的取值又容易受主观影响，因此合理确定α的取值方法十分重要，一般来说，如果数据波动较大，α值应取大一些，可以增加近期数据对预测结果的影响。如果数据波动平稳，α值应取小一些。理论界一般认为有以下方法可供选择：　 　　经验判断法。这种方法主要依赖于时间序列的发展趋势和预测者的经验做出判断。 　　1、当时间序列呈现较稳定的水平趋势时，应选较小的α值，一般可在0.05～0.20之间取值； 　　2、当时间序列有波动，但长期趋势变化不大时，可选稍大的α值，常在0.1～0.4之间取值； 　　3、当时间序列波动很大，长期趋势变化幅度较大，呈现明显且迅速的上升或下降趋势时，宜选择较大的α值，如可在0.6～0.8间选值，以使预测模型灵敏度高些，能迅速跟上数据的变化； 　　4、当时间序列数据是上升（或下降）的发展趋势类型，α应取较大的值，在0.6~1之间。 　　试算法。根据具体时间序列情况，参照经验判断法，来大致确定额定的取值范围，然后取几个α值进行试算，比较不同α值下的预测标准误差，选取预测标准误差最小的α。 　　在实际应用中预测者应结合对预测对象的变化规律做出定性判断且计算预测误差，并要考虑到预测灵敏度和预测精度是相互矛盾的，必须给予二者一定的考虑，采用折中的α值。 下期预测数=本期实际数×平滑系数+本期预测数×（1-平滑系数） 如某种产品销售量的平滑系数为0.4，1996年实际销售量为31万件，预测销售量为33万件。则1997年的预测销售量为： 1997年预测销售量= 31万件×0.4+33万件×（1-0.4）=32.2万件
基于C#的五点N次平滑算法
08-16
该算法是基于原来用户上传的五点二次平滑算法做了修整的，用户可以直接下载改代码并直接传值使用。 LinearSmooth5(double[] InData, double[] OutData, int N) #InData 输入数据 #OutData 输入数值 #N N次平滑
C#数据处理的类
10-08
C#数据处理的类，包括ORALCE，ACCESS，SQLSERVER的数据库连接和操作。
数据平滑处理（自用）
w19990809的博客
02-22 1180
数据平滑处理，SG算法
c#数据处理
大黄鸭在发光的专栏
09-29 1143
1.十六进制字符串转换为字节数组private const string CharSet="0123456789ABCDEF";int nLen=%%1.Length/2;byte[] %%2=new byte[nLen];for(int i=0;istring chs=%%1.ToUpper();if(chs.Length%%2[i]=(byte)(CharSet.I
C# 数据处理汇总(持续更新ing)
痴梦小哥哥的博客
05-13 1220
数组去重： String[] str = { "A", "B", "C", "D" }; String[] str2 = str.Distinct().ToArray(); 数组转字符串，以 | 分割 string[] array = { "A", "B", "C", "D" }; string str = string.Join(",", array); 列表取最大值 List<int> list1 = new List<int>() { 1, 2, 3, 4
制作进度条
weixin_34146986的博客
03-30 145
　在早先的进度条控件版本中，例如在 Microsoft Windows Common Controls ActiveX 控件中提供的版本，您可以看到进度条有两种不同的视图。您可以通过设定 Scrolling 属性来设定 Standard 视图或是 Smooth 视图。 Smooth 视图提供了一个区域来平滑的显示进度， Standard 试图则看上去是由一个一个方块来表示进度的。 　　在 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值