top of page

Economic Load Dispatch Using Sparrow Search Optimization

Economic Load Dispatch Using Sparrow Search Optimization

Title: Optimizing Economic Load Dispatch Using Sparrow Search Algorithm

Introduction: In today's tutorial, we will delve into the field of optimization and explore how the Sparrow Search Algorithm can be applied to solve the Economic Load Dispatch (ELD) problem. The ELD problem involves determining the optimal power generation levels for a set of generators to meet the electricity demand while minimizing the total cost of generation. Sparrow Search Algorithm is a novel optimization technique that can efficiently tackle such complex problems.

Understanding Economic Load Dispatch: The Economic Load Dispatch problem is a crucial aspect of power system operation. It revolves around the efficient allocation of power generation among different generators to ensure a balance between electricity supply and demand while minimizing the overall cost. This problem is particularly relevant in modern power systems where the emphasis is on reducing operational costs and environmental impact.

Components of the Sparrow Search Algorithm: Before diving into the code, let's understand the key components of the Sparrow Search Algorithm used in this optimization:

  1. Objective Function: The primary goal of the Sparrow Search Algorithm is to minimize the objective function. In this context, the objective function represents the total cost of power generation, often referred to as the fuel cost.

  2. Search Space: The search space defines the range within which the algorithm looks for the optimal solution. For ELD, this space includes the power generation levels of each generator. It is crucial to provide lower and upper bounds for this search space.

  3. Parameters: The algorithm requires specific parameters to be set, such as the number of search agents (representing potential solutions) and the maximum number of iterations.

Implementation of Sparrow Search Algorithm for ELD: Now, let's walk through the code used for optimizing the ELD problem using the Sparrow Search Algorithm:

% Load demand data for 24 hours

demand = [215, 210, 205, 200, 195, 190, 185, 180, 175, 170, 165, 160, ...

155, 150, 145, 140, 135, 130, 125, 120, 115, 110, 105, 100];

% Generator data (Fuel cost coefficients)

% You need to provide the coefficients for your specific generators

% Define lower and upper bounds for power generation

lower_bound = [50, 40, 30]; % Lower bound for each generator

upper_bound = [200, 150, 120]; % Upper bound for each generator

% Number of search agents and maximum iterations

num_agents = 20; % You can adjust this number

max_iterations = 100; % Maximum number of iterations

% Call the Sparrow Search Algorithm function

[result, cost_history] = SparrowSearchELD(demand, lower_bound, upper_bound, num_agents, max_iterations);

% Display the results

disp('Hour | Load Demand | Gen 1 | Gen 2 | Gen 3 | Total Generation | Power Loss | Total Cost');


% Plot the cost history




ylabel('Objective Function Value');

title('Convergence Plot');

% Function to perform Economic Load Dispatch using Sparrow Search Algorithm

function [result, cost_history] = SparrowSearchELD(demand, lower_bound, upper_bound, num_agents, max_iterations)

% Initialize search agents randomly within the search space

agents = initialize_agents(num_agents, lower_bound, upper_bound);

% Initialize cost history

cost_history = zeros(1, max_iterations);

% Main optimization loop

for iteration = 1:max_iterations

% Calculate the objective function (fuel cost)

costs = calculate_costs(agents, demand);

% Sort agents based on objective function values (ascending order)

[costs, idx] = sort(costs);

agents = agents(idx, :);

% Calculate the new position for each agent

agents = move_agents(agents, lower_bound, upper_bound, iteration, max_iterations);

% Record the best cost in this iteration

cost_history(iteration) = costs(1);


% Select the best agent (minimum cost) as the result

best_agent = agents(1, :);

result = [1:24; demand; best_agent; sum(best_agent); sum(demand - best_agent); sum(costs)];


% Function to initialize search agents randomly

function agents = initialize_agents(num_agents, lower_bound, upper_bound)

num_generators = length(lower_bound);

agents = rand(num_agents, num_generators) .* (upper_bound - lower_bound) + lower_bound;


% Function to calculate fuel costs for each agent

function costs = calculate_costs(agents, demand)

num_agents = size(agents, 1);

costs = zeros(1, num_agents);

for i = 1:num_agents

costs(i) = sum(agents(i, :)) * demand';



% Function to move search agents based on the Sparrow Search Algorithm

function new_agents = move_agents(agents, lower_bound, upper_bound, iteration, max_iterations)

[num_agents, num_generators] = size(agents);

new_agents = zeros(num_agents, num_generators);

% Define exploration and exploitation rates

a = 2 - (2 * iteration / max_iterations); % Exploration rate

r1 = rand(num_agents, num_generators); % Random values for exploration

r2 = rand(num_agents, num_generators); % Random values for exploitation

for i = 1:num_agents

% Exploration

if r1(i) < a

random_agent = agents(randi(num_agents), :);

new_agents(i, :) = agents(i, :) + rand() * (random_agent - agents(i, :));


% Exploitation

global_best = agents(1, :);

for j = 1:num_agents

if calculate_costs(agents(j, :), demand) < calculate_costs(global_best, demand)

global_best = agents(j, :);



new_agents(i, :) = agents(i, :) + rand() * (global_best - agents(i, :));


% Ensure agents stay within bounds

new_agents(i, :) = min(max(new_agents(i, :), lower_bound), upper_bound);



Thank you for watching this tutorial. For more informative content and tutorials, please subscribe to our channel and enable notifications.

5 views0 comments


bottom of page