% Phase 2: Determination of the hazard scores according to human error using IVFF-AHP 

% Step 2: The weight for each decision maker 
mu = [0.95, 0.95, 0.95, 0.55, 0.55, 0.55 ]; % mu values for each decision maker 
nu = [0.10, 0.10, 0.10, 0.50, 0.50, 0.50 ]; % vu values for each decision maker

psi = zeros(1, 6);

for t = 1:6
    psi(t) = 1 + mu(t)^3 - nu(t)^3;
end

total_psi = sum(psi);
weights = psi / total_psi;

disp('The weight of decision makers:');
disp(weights);

% Step1: The weight of hazards 
n = 9;

% IVFFSs
IVFF_terms = struct('CHI', [0.95, 1.0, 0.0, 0.0], ...
                    'VHI', [0.8, 0.9, 0.1, 0.2], ...
                    'HI', [0.7, 0.8, 0.2, 0.3], ...
                    'SMI', [0.6, 0.65, 0.35, 0.4], ...
                    'EI', [0.5, 0.5, 0.5, 0.5], ...
                    'SLI', [0.35, 0.4, 0.6, 0.65], ...
                    'LI', [0.2, 0.3, 0.7, 0.8], ...
                    'VLI', [0.1, 0.2, 0.8, 0.9], ...
                    'CLI', [0.0, 0.0, 0.95, 1.0]);

% Step 3:
Z1 = zeros(n, n, 4); % DM1
Z2 = zeros(n, n, 4); % DM2
Z3 = zeros(n, n, 4); % DM3
Z4 = zeros(n, n, 4); % DM4
Z5 = zeros(n, n, 4); % DM5
Z6 = zeros(n, n, 4); % DM6

% DM1;
Z1(1,2,:) = IVFF_terms.VLI;
Z1(1,3,:) = IVFF_terms.SMI;
Z1(1,4,:) = IVFF_terms.CHI;
Z1(1,5,:) = IVFF_terms.SMI;
Z1(1,6,:) = IVFF_terms.SLI;
Z1(1,7,:) = IVFF_terms.HI;
Z1(1,8,:) = IVFF_terms.LI;
Z1(1,9,:) = IVFF_terms.CLI;
Z1(2,3,:) = IVFF_terms.CHI;
Z1(2,4,:) = IVFF_terms.CHI;
Z1(2,5,:) = IVFF_terms.CHI;
Z1(2,6,:) = IVFF_terms.SMI;
Z1(2,7,:) = IVFF_terms.CHI;
Z1(2,8,:) = IVFF_terms.SMI;
Z1(2,9,:) = IVFF_terms.SLI;
Z1(3,4,:) = IVFF_terms.SMI;
Z1(3,5,:) = IVFF_terms.EI;
Z1(3,6,:) = IVFF_terms.LI;
Z1(3,7,:) = IVFF_terms.EI;
Z1(3,8,:) = IVFF_terms.VLI;
Z1(3,9,:) = IVFF_terms.CLI;
Z1(4,5,:) = IVFF_terms.SLI;
Z1(4,6,:) = IVFF_terms.CLI;
Z1(4,7,:) = IVFF_terms.SLI;
Z1(4,8,:) = IVFF_terms.CLI;
Z1(4,9,:) = IVFF_terms.CLI;
Z1(5,6,:) = IVFF_terms.CLI;
Z1(5,7,:) = IVFF_terms.EI;
Z1(5,8,:) = IVFF_terms.CLI;
Z1(5,9,:) = IVFF_terms.CLI;
Z1(6,7,:) = IVFF_terms.CHI;
Z1(6,8,:) = IVFF_terms.SLI;
Z1(6,9,:) = IVFF_terms.VLI;
Z1(7,8,:) = IVFF_terms.CLI;
Z1(7,9,:) = IVFF_terms.CLI;
Z1(8,9,:) = IVFF_terms.LI;

% DM2;
Z2(1,2,:) = IVFF_terms.HI;
Z2(1,3,:) = IVFF_terms.SMI;
Z2(1,4,:) = IVFF_terms.CHI;
Z2(1,5,:) = IVFF_terms.CHI;
Z2(1,6,:) = IVFF_terms.VHI;
Z2(1,7,:) = IVFF_terms.VHI;
Z2(1,8,:) = IVFF_terms.VHI;
Z2(1,9,:) = IVFF_terms.EI;
Z2(2,3,:) = IVFF_terms.SLI;
Z2(2,4,:) = IVFF_terms.HI;
Z2(2,5,:) = IVFF_terms.HI;
Z2(2,6,:) = IVFF_terms.SMI;
Z2(2,7,:) = IVFF_terms.SMI;
Z2(2,8,:) = IVFF_terms.SMI;
Z2(2,9,:) = IVFF_terms.LI;
Z2(3,4,:) = IVFF_terms.VHI;
Z2(3,5,:) = IVFF_terms.VHI;
Z2(3,6,:) = IVFF_terms.HI;
Z2(3,7,:) = IVFF_terms.HI;
Z2(3,8,:) = IVFF_terms.HI;
Z2(3,9,:) = IVFF_terms.SLI;
Z2(4,5,:) = IVFF_terms.EI;
Z2(4,6,:) = IVFF_terms.SLI;
Z2(4,7,:) = IVFF_terms.SLI;
Z2(4,8,:) = IVFF_terms.SLI;
Z2(4,9,:) = IVFF_terms.CLI;
Z2(5,6,:) = IVFF_terms.SLI;
Z2(5,7,:) = IVFF_terms.SLI;
Z2(5,8,:) = IVFF_terms.SLI;
Z2(5,9,:) = IVFF_terms.CLI;
Z2(6,7,:) = IVFF_terms.EI;
Z2(6,8,:) = IVFF_terms.EI;
Z2(6,9,:) = IVFF_terms.CLI;
Z2(7,8,:) = IVFF_terms.EI;
Z2(7,9,:) = IVFF_terms.CLI;
Z2(8,9,:) = IVFF_terms.CLI;

% DM3;
Z3(1,2,:) = IVFF_terms.VLI;
Z3(1,3,:) = IVFF_terms.SLI;
Z3(1,4,:) = IVFF_terms.EI;
Z3(1,5,:) = IVFF_terms.SLI;
Z3(1,6,:) = IVFF_terms.SLI;
Z3(1,7,:) = IVFF_terms.VLI;
Z3(1,8,:) = IVFF_terms.VLI;
Z3(1,9,:) = IVFF_terms.CLI;
Z3(2,3,:) = IVFF_terms.HI;
Z3(2,4,:) = IVFF_terms.SMI;
Z3(2,5,:) = IVFF_terms.HI;
Z3(2,6,:) = IVFF_terms.SMI;
Z3(2,7,:) = IVFF_terms.SLI;
Z3(2,8,:) = IVFF_terms.VLI;
Z3(2,9,:) = IVFF_terms.LI;
Z3(3,4,:) = IVFF_terms.SMI;
Z3(3,5,:) = IVFF_terms.SMI;
Z3(3,6,:) = IVFF_terms.SLI;
Z3(3,7,:) = IVFF_terms.LI;
Z3(3,8,:) = IVFF_terms.VLI;
Z3(3,9,:) = IVFF_terms.LI;
Z3(4,5,:) = IVFF_terms.SMI;
Z3(4,6,:) = IVFF_terms.LI;
Z3(4,7,:) = IVFF_terms.LI;
Z3(4,8,:) = IVFF_terms.VLI;
Z3(4,9,:) = IVFF_terms.LI;
Z3(5,6,:) = IVFF_terms.SLI;
Z3(5,7,:) = IVFF_terms.LI;
Z3(5,8,:) = IVFF_terms.VLI;
Z3(5,9,:) = IVFF_terms.VLI;
Z3(6,7,:) = IVFF_terms.SLI;
Z3(6,8,:) = IVFF_terms.VLI;
Z3(6,9,:) = IVFF_terms.LI;
Z3(7,8,:) = IVFF_terms.SLI;
Z3(7,9,:) = IVFF_terms.SLI;
Z3(8,9,:) = IVFF_terms.EI;

% DM4;
Z4(1,2,:) = IVFF_terms.EI;
Z4(1,3,:) = IVFF_terms.EI;
Z4(1,4,:) = IVFF_terms.CHI;
Z4(1,5,:) = IVFF_terms.CHI;
Z4(1,6,:) = IVFF_terms.VHI;
Z4(1,7,:) = IVFF_terms.CHI;
Z4(1,8,:) = IVFF_terms.SMI;
Z4(1,9,:) = IVFF_terms.SLI;
Z4(2,3,:) = IVFF_terms.SMI;
Z4(2,4,:) = IVFF_terms.CHI;
Z4(2,5,:) = IVFF_terms.CHI;
Z4(2,6,:) = IVFF_terms.VHI;
Z4(2,7,:) = IVFF_terms.VHI;
Z4(2,8,:) = IVFF_terms.HI;
Z4(2,9,:) = IVFF_terms.LI;
Z4(3,4,:) = IVFF_terms.CHI;
Z4(3,5,:) = IVFF_terms.CHI;
Z4(3,6,:) = IVFF_terms.HI;
Z4(3,7,:) = IVFF_terms.VHI;
Z4(3,8,:) = IVFF_terms.SMI;
Z4(3,9,:) = IVFF_terms.VLI;
Z4(4,5,:) = IVFF_terms.EI;
Z4(4,6,:) = IVFF_terms.LI;
Z4(4,7,:) = IVFF_terms.SLI;
Z4(4,8,:) = IVFF_terms.VLI;
Z4(4,9,:) = IVFF_terms.CLI;
Z4(5,6,:) = IVFF_terms.LI;
Z4(5,7,:) = IVFF_terms.SLI;
Z4(5,8,:) = IVFF_terms.VLI;
Z4(5,9,:) = IVFF_terms.CLI;
Z4(6,7,:) = IVFF_terms.SMI;
Z4(6,8,:) = IVFF_terms.SLI;
Z4(6,9,:) = IVFF_terms.CLI;
Z4(7,8,:) = IVFF_terms.LI;
Z4(7,9,:) = IVFF_terms.CLI;
Z4(8,9,:) = IVFF_terms.CLI;

% DM5;
Z5(1,2,:) = IVFF_terms.EI;
Z5(1,3,:) = IVFF_terms.SMI;
Z5(1,4,:) = IVFF_terms.CHI;
Z5(1,5,:) = IVFF_terms.CHI;
Z5(1,6,:) = IVFF_terms.HI;
Z5(1,7,:) = IVFF_terms.VHI;
Z5(1,8,:) = IVFF_terms.HI;
Z5(1,9,:) = IVFF_terms.SLI;
Z5(2,3,:) = IVFF_terms.SMI;
Z5(2,4,:) = IVFF_terms.CHI;
Z5(2,5,:) = IVFF_terms.CHI;
Z5(2,6,:) = IVFF_terms.HI;
Z5(2,7,:) = IVFF_terms.VHI;
Z5(2,8,:) = IVFF_terms.HI;
Z5(2,9,:) = IVFF_terms.SLI;
Z5(3,4,:) = IVFF_terms.VHI;
Z5(3,5,:) = IVFF_terms.VHI;
Z5(3,6,:) = IVFF_terms.SMI;
Z5(3,7,:) = IVFF_terms.HI;
Z5(3,8,:) = IVFF_terms.SMI;
Z5(3,9,:) = IVFF_terms.LI;
Z5(4,5,:) = IVFF_terms.EI;
Z5(4,6,:) = IVFF_terms.LI;
Z5(4,7,:) = IVFF_terms.SLI;
Z5(4,8,:) = IVFF_terms.LI;
Z5(4,9,:) = IVFF_terms.CLI;
Z5(5,6,:) = IVFF_terms.LI;
Z5(5,7,:) = IVFF_terms.SLI;
Z5(5,8,:) = IVFF_terms.LI;
Z5(5,9,:) = IVFF_terms.CLI;
Z5(6,7,:) = IVFF_terms.SMI;
Z5(6,8,:) = IVFF_terms.EI;
Z5(6,9,:) = IVFF_terms.CLI;
Z5(7,8,:) = IVFF_terms.SLI;
Z5(7,9,:) = IVFF_terms.CLI;
Z5(8,9,:) = IVFF_terms.CLI;

% DM6;
Z6(1,2,:) = IVFF_terms.VLI;
Z6(1,3,:) = IVFF_terms.SMI;
Z6(1,4,:) = IVFF_terms.HI;
Z6(1,5,:) = IVFF_terms.HI;
Z6(1,6,:) = IVFF_terms.EI;
Z6(1,7,:) = IVFF_terms.SMI;
Z6(1,8,:) = IVFF_terms.EI;
Z6(1,9,:) = IVFF_terms.SMI;
Z6(2,3,:) = IVFF_terms.VHI;
Z6(2,4,:) = IVFF_terms.CHI;
Z6(2,5,:) = IVFF_terms.CHI;
Z6(2,6,:) = IVFF_terms.HI;
Z6(2,7,:) = IVFF_terms.CHI;
Z6(2,8,:) = IVFF_terms.SMI;
Z6(2,9,:) = IVFF_terms.EI;
Z6(3,4,:) = IVFF_terms.SMI;
Z6(3,5,:) = IVFF_terms.SMI;
Z6(3,6,:) = IVFF_terms.SLI;
Z6(3,7,:) = IVFF_terms.EI;
Z6(3,8,:) = IVFF_terms.LI;
Z6(3,9,:) = IVFF_terms.CLI;
Z6(4,5,:) = IVFF_terms.EI;
Z6(4,6,:) = IVFF_terms.LI;
Z6(4,7,:) = IVFF_terms.SLI;
Z6(4,8,:) = IVFF_terms.VLI;
Z6(4,9,:) = IVFF_terms.CLI;
Z6(5,6,:) = IVFF_terms.LI;
Z6(5,7,:) = IVFF_terms.SLI;
Z6(5,8,:) = IVFF_terms.VLI;
Z6(5,9,:) = IVFF_terms.CLI;
Z6(6,7,:) = IVFF_terms.HI;
Z6(6,8,:) = IVFF_terms.SLI;
Z6(6,9,:) = IVFF_terms.SLI;
Z6(7,8,:) = IVFF_terms.CLI;
Z6(7,9,:) = IVFF_terms.CLI;
Z6(8,9,:) = IVFF_terms.SLI;

for i = 1:n
    Z1(i,i,:) = IVFF_terms.EI;
    Z2(i,i,:) = IVFF_terms.EI;
    Z3(i,i,:) = IVFF_terms.EI;
    Z4(i,i,:) = IVFF_terms.EI;
    Z5(i,i,:) = IVFF_terms.EI;
    Z6(i,i,:) = IVFF_terms.EI;
end

for i = 1:n
    for j = i+1:n
        Z1(j,i,:) = [ Z1(i,j,3), Z1(i,j,4), Z1(i,j,1), Z1(i,j,2)];
        Z2(j,i,:) = [ Z2(i,j,3), Z2(i,j,4), Z2(i,j,1), Z2(i,j,2)];
        Z3(j,i,:) = [ Z3(i,j,3), Z3(i,j,4), Z3(i,j,1), Z3(i,j,2)];
        Z4(j,i,:) = [ Z4(i,j,3), Z4(i,j,4), Z4(i,j,1), Z4(i,j,2)];
        Z5(j,i,:) = [ Z5(i,j,3), Z5(i,j,4), Z5(i,j,1), Z5(i,j,2)];
        Z6(j,i,:) = [ Z6(i,j,3), Z6(i,j,4), Z6(i,j,1), Z6(i,j,2)];
    end
end

% Step 5: IVFFWA operator
finalZ = zeros(n, n, 4);

for i = 1:n
    for j = 1:n
        mu_L_combined = 1 - nthroot(prod(1 - (1 - [Z1(i,j,1), Z2(i,j,1), Z3(i,j,1), Z4(i,j,1), Z5(i,j,1), Z6(i,j,1) ]).^3 .* weights), 3);
        mu_U_combined = 1 - nthroot(prod(1 - (1 - [Z1(i,j,2), Z2(i,j,2), Z3(i,j,2), Z4(i,j,2), Z5(i,j,2), Z6(i,j,2) ]).^3 .* weights), 3);
        nu_L_combined = prod([Z1(i,j,3), Z2(i,j,3), Z3(i,j,3), Z4(i,j,3), Z5(i,j,3), Z6(i,j,3) ].^weights);
        nu_U_combined = prod([Z1(i,j,4), Z2(i,j,4), Z3(i,j,4), Z4(i,j,4), Z5(i,j,4), Z6(i,j,4) ].^weights);
        
        finalZ(i,j,:) = [mu_L_combined, mu_U_combined, nu_L_combined, nu_U_combined];
    end
end

% Step 6:
dL = zeros(n, n);
dU = zeros(n, n);

for i = 1:n
    for j = 1:n
        dL(i,j) = (finalZ(i,j,1))^3 - (finalZ(i,j,4))^3;
        dU(i,j) = (finalZ(i,j,2))^3 - (finalZ(i,j,3))^3;
    end
end

% Step 7:
sL = zeros(n, n);
sU = zeros(n, n);

for i = 1:n
    for j = 1:n
        sL(i,j) = nthroot(1000 * dL(i,j), 3);
        sU(i,j) = nthroot(1000 * dU(i,j), 3);
    end
end

% Step 8:
tij = zeros(n, n);

for i = 1:n
    for j = 1:n
        tij(i,j) = 1 - ((finalZ(i,j,2))^3 - (finalZ(i,j,1))^3) - ((finalZ(i,j,4))^3 - (finalZ(i,j,3))^3);
    end
end

% Step 9:
rij = zeros(n, n);

for i = 1:n
    for j = 1:n
        rij(i,j) = ((sL(i,j) + sU(i,j)) / 2) * tij(i,j);
    end
end

% Step 10:
wi = zeros(1, n);

total_rij = sum(rij, 'all');

for i = 1:n
    wi(i) = sum(rij(i, :)) / total_rij;
end

% Results
disp('w_i Değerleri (Hazard scores according to human error):');
disp(wi);