सरल मूविंग औसत एल्गोरिथम

C ++ में एक चलती औसत एल्गोरिदम को लागू करने का एक कार्य था, जो सिग्नल प्रोसेसिंग और आंकड़ों में व्यापक रूप से उपयोग किया जाता है।

आधार MATLAB में सुचारू कार्य था।
इस फ़ंक्शन का उपयोग संकेतों को फ़िल्टर करने के लिए किया जा सकता है। डेटा की एक सरणी और एक औसत विंडो को इनपुट मापदंडों के रूप में परिभाषित किया गया है।
कौन परवाह करता है, मैं कटौती के लिए कहता हूं


तो, इस एल्गोरिथ्म के कई कार्यान्वयन हैं। सबसे सरल पर विचार करें:
मान लें कि औसत विंडो का आकार 5 है, तो वर्तमान मूल्य के औसत के प्रत्येक चरण पर, पिछले 4 को जोड़ दिया जाता है और परिणाम को 5 से विभाजित किया जाता है। यहाँ स्पष्ट समस्या एल्गोरिथ्म के प्रारंभ में है, पहले आपको एक निश्चित मात्रा में डेटा संचय करने की आवश्यकता है, जो औसत विंडो से कम नहीं है।

MATLAB में, चलती औसत फ़िल्टरिंग एल्गोरिथ्म को चिकनी फ़ंक्शन में लागू किया जाता है
उदाहरण चिकनी (इनपुट, विंडो) का उपयोग कर,
जहां इनपुट इनपुट डेटा की एक सरणी है
खिड़की - औसत खिड़की।
विंडो पैरामीटर को बदलकर, आप डेटा स्मूथिंग की अधिक या कम डिग्री प्राप्त कर सकते हैं:


इस उदाहरण को लागू करने वाला स्रोत नीचे प्रस्तुत किया गया है:

clear all; %%  t=1;%   Fd=512;%   () A1=1;%   F1=10;%   () SNR=0.3;%  / T=0:1/Fd:t;%   Noise=A1*SNR*randn(1,length(T));%  Signal=A1*sind((F1*360).*T);%  SN=Signal+Noise; figure(1); subplot(4,1,1); plot(SN); subplot(4,1,2); plot(smooth(SN,3)); subplot(4,1,3); plot(smooth(SN,8)); subplot(4,1,4); plot(smooth(SN,20)); 

सिग्नल प्रोसेसिंग में देरी के लिए क्षतिपूर्ति करने के लिए, MATLAB एक गतिशील आकार बदलने योग्य विंडो का उपयोग करता है; विधि का सार निम्नलिखित उदाहरण द्वारा चित्रित किया गया है:


मैंने पहले MATLAB में इस एल्गोरिथम का अपना कार्यान्वयन लिखा था, और फिर इसे C ++ में स्थानांतरित कर दिया

MATLAB संस्करण:

 %my_smooth % ,    ,    1  ; window = 5; if(mod(window,2)==0) window=window+1; end hw=(window-1)/2; %        n=length(Signal); result=zeros(n,1); result(1)=SN(1); %      SN   for i=2:n %     init_sum = 0; if(i<=hw) %    ,     , %     k1=1; %       k2=2*i-1; %  z=k2; %   elseif (i+hw>n) % +   n -         %   k1=i-n+i; %  k2=n; %  -    z=k2-k1; %  else %     ,     k1=i-hw; k2=i+hw; z=window; end for j=k1:k2 %       init_sum=init_sum+SN(j); %   end result(i)=init_sum/(z); %      end 

इस कार्यक्रम का परिणाम पूरी तरह से विषम खिड़की के आकार में मटैलब के साथ मेल खाता है और इसके मूल्य से थोड़ा अलग है (यहां तक ​​कि खिड़कियां मटलब को थोड़ा अलग मानती हैं)
स्रोत m-file को यहां लिया जा सकता है

सी ++ संस्करण

 void smooth(double *input, double *output, int n, int window) { int i,j,z,k1,k2,hw; double tmp; if(fmod(window,2)==0) window++; hw=(window-1)/2; output[0]=input[0]; for (i=1;i<n;i++){ tmp=0; if(i<hw){ k1=0; k2=2*i; z=k2+1; } else if((i+hw)>(n-1)){ k1=i-n+i+1; k2=n-1; z=k2-k1+1; } else{ k1=i-hw; k2=i+hw; z=window; } for (j=k1;j<=k2;j++){ tmp=tmp+input[j]; } output[i]=tmp/z; } 

आपके ध्यान के लिए धन्यवाद, रचनात्मक आलोचना का स्वागत है
पुनश्च:
राशि की गणना को बदलकर एल्गोरिथ्म को गति के लिए अनुकूलित किया जा सकता है:

यह देखा जा सकता है कि 4 वें चरण में तत्वों की राशि की गणना करने के लिए, आपको तीसरे चरण में योग से सरणी के 1 तत्व (2, लाल में चिह्नित) को घटाना होगा और 6 वें तत्व (8, पीला सेल) को जोड़ना होगा।
अगले चरण में, प्रक्रिया को दोहराया जाता है।

यह दृष्टिकोण एक बड़ी औसत खिड़की के साथ प्रभावी होगा।