classdef FFE_plain_test < IMDDTestCase
    methods (Test, TestTags = {'unit', 'fast', 'dsp', 'ffe'})
        function constructorKeepsPlainDefaults(testCase)
            ffe = FFE_plain();

            testCase.verifyEqual(ffe.sps, 2);
            testCase.verifyEqual(ffe.order, 15);
            testCase.verifyEqual(ffe.len_tr, 4096);
            testCase.verifyEqual(ffe.mu_tr, 0);
            testCase.verifyEqual(ffe.epochs_tr, 5);
            testCase.verifyEqual(ffe.adaption_technique, adaption_method.lms);
            testCase.verifyEqual(ffe.dd_mode, 1);
            testCase.verifyEqual(ffe.mu_dd, 1e-5);
            testCase.verifyEqual(ffe.epochs_dd, 5);
            testCase.verifyEqual(ffe.dd_len_fraction, 1);
            testCase.verifyFalse(ffe.decide);
            testCase.verifyEqual(ffe.e, zeros(ffe.order,1));
            testCase.verifyFalse(isprop(ffe,"dc_tracking_mu"));
            testCase.verifyFalse(isprop(ffe,"dc_avg_bufferlength_a1"));
            testCase.verifyFalse(isprop(ffe,"dc_level_avg_bufferlength_a2"));
        end

        function plainMatchesFullCoreForLms(testCase)
            result = runCoreParity(adaption_method.lms,0.02,0.01);

            verifyCoreParity(testCase,result);
        end

        function plainMatchesFullCoreForNlms(testCase)
            result = runCoreParity(adaption_method.nlms,0.08,0.03);

            verifyCoreParity(testCase,result);
        end

        function plainMatchesFullCoreForRls(testCase)
            result = runCoreParity(adaption_method.rls,0.995,0.998);

            verifyCoreParity(testCase,result);
        end

        function optimizationSignalsUsesShortenedAlignedPrefix(testCase)
            ffe = FFE_plain( ...
                "sps", 2, ...
                "len_tr", 16, ...
                "mu_optimization_len", 22);
            x = (1:100).';
            d = (1:50).';

            [x_opt,d_opt,N_opt] = ffe.optimizationSignals(x,d);

            testCase.verifyEqual(N_opt, 22);
            testCase.verifyEqual(x_opt, x(1:22));
            testCase.verifyEqual(d_opt, d(1:11));
        end
    end
end

function result = runCoreParity(adaption,mu_tr,mu_dd)
    x = [ ...
        -2.2; -0.9; 0.8; 2.1; ...
        -2.0; -1.1; 1.1; 2.2; ...
        -2.1; -0.8; 0.9; 2.0; ...
        -2.3; -1.0; 1.0; 2.3];
    d = [ ...
        -3; -1; 1; 3; ...
        -3; -1; 1; 3; ...
        -3; -1; 1; 3; ...
        -3; -1; 1; 3];
    settings = { ...
        "sps", 1, ...
        "order", 3, ...
        "len_tr", numel(x), ...
        "epochs_tr", 2, ...
        "mu_tr", mu_tr, ...
        "dd_mode", 1, ...
        "epochs_dd", 2, ...
        "mu_dd", mu_dd, ...
        "adaption_technique", adaption};

    plain = FFE_plain(settings{:});
    full = FFE(settings{:});
    plain.constellation = unique(d);
    full.constellation = unique(d);
    plain.P = (1/0.05) * eye(plain.order);
    full.P = (1/0.05) * eye(full.order);

    plain.equalize(x,d,plain.mu_tr,plain.epochs_tr,plain.len_tr,true,false);
    full.equalize(x,d,full.mu_tr,full.epochs_tr,full.len_tr,true,false);
    plain.e_tr = plain.e;
    full.e_tr = full.e;

    [result.y_plain,result.dhat_plain] = plain.equalize(x,d,plain.mu_dd,plain.epochs_dd,numel(x),false,false);
    [result.y_full,result.dhat_full] = full.equalize(x,d,full.mu_dd,full.epochs_dd,numel(x),false,false);
    result.e_plain = plain.e;
    result.e_full = full.e;
    result.e_tr_plain = plain.e_tr;
    result.e_tr_full = full.e_tr;
end

function verifyCoreParity(testCase,result)
    testCase.verifyEqual(result.y_plain,result.y_full,"AbsTol",1e-12);
    testCase.verifyEqual(result.dhat_plain,result.dhat_full,"AbsTol",1e-12);
    testCase.verifyEqual(result.e_plain,result.e_full,"AbsTol",1e-12);
    testCase.verifyEqual(result.e_tr_plain,result.e_tr_full,"AbsTol",1e-12);
end