Using Hai's formulas for ML and EM Gauss-Markov with known h_0

x4_mc.m:

    % the usual reasonable init:
    %
     B=[];
     vit_C;
     b = get_ex;

cost_init.m, with no symbol estimates:

  elseif( GM)

     FIR = alpha * FIR_0;
     G = Rh;

     % previously, with known h_1 kludge, was:
     %
     % FIR = FIR_save(:,1);
     % G = Rh/(1-alpha2);

cost_update.m, with no symbol estimates:

  elseif( GM)

     FIR = alpha * FIR;

cost_init, with symbol estimates:

  elseif( GM)

    GG = zeros( FIR_length, N*FIR_length);
    qq = zeros( FIR_length, N);
    Fv = [1:FIR_length];

    for k=N:-1:2

      t = B(k,:)';
      G = t*(t'/var_noise) + inv_Rh;
      q = t*(z(k)/var_noise);
      if( k < N)
        CGk1 = inv_Rh * GG(:,Fv+k*FIR_length);
        G = G + alpha2*(inv_Rh - CGk1*inv_Rh);
        q = q + alpha*(CGk1*qq(:,k+1));
      end
      G = inv(G);
      GG(:,Fv+(k-1)*FIR_length) = G;
      qq(:,k) = q;
    end

      % k = 1
      %
      t = B(1,:)';
      CGk1 = inv_Rh * G;		% RHS G and q are from k=2
      q = t*(z(1)/var_noise) + alpha*(inv_Rh*FIR_0) + alpha*(CGk1*q);
      G = t*(t'/var_noise) + (1+alpha2)*inv_Rh - alpha2*(CGk1*inv_Rh);
      G = inv(G);
      FIR = G*q;

  end

cost_update, with symbol estimates:

  c1 = col + 1;
  ...

  elseif( GM)

    Fv = [1:FIR_length];

    t = B(col,:)';

    if( col == 1) 

      G = t*(t'/var_noise) + (1+alpha2)*inv_Rh;
      q = t*(z(col)/var_noise) + alpha*(inv_Rh*FIR_0);

    else

      G = t*(t'/var_noise) + inv_Rh;
      q = t*(z(col)/var_noise);

      CGk1 = inv_Rh * GG(:,Fv+(col-2)*FIR_length);
      G = G + alpha2*(inv_Rh - CGk1*inv_Rh);
      q = q + alpha*(CGk1*qq(:,col-1));

    end

    G = inv(G);

    GG(:,Fv+(col-1)*FIR_length) = G;
    qq(:,col) = q;

    % set next G and q
    %
    t = B(c1,:)';
    CGk1 = inv_Rh * G;	% RHS G and q are from previous section
    q = t*(z(c1)/var_noise) + alpha*(CGk1*q);
    G = t*(t'/var_noise) + inv_Rh - alpha2*(CGk1*inv_Rh);

    if( c1 < N)
      CGk1 = inv_Rh * GG(:,Fv+c1*FIR_length);
      G = G + alpha2*(inv_Rh - CGk1*inv_Rh);
      q = q + alpha*(CGk1*qq(:,c1+1));
    end

    G = inv(G);
    FIR = G*q;

gm.51:

trials = 1000

using N-FIR_length bits to compute BER
EM init using alpha and h_0
uncorrelated h's
GM h

alpha = 0.995

FIR_length = 3


N = 10


avg_h =

     0
     0
     0


FIR_0 =

     1
     1
     1


var_h = 0.01

inv_Rh =

   100     0     0
     0   100     0
     0     0   100


N, SNR, det, g, known, ML

           10            0            0      0.23357        0.222      0.23443
           10          2.5            0        0.202      0.18229        0.205
           10            5            0      0.12586      0.10271        0.125
           10          7.5            0        0.078     0.038571     0.069857
           10           10            0     0.040286     0.010857     0.034429

iter_avg_g =

        1.013
        1.014
        1.009
        1.009
        1.011

iter_max_g =

     3
     2
     2
     2
     2

EM local min %

ans =

         96.7
         95.6
         93.3
         93.7
           94

ML local min %

ans =

   100
   100
   100
   100
   100

EM_equal_ML %

ans =

         92.1
         89.5
         84.9
         83.4
         86.7


elapsed_time = 25268