MFO算法优化滤波器设计——matlab

已于 2023-04-11 17:17:06 修改
阅读量167 收藏
点赞数
文章标签： matlab 算法 开发语言
于 2022-12-16 11:12:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fy_yt/article/details/128339623
版权

 从阻抗出发计算滤波器的ABCD矩阵，这里是二阶BVD模型的级联

function [ABCD_params]=count_ABCD_fun(f00,n,ccl)

N_ccl=length(ccl);
%把ccl变成三列的矩阵
C0CmLm=zeros(N_ccl/3,3);
%for kk=1:N_ccl/3
    k1=1;
    ii=1;
    for k1=1:N_ccl/3
        C0CmLm(k1,1)=ccl(ii);
        ii=ii+1;
        C0CmLm(k1,2)=ccl(ii);
        ii=ii+1;
        C0CmLm(k1,3)=ccl(ii);
        ii=ii+1;
    end
%end

    C0CmLm(:,1)=C0CmLm(:,1)*10^(-14);
    C0CmLm(:,2)=C0CmLm(:,2)*10^(-17);
    C0CmLm(:,3)=C0CmLm(:,3)*10^(-11);
    
    
% C0CmLm_10=[10^(-15),10^(-18),10^(-12);
%         10^(-15),10^(-18),10^(-12);
%         10^(-15),10^(-18),10^(-12);
%         10^(-15),10^(-18),10^(-12)];
    
%C0CmLm=C0CmLm.*C0CmLm_10;  

%计算ABCD矩阵
N=size(C0CmLm,1);% 矩阵行数

if n==0
   for i=1:N
       Z(i)=1./(1j.*f00.*C0CmLm(i,1)+1./(1j.*f00.*C0CmLm(i,3)+1./(1j.*f00.*C0CmLm(i,2))));
       if i==1
           ABCD_params=[1,Z(i);0,1];
       else
          if mod(i,2)==0   %   偶数
          ABCD_params=ABCD_params*[1,0;1/Z(i),1];
          else           
          ABCD_params=ABCD_params*[1,Z(i);0,1];    
          end 
       end
   end
else
    for i=1:N
       Z(i)=1./(1j.*f00.*C0CmLm(i,1)+1./(1j.*f00.*C0CmLm(i,2)+1./(1j.*f00.*C0CmLm(i,3))));
        if i==1
           ABCD_params=ABCD_params*[1,0;1/Z(i),1];
       else
          if mod(i,2)==0   %   偶数
          ABCD_params=ABCD_params*[1,Z(i);0,1];    
          else           
          ABCD_params=ABCD_params*[1,0;1/Z(i),1];
          end 
       end
   end
end

从kt2出发计算

function [ABCD_params]=count_ABCD_fun(f00,n,ccl)
% 固定变量kt2,Q,Rs 不定变量fs,C0
kt2=0.1;
Q=2000;
Rs=0;

% 
% Rm=pi^2/(8*2*pi*fs*C0*kt2*Q);
% Lm=pi^2/(8*(2*pi*fs)^2*C0*kt2);
% Cm=(8*C0*kt2)/(pi^2)
% Zm=Rm+1j*f00*Lm+1/(1j*f00*Cm);
% Z_R=Rs+1/(1/Zm+1j*f00*C0);

N_ccl=length(ccl);
%把ccl变成三列的矩阵
fsC0=zeros(N_ccl/2,2);

  
    ii=1;
    for k1=1:N_ccl/2
        fsC0(k1,1)=ccl(ii);
        fsC0(k1,1)=fsC0(k1,1)*10^(6);
        ii=ii+1;
        fsC0(k1,2)=ccl(ii);
        fsC0(k1,2)=fsC0(k1,2)*10^(-15);
        ii=ii+1;
    end
% fsC0

    
    
 

%计算ABCD矩阵
N=size(fsC0,1);% 矩阵行数

if n==0
   for i=1:N
       %Z(i)=1./(1j.*f00.*fsC0(i,1)+1./(1j.*f00.*fsC0(i,3)+1./(1j.*f00.*fsC0(i,2))));
       Rm=(pi^2)/(8*2*3.14159*fsC0(i,1)*fsC0(i,2)*kt2*Q);
       Lm=(pi^2)/(8*(2*3.14159*fsC0(i,1))^2*fsC0(i,2)*kt2);
       Cm=(8*fsC0(i,2)*kt2)/(pi^2);
       Zm=Rm+1j*f00*Lm+1/(1j*f00*Cm);
       Z_R(i)=Rs+1/(1/Zm+1j*f00*fsC0(i,2));
       
       if i==1
           ABCD_params=[1,Z_R(i);0,1];
       else
          if mod(i,2)==0   %   偶数
          ABCD_params=ABCD_params*[1,0;1/Z_R(i),1];
          else           
          ABCD_params=ABCD_params*[1,Z_R(i);0,1];    
          end 
       end
   end
else
    for i=1:N
      % Z(i)=1./(1j.*f00.*fsC0(i,1)+1./(1j.*f00.*fsC0(i,2)+1./(1j.*f00.*fsC0(i,3))));
       Rm=pi^2/(8*2*pi*fsC0(i,1)*fsC0(i,2)*kt2*Q);
       Lm=pi^2/(8*(2*pi*fsC0(i,1))^2*fsC0(i,2)*kt2);
       Cm=(8*fsC0(i,2)*kt2)/(pi^2);
       Zm=Rm+1j*f00*Lm+1/(1j*f00*Cm);
       Z_R(i)=Rs+1/(1/Zm+1j*f00*fsC0(i,2));
        if i==1
           ABCD_params=ABCD_params*[1,0;1/Z_R(i),1];
       else
          if mod(i,2)==0   %   偶数
          ABCD_params=ABCD_params*[1,Z_R(i);0,1];    
          else           
          ABCD_params=ABCD_params*[1,0;1/Z_R(i),1];
          end 
       end
   end
end

 计算滤波器零极点并处理，也许不需要处理需要实部虚部的同时考虑优化。

function [chz,chp]=count_z_p_fun(n,C0CmLm)
%%%  算零极点,开头是串联n=０,是并联n=１

syms f00

ABCD_params=count_ABCD_fun(f00,n,C0CmLm);

S21=2/(ABCD_params(1,1)+ABCD_params(1,2)/50+ABCD_params(2,1)*50+ABCD_params(2,2));
S11=(ABCD_params(1,1)+ABCD_params(1,2)/50-ABCD_params(2,1)*50-ABCD_params(2,2))/(ABCD_params(1,1)+ABCD_params(1,2)/50+ABCD_params(2,1)*50+ABCD_params(2,2));
[E3,~]=numden(S21);
[E5,~]=numden(S11);
%[E7,E8]=numden(Y22)
ft6=solve(E3,f00);
ft7=solve(E5,f00);
%ft8=solve(E7,f00)
F=subs(ft7);
p=vpa(F,8);%真实值

F1=subs(ft6);
z=vpa(F1,8);

real_z=real(z);
real_p=real(p);


k1=1;
for i1=1:length(real_z)
    if real_z(i1)>0
        ch_z(k1)=real_z(i1)/(3.14159*2);
        k1=k1+1;
    end
end
k2=1;
 for i3=1:length(real_p)
     if real_p(i3)>0
         ch_p(k2)=real_p(i3)/(3.14159*2);
         k2=k2+1;
     end
 end
chz=sort(ch_z);
chp=sort(ch_p);

得到零极点的同时得到一些数

function [ch_z,ch_p,p_S11,s_S21]=count_z_p_fun(n,C0CmLm)
%%%  算零极点,开头是串联n=０,是并联n=１

syms f00

ABCD_params=count_ABCD_fun(f00,n,C0CmLm);

S21=2/(ABCD_params(1,1)+ABCD_params(1,2)/50+ABCD_params(2,1)*50+ABCD_params(2,2));
S11=(ABCD_params(1,1)+ABCD_params(1,2)/50-ABCD_params(2,1)*50-ABCD_params(2,2))/(ABCD_params(1,1)+ABCD_params(1,2)/50+ABCD_params(2,1)*50+ABCD_params(2,2));
[E3,~]=numden(S21);
[E5,~]=numden(S11);
%[E7,E8]=numden(Y22)
ft6=solve(E3,f00);
ft7=solve(E5,f00);
%ft8=solve(E7,f00)
F=subs(ft7);
p=vpa(F,8);

F1=subs(ft6);
z=vpa(F1,8);

real_z=real(z);
real_p=real(p);

chz=sort(real_z);
chp=sort(real_p);

% for i4=1:length(chp)
% p_S11(i4)=subs(S11,f00,chp(i4));
% p_S11(i4)=20*log10(abs(p_S11(i4)));
% end
k1=1;

for i1=1:length(chz)
    if chz(i1)>0
        ch_z(k1)=chz(i1)/(3.14159*2);
        k1=k1+1;
    end
end

k2=1;
 for i3=1:length(chp)
     if chp(i3)>0
         p_S11(k2)=subs(S11,f00,chp(i3));
         p_S11(k2)=20*log10(abs(p_S11(k2)));
         ch_p(k2)=chp(i3)/(3.14159*2);
         k2=k2+1;
     end
 end


chp_1=(ch_p(1)+(ch_p(2)-ch_p(1))*0.2)*3.14159*2;
s_S21(1)=subs(S21,f00,chp_1);
s_S21(1)=20*log10(abs(s_S21(1)));

chp_4=(ch_p(4)-(ch_p(4)-ch_p(3))*0.2)*3.14159*2;
s_S21(2)=subs(S21,f00,chp_4);
s_S21(2)=20*log10(abs(s_S21(2)));

S  参数绘制  dBS21 dBS11

function S_para_plot_fun(n,n_f,ini)
%%%%%%%%%%%%%%%画S参数图像的函数%x是频率，开头是串联n=０,是并联n=１

syms f00
ABCD_params=count_ABCD_fun(f00,n,ini);

S21=2/(ABCD_params(1,1)+ABCD_params(1,2)/50+ABCD_params(2,1)*50+ABCD_params(2,2));

S11=(ABCD_params(1,1)+ABCD_params(1,2)/50-ABCD_params(2,1)*50-ABCD_params(2,2))/(ABCD_params(1,1)+ABCD_params(1,2)/50+ABCD_params(2,1)*50+ABCD_params(2,2));

%F_S11=subs(S11,{'c01', 'cm1', 'lm1','c03', 'cm3', 'lm3','c02', 'cm2', 'lm2','c04', 'cm4', 'lm4'},{1*10^(-12),0.06634*10^(-12),31.2*10^(-9),1*10^(-12),0.06634*10^(-12),33.2*10^(-9),1*10^(-12),0.06634*10^(-12),31.2*10^(-9),1*10^(-12),0.06634*10^(-12),33.2*10^(-9)});


f0 = 18.85*10^9:10000000:25.133*10^9;
plot_S11=subs(S11,{'f00'},f0);

%figure(n_f)

plot(f0/(2*3.14159),20*log10(abs(plot_S11)))
hold on
%F_S21=subs(S21,{'c01', 'cm1', 'lm1','c03', 'cm3', 'lm3','c02', 'cm2', 'lm2','c04', 'cm4', 'lm4'},{1*10^(-12),0.06634*10^(-12),31.2*10^(-9),1*10^(-12),0.06634*10^(-12),33.2*10^(-9),1*10^(-12),0.06634*10^(-12),31.2*10^(-9),1*10^(-12),0.06634*10^(-12),33.2*10^(-9)})
plot_S21=subs(S21,{'f00'},f0);

plot(f0/(2*3.14159),20*log10(abs(plot_S21)))

  数据初始化：

把不能当滤波器的数剔除掉，可以考虑之后多加一些限制条件

%______________________________________________________________________________________________
%  Moth-Flame Optimization Algorithm (MFO)                                                            
%  Source codes demo version 1.0                                                                      
%                                                                                                     
%  Developed in MATLAB R2011b(7.13)                                                                   
%                                                                                                     
%  Author and programmer: Seyedali Mirjalili                                                          
%                                                                                                     
%         e-Mail: ali.mirjalili@gmail.com                                                             
%                 seyedali.mirjalili@griffithuni.edu.au                                               
%                                                                                                     
%       Homepage: http://www.alimirjalili.com                                                         
%                                                                                                     
%  Main paper:                                                                                        
%  S. Mirjalili, Moth-Flame Optimization Algorithm: A Novel Nature-inspired Heuristic Paradigm, 
%  Knowledge-Based Systems, DOI: http://dx.doi.org/10.1016/j.knosys.2015.07.006
%_______________________________________________________________________________________________

% This function creates the first random population of moths

%%
% C0:500-1500
% Cm:66000-67000
% Lm:31000-32000
%    33000-34000
   
%%
function X=initialization(SearchAgents_no,dim,ub,lb,target_z,target_p)
 display('MFO is initialization');

kk=1;

while kk<=SearchAgents_no%  只把符合滤波器的数做初始值

     for ii=1:dim  
     ub_i=ub(ii);
     lb_i=lb(ii);
     %X1(kk,ii)=rand(1).*(ub_i-lb_i)+lb_i+ini(ii);
     X1(kk,ii)=rand(1).*(ub_i-lb_i)+lb_i;
     end
    [temp_z,temp_p]=count_z_p_fun(0,X1(kk,:));
    temp_z=eval(temp_z);%转换为真实值
    temp_p=eval(temp_p);
     
    %判断是否为4个零点
    if length(temp_p)~=4
       t=0;
    else
       l_target=length(target_p);
       l_temp=length(temp_p);
       if temp_p(1)<target_p(1)
           k_p_min=temp_p(1);
       else
           k_p_min=target_p(1);
       end
     
       if temp_p(l_temp)<target_p(l_target)
           k_p_max=target_p(l_target);
       else
           k_p_max=temp_p(l_temp);
       end
     
      for jj=1:length(temp_z)
      if temp_z(jj)>k_p_min && temp_z(jj)<k_p_max   %   判断是否为滤波器
             t=0;
              display('0')
             break
      end
      t=1;
      end
    end
    
      if t==1
      X(kk,:)=X1(kk,:);
      kk=kk+1;
      display('ini+1')
      end
end   
end

MFO主函数

%______________________________________________________________________________________________
%  Moth-Flame Optimization Algorithm (MFO)                                                            
%  Source codes demo version 1.0                                                                      
%                                                                                                     
%  Developed in MATLAB R2011b(7.13)                                                                   
%                                                                                                     
%  Author and programmer: Seyedali Mirjalili                                                          
%                                                                                                     
%         e-Mail: ali.mirjalili@gmail.com                                                             
%                 seyedali.mirjalili@griffithuni.edu.au                                               
%                                                                                                     
%       Homepage: http://www.alimirjalili.com                                                         
%                                                                                                     
%  Main paper:                                                                                        
%  S. Mirjalili, Moth-Flame Optimization Algorithm: A Novel Nature-inspired Heuristic Paradigm, 
%  Knowledge-Based Systems, DOI: http://dx.doi.org/10.1016/j.knosys.2015.07.006
%_______________________________________________________________________________________________
% You can simply define your cost in a seperate file and load its handle to fobj 
% The initial parameters that you need are:
%__________________________________________
% fobj = @YourCostFunction
% dim = number of your variables
% Max_iteration = maximum number of generations
% SearchAgents_no = number of search agents
% lb=[lb1,lb2,...,lbn] where lbn is the lower bound of variable n
% ub=[ub1,ub2,...,ubn] where ubn is the upper bound of variable n
% If all the variables have equal lower bound you can just
% define lb and ub as two single number numbers

% To run MFO: [Best_score,Best_pos,cg_curve]=MFO(SearchAgents_no,Max_iteration,lb,ub,dim,fobj)
%______________________________________________________________________________________________

function [Best_flame_score,Best_flame_pos,Convergence_curve]=MFO(N,Max_iteration,lb,ub,dim,target_z,target_p)

display('MFO is optimizing your problem');
%Initialize the positions of moths
Moth_pos=initialization(N,dim,ub,lb,target_z,target_p);

Convergence_curve=zeros(1,Max_iteration);

Iteration=1;

% Main loop
while Iteration<Max_iteration+1
%       Number of flames Eq. (3.14) in the paper
    Flame_no=round(N-Iteration*((N-1)/Max_iteration));
    
    for i=1:size(Moth_pos,1)
        
        % Check if moths go out of the search spaceand bring it back  
        %a = b ＞ c    b>c a=1;

        Flag4ub=Moth_pos(i,:)>ub;%大于大的
        Flag4lb=Moth_pos(i,:)<lb;%小于小的
        Moth_pos(i,:)=(Moth_pos(i,:).*(~(Flag4ub+Flag4lb)))+ub.*Flag4ub+lb.*Flag4lb;  %赋值边界
        
        % Calculate the fitness of moths
        %Moth_fitness(1,i)=fobj(Moth_pos(i,:));  
        [z,p]=count_z_p_fun(0,Moth_pos(i,:));%从小到大排列

        Moth_fitness(1,i)=count_cost(z,p,target_z,target_p);
    end
       Moth_fitness
    if Iteration==1
        % Sort the first population of moths
        [fitness_sorted I]=sort(Moth_fitness);%I是对应的原来位置的索引
        sorted_population=Moth_pos(I,:);
        
        % Update the flames
        best_flames=sorted_population;
        best_flame_fitness=fitness_sorted;
    else
        
        % Sort the moths
        double_population=[previous_population;best_flames];
        double_fitness=[previous_fitness best_flame_fitness];
        
        [double_fitness_sorted I]=sort(double_fitness);
        double_sorted_population=double_population(I,:);
        
        fitness_sorted=double_fitness_sorted(1:N);
        sorted_population=double_sorted_population(1:N,:);
        
        % Update the flames
        best_flames=sorted_population;
        best_flame_fitness=fitness_sorted;
    end
    
    % Update the position best flame obtained so far
    Best_flame_score=fitness_sorted(1);
    Best_flame_pos=sorted_population(1,:);
      
    previous_population=Moth_pos;
    previous_fitness=Moth_fitness;
    
    % a linearly dicreases from -1 to -2 to calculate t in Eq. (3.12)
    a=-1+Iteration*((-1)/Max_iteration);
    
    for i=1:size(Moth_pos,1)
        
        for j=1:size(Moth_pos,2)
            if i<=Flame_no % Update the position of the moth with respect to its corresponsing flame
                
                % D in Eq. (3.13)
                distance_to_flame=abs(sorted_population(i,j)-Moth_pos(i,j));
                b=1;
                t=(a-1)*rand+1;
                
                % Eq. (3.12)
                Moth_pos(i,j)=distance_to_flame*exp(b.*t).*cos(t.*2*pi)+sorted_population(i,j);
            end
            
            if i>Flame_no % Upaate the position of the moth with respct to one flame
                
                % Eq. (3.13)
                distance_to_flame=abs(sorted_population(i,j)-Moth_pos(i,j));
                b=1;
                t=(a-1)*rand+1;
                
                % Eq. (3.12)
                Moth_pos(i,j)=distance_to_flame*exp(b.*t).*cos(t.*2*pi)+sorted_population(Flame_no,j);
            end
            
        end
        
    end
    
    Convergence_curve(Iteration)=Best_flame_score;
    
    % Display the iteration and best optimum obtained so far
    if mod(Iteration,50)==0
        display('At iteration: ')
        Iteration
        display(' the best fitness is ')
        Best_flame_score
        display(' the best pose is ')
        Best_flame_pos=sorted_population(1,:)
        figure(Iteration/50) %  删除后图片会最后显示
         hold on
        S_para_plot_fun(0,Iteration/50,sorted_population(1,:))
        %display(['At iteration ', num2str(Iteration), ' the best fitness is ', num2str(Best_flame_score)]);
    end
    Iteration=Iteration+1; 
end

main   函数

%______________________________________________________________________________________________
%  Moth-Flame Optimization Algorithm (MFO)                                                            
%  Source codes demo version 1.0                                                                      
%                                                                                                     
%  Developed in MATLAB R2011b(7.13)                                                                   
%                                                                                                     
%  Author and programmer: Seyedali Mirjalili                                                          
%                                                                                                     
%         e-Mail: ali.mirjalili@gmail.com                                                             
%                 seyedali.mirjalili@griffithuni.edu.au                                               
%                                                                                                     
%       Homepage: http://www.alimirjalili.com                                                         
%                                                                                                     
%  Main paper:                                                                                        
%  S. Mirjalili, Moth-Flame Optimization Algorithm: A Novel Nature-inspired Heuristic Paradigm, 
%  Knowledge-Based Systems, DOI: http://dx.doi.org/10.1016/j.knosys.2015.07.006
%_______________________________________________________________________________________________
% You can simply define your cost in a seperate file and load its handle to fobj 
% The initial parameters that you need are:
%__________________________________________
% fobj = @YourCostFunction
% dim = number of your variables
% Max_iteration = maximum number of generations
% SearchAgents_no = number of search agents
% lb=[lb1,lb2,...,lbn] where lbn is the lower bound of variable n
% ub=[ub1,ub2,...,ubn] where ubn is the upper bound of variable n
% If all the variables have equal lower bound you can just
% define lb and ub as two single number numbers

% To run MFO: [Best_score,Best_pos,cg_curve]=MFO(SearchAgents_no,Max_iteration,lb,ub,dim,fobj)
%______________________________________________________________________________________________

clear all 
clc
target_z=[3.4050*10^(9),3.5970*10^(9)];
%target_p=[3.4235*10^(9),3.47*10^(9),3.5295*10^(9),3.5785*10^(9)];%从小到大
target_p=[3.4311*10^(9),3.47*10^(9),3.5295*10^(9),3.5693*10^(9)];%从小到大
SearchAgents_no=30; % Number of search agents种群大小

%%Function_name='F2'; % Name of the test function that can be from F1 to F23 (Table 1,2,3 in the paper)

Max_iteration=500; % Maximum numbef of iterations迭代次数

% Load details of the selected benchmark function. dim:待优化变量
%%[lb,ub,dim,fobj]=Get_Functions_details(Function_name);

dim=12;
%最大边界
ub=[140,6700,3250,170,6700,3400,140,6700,3200,170,6700,3400];
%ub=[50,50,50,50,50,50,50,50,50,50,50,50];
%初始值
%ini=[100,6634,3120,100,6634,3320,100,6634,3120,100,6634,3320];
lb=[30,6500,3100,50,6500,3200,30,6500,3100,50,6500,3200];
%最小边界
%lb=[-50,-50,-50,-50,-50,-50,-50,-50,-50,-50,-50,-50];

[Best_score,Best_pos,cg_curve]=MFO(SearchAgents_no,Max_iteration,lb,ub,dim,target_z,target_p);

% % figure('Position',[284   214   660   290])
% % %Draw search space
% % subplot(1,2,1);
% % func_plot(Function_name);
% % title('Test function')
% % xlabel('x_1');
% % ylabel('x_2');
% % zlabel([Function_name,'( x_1 , x_2 )'])
% % grid off
Best_score
Best_pos
%Draw objective space
%%subplot(1,2,2);
figure(Max_iteration/50+1) 
hold on
semilogy(cg_curve,'Color','b')
title('Convergence curve')
xlabel('Iteration');
ylabel('Best flame (score) obtained so far');

axis tight
grid off
box on
legend('MFO')

%display(['The best solution obtained by MFO is : ', num2str(Best_pos)]);
%display(['The best optimal value of the objective funciton found by MFO is : ', num2str(Best_score)]);

fy_yt
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【MFO】飞蛾扑火优化算法(Moth Flame Optimization,MFO)理论分析与matlab性能仿真,使用CEC2017测试
平时工作较为繁忙,私信消息一般晚上回复,谢谢大家~~
04-30 325
在自然界中，不同种类的昆虫利用不同方法来辨认方向。食物，同类的气味，温度高低等因素都能成为昆虫确定活动方向的因素。飞蛾主要依靠月光来判定方向，它总是使月光从一个方向投射到眼中，这样就找到了大致的飞行方向。飞蛾在逃避天敌的追逐，或者绕过障碍物转弯以后，它只要不断地转弯，月光仍将从原先的方向射来，它也就再次找到了方向。假设候选解是飞蛾，问题的变量是飞蛾在空间中的位置：这里n为种群规模，d为空间维度。
【优化算法Matlab代码】资源存储库-第五期-飞蛾扑火优化算法(MFO ).zip
04-08
飞蛾扑火优化(Moth-flame optimization，MFO)，由Seyedali Mirjalili在2015年提出，为优化领域提供了一种新的启发式搜索范式：螺旋搜索。 飞蛾在夜间有一种特殊的导航方式：横向定向。即它会与月亮(光源)保持一定的角度飞行，从而能够保持直线的飞行路径，但是，这种方式只在光源离飞蛾较远的情况下才有效。当有人造光源存在时，飞蛾会被人工灯光所欺骗，一直保持与人造灯光相同的角度飞行，由于它与光源的距离过近，它飞行的路径已经不是直线，而是一种螺旋的路径。
Matlab滤波器设计示例
chenxy_bwave的专栏
11-20 1万+
Matlab提供了非常丰富的滤波器设计工具，其中最基本的是designfilt()函数。designfilt()函数是通用的滤波器设计工具，可以用于设计各种类型的数字滤波器，以及模拟滤波器的数字近似。Matlab还提供了其它很多专用类型的滤波器设计函数，还有基于图形化界面进行滤波器设计的工具filterDesigner(旧版本为fdatool)。本文综合但简要地介绍各种matlab滤波器设计工具，顺便代码示例介绍用于滤波器频谱观测用的工具、以及如何使用所生成的滤波器对象。
滤波算法一(C代码)
让你爱上电路设计
04-16 3493
一阶滞后滤波算法、限幅滤波法（又称程序判断滤波法）、中位值滤波法、算术平均滤波法、递推平均滤波法（又称滑动平均滤波法）、中位值平均滤波法（又称防脉冲干扰平均滤波法）、限幅平均滤波法、加权递推平均滤波法、消抖滤波法
MFO_matlab_飞蛾扑火优化算法_mfo_MFO代码_
10-03
matlab实现mfo代码 ，好用的代码，真实有效
MFO 飞蛾优化算法 matlab代码
04-22
MFO 飞蛾优化算法 matlab代码
飞蛾扑火优化算法（MFO）matlab代码
06-11
飞蛾扑火优化算法（Moth-Flame Optimization，MFO）是澳大利亚学者Seyedali Mirjalili于2015年提出的一种受自然生物启发的智能优化算法。代码里面包含了20几种基准测试函数，用来测试算法的性能。 该算法的主要灵感...
MFO算法以及论文,MFO算法,matlab
09-10
一个飞蛾扑火算法的实现，里面包含了算法的论文，可以参考着看
matlab多目标mfo飞蛾扑火启发式算法
最新发布
04-17
matlab多目标mfo飞蛾扑火启发式算法
智能优化算法（源码）-飞蛾扑火优化算法（MFO）
松间沙路的博客
04-20 5033
获取更多资讯，赶快关注上面的公众号吧！ 文章目录灵感MFO算法 飞蛾扑火优化算法（Moth-Flame Optimization，MFO）是澳大利亚学者Seyedali Mirjalili于2015年提出的一种受自然生物启发的智能优化算法，该算法的主要灵感来自于飞蛾被称为“横定向”的导航方法。飞蛾在夜间飞行时相对于月亮保持一个固定的角度，这是一种非常有效的远距离直线飞行机制，但是在人造光周围，飞蛾却容易陷入致命的螺旋路径。作者就是模拟了飞蛾的这种特点。扫码关注公众号，后台回复“飞蛾扑火”或“MFO”可以.
11种经典滤波算法
木牛的博客
07-14 7702
1、限幅滤波法（又称程序判断滤波法） A、方法： 根据经验判断，确定两次采样允许的最大偏差值（设为A） 每次检测到新值时判断： 如果本次值与上次值之差<=A,则本次值有效 如果本次值与上次值之差>A,则本次值无效,放弃本次值,用上次值代替本次值 B、优点： 能有效克服因偶然因素引起的脉冲干扰 C、缺点 无法抑制那种周期性的干扰 平滑度差 2、中位值滤波...
滤波算法——十大滤波算法程序大全
数字世界 万物互联
12-09 8383
最近做数据采集相关的，用到去除信号抖动相关的算法，网上找了些大神分享的资源，整理如下，尊重他人成果，附转载链接：https://www.geek-workshop.com/thread-7694-1-1.html 1、限幅滤波法（又称程序判断滤波法） 2、中位值滤波法 3、算术平均滤波法 4、递推平均滤波法（又称滑动平均滤波法） 5、中位值平均滤波法（又称防脉冲干扰平均滤波法） 6、限幅...
常用软件滤波方法及其示例程序
03-29 5494
常用软件滤波方法及其示例程序   作者 未知    来源     发布时间 2005-08-24     浏览次数 119    字体 大  中  小
分布式算法FIR滤波器
FPGA/MATLAB学习教程/源码/项目合作开发
06-02 4693
目前FIR滤波器的实现方法有三种：利用单片通用数字滤波器集成电路、DSP器件和可编程逻辑器件实现。单片通用数字滤波器使用方便，但由于字长和阶数的规格较少，不能完全满足实际需要。使用DSP器件实现虽然简单，但由于程序顺序执行，执行速度必然不快。FPGA有着规整的内部逻辑阵列和丰富的连线资源，特别适合于数字信号处理任务，相对于串行运算为主导的通用DSP芯片来说，其并行性和可扩展性更好。但长期以来，FPGA一直被用于系统逻辑或时序控制上，很少有信号处理方面的应用，其原因主要是因为在FPGA中缺乏实现乘法运...
自动驾驶算法-滤波器系列（六）——10+种经典滤波算法
weixin_41480034的博客
12-25 1158
经典滤波器介绍1、限幅滤波法（又称程序判断滤波法）2、中位值滤波法3、算术平均滤波法4、递推平均滤波法（又称滑动平均滤波法）5、中位值平均滤波法（又称防脉冲干扰平均滤波法）6、限幅平均滤波法7、一阶滞后滤波法8、加权递推平均滤波法9、消抖滤波法10、限幅消抖滤波法11、IIR 数字滤波器 滤波 1、限幅滤波法（又称程序判断滤波法） 2、中位值滤波法 3、算术平均滤波法 4、递推平均滤波法（又称滑动平均滤波法） 5、中位值平均滤波法（又称防脉冲干扰平均滤波法） 6、限幅平均滤波法 7、一阶滞后滤波法 8、
七种滤波方法测试matlab
傅斯年的写字台
08-17 2万+
七种滤波方法测试matlab实现（转）   本文源自：http://blog.163.com/xiaheng0804@126/blog/static/1205282120132129471816/ 创建两个混合信号，便于更好测试滤波器效果。同时用七中滤波方法测试。 混合信号ix_Signal_1 = 信号Signal_Original_1+白噪声。 混合
数字信号处理公式变程序（四）——巴特沃斯滤波器（上）
热门推荐
阿生的专栏
07-07 6万+
之前搞了一些数字信号处理算法编程（OC），一直没来得及整理，现在整理一下，包括FFT、巴特沃斯滤波器（高通、低通、带通、带阻）、数据差值（线性、sinc、三次样条*）、数据压缩（等距、平均、峰值检测）和模仿matlab的STFT功能（spectrogram函数三维绘图）。 注：可能会有不足或者理解偏差的地方，路过的高人请不吝赐教。 今天来说一下数字滤波器的代码实现（IIR）。 -...
各种滤波算法的比较
wangweijjj的博客
06-20 4万+
原文地址：http://www.wtoutiao.com/p/1fe9dPI.html  各种滤波算法的比较 数字滤波(digital filtering):数字滤波(digital filtering):用数字设备，通过一定的算法，对信号进行处理，将某个频段的信号进行滤除，得到新的信号的这一过程叫做数字滤波。数字滤波器可以分为两大部分:即经典滤波器和现代滤
MFO算法MATLAB代码,【优化求解】飞蛾扑火算法（MFO）【Matlab 192期】
06-06
以下是MATLAB实现的MFO算法代码： ```matlab function [bestFit, bestInd] = MFO(func, dim, lb, ub, maxIter) % 参数说明： % func：优化函数 % dim：优化问题的维度 % lb：每个维度的下界 % ub：每个维度的上界 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值