berg_algs.m

有关信道估计和信道均衡的仿真程序

% this handles the stochastic-gradient-descent CMA algorithms for the
% bergulator, and is called by ui_traj.m
%
% if not available for your platform, you can create a .mex version 
% by typing "mex -O berg_algs.c" at the system prompt
 
% Copyright 1997-1998 Phil Schniter

function [f,y,srcme] = berg_algs(N,N_f,D_f,D_e,is_FSE,kappa,mu,r,f_init,...
				 alg, misc)

 f_cur = f_init;
 if alg == 1,           % straight-up CMA
   f = zeros(N_f,floor((N-1)/D_f)+1);          % equalizer history
   y = zeros(1,floor((N-1)/D_e)+1);            % soft decisions
   srcme = zeros(1,floor((N-1)/D_e)+1);        % sqrt(CM) error history
   D_u = misc;				       % update-decimation factor
   for i = D_u:D_u:N,
     reg = r(1, N_f+(1+is_FSE)*i:-1:(1+is_FSE)*i+1);
     y_cur = reg*f_cur;
     srcme_cur = kappa-abs(y_cur)^2;
     f_cur = f_cur+mu*reg'*(y_cur*srcme_cur);
     f(:,floor((i-1)/D_f)+1) = f_cur;
     y(floor((i-1)/D_e)+1) = y_cur;
     srcme(floor((i-1)/D_e)+1) = srcme_cur;
   end
 elseif alg == 2,       % normalized CMA (N-CMA)
   f = zeros(N_f,floor((N-1)/D_f)+1);          % equalizer history
   y = zeros(1,floor((N-1)/D_e)+1);            % soft decisions
   srcme = zeros(1,floor((N-1)/D_e)+1);        % sqrt(CM) error history
   alpha = misc;			       % regularization term
   for i = 1:N,
     reg = r(1, N_f+(1+is_FSE)*i:-1:(1+is_FSE)*i+1);
     y_cur = reg*f_cur;
     srcme_cur = kappa-abs(y_cur)^2;
     f_cur = f_cur + mu/(alpha+norm(reg)^2)*reg'*(y_cur*srcme_cur);
     f(:,floor((i-1)/D_f)+1) = f_cur;
     y(floor((i-1)/D_e)+1) = y_cur;
     srcme(floor((i-1)/D_e)+1) = srcme_cur;
   end
 elseif alg == 3,       % signed-error CMA (SE-CMA)
   f = zeros(N_f,floor((N-1)/D_f)+1);          % equalizer history
   y = zeros(1,floor((N-1)/D_e)+1);            % soft decisions
   srcme = zeros(1,floor((N-1)/D_e)+1);        % sqrt(CM) error history
   for i = 1:N,
     reg = r(1, N_f+(1+is_FSE)*i:-1:(1+is_FSE)*i+1);
     y_cur = reg*f_cur;
     srcme_cur = kappa-abs(y_cur)^2;
     f_cur = f_cur + mu*reg'*...
       (sign(real(y_cur)*srcme_cur)+j*sign(imag(y_cur)*srcme_cur));
     %f_cur = f_cur + mu*reg'*(y_cur*srcme_cur)/abs(y_cur*srcme_cur);
     f(:,floor((i-1)/D_f)+1) = f_cur;
     y(floor((i-1)/D_e)+1) = y_cur;
     srcme(floor((i-1)/D_e)+1) = srcme_cur;
   end
 elseif alg == 4,       % signed-regressor CMA (SR-CMA)
   f = zeros(N_f,floor((N-1)/D_f)+1);          % equalizer history
   y = zeros(1,floor((N-1)/D_e)+1);            % soft decisions
   srcme = zeros(1,floor((N-1)/D_e)+1);        % sqrt(CM) error history
   for i = 1:N,
     reg = r(1, N_f+(1+is_FSE)*i:-1:(1+is_FSE)*i+1);
     y_cur = reg*f_cur;
     srcme_cur = kappa-abs(y_cur)^2;
     f_cur = f_cur+mu*(sign(real(reg))+j*sign(imag(reg)))'*(y_cur*srcme_cur);
     %f_cur = f_cur + mu*(reg./abs(reg))'*(y_cur*srcme_cur);
     f(:,floor((i-1)/D_f)+1) = f_cur;
     y(floor((i-1)/D_e)+1) = y_cur;
     srcme(floor((i-1)/D_e)+1) = srcme_cur;
   end
 elseif alg == 5,       % signed-error, signed-regressor CMA (SS-CMA)
   f = zeros(N_f,floor((N-1)/D_f)+1);          % equalizer history
   y = zeros(1,floor((N-1)/D_e)+1);            % soft decisions
   srcme = zeros(1,floor((N-1)/D_e)+1);        % sqrt(CM) error history
   for i = 1:N,
     reg = r(1, N_f+(1+is_FSE)*i:-1:(1+is_FSE)*i+1);
     y_cur = reg*f_cur;
     srcme_cur = kappa-abs(y_cur)^2;
     f_cur = f_cur + mu*(sign(real(reg))+j*sign(imag(reg)))'*...
       (sign(real(y_cur)*srcme_cur)+j*sign(imag(y_cur)*srcme_cur));
     %f_cur = f_cur+mu*(reg./abs(reg))'*(y_cur*srcme_cur)/abs(y_cur*srcme_cur);
     f(:,floor((i-1)/D_f)+1) = f_cur;
     y(floor((i-1)/D_e)+1) = y_cur;
     srcme(floor((i-1)/D_e)+1) = srcme_cur;
   end
 elseif alg == 6,       % dithered signed-error CMA (DSE-CMA)
   alpha = misc;			       % dither amplitude
   f = zeros(N_f,floor((N-1)/D_f)+1);          % equalizer history
   y = zeros(1,floor((N-1)/D_e)+1);            % soft decisions
   srcme = zeros(1,floor((N-1)/D_e)+1);        % sqrt(CM) error history
   dith_r = alpha*(2*rand(1,N)-1);	       % real dither
   if ~isreal(r),
     dith_i = alpha*(2*rand(1,N)-1);	       % imag dither
   end;
   mu = mu*alpha; 			       % adjust step size w.r.t. alpha
   for i = 1:N,
     reg = r(1, N_f+(1+is_FSE)*i:-1:(1+is_FSE)*i+1);
     y_cur = reg*f_cur;
     srcme_cur = kappa-abs(y_cur)^2;
     f_cur = f_cur + mu*reg'*sign(real(y_cur)*srcme_cur+dith_r(i));
     if ~isreal(r),
       f_cur = f_cur + j*mu*reg'*sign(imag(y_cur)*srcme_cur+dith_i(i));
     end;
     f(:,floor((i-1)/D_f)+1) = f_cur;
     y(floor((i-1)/D_e)+1) = y_cur;
     srcme(floor((i-1)/D_e)+1) = srcme_cur;
   end
 elseif alg == 7,       % weerackody's signed-godard algorithm (WSGA)
   f = zeros(N_f,floor((N-1)/D_f)+1);          % equalizer history
   y = zeros(1,floor((N-1)/D_e)+1);            % soft decisions
   srcme = zeros(1,floor((N-1)/D_e)+1);        % sqrt(CM) error history
   for i = 1:N,
     reg = r(1, N_f+(1+is_FSE)*i:-1:(1+is_FSE)*i+1);
     y_cur = reg*f_cur;
     srcme_cur = kappa-abs(y_cur)^2;
     f_cur = f_cur + mu*reg'*sign(kappa-abs(real(y_cur))-abs(imag(y_cur)))*...
       (sign(real(y_cur))+j*sign(imag(y_cur)));
     f(:,floor((i-1)/D_f)+1) = f_cur;
     y(floor((i-1)/D_e)+1) = y_cur;
     srcme(floor((i-1)/D_e)+1) = srcme_cur;
   end
 else
   error('That algorithm is not supported by berg_algs.m');
 end;