五点三次平滑法滤波 C 和 matlab代码

最新推荐文章于 2024-07-16 10:12:51 发布
最新推荐文章于 2024-07-16 10:12:51 发布
阅读量1.7w 收藏 21
点赞数 6
分类专栏： C# 文章标签： 5点3次平滑法 
 
 

  
  转载http://blog.csdn.net/liyuanbhu/article/details/11119081

 
 

 
 

  
  

 
 

 
 

  
  以五点三次平滑为例。取相邻的5个数据点，可以拟合出一条3次曲线来，然后用3次曲线上相应的位置的数据值作为滤波后结果。简单的说就是 Savitzky-Golay 滤波器 。只不过Savitzky-Golay 滤波器并不特殊考虑边界的几个数据点，而这个算法还特意把边上的几个点的数据拟合结果给推导了出来。

 
 

 
 

  
  首先是线性拟合平滑处理的代码. 分别为三点线性平滑、五点线性平滑和七点线性平滑。

 
 

 
 

  
  void 
  
  linearSmooth3 
  
  ( 
  
  double 
  
  in
  
  [], 
  
  double 
  
  out
  
  [], 
  
  int 
  
  N 
  
  )
 
 

 
 

  
  {
 
 

 
 
    
  
  int 
  
  i
  
  ;
 
 

 
 
    
  
  if 
  
  ( 
  
  N 
  
  < 
  
  3 
  
  )
 
 

 
 
    
  
  {
 
 

 
 
        
  
  for 
  
  ( 
  
  i 
  
  = 
  
  0
  
  ; 
  
  i 
  
  <= 
  
  N 
  
  - 
  
  1
  
  ; 
  
  i
  
  ++ 
  
  )
 
 

 
 
        
  
  {
 
 

 
 
            
  
  out
  
  [
  
  i
  
  ] 
  
  = 
  
  in
  
  [
  
  i
  
  ];
 
 

 
 
        
  
  }
 
 

 
 
    
  
  }
 
 

 
 
    
  
  else
 
 

 
 
    
  
  {
 
 

 
 
        
  
  out
  
  [
  
  0
  
  ] 
  
  = 
  
  ( 
  
  5.0 
  
  * 
  
  in
  
  [
  
  0
  
  ] 
  
  + 
  
  2.0 
  
  * 
  
  in
  
  [
  
  1
  
  ] 
  
  - 
  
  in
  
  [
  
  2
  
  ] 
  
  ) 
  
  / 
  
  6.0
  
  ;
 
 

 
 


 
 

 
 
        
  
  for 
  
  ( 
  
  i 
  
  = 
  
  1
  
  ; 
  
  i 
  
  <= 
  
  N 
  
  - 
  
  2
  
  ; 
  
  i
  
  ++ 
  
  )
 
 

 
 
        
  
  {
 
 

 
 
            
  
  out
  
  [
  
  i
  
  ] 
  
  = 
  
  ( 
  
  in
  
  [
  
  i 
  
  - 
  
  1
  
  ] 
  
  + 
  
  in
  
  [
  
  i
  
  ] 
  
  + 
  
  in
  
  [
  
  i 
  
  + 
  
  1
  
  ] 
  
  ) 
  
  / 
  
  3.0
  
  ;
 
 

 
 
        
  
  }
 
 

 
 


 
 

 
 
        
  
  out
  
  [
  
  N 
  
  - 
  
  1
  
  ] 
  
  = 
  
  ( 
  
  5.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  1
  
  ] 
  
  + 
  
  2.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  2
  
  ] 
  
  - 
  
  in
  
  [
  
  N 
  
  - 
  
  3
  
  ] 
  
  ) 
  
  / 
  
  6.0
  
  ;
 
 

 
 
    
  
  }
 
 

 
 

  
  }
 
 

 
 


 
 

 
 

  
  void 
  
  linearSmooth5 
  
  ( 
  
  double 
  
  in
  
  [], 
  
  double 
  
  out
  
  [], 
  
  int 
  
  N 
  
  )
 
 

 
 

  
  {
 
 

 
 
    
  
  int 
  
  i
  
  ;
 
 

 
 
    
  
  if 
  
  ( 
  
  N 
  
  < 
  
  5 
  
  )
 
 

 
 
    
  
  {
 
 

 
 
        
  
  for 
  
  ( 
  
  i 
  
  = 
  
  0
  
  ; 
  
  i 
  
  <= 
  
  N 
  
  - 
  
  1
  
  ; 
  
  i
  
  ++ 
  
  )
 
 

 
 
        
  
  {
 
 

 
 
            
  
  out
  
  [
  
  i
  
  ] 
  
  = 
  
  in
  
  [
  
  i
  
  ];
 
 

 
 
        
  
  }
 
 

 
 
    
  
  }
 
 

 
 
    
  
  else
 
 

 
 
    
  
  {
 
 

 
 
        
  
  out
  
  [
  
  0
  
  ] 
  
  = 
  
  ( 
  
  3.0 
  
  * 
  
  in
  
  [
  
  0
  
  ] 
  
  + 
  
  2.0 
  
  * 
  
  in
  
  [
  
  1
  
  ] 
  
  + 
  
  in
  
  [
  
  2
  
  ] 
  
  - 
  
  in
  
  [
  
  4
  
  ] 
  
  ) 
  
  / 
  
  5.0
  
  ;
 
 

 
 
        
  
  out
  
  [
  
  1
  
  ] 
  
  = 
  
  ( 
  
  4.0 
  
  * 
  
  in
  
  [
  
  0
  
  ] 
  
  + 
  
  3.0 
  
  * 
  
  in
  
  [
  
  1
  
  ] 
  
  + 
  
  2 
  
  * 
  
  in
  
  [
  
  2
  
  ] 
  
  + 
  
  in
  
  [
  
  3
  
  ] 
  
  ) 
  
  / 
  
  10.0
  
  ;
 
 

 
 
        
  
  for 
  
  ( 
  
  i 
  
  = 
  
  2
  
  ; 
  
  i 
  
  <= 
  
  N 
  
  - 
  
  3
  
  ; 
  
  i
  
  ++ 
  
  )
 
 

 
 
        
  
  {
 
 

 
 
            
  
  out
  
  [
  
  i
  
  ] 
  
  = 
  
  ( 
  
  in
  
  [
  
  i 
  
  - 
  
  2
  
  ] 
  
  + 
  
  in
  
  [
  
  i 
  
  - 
  
  1
  
  ] 
  
  + 
  
  in
  
  [
  
  i
  
  ] 
  
  + 
  
  in
  
  [
  
  i 
  
  + 
  
  1
  
  ] 
  
  + 
  
  in
  
  [
  
  i 
  
  + 
  
  2
  
  ] 
  
  ) 
  
  / 
  
  5.0
  
  ;
 
 

 
 
        
  
  }
 
 

 
 
        
  
  out
  
  [
  
  N 
  
  - 
  
  2
  
  ] 
  
  = 
  
  ( 
  
  4.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  1
  
  ] 
  
  + 
  
  3.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  2
  
  ] 
  
  + 
  
  2 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  3
  
  ] 
  
  + 
  
  in
  
  [
  
  N 
  
  - 
  
  4
  
  ] 
  
  ) 
  
  / 
  
  10.0
  
  ;
 
 

 
 
        
  
  out
  
  [
  
  N 
  
  - 
  
  1
  
  ] 
  
  = 
  
  ( 
  
  3.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  1
  
  ] 
  
  + 
  
  2.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  2
  
  ] 
  
  + 
  
  in
  
  [
  
  N 
  
  - 
  
  3
  
  ] 
  
  - 
  
  in
  
  [
  
  N 
  
  - 
  
  5
  
  ] 
  
  ) 
  
  / 
  
  5.0
  
  ;
 
 

 
 
    
  
  }
 
 

 
 

  
  }
 
 

 
 


 
 

 
 

  
  void 
  
  linearSmooth7 
  
  ( 
  
  double 
  
  in
  
  [], 
  
  double 
  
  out
  
  [], 
  
  int 
  
  N 
  
  )
 
 

 
 

  
  {
 
 

 
 
    
  
  int 
  
  i
  
  ;
 
 

 
 
    
  
  if 
  
  ( 
  
  N 
  
  < 
  
  7 
  
  )
 
 

 
 
    
  
  {
 
 

 
 
        
  
  for 
  
  ( 
  
  i 
  
  = 
  
  0
  
  ; 
  
  i 
  
  <= 
  
  N 
  
  - 
  
  1
  
  ; 
  
  i
  
  ++ 
  
  )
 
 

 
 
        
  
  {
 
 

 
 
            
  
  out
  
  [
  
  i
  
  ] 
  
  = 
  
  in
  
  [
  
  i
  
  ];
 
 

 
 
        
  
  }
 
 

 
 
    
  
  }
 
 

 
 
    
  
  else
 
 

 
 
    
  
  {
 
 

 
 
        
  
  out
  
  [
  
  0
  
  ] 
  
  = 
  
  ( 
  
  13.0 
  
  * 
  
  in
  
  [
  
  0
  
  ] 
  
  + 
  
  10.0 
  
  * 
  
  in
  
  [
  
  1
  
  ] 
  
  + 
  
  7.0 
  
  * 
  
  in
  
  [
  
  2
  
  ] 
  
  + 
  
  4.0 
  
  * 
  
  in
  
  [
  
  3
  
  ] 
  
  +
 
 

 
 
                  
  
  in
  
  [
  
  4
  
  ] 
  
  - 
  
  2.0 
  
  * 
  
  in
  
  [
  
  5
  
  ] 
  
  - 
  
  5.0 
  
  * 
  
  in
  
  [
  
  6
  
  ] 
  
  ) 
  
  / 
  
  28.0
  
  ;
 
 

 
 


 
 

 
 
        
  
  out
  
  [
  
  1
  
  ] 
  
  = 
  
  ( 
  
  5.0 
  
  * 
  
  in
  
  [
  
  0
  
  ] 
  
  + 
  
  4.0 
  
  * 
  
  in
  
  [
  
  1
  
  ] 
  
  + 
  
  3 
  
  * 
  
  in
  
  [
  
  2
  
  ] 
  
  + 
  
  2 
  
  * 
  
  in
  
  [
  
  3
  
  ] 
  
  +
 
 

 
 
                  
  
  in
  
  [
  
  4
  
  ] 
  
  - 
  
  in
  
  [
  
  6
  
  ] 
  
  ) 
  
  / 
  
  14.0
  
  ;
 
 

 
 


 
 

 
 
        
  
  out
  
  [
  
  2
  
  ] 
  
  = 
  
  ( 
  
  7.0 
  
  * 
  
  in
  
  [
  
  0
  
  ] 
  
  + 
  
  6.0 
  
  * 
  
  in 
  
  [
  
  1
  
  ] 
  
  + 
  
  5.0 
  
  * 
  
  in
  
  [
  
  2
  
  ] 
  
  + 
  
  4.0 
  
  * 
  
  in
  
  [
  
  3
  
  ] 
  
  +
 
 

 
 
                  
  
  3.0 
  
  * 
  
  in
  
  [
  
  4
  
  ] 
  
  + 
  
  2.0 
  
  * 
  
  in
  
  [
  
  5
  
  ] 
  
  + 
  
  in
  
  [
  
  6
  
  ] 
  
  ) 
  
  / 
  
  28.0
  
  ;
 
 

 
 


 
 

 
 
        
  
  for 
  
  ( 
  
  i 
  
  = 
  
  3
  
  ; 
  
  i 
  
  <= 
  
  N 
  
  - 
  
  4
  
  ; 
  
  i
  
  ++ 
  
  )
 
 

 
 
        
  
  {
 
 

 
 
            
  
  out
  
  [
  
  i
  
  ] 
  
  = 
  
  ( 
  
  in
  
  [
  
  i 
  
  - 
  
  3
  
  ] 
  
  + 
  
  in
  
  [
  
  i 
  
  - 
  
  2
  
  ] 
  
  + 
  
  in
  
  [
  
  i 
  
  - 
  
  1
  
  ] 
  
  + 
  
  in
  
  [
  
  i
  
  ] 
  
  + 
  
  in
  
  [
  
  i 
  
  + 
  
  1
  
  ] 
  
  + 
  
  in
  
  [
  
  i 
  
  + 
  
  2
  
  ] 
  
  + 
  
  in
  
  [
  
  i 
  
  + 
  
  3
  
  ] 
  
  ) 
  
  / 
  
  7.0
  
  ;
 
 

 
 
        
  
  }
 
 

 
 


 
 

 
 
        
  
  out
  
  [
  
  N 
  
  - 
  
  3
  
  ] 
  
  = 
  
  ( 
  
  7.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  1
  
  ] 
  
  + 
  
  6.0 
  
  * 
  
  in 
  
  [
  
  N 
  
  - 
  
  2
  
  ] 
  
  + 
  
  5.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  3
  
  ] 
  
  +
 
 

 
 
                      
  
  4.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  4
  
  ] 
  
  + 
  
  3.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  5
  
  ] 
  
  + 
  
  2.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  6
  
  ] 
  
  + 
  
  in
  
  [
  
  N 
  
  - 
  
  7
  
  ] 
  
  ) 
  
  / 
  
  28.0
  
  ;
 
 

 
 


 
 

 
 
        
  
  out
  
  [
  
  N 
  
  - 
  
  2
  
  ] 
  
  = 
  
  ( 
  
  5.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  1
  
  ] 
  
  + 
  
  4.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  2
  
  ] 
  
  + 
  
  3.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  3
  
  ] 
  
  +
 
 

 
 
                      
  
  2.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  4
  
  ] 
  
  + 
  
  in
  
  [
  
  N 
  
  - 
  
  5
  
  ] 
  
  - 
  
  in
  
  [
  
  N 
  
  - 
  
  7
  
  ] 
  
  ) 
  
  / 
  
  14.0
  
  ;
 
 

 
 


 
 

 
 
        
  
  out
  
  [
  
  N 
  
  - 
  
  1
  
  ] 
  
  = 
  
  ( 
  
  13.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  1
  
  ] 
  
  + 
  
  10.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  2
  
  ] 
  
  + 
  
  7.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  3
  
  ] 
  
  +
 
 

 
 
                      
  
  4 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  4
  
  ] 
  
  + 
  
  in
  
  [
  
  N 
  
  - 
  
  5
  
  ] 
  
  - 
  
  2 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  6
  
  ] 
  
  - 
  
  5 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  7
  
  ] 
  
  ) 
  
  / 
  
  28.0
  
  ;
 
 

 
 
    
  
  }
 
 

 
 

  
  }

然后是利用二次函数拟合平滑。

 
 

  
  void 
  
  quadraticSmooth5
  
  (
  
  double 
  
  in
  
  [], 
  
  double 
  
  out
  
  [], 
  
  int 
  
  N
  
  )
 
 

 
 

  
  {
 
 

 
 
    
  
  int 
  
  i
  
  ;
 
 

 
 
    
  
  if 
  
  ( 
  
  N 
  
  < 
  
  5 
  
  )
 
 

 
 
    
  
  {
 
 

 
 
        
  
  for 
  
  ( 
  
  i 
  
  = 
  
  0
  
  ; 
  
  i 
  
  <= 
  
  N 
  
  - 
  
  1
  
  ; 
  
  i
  
  ++ 
  
  )
 
 

 
 
        
  
  {
 
 

 
 
            
  
  out
  
  [
  
  i
  
  ] 
  
  = 
  
  in
  
  [
  
  i
  
  ];
 
 

 
 
        
  
  }
 
 

 
 
    
  
  }
 
 

 
 
    
  
  else
 
 

 
 
    
  
  {
 
 

 
 
        
  
  out
  
  [
  
  0
  
  ] 
  
  = 
  
  ( 
  
  31.0 
  
  * 
  
  in
  
  [
  
  0
  
  ] 
  
  + 
  
  9.0 
  
  * 
  
  in
  
  [
  
  1
  
  ] 
  
  - 
  
  3.0 
  
  * 
  
  in
  
  [
  
  2
  
  ] 
  
  - 
  
  5.0 
  
  * 
  
  in
  
  [
  
  3
  
  ] 
  
  + 
  
  3.0 
  
  * 
  
  in
  
  [
  
  4
  
  ] 
  
  ) 
  
  / 
  
  35.0
  
  ;
 
 

 
 
        
  
  out
  
  [
  
  1
  
  ] 
  
  = 
  
  ( 
  
  9.0 
  
  * 
  
  in
  
  [
  
  0
  
  ] 
  
  + 
  
  13.0 
  
  * 
  
  in
  
  [
  
  1
  
  ] 
  
  + 
  
  12 
  
  * 
  
  in
  
  [
  
  2
  
  ] 
  
  + 
  
  6.0 
  
  * 
  
  in
  
  [
  
  3
  
  ] 
  
  - 
  
  5.0 
  
  *
  
  in
  
  [
  
  4
  
  ]) 
  
  / 
  
  35.0
  
  ;
 
 

 
 
        
  
  for 
  
  ( 
  
  i 
  
  = 
  
  2
  
  ; 
  
  i 
  
  <= 
  
  N 
  
  - 
  
  3
  
  ; 
  
  i
  
  ++ 
  
  )
 
 

 
 
        
  
  {
 
 

 
 
            
  
  out
  
  [
  
  i
  
  ] 
  
  = 
  
  ( 
  
  - 
  
  3.0 
  
  * 
  
  (
  
  in
  
  [
  
  i 
  
  - 
  
  2
  
  ] 
  
  + 
  
  in
  
  [
  
  i 
  
  + 
  
  2
  
  ]) 
  
  +
 
 

 
 
                      
  
  12.0 
  
  * 
  
  (
  
  in
  
  [
  
  i 
  
  - 
  
  1
  
  ] 
  
  + 
  
  in
  
  [
  
  i 
  
  + 
  
  1
  
  ]) 
  
  + 
  
  17 
  
  * 
  
  in
  
  [
  
  i
  
  ] 
  
  ) 
  
  / 
  
  35.0
  
  ;
 
 

 
 
        
  
  }
 
 

 
 
        
  
  out
  
  [
  
  N 
  
  - 
  
  2
  
  ] 
  
  = 
  
  ( 
  
  9.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  1
  
  ] 
  
  + 
  
  13.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  2
  
  ] 
  
  + 
  
  12.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  3
  
  ] 
  
  + 
  
  6.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  4
  
  ] 
  
  - 
  
  5.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  5
  
  ] 
  
  ) 
  
  / 
  
  35.0
  
  ;
 
 

 
 
        
  
  out
  
  [
  
  N 
  
  - 
  
  1
  
  ] 
  
  = 
  
  ( 
  
  31.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  1
  
  ] 
  
  + 
  
  9.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  2
  
  ] 
  
  - 
  
  3.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  3
  
  ] 
  
  - 
  
  5.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  4
  
  ] 
  
  + 
  
  3.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  5
  
  ]) 
  
  / 
  
  35.0
  
  ;
 
 

 
 
    
  
  }
 
 

 
 

  
  }
 
 

 
 


 
 

 
 


 
 

 
 

  
  void 
  
  quadraticSmooth7
  
  (
  
  double 
  
  in
  
  [], 
  
  double 
  
  out
  
  [], 
  
  int 
  
  N
  
  )
 
 

 
 

  
  {
 
 

 
 
    
  
  int 
  
  i
  
  ;
 
 

 
 
    
  
  if 
  
  ( 
  
  N 
  
  < 
  
  7 
  
  )
 
 

 
 
    
  
  {
 
 

 
 
        
  
  for 
  
  ( 
  
  i 
  
  = 
  
  0
  
  ; 
  
  i 
  
  <= 
  
  N 
  
  - 
  
  1
  
  ; 
  
  i
  
  ++ 
  
  )
 
 

 
 
        
  
  {
 
 

 
 
            
  
  out
  
  [
  
  i
  
  ] 
  
  = 
  
  in
  
  [
  
  i
  
  ];
 
 

 
 
        
  
  }
 
 

 
 
    
  
  }
 
 

 
 
    
  
  else
 
 

 
 
    
  
  {
 
 

 
 
        
  
  out
  
  [
  
  0
  
  ] 
  
  = 
  
  ( 
  
  32.0 
  
  * 
  
  in
  
  [
  
  0
  
  ] 
  
  + 
  
  15.0 
  
  * 
  
  in
  
  [
  
  1
  
  ] 
  
  + 
  
  3.0 
  
  * 
  
  in
  
  [
  
  2
  
  ] 
  
  - 
  
  4.0 
  
  * 
  
  in
  
  [
  
  3
  
  ] 
  
  -
 
 

 
 
                  
  
  6.0 
  
  * 
  
  in
  
  [
  
  4
  
  ] 
  
  - 
  
  3.0 
  
  * 
  
  in
  
  [
  
  5
  
  ] 
  
  + 
  
  5.0 
  
  * 
  
  in
  
  [
  
  6
  
  ] 
  
  ) 
  
  / 
  
  42.0
  
  ;
 
 

 
 


 
 

 
 
        
  
  out
  
  [
  
  1
  
  ] 
  
  = 
  
  ( 
  
  5.0 
  
  * 
  
  in
  
  [
  
  0
  
  ] 
  
  + 
  
  4.0 
  
  * 
  
  in
  
  [
  
  1
  
  ] 
  
  + 
  
  3.0 
  
  * 
  
  in
  
  [
  
  2
  
  ] 
  
  + 
  
  2.0 
  
  * 
  
  in
  
  [
  
  3
  
  ] 
  
  +
 
 

 
 
                  
  
  in
  
  [
  
  4
  
  ] 
  
  - 
  
  in
  
  [
  
  6
  
  ] 
  
  ) 
  
  / 
  
  14.0
  
  ;
 
 

 
 


 
 

 
 
        
  
  out
  
  [
  
  2
  
  ] 
  
  = 
  
  ( 
  
  1.0 
  
  * 
  
  in
  
  [
  
  0
  
  ] 
  
  + 
  
  3.0 
  
  * 
  
  in 
  
  [
  
  1
  
  ] 
  
  + 
  
  4.0 
  
  * 
  
  in
  
  [
  
  2
  
  ] 
  
  + 
  
  4.0 
  
  * 
  
  in
  
  [
  
  3
  
  ] 
  
  +
 
 

 
 
                  
  
  3.0 
  
  * 
  
  in
  
  [
  
  4
  
  ] 
  
  + 
  
  1.0 
  
  * 
  
  in
  
  [
  
  5
  
  ] 
  
  - 
  
  2.0 
  
  * 
  
  in
  
  [
  
  6
  
  ] 
  
  ) 
  
  / 
  
  14.0
  
  ;
 
 

 
 
        
  
  for 
  
  ( 
  
  i 
  
  = 
  
  3
  
  ; 
  
  i 
  
  <= 
  
  N 
  
  - 
  
  4
  
  ; 
  
  i
  
  ++ 
  
  )
 
 

 
 
        
  
  {
 
 

 
 
            
  
  out
  
  [
  
  i
  
  ] 
  
  = 
  
  ( 
  
  -
  
  2.0 
  
  * 
  
  (
  
  in
  
  [
  
  i 
  
  - 
  
  3
  
  ] 
  
  + 
  
  in
  
  [
  
  i 
  
  + 
  
  3
  
  ]) 
  
  +
 
 

 
 
                       
  
  3.0 
  
  * 
  
  (
  
  in
  
  [
  
  i 
  
  - 
  
  2
  
  ] 
  
  + 
  
  in
  
  [
  
  i 
  
  + 
  
  2
  
  ]) 
  
  +
 
 

 
 
                      
  
  6.0 
  
  * 
  
  (
  
  in
  
  [
  
  i 
  
  - 
  
  1
  
  ] 
  
  + 
  
  in
  
  [
  
  i 
  
  + 
  
  1
  
  ]) 
  
  + 
  
  7.0 
  
  * 
  
  in
  
  [
  
  i
  
  ] 
  
  ) 
  
  / 
  
  21.0
  
  ;
 
 

 
 
        
  
  }
 
 

 
 
        
  
  out
  
  [
  
  N 
  
  - 
  
  3
  
  ] 
  
  = 
  
  ( 
  
  1.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  1
  
  ] 
  
  + 
  
  3.0 
  
  * 
  
  in 
  
  [
  
  N 
  
  - 
  
  2
  
  ] 
  
  + 
  
  4.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  3
  
  ] 
  
  +
 
 

 
 
                      
  
  4.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  4
  
  ] 
  
  + 
  
  3.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  5
  
  ] 
  
  + 
  
  1.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  6
  
  ] 
  
  - 
  
  2.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  7
  
  ] 
  
  ) 
  
  / 
  
  14.0
  
  ;
 
 

 
 


 
 

 
 
        
  
  out
  
  [
  
  N 
  
  - 
  
  2
  
  ] 
  
  = 
  
  ( 
  
  5.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  1
  
  ] 
  
  + 
  
  4.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  2
  
  ] 
  
  + 
  
  3.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  3
  
  ] 
  
  +
 
 

 
 
                      
  
  2.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  4
  
  ] 
  
  + 
  
  in
  
  [
  
  N 
  
  - 
  
  5
  
  ] 
  
  - 
  
  in
  
  [
  
  N 
  
  - 
  
  7
  
  ] 
  
  ) 
  
  / 
  
  14.0
  
  ;
 
 

 
 


 
 

 
 
        
  
  out
  
  [
  
  N 
  
  - 
  
  1
  
  ] 
  
  = 
  
  ( 
  
  32.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  1
  
  ] 
  
  + 
  
  15.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  2
  
  ] 
  
  + 
  
  3.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  3
  
  ] 
  
  -
 
 

 
 
                      
  
  4.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  4
  
  ] 
  
  - 
  
  6.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  5
  
  ] 
  
  - 
  
  3.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  6
  
  ] 
  
  + 
  
  5.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  7
  
  ] 
  
  ) 
  
  / 
  
  42.0
  
  ;
 
 

 
 
    
  
  }
 
 

 
 

  
  }
最后是三次函数拟合平滑。 

 
 

  
  /**
 
 

 
 

  
   * 五点三次平滑
 
 

 
 

  
   *
 
 

 
 

  
   */
 
 

 
 

  
  void 
  
  cubicSmooth5 
  
  ( 
  
  double 
  
  in
  
  [], 
  
  double 
  
  out
  
  [], 
  
  int 
  
  N 
  
  )
 
 

 
 

  
  {
 
 

 
 


 
 

 
 
    
  
  int 
  
  i
  
  ;
 
 

 
 
    
  
  if 
  
  ( 
  
  N 
  
  < 
  
  5 
  
  )
 
 

 
 
    
  
  {
 
 

 
 
        
  
  for 
  
  ( 
  
  i 
  
  = 
  
  0
  
  ; 
  
  i 
  
  <= 
  
  N 
  
  - 
  
  1
  
  ; 
  
  i
  
  ++ 
  
  )
 
 

 
 
            
  
  out
  
  [
  
  i
  
  ] 
  
  = 
  
  in
  
  [
  
  i
  
  ];
 
 

 
 
    
  
  }
 
 

 
 


 
 

 
 
    
  
  else
 
 

 
 
    
  
  {
 
 

 
 
        
  
  out
  
  [
  
  0
  
  ] 
  
  = 
  
  (
  
  69.0 
  
  * 
  
  in
  
  [
  
  0
  
  ] 
  
  + 
  
  4.0 
  
  * 
  
  in
  
  [
  
  1
  
  ] 
  
  - 
  
  6.0 
  
  * 
  
  in
  
  [
  
  2
  
  ] 
  
  + 
  
  4.0 
  
  * 
  
  in
  
  [
  
  3
  
  ] 
  
  - 
  
  in
  
  [
  
  4
  
  ]) 
  
  / 
  
  70.0
  
  ;
 
 

 
 
        
  
  out
  
  [
  
  1
  
  ] 
  
  = 
  
  (
  
  2.0 
  
  * 
  
  in
  
  [
  
  0
  
  ] 
  
  + 
  
  27.0 
  
  * 
  
  in
  
  [
  
  1
  
  ] 
  
  + 
  
  12.0 
  
  * 
  
  in
  
  [
  
  2
  
  ] 
  
  - 
  
  8.0 
  
  * 
  
  in
  
  [
  
  3
  
  ] 
  
  + 
  
  2.0 
  
  * 
  
  in
  
  [
  
  4
  
  ]) 
  
  / 
  
  35.0
  
  ;
 
 

 
 
        
  
  for 
  
  ( 
  
  i 
  
  = 
  
  2
  
  ; 
  
  i 
  
  <= 
  
  N 
  
  - 
  
  3
  
  ; 
  
  i
  
  ++ 
  
  )
 
 

 
 
        
  
  {
 
 

 
 
            
  
  out
  
  [
  
  i
  
  ] 
  
  = 
  
  (
  
  -
  
  3.0 
  
  * 
  
  (
  
  in
  
  [
  
  i 
  
  - 
  
  2
  
  ] 
  
  + 
  
  in
  
  [
  
  i 
  
  + 
  
  2
  
  ])
  
  + 
  
  12.0 
  
  * 
  
  (
  
  in
  
  [
  
  i 
  
  - 
  
  1
  
  ] 
  
  + 
  
  in
  
  [
  
  i 
  
  + 
  
  1
  
  ]) 
  
  + 
  
  17.0 
  
  * 
  
  in
  
  [
  
  i
  
  ] 
  
  ) 
  
  / 
  
  35.0
  
  ;
 
 

 
 
        
  
  }
 
 

 
 
        
  
  out
  
  [
  
  N 
  
  - 
  
  2
  
  ] 
  
  = 
  
  (
  
  2.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  5
  
  ] 
  
  - 
  
  8.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  4
  
  ] 
  
  + 
  
  12.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  3
  
  ] 
  
  + 
  
  27.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  2
  
  ] 
  
  + 
  
  2.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  1
  
  ]) 
  
  / 
  
  35.0
  
  ;
 
 

 
 
        
  
  out
  
  [
  
  N 
  
  - 
  
  1
  
  ] 
  
  = 
  
  (
  
  - 
  
  in
  
  [
  
  N 
  
  - 
  
  5
  
  ] 
  
  + 
  
  4.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  4
  
  ] 
  
  - 
  
  6.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  3
  
  ] 
  
  + 
  
  4.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  2
  
  ] 
  
  + 
  
  69.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  1
  
  ]) 
  
  / 
  
  70.0
  
  ;
 
 

 
 
    
  
  }
 
 

 
 
    
  
  return
  
  ;
 
 

 
 

  
  }
 
 

 
 


 
 

 
 

  
  void 
  
  cubicSmooth7
  
  (
  
  double 
  
  in
  
  [], 
  
  double 
  
  out
  
  [], 
  
  int 
  
  N
  
  )
 
 

 
 

  
  {
 
 

 
 
    
  
  int 
  
  i
  
  ;
 
 

 
 
    
  
  if 
  
  ( 
  
  N 
  
  < 
  
  7 
  
  )
 
 

 
 
    
  
  {
 
 

 
 
        
  
  for 
  
  ( 
  
  i 
  
  = 
  
  0
  
  ; 
  
  i 
  
  <= 
  
  N 
  
  - 
  
  1
  
  ; 
  
  i
  
  ++ 
  
  )
 
 

 
 
        
  
  {
 
 

 
 
            
  
  out
  
  [
  
  i
  
  ] 
  
  = 
  
  in
  
  [
  
  i
  
  ];
 
 

 
 
        
  
  }
 
 

 
 
    
  
  }
 
 

 
 
    
  
  else
 
 

 
 
    
  
  {
 
 

 
 
        
  
  out
  
  [
  
  0
  
  ] 
  
  = 
  
  ( 
  
  39.0 
  
  * 
  
  in
  
  [
  
  0
  
  ] 
  
  + 
  
  8.0 
  
  * 
  
  in
  
  [
  
  1
  
  ] 
  
  - 
  
  4.0 
  
  * 
  
  in
  
  [
  
  2
  
  ] 
  
  - 
  
  4.0 
  
  * 
  
  in
  
  [
  
  3
  
  ] 
  
  +
 
 

 
 
                  
  
  1.0 
  
  * 
  
  in
  
  [
  
  4
  
  ] 
  
  + 
  
  4.0 
  
  * 
  
  in
  
  [
  
  5
  
  ] 
  
  - 
  
  2.0 
  
  * 
  
  in
  
  [
  
  6
  
  ] 
  
  ) 
  
  / 
  
  42.0
  
  ;
 
 

 
 
        
  
  out
  
  [
  
  1
  
  ] 
  
  = 
  
  ( 
  
  8.0 
  
  * 
  
  in
  
  [
  
  0
  
  ] 
  
  + 
  
  19.0 
  
  * 
  
  in
  
  [
  
  1
  
  ] 
  
  + 
  
  16.0 
  
  * 
  
  in
  
  [
  
  2
  
  ] 
  
  + 
  
  6.0 
  
  * 
  
  in
  
  [
  
  3
  
  ] 
  
  -
 
 

 
 
                  
  
  4.0 
  
  * 
  
  in
  
  [
  
  4
  
  ] 
  
  - 
  
  7.0
  
  * 
  
  in
  
  [
  
  5
  
  ] 
  
  + 
  
  4.0 
  
  * 
  
  in
  
  [
  
  6
  
  ] 
  
  ) 
  
  / 
  
  42.0
  
  ;
 
 

 
 
        
  
  out
  
  [
  
  2
  
  ] 
  
  = 
  
  ( 
  
  -
  
  4.0 
  
  * 
  
  in
  
  [
  
  0
  
  ] 
  
  + 
  
  16.0 
  
  * 
  
  in 
  
  [
  
  1
  
  ] 
  
  + 
  
  19.0 
  
  * 
  
  in
  
  [
  
  2
  
  ] 
  
  + 
  
  12.0 
  
  * 
  
  in
  
  [
  
  3
  
  ] 
  
  +
 
 

 
 
                  
  
  2.0 
  
  * 
  
  in
  
  [
  
  4
  
  ] 
  
  - 
  
  4.0 
  
  * 
  
  in
  
  [
  
  5
  
  ] 
  
  + 
  
  1.0 
  
  * 
  
  in
  
  [
  
  6
  
  ] 
  
  ) 
  
  / 
  
  42.0
  
  ;
 
 

 
 
        
  
  for 
  
  ( 
  
  i 
  
  = 
  
  3
  
  ; 
  
  i 
  
  <= 
  
  N 
  
  - 
  
  4
  
  ; 
  
  i
  
  ++ 
  
  )
 
 

 
 
        
  
  {
 
 

 
 
            
  
  out
  
  [
  
  i
  
  ] 
  
  = 
  
  ( 
  
  -
  
  2.0 
  
  * 
  
  (
  
  in
  
  [
  
  i 
  
  - 
  
  3
  
  ] 
  
  + 
  
  in
  
  [
  
  i 
  
  + 
  
  3
  
  ]) 
  
  +
 
 

 
 
                       
  
  3.0 
  
  * 
  
  (
  
  in
  
  [
  
  i 
  
  - 
  
  2
  
  ] 
  
  + 
  
  in
  
  [
  
  i 
  
  + 
  
  2
  
  ]) 
  
  +
 
 

 
 
                      
  
  6.0 
  
  * 
  
  (
  
  in
  
  [
  
  i 
  
  - 
  
  1
  
  ] 
  
  + 
  
  in
  
  [
  
  i 
  
  + 
  
  1
  
  ]) 
  
  + 
  
  7.0 
  
  * 
  
  in
  
  [
  
  i
  
  ] 
  
  ) 
  
  / 
  
  21.0
  
  ;
 
 

 
 
        
  
  }
 
 

 
 
        
  
  out
  
  [
  
  N 
  
  - 
  
  3
  
  ] 
  
  = 
  
  ( 
  
  -
  
  4.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  1
  
  ] 
  
  + 
  
  16.0 
  
  * 
  
  in 
  
  [
  
  N 
  
  - 
  
  2
  
  ] 
  
  + 
  
  19.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  3
  
  ] 
  
  +
 
 

 
 
                      
  
  12.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  4
  
  ] 
  
  + 
  
  2.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  5
  
  ] 
  
  - 
  
  4.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  6
  
  ] 
  
  + 
  
  1.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  7
  
  ] 
  
  ) 
  
  / 
  
  42.0
  
  ;
 
 

 
 
        
  
  out
  
  [
  
  N 
  
  - 
  
  2
  
  ] 
  
  = 
  
  ( 
  
  8.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  1
  
  ] 
  
  + 
  
  19.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  2
  
  ] 
  
  + 
  
  16.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  3
  
  ] 
  
  +
 
 

 
 
                      
  
  6.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  4
  
  ] 
  
  - 
  
  4.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  5
  
  ] 
  
  - 
  
  7.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  6
  
  ] 
  
  + 
  
  4.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  7
  
  ] 
  
  ) 
  
  / 
  
  42.0
  
  ;
 
 

 
 
        
  
  out
  
  [
  
  N 
  
  - 
  
  1
  
  ] 
  
  = 
  
  ( 
  
  39.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  1
  
  ] 
  
  + 
  
  8.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  2
  
  ] 
  
  - 
  
  4.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  3
  
  ] 
  
  -
 
 

 
 
                      
  
  4.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  4
  
  ] 
  
  + 
  
  1.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  5
  
  ] 
  
  + 
  
  4.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  6
  
  ] 
  
  - 
  
  2.0 
  
  * 
  
  in
  
  [
  
  N 
  
  - 
  
  7
  
  ] 
  
  ) 
  
  / 
  
  42.0
  
  ;
 
 

 
 
    
  
  }
 
 

 
 

  
  }

Matlab代码

加高斯白噪

function [Y,NOISE] = noisegen(X,SNR)
% noisegen add white Gaussian noise to a signal.
% [Y, NOISE] = NOISEGEN(X,SNR) adds white Gaussian NOISE to X. The SNR is in dB.
%X是纯信号，SNR是要求的信噪比，Y是带噪信号，NOISE是叠加在信号上的噪声。
NOISE=randn(size(X));
NOISE=NOISE-mean(NOISE);
signal_power = 1/length(X)*sum(X.*X);
noise_variance = signal_power / ( 10^(SNR/10) );
NOISE=sqrt(noise_variance)/std(NOISE)*NOISE;
Y=X+NOISE;

五点三次平滑滤波

function y = smooth5_3(x, m)
% x为需要的数据
% m 为平滑次数
n=length(x);
a=x;
for k=1: m
b(1) = (69*a(1) +4*(a(2) +a(4)) -6*a(3) -a(5)) /70;
b(2) = (2* (a(1) +a(5)) +27*a(2) +12*a(3) -8*a(4)) /35;
for j=3:n-2
b (j) = (-3*(a(j-2) +a(j+2)) +12*(a(j-1) +a(j+1)) +17*a(j)) /35;
end
b (n-1) = (2*(a(n) +a(n-4)) +27*a(n-1) +12*a(n-2) -8*a(n-3)) /35;
b (n) = (69*a(n) +4* (a(n-1) +a(n-3)) -6*a(n-2) -a(n-4)) /70;
a=b;
end
y =a;



linlindie
关注
专栏目录
matlab 五点三次平滑算法
点云侠的博客
10-18 5885
五点三次平滑算法及matlab代码实现
五点三次平滑滤波C语言程序
10-06
五点三次平滑滤波程序，可以滤掉波形的坏点，使波形平滑！
信号平滑或移动平均滤波研究（Matlab代码实现）
最新发布
weixin_46039719的博客
07-16 973
信号平滑或移动平均滤波是一种常用的信号处理技术，用于去除信号中的噪声或波动，使信号变得更加平滑和稳定。移动平均滤波的基本原理是将信号中的每个数据点与其前后若干个数据点的平均值进行比较，然后用该平均值替代该数据点。这样可以有效地平滑信号，并减小噪声的影响。常见的移动平均滤波方法包括简单移动平均、加权移动平均和指数移动平均等。简单移动平均是最基本的移动平均滤波方法，它将信号中每个数据点与其前后一定数量的数据点的平均值进行比较。
五点三次平滑滤波
热门推荐
wdlhgd的博客
05-05 1万+
算法简介 五点三次平滑滤波能够有效去除信号中的高频随机噪声，在数字信号处理中有着广泛应用，且滤波效果和灵活性优于滑动平均滤波。五点三次平滑滤波效果如下图所示： 完整代码（java） //函数参数说明：a为一维输入信号， m为五点三次平滑的阶数，阶数越高，滤波后的信号越平滑但耗时也更长。 float[] Mean5_3(float[] a, int m) { float[] b = new...
五点三次平滑算法
06-19
这里提供一个函数mean5_3(五点三次平滑算法)对数据进行平滑处理
五点三次平滑滤波（可用于波动曲线的去毛刺，分析走向趋势）
06-30
五点三次平滑算法属于平滑滤波算法的一种，在平滑滤波算法中，常用的有: 样条差值函数平滑法、平均计算平滑法和五点三次平滑法。样条差值函数平滑法采用样条插值的方式来逼近采样点，以此实现平滑，算法灵活多变，效果较好，但该方法计算过程相对复杂，在平滑幅度方面表现较差; 平均计算平滑法虽然相对简单，但滤波的效果并不好; 五点三次平滑法实现平滑滤波的原理是利用多项式最小二乘法来逼近采样点，算法十分简单，滤波效果也较好。 M文件由掌柜本人编写，保证运行。
共享一个实用的一维信号平滑滤波方法五点三次平滑滤波-x.dat
08-13
共享一个实用的一维信号平滑滤波方法五点三次平滑滤波-x.dat test.jpg 各种循环次数下的结果图 clear all close all clc V1 = rand*700 200; subplot 231; plot; ylim; grid;...
共享一个实用的一维信号平滑滤波方法五点三次平滑滤波-figure_plot.m
08-13
共享一个实用的一维信号平滑滤波方法五点三次平滑滤波-figure_plot.m test.jpg 各种循环次数下的结果图 clear all close all clc V1 = rand*700 200; subplot 231; plot; ...
基于matlab实现振动信号预处理，主要为五点三次平滑法和平均法.rar
05-05
本项目是使用MATLAB编程语言来实现这一过程，主要涉及到的技术有五点三次平滑法和平均法。 五点三次平滑法是一种滑动窗口滤波技术，它通过三次多项式拟合来平滑数据。这种方法适用于消除短期噪声，同时保持信号的...
五点三次平滑滤波在消除随机噪声中的应用以及其Maltab程序
JunJun
05-06 4429
五点三次平滑滤波其原理是对通过采样信号使用最小二乘法的思想进行三次平滑。 采用五点三次平滑滤波对信号进行滤波，其效果如图所示： 五点三次平滑滤波的Matlab相关程序如下所示： m = 3; N = length(x1); a = x1; b = zeros(1, N); for M = 1 : m b(1) = (69 * a(1) + 4 * (a(2) + a(4)...
五次三点数据平滑算法程序C代码
05-06
用于离散数据的平滑滤波，基于VC平台的源代码。欢迎下载
信号平滑处理五点三次平均法-five_three.rar
08-12
信号平滑处理五点三次平均法-five_three.rar 信号平滑处理—五点三次平均法
Matlab信号平滑处理—五点三次平均法
03-09
自己写的M文件，进行信号平滑处理—五点三次平均法
曲线五点滑动平均分法平滑处理
06-17
曲线五点滑动平均分法平滑处理,曲线五点滑动平均分法平滑处理,
五点三次平滑_vibration_五点三次平滑_
09-29
对振动加速度信号进行五点三次平滑，以及最小二乘法消除趋势项 希望大家批评指正，指出Excel和text。
五点三次平滑+python实现
Einsam0的博客
08-17 8346
在处理工业数据的时候，工业数据有数据颗粒细，噪声大，量大，随着测量点的增加，数据维度高，复杂性高，而且关联性强，不过这个关联性是相对的，因为有时候数据噪声较大，显示不出来这种关联性。 最近了解的五点三次平滑，在一个工业数据处理平台上有这个，就很疑惑为什么要用这个，搜了很多都是matlab写的代码，没有说明为什么用这个方法，就去知网搜了几篇论文，引用这些文献的解释: “一般来说，在数据采集系统中...
37 数据平滑与预测：五点三次平滑算法与MATLAB实现
目标检测专栏持续更新中，改进YOLO系列通用，适用v5、v7、v8、所有博客均是团队原创博客，所有文章禁止转载，违者必究。
10-17 774
五点三次平滑算法，也称为五点平滑算法，是一种用于平滑时间序列数据的经典方法。它采用五个相邻数据点的加权平均值来计算平滑后的数据点。这种算法的优点在于它可以在消除噪声的同时保留数据的趋势信息。五点三次平滑算法的基本思想是，通过使用附近的数据点来估计当前数据点，以减小随机噪声的影响。这种算法的核心是使用一个三次多项式来拟合数据，以生成平滑的曲线。
matlab5点3次平滑程序,三次指数平滑法MATLAB代码
weixin_32987379的博客
03-17 1134
clear;clc;z=xlsread('PA.xlsx');x=z';p=input('ê?è??óè¨?μêy');n=length(x);s1_0=mean(x(1:3));s2_0=s1_0;s3_0=s1_0;s1(1)=p*x(1)+(1-p)*s1_0;s2(1)=p*s1(1)+(1-p)*s2_0;s3(1)=p*s2(1)+(1-p)*s3_0;for t=2:ns1(t)=p...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值