实验三 多次迭代滑动平均法程序设计
滑动平均法matlab编程
滑动平均法matlab编程
滑动平均法matlab编程
滑动平均法是一种信号处理方法，经常被用来降低噪声和平滑数据。
它的实现方法是将一段时间内的数据平均起来，然后作为一个新数据点。
MATLAB中提供了使用滑动平均法的函数smooth。
使用滑动平均法的基本语法如下：
```matlab
y_new = smooth(y);
```
其中，y代表原始数据，y_new代表平滑后的数据。
如果需要更多的数据处理选项，也可以使用下列语法：
```matlab
y_new = smooth(y, span, method);
```
其中，span代表处理数据的时间段，method代表平滑数据使用的方法。
例如，对于一个长度为n的数据向量，如果我们想要对每个数据点的前m个数据进行平滑处理，可以通过以下代码实现：```matlab
y_new = smooth(y, m);
```
另外，如果我们想要使用移动平均法作为平滑的方法，可以通过以下代码实现：
```matlab
y_new = smooth(y, m, 'moving');
```
需要注意的是，虽然滑动平均法是一种简单和有效的信号处理方法，但是它也有其局限性。
当数据中包含大量突然变化时，滑动平均法的平滑效果可能不佳，因此需要根据具体数据进行判断是否使用该方法。
数学数学实验Newton迭代法
数学实验题目4 Newton 迭代法摘要0x 为初始猜测，则由递推关系产生逼近解*x 的迭代序列{}k x ，这个递推公式就是Newton 法。
当0x 距*x 较近时，{}k x 很快收敛于*x 。
但当0x 选择不当时，会导致{}k x 发散。
故我们事先规定迭代的最多次数。
若超过这个次数，还不收敛，则停止迭代另选初值。
前言利用牛顿迭代法求的根程序设计流程问题1（1 程序运行如下：r = NewtSolveOne('fun1_1',pi/4,1e-6,1e-4,10) r = 0.7391（2 程序运行如下：r = NewtSolveOne('fun1_2',0.6,1e-6,1e-4,10) r = 0.5885问题2（1 程序运行如下：否 是否是是定义()f x输入012,,,x N εε开 始1k =01()f x ε<0100()()f x x x f x =-'102||x x ε-<k N =输出迭代失败标志输出1x输出奇 异标志结 束01x x = 1k k =+ 否r = NewtSolveOne('fun2_1',0.5,1e-6,1e-4,10)r = 0.5671（2）程序运行如下：r = NewtSolveOne('fun2_2',0.5,1e-6,1e-4,20)r = 0.5669问题3（1）程序运行如下：①p = LegendreIter(2)p = 1.0000 0 -0.3333p = LegendreIter(3)p = 1.0000 0 -0.6000 0p = LegendreIter(4)p =1.0000 0 -0.8571 0 0.0857p = LegendreIter(5)p = 1.0000 0 -1.1111 0 0.2381 0②p = LegendreIter(6)p = 1.0000 0 -1.3636 0 0.4545 0 -0.0216r = roots(p)'r= -0.932469514203150 -0.6612 0.9324695142031530.6612 -0.238619186083197 0.238619186083197用二分法求根为：r = BinSolve('LegendreP6',-1,1,1e-6)r = -0.932470204878826 -0.661212531887755 -0.2386200573979590.2386 0.661192602040816 0.932467713647959（2）程序运行如下：①p = ChebyshevIter(2)p = 1.0000 0 -0.5000p = ChebyshevIter(3)p = 1.0000 0 -0.7500 0p = ChebyshevIter(4)p = 1.0000 0 -1.0000 0 0.1250p = ChebyshevIter(5)p = 1.0000 0 -1.2500 0 0.3125 0②p = ChebyshevIter(6)p = 1.0000 0 -1.5000 0 0.5625 0 -0.0313r = roots(p)'r = -0.965925826289067 -0.7548 0.9659258262890680.7547 -0.258819045102521 0.258819045102521用二分法求根为：r = BinSolve('ChebyshevT6',-1,1,1e-6)r = -0.965929926658163 -0.7755 -0.2588289221938780.2588 0.7020 0.965924944196429与下列代码结果基本一致，只是元素顺序稍有不同：j = 0:5;x = cos((2*j+1)*pi/2/(5+1))x =0.965925826289068 0.7548 0.258819045102521-0.258819045102521 -0.7547 -0.965925826289068（3）程序运行如下：①p = LaguerreIter(2)p = 1 -4 2p = LaguerreIter(3)p = 1 -9 18 -6p = LaguerreIter(4)p = 1 -16 72 -96 24p = LaguerreIter(5)p =1.0000 -25.0000 200.0000 -600.0000 600.0000 -120.000②p = LaguerreIter(5)p =1.0000 -25.0000 200.0000 -600.0000 600.0000 -120.000r = roots(p)'r =12.6432 7.8891 3.5964257710407111.4520 0.263560319718141用二分法求根为：r = BinSolve('LaguerreL5',0,13,1e-6)r = 0.263560314567722 1.4789 3.5964257656311507.0720 12.6490（4）程序运行如下：①p = HermiteIter(2)p = 1.0000 0 -0.5000p = HermiteIter(3)p = 1.0000 0 -1.5000 0p = HermiteIter(4)p = 1.0000 0 -3.0000 0 0.7500p = HermiteIter(5)p = 1.0000 0 -5.0000 0 3.7500 0②p = HermiteIter(6)p = 1.0000 0 -7.5000 0 11.2500 0 -1.8750r = roots(p)'r =-2.3587 2.3588 -1.3358490740136961.335849074013698 -0.4367 0.4366用二分法求根为：r = BinSolve('HermiteH6',-3,3,1e-6)r =-2.3516 -1.335849********* -0.43630.4366 1.335848983453244 2.3504所用到的函数function r = NewtSolveOne(fun, x0, ftol, dftol, maxit)% NewtSolveOne 用Newton法解方程f(x)=0在x0附近的一个根%% Synopsis: r = NewtSolveOne(fun, x0)% r = NewtSolveOne(fun, x0, ftol, dftol)%% Input: fun = (string) 需要求根的函数及其导数% x0 = 猜测根，Newton法迭代初始值% ftol = (optional)误差，默认为5e-9% dftol = (optional)导数容忍最小值，小于它表明Newton法失败，默认为5e-9 % maxit = (optional)迭代次数，默认为25%% Output: r = 在寻根区间内的根或奇点if nargin < 3ftol = 5e-9;endif nargin < 4dftol = 5e-9;endif nargin < 5maxit = 25;endx = x0; %设置初始迭代位置为x0k = 0; %初始化迭代次数为0while k <= maxitk = k + 1;[f,dfdx] = feval(fun,x); %fun返回f(x)和f'(x)的值if abs(dfdx) < dftol %如果导数小于dftol，Newton法失败，返回空值r = [];warning('dfdx is too small!');return;enddx = f/dfdx; %x(n+1) = x(n) - f( x(n) )/f'( x(n) )，这里设dx = f( x(n) )/f'( x(n) )x = x - dx;if abs(f) < ftol %如果误差小于ftol，返回当前x为根r = x;return;endendr = []; %如果牛顿法未收敛，返回空值function p = LegendreIter(n)% LegendreIter 用递推的方法计算n次勒让德多项式的系数向量Pn+2(x) = (2*i+3)/(i+2) * x*Pn+1(x) - (i+1)/(i+2) * Pn(x)%% Synopsis: p = LegendreIter(n)%% Input: n = 勒让德多项式的次数%% Output: p = n次勒让德多项式的系数向量if round(n) ~= n | n < 0error('n必须是一个非负整数');endif n == 0 %P0(x) = 1p = 1;return;elseif n == 1 %P1(x) = xp = [1 0];return;endpBk = 1; %初始化三项递推公式后项为P0pMid = [1 0]; %初始化三项递推公式中项为P1for i = 0:n-2pMidCal = zeros(1,i+3); %构造用于计算的x*Pn+1pMidCal(1:i+2) = pMid;pBkCal = zeros(1,i+3); %构造用于计算的PnpBkCal(3:i+3) = pBk;pFwd = (2*i+3)/(i+2) * pMidCal - (i+1)/(i+2) * pBkCal; %勒让德多项式三项递推公式Pn+2(x) = (2*i+3)/(i+2) * x*Pn+1(x) - (i+1)/(i+2) * Pn(x)pBk = pMid; %把中项变为后项进行下次迭代pMid = pFwd; %把前项变为中项进行下次迭代endp = pFwd/pFwd(1); %把勒让德多项式最高次项系数归一化function p = ChebyshevIter(n)% ChebyshevIter 用递推的方法计算n次勒让德-切比雪夫多项式的系数向量Tn+2(x) = 2*x*Tn+1(x) - Tn(x)%% Synopsis: p = ChebyshevIter(n)%% Input: n = 勒让德-切比雪夫多项式的次数%% Output: p = n次勒让德-切比雪夫多项式的系数向量if round(n) ~= n | n < 0error('n必须是一个非负整数');endif n == 0 %T0(x) = 1p = 1;return;elseif n == 1 %T1(x) = xp = [1 0];return;endpBk = 1; %初始化三项递推公式后项为T0pMid = [1 0]; %初始化三项递推公式中项为T1for i = 0:n-2pMidCal = zeros(1,i+3); %构造用于计算的x*Tn+1pMidCal(1:i+2) = pMid;pBkCal = zeros(1,i+3); %构造用于计算的PnpBkCal(3:i+3) = pBk;pFwd = 2*pMidCal - pBkCal; %勒让德-切比雪夫多项式三项递推公式Tn+2(x) = 2*x*Tn+1(x) - Tn(x)pBk = pMid; %把中项变为后项进行下次迭代pMid = pFwd; %把前项变为中项进行下次迭代endp = pFwd/pFwd(1); %把勒让德-切比雪夫多项式最高次项系数归一化function p = LaguerreIter(n)% LaguerreIter 用递推的方法计算n次拉盖尔多项式的系数向量Ln+2(x) = (2*n+3-x)*Ln+1(x) - (n+1)*Ln(x)%% Synopsis: p = LaguerreIter(n)%% Input: n = 拉盖尔多项式的次数%% Output: p = n次拉盖尔多项式的系数向量if round(n) ~= n | n < 0error('n必须是一个非负整数');endif n == 0 %L0(x) = 1p = 1;return;elseif n == 1 %L1(x) = -x+1p = [-1 1];return;endpBk = 1; %初始化三项递推公式后项为L0pMid = [-1 1]; %初始化三项递推公式中项为L1for i = 0:n-2pMidCal1 = zeros(1,i+3); %构造用于计算的x*Ln+1(x)pMidCal1(1:i+2) = pMid;pMidCal2 = zeros(1,i+3); %构造用于计算的Ln+1(x)pMidCal2(2:i+3) = pMid;pBkCal = zeros(1,i+3); %构造用于计算的Ln(x)pBkCal(3:i+3) = pBk;pFwd =( (2*i+3)*pMidCal2 - pMidCal1 - (i+1)*pBkCal )/ (i+2); %拉盖尔多项式三项递推公式Ln+2(x) = (2*n+3-x)*Ln+1(x) - (n+1)^2*Ln(x)pBk = pMid; %把中项变为后项进行下次迭代pMid = pFwd; %把前项变为中项进行下次迭代endp = pFwd/pFwd(1); %把拉盖尔多项式最高次项系数归一化function p = HermiteIter(n)% HermiteIter 用递推的方法计算n次埃尔米特多项式的系数向量Hn+2(x) = 2*x*Hn+1(x) - 2*(n+1)*Hn(x)%% Synopsis: p = HermiteIter(n)%% Input: n = 埃尔米特多项式的次数%% Output: p = n次埃尔米特多项式的系数向量if round(n) ~= n | n < 0error('n必须是一个非负整数');endif n == 0 %H0(x) = 1p = 1;return;elseif n == 1 %H1(x) = 2*xp = [2 0];return;endpBk = 1; %初始化三项递推公式后项为L0pMid = [2 0]; %初始化三项递推公式中项为L1for i = 0:n-2pMidCal = zeros(1,i+3); %构造用于计算的x*Hn+1(x)pMidCal(1:i+2) = pMid;pBkCal = zeros(1,i+3); %构造用于计算的Hn(x)pBkCal(3:i+3) = pBk;pFwd =2*pMidCal - 2*(i+1)*pBkCal; %埃尔米特多项式三项递推公式Hn+2(x) = 2*x*Hn+1(x) - 2*(n+1)*Hn(x)pBk = pMid; %把中项变为后项进行下次迭代pMid = pFwd; %把前项变为中项进行下次迭代endp = pFwd/pFwd(1); %把拉盖尔多项式最高次项系数归一化function r = BinSolve(fun, a, b, tol)% BinSolve 用二分法解方程f(x)=0在区间[a,b]的根%% Synopsis: r = BinSolve(fun, a, b)% r = BinSolve(fun, a, b, tol)%% Input: fun = (string) 需要求根的函数% a,b = 寻根区间上下限% tol = (optional)误差，默认为5e-9%% Output: r = 在寻根区间内的根if nargin < 4tol = 5e-9;endXb = RootBracket(fun, a, b); %粗略寻找含根区间[m,n] = size(Xb);r = [];nr = 1; %初始化找到的根的个数为1maxit = 50; %最大二分迭代次数为50for i = 1:ma = Xb(i,1); %初始化第i个寻根区间下限b = Xb(i,2); %初始化第i个寻根区间上限err = 1; %初始化误差k = 0;while k < maxitfa = feval(fun, a); %计算下限函数值fb = feval(fun, b); %计算上限函数值m = (a+b)/2;fm = feval(fun, m);err = abs(fm);if sign(fm) == sign(fb) %若中点处与右端点函数值同号，右端点赋值为中点b = m;else %若中点处与左端点函数值同号或为0，左端点赋值为中点a = m;endif err < tol %如果在a处函数值小于tolr(nr) = a; %一般奇点不符合该条件，这样可以去除奇点nr = nr + 1; %找到根的个数递增k = maxit; %改变k值跳出循环endk = k + 1; %二分迭代次数递增endendfunction X = powerX(x,a,b)% powerX 对给定向量(x1, x2,..., xn)返回增幂矩阵(x1^a, x2^a,..., xn^a; x1^a+1, x2^a+1,..., xn^a+1; ...; x1^b, x2^b,..., xn^b;)%% Synopsis: X = powerX(x,a,b)%% Input: x = 需要返回增幂矩阵的向量% a,b = 寻根区间上下限%% Output: X = 增幂矩阵(x1^a, x2^a,..., xn^a; x1^a+1, x2^a+1,..., xn^a+1; ...; x1^b, x2^b,..., xn^b;)if round(a) ~= a | round(b) ~= berror('a,b must be integers');elseif a >= berror('a must be smaller than b!');endx = x(:)';row = b-a+1;col = length(x);X = zeros(row, col);for i = b:-1:aX(b-i+1,:) = x.^i;Endfunction [f, dfdx] = fun1_1(x)f = cos(x) - x;dfdx = -sin(x) - 1;function [f, dfdx] = fun1_2(x)f = exp(-x) - sin(x);dfdx = -exp(-x) - cos(x);function [f, dfdx] = fun2_1(x)f = x - exp(-x);dfdx = 1 + exp(-x);function [f, dfdx] = fun2_2(x)f = x.^2 - 2*x*exp(-x) + exp(-2*x);dfdx = 2*x - 2*exp(-x) + 2*x*exp(-x) - 2*exp(-2*x);function y = LegendreP6(x)p = LegendreIter(6);X = powerX(x,0,6);y = p*X;function y = ChebyshevT6(x)p = ChebyshevIter(6);X = powerX(x,0,6);y = p*X;function y = LaguerreL5(x)p = LaguerreIter(5);X = powerX(x,0,5);y = p*X;function y = HermiteH6(x)p = HermiteIter(6);X = powerX(x,0,6);y = p*X;思考题（1）由于Newton法具有局部收敛性，所以在实际问题中，当实际问题本身能提供接近于根的初始近似值时，就可保证迭代序列收敛，但当初值难以确定时，迭代序列就不一定收敛。
实验三牛顿迭代法和牛顿下山法
实验三牛顿迭代法和牛顿下山法（2学时）
牛顿迭代法和牛顿下山法是求解非线性方程的有效方法，要求熟练掌握牛顿迭代公式和牛顿下山法，并能够针对不同的非线性方程构造其迭代公式。
一、实验目的
1 ．能熟练掌握牛顿迭代法和牛顿迭代法。
2 ．掌握迭代的收敛性。
二、实验要求
1 ．上机前作好充分准备，比较不用的方法解决相同问题的不同。
2 ．编写Fortran程序，记录调试过程及结果。
3 ．程序调试完后，在机器上检查运行结果。
4 ．给出本实验的实验报告。
三、实验内容
1 ．求解方程：f（x）=x3-x-1 的根。
2 ．编写牛顿迭代法程序，取初值x0=1.3，迭代收敛的条件为前后迭代结果的差小于10—6。
3 ．编写牛顿下山法程序，取初值0.6，迭代的收敛条件为前后迭代结果的差小于10—6。
4 ．并用上述几种算法程序计算出上面方程的解。
四、实验步骤
•根据实验题目，给出解决问题的程序代码。
•上机输入和调试自己所编的程序。
•上机结束后，应整理出实验报告。
五、实验报告要求及记录、格式
按《数值计算方法》课程实验报告要求格式填写。
Java上机实验-迭代循环法
实验名称Java上机实验迭代循环法和位运算姓名：山水不言学号：xxxxxx一、实验内容1、编制程序，求出斐波拉契数列。
斐波拉契数列定义如下：Fibonacci(n)=n,(当n=0,1)Fibonacci(n)=fibonacci(n-1)+fibonacci(n-2),(当n>=2)分别用迭代循环法和递归法完成之。
实验思路：斐波那数列的第0项和第1项需要单独考虑，在迭代循环法中作为其他项的来源，在递归法中作为递归函数的出口。
实验源码：package fibonacci;import java.util.Scanner;public class fibonacci {public static void main(String[] args) {// TODO自动生成的方法存根int select=0,num=0;System.out.print("请输入数字");Scanner input=new Scanner(System.in);num=input.nextInt();System.out.print("迭代循环法输入1，递归法输入2/n");select=input.nextInt();if(select==1){fibon1(num);}else if(select==2){System.out.print("斐波拉契数列第"+num+"项为："+fibon2(num));}}public static void fibon1(int num)//循环迭代{int []fibo=new int[num+1];if(num==0||num==1){System.out.print("斐波拉契数列第"+num+"项为："+num);}else {fibo[0]=0;fibo[1]=1;int n=2;while(n<=num){fibo[n]=fibo[n-1]+fibo[n-2];n++;}System.out.print("斐波拉契数列第"+num+"项为："+fibo[num]);}}public static int fibon2(int num)//递归{if(num==0||num==1)return num;elsereturn fibon2(num-1)+fibon2(num-2);}}2、用位运算将一个数扩大100倍实验思路：扩大100倍可以看做利用位运算取代乘法和加法。
泰克 多次平均 算法
泰克多次平均算法在数据处理和统计分析领域中，泰克多次平均算法是一种有效的方法，用于对一组数据进行平均处理。
它可以在去除异常值的同时，减小随机误差对结果的影响，提高数据的可靠性和准确性。
本文将对泰克多次平均算法进行详细介绍，并探讨其在数据处理中的应用。
一、泰克多次平均算法简介泰克多次平均算法，又称为TK算法，是一种通过多次迭代计算得到数据的平均值的方法。
其基本思想是在每次迭代中，去除数据中的一部分异常值，然后重新计算平均值，直至达到指定的迭代次数或满足收敛条件。
二、泰克多次平均算法的步骤1. 输入数据：首先，需要输入一组待处理的数据。
这些数据可以是实验测量数据、观测数据等。
2. 初次平均：对输入的数据进行首次平均处理，得到初始平均值。
3. 异常值检测：通过统计学方法或其他异常值检测算法，识别并去除数据中的异常值。
常用的方法包括标准差法、箱线图法等。
4. 剔除异常值：根据异常值检测的结果，将异常值从数据集中剔除。
5. 重新平均：对剔除异常值后的数据进行重新平均处理，得到新的平均值。
6. 判断收敛：判断新的平均值与之前的平均值之间的差异是否满足收敛条件。
如果满足条件，则停止迭代；如果不满足条件，则返回步骤3，继续进行异常值检测和剔除操作。
7. 输出结果：最终得到的平均值即为经过泰克多次平均算法处理后的结果。
三、泰克多次平均算法的应用场景1. 实验数据处理：在科学实验中，由于各种因素的干扰，得到的数据可能存在异常值。
使用泰克多次平均算法可以去除异常值，得到更可靠的实验结果。
2. 数据分析与挖掘：在大数据分析和挖掘中，泰克多次平均算法可以应用于异常值检测和数据清洗工作，提高数据的准确性和可信度。
3. 财务分析：在财务数据分析中，泰克多次平均算法可以用于去除财务报表中的异常值，提高财务数据的可靠性。
4. 生产过程控制：在工业生产过程中，通过对生产数据进行泰克多次平均算法处理，可以排除因设备故障等原因引起的异常值，提高生产过程的稳定性和可控性。
滑动平均法的基本原理
滑动平均法的基本原理滑动平均法的基本原理是通过对一段连续的数据进行平均运算，将每个数据点与其它一定范围内的数据点进行加权平均，从而得到平滑后的数值。
这个范围称为窗口（Window），也称为移动窗口（Moving Window），其大小通常由用户指定。
具体来说，滑动平均法的实现步骤如下：1.定义窗口大小：首先需要根据实际需求和数据特点，选择一个适当的窗口大小。
较小的窗口可以对数据更敏感，但同时也容易受到噪声和异常值的影响；较大的窗口可以平滑数据，但会导致更多的延迟和滞后。
2.计算窗口内数据的平均值：在滑动平均法中，窗口内的数据点被加权平均，得到当前的平均值。
常见的加权方式有简单平均、加权平均和指数平均。
简单平均是对窗口内的数据点直接进行平均运算。
加权平均是通过给不同的数据点分配不同的权重，再进行平均运算。
指数平均是给最近的数据点分配更高的权重，而较远的数据点分配较低的权重，以适应不同数据点的重要程度。
3.移动窗口：将窗口向前移动一个数据点，继续进行平均运算。
即将窗口内最早的数据点去除，加入最新的数据点。
这样就实现了数据的平滑处理。
通过滑动平均法，我们可以得到一系列平滑后的数据点，这些数据点在一定程度上去除了随机波动和异常值的影响，更能反映出数据的趋势和周期性。
滑动平均法广泛应用于金融领域、经济学、信号处理等。
例如，在金融交易中，滑动平均法可以用于识别价格趋势和判断买卖信号。
1.窗口大小的选择：窗口大小的选择需要根据实际需求和数据特点进行权衡。
较小的窗口可以更敏感地捕捉数据的变化，但也容易受到噪声和异常值的干扰；较大的窗口可以平滑数据，但会导致更多的延迟和滞后，难以快速捕捉数据的变化。
2.数据的平稳性：滑动平均法适用于平稳的时间序列数据。
如果数据存在趋势、周期性或者季节性等特点，滑动平均法可能无法准确捕捉到数据的变化。
3.异常值的处理：滑动平均法可以一定程度上平滑异常值，但也有可能将异常值模糊化成整体趋势。
数据平滑5点3次 等距
1 (69Y 2 +4Y 1 -6Y 0 +4 Y 1 -Y 2 ) 70 1 Y1 = (2 Y 2 +27 Y 1 +12 Y 0 -8 Y1 +2 Y 2 ) 30 1 Y0 = (-3 Y 2 +12 Y 1 +17 Y 0 +12 Y1 -3 Y 2 ) 35 1 Y1 = (2 Y 2 -8 Y 1 +12 Y 0 +27 Y 1 +2 Y 2 ) 35 1 (- Y 2 +4 Y 1 -6 Y 0 +4 Y 1 +69 Y 2 ) Y2 = 70
X X0 则原节 h
i n
Ri2 = [ a1t ij -Y i ] 2 = (a 0 ,a 1 ,…,a m )
i n
n
n
m
j 0
为使 (a 0 ,a 1 ,…,a m )达到最小. 将它分为对 a k (k=0,1,….,m) 求编导数,并令其为 0,可得方程组
330 FOR J=3 TO N-2 340 A(J)=(-3*(B(J-2)+B(J+2))+12*(B(J-1)+B(J+1))+17*B(J))/35 350 NEXT J 360 A(N-1)=(2*(B(N-4)+B(N))-8*B(N-3)+12*B(N-2)+27*B(N-1))/35 370 A(N)==(-B(N-4)+4*(B(N-3)+B(N-1))-6*B(N-2)+69*B(N))/70 380 RETURN 例: x(J) 1 2 3 4 5 6 7 8 9 10 11 n=11 OLD 54 145 227 359 381 401 372 342 259 112 65 NEW 57.12857 132.4857 24572 380.5715 338.4857 244 122 62.5
滑动平均算法c语言
滑动平均算法c语言什么是滑动平均算法滑动平均算法（Moving Average）是一种用于平滑时间序列数据的常用方法。
它通过计算一系列连续时间段内数据的均值，并将均值作为结果输出。
滑动平均算法对于去除噪音、平滑数据、降低波动等方面具有广泛的应用。
滑动平均算法的原理滑动平均算法的原理很简单，它通过维护一个固定大小的窗口（滑动窗口）来计算各个时间段内数据的均值。
在每个时间点，只需要更新窗口内的数据即可。
具体来说，滑动平均算法的计算过程如下：1.初始化一个长度为n的窗口，窗口内的初始数据为0。
2.每次输入一个新的数据，将其加入窗口，并将窗口最旧的数据移出窗口。
3.计算窗口内数据的均值，并将均值作为输出。
通过不断更新窗口内的数据，滑动平均算法可以平滑时间序列数据，使其更加稳定和可靠。
滑动平均算法的实现步骤滑动平均算法的实现步骤如下：1.定义一个长度为n的数组，用于存储窗口内的数据。
2.初始化数组中的元素为0。
3.定义变量sum，用于存储窗口内数据的和。
4.定义变量count，用于记录窗口内数据的个数。
5.定义变量index，用于记录当前窗口中最旧的数据的索引。
6.在每次输入新数据时，将新数据放入数组中的index位置，并更新sum和count值。
7.更新index的值，使其指向下一个最旧的数据。
8.如果count小于n，则count加1；否则，移除窗口中最旧的数据，并更新sum和count的值。
9.计算窗口内数据的均值，即sum除以count，并将均值作为输出。
滑动平均算法的C语言实现下面是使用C语言实现滑动平均算法的代码：#include <stdio.h>#define N 10float slidingAverage(float arr[], int n, float x) {static float window[N];static int count = 0;static float sum = 0;static int index = 0;// 更新窗口内数据的和sum = sum - window[index] + x;// 更新窗口内数据的个数count = (count < n) ? (count + 1) : n;// 更新窗口中最旧数据的索引index = (index + 1) % n;// 更新窗口内的数据window[index] = x;// 计算窗口内数据的均值return sum / count;}int main() {float data[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};int n = sizeof(data) / sizeof(data[0]);printf("滑动平均结果：\n");for (int i = 0; i < n; i++) {float average = slidingAverage(data, N, data[i]);printf("%.2f ", average);}printf("\n");return 0;}在上述代码中，我们使用了一个静态数组window用于存储窗口内的数据，使用count变量记录窗口内数据的个数，使用sum变量记录窗口内数据的和，使用index 变量记录窗口中最旧数据的索引。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验三多次迭代滑动平均法程序设计姓名：专业：勘查技术与工程学号：指导教师：纪新林一. 基本原理：1．多次迭代法的计算公式：⎪⎪⎩⎪⎪⎨⎧⋅++==∑∑∑∑-=-=-=-=+Nr Nr l Mr Mr l Nr Nr l Mr Mr k P P l i k i G j i G j i G j i G 1),(),(),(),()()1()0( 式中：),1;,1)(,(n j m i j i G ⋅⋅⋅=⋅⋅⋅=为总场值； ),1;,1)(,()0(n j m i j i G ⋅⋅⋅=⋅⋅⋅=为迭代的初始值；P 为迭代次数，Nr 为窗口沿y 轴的半径，Mr 为窗口沿x 轴的半径。
2．多次迭代法可解决的问题：可以进行场的分离，得到深部区域场和剩余场，同时也可以消除随机异常。
二．输入输出数据格式设计：X 方向窗口半径：MradiusY 方向窗口半径：Nradius迭代次数：Interationmax输入总场文件名：Totalfilename 输出区域场文件名：Regfilename 输出剩余场文件名：Resfilename 总场值：G区域场值：GReg 剩余场值：GRes 点数：mpoint 线数：nline点坐标的最小值：Xmin 点坐标的最大值：Xmax 线坐标的最小值：Ymin 线坐标的最大值：Ymax三．总体设计I ：输入有关参数：文件名，迭代次数，窗口半径输入点线数，X ，Y 坐标的最大值和最小值 输入总场P ：循环进行滑动平均计算 O ：输出区域场和剩余场四．测试结果1.测试参数如下：（1）网格数据保存在Totalfilename.grd 中。
网格数据按grd 格式保存，有27条线、27个点，点（线）坐标从-26m~26m ，点线距为2m 。
(2) 迭代次数3，窗口半径为6m ，相关参数保存在CMD.txt 文件中：Totalfilename.grd Regfilename.grd Resfilename.grd 3 6 62.测试结果：得到区域场和剩余场的两个网格化文件：Regfilename.grd ，Resfilename.grd 用Surfer 8 分别绘制等值线图：分别得到总场等值线图，区域场等值线图，剩余场等值线图：-25-20-15-10-5510152025-25-20-15-10-55101520250.020.040.060.080.10.120.140.160.180.20.220.240.260.280.30.320.340.360.38总场等值线图-25-20-15-10-5510152025-25-20-15-10-55101520250.030.0350.040.0450.050.0550.060.0650.070.0750.080.0850.090.0950.1区域场等值线图-25-20-15-10-5510152025-25-20-15-10-5510152025-0.06-0.04-0.0200.020.040.060.080.10.120.140.160.180.20.220.240.260.28剩余场等值线五．结论及建议：多次迭代滑动平均法可以进行场的分离，将一个重力异常分离为深部的区域异常和剩余场，同时能够消除随机虚假异常。
一般来说，窗口越大，滑动平均值反映的区域异常越深；迭代次数越多，得到的区域场越平滑，得到的剩余场越明显，反复迭代基本上可以消除随机异常和假异常，达到压制干扰的效果。
本次测试迭代了三次，由以上图可知，迭代得到的区域异常比总异常平滑了很多，而剩余场基本上与总场一致，有细微的差别。
总体来说得到了实验要求的效果，基本上反映了多次迭代滑动平均法进行场的分离的规律。
为了使结果更加明显，可以增加迭代次数。
附录：源程序代码!ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc !ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc ! 程序说明!! 程序功能：mulfi_iter_mean --- 重力异常数据的多次迭代滑动平均处理!! 输入参数: Mradius --- X方向窗口半径mpoint --- 点数! Nradius --- Y方向窗口半径nline --- 线数! Interationmax --- 迭代次数Xmin --- X测线最小值! Totalfilename --- 输入总场文件名Xmax --- X测线最大值! Regfilename --- 输出区域场文件名Ymin --- Y测线最小值! Resfilename --- 输出剩余场文件名Ymax --- Y测线最大值! G --- 总场值!! 所用文件：CMD.txt --- 输入相关参数! Totalfilename.grd --- 总场输入文件! Regfilename.grd --- 区域场输出文件! Resfilename.grd --- 剩余场输出文件!! 中间变量：number --- 中间整型变量GReg --- 区域场值! sum --- 中间实型变量GRes --- 剩余场值! Gmax --- 网格点处异常数据的最大值! Gmax --- 网格点处异常数据的最小值!! 输出参数：Regfilename.grd --- 区域场输出文件! Resfilename.grd --- 剩余场输出文件!! 所用子程序：input_CMD --- 输入相关文件名和数据! read_mpointnline --- 从输入文件中读入点线个数! 和X，Y测线最大值最小值! inputGRD --- 输入总场值到数组G! mulfi_iter_mea --- 滑动平均法! mean_sub --- 迭代过程! outputGRD --- 输出网格化文件!!! 作者：韩自强!ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc !ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc!滑动平均法的主程序~~~PROGRAM mulfi_iter_meanCHARACTER*80 Totalfilename,Regfilename,ResfilenameINTEGER mrradius,nradiusINTEGER interationmaxINTEGER mpoint,nlineREAL xmin,xmax,ymin,ymaxREAL,ALLOCATABLE:: G(:,:),GReg(:,:),GRes(:,:)CALL input_CMD(Totalfilename,Regfilename,Resfilename,* interationmax,mradius,nradius)CALL read_mpointnline(Totalfilename,mpoint,nline,* xmin,xmax,ymin,ymax)ALLOCATE(G(1:mpoint,1:nline),GReg(1:mpoint,1:nline),* GRes(1:mpoint,1:nline))CALL inputGRD(Totalfilename,mpoint,nline,G)CALL mulfi_iter_mea(mpoint,nline,G,mradius,nradius,* interationmax,GReg,GRes)CALL outputGRD(Regfilename,mpoint,nline,GReg,xmin,xmax,ymin,ymax) CALL outputGRD(Resfilename,mpoint,nline,GRes,xmin,xmax,ymin,ymax) DEALLOCATE(G,GReg,GRes)END PROGRAM mulfi_iter_mean!输入相关文件名和数据~~~SUBROUTINE input_CMD(Totalfilename,Regfilename,Resfilename,* interationmax,mradius,nradius)CHARACTER*80 Totalfilename,Regfilename,ResfilenameINTEGER interationmax,mrradius,nradiusOPEN(20,file='CMD.txt')READ(20,*) TotalfilenameREAD(20,*) RegfilenameREAD(20,*) ResfilenameREAD(20,*) interationmaxREAD(20,*) mradiusREAD(20,*) nradiusclose(20)END SUBROUTINE input_CMD!从输入文件中读入点线个数和X，Y测线最大值最小值~~~SUBROUTINE read_mpointnline(Totalfilename,mpoint,nline, xmin,xmax, * ymin,ymax)CHARACTER*80 TotalfilenameINTEGER mpoint,nlineREAL xmin,xmax,ymin,ymaxOPEN(20,file=Totalfilename)READ(20,*)READ(20,*) mpoint,nlineREAD(20,*) xmin,xmaxREAD(20,*) ymin,ymaxCLOSE(20)END SUBROUTINE read_mpointnline!输入总场值到数组G~~~SUBROUTINE inputGRD(Totalfilename,mpoint,nline,G)CHARACTER*80 TotalfilenameINTEGER mpoint,nlineREAL G(1:mpoint,1:nline)OPEN(20,file=Totalfilename)READ(20,*)READ(20,*) mpoint,nlineREAD(20,*)READ(20,*)READ(20,*)READ(20,*) (((G(I,J)),I=1,mpoint),J=1,nline)CLOSE(20)END SUBROUTINE inputGRD!滑动平均法~~~SUBROUTINE mulfi_iter_mea(mpoint,nline,G,mradius,nradius,* interationmax,GReg,GRes)INTEGER mrradius,nradiusINTEGER interationmaxINTEGER mpoint,nlineREAL G(1:mpoint,1:nline),GReg(1:mpoint,1:nline),* GRes(1:mpoint,1:nline)GRes=GDO K=1,interationmaxCALL mean_sub(mpoint,nline,mradius,nradius,GReg,GRes)GRes=GRegEND DOGRes=G-GRegEND SUBROUTINE mulfi_iter_mea!迭代过程~~~SUBROUTINE mean_sub(mpoint,nline,mradius,nradius,GReg,GRes) INTEGER mpoint,nlineREAL GReg(1:mpoint,1:nline),GRes(1:mpoint,1:nline)DO J=1,nlineDO I=1,mpointsum=0.0number=0DO K=MAX(1,I-mradius),MIN(mpoint,I+mradius)DO L=MAX(1,J-nradius),MIN(nline,J+nradius)number=number+1sum=sum+GRes(K,L)END DOEND DOGReg(I,J)=sum/numberEND DOEND DOEND SUBROUTINE mean_sub!输出网格化文件~~~SUBROUTINE outputGRD(Regfilename,mpoint,nline,GReg,xmin,xmax, * ymin,ymax)CHARACTER*80 RegfilenameINTEGER mpoint,nlineREAL xmin,xmax,ymin,ymaxREAL GReg(1:mpoint,1:nline)Gmax=GReg(1,1)Gmin=GReg(1,1)DO I=1,mpointDO J=1,nlineIF(Gmax<=GReg(I,J)) THENGmax=GReg(I,J)END IFIF(Gmin>=GReg(I,J)) THENGmin=GReg(I,J)END IFEND DOEND DOOPEN(20,file=Regfilename)WRITE(20,'(A)') 'DSAA'WRITE(20,*) mpoint,nlineWRITE(20,*) xmin,xmaxWRITE(20,*) ymin,xmaxWRITE(20,*) Gmin,GmaxWRITE(20,*) (((GReg(I,J)),I=1,mpoint),J=1,nline)CLOSE(20)END SUBROUTINE outputGRD。