which code is better?

code 1:
% MOEMA optimization with Levy Flights and Enhanced Crowding Distance
% Main script to run MOEMA optimization with improvements
clc;
clear;
close all;

% Set problem parameters
NPop = 50;  % Population size
T = 500;     % Number of iterations
dim = 30;    % Number of decision variables
lb = zeros(1, dim);  % Lower bound
ub = ones(1, dim);   % Upper bound

num_runs = 20;          % Number of runs for statistical evaluation

% Storage for metrics
GD_values = zeros(num_runs, 1);
IGD_values = zeros(num_runs, 1);
Spacing_values = zeros(num_runs, 1);

% store best pareto
paretoFronts = cell(num_runs, 1);
paretoSets = cell(num_runs, 1);
%% Run MOEMA Multiple Times
for run = 1:num_runs
    fprintf('Run #%d/%d\n', run, num_runs);
    
    % Run MOEMA
    [paretoFront, paretoSet, Trajectories, fitness_history, position_history] = ...
        MOEMA(NPop, T, lb, ub, dim, @zdt1);
    
    
    % Store Pareto front and set
    paretoFronts{run} = paretoFront;
    paretoSets{run} = paretoSet;
    
    % Get True Pareto Front
    true_pareto = get_true_pareto();
    
    
    % Update the metrics calculation in the main loop:
    [GD_values(run), IGD_values(run), Spacing_values(run)] = calculate_metrics(paretoFront, true_pareto);

end

metrics = {GD_values, IGD_values, Spacing_values};
metric_names = {'GD', 'IGD', 'Spacing'};

% Find the best run based on the chosen metric (e.g., IGD)
[~, best_run_idx] = min(IGD_values);
best_paretoFront = paretoFronts{best_run_idx};
best_paretoSet = paretoSets{best_run_idx};


% Print results
fprintf('\nPerformance Metrics over %d runs:\n', num_runs);
for i = 1:length(metrics)
    fprintf('\n%s Statistics:\n', metric_names{i});
    fprintf('  Best    = %.4f\n', min(metrics{i}));
    fprintf('  Average = %.4f\n', mean(metrics{i}));
    fprintf('  Median  = %.4f\n', median(metrics{i}));
    fprintf('  Worst   = %.4f\n', max(metrics{i}));
    fprintf('  Std Dev = %.4f\n', std(metrics{i}));
end

%% Plot Results

% Plot the best Pareto Front
figure;
plot(best_paretoFront(:,1), best_paretoFront(:,2), 'ro', 'MarkerSize', 6, 'MarkerFaceColor', 'r');
hold on;
plot(true_pareto(:,1), true_pareto(:,2), 'b--', 'LineWidth', 1.5);
xlabel('f1');
ylabel('f2');
title('Pareto Front for ZDT1 (MOEMA)');
legend('Obtained Pareto Front', 'True Pareto Front');
grid on;
hold off;

% Display metrics for the best run
fprintf('\nBest Run #%d Metrics:\n', best_run_idx);
fprintf('GD    = %.4f\n', GD_values(best_run_idx));
fprintf('IGD   = %.4f\n', IGD_values(best_run_idx));
% Plot Pareto Front
figure;
plot(paretoFront(:,1), paretoFront(:,2), 'ro', 'MarkerSize', 6, 'MarkerFaceColor', 'r');
hold on;
plot(true_pareto(:,1), true_pareto(:,2), 'b--', 'LineWidth', 1.5);
xlabel('f1');
ylabel('f2');
title('Pareto Front for ZDT1 (MOEMA)');
legend('Obtained Pareto Front', 'True Pareto Front');
grid on;
hold off;

function [paretoFront, paretoSet, Trajectories, fitness_history, position_history] = MOEMA(NPop, T, lb, ub, dim, FITNESSFCN)
% Multi-Objective Evolutionary Mating Algorithm (MOEMA) with improvements

% Preallocation
fitness_history = zeros(NPop, T, 2);  % Assuming 2 objectives
position_history = zeros(NPop, T, dim);
Trajectories = zeros(dim, T);

% Generation of initial population
pop = initialization(NPop, dim, ub, lb);
pop_dad = pop(1:NPop/2, :);  % Eqn (1) in the paper
pop_mum = pop(NPop/2+1:end, :); % Eqn (2) in the paper

% Evaluation of objective function for initialization
obj_dad = evaluate_population(pop_dad, FITNESSFCN);
obj_mum = evaluate_population(pop_mum, FITNESSFCN);
obj = [obj_dad; obj_mum];

% Initialize archive with non-dominated solutions
archive = update_archive([], [], pop, obj);

for gen = 1:T  % Start iteration
    k1 = randperm(NPop/2);
    k2 = randperm(NPop/2);
    k1x = pop_dad(k1, :);
    k2x = pop_mum(k2, :);
    
    for k = 1:NPop/2
        % Mating process
        Imates = 1 + (var(k1x(k, :)) - var(k2x(k, :))); % Eqn (4) in the paper
        p = randn(1, dim);  % Eqn (6) in the paper
        r = levy_flights(1, dim);  % Using Levy flights
        
        if Imates >= 0  % Upper part of Eqn (5) in the paper
            temp1 = p .* k1x(k, :);
            temp2 = (1-p) .* k2x(k, :);
            pop_child = temp1 + temp2;
        else  % Lower part of Eqn (5) in the paper
            temp1 = p .* k2x(k, :);
            temp2 = (1-p) .* k1x(k, :);
            pop_child = temp1 + temp2;
        end
        
        % Enhanced Impact of best environment (using random non-dominated solution)
        if ~isempty(archive.pop)
            best_pop = archive.pop(randi(size(archive.pop, 1)), :);
            K = rand(1, dim) < 0.8;  % Eqn (8) in the paper
            pop_child = best_pop .* (1-K) + pop_child .* K;  % Eqn (7) in the paper
        end
        
                % Mutation operator
            if rand() < 0.1
                % Special handling for x1
                if rand() < 0.5
                    pop_child(1) = pop_child(1) + randn() * 0.1;
                    pop_child(1) = max(0, min(1, pop_child(1)));
                end
                % Regular mutation for other variables
                mutation_idx = rand(1, dim-1) < 0.1;
                pop_child(2:end) = pop_child(2:end) + mutation_idx .* randn(1, dim-1) * 0.1;
            end
        
        % Bounding of the solution
        pop_child = max(min(ub, pop_child), lb);
        
        % Evaluate child
        obj_child = FITNESSFCN(pop_child);
        
        % Update population using non-dominated sorting
        [pop_dad, obj_dad] = update_population(pop_dad, obj_dad, pop_child, obj_child, k1(k));
        [pop_mum, obj_mum] = update_population(pop_mum, obj_mum, pop_child, obj_child, k2(k));
        
        % Exploration process with levy flight
        if rand() < 0.2
            if ~isempty(archive.pop)
                temp1 = archive.pop(randi(size(archive.pop, 1)), :);
                pop_child = levy_flights(1, dim) .* temp1;  % Exploring with Levy flights
                pop_child = max(min(ub, pop_child), lb);
                obj_child = FITNESSFCN(pop_child);
                
                % Update population using non-dominated sorting
                [pop_dad, obj_dad] = update_population(pop_dad, obj_dad, pop_child, obj_child, randi(NPop/2));
                [pop_mum, obj_mum] = update_population(pop_mum, obj_mum, pop_child, obj_child, randi(NPop/2));
            end
        end
    end
    
    % Combine updated pool dad and mum
    pop = [pop_dad; pop_mum];
    obj = [obj_dad; obj_mum];
    
    % Update archive
    archive = update_archive(archive.pop, archive.obj, pop, obj);
    
    % Record the history at each iteration
    fitness_history(:, gen, :) = obj;
    position_history(:, gen, :) = pop;
    
    % Update Trajectories (using a random non-dominated solution)
    if ~isempty(archive.pop)
        Trajectories(:, gen) = archive.pop(randi(size(archive.pop, 1)), :)';
    end
    
        % Display progress every 10 iterations
    if mod(gen, 50) == 0
        disp(['Iteration #', num2str(gen), ' completed. Archive size: ', num2str(size(archive.pop, 1))]);
    end
end

% Return Pareto front and Pareto set
paretoFront = archive.obj;
paretoSet = archive.pop;

end

% Helper Functions

function pop = initialization(NPop, dim, ub, lb)
    pop = rand(NPop, dim) .* (ub - lb) + lb;
end

function obj = evaluate_population(pop, FITNESSFCN)
    obj = zeros(size(pop, 1), 2);  % Assuming 2 objectives
    for i = 1:size(pop, 1)
        obj(i, :) = FITNESSFCN(pop(i, :));
    end
end

function [pop, obj] = update_population(pop, obj, child, child_obj, index)
    if dominates(child_obj, obj(index, :))
        pop(index, :) = child;
        obj(index, :) = child_obj;
    elseif ~dominates(obj(index, :), child_obj)
        if rand() < 0.5
            pop(index, :) = child;
            obj(index, :) = child_obj;
        end
    end
end

function archive = update_archive(archive_pop, archive_obj, pop, obj)
    combined_pop = [archive_pop; pop];
    combined_obj = [archive_obj; obj];
    
    [is_dominated, ~] = pareto_dominance(combined_obj);
    non_dominated = ~is_dominated;
    
    archive.pop = combined_pop(non_dominated, :);
    archive.obj = combined_obj(non_dominated, :);
    archive_size_max = 200;
    % Enhanced crowding distance (using NSGA-II inspired technique)
    if size(archive.pop, 1) > archive_size_max
        crowding_distances = calculate_crowding_distances(archive.obj);
        [~, sorted_indices] = sort(crowding_distances, 'descend');
        archive.pop = archive.pop(sorted_indices(1:archive_size_max), :);
        archive.obj = archive.obj(sorted_indices(1:archive_size_max), :);
    end
end

function distances = calculate_crowding_distances(objectives)
    num_solutions = size(objectives, 1);
    distances = zeros(num_solutions, 1);

    for m = 1:size(objectives, 2)
        [values, idx] = sort(objectives(:, m));
        distances(idx(1)) = inf;
        distances(idx(end)) = inf;

        for i = 2:num_solutions-1
            distances(idx(i)) = distances(idx(i)) + ...
                (values(i+1) - values(i-1)) / (max(values) - min(values));
        end
    end
end

function [is_dominated, domination_count] = pareto_dominance(objectives)
    [n_solutions, n_objectives] = size(objectives);
    is_dominated = false(n_solutions, 1);
    domination_count = zeros(n_solutions, 1);

    for i = 1:n_solutions
        for j = i+1:n_solutions
            if dominates(objectives(i, :), objectives(j, :))
                is_dominated(j) = true;
                domination_count(i) = domination_count(i) + 1;
            elseif dominates(objectives(j, :), objectives(i, :))
                is_dominated(i) = true;
                domination_count(j) = domination_count(j) + 1;
            end
        end
    end
end

function result = dominates(obj1, obj2)
    result = all(obj1 <= obj2) && any(obj1 < obj2);
end

function steps = levy_flights(n, dim, beta)
    % Generates n Levy flight steps in dim dimensions based on Mantegna's algorithm
    if nargin < 3
        beta = 1.5;
    end
    sigma_u = (gamma(1 + beta) * sin(pi * beta / 2) / ...
        (gamma((1 + beta) / 2) * beta * 2^((beta - 1) / 2)))^(1/beta);
    u = random('Normal', 0, sigma_u, n, dim);
    v = random('Normal', 0, 1, n, dim);
    steps = u ./ abs(v).^(1 / beta);
end

function f = zdt1(x)
    f1 = x(1);
    g = 1 + 9 * sum(x(2:end)) / (length(x) - 1);
    h = 1 - sqrt(f1 / g);
    f2 = g * h;
    f = [f1, f2];
end

function true_pareto = get_true_pareto()
    num_points = 100;
    f1 = linspace(0, 1, num_points)';
    f2 = 1 - sqrt(f1);
    true_pareto = [f1, f2];
end

%% Performance Metrics Functions

function [GD, IGD, Spacing] = calculate_metrics(obtained_pf, true_pf)
    GD = generational_distance(obtained_pf, true_pf);
    IGD = inverted_generational_distance(obtained_pf, true_pf);
    Spacing = spacing_metric(obtained_pf);
end

function gd = generational_distance(obtained_pf, true_pf)
    if isempty(obtained_pf)
        gd = Inf;
        return;
    end
    distances = zeros(size(obtained_pf, 1), 1);
    for i = 1:size(obtained_pf, 1)
        dist_to_true = sqrt(sum((true_pf - obtained_pf(i,:)).^2, 2));
        distances(i) = min(dist_to_true);
    end
    p = 2;
    gd = (sum(distances.^p) / size(obtained_pf, 1))^(1/p);
end

function igd = inverted_generational_distance(obtained_pf, true_pf)
    if isempty(obtained_pf)
        igd = Inf;
        return;
    end
    distances = zeros(size(true_pf, 1), 1);
    for i = 1:size(true_pf, 1)
        dist_to_obtained = sqrt(sum((obtained_pf - true_pf(i,:)).^2, 2));
        distances(i) = min(dist_to_obtained);
    end
    p = 2;
    igd = (sum(distances.^p) / size(true_pf, 1))^(1/p);
end

function spacing = spacing_metric(obtained_pf)
    if size(obtained_pf, 1) < 2
        spacing = Inf;
        return;
    end
    
    n = size(obtained_pf, 1);
    d = zeros(n, 1);
    
    % Calculate di for each solution
    for i = 1:n
        % Calculate distances to all other solutions
        min_dist = Inf;
        for j = 1:n
            if i ~= j
                % Calculate |f1(x) - f1(x')| + |f2(x) - f2(x')|
                dist = abs(obtained_pf(i,1) - obtained_pf(j,1)) + ...
                       abs(obtained_pf(i,2) - obtained_pf(j,2));
                min_dist = min(min_dist, dist);
            end
        end
        d(i) = min_dist;
    end
    
    % Calculate mean of distances
    d_bar = mean(d);
    
    % Calculate spacing metric SP
    spacing = sqrt(sum((d_bar - d).^2) / (n - 1));
end


code2:
% MOEMA optimization with Levy Flights and Enhanced Crowding Distance
% Main script to run MOEMA optimization with improvements
clc;
clear;
close all;

% Set problem parameters
NPop = 50;  % Population size
T = 500;     % Number of iterations
dim = 30;    % Number of decision variables
lb = zeros(1, dim);  % Lower bound
ub = ones(1, dim);   % Upper bound

num_runs = 1;          % Number of runs for statistical evaluation

% Storage for metrics
GD_values = zeros(num_runs, 1);
IGD_values = zeros(num_runs, 1);
Spacing_values = zeros(num_runs, 1);

% store best pareto
paretoFronts = cell(num_runs, 1);
paretoSets = cell(num_runs, 1);
%% Run MOEMA Multiple Times
for run = 1:num_runs
    fprintf('Run #%d/%d\n', run, num_runs);
    
    % Run MOEMA
    [paretoFront, paretoSet, Trajectories, fitness_history, position_history] = ...
        MOEMA(NPop, T, lb, ub, dim, @zdt1);
    
    
    % Store Pareto front and set
    paretoFronts{run} = paretoFront;
    paretoSets{run} = paretoSet;
    
    % Get True Pareto Front
    true_pareto = get_true_pareto();
    
    
    % Update the metrics calculation in the main loop:
    [GD_values(run), IGD_values(run), Spacing_values(run)] = calculate_metrics(paretoFront, true_pareto);

end

metrics = {GD_values, IGD_values, Spacing_values};
metric_names = {'GD', 'IGD', 'Spacing'};

% Find the best run based on the chosen metric (e.g., IGD)
[~, best_run_idx] = min(IGD_values);
best_paretoFront = paretoFronts{best_run_idx};
best_paretoSet = paretoSets{best_run_idx};


% Print results
fprintf('\nPerformance Metrics over %d runs:\n', num_runs);
for i = 1:length(metrics)
    fprintf('\n%s Statistics:\n', metric_names{i});
    fprintf('  Best    = %.4f\n', min(metrics{i}));
    fprintf('  Average = %.4f\n', mean(metrics{i}));
    fprintf('  Median  = %.4f\n', median(metrics{i}));
    fprintf('  Worst   = %.4f\n', max(metrics{i}));
    fprintf('  Std Dev = %.4f\n', std(metrics{i}));
end

%% Plot Results

% Plot the best Pareto Front
figure;
plot(best_paretoFront(:,1), best_paretoFront(:,2), 'ro', 'MarkerSize', 6, 'MarkerFaceColor', 'r');
hold on;
plot(true_pareto(:,1), true_pareto(:,2), 'b--', 'LineWidth', 1.5);
xlabel('f1');
ylabel('f2');
title('Pareto Front for ZDT1 (MOEMA)');
legend('Obtained Pareto Front', 'True Pareto Front');
grid on;
hold off;

% Display metrics for the best run
fprintf('\nBest Run #%d Metrics:\n', best_run_idx);
fprintf('GD    = %.4f\n', GD_values(best_run_idx));
fprintf('IGD   = %.4f\n', IGD_values(best_run_idx));
% Plot Pareto Front
figure;
plot(paretoFront(:,1), paretoFront(:,2), 'ro', 'MarkerSize', 6, 'MarkerFaceColor', 'r');
hold on;
plot(true_pareto(:,1), true_pareto(:,2), 'b--', 'LineWidth', 1.5);
xlabel('f1');
ylabel('f2');
title('Pareto Front for ZDT1 (MOEMA)');
legend('Obtained Pareto Front', 'True Pareto Front');
grid on;
hold off;

function [paretoFront, paretoSet, Trajectories, fitness_history, position_history] = MOEMA(NPop, T, lb, ub, dim, FITNESSFCN)
% Multi-Objective Evolutionary Mating Algorithm (MOEMA) with improvements
% Following the research proposal specifications

% Preallocation
fitness_history = zeros(NPop, T, 2);  % Assuming 2 objectives
position_history = zeros(NPop, T, dim);
Trajectories = zeros(dim, T);

% Generation of initial population following Equations (1) and (2)
pop = initialization(NPop, dim, ub, lb);
pop_dad = pop(1:NPop/2, :);  % Males - Equation (1)
pop_mum = pop(NPop/2+1:end, :); % Females - Equation (2)

% Initial evaluation
obj_dad = evaluate_population(pop_dad, FITNESSFCN);
obj_mum = evaluate_population(pop_mum, FITNESSFCN);
obj = [obj_dad; obj_mum];

% Initialize archive with non-dominated solutions
archive = update_archive([], [], pop, obj);

for gen = 1:T
    k1 = randperm(NPop/2);
    k2 = randperm(NPop/2);
    k1x = pop_dad(k1, :);
    k2x = pop_mum(k2, :);
    
    for k = 1:NPop/2
        % Mating process using Hardy-Weinberg principle
        % Calculate Imates using Equation (4)
        var_male = var(k1x(k, :));
        var_female = var(k2x(k, :));
        Imates = 1 + (var_male - var_female);
        
        % Generate p and q following Hardy-Weinberg principle
        p = randn(1, dim);  % Equation (6)
        q = 1 - p;  % Following HW principle
        
        % Create offspring using Equation (5)
        if Imates >= 0
            pop_child = p .* k1x(k, :) + q .* k2x(k, :);
        else
            pop_child = p .* k2x(k, :) + q .* k1x(k, :);
        end
        
        % Impact of best environment using Equation (7)
        if ~isempty(archive.pop)
            best_pop = archive.pop(randi(size(archive.pop, 1)), :);
            K = rand(1, dim) < 0.8;  % Equation (8)
            pop_child = best_pop .* (1-K) + pop_child .* K;
        end
        
        % Environmental effects (predator encounters) using Equation (9)
        if rand() < 0.2  % Predator encounter probability r
            if ~isempty(archive.pop)
                best_solution = archive.pop(randi(size(archive.pop, 1)), :);
                % Apply Levy flight using Equations (11-13)
                levy_step = improved_levy_flights(1, dim);
                pop_child = levy_step .* best_solution;
            end
        end
        
        % Boundary handling
        pop_child = max(min(ub, pop_child), lb);
        
        % Evaluate offspring
        obj_child = FITNESSFCN(pop_child);
        
        % Update populations using non-dominated sorting
        [pop_dad, obj_dad] = update_population(pop_dad, obj_dad, pop_child, obj_child, k1(k));
        [pop_mum, obj_mum] = update_population(pop_mum, obj_mum, pop_child, obj_child, k2(k));
    end
    
    % Combine populations
    pop = [pop_dad; pop_mum];
    obj = [obj_dad; obj_mum];
    
    % Update archive with improved crowding distance
    archive = update_archive_improved(archive.pop, archive.obj, pop, obj);
    
    % Record history
    fitness_history(:, gen, :) = obj;
    position_history(:, gen, :) = pop;
    
    if ~isempty(archive.pop)
        Trajectories(:, gen) = archive.pop(randi(size(archive.pop, 1)), :)';
    end
    
    % Display progress
    if mod(gen, 50) == 0
        disp(['Iteration #', num2str(gen), ' completed. Archive size: ', num2str(size(archive.pop, 1))]);
    end
end

paretoFront = archive.obj;
paretoSet = archive.pop;
end

% Helper Functions

function pop = initialization(NPop, dim, ub, lb)
    pop = rand(NPop, dim) .* (ub - lb) + lb;
end
function archive = update_archive(archive_pop, archive_obj, pop, obj)
    combined_pop = [archive_pop; pop];
    combined_obj = [archive_obj; obj];
    
    [is_dominated, ~] = pareto_dominance(combined_obj);
    non_dominated = ~is_dominated;
    
    archive.pop = combined_pop(non_dominated, :);
    archive.obj = combined_obj(non_dominated, :);
    archive_size_max = 200;
    % Enhanced crowding distance (using NSGA-II inspired technique)
    if size(archive.pop, 1) > archive_size_max
        crowding_distances = calculate_crowding_distances(archive.obj);
        [~, sorted_indices] = sort(crowding_distances, 'descend');
        archive.pop = archive.pop(sorted_indices(1:archive_size_max), :);
        archive.obj = archive.obj(sorted_indices(1:archive_size_max), :);
    end
end

function obj = evaluate_population(pop, FITNESSFCN)
    obj = zeros(size(pop, 1), 2);
    for i = 1:size(pop, 1)
        obj(i, :) = FITNESSFCN(pop(i, :));
    end
end

function steps = improved_levy_flights(n, dim)
    % Implementation of Equations (11-13)
    beta = 1.5;  % As specified in proposal
    sigma = ((gamma(1 + beta) * sin(pi * beta / 2)) / ...
            (gamma((1 + beta) / 2) * beta * 2^((beta - 1) / 2)))^(1/beta);
    r1 = randn(n, dim) * sigma;
    r2 = randn(n, dim);
    steps = r1 ./ abs(r2).^(1/beta);
end

function archive = update_archive_improved(archive_pop, archive_obj, pop, obj)
    combined_pop = [archive_pop; pop];
    combined_obj = [archive_obj; obj];
    
    [is_dominated, ~] = pareto_dominance(combined_obj);
    non_dominated = ~is_dominated;
    
    archive.pop = combined_pop(non_dominated, :);
    archive.obj = combined_obj(non_dominated, :);
    
    % Apply size limit with improved crowding distance
    archive_size_max = 200;
    if size(archive.pop, 1) > archive_size_max
        crowding_distances = improved_crowding_distance(archive.obj);
        [~, sorted_indices] = sort(crowding_distances, 'descend');
        archive.pop = archive.pop(sorted_indices(1:archive_size_max), :);
        archive.obj = archive.obj(sorted_indices(1:archive_size_max), :);
    end
end

function distances = improved_crowding_distance(objectives)
    % Implementation of improved crowding distance from Fig. 6
    [n_solutions, n_objectives] = size(objectives);
    distances = zeros(n_solutions, 1);
    
    % For each objective
    for m = 1:n_objectives
        [sorted_obj, idx] = sort(objectives(:, m));
        
        % Boundary points always get infinite distance
        distances(idx(1)) = inf;
        distances(idx(end)) = inf;
        
        for i = 2:n_solutions-1
            % Calculate inner rectangle perimeter instead of outer
            prev_diff = sorted_obj(i) - sorted_obj(i-1);
            next_diff = sorted_obj(i+1) - sorted_obj(i);
            
            % Use smaller differences for better convergence
            distances(idx(i)) = distances(idx(i)) + ...
                min(prev_diff, next_diff) / (max(sorted_obj) - min(sorted_obj));
        end
    end
end

function [pop, obj] = update_population(pop, obj, child, child_obj, index)
    if dominates(child_obj, obj(index, :))
        pop(index, :) = child;
        obj(index, :) = child_obj;
    elseif ~dominates(obj(index, :), child_obj)
        if rand() < 0.5
            pop(index, :) = child;
            obj(index, :) = child_obj;
        end
    end
end

function [is_dominated, domination_count] = pareto_dominance(objectives)
    [n_solutions, ~] = size(objectives);
    is_dominated = false(n_solutions, 1);
    domination_count = zeros(n_solutions, 1);
    
    for i = 1:n_solutions
        for j = i+1:n_solutions
            if dominates(objectives(i, :), objectives(j, :))
                is_dominated(j) = true;
                domination_count(i) = domination_count(i) + 1;
            elseif dominates(objectives(j, :), objectives(i, :))
                is_dominated(i) = true;
                domination_count(j) = domination_count(j) + 1;
            end
        end
    end
end

function result = dominates(obj1, obj2)
    result = all(obj1 <= obj2) && any(obj1 < obj2);
end
function f = zdt1(x)
    f1 = x(1);
    g = 1 + 9 * sum(x(2:end)) / (length(x) - 1);
    h = 1 - sqrt(f1 / g);
    f2 = g * h;
    f = [f1, f2];
end

function true_pareto = get_true_pareto()
    num_points = 100;
    f1 = linspace(0, 1, num_points)';
    f2 = 1 - sqrt(f1);
    true_pareto = [f1, f2];
end

%% Performance Metrics Functions

function [GD, IGD, Spacing] = calculate_metrics(obtained_pf, true_pf)
    GD = generational_distance(obtained_pf, true_pf);
    IGD = inverted_generational_distance(obtained_pf, true_pf);
    Spacing = spacing_metric(obtained_pf);
end

function gd = generational_distance(obtained_pf, true_pf)
    if isempty(obtained_pf)
        gd = Inf;
        return;
    end
    distances = zeros(size(obtained_pf, 1), 1);
    for i = 1:size(obtained_pf, 1)
        dist_to_true = sqrt(sum((true_pf - obtained_pf(i,:)).^2, 2));
        distances(i) = min(dist_to_true);
    end
    p = 2;
    gd = (sum(distances.^p) / size(obtained_pf, 1))^(1/p);
end

function igd = inverted_generational_distance(obtained_pf, true_pf)
    if isempty(obtained_pf)
        igd = Inf;
        return;
    end
    distances = zeros(size(true_pf, 1), 1);
    for i = 1:size(true_pf, 1)
        dist_to_obtained = sqrt(sum((obtained_pf - true_pf(i,:)).^2, 2));
        distances(i) = min(dist_to_obtained);
    end
    p = 2;
    igd = (sum(distances.^p) / size(true_pf, 1))^(1/p);
end

function spacing = spacing_metric(obtained_pf)
    if size(obtained_pf, 1) < 2
        spacing = Inf;
        return;
    end
    
    n = size(obtained_pf, 1);
    d = zeros(n, 1);
    
    % Calculate di for each solution
    for i = 1:n
        % Calculate distances to all other solutions
        min_dist = Inf;
        for j = 1:n
            if i ~= j
                % Calculate |f1(x) - f1(x')| + |f2(x) - f2(x')|
                dist = abs(obtained_pf(i,1) - obtained_pf(j,1)) + ...
                       abs(obtained_pf(i,2) - obtained_pf(j,2));
                min_dist = min(min_dist, dist);
            end
        end
        d(i) = min_dist;
    end
    
    % Calculate mean of distances
    d_bar = mean(d);
    
    % Calculate spacing metric SP
    spacing = sqrt(sum((d_bar - d).^2) / (n - 1));
end