EMD简化代码

Question

%% EMD分解
function [imf,ort,nbits] = emd(varargin)
[x,t,sd,sd2,tol,MODE_COMPLEX,ndirs,display_sifting,sdt,sd2t,r,imf,k,nbit,NbIt,MAXITERATIONS,FIXE,FIXE_H,MAXMODES,INTERP,mask] = init(varargin{:});

%main loop : requires at least 3 extrema to proceed
while (~stop_EMD(r,MODE_COMPLEX,ndirs) && (k < MAXMODES+1 || MAXMODES == 0) && ~any(mask))
% current mode
m = r;
% mode at previous iteration
mp = m;
%computation of mean and stopping criterion
if FIXE
[stop_sift,moyenne] = stop_sifting_fixe(t,m,INTERP,MODE_COMPLEX,ndirs);
elseif FIXE_H
stop_count = 0;
[stop_sift,moyenne] = stop_sifting_fixe_h(t,m,INTERP,stop_count,FIXE_H,MODE_COMPLEX,ndirs);
else
[stop_sift,moyenne] = stop_sifting(m,t,sd,sd2,tol,INTERP,MODE_COMPLEX,ndirs);
end

% in case the current mode is so small that machine precision can cause
% spurious extrema to appear
if (max(abs(m))) < (1e-10)*(max(abs(x)))
if ~stop_sift
warning('emd:warning','forced stop of EMD : too small amplitude')
else
disp('forced stop of EMD : too small amplitude')
end
break
end

% sifting loop
while ~stop_sift && nbit<MAXITERATIONS
if(~MODE_COMPLEX && nbit>MAXITERATIONS/5 && mod(nbit,floor(MAXITERATIONS/10))==0 && ~FIXE && nbit > 100)
disp(['mode ',int2str(k),', iteration ',int2str(nbit)])
if exist('s','var')
disp(['stop parameter mean value : ',num2str(s)])
end
[im,iM] = extr(m);
disp([int2str(sum(m(im) > 0)),' minima > 0; ',int2str(sum(m(iM) < 0)),' maxima < 0.'])
end

text
%sifting
m = m - moyenne;

%computation of mean and stopping criterion
if FIXE
  [stop_sift,moyenne] = stop_sifting_fixe(t,m,INTERP,MODE_COMPLEX,ndirs);
elseif FIXE_H
  [stop_sift,moyenne,stop_count] = stop_sifting_fixe_h(t,m,INTERP,stop_count,FIXE_H,MODE_COMPLEX,ndirs);
else
  [stop_sift,moyenne,s] = stop_sifting(m,t,sd,sd2,tol,INTERP,MODE_COMPLEX,ndirs);
end

mp = m;
nbit=nbit+1;
NbIt=NbIt+1;

if(nbit==(MAXITERATIONS-1) && ~FIXE && nbit > 100)
  if exist('s','var')
    warning('emd:warning',['forced stop of sifting : too many iterations... mode ',int2str(k),'. stop parameter mean value : ',num2str(s)])
  else
    warning('emd:warning',['forced stop of sifting : too many iterations... mode ',int2str(k),'.'])
  end
end

end % sifting loop
imf(k,:) = m;
if display_sifting
disp(['mode ',int2str(k),' stored'])
end
nbits(k) = nbit;
k = k+1;

r = r - m;
nbit=0;

end %main loop

if any(r) && ~any(mask)
imf(k,:) = r;
end

ort = io(x,imf);

if display_sifting
close
end
end

%---------------------------------------------------------------------------------------------------
% tests if there are enough (3) extrema to continue the decomposition
function stop = stop_EMD(r,MODE_COMPLEX,ndirs)
if MODE_COMPLEX
for k = 1:ndirs
phi = (k-1)pi/ndirs;
[indmin,indmax] = extr(real(exp(iphi)*r));
ner(k) = length(indmin) + length(indmax);
end
stop = any(ner < 3);
else
[indmin,indmax] = extr(r);
ner = length(indmin) + length(indmax);
stop = ner < 3;
end
end

%---------------------------------------------------------------------------------------------------
% computes the mean of the envelopes and the mode amplitude estimate
function [envmoy,nem,nzm,amp] = mean_and_amplitude(m,t,INTERP,MODE_COMPLEX,ndirs)
NBSYM = 2;
if MODE_COMPLEX
switch MODE_COMPLEX
case 1
for k = 1:ndirs
phi = (k-1)pi/ndirs;
y = real(exp(-iphi)*m);
[indmin,indmax,indzer] = extr(y);
nem(k) = length(indmin)+length(indmax);
nzm(k) = length(indzer);
[tmin,tmax,zmin,zmax] = boundary_conditions(indmin,indmax,t,y,m,NBSYM);
envmin(k,:) = interp1(tmin,zmin,t,INTERP);
envmax(k,:) = interp1(tmax,zmax,t,INTERP);
end
envmoy = mean((envmin+envmax)/2,1);
if nargout > 3
amp = mean(abs(envmax-envmin),1)/2;
end
case 2
for k = 1:ndirs
phi = (k-1)pi/ndirs;
y = real(exp(-iphi)m);
[indmin,indmax,indzer] = extr(y);
nem(k) = length(indmin)+length(indmax);
nzm(k) = length(indzer);
[tmin,tmax,zmin,zmax] = boundary_conditions(indmin,indmax,t,y,y,NBSYM);
envmin(k,:) = exp(iphi)interp1(tmin,zmin,t,INTERP);
envmax(k,:) = exp(iphi)*interp1(tmax,zmax,t,INTERP);
end
envmoy = mean((envmin+envmax),1);
if nargout > 3
amp = mean(abs(envmax-envmin),1)/2;
end
end
else
[indmin,indmax,indzer] = extr(m);
nem = length(indmin)+length(indmax);
nzm = length(indzer);
[tmin,tmax,mmin,mmax] = boundary_conditions(indmin,indmax,t,m,m,NBSYM);
envmin = interp1(tmin,mmin,t,INTERP);
envmax = interp1(tmax,mmax,t,INTERP);
envmoy = (envmin+envmax)/2;
if nargout > 3
amp = mean(abs(envmax-envmin),1)/2;
end
end
end

%-------------------------------------------------------------------------------
% default stopping criterion
function [stop,envmoy,s] = stop_sifting(m,t,sd,sd2,tol,INTERP,MODE_COMPLEX,ndirs)
try
[envmoy,nem,nzm,amp] = mean_and_amplitude(m,t,INTERP,MODE_COMPLEX,ndirs);
sx = abs(envmoy)./amp;
s = mean(sx);
stop = ~((mean(sx > sd) > tol | any(sx > sd2)) & (all(nem > 2)));
if ~MODE_COMPLEX
stop = stop && ~(abs(nzm-nem)>1);
end
catch
stop = 1;
envmoy = zeros(1,length(m));
s = NaN;
end
end

%-------------------------------------------------------------------------------
% stopping criterion corresponding to option FIX
function [stop,moyenne]= stop_sifting_fixe(t,m,INTERP,MODE_COMPLEX,ndirs)
try
moyenne = mean_and_amplitude(m,t,INTERP,MODE_COMPLEX,ndirs);
stop = 0;
catch
moyenne = zeros(1,length(m));
stop = 1;
end
end

%-------------------------------------------------------------------------------
% stopping criterion corresponding to option FIX_H
function [stop,moyenne,stop_count]= stop_sifting_fixe_h(t,m,INTERP,stop_count,FIXE_H,MODE_COMPLEX,ndirs)
try
[moyenne,nem,nzm] = mean_and_amplitude(m,t,INTERP,MODE_COMPLEX,ndirs);
if (all(abs(nzm-nem)>1))
stop = 0;
stop_count = 0;
else
stop_count = stop_count+1;
stop = (stop_count == FIXE_H);
end
catch
moyenne = zeros(1,length(m));
stop = 1;
end
end

%---------------------------------------------------------------------------------------
% defines new extrema points to extend the interpolations at the edges of the
% signal (mainly mirror symmetry)
function [tmin,tmax,zmin,zmax] = boundary_conditions(indmin,indmax,t,x,z,nbsym)

lx = length(x);

if (length(indmin) + length(indmax) < 3)
error('not enough extrema')
end

% boundary conditions for interpolations :

if indmax(1) < indmin(1)
if x(1) > x(indmin(1))
lmax = fliplr(indmax(2:min(end,nbsym+1)));
lmin = fliplr(indmin(1:min(end,nbsym)));
lsym = indmax(1);
else
lmax = fliplr(indmax(1:min(end,nbsym)));
lmin = [fliplr(indmin(1:min(end,nbsym-1))),1];
lsym = 1;
end
else

text
if x(1) < x(indmax(1))
  lmax = fliplr(indmax(1:min(end,nbsym)));
  lmin = fliplr(indmin(2:min(end,nbsym+1)));
  lsym = indmin(1);
else
  lmax = [fliplr(indmax(1:min(end,nbsym-1))),1];
  lmin = fliplr(indmin(1:min(end,nbsym)));
  lsym = 1;
end

end

if indmax(end) < indmin(end)
if x(end) < x(indmax(end))
rmax = fliplr(indmax(max(end-nbsym+1,1):end));
rmin = fliplr(indmin(max(end-nbsym,1):end-1));
rsym = indmin(end);
else
rmax = [lx,fliplr(indmax(max(end-nbsym+2,1):end))];
rmin = fliplr(indmin(max(end-nbsym+1,1):end));
rsym = lx;
end
else
if x(end) > x(indmin(end))
rmax = fliplr(indmax(max(end-nbsym,1):end-1));
rmin = fliplr(indmin(max(end-nbsym+1,1):end));
rsym = indmax(end);
else
rmax = fliplr(indmax(max(end-nbsym+1,1):end));
rmin = [lx,fliplr(indmin(max(end-nbsym+2,1):end))];
rsym = lx;
end
end

tlmin = 2t(lsym)-t(lmin);
tlmax = 2t(lsym)-t(lmax);
trmin = 2t(rsym)-t(rmin);
trmax = 2t(rsym)-t(rmax);

% in case symmetrized parts do not extend enough
if tlmin(1) > t(1) || tlmax(1) > t(1)
if lsym == indmax(1)
lmax = fliplr(indmax(1:min(end,nbsym)));
else
lmin = fliplr(indmin(1:min(end,nbsym)));
end
if lsym == 1
error('bug')
end
lsym = 1;
tlmin = 2t(lsym)-t(lmin);
tlmax = 2t(lsym)-t(lmax);
end

if trmin(end) < t(lx) || trmax(end) < t(lx)
if rsym == indmax(end)
rmax = fliplr(indmax(max(end-nbsym+1,1):end));
else
rmin = fliplr(indmin(max(end-nbsym+1,1):end));
end
if rsym == lx
error('bug')
end
rsym = lx;
trmin = 2t(rsym)-t(rmin);
trmax = 2t(rsym)-t(rmax);
end

zlmax =z(lmax);
zlmin =z(lmin);
zrmax =z(rmax);
zrmin =z(rmin);

tmin = [tlmin t(indmin) trmin];
tmax = [tlmax t(indmax) trmax];
zmin = [zlmin z(indmin) zrmin];
zmax = [zlmax z(indmax) zrmax];
end

%---------------------------------------------------------------------------------------------------
%extracts the indices of extrema
function [indmin, indmax, indzer] = extr(x,t)

if(nargin==1)
t=1:length(x);
end

m = length(x);

if nargout > 2
x1=x(1:m-1);
x2=x(2:m);
indzer = find(x1.*x2<0);

if any(x == 0)
iz = find( x==0 );
indz = [];
if any(diff(iz)==1)
zer = x == 0;
dz = diff([0 zer 0]);
debz = find(dz == 1);
finz = find(dz == -1)-1;
indz = round((debz+finz)/2);
else
indz = iz;
end
indzer = sort([indzer indz]);
end
end

d = diff(x);

n = length(d);
d1 = d(1:n-1);
d2 = d(2:n);
indmin = find(d1.*d2<0 & d1<0)+1;
indmax = find(d1.*d2<0 & d1>0)+1;

% when two or more successive points have the same value we consider only one extremum in the middle of the constant area
% (only works if the signal is uniformly sampled)

if any(d==0)

imax = [];
imin = [];

bad = (d==0);
dd = diff([0 bad 0]);
debs = find(dd == 1);
fins = find(dd == -1);
if debs(1) == 1
if length(debs) > 1
debs = debs(2:end);
fins = fins(2:end);
else
debs = [];
fins = [];
end
end
if length(debs) > 0
if fins(end) == m
if length(debs) > 1
debs = debs(1:(end-1));
fins = fins(1:(end-1));

text
  else
    debs = [];
    fins = [];
  end
end

end
lc = length(debs);
if lc > 0
for k = 1:lc
if d(debs(k)-1) > 0
if d(fins(k)) < 0
imax = [imax round((fins(k)+debs(k))/2)];
end
else
if d(fins(k)) > 0
imin = [imin round((fins(k)+debs(k))/2)];
end
end
end
end

if length(imax) > 0
indmax = sort([indmax imax]);
end

if length(imin) > 0
indmin = sort([indmin imin]);
end

end
end

%---------------------------------------------------------------------------------------------------

function ort = io(x,imf)
% ort = IO(x,imf) computes the index of orthogonality
%
% inputs : - x : analyzed signal
% - imf : empirical mode decomposition

n = size(imf,1);

s = 0;

for i = 1:n
for j =1:n
if i~=j
s = s + abs(sum(imf(i,:).*conj(imf(j,:)))/sum(x.^2));
end
end
end

ort = 0.5*s;
end
%---------------------------------------------------------------------------------------------------

function [x,t,sd,sd2,tol,MODE_COMPLEX,ndirs,display_sifting,sdt,sd2t,r,imf,k,nbit,NbIt,MAXITERATIONS,FIXE,FIXE_H,MAXMODES,INTERP,mask] = init(varargin)

x = varargin{1};
if nargin == 2
if isstruct(varargin{2})
inopts = varargin{2};
else
error('when using 2 arguments the first one is the analyzed signal X and the second one is a struct object describing the options')
end
elseif nargin > 2
try
inopts = struct(varargin{2:end});
catch
error('bad argument syntax')
end
end

% default for stopping
defstop = [0.05,0.5,0.05];

opt_fields = {'t','stop','display','maxiterations','fix','maxmodes','interp','fix_h','mask','ndirs','complex_version'};

defopts.stop = defstop;
defopts.display = 0;
defopts.t = 1:max(size(x));
defopts.maxiterations = 2000;
defopts.fix = 0;
defopts.maxmodes = 0;
defopts.interp = 'spline';
defopts.fix_h = 0;
defopts.mask = 0;
defopts.ndirs = 4;
defopts.complex_version = 2;

opts = defopts;

if(nargin==1)
inopts = defopts;
elseif nargin == 0
error('not enough arguments')
end

names = fieldnames(inopts);
for nom = names'
if ~any(strcmpi(char(nom), opt_fields))
error(['bad option field name: ',char(nom)])
end
if ~isempty(eval(['inopts.',char(nom)])) % empty values are discarded
eval(['opts.',lower(char(nom)),' = inopts.',char(nom),';'])
end
end
t = opts.t;
stop = opts.stop;
display_sifting = opts.display;
MAXITERATIONS = opts.maxiterations;
FIXE = opts.fix;
MAXMODES = opts.maxmodes;
INTERP = opts.interp;
FIXE_H = opts.fix_h;
mask = opts.mask;
ndirs = opts.ndirs;
complex_version = opts.complex_version;
if ~isvector(x)
error('X must have only one row or one column')
end
if size(x,1) > 1
x = x.';
end

if ~isvector(t)
error('option field T must have only one row or one column')
end

if ~isreal(t)
error('time instants T must be a real vector')
end

if size(t,1) > 1
t = t';
end
if (length(t)~=length(x))
error('X and option field T must have the same length')
end
if ~isvector(stop) || length(stop) > 3
error('option field STOP must have only one row or one column of max three elements')
end
if ~all(isfinite(x))
error('data elements must be finite')
end
if size(stop,1) > 1
stop = stop';
end

L = length(stop);
if L < 3
stop(3)=defstop(3);
end

if L < 2
stop(2)=defstop(2);
end

if ~ischar(INTERP) || ~any(strcmpi(INTERP,{'linear','cubic','spline'}))
error('INTERP field must be ''linear'', ''cubic'', ''pchip'' or ''spline''')
end

%special procedure when a masking signal is specified
if any(mask)
if ~isvector(mask) || length(mask) ~= length(x)
error('masking signal must have the same dimension as the analyzed signal X')
end

if size(mask,1) > 1
mask = mask.';
end
opts.mask = 0;
imf1 = emd(x+mask,opts);
imf2 = emd(x-mask,opts);
if size(imf1,1) ~= size(imf2,1)
warning('emd:warning',['the two sets of IMFs have different sizes: ',int2str(size(imf1,1)),' and ',int2str(size(imf2,1)),' IMFs.'])
end
S1 = size(imf1,1);
S2 = size(imf2,1);
if S1 ~= S2
if S1 < S2
tmp = imf1;
imf1 = imf2;
imf2 = tmp;
end
imf2(max(S1,S2),1) = 0;
end
imf = (imf1+imf2)/2;
end
sd = stop(1);
sd2 = stop(2);
tol = stop(3);
lx = length(x);
sdt = sdones(1,lx);
sd2t = sd2ones(1,lx);
if FIXE
MAXITERATIONS = FIXE;
if FIXE_H
error('cannot use both ''FIX'' and ''FIX_H'' modes')
end
end
MODE_COMPLEX = ~isreal(x)*complex_version;
if MODE_COMPLEX && complex_version ~= 1 && complex_version ~= 2
error('COMPLEX_VERSION parameter must equal 1 or 2')
end
% number of extrema and zero-crossings in residual
ner = lx;
nzr = lx;
r = x;
if ~any(mask) % if a masking signal is specified "imf" already exists at this stage
imf = [];
end
k = 1;
% iterations counter for extraction of 1 mode
nbit=0;
% total iterations counter
NbIt=0;
end

%% ceemd分解
function [modos, its] = ceemd(x, Nstd, NR, MaxIter)
%--------------------------------------------------------------------------
% WARNING: This code requires the 'emd.m' file developed by Rilling and Flandrin.
%--------------------------------------------------------------------------
% OUTPUT
% modos: Contains the obtained modes in a matrix with the rows being the modes
% its: Contains the iterations needed for each mode for each realization
%
% INPUT
% x: Signal to decompose
% Nstd: Noise standard deviation
% NR: Number of realizations (repetitions for generating multiple noise signals)
% MaxIter: Maximum number of sifting iterations allowed in EMD
%--------------------------------------------------------------------------
% Syntax
% modos = ceemd(x, Nstd, NR, MaxIter)
% [modos, its] = ceemd(x, Nstd, NR, MaxIter)
%--------------------------------------------------------------------------
% NOTE: If Nstd = 0 and NR = 1, the EMD decomposition is obtained.
%--------------------------------------------------------------------------
% Example of usage:
% [modes, its] = ceemd(x, 0.2, 100, 1000);

% 1. 计算输入信号的标准差并进行归一化处理
desvio_estandar = std(x); % 计算输入信号的标准差
x = x / desvio_estandar; % 对信号进行归一化处理

% 2. 初始化用于存储分解模式的矩阵以及用于记录迭代次数的矩阵
modos = zeros(length(x), 0); % 初始化用于存储模态的矩阵
iter = []; % 初始化用于记录每次分解的迭代次数的矩阵

% 3. 进行多次噪声添加与EMD分解
for i = 1:NR
% 生成带正噪声的信号（标准高斯白噪声）
xconruido_pos = x + Nstd * randn(size(x)); % 添加正高斯白噪声
% 生成带负噪声的信号（标准高斯白噪声）
xconruido_neg = x - Nstd * randn(size(x)); % 添加负高斯白噪声

text
% 对带正噪声信号进行EMD分解，返回分解结果和每次分解的迭代次数
[temp_pos, ~, it_pos] = emd(xconruido_pos, 'MAXITERATIONS', MaxIter); 
% 对带负噪声信号进行EMD分解，返回分解结果和每次分解的迭代次数
[temp_neg, ~, it_neg] = emd(xconruido_neg, 'MAXITERATIONS', MaxIter); 

% 获取两个模态分解结果的行数和列数
[rows_pos, cols_pos] = size(temp_pos);
[rows_neg, cols_neg] = size(temp_neg);

% 如果行数不同，填充较小的矩阵
if rows_pos < rows_neg
    temp_pos = [temp_pos; zeros(rows_neg - rows_pos, cols_pos)];
elseif rows_pos > rows_neg
    temp_neg = [temp_neg; zeros(rows_pos - rows_neg, cols_neg)];
end

% 平均正负噪声的分解结果
temp = (temp_pos + temp_neg) / 2;

% 处理迭代次数：确保它们是列向量
it_pos = it_pos(:); % 将 it_pos 转换为列向量
it_neg = it_neg(:); % 将 it_neg 转换为列向量 

% 记录每次分解的迭代次数
iter = [iter; it_pos; it_neg]; 

% 如果是第一次迭代，初始化分解模式矩阵
if i == 1
    modos = temp; % 第一次迭代时初始化分解结果
else
    % 如果不是第一次迭代，则将当前模态添加到累积结果中
    [filas, ~] = size(modos); % 获取当前模态矩阵的尺寸
    [new_filas, ~] = size(temp); % 获取新模态的尺寸
    
    % 根据模态的尺寸调整矩阵大小，使其一致
    if new_filas > filas
        modos = [modos; zeros(new_filas - filas, size(modos, 2))]; % 增加行
    elseif filas > new_filas
        temp = [temp; zeros(filas - new_filas, size(temp, 2))]; % 增加行
    end
    
    % 累加当前模态结果到总的模态矩阵中
    modos = modos + temp; % 将当前模态结果累加
end

end

% 4. 在所有迭代完成后，进行最终的模态平均处理
modos = modos * desvio_estandar; % 恢复到原始信号的尺度（恢复标准差）

% 5. 返回每个模态分解的迭代次数信息
its = iter; % 返回每次分解的迭代次数
end
整个是现有的ceemd分解函数，其中有着确定输入数据是实数还是虚数进行操作的部分，但是我的操作只是对实数进行分解，因此叙述部分相关代码就使得代码变得冗杂，因此我想要更改这些代码，让这个代码变得简洁，你能帮我修改一下吗，要求尽量不要改变代码参数的定义，并使得代码符合matlab的要求

Answer 1

下面给出一个简化版本的 emd.m 和 ceemd.m，仅保留对实数信号进行处理所需的部分。与原始版本相比，以下代码中已去除了对复数信号的特殊处理逻辑（如 MODE_COMPLEX、ndirs、phi 等相关代码），同时尽量保持了函数的输入输出参数定义以及整体结构，以使代码在 MATLAB 中仍能正常运行。

简化后的 `emd.m`

matlab
function [imf,ort,nbits] = emd(varargin)
% EMD Empirical Mode Decomposition for real signals (simplified).
%
% [imf, ort, nbits] = emd(x)
% [imf, ort, nbits] = emd(x, 'MAXITERATIONS', 1000, ...)
%
% 只保留了对实数信号的处理逻辑，移除了对复数信号的相关判断。

    %----------------------------------------------------------------------
    % 初始化：解析输入参数、设置默认值、处理 mask 情况等
    %----------------------------------------------------------------------
    [x,t,sd,sd2,tol,MODE_COMPLEX,ndirs,display_sifting,...
       sdt,sd2t,r,imf,k,nbit,NbIt,MAXITERATIONS,FIXE,FIXE_H,...
       MAXMODES,INTERP,mask] = init(varargin{:});

    %----------------------------------------------------------------------
    % 主循环：逐模态提取，直到满足停止条件或达到最大模态数
    %----------------------------------------------------------------------
    while (~stop_EMD(r) && (k < MAXMODES+1 || MAXMODES == 0) && ~any(mask))
        % 当前待提取的模式
        m = r;
        
        % 先计算当前模式的平均包络和停止准则
        if FIXE
            [stop_sift,moyenne] = stop_sifting_fixe(t,m,INTERP);
        elseif FIXE_H
            stop_count = 0;
            [stop_sift,moyenne] = stop_sifting_fixe_h(t,m,INTERP,stop_count,FIXE_H);
        else
            [stop_sift,moyenne] = stop_sifting(m,t,sd,sd2,tol,INTERP);
        end

        % 如果信号幅值过小，强制退出（避免机器精度导致的虚假极值）
        if (max(abs(m))) < (1e-10)*(max(abs(x)))
            if ~stop_sift
                warning('emd:warning','forced stop of EMD: too small amplitude');
            else
                disp('forced stop of EMD: too small amplitude');
            end
            break
        end

        %--------------------------------------------------------------
        % sifting 过程
        %--------------------------------------------------------------
        while ~stop_sift && nbit < MAXITERATIONS
            % 更新当前模式
            m = m - moyenne;

            % 再次计算包络平均及停止条件
            if FIXE
                [stop_sift,moyenne] = stop_sifting_fixe(t,m,INTERP);
            elseif FIXE_H
                [stop_sift,moyenne,stop_count] = stop_sifting_fixe_h(t,m,INTERP,stop_count,FIXE_H);
            else
                [stop_sift,moyenne,s] = stop_sifting(m,t,sd,sd2,tol,INTERP);
            end

            nbit = nbit + 1;
            NbIt = NbIt + 1;

            % 如果迭代次数过多，强制停止该模态
            if (nbit == (MAXITERATIONS-1) && ~FIXE && nbit > 100)
                if exist('s','var')
                    warning('emd:warning',...
                        ['forced stop of sifting: too many iterations... mode ',int2str(k),'. stop parameter mean value: ',num2str(s)]);
                else
                    warning('emd:warning',...
                        ['forced stop of sifting: too many iterations... mode ',int2str(k),'.']);
                end
            end
        end

        % 将当前模式存储到 imf 中
        imf(k,:) = m;
        if display_sifting
            disp(['mode ',int2str(k),' stored']);
        end
        nbits(k) = nbit;  %#ok<AGROW>
        k = k + 1;

        % 更新剩余量
        r = r - m;
        nbit = 0;
    end

    % 如果还剩余信号且没有 mask，则将其作为最后一个模态
    if any(r) && ~any(mask)
        imf(k,:) = r;
    end

    % 计算正交度（可选）
    ort = io(x, imf);

    % 若显示过 sifting 过程，则关闭相关 figure
    if display_sifting
        close
    end
end

%--------------------------------------------------------------------------
% 只保留对实数信号的极值判断：极值需至少有三个，才继续分解
%--------------------------------------------------------------------------
function stop = stop_EMD(r)
    [indmin,indmax] = extr(r);
    ner = length(indmin) + length(indmax);
    stop = (ner < 3);
end

%--------------------------------------------------------------------------
% 计算上下包络均值以及振幅
%--------------------------------------------------------------------------
function [envmoy,nem,nzm,amp] = mean_and_amplitude(m,t,INTERP)
    NBSYM = 2;
    [indmin,indmax,indzer] = extr(m);
    nem = length(indmin)+length(indmax);
    nzm = length(indzer);

    [tmin,tmax,mmin,mmax] = boundary_conditions(indmin,indmax,t,m,m,NBSYM);
    envmin = interp1(tmin,mmin,t,INTERP);
    envmax = interp1(tmax,mmax,t,INTERP);
    envmoy = (envmin+envmax)/2;
    if nargout > 3
        amp = mean(abs(envmax-envmin),1)/2;
    end
end

%--------------------------------------------------------------------------
% 缺省的停止准则
%--------------------------------------------------------------------------
function [stop,envmoy,s] = stop_sifting(m,t,sd,sd2,tol,INTERP)
    try
        [envmoy,nem,nzm,amp] = mean_and_amplitude(m,t,INTERP);
        sx = abs(envmoy)./amp;
        s = mean(sx);

        % 停止条件
        stop = ~((mean(sx > sd) > tol || any(sx > sd2)) && (nem > 2));
        % 对于实数信号，额外要求零交叉数不能和极值数相差太大
        stop = stop && ~(abs(nzm-nem)>1);
    catch
        stop = 1;
        envmoy = zeros(1,length(m));
        s = NaN;
    end
end

%--------------------------------------------------------------------------
% 固定 sifting 次数 (FIX 模式) 对应的停止准则
%--------------------------------------------------------------------------
function [stop,moyenne] = stop_sifting_fixe(t,m,INTERP)
    try
        moyenne = mean_and_amplitude(m,t,INTERP);
        stop = 0; % 不做自适应停止
    catch
        moyenne = zeros(1,length(m));
        stop = 1;
    end
end

%--------------------------------------------------------------------------
% 固定 sifting 次数 (FIX_H 模式) 对应的停止准则
%--------------------------------------------------------------------------
function [stop,moyenne,stop_count] = stop_sifting_fixe_h(t,m,INTERP,stop_count,FIXE_H)
    try
        [moyenne,nem,nzm] = mean_and_amplitude(m,t,INTERP);
        if (abs(nzm-nem)>1)
            stop = 0;
            stop_count = 0;
        else
            stop_count = stop_count+1;
            stop = (stop_count == FIXE_H);
        end
    catch
        moyenne = zeros(1,length(m));
        stop = 1;
    end
end

%--------------------------------------------------------------------------
% 边界延拓，获取插值需要的额外端点
%--------------------------------------------------------------------------
function [tmin,tmax,zmin,zmax] = boundary_conditions(indmin,indmax,t,x,z,nbsym)
    lx = length(x);
    if (length(indmin)+length(indmax) < 3)
        error('not enough extrema');
    end

    % 左右边界处理
    if indmax(1) < indmin(1)
        if x(1) > x(indmin(1))
            lmax = fliplr(indmax(2:min(end,nbsym+1)));
            lmin = fliplr(indmin(1:min(end,nbsym)));
            lsym = indmax(1);
        else
            lmax = fliplr(indmax(1:min(end,nbsym)));
            lmin = [fliplr(indmin(1:min(end,nbsym-1))),1];
            lsym = 1;
        end
    else
        if x(1) < x(indmax(1))
            lmax = fliplr(indmax(1:min(end,nbsym)));
            lmin = fliplr(indmin(2:min(end,nbsym+1)));
            lsym = indmin(1);
        else
            lmax = [fliplr(indmax(1:min(end,nbsym-1))),1];
            lmin = fliplr(indmin(1:min(end,nbsym)));
            lsym = 1;
        end
    end

    if indmax(end) < indmin(end)
        if x(end) < x(indmax(end))
            rmax = fliplr(indmax(max(end-nbsym+1,1):end));
            rmin = fliplr(indmin(max(end-nbsym,1):end-1));
            rsym = indmin(end);
        else
            rmax = [lx,fliplr(indmax(max(end-nbsym+2,1):end))];
            rmin = fliplr(indmin(max(end-nbsym+1,1):end));
            rsym = lx;
        end
    else
        if x(end) > x(indmin(end))
            rmax = fliplr(indmax(max(end-nbsym,1):end-1));
            rmin = fliplr(indmin(max(end-nbsym+1,1):end));
            rsym = indmax(end);
        else
            rmax = fliplr(indmax(max(end-nbsym+1,1):end));
            rmin = [lx,fliplr(indmin(max(end-nbsym+2,1):end))];
            rsym = lx;
        end
    end

    tlmin = 2*t(lsym)-t(lmin);
    tlmax = 2*t(lsym)-t(lmax);
    trmin = 2*t(rsym)-t(rmin);
    trmax = 2*t(rsym)-t(rmax);

    zlmax = z(lmax);
    zlmin = z(lmin);
    zrmax = z(rmax);
    zrmin = z(rmin);

    tmin = [tlmin t(indmin) trmin];
    tmax = [tlmax t(indmax) trmax];
    zmin = [zlmin z(indmin) zrmin];
    zmax = [zlmax z(indmax) zrmax];
end

%--------------------------------------------------------------------------
% 寻找极值点 (只针对实信号)
%--------------------------------------------------------------------------
function [indmin, indmax, indzer] = extr(x,t)
    if nargin==1
        t = 1:length(x);
    end

    m = length(x);

    if nargout > 2
        x1 = x(1:m-1);
        x2 = x(2:m);
        indzer = find(x1.*x2<0);

        % 若存在恰好为 0 的点
        if any(x == 0)
            iz = find(x==0);
            indz = [];
            if any(diff(iz)==1)
                zer = (x == 0);
                dz = diff([0 zer 0]);
                debz = find(dz == 1);
                finz = find(dz == -1)-1;
                indz = round((debz+finz)/2);
            else
                indz = iz;
            end
            indzer = sort([indzer indz]);
        end
    end

    d = diff(x);
    n = length(d);
    d1 = d(1:n-1);
    d2 = d(2:n);
    indmin = find(d1.*d2<0 & d1<0)+1;
    indmax = find(d1.*d2<0 & d1>0)+1;

    % 连续平值区间处理
    if any(d==0)
        imax = [];
        imin = [];
        bad = (d==0);
        dd = diff([0 bad 0]);
        debs = find(dd == 1);
        fins = find(dd == -1);

        if ~isempty(debs)
            if debs(1) == 1
                if length(debs)>1
                    debs = debs(2:end);
                    fins = fins(2:end);
                else
                    debs = [];
                    fins = [];
                end
            end
        end

        if ~isempty(debs)
            if fins(end) == m
                if length(debs)>1
                    debs = debs(1:end-1);
                    fins = fins(1:end-1);
                else
                    debs = [];
                    fins = [];
                end
            end
        end

        lc = length(debs);
        if lc > 0
            for k = 1:lc
                if d(debs(k)-1) > 0
                    if d(fins(k)) < 0
                        imax = [imax round((fins(k)+debs(k))/2)];
                    end
                else
                    if d(fins(k)) > 0
                        imin = [imin round((fins(k)+debs(k))/2)];
                    end
                end
            end
        end
        if ~isempty(imax)
            indmax = sort([indmax imax]);
        end
        if ~isempty(imin)
            indmin = sort([indmin imin]);
        end
    end
end

%--------------------------------------------------------------------------
% 计算正交度（可选）
%--------------------------------------------------------------------------
function ort = io(x,imf)
    n = size(imf,1);
    s = 0;
    for i = 1:n
        for j = 1:n
            if i ~= j
                s = s + abs(sum(imf(i,:).*imf(j,:)) / sum(x.^2));
            end
        end
    end
    ort = 0.5 * s;
end

%--------------------------------------------------------------------------
% 初始化函数：处理输入参数，设置默认值
%--------------------------------------------------------------------------
function [x,t,sd,sd2,tol,MODE_COMPLEX,ndirs,display_sifting,...
          sdt,sd2t,r,imf,k,nbit,NbIt,MAXITERATIONS,FIXE,FIXE_H,...
          MAXMODES,INTERP,mask] = init(varargin)

    % 1) 取第一个参数为信号 x
    x = varargin{1};
    
    % 2) 解析后续参数
    if nargin == 2
        if isstruct(varargin{2})
            inopts = varargin{2};
        else
            error('When using 2 arguments, the second one must be a struct of options.');
        end
    elseif nargin > 2
        try
            inopts = struct(varargin{2:end});
        catch
            error('Bad argument syntax: check name-value pairs.');
        end
    else
        inopts = struct();
    end

    % 默认停止准则参数
    defstop = [0.05, 0.5, 0.05];

    % 可能的字段
    opt_fields = {'t','stop','display','maxiterations','fix','maxmodes','interp',...
                  'fix_h','mask','ndirs','complex_version'};

    % 设定默认选项
    defopts.stop           = defstop;
    defopts.display        = 0;
    defopts.t              = 1:max(size(x));
    defopts.maxiterations  = 2000;
    defopts.fix            = 0;
    defopts.maxmodes       = 0;
    defopts.interp         = 'spline';
    defopts.fix_h          = 0;
    defopts.mask           = 0;
    % 下面两个对实数而言没有实际作用了，但保留作为占位
    defopts.ndirs          = 4;  
    defopts.complex_version= 2;

    opts = defopts;

    % 根据 inopts 更新 opts
    names = fieldnames(inopts);
    for nom = names'
        if ~any(strcmpi(char(nom), opt_fields))
            error(['Bad option field name: ',char(nom)]);
        end
        val = eval(['inopts.',char(nom),';']);
        if ~isempty(val)
            eval(['opts.',lower(char(nom)),' = val;']);
        end
    end

    % 赋值
    t             = opts.t;
    stop          = opts.stop;
    display_sifting  = opts.display;
    MAXITERATIONS = opts.maxiterations;
    FIXE          = opts.fix;
    MAXMODES      = opts.maxmodes;
    INTERP        = opts.interp;
    FIXE_H        = opts.fix_h;
    mask          = opts.mask;
    ndirs         = opts.ndirs;           %#ok<NASGU> 
    complex_version = opts.complex_version; %#ok<NASGU> 
    MODE_COMPLEX  = 0;  % 对实信号强制设为0
    
    % 确保 x 是行向量
    if ~isvector(x)
        error('X must be a 1-D vector.');
    end
    if size(x,1) > 1
        x = x.';
    end

    % 时间向量 t 也是行向量
    if ~isvector(t)
        error('Option field T must be a 1-D vector.');
    end
    if size(t,1) > 1
        t = t';
    end
    if length(t) ~= length(x)
        error('X and T must have the same length.');
    end
    if ~isvector(stop) || length(stop) > 3
        error('Option field STOP must be a vector of up to 3 elements.');
    end
    if any(~isfinite(x))
        error('Data elements in X must be finite.');
    end
    
    L = length(stop);
    if L < 3
        stop(3)=defstop(3);
    end
    if L < 2
        stop(2)=defstop(2);
    end

    if ~ischar(INTERP) || ~any(strcmpi(INTERP,{'linear','cubic','spline','pchip'}))
        error('INTERP must be ''linear'', ''cubic'', ''spline'', or ''pchip''.');
    end

    % 如果有 mask 信号
    if any(mask)
        if ~isvector(mask) || length(mask) ~= length(x)
            error('Mask signal must have same dimension as X.');
        end
        if size(mask,1) > 1
            mask = mask.';
        end
        % 直接调用两次 EMD，得到叠加结果（此段保留）
        opts.mask = 0;
        imf1 = emd(x+mask, opts);
        imf2 = emd(x-mask, opts);
        if size(imf1,1) ~= size(imf2,1)
            warning('emd:warning',...
                ['The two sets of IMFs have different sizes: ',...
                int2str(size(imf1,1)), ' and ', int2str(size(imf2,1)),' IMFs.']);
        end
        S1 = size(imf1,1);
        S2 = size(imf2,1);
        if S1 ~= S2
            if S1 < S2
                tmp = imf1; imf1 = imf2; imf2 = tmp;
            end
            imf2(max(S1,S2),1) = 0;
        end
        imf = (imf1 + imf2)/2;
    else
        imf = [];
    end

    sd  = stop(1);
    sd2 = stop(2);
    tol = stop(3);

    lx = length(x);
    sdt  = sd*ones(1,lx);
    sd2t = sd2*ones(1,lx);

    if FIXE
       MAXITERATIONS = FIXE;
       if FIXE_H
           error('Cannot use both ''fix'' and ''fix_h'' modes simultaneously.');
       end
    end

    r      = x;
    k      = 1;      % 模态计数
    nbit   = 0;      % 当前模态迭代次数
    NbIt   = 0;      % 总迭代次数
end

简化后的 `ceemd.m`

matlab
function [modos, its] = ceemd(x, Nstd, NR, MaxIter)
% CEEMD Complete Ensemble EMD for real signals (simplified).
%
% [modos, its] = ceemd(x, Nstd, NR, MaxIter)
%
% 仅保留实数信号处理逻辑，不再考虑复数的情况。
% 调用上述简化后的 emd.m 进行逐次分解。

    % 1. 计算输入信号的标准差并归一化
    desvio_estandar = std(x); 
    x = x / desvio_estandar; 

    % 2. 初始化
    modos = zeros(length(x), 0); % 存放最终各阶模态的矩阵
    iter = [];  % 记录每次分解(噪声/负噪声)的迭代次数

    % 3. 进行多次加噪并 EMD 分解
    for i = 1:NR
        % 生成带正噪声的信号
        xconruido_pos = x + Nstd * randn(size(x));
        % 生成带负噪声的信号
        xconruido_neg = x - Nstd * randn(size(x));

        % 对带正噪声信号进行 EMD
        [temp_pos, ~, it_pos] = emd(xconruido_pos, 'MAXITERATIONS', MaxIter); 
        % 对带负噪声信号进行 EMD
        [temp_neg, ~, it_neg] = emd(xconruido_neg, 'MAXITERATIONS', MaxIter); 

        % 保证正负噪声的模态分解矩阵行数相同
        [rows_pos, cols_pos] = size(temp_pos);
        [rows_neg, cols_neg] = size(temp_neg);
        if rows_pos < rows_neg
            temp_pos = [temp_pos; zeros(rows_neg - rows_pos, cols_pos)];
        elseif rows_pos > rows_neg
            temp_neg = [temp_neg; zeros(rows_pos - rows_neg, cols_neg)];
        end

        % 平均正负噪声结果
        temp = (temp_pos + temp_neg) / 2;

        % 整理迭代次数为列向量
        it_pos = it_pos(:); 
        it_neg = it_neg(:); 
        iter = [iter; it_pos; it_neg]; %#ok<AGROW>

        % 若第一次循环，直接初始化 modos
        if i == 1
            modos = temp;
        else
            [filas, ~] = size(modos);
            [new_filas, ~] = size(temp);
            % 行数不一致则补零
            if new_filas > filas
                modos = [modos; zeros(new_filas - filas, size(modos,2))];
            elseif filas > new_filas
                temp = [temp; zeros(filas - new_filas, size(temp,2))];
            end
            % 累加
            modos = modos + temp;
        end
    end

    % 4. 分解完后，乘回原标准差，恢复原幅值尺度
    modos = modos * desvio_estandar;

    % 5. 返回所有迭代信息
    its = iter;
end

说明

保留了原函数的输入/输出参数：
- emd.m: 入口函数依然是 [imf, ort, nbits] = emd(...)，并保留了原先各处调用的子函数名字及功能。
- ceemd.m: 入口函数依然是 [modos, its] = ceemd(x, Nstd, NR, MaxIter)。
对复数信号的处理已去除：
- 在 emd.m 中的 MODE_COMPLEX、complex_version、ndirs 虽然在 init 函数里仍以参数形式存在，但都设置成对实数无效的默认值（例如 MODE_COMPLEX = 0），并且在代码主体中去除了“if MODE_COMPLEX”等分支逻辑。
- 对于 ceemd.m，仅保留对实数信号分解所需的部分。
边界插值、极值检测、停止准则 等常用功能仍然保留，用于实数信号的 EMD 分解。
保持与 MATLAB 的兼容：
- 经过精简后，代码仍旧可以使用 emd(...) 和 ceemd(...) 的原有方式进行调用。
- 注意要将以上两个文件放到同一路径下，以便 ceemd.m 能够正确调用 emd.m。

这样，你就得到一个针对实数信号且更简洁的 EMD/CEEMD 版本，不会再出现与复数处理相关的冗余逻辑。希望能帮到你!

Answer 2

下面给出一个进一步精简的 EMD/CEEMD 实现示例，仅针对实数的电压或电流类信号进行分解，去除了许多不常用的功能（例如：掩膜信号、复数版本、固定迭代次数模式、复杂的边界拓展、正交度计算等）。这样的版本更方便在一些对资源受限的场合（如硬件移植）中使用，同时也保持了自定义函数的形式，不依赖任何第三方库。

说明

该代码仅是一个示例，并非最严谨或最完整的 EMD/CEEMD 实现。它倾向于精简易懂，可在此基础上根据实际需求进行适度调整。

这里的边界插值只做了最简单的处理（直接在端点向外延拓），在某些极端情况下可能影响分解精度；若对分解精度有较高要求，可以在此处换成更复杂的边界延拓策略。

代码中为了演示，保留了若干注释与提示，实际硬件移植时可去除注释与多余的 disp、warning 等命令，以进一步缩减体积。

一、EMD 函数 (emd.m)

下面的代码放在一个独立的文件 emd.m 中：

matlab
function [imfs] = emd(x, maxIter, sd, tol)
% EMD  Empirical Mode Decomposition (simplified for real signals).
%
%   imfs = emd(x)
%   imfs = emd(x, maxIter)
%   imfs = emd(x, maxIter, sd, tol)
%
% 输入参数：
%   x       : 待分解的实数信号（行或列向量）
%   maxIter : sifting 最大迭代次数，默认 1000
%   sd      : 停止准则阈值的一部分 (默认值 0.2，可按需调整)
%   tol     : 停止准则中的容忍度 (默认值 0.05，可按需调整)
%
% 输出参数：
%   imfs    : 分解得到的本征模态函数(若干行)，行数即模态数

    % -----------------------------
    % 1) 参数初始化及默认值
    % -----------------------------
    if nargin < 4, tol = 0.05; end
    if nargin < 3, sd  = 0.2;  end
    if nargin < 2, maxIter = 1000; end
    
    % 确保 x 为行向量
    x = x(:).';  
    N = length(x);

    % 存放最终 IMFs 的矩阵（行数未知，先预分配一点空间）
    imfs = zeros(0, N);

    % 剩余量(初始为原信号)
    r = x;  
    % 最少需要 3 个极值才能继续分解
    while hasEnoughExtrema(r)
        %------------------------------------------------------------------
        % 提取当前 IMF
        %------------------------------------------------------------------
        m = r;          % 当前要被分离出来的模态
        iterCount = 0;  % sifting 的迭代计数
        
        % 进入 sifting 迭代
        while iterCount < maxIter
            iterCount = iterCount + 1;
            
            % 1) 计算上下包络的平均值
            meanEnvelope = getMeanEnvelope(m);

            % 2) 更新模态
            mNew = m - meanEnvelope;
            
            % 3) 判断是否满足停止准则
            if checkStopCriterion(m, mNew, sd, tol)
                m = mNew;
                break;
            end

            % 若未满足停止条件，继续下一次迭代
            m = mNew;
        end

        % 将当前模态从剩余量中扣除
        r = r - m;

        % 记录该 IMF
        imfs(end+1, :) = m;  %#ok<AGROW>
        
        % 如果剩余量已经近似为零或极小，可认为分解结束
        if max(abs(r)) < 1e-12
            break;
        end
    end

    % 如果循环结束后还剩下一些 r，可当作最后一个 IMF
    if any(abs(r) > 1e-12)
        imfs(end+1, :) = r;
    end
end

%------------------------
% 判断是否有足够的极值
%------------------------
function flag = hasEnoughExtrema(sig)
    [indMin, indMax] = findExtrema(sig);
    % 只要极大极小数总和 >= 3 才继续
    if (length(indMin) + length(indMax)) >= 3
        flag = true;
    else
        flag = false;
    end
end

%-----------------------------------
% 获取信号的上下包络平均值 meanEnvelope
%-----------------------------------
function envMean = getMeanEnvelope(sig)
    N = length(sig);
    
    % 1) 找极大极小点
    [indMin, indMax] = findExtrema(sig);

    % 若极值点过少，直接返回零
    if (length(indMin) + length(indMax)) < 2
        envMean = zeros(1, N);
        return;
    end

    % 2) 获得插值需要的坐标值
    %    这里做一个非常简化的“边界延拓”，即：把端点当作极值处理
    if isempty(indMin) || indMin(1) > 1
        indMin = [1, indMin];
    end
    if isempty(indMin) || indMin(end) < N
        indMin = [indMin, N];
    end
    if isempty(indMax) || indMax(1) > 1
        indMax = [1, indMax];
    end
    if isempty(indMax) || indMax(end) < N
        indMax = [indMax, N];
    end

    % 3) 计算上下包络
    xInd = 1:N; 
    envMin = interp1(indMin, sig(indMin), xInd, 'spline');
    envMax = interp1(indMax, sig(indMax), xInd, 'spline');

    % 4) 取均值
    envMean = (envMin + envMax) / 2;
end

%-----------------------------------
% 判断停止准则 (Rilling & Flandrin 经典思路的简化版)
%-----------------------------------
function stopFlag = checkStopCriterion(mOld, mNew, sd, tol)
    % mOld: 上一轮的 IMF
    % mNew: 新一轮迭代后的 IMF
    % sd 和 tol: 用户控制的阈值

    % 计算变化率
    eps = sum((mOld - mNew).^2) / (sum(mOld.^2) + 1e-12);

    % 如果变化率小于一定阈值，就可以停止
    cond1 = (eps < tol);

    % 也可结合上下包络占比判断，这里只做最简处理
    % 例如 cond2 = ...

    % 最终判断：只用 cond1
    stopFlag = cond1;
end

%-----------------------------------
% 寻找极值点
%-----------------------------------
function [indMin, indMax] = findExtrema(sig)
    d = diff(sig);
    N = length(sig);

    % 先简单判定极大/极小
    indMax = find(d(1:end-1) > 0 & d(2:end) < 0) + 1;
    indMin = find(d(1:end-1) < 0 & d(2:end) > 0) + 1;

    % 为了避免长时间平值区段，这里不做复杂处理
    % 有需要可以加上平值区间的特殊判定
    % ...
    
    % 安全性：如果首末端明显比周围大/小，也可视为极值
    if sig(1) > sig(2)
        indMax = [1, indMax];
    elseif sig(1) < sig(2)
        indMin = [1, indMin];
    end
    if sig(N) > sig(N-1)
        indMax = [indMax, N];
    elseif sig(N) < sig(N-1)
        indMin = [indMin, N];
    end
end

使用方法示例：

matlab
% 假设我们有一个电流信号 i(t)，长度为 1000
iSig = ... % 你的电流数据

% 直接使用默认参数进行分解
imfs = emd(iSig);

% 或者手动指定最大迭代次数、sd、tol
imfs = emd(iSig, 2000, 0.3, 0.05);

% imfs 是一个二维矩阵，每一行代表一个 IMF 模态
figure; 
for k=1:size(imfs,1)
    subplot(size(imfs,1),1,k);
    plot(imfs(k,:));
    title(['IMF #',num2str(k)]);
end

二、CEEMD 函数 (ceemd.m)

下面给出一个简化版的 CEEMD（Complete Ensemble EMD），它调用上述的 emd.m 来进行每一次的加噪分解。请将其放在单独文件 ceemd.m 中：

matlab
function [modes] = ceemd(x, Nstd, NR, maxIter, sd, tol)
% CEEMD  Complete Ensemble EMD for real signals (simplified).
%
%   modes = ceemd(x, Nstd, NR)
%   modes = ceemd(x, Nstd, NR, maxIter, sd, tol)
%
% 输入参数：
%   x        : 待分解的实数信号(行/列向量)
%   Nstd     : 加噪声的标准差倍数 (典型值 0.1 ~ 0.4)
%   NR       : 加噪声的重复次数
%   maxIter  : 每次 EMD 的最大迭代次数（默认 1000）
%   sd, tol  : EMD 停止准则的辅助参数（默认 0.2, 0.05）
%
% 输出：
%   modes    : 最终得到的模态均值 (各行对应一个 IMF)

    if nargin < 6, tol = 0.05; end
    if nargin < 5, sd = 0.2;   end
    if nargin < 4, maxIter = 1000; end

    % 1) 对输入信号做归一化处理 (防止噪声尺度不好控制)
    orig_std = std(x);
    if orig_std < 1e-12
        warning('Signal standard deviation is too small, results may be inaccurate.');
        orig_std = 1.0;
    end
    x = x(:).'/orig_std;  % 转为行向量并归一化

    % 2) 用来累加所有（正/负噪声）分解结果的矩阵
    %   注意：不同次 EMD 得到的 IMF 数目可能不同，需在后面对齐
    sumModes = [];

    % 3) 噪声叠加 EMD
    for k = 1:NR
        % 生成正噪声与负噪声
        noisePos = Nstd * randn(size(x));
        noiseNeg = Nstd * randn(size(x));  % 这里也可用同一噪声取负

        % 带正/负噪声的信号
        xPos = x + noisePos;
        xNeg = x - noiseNeg;

        % 分别做 EMD
        imfsPos = emd(xPos, maxIter, sd, tol);
        imfsNeg = emd(xNeg, maxIter, sd, tol);

        % 对齐行数（IMF 数）并求平均
        [imfsPos, imfsNeg] = unifyIMFrows(imfsPos, imfsNeg);
        imfsThisRound = (imfsPos + imfsNeg) / 2;

        % 累加
        [sumModes, imfsThisRound] = unifyIMFrows(sumModes, imfsThisRound);
        sumModes = sumModes + imfsThisRound;
    end

    % 4) 全部结束后，取平均，并恢复原幅度
    if ~isempty(sumModes)
        modes = (sumModes / NR) * orig_std;
    else
        modes = x * orig_std;  % 若分解失败，就仅返回原信号
    end
end

%--------------------------------------------
% 将两个 IMF 矩阵统一为相同行数，以便相加或比较
%--------------------------------------------
function [Aout, Bout] = unifyIMFrows(A, B)
    rA = size(A,1);
    rB = size(B,1);
    cA = size(A,2);
    cB = size(B,2);

    % 以列数大的为准
    C = max(cA, cB);

    % 若 A 或 B 为空，则补零
    if isempty(A)
        A = zeros(0, C);
        rA = 0;
        cA = C;
    elseif cA < C
        A = [A, zeros(rA, C - cA)];
    end
    
    if isempty(B)
        B = zeros(0, C);
        rB = 0;
        cB = C;
    elseif cB < C
        B = [B, zeros(rB, C - cB)];
    end

    % 行数补齐
    rMax = max(rA, rB);
    if rA < rMax
        A = [A; zeros(rMax - rA, C)];
    end
    if rB < rMax
        B = [B; zeros(rMax - rB, C)];
    end

    Aout = A;
    Bout = B;
end

简单示例：

matlab
% 生成一个电压信号的模拟数据(混合多个频率)
fs = 1000;
t  = (0:fs-1)/fs;
v  = sin(2*pi*50*t) + 0.3*sin(2*pi*100*t) + 0.1*randn(size(t));

% 使用 CEEMD
modes_ceemd = ceemd(v, 0.2, 50, 500, 0.2, 0.05);

% 绘制结果
figure;
for k=1:size(modes_ceemd,1)
    subplot(size(modes_ceemd,1),1,k);
    plot(modes_ceemd(k,:));
    title(['CEEMD: Mode #', num2str(k)]);
end

三、进一步精简的可能性

去除插值边界延拓
在上面的 emd.m 中，对于上下包络的插值，我们仅做了一个最简单的“把端点视作极值”。你也可以完全去掉这一步，让插值只基于真实找到的极值点，但这样极容易在边缘处发生插值失败或插值失真问题。若真的要再简化，可去掉对端点的特殊处理，代码会更短，但边缘效果会更糟。
固定插值方法
目前示例中插值使用 'spline'，你也可以改成 'linear' 并去掉对插值方法的可选性。
去除一些安全判断 / 提示
例如检测标准差过小、在 checkStopCriterion 中给 +1e-12 这种防止除零错误的保护，以及各种 warning、disp。在硬件实现中，若资源很紧张，可以全部去掉以缩减体积。
去除 CEEMD 中的“正/负噪声平均”
CEEMD 之所以需要对同一幅度的正噪声和负噪声分别分解再求平均，是为了更好地消除噪声偏差。若你的应用对精度要求不高，可只加正噪声，去掉负噪声那一半，这样能再省下一些计算。
合并文件
如果方便维护，可以把 emd.m 和 ceemd.m 中的子函数都写在一个大文件里，也可以进一步内联函数。不过从代码清晰度角度，拆成两个文件常见且直观。

以上即为一个简洁的、纯 MATLAB 代码、仅针对 实数信号 的 EMD/CEEMD 方案示例。若还需更进一步的“极简”，可以继续删减上述提到的功能或保护性代码，根据自己对分解精度、数值稳定性的需求，来决定要不要保留。祝移植顺利!

Answer 3

下面给出一个分段对比的说明，帮助你了解「你现在贴出的这份代码」与「我第一次给出的简化版 EMD/CEEMD 代码」之间有哪些精简和改动。由于你给出的这份代码（下文称为「原始代码」）包含很多对复数信号、掩膜信号、多种停止准则（FIX/FIX_H）以及边界扩展的完整逻辑，而我在第一次给出的简化代码中，对这些不需要的功能做了大量删除或合并。以下按照主要功能模块进行对比说明。

1. 文件结构与函数接口

原始代码

代码在一个文件 emd.m 中定义了非常多的子函数（如 stop_EMD、mean_and_amplitude、stop_sifting_fixe、boundary_conditions 等）并且还含有一个名为 init 的初始化函数。
还有部分与 CEEMD 配合使用的结构，例如是否有 mask、是否是 MODE_COMPLEX 分析等等。
入口函数是 function [imf,ort,nbits] = emd(varargin)，返回 IMF、正交度 ort 和迭代次数 nbits。

第一次简化版

大幅缩减了代码，只保留了对实数信号进行 EMD 的核心逻辑。
将大部分子函数（特别是针对复数信号、掩膜等逻辑）删除。
不再返回正交度 ort 和迭代次数 nbits，直接将核心 EMD 结果（IMFs）作为输出。
不再依赖复杂的 init，而是直接把初始化过程合并到开头（设置 maxIter、sd、tol 等简单参数）。

简而言之：第一次的简化版把「EMD」的入口函数和关键步骤放在一个相对短小的 emd.m 中，不包含对复数、掩膜、各种停机准则（FIX/FIX_H）等特殊场景的处理。这样可以让代码更易读、也更容易在硬件环境中移植。

2. 主循环部分（提取 IMF 的流程）

原始代码

matlab
while (~stop_EMD(r,MODE_COMPLEX,ndirs) && (k < MAXMODES+1 || MAXMODES == 0) && ~any(mask))
    ...
    % 1) 先根据 stop_sifting_fixe / stop_sifting_fixe_h / stop_sifting 等不同函数计算包络均值
    % 2) 如果当前模态幅值太小则强制停止
    % 3) 进入 sifting 循环，可能打印 mode/iteration 等日志信息
    % 4) 不同情况下使用 stop_sifting_fixe / stop_sifting_fixe_h / stop_sifting 进行判断
    ...
    % 5) 存储 IMF 到 imf(k,:)，更新剩余信号 r
end

判断条件非常复杂：既要检查是否不足 3 个极值(stop_EMD)，又要看 k < MAXMODES+1 || MAXMODES == 0，还要看 ~any(mask)，还涉及 MODE_COMPLEX。
sifting 循环里又有对 FIXE、FIXE_H、MAXITERATIONS、nbit > 100 的各种分支。
在每次迭代中还会输出大量 debug 信息。

第一次简化版

matlab
while hasEnoughExtrema(r)
    m = r;
    iterCount = 0;
    while iterCount < maxIter
        meanEnvelope = getMeanEnvelope(m);
        mNew = m - meanEnvelope;
        if checkStopCriterion(m, mNew, sd, tol)
            m = mNew;
            break;
        end
        m = mNew;
        iterCount = iterCount + 1;
    end
    r = r - m;
    imfs(end+1,:) = m;
    if max(abs(r)) < 1e-12
        break;
    end
end

只保留了最基本的“极值是否大于 3” (hasEnoughExtrema) 来继续分解的判断。
删除了所有和 FIXE、FIXE_H、mask、MODE_COMPLEX、MAXMODES 等逻辑相关的判断，直接地判断极值足够且幅值没接近 0，就继续分解。
sifting 的循环也只保留了一个核心：
1. 计算包络平均 meanEnvelope
2. mNew = m - meanEnvelope
3. 判断停止条件 → 若满足则退出，否则继续
不再有复杂的日志输出或迭代次数限制提醒；只保留一个简单的 iterCount < maxIter 防止无限循环。

3. 针对复数信号 (MODE_COMPLEX) 和多方向 (ndirs)

原始代码

几乎在每个函数里都能看到 if MODE_COMPLEX ... else ... end 之类的分支。还会在 mean_and_amplitude 中对不同 phi 方向取实部或进行旋转插值。
需要用户提供 ndirs (缺省值 4) 以及 complex_version (1 或 2)，对复数进行不同处理。

第一次简化版

完全删除对复数/多方向的所有处理。
不保留 MODE_COMPLEX、ndirs、phi 之类的参数，也不在函数里做分支判断。
一律只支持实数信号 x。

4. 针对掩膜信号 (mask)

原始代码

在 init 里，如果用户提供了 mask，要调用两次 emd(x+mask) 和 emd(x-mask) 并把结果平均。
在主循环里，还要判断 ~any(mask) 以决定是否继续分解。

第一次简化版

完全删除对掩膜信号的任何支持。
也就不再在初始化过程里做 “如果有 mask，再调用两次 EMD” 的操作。

5. 各种停止准则 (stop_sifting_fixe, stop_sifting_fixe_h, stop_sifting)

原始代码

定义了多个函数 stop_sifting_fixe, stop_sifting_fixe_h, stop_sifting，以及在主循环、sifting 循环里根据 FIXE, FIXE_H 分别调用它们。
stop_sifting_fixe 就是“永远不主动停”，只靠固定迭代次数；
stop_sifting_fixe_h 里还会对计数器 stop_count 做逻辑；
stop_sifting 做复杂的振幅比率等判断。

第一次简化版

只保留了一个 checkStopCriterion 函数(相当于 stop_sifting 的简化体)，里面只做最基本的「判断 IMF 新旧差异是否足够小」。
所有 FIXE、FIXE_H 等模式均被移除，这样就不再有那些额外的计数器和复杂判断流程。

6. 边界扩展与插值 (boundary_conditions)

原始代码

有一个相当复杂的 boundary_conditions 函数，用于镜像对称；要确保左右两端有足够的极值点，可反转 indmax / indmin 并加各种检查，防止插值超出边界。
在 mean_and_amplitude 中，会先调用 boundary_conditions 再用 interp1(..., INTERP) 获取上下包络；
支持 linear、cubic、spline、pchip 等插值方法（通过 INTERP 字段）。

第一次简化版

删除了「镜像对称」等复杂边界操作，只做了最简单的处理：
- 在 getMeanEnvelope 里，若极值不够，就直接返回 0 向量；
- 简单地把端点(1 和 N) 强行视作极大或极小，使得 interp1 不至于出错；
- 固定使用 'spline'（或 'linear'），不再对插值方法做可配置。
这样大大简化了插值前的边界延拓逻辑。

7. 提取极值点 (extr)

原始代码

extr 函数里要考虑到零交点、连续平值区间等情况，处理非常细致。
若 nargout > 2 则计算零交点 indzer，否则不算。
还有针对连续等值点时只取中间点的逻辑。

第一次简化版

同样做了大幅删减：
- 保留最基础的极大值 indMax、极小值 indMin 判定，不再处理复杂的“连续平值区间”或“零交点”判断；
- 较短的实现即可满足多数实际场景下的 EMD 分解需求。

8. 输出正交度 (io) 与迭代次数 (nbits)

原始代码

在主函数末尾，调用 ort = io(x, imf) 计算正交度；
nbits 记录每个模态的 sifting 迭代次数。
io 函数对所有 IMFs 两两内积计算正交度。
nbits 在很多地方用来提示/警告“过多迭代次数”。

第一次简化版

直接删除了正交度的计算和 nbits 的记录。对大多数 EMD 应用而言，这些不是刚需。
如果用户需要，可自行在外部计算正交性或统计迭代次数。

9. `init` 函数和参数解析

原始代码 (init)

负责解析 varargin，容纳 stop、t、maxiterations、fix、maxmodes、interp、mask、ndirs、complex_version 等字段；
对 FIXE/FIXE_H、MODE_COMPLEX 做各种初始化；
同时还把掩膜操作提前做了 imf1 = emd(x+mask, opts), imf2 = emd(x-mask, opts) 的结果合并。

第一次简化版

不再有专门的 init 函数。所有初始化在 emd.m 顶部通过 nargin 判断完成：
- function [imfs] = emd(x, maxIter, sd, tol) ...
- 如果用户不传 maxIter、sd、tol，就用默认值；
- 不需要再做大量字段名校验，因为只留了这几个简单参数。
不再处理 mask、ndirs、complex_version 等，与复数或掩膜有关的逻辑统统删除。

结论

主要精简点：
1. 移除复数模式 (MODE_COMPLEX) 和方向数 (ndirs)
2. 移除掩膜 (mask) 及相关逻辑
3. 合并/删除多种停止准则：FIXE、FIXE_H、标准 sifting → 只留一个简单的停机判定
4. 简化边界条件：不再做复杂的镜像插值，只做最基本的处理
5. 删除正交度 (io) 和迭代次数 (nbits) 的输出
6. 不再有专门的 init：初始化过程直接写在函数开头
7. 不再频繁打印调试信息：如 “mode x, iteration y” 等
收益：代码更短、更清晰、更适合在硬件端部署，只需关注实数信号、基本 EMD 框架以及一个简单的停机判定即可。

以上就是两份代码的对应段落的主要差异和精简逻辑。希望能帮你清晰了解，第一次简化版核心思路是「去掉不必要的功能并合并核心流程」，从而使 EMD 对于电压/电流等实数信号的应用更加简洁、易读，也更适合在资源受限的环境中运行。

Answer 4

下面给你一个针对实数信号的 EMD 代码示例，只移除了和复数信号相关的部分，同时保留了原本复杂的边界延拓逻辑（以尽量减小边界效应带来的失真），并去除了调试信息。另外，保留了固定迭代次数（FIXE）和固定模态数（MAXMODES）等常用功能；对于“FIXE_H”模式，如果你不需要，可直接删去相关函数。关于初始化子程序 init，下面我展示了一个单文件版本，你可以根据需要，将 init 独立出来，或直接把初始化写在 emd 开头。

一、修改要点与说明

删除所有与复数信号 (MODE_COMPLEX) 相关的代码
- 不再区分 MODE_COMPLEX 的各种情况，也不再使用 ndirs。
- mean_and_amplitude、stop_EMD 等函数不再根据 MODE_COMPLEX 做分支，只保留实数逻辑。
保留原本的“边界扩展”
- boundary_conditions 函数仍保持原有的“镜像对称”方式，以减少边缘插值失真。
- 这样可以最大程度保持对边缘的准确插值，提升分解精度。
**保留“固定迭代次数”（FIXE）**与“固定模态数”（MAXMODES）并行
- 这样，当你指定 FIXE，则单个 IMF 的 sifting 会在固定迭代次数后停止；当你指定 MAXMODES，则最多分解出指定数量的 IMF。
移除或精简了调试日志
- 原先在 sifting 循环中，会打印 mode x, iteration y、stop parameter mean value : ... 等信息，现全部删除。
- 若日后想要打印，可以自行在循环里加几行简单的 disp 即可。
保留 FIXE_H 与否
- 代码里我给了示例，如果你不再需要 “FIXE_H” 这一模式，可整段删去 stop_sifting_fixe_h 及相关调用。这里我默认删掉了，因为你说主要想用固定迭代次数（FIXE）或固定模态数（MAXMODES）。
“init” 子函数
- 我在下面的示例依旧保留 init，这样可让配置逻辑更清晰；若你觉得不需要，可以把它合并到 emd 的开头。
保留了“正交性指数” (io)
- 如果你并不关心 IMF 之间的正交度，可以将 ort = io(...) 及对应子函数 io 删去。这里演示保留的版本。

二、示例代码

你可以将下面的所有内容放在一个文件（如 emd.m）里；或者把 init、boundary_conditions、extr 等子函数独立拆分，但要确保它们能被主函数访问。请根据实际需求调整。

matlab
function [imf, ort, nbits] = emd(varargin)
% EMD for real signals, with boundary extension and optional fixed-iteration / max-modes.
% 
% USAGE:
%   [imf, ort, nbits] = emd(x) 
%   [imf, ort, nbits] = emd(x, 'STOP',[sd,sd2,tol], 'MAXITERATIONS',2000, ...
%                          'FIX', 0, 'MAXMODES', 0, 'INTERP','spline', ...)
%
% INPUT (as name-value pairs in varargin):
%   - x               : the input signal (vector).
%   - STOP            : a vector [sd, sd2, tol], default [0.05, 0.5, 0.05].
%   - MAXITERATIONS   : max sifting iterations (default 2000).
%   - FIX             : if nonzero, indicates fixed iteration count for each IMF. 
%                       e.g. 'FIX',100 means each IMF uses at most 100 sifting iterations.
%   - MAXMODES        : if nonzero, maximum number of IMFs to extract (default 0 means unlimited).
%   - INTERP          : interpolation method, e.g. 'linear','cubic','spline' (default 'spline').
% 
% OUTPUT:
%   - imf   : matrix storing each IMF row by row
%   - ort   : orthogonality index of IMFs (you can remove if not needed)
%   - nbits : iteration counts used for each IMF
%
% Author: (YourName), with modifications focusing on real signals only.

%----------------------------------------------------------------------
% (1) Initialize parameters by calling init (no complex, no mask, etc.)
%----------------------------------------------------------------------
[x, t, sd, sd2, tol, r, imf, k, nbit, NbIt, ...
    MAXITERATIONS, FIXE, MAXMODES, INTERP] = init(varargin{:});

%----------------------------------------------------------------------
% (2) Main loop for extracting IMFs:
%     continue if there's enough extrema, not exceeded max modes, etc.
%----------------------------------------------------------------------
while (~stop_EMD(r) && (k < MAXMODES+1 || MAXMODES == 0))

    % current mode to extract
    m = r; 
    
    % compute initial envelope mean + check stop criterion
    % (here we only keep standard "stop_sifting", or "stop_sifting_fixe" if FIXE>0)
    if FIXE
        [stop_sift, moyenne] = stop_sifting_fixe(t, m, INTERP);
    else
        [stop_sift, moyenne] = stop_sifting(m, t, sd, sd2, tol, INTERP);
    end
    
    % if amplitude is too small, forcibly stop
    if (max(abs(m))) < (1e-10)*max(abs(x))
        warning('emd:warning','forced stop of EMD : too small amplitude')
        break
    end

    %--------------------------------------------------
    % sifting loop for the current IMF
    %--------------------------------------------------
    while ~stop_sift && (nbit < MAXITERATIONS)
        
        % do one sifting iteration
        m = m - moyenne;

        % compute envelope again + check stop
        if FIXE
            [stop_sift, moyenne] = stop_sifting_fixe(t, m, INTERP);
        else
            [stop_sift, moyenne, s] = stop_sifting(m, t, sd, sd2, tol, INTERP);
        end

        nbit  = nbit + 1;   % sifting iteration count for current IMF
        NbIt  = NbIt + 1;   % total iteration count
        
        % if approaching max iteration
        if (nbit == (MAXITERATIONS-1) && ~FIXE && nbit>100)
            warning('emd:warning',['forced stop: too many iterations... IMF #',int2str(k)])
        end
    end

    % store the extracted IMF
    imf(k,:) = m;
    
    % store iteration count for that IMF
    nbits(k) = nbit;

    % update the residual
    r = r - m;
    
    % move on to next IMF
    k = k + 1;
    nbit = 0;  % reset iteration for next IMF
end

% if there's leftover r that is nonzero, store as final IMF
if any(r)
    imf(k,:) = r;
end

% compute orthogonality index (optional)
ort = io(x, imf);

end  % ---------------- end of main emd function ----------------


%============================================================
%   Subfunction: stop_EMD(r)
%   Checks if there's enough extrema to continue
%============================================================
function stop = stop_EMD(r)
    [indmin, indmax] = extr(r);
    ner = length(indmin) + length(indmax);
    stop = (ner < 3);
end


%============================================================
%   Subfunction: mean_and_amplitude for real signals
%============================================================
function [envmoy, nem, nzm, amp] = mean_and_amplitude(m, t, INTERP)
    % find extremas
    [indmin, indmax, indzer] = extr(m);
    nem = length(indmin) + length(indmax);
    nzm = length(indzer);
    
    % boundary extension & get envelopes
    [tmin, tmax, mmin, mmax] = boundary_conditions(indmin, indmax, t, m, m, 2);
    envmin = interp1(tmin, mmin, t, INTERP);
    envmax = interp1(tmax, mmax, t, INTERP);

    envmoy = (envmin + envmax)/2;
    amp    = mean(abs(envmax-envmin))/2;
end


%============================================================
%   Subfunction: stop_sifting (default stopping criterion)
%============================================================
function [stop, envmoy, s] = stop_sifting(m, t, sd, sd2, tol, INTERP)
    try
        [envmoy, nem, nzm, amp] = mean_and_amplitude(m, t, INTERP);
        sx = abs(envmoy)./amp;
        s  = mean(sx);

        % check conditions
        cond1 = (mean(sx>sd) > tol) || any(sx>sd2);
        cond2 = (nem > 2);
        % also ensure zero-crossing ~ extrema count
        cond3 = (abs(nzm-nem) <= 1);

        stop = ~(cond1 && cond2 && cond3);
    catch
        stop    = 1;
        envmoy  = zeros(size(m));
        s       = NaN;
    end
end


%============================================================
%   Subfunction: stop_sifting_fixe
%   If we choose a fixed iteration approach => always stop=0
%============================================================
function [stop, moyenne] = stop_sifting_fixe(t, m, INTERP)
    try
        moyenne = mean_and_amplitude(m, t, INTERP);
        % In fixed iteration mode, we do NOT do adaptive stopping
        % => always return stop=0 unless error
        stop = 0;  
    catch
        moyenne = zeros(size(m));
        stop    = 1;  
    end
end


%============================================================
%   Subfunction: boundary_conditions
%   mirror extension at both ends for real signals
%============================================================
function [tmin, tmax, zmin, zmax] = boundary_conditions(indmin, indmax, t, x, z, nbsym)
    
    lx = length(x);
    if (length(indmin)+length(indmax) < 3)
        error('not enough extrema');
    end

    % replicate the original logic for mirrored extension
    if indmax(1) < indmin(1)
        if x(1) > x(indmin(1))
            lmax = fliplr(indmax(2:min(end, nbsym+1)));
            lmin = fliplr(indmin(1:min(end, nbsym)));
            lsym = indmax(1);
        else
            lmax = fliplr(indmax(1:min(end, nbsym)));
            lmin = [fliplr(indmin(1:min(end, nbsym-1))) 1];
            lsym = 1;
        end
    else
        if x(1) < x(indmax(1))
            lmax = fliplr(indmax(1:min(end, nbsym)));
            lmin = fliplr(indmin(2:min(end, nbsym+1)));
            lsym = indmin(1);
        else
            lmax = [fliplr(indmax(1:min(end, nbsym-1))) 1];
            lmin = fliplr(indmin(1:min(end, nbsym)));
            lsym = 1;
        end
    end

    if indmax(end) < indmin(end)
        if x(end) < x(indmax(end))
            rmax = fliplr(indmax(max(end-nbsym+1,1):end));
            rmin = fliplr(indmin(max(end-nbsym,1):end-1));
            rsym = indmin(end);
        else
            rmax = [lx fliplr(indmax(max(end-nbsym+2,1):end))];
            rmin = fliplr(indmin(max(end-nbsym+1,1):end));
            rsym = lx;
        end
    else
        if x(end) > x(indmin(end))
            rmax = fliplr(indmax(max(end-nbsym,1):end-1));
            rmin = fliplr(indmin(max(end-nbsym+1,1):end));
            rsym = indmax(end);
        else
            rmax = fliplr(indmax(max(end-nbsym+1,1):end));
            rmin = [lx fliplr(indmin(max(end-nbsym+2,1):end))];
            rsym = lx;
        end
    end

    tlmin = 2*t(lsym) - t(lmin);
    tlmax = 2*t(lsym) - t(lmax);
    trmin = 2*t(rsym) - t(rmin);
    trmax = 2*t(rsym) - t(rmax);

    zlmax = z(lmax);
    zlmin = z(lmin);
    zrmax = z(rmax);
    zrmin = z(rmin);

    tmin = [tlmin t(indmin) trmin];
    tmax = [tlmax t(indmax) trmax];
    zmin = [zlmin z(indmin) zrmin];
    zmax = [zlmax z(indmax) zrmax];
end


%============================================================
%   Subfunction: extr 
%   extract min/max/zerocross from real signal
%============================================================
function [indmin, indmax, indzer] = extr(x, t)

    if nargin<2
        t = 1:length(x);
    end

    m = length(x);
    indzer = [];
    
    if nargout>2
        x1 = x(1:m-1);
        x2 = x(2:m);
        indzer = find(x1.*x2<0);
        if any(x==0)
            iz = find(x==0);
            indz= [];
            if any(diff(iz)==1)
                zer = (x==0);
                dz  = diff([0 zer 0]);
                debz= find(dz==1);
                finz= find(dz==-1)-1;
                indz= round((debz+finz)/2);
            else
                indz= iz;
            end
            indzer = sort([indzer indz]);
        end
    end
    
    d  = diff(x);
    n  = length(d);
    d1 = d(1:n-1);
    d2 = d(2:n);
    indmin = find(d1.*d2<0 & d1<0)+1;
    indmax = find(d1.*d2<0 & d1>0)+1;

    if any(d==0)
        imax = [];
        imin = [];
        bad = (d==0);
        dd  = diff([0 bad 0]);
        debs= find(dd==1);
        fins= find(dd==-1);
        if ~isempty(debs)
            if debs(1)==1
                if length(debs)>1
                    debs= debs(2:end);
                    fins= fins(2:end);
                else
                    debs=[];
                    fins=[];
                end
            end
        end
        if ~isempty(debs)
            if fins(end)==m
                if length(debs)>1
                    debs= debs(1:end-1);
                    fins= fins(1:end-1);
                else
                    debs=[];
                    fins=[];
                end
            end
        end
        lc= length(debs);
        if lc>0
            for k=1:lc
                if d(debs(k)-1)>0 && d(fins(k))<0
                    imax = [imax round((fins(k)+debs(k))/2)];
                elseif d(debs(k)-1)<0 && d(fins(k))>0
                    imin = [imin round((fins(k)+debs(k))/2)];
                end
            end
        end
        if ~isempty(imax)
            indmax=sort([indmax imax]);
        end
        if ~isempty(imin)
            indmin=sort([indmin imin]);
        end
    end
end


%============================================================
%   Subfunction: io (orthogonality index)
%============================================================
function ort = io(x, imf)
    n = size(imf,1);
    s = 0;
    for i=1:n
        for j=1:n
            if i~=j
                s = s + abs( sum(imf(i,:).*imf(j,:))/sum(x.^2) );
            end
        end
    end
    ort = 0.5*s;
end


%============================================================
%   Subfunction: init
%   parse input parameters (no complex, no mask)
%============================================================
function [x,t,sd,sd2,tol,r,imf,k,nbit,NbIt,MAXITERATIONS,FIXE,MAXMODES,INTERP] = init(varargin)

    x = varargin{1};
    if nargin>=2 && isstruct(varargin{2})
        inopts = varargin{2};
    elseif nargin>2
        try
            inopts = struct(varargin{2:end});
        catch
            error('bad argument syntax');
        end
    else
        inopts = struct();
    end

    defstop = [0.05,0.5,0.05];
    defopts.stop          = defstop;
    defopts.t             = 1:length(x);
    defopts.maxiterations = 2000;
    defopts.fix           = 0;
    defopts.maxmodes      = 0;
    defopts.interp        = 'spline';
    
    opts = defopts;
    names= fieldnames(inopts);
    for nm = names'
        nmchar = char(nm);
        opts.(nmchar) = inopts.(nmchar);
    end
    
    t             = opts.t;
    stop          = opts.stop;
    MAXITERATIONS = opts.maxiterations;
    FIXE          = opts.fix;       % fixed iteration if nonzero
    MAXMODES      = opts.maxmodes;  % limit #imfs if nonzero
    INTERP        = opts.interp;

    if ~isvector(x), error('X must be a vector'); end
    if size(x,1)>1, x=x.'; end
    if size(t,1)>1, t=t.'; end
    if length(t)~=length(x)
        error('X and T must have the same length');
    end
    
    if ~isvector(stop) || length(stop)>3
        error('option STOP must have up to 3 elements');
    end
    if length(stop)<3, stop(3) = defstop(3); end
    if length(stop)<2, stop(2) = defstop(2); end
    
    sd  = stop(1);
    sd2 = stop(2);
    tol = stop(3);

    r    = x;    % residual
    imf  = [];   % storing
    k    = 1;    % IMF index
    nbit = 0;    % iteration for one IMF
    NbIt = 0;    % total iteration 
end

三、如何使用

固定迭代次数：如果你想对每个 IMF 只进行固定 100 次迭代，可以调用
```
matlab
imf = emd(x, 'FIX', 100);
```
则在 stop_sifting_fixe 里始终 stop=0，实际上不会因为包络的小波形而提前停，而是最多迭代 FIX=100 次后（见主循环 while nbit<MAXITERATIONS）就出该 IMF。
固定模态数：想要限制最多提取多少层 IMF，例如提取 5 层：
```
matlab
imf = emd(x, 'MAXMODES', 5);
```
主循环里用 (k < MAXMODES+1) 控制，不再往下分解更多 IMF。
兼顾固定迭代次数与固定模态数：
```
matlab
imf = emd(x, 'FIX', 100, 'MAXMODES', 5);
```
则每个 IMF 最多迭代 100 次，共不超过 5 个 IMF。
设置插值方法：
例如 'INTERP','linear'，会让 interp1 用线性插值，速度更快但可能精度略低。
默认 'spline' 能在边缘比较平滑。
边界扩展：
代码中保留了原先复杂的镜像逻辑，保证对边缘有较好处理。如果还想做得更极端（如再多镜像点 nbsym=4 之类），可以自行修改 boundary_conditions 里传入的 nbsym 值。
正交度：
返回的 ort 可以让你评估分解后的 IMF 是否正交；若不需要，就把 ort = io(x, imf) 及对应子函数 io 一并删掉。

总结

这份代码只删除了和复数信号（MODE_COMPLEX, ndirs）相关的内容，其他复杂结构（如边界延拓、固定迭代、固定模态数、多种插值方式）都依然保留了。
删除了所有调试/日志输出，让它更简洁；若需要，可以在 sifting 循环里加一些 disp(...)。
你也可以把 init 拆成外部文件，或者合并到 emd.m 顶部；保留/删除 FIXE_H、io、mask 相关函数，均取决于你是否还有此需求。

这样既能保持原本对边界条件的高精度处理，又只去掉复杂的「复数信号」和「多余的输出信息」，同时保留了固定迭代/固定模态这两个重要控制手段，方便你在实际工程中平衡运算速度和分解精度。

Answer 5

下面给出的是在代码中添加中文注释的版本，帮助你（或他人）更容易理解各个部分的功能和流程。在不改变逻辑的前提下，为每个关键步骤添加了中文说明。请根据需要自行补充或调整注释的细节。

matlab
function [imf, ort, nbits] = emd(varargin)
% EMD 算法（针对实数信号），支持边界扩展、可选的固定迭代次数以及最大模态数
%
% 用法示例：
%   [imf, ort, nbits] = emd(x)
%   [imf, ort, nbits] = emd(x, 'STOP',[sd, sd2, tol], 'MAXITERATIONS', 2000, ...
%                          'FIX', 0, 'MAXMODES', 0, 'INTERP','spline', ...)
%
% 输入参数（可用 name-value pairs 形式）：
%   - x             : 输入信号，必须是向量(行或列)。
%   - STOP          : 停止准则的参数向量 [sd, sd2, tol]，默认 [0.05, 0.5, 0.05]。
%   - MAXITERATIONS : 每个 IMFs 的 sifting 最大迭代次数，默认 2000。
%   - FIX           : 若非0，则表示固定迭代次数的模式，例如 'FIX',100 意味着对每个模态最多迭代100次。
%   - MAXMODES      : 若非0，则表示最多分解出指定数量的 IMF（默认0表示不限制个数）。
%   - INTERP        : 插值方式，可为 'linear','cubic','spline' 等，默认 'spline'。
%
% 输出参数：
%   - imf  : 分解得到的所有 IMF，逐行存储；行数 = 模态数，列数 = 信号长度
%   - ort  : 各 IMF 之间的正交性指标（若不需要可忽略或删除此部分）
%   - nbits: 每个 IMF 对应的迭代次数
%
% 作者: (YourName)，在原始基础上做了针对实数信号的简化与注释。

%----------------------------------------------------------------------
% (1) 通过 init 函数初始化参数（不支持复数、不支持mask等复杂情况）
%     注意：init 会解析 varargin，把 name-value 对应到 opts 中
%----------------------------------------------------------------------
[x, t, sd, sd2, tol, r, imf, k, nbit, NbIt, ...
    MAXITERATIONS, FIXE, MAXMODES, INTERP] = init(varargin{:});

%----------------------------------------------------------------------
% (2) 主循环：逐个提取 IMF
%     满足以下条件则继续提取：
%       - 信号剩余量 r 仍有足够多的极值(大于等于3个)
%       - 尚未达到用户设定的最大模态数 MAXMODES（若为 0 则不限制）
%----------------------------------------------------------------------
while (~stop_EMD(r) && (k < MAXMODES+1 || MAXMODES == 0))

    % 当前要提取的 IMF 初值为剩余量 r
    m = r; 
    
    % 首先计算包络均值，并判断是否满足停止准则
    % 如果用户设定了 FIXE（固定迭代），则使用 stop_sifting_fixe，
    % 否则使用默认的 stop_sifting
    if FIXE
        [stop_sift, moyenne] = stop_sifting_fixe(t, m, INTERP);
    else
        [stop_sift, moyenne] = stop_sifting(m, t, sd, sd2, tol, INTERP);
    end
    
    % 若当前模态的幅度过小，以至于可能导致虚假极值，强制停止
    if (max(abs(m))) < (1e-10)*max(abs(x))
        warning('emd:warning','强制停止 EMD：模态幅度过小');
        break
    end

    %--------------------------------------------------
    % (3) sifting 循环：对当前模态进行多次迭代
    %--------------------------------------------------
    while ~stop_sift && (nbit < MAXITERATIONS)
        
        % 从信号中减去当前估计的包络均值
        m = m - moyenne;

        % 再次计算新的包络均值，并检测是否停止
        if FIXE
            [stop_sift, moyenne] = stop_sifting_fixe(t, m, INTERP);
        else
            [stop_sift, moyenne, s] = stop_sifting(m, t, sd, sd2, tol, INTERP);
        end

        % 记录迭代次数
        nbit  = nbit + 1;  % 当前 IMF 的迭代次数
        NbIt  = NbIt + 1;  % 全局总迭代次数
        
        % 如果迭代次数已接近最大值，且不是固定迭代模式，给出警告
        if (nbit == (MAXITERATIONS-1) && ~FIXE && nbit>100)
            warning('emd:warning',['强制停止：迭代次数过多... IMF #',int2str(k)])
        end
    end

    % 一个 IMF 提取完成，将其存储到 imf 中
    imf(k,:) = m;
    
    % 记录该 IMF 的迭代次数
    nbits(k) = nbit;

    % 从剩余量 r 中减去该 IMF，得到下一步的剩余量
    r = r - m;
    
    % 准备提取下一个 IMF
    k = k + 1;
    nbit = 0;  % 重置迭代计数
end

% 如果还有剩余 r，不为全零，则将其当作最后一个 IMF
if any(r)
    imf(k,:) = r;
end

% 计算正交度（可选），若不需要可注释/删除
ort = io(x, imf);

end  % ---------------- 主函数 emd 结束 ----------------


%============================================================
%   子函数：stop_EMD(r)
%   判断是否还存在足够多的极值，以继续 EMD 分解
%============================================================
function stop = stop_EMD(r)
    [indmin, indmax] = extr(r);
    ner = length(indmin) + length(indmax);
    % 若极值总数 < 3，则停止
    stop = (ner < 3);
end


%============================================================
%   子函数：mean_and_amplitude
%   计算实数信号的上下包络并求平均，以及模态振幅
%============================================================
function [envmoy, nem, nzm, amp] = mean_and_amplitude(m, t, INTERP)
    % 提取极值（极大值/极小值）与零交点
    [indmin, indmax, indzer] = extr(m);
    nem = length(indmin) + length(indmax);  % 极值总数
    nzm = length(indzer);                  % 零交点数量
    
    % 使用镜像边界条件，计算最小包络和最大包络
    [tmin, tmax, mmin, mmax] = boundary_conditions(indmin, indmax, t, m, m, 2);
    
    % 插值得到包络
    envmin = interp1(tmin, mmin, t, INTERP);
    envmax = interp1(tmax, mmax, t, INTERP);

    % 上下包络的平均值
    envmoy = (envmin + envmax)/2;
    
    % 估计幅度（上下包络之差的平均值的一半）
    amp    = mean(abs(envmax - envmin))/2;
end


%============================================================
%   子函数：stop_sifting (默认停止准则)
%   检查当前模态与包络的关系，判断是否继续迭代
%============================================================
function [stop, envmoy, s] = stop_sifting(m, t, sd, sd2, tol, INTERP)
    try
        % 计算当前的包络均值和相关参数
        [envmoy, nem, nzm, amp] = mean_and_amplitude(m, t, INTERP);
        
        % 包络均值与振幅的比率
        sx = abs(envmoy)./amp;
        s  = mean(sx);  % 其均值
        
        % 条件1：大部分点的 sx 大于 sd 且超过 tol，或 sx 有部分点大于 sd2
        cond1 = (mean(sx>sd) > tol) || any(sx>sd2);
        % 条件2：极值数应大于 2
        cond2 = (nem > 2);
        % 条件3：零交点数与极值数之差不应超过 1
        cond3 = (abs(nzm - nem) <= 1);

        % 若要继续迭代，需要以上条件都满足，取其逻辑
        % stop = not(满足所有条件)
        stop = ~(cond1 && cond2 && cond3);
    catch
        % 若过程中出错，设为停止状态
        stop    = 1;
        envmoy  = zeros(size(m));
        s       = NaN;
    end
end


%============================================================
%   子函数：stop_sifting_fixe
%   当使用固定迭代次数时，始终不基于信号判定停止
%   因此 stop=0，让外层 while 看 nbit < MAXITERATIONS
%============================================================
function [stop, moyenne] = stop_sifting_fixe(t, m, INTERP)
    try
        % 这里仍计算一下包络均值，不过不做自适应停止
        moyenne = mean_and_amplitude(m, t, INTERP);
        stop = 0;  % 固定迭代模式下，内部不停止
    catch
        % 若出错则停止
        moyenne = zeros(size(m));
        stop    = 1;  
    end
end


%============================================================
%   子函数：boundary_conditions
%   对实数信号采用镜像扩展，以减少边界失真
%============================================================
function [tmin, tmax, zmin, zmax] = boundary_conditions(indmin, indmax, t, x, z, nbsym)
    
    lx = length(x);
    if (length(indmin)+length(indmax) < 3)
        error('not enough extrema');
    end

    % 以下是镜像边界延拓的原逻辑
    % 根据极值的排列、端点位置，反转若干点做镜像
    if indmax(1) < indmin(1)
        if x(1) > x(indmin(1))
            lmax = fliplr(indmax(2:min(end, nbsym+1)));
            lmin = fliplr(indmin(1:min(end, nbsym)));
            lsym = indmax(1);
        else
            lmax = fliplr(indmax(1:min(end, nbsym)));
            lmin = [fliplr(indmin(1:min(end, nbsym-1))) 1];
            lsym = 1;
        end
    else
        if x(1) < x(indmax(1))
            lmax = fliplr(indmax(1:min(end, nbsym)));
            lmin = fliplr(indmin(2:min(end, nbsym+1)));
            lsym = indmin(1);
        else
            lmax = [fliplr(indmax(1:min(end, nbsym-1))) 1];
            lmin = fliplr(indmin(1:min(end, nbsym)));
            lsym = 1;
        end
    end

    if indmax(end) < indmin(end)
        if x(end) < x(indmax(end))
            rmax = fliplr(indmax(max(end-nbsym+1,1):end));
            rmin = fliplr(indmin(max(end-nbsym,1):end-1));
            rsym = indmin(end);
        else
            rmax = [lx fliplr(indmax(max(end-nbsym+2,1):end))];
            rmin = fliplr(indmin(max(end-nbsym+1,1):end));
            rsym = lx;
        end
    else
        if x(end) > x(indmin(end))
            rmax = fliplr(indmax(max(end-nbsym,1):end-1));
            rmin = fliplr(indmin(max(end-nbsym+1,1):end));
            rsym = indmax(end);
        else
            rmax = fliplr(indmax(max(end-nbsym+1,1):end));
            rmin = [lx fliplr(indmin(max(end-nbsym+2,1):end))];
            rsym = lx;
        end
    end

    % 计算镜像后对应的时间坐标
    tlmin = 2*t(lsym) - t(lmin);
    tlmax = 2*t(lsym) - t(lmax);
    trmin = 2*t(rsym) - t(rmin);
    trmax = 2*t(rsym) - t(rmax);

    % 对应的信号值也镜像
    zlmax = z(lmax);
    zlmin = z(lmin);
    zrmax = z(rmax);
    zrmin = z(rmin);

    % 整合：在中间插入原本的极值坐标与数值
    tmin = [tlmin t(indmin) trmin];
    tmax = [tlmax t(indmax) trmax];
    zmin = [zlmin z(indmin) zrmin];
    zmax = [zlmax z(indmax) zrmax];
end


%============================================================
%   子函数：extr 
%   从实数信号中提取极大值、极小值和零交点
%============================================================
function [indmin, indmax, indzer] = extr(x, t)

    if nargin<2
        t = 1:length(x);
    end

    m = length(x);
    indzer = [];
    
    % 如果要求返回零交点（nargout>2），则要进一步计算
    if nargout>2
        x1 = x(1:m-1);
        x2 = x(2:m);
        indzer = find(x1.*x2<0);
        % 若存在恰好为 0 的点，也要考虑合并
        if any(x==0)
            iz = find(x==0);
            indz= [];
            if any(diff(iz)==1)
                zer = (x==0);
                dz  = diff([0 zer 0]);
                debz= find(dz==1);
                finz= find(dz==-1)-1;
                indz= round((debz+finz)/2);
            else
                indz= iz;
            end
            indzer = sort([indzer indz]);
        end
    end
    
    % 差分
    d  = diff(x);
    n  = length(d);
    d1 = d(1:n-1);
    d2 = d(2:n);
    
    % 极小值：d1<0 且 d1*d2<0
    indmin = find(d1.*d2<0 & d1<0)+1;
    % 极大值：d1>0 且 d1*d2<0
    indmax = find(d1.*d2<0 & d1>0)+1;

    % 对连续平值区间(d==0)的特殊处理
    if any(d==0)
        imax = [];
        imin = [];
        bad = (d==0);
        dd  = diff([0 bad 0]);
        debs= find(dd==1);
        fins= find(dd==-1);
        if ~isempty(debs)
            if debs(1)==1
                if length(debs)>1
                    debs= debs(2:end);
                    fins= fins(2:end);
                else
                    debs=[];
                    fins=[];
                end
            end
        end
        if ~isempty(debs)
            if fins(end)==m
                if length(debs)>1
                    debs= debs(1:end-1);
                    fins= fins(1:end-1);
                else
                    debs=[];
                    fins=[];
                end
            end
        end
        lc= length(debs);
        if lc>0
            for k=1:lc
                if d(debs(k)-1)>0 && d(fins(k))<0
                    imax = [imax round((fins(k)+debs(k))/2)];
                elseif d(debs(k)-1)<0 && d(fins(k))>0
                    imin = [imin round((fins(k)+debs(k))/2)];
                end
            end
        end
        if ~isempty(imax)
            indmax=sort([indmax imax]);
        end
        if ~isempty(imin)
            indmin=sort([indmin imin]);
        end
    end
end


%============================================================
%   子函数：io (orthogonality index)
%   用于计算各 IMF 间的正交性指数，若不需要可删除
%============================================================
function ort = io(x, imf)
    n = size(imf,1);
    s = 0;
    % 两两模态间计算内积，累加
    for i=1:n
        for j=1:n
            if i~=j
                s = s + abs( sum(imf(i,:).*imf(j,:)) / sum(x.^2) );
            end
        end
    end
    % 返回正交度指标
    ort = 0.5 * s;
end


%============================================================
%   子函数：init
%   解析输入参数，提供默认值并初始化 EMD 所需变量
%============================================================
function [x,t,sd,sd2,tol,r,imf,k,nbit,NbIt,MAXITERATIONS,FIXE,MAXMODES,INTERP] = init(varargin)

    % x 为第一个必选参数：输入信号
    x = varargin{1};
    
    % 若第二个参数是结构体，则直接认为它是选项 inopts
    % 若之后还有更多参数，则尝试用 struct() 解析成一个选项结构
    if nargin>=2 && isstruct(varargin{2})
        inopts = varargin{2};
    elseif nargin>2
        try
            inopts = struct(varargin{2:end});
        catch
            error('参数语法错误：无法解析为结构体');
        end
    else
        inopts = struct();
    end

    % 默认停止准则
    defstop = [0.05, 0.5, 0.05];
    
    % 设定默认选项
    defopts.stop          = defstop;        % [sd, sd2, tol]
    defopts.t             = 1:length(x);    % 默认时间向量
    defopts.maxiterations = 2000;           % 默认最大迭代次数
    defopts.fix           = 0;              % 默认不使用固定迭代
    defopts.maxmodes      = 0;              % 默认不限制 IMF 数量
    defopts.interp        = 'spline';       % 默认插值方式
    
    % 将用户输入的选项合并到 opts 中
    opts = defopts;
    names = fieldnames(inopts);
    for nm = names'
        nmchar = char(nm);
        opts.(nmchar) = inopts.(nmchar);
    end
    
    % 从 opts 中取出主要的字段
    t             = opts.t;
    stop          = opts.stop;
    MAXITERATIONS = opts.maxiterations;
    FIXE          = opts.fix;
    MAXMODES      = opts.maxmodes;
    INTERP        = opts.interp;

    % 基本检查：x, t 是否匹配长度
    if ~isvector(x), error('X 必须是一个向量'); end
    if size(x,1)>1, x = x.'; end
    if size(t,1)>1, t = t.'; end
    if length(t)~=length(x)
        error('X 与 T 长度必须一致');
    end
    
    % 检查 STOP 参数合法性
    if ~isvector(stop) || length(stop)>3
        error('选项 STOP 只能最多有 3 个元素');
    end
    % 若 stop 不足3个元素，补充默认值
    if length(stop)<3, stop(3) = defstop(3); end
    if length(stop)<2, stop(2) = defstop(2); end
    
    % 拆分停止参数
    sd  = stop(1);
    sd2 = stop(2);
    tol = stop(3);

    % 初始化剩余量 r（最开始就是原信号）
    r    = x;   
    imf  = [];  
    k    = 1;   % IMF 计数
    nbit = 0;   % 当前 IMF 的迭代次数
    NbIt = 0;   % 总迭代次数
    
end

注：

若不需要正交性ort，可删除 io 函数以及主函数最后那一行 ort = io(x, imf);。
若只想用固定迭代的模式（不需要自适应停机），可把 stop_sifting 相关逻辑删掉，只留 stop_sifting_fixe 即可。
若不需要零交点，也可以在 extr 函数里去掉相关的 indzer 代码。

这样就得到了中文注释的版本，便于阅读和进一步二次开发。祝使用愉快!

Answer 6

首先就你给出的这段脚本，在理论上是可以直接调用我们提供的 CEEMD 代码（以及它所依赖的 EMD 代码）来完成分解和绘图的。代码本身不会有致命错误，但有几点需要注意，以防止出现变量冲突或函数路径等常见问题。

1. 代码中核心调用

matlab
[u, its] = ceemd(s, Nstd, NR, MaxIter);

这里 $\texttt{ceemd}$ 函数需要你之前已经定义好，并且处在 MATLAB 的搜索路径中(或者在同一个工作文件夹里)。
如果你参考的是我们之前给出的 $\texttt{ceemd.m}$ 以及 $\texttt{emd.m}$ ，那么只要把这两个文件放到和你当前脚本相同的目录下(或加到 path 中)，就可以正常调用。

2. 注意变量名 “t” 的重复使用

在你的脚本最后有这样一句：

matlab
t = timeit(@() ceemd(s, Nstd, NR, MaxIter)); 
fprintf('Execution time: %.5f seconds\n', t);

但是你的脚本中 也使用了 变量 $\texttt{t}$ 来存放时间向量 ( $\texttt{sampledTime}$ )。这就导致同名变量被覆盖：一旦执行上面的语句， $\texttt{t}$ 不再是时间向量，而是 $\texttt{timeit}$ 函数返回的一个标量执行时间。

如果你不打算在后面再次使用 $\texttt{t}$ 当时间向量，这个覆盖也不一定会报错，但容易引起混淆。
解决办法：将存储执行时间的变量换个名字，比如：
```
matlab
exec_time = timeit(@() ceemd(s, Nstd, NR, MaxIter));
fprintf('Execution time: %.5f seconds\n', exec_time);
```
这样就不会覆盖之前的 $\texttt{t}$ （时间向量）了。

3. 可能的警告或提示

路径/函数不可见
如果报错类似 “Undefined function or variable 'ceemd'”，说明 CEEMD 代码文件不在当前工作路径内，或者脚本找不到。需要你把 ceemd.m (以及里面需要的 emd.m) 放到同一文件夹里，或者在 MATLAB 命令行里用
```
matlab
addpath('CEEMD所在的文件夹路径');
```
让其可见。
多余的输出
当你只想要分解后的模态 $\texttt{u}$ 而不想要迭代次数 $\texttt{its}$ ，可以写成：
```
matlab
u = ceemd(s, Nstd, NR, MaxIter);
```
这样不用在后面处理 $\texttt{its}$ 。当然，你现在这样写也没问题，只是 $\texttt{its}$ 是否会在脚本其他地方继续用到。
提示：最大迭代次数过小
你把 $\texttt{MaxIter=10}$ ，对于某些信号来说，EMD 可能刚处理到一半就已经到达了最大迭代限制。这样做不一定会出错，但分解效果和模态精度可能不理想，会在命令行提示你“sifting: too many iterations... forced stop”之类的警告，或者使某些模态分解不够细致。根据需求可以考虑增大到 100、500 或 1000 看看效果。

4. 整体结论

是否会报错：只要你放好 CEEMD 和 EMD 代码（即我们之前提供的或你自己改写过的版本），并且修改了脚本中 t = timeit(...) 这类变量重名的问题，一般就不会报错，可以正常运行。
是否精确：既然你使用了 EEMD 并加上了多次加噪重分解 (NR=50)，在原理上可以获得更平稳的分解结果。但要留意 MaxIter 过小可能让分解不够充分。
执行时间：EEMD 进行多次加噪，相比单次 EMD，要花更多时间，所以 timeit(@() ceemd(...)) 也比较常见，能帮你测量分解性能。

只要处理好以上几点，这段脚本就可以在你给出的 CEEMD/EMD 代码上正确应用，不会报错。祝实验顺利!

Answer 7

下面是一份对你原脚本的稍作修改版本，主要是避免重用变量t（因为它已经用于存放时间向量），并改成使用 exec_time 来接收 timeit 的结果。其余功能和逻辑不变。

matlab
clear;
clc;

% 读取Excel数据
filename = 'D:\Y1\Offshore Wind Powe\数据\shiyanshuju2.xlsx'; % 文件名
data = xlsread(filename);     % 读取数据
x = data(:, 2)';             % 第2列为正极电压信号 (假设)
sampledTime = data(:, 1)';   % 第1列为时间数据
Fs = 1 / (sampledTime(2) - sampledTime(1)); % 根据时间间隔计算采样频率

%% EEMD分解参数
Nstd = 0.5;      % 噪声标准差
NR = 50;         % 噪声重复次数（重分解次数）
MaxIter = 10;    % 每次EMD最大迭代次数

% 将 x 赋给 s，用作分解信号
s = x; 

% 调用 ceemd.m 对信号进行分解 
% （注意：需确保 ceemd.m/emd.m 文件在当前路径或已 addpath）
[u, its] = ceemd(s, Nstd, NR, MaxIter);

% 设置时间向量，便于绘图
t = sampledTime;

% 获取分解得到的模态数
a = size(u, 1);

%--------------------------------------------------------------------------
% 绘制：原始信号  +  IMF 分量
%--------------------------------------------------------------------------
figure(1);
subplot(a+1, 1, 1); 
plot(t, s, 'b-'); 
ylabel('s', 'fontsize', 12, 'fontname', '宋体');
title('原始信号及其 IMFs');

for n1 = 1:a
    subplot(a+1, 1, n1+1);
    plot(t, u(n1,:), 'r-'); 
    ylabel(['IMF' int2str(n1)], 'fontsize', 10); 
end
xlabel('时间 (s)', 'fontsize', 12, 'fontname', '宋体');

%--------------------------------------------------------------------------
% 绘制：各个 IMF 分量的频谱图
%--------------------------------------------------------------------------
figure('Name', '频谱图', 'Color', 'white');
K = a;           % IMF 分量数量
L = length(t);   % 信号长度
fs = Fs;         % 采样频率

for i = 1:K
    % 对第 i 个 IMF 做 FFT
    p = abs(fft(u(i,:)));  
    subplot(K, 1, i);
    plot((0:L-1)*fs/L, p, 'b-');  
    xlim([0 fs/2]);  
    if i == 1
        title('各 IMF 分量的频谱图');
        ylabel(['IMF' int2str(i)]);
    elseif i == K
        xlabel('频率 (Hz)');
        ylabel(['IMF' int2str(i)]);
    else
        ylabel(['IMF' int2str(i)]);
    end
end
set(gcf, 'color', 'w');  % 设置背景颜色为白色

%--------------------------------------------------------------------------
% 计算并显示 CEEMD 运行时间
%--------------------------------------------------------------------------
exec_time = timeit(@() ceemd(s, Nstd, NR, MaxIter));  % 调用 timeit 函数
fprintf('CEEMD 执行耗时: %.5f 秒\n', exec_time);

主要改动

避免了变量冲突：
- 原脚本末尾使用 t = timeit(@() ceemd(s, Nstd, NR, MaxIter));，会覆写先前的时间向量 t。
- 现改名为 exec_time = timeit(...)，用 exec_time 存储执行时间，避免冲突。
其他说明：
- 如果要调用此脚本，需要确保当前文件夹或 MATLAB 路径下存在 ceemd.m 及其所需的 emd.m。
- 若只想看分解结果、不关心耗时，可直接删除计算 timeit 的部分。
建议：
- 你设定的 MaxIter=10 对部分信号可能过小，会导致分解精度不高或出现迭代不足等问题，可根据需要调大（如 100、200 等）观察分解效果。
- 如果数据量大、加噪次数 NR 较高，会消耗一定的运行时间，需留意性能。

这样修改后，脚本就可以正确地完成：Excel 数据读取 → EEMD 分解 → 绘图 → 打印 EEMD 耗时，且不会再因为 t 被重新赋值而产生冲突或报错。

Pregunta

Pensamiento

Respuesta

简化后的 emd.m

简化后的 ceemd.m

说明

Pregunta

Pensamiento

Respuesta

一、EMD 函数 (emd.m)

二、CEEMD 函数 (ceemd.m)

三、进一步精简的可能性

Pregunta

Pensamiento

Respuesta

1. 文件结构与函数接口

2. 主循环部分（提取 IMF 的流程）

3. 针对复数信号 (MODE_COMPLEX) 和多方向 (ndirs)

4. 针对掩膜信号 (mask)

5. 各种停止准则 (stop_sifting_fixe, stop_sifting_fixe_h, stop_sifting)

6. 边界扩展与插值 (boundary_conditions)

7. 提取极值点 (extr)

8. 输出正交度 (io) 与迭代次数 (nbits)

9. init 函数和参数解析

结论

Pregunta

Pensamiento

Respuesta

一、修改要点与说明

二、示例代码

三、如何使用

总结

Pregunta

Pensamiento

Respuesta

Pregunta

Pensamiento

Respuesta

1. 代码中核心调用

2. 注意变量名 “t” 的重复使用

3. 可能的警告或提示

4. 整体结论

Pregunta

Pensamiento

Respuesta

主要改动

Compartir este Q&A

简化后的 `emd.m`

简化后的 `ceemd.m`

9. `init` 函数和参数解析