Economic Load Dispatch Using

Reduced Gradient Method

March 15, 2025

Contents
1 Introduction 3

2 Problem Formulation 3
2.1 Objective Function . . . . . . . . . . . . . . . . . . . . . . . . 3
2.2 Constraints . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2.2.1 Power Balance Constraint . . . . . . . . . . . . . . . . 3
2.2.2 Generator Capacity Constraints . . . . . . . . . . . . . 4
2.3 Transmission Line Losses . . . . . . . . . . . . . . . . . . . . . 4

3 The Reduced Gradient Method 4

3.1 Mathematical Formulation . . . . . . . . . . . . . . . . . . . . 4
3.2 Algorithm Steps . . . . . . . . . . . . . . . . . . . . . . . . . . 5

4 Code Implementation 5
4.1 Main Program Structure . . . . . . . . . . . . . . . . . . . . . 5
4.1.1 Data Initialization . . . . . . . . . . . . . . . . . . . . 6
4.1.2 Finding Feasible Initial Solution . . . . . . . . . . . . . 6
4.1.3 Main Iteration Loop . . . . . . . . . . . . . . . . . . . 7
4.2 Reduced Gradient Function . . . . . . . . . . . . . . . . . . . 9

5 Key Algorithmic Features 13

5.1 Initial Solution Feasibility . . . . . . . . . . . . . . . . . . . . 13
5.2 Adaptive Step Size . . . . . . . . . . . . . . . . . . . . . . . . 13
5.3 Penalty Factors . . . . . . . . . . . . . . . . . . . . . . . . . . 14
5.4 Dependent Generator Selection . . . . . . . . . . . . . . . . . 14
5.5 Convergence Criteria . . . . . . . . . . . . . . . . . . . . . . . 14

1
6 Example Test Case 15
6.1 Generator Data . . . . . . . . . . . . . . . . . . . . . . . . . . 15
6.2 System Demand . . . . . . . . . . . . . . . . . . . . . . . . . . 15
6.3 Expected Results Analysis . . . . . . . . . . . . . . . . . . . . 15

7 Visualization and Analysis 16

7.1 Interpretation of Results . . . . . . . . . . . . . . . . . . . . . 16

8 Conclusion 16
8.1 Future Enhancements . . . . . . . . . . . . . . . . . . . . . . . 17

2
1 Introduction
Economic Load Dispatch (ELD) is a fundamental optimization problem in
power system operation that aims to determine the optimal output of mul-
tiple generating units to meet a specific load demand at the lowest possible
cost while satisfying various operational constraints. This document explains
the implementation of the Reduced Gradient Method for solving the ELD
problem, taking into account transmission line losses.

2 Problem Formulation
2.1 Objective Function
The objective of the ELD problem is to minimize the total generation cost:
N
X
min Ci (PGi ) (1)
i=1

where:
• N is the number of generators

• PGi is the power output of generator i

• Ci (PGi ) is the cost function of generator i

The cost function for each generator is typically modeled as a quadratic
function:

Ci (PGi ) = ai PG2 i + bi PGi + ci (2)

where ai , bi , and ci are the cost coefficients.

2.2 Constraints
2.2.1 Power Balance Constraint
The total power generated must equal the sum of the total demand and the
transmission line losses:
N
X
PG i = PD + PL (3)
i=1

where:

3
 • PD is the total load demand

• PL is the total transmission line losses

2.2.2 Generator Capacity Constraints

The power output of each generator is bounded by its minimum and maxi-
mum limits:

PGmin
i
≤ PGi ≤ PGmax
i
(4)

2.3 Transmission Line Losses

Transmission line losses are modeled using simplified B-coefficients:
N
X
PL = Bii PG2 i (5)
i=1

where Bii are the loss coefficients for each generator.

3 The Reduced Gradient Method

3.1 Mathematical Formulation
The reduced gradient method is an optimization technique for solving con-
strained optimization problems. For the ELD problem, we can form the
Lagrangian:
N N
!
X X
L(PG , λ) = Ci (PGi ) + λ PG i − P D − PL (6)
i=1 i=1

where λ is the Lagrange multiplier.

The optimality conditions require:
 
∂L dCi ∂PL
= +λ 1− = 0, i = 1, 2, . . . , N (7)
∂PGi dPGi ∂PGi
This leads to the concept of the penalty factor for each generator:
1
P Fi = ∂PL
(8)
1− ∂PGi

With the simplified loss model, the penalty factor becomes:

4
 1
P Fi = (9)
1 − 2Bii PGi
The reduced gradient method classifies variables into dependent and in-
dependent sets. In the ELD problem, we typically select one generator as the
dependent variable (usually the last one) and adjust it to satisfy the power
balance constraint.

3.2 Algorithm Steps

1. Initialize generator outputs PG and Lagrange multiplier λ

2. Calculate initial losses PL

3. Compute penalty factors P F

4. For each iteration:

(a) Select a dependent generator (typically the last one)

(b) Adjust its output to satisfy the power balance constraint
(c) Calculate the reduced gradient for each independent generator
(d) Update generator outputs using gradient descent
(e) Check for generator limit violations and adjust accordingly
(f) Recalculate losses and update the dependent generator
(g) Check for convergence

4 Code Implementation
4.1 Main Program Structure
The main program is structured as follows:

1. Data initialization

2. Finding a feasible initial solution

3. Main iteration loop calling the reduced gradient function

4. Final adjustments to ensure power balance

5. Results display and visualization

5
 4.1.1 Data Initialization

1 % Load ELD data

2 % Format : [a , b , c , pg_min , pg_max , pgi_guess ,
ploss_coeff ]
3 PG_data = [0.004 , 5.3 , 500 , 200 , 450 , 0 , 0.00003;
4 0.006 , 5.5 , 400 , 150 , 350 , 0 , 0.00009;
5 0.009 , 5.8 , 200 , 100 , 225 , 0 , 0.00012];
6

7 N = length ( PG_data (: ,1) ) ; % Number of generators

8 a = PG_data (: ,1) ; % Quadratic cost coefficient
9 b = PG_data (: ,2) ; % Linear cost coefficient
10 c = PG_data (: ,3) ; % Constant cost coefficient
11 pg_min = PG_data (: ,4) ; % Minimum generation limit
12 pg_max = PG_data (: ,5) ; % Maximum generation limit
13 ploss_coeff = PG_data (: ,7) ; % Loss coefficients
14

15 pd = 975; % Demand value in MW

Listing 1: Data initialization for the ELD problem

4.1.2 Finding Feasible Initial Solution

The code initializes the generators with a feasible solution by:

1. Setting most generators to their maximum capacity

2. Estimating initial losses

3. Adjusting the swing generator to balance the system

4. Checking if the swing generator violates its limits and redistributing if

necessary

1 % Initialize with generators at maximum except the last

one
2 pg = zeros (N , 1) ;
3 for i = 1: N -1
4 pg ( i ) = pg_max ( i ) ;
5 end
6

7 % Calculate initial losses estimate

8 ini t i a l _ l o s s _ e s t i m a t e = pd * 0.03; % Assume 3% losses
initially

6
 9 target_gen = pd + i n i t i a l _ l o s s _ e s t i m a t e ;
10

11 % Adjust to meet the target generation + estimated

losses
12 if sum ( pg (1: N -1) ) > target_gen
13 % Sort by marginal cost ( descending ) to reduce most
expensive first
14 [~ , cost_order ] = sort ([2* a (1: N -1) .* pg_max (1: N -1) +
b (1: N -1) ] , ’ descend ’) ;
15

16 excess = sum ( pg (1: N -1) ) - target_gen ;

17 for idx = 1: N -1
18 i = cost_order ( idx ) ;
19 reduction = min ( excess , pg ( i ) - pg_min ( i ) ) ;
20 pg ( i ) = pg ( i ) - reduction ;
21 excess = excess - reduction ;
22 if excess <= 0
23 break ;
24 end
25 end
26 end
27

28 % Set the swing generator to balance

29 pg ( N ) = pd - sum ( pg (1: N -1) ) ; % Initial estimate without
losses
30

31 % Calculate initial losses and update swing generator

32 ploss = sum ( ploss_coeff .* pg .^2) ;
33 pg ( N ) = pd + ploss - sum ( pg (1: N -1) ) ; % Update with
losses
Listing 2: Finding a feasible initial solution

4.1.3 Main Iteration Loop

The main iteration loop calls the reduced gradient function and updates
parameters until convergence:
1 for iteration = 1: max_iterations
2 % Call reduced gradient function
3 [ pg , lambda , ploss_new ] =
r e d u c e d _ g r a d i e n t _ f u n c t i o n ( alpha , N ,
error_tolerance_reduced_gradient , ...

7
 4 a, b, c,
lambda ,
ploss_coeff ,
pd , ploss ,
pf ,
pg_old ,
pg_min ,
pg_max ) ;
5

6 % Update penalty factors

7 pf_new = 1./(1 - 2* pg .* ploss_coeff ) ;
8

9 % Calculate difference in losses

10 diff_ploss = sum ( ploss_new ) - sum ( ploss ) ;
11

12 % Check convergence criteria

13 is_c onver ged_lo ss = ( abs ( diff_ploss ) <
error_tolerance_ploss_diff );
14 is_within_limits = ~ limits_violated ;
15 is_balanced = ( abs ( power_balance ) < 0.1) ;
16

17 if is_ conver ged_lo ss && is_within_limits &&

is_balanced
18 break ;
19 end
20

21 % Update for next iteration

22 ploss = ploss_new ;
23 pf = pf_new ;
24 pg_old = pg ;
25

26 % Adaptive step size adjustment

27 if iteration > 10
28 if abs ( diff_ploss ) >
e r r o r _ t o l e r a n c e _ p l o s s _ d i f f *10 ||
abs ( power_balance ) > 1
29 alpha = alpha * 0.95; % Reduce step size
30 elseif iteration > 30 && abs ( diff_ploss ) <
e r r o r _ t o l e r a n c e _ p l o s s _ d i f f *100 &&
abs ( power_balance ) < 10
31 alpha = alpha * 1.05; % Increase step size
32 alpha = min ( alpha , 0.01) ; % Cap step size
33 end

8
34 end
35 end
Listing 3: Main iteration loop

4.2 Reduced Gradient Function

The reduced gradient function implements the core optimization algorithm:
1 function [ pg , lambda , ploss_updated ] =
r e d u c e d _ g r a d i e n t _ f u n c t i o n ( alpha , N , error_tolerance ,
...
2 a, b, c,
lambda ,
ploss_coeff ,
pd ,
ploss ,
pf ,
pg_old ,
pg_min ,
pg_max )
3 % Initialize variables
4 pg = pg_old ;
5 gradient_vector = zeros ( N +1 , 1) ;
6

7 % Calculate initial losses

8 ploss_updated = sum ( ploss_coeff .* pg .^2) ;
9

10 % Reduced gradient method iterations

11 m a x _ i n n e r _ i t e r a t i o n s = 100;
12 for iteration = 1: m a x _ i n n e r _ i t e r a t i o n s
13 % Apply generator limits
14 for i = 1: N
15 if pg ( i ) < pg_min ( i )
16 pg ( i ) = pg_min ( i ) ;
17 elseif pg ( i ) > pg_max ( i )
18 pg ( i ) = pg_max ( i ) ;
19 end
20 end
21

22 % Recalculate losses
23 ploss_updated = sum ( ploss_coeff .* pg .^2) ;
24

25 % Select dependent generator

9
26 dependent_gen = N ;
27

28 % Set dependent generator to balance power

29 pg ( dependent_gen ) = pd + ploss_updated -
sum ( pg (1: N ) ) + pg ( dependent_gen ) ;
30

31 % Check dependent generator limits and

redistribute if necessary
32 if pg ( dependent_gen ) < pg_min ( dependent_gen )
33 % Handle case where dependent generator is
below minimum
34 deficit = pg_min ( dependent_gen ) -
pg ( dependent_gen ) ;
35 pg ( dependent_gen ) = pg_min ( dependent_gen ) ;
36

37 % Find generators that can increase output

38 % ... ( redistribution logic )
39

40 elseif pg ( dependent_gen ) > pg_max ( dependent_gen )

41 % Handle case where dependent generator is
above maximum
42 excess = pg ( dependent_gen ) -
pg_max ( dependent_gen ) ;
43 pg ( dependent_gen ) = pg_max ( dependent_gen ) ;
44

45 % Find generators that can decrease output

46 % ... ( redistribution logic )
47 end
48

49 % Recalculate losses
50 ploss_updated = sum ( ploss_coeff .* pg .^2) ;
51

52 % Calculate gradients for each generator

53 for i = 1: N
54 if i == dependent_gen
55 gradient_vector ( i ) = 0; % Skip
dependent generator
56 continue ;
57 end
58

59 % Skip generators at their limits

60 if pg ( i ) <= pg_min ( i ) && gradient_vector ( i )
> 0

10
61 gradient_vector ( i ) = 0;
62 continue ;
63 elseif pg ( i ) >= pg_max ( i ) &&
gradient_vector ( i ) < 0
64 gradient_vector ( i ) = 0;
65 continue ;
66 end
67

68 % Calculate marginal costs

69 dCost_i = 2* a ( i ) * pg ( i ) + b ( i ) ; %
Incremental cost of generator i
70 dCost_dep =
2* a ( dependent_gen ) * pg ( dependent_gen ) +
b ( dependent_gen ) ; % Incremental cost of
dependent generator
71

72 % Calculate loss sensitivities

73 dLoss_i = 2* ploss_coeff ( i ) * pg ( i ) ; % Change
in losses due to generator i
74 dLoss_dep =
2* ploss_coeff ( dependent_gen ) * pg ( dependent_gen ) ;
% Change in losses due to dependent
generator
75

76 % Calculate penalty factors

77 pf_i = 1/(1 - dLoss_i ) ;
78 pf_dep = 1/(1 - dLoss_dep ) ;
79

80 % Calculate reduced gradient

81 gradient_vector ( i ) = pf_i * dCost_i -
pf_dep * dCost_dep ;
82 end
83

84 % Power balance constraint gradient

85 gradient_vector ( N +1) = sum ( pg ) - ( pd +
ploss_updated ) ;
86

87 % Update generators using gradient descent

88 max_gradient = 0;
89 for i = 1: N
90 if i == dependent_gen
91 continue ; % Skip dependent generator
92 end

11
 93

94 % Only update if not at limits % Only update

if not at limits or if gradient pushes
away from limit
95 if ( pg ( i ) > pg_min ( i ) && pg ( i ) < pg_max ( i ) )
|| ...
96 ( pg ( i ) <= pg_min ( i ) &&
gradient_vector ( i ) < 0) || ...
97 ( pg ( i ) >= pg_max ( i ) &&
gradient_vector ( i ) > 0)
98

99 step = alpha * gradient_vector ( i ) ;

100 pg ( i ) = pg ( i ) - step ;
101

102 % Apply limits after update

103 if pg ( i ) < pg_min ( i )
104 pg ( i ) = pg_min ( i ) ;
105 elseif pg ( i ) > pg_max ( i )
106 pg ( i ) = pg_max ( i ) ;
107 end
108 end
109

110 % Track maximum gradient for convergence

check
111 max_gradient = max ( max_gradient ,
abs ( gradient_vector ( i ) ) ) ;
112 end
113

114 % Update lambda ( Lagrange multiplier )

115 lambda = lambda + alpha * gradient_vector ( N +1) ;
116

117 % Recalculate dependent generator and losses

118 ploss_updated = sum ( ploss_coeff .* pg .^2) ;
119 pg ( dependent_gen ) = pd + ploss_updated -
sum ( pg (1: N ) ) + pg ( dependent_gen ) ;
120

121 % Apply limits to dependent generator

122 if pg ( dependent_gen ) < pg_min ( dependent_gen )
123 pg ( dependent_gen ) = pg_min ( dependent_gen ) ;
124 elseif pg ( dependent_gen ) > pg_max ( dependent_gen )
125 pg ( dependent_gen ) = pg_max ( dependent_gen ) ;
126 end
127

12
128 % Check convergence
129 power_balance = sum ( pg ) - ( pd + ploss_updated ) ;
130 if max_gradient < error_tolerance &&
abs ( power_balance ) < error_tolerance
131 break ;
132 end
133 end
134

135 % Final recalculation of losses

136 ploss_updated = sum ( ploss_coeff .* pg .^2) ;
137 end
Listing 4: Reduced gradient function implementation

5 Key Algorithmic Features

5.1 Initial Solution Feasibility
The algorithm starts with a feasible solution by:
• Setting generators to their maximum capacity (except the last one)

• Estimating losses

• Balancing the system using the swing generator

• Checking and adjusting if the swing generator violates its limits

This initialization approach ensures that the algorithm begins from a valid
point in the feasible region, which helps with convergence. Starting with
generators at their maximum capacities allows the algorithm to determine
if capacity constraints are binding and provides a known reference point for
adjustments.

5.2 Adaptive Step Size

The algorithm uses an adaptive step size to improve convergence:
• Decreases step size when changes in losses are large or power balance
is poor

• Increases step size when convergence is slow but stable

• Caps the maximum step size to prevent oscillation

13
 The adaptive step size mechanism is crucial for balancing between speed
and stability of convergence. When the solution is far from optimal, larger
steps help reach the vicinity of the optimum quickly. As the solution ap-
proaches the optimum, smaller steps provide more precise convergence with-
out overshooting.

5.3 Penalty Factors

Penalty factors account for the effect of losses on incremental costs:
1
P Fi = (10)
1 − 2Bii PGi
These factors adjust the incremental costs to reflect the true cost of de-
livering power to the load. Penalty factors are essential in systems with
significant transmission losses, as they ensure that the optimization accounts
for the additional generation needed to compensate for these losses. Without
penalty factors, the solution would underestimate the true cost of generation.

5.4 Dependent Generator Selection

The algorithm selects one generator (usually the last one) as the dependent
variable, which is adjusted to satisfy the power balance constraint. If this
generator violates its limits, the excess or deficit is redistributed among other
generators based on their incremental costs.
Choosing a dependent generator reduces the dimensionality of the prob-
lem and ensures that the power balance constraint is always satisfied during
the optimization process. The redistribution mechanism handles cases where
the dependent generator cannot alone satisfy the balance constraint due to
its capacity limits.

5.5 Convergence Criteria

The algorithm checks for convergence using multiple criteria:

• Small gradients (optimality)

• Small changes in losses (stability)

• Power balance (feasibility)

• Generators within limits (constraints)

14
 Using multiple convergence criteria ensures that the final solution is not
only optimal but also feasible and stable. The algorithm terminates only
when all criteria are satisfied, providing a robust solution to the economic
load dispatch problem.

6 Example Test Case

The test case provided in the code has the following parameters:

6.1 Generator Data

Generator a b c Min (MW) Max (MW) B

1 0.004 5.3 500 200 450 0.00003
2 0.006 5.5 400 150 350 0.00009
3 0.009 5.8 200 100 225 0.00012

Table 1: Generator Parameters for the Test Case

6.2 System Demand

Total Load Demand: 975 MW

6.3 Expected Results Analysis

For this test case, we would expect the following characteristics in the optimal
solution:
• Generator 1 will likely operate at a higher output due to its lower
quadratic cost coefficient (a1 = 0.004)
• Generator 3 will likely operate at a lower output due to its higher
quadratic cost coefficient (a3 = 0.009)
• The penalty factors will be higher for generators with larger loss coef-
ficients
• The adjusted incremental costs (including penalty factors) should be
approximately equal at the optimal operating point
• The total system losses will typically be around 2-5% of the total de-
mand
• The optimal solution should satisfy all generator limits

15
7 Visualization and Analysis
The code includes visualization of:
• Generator outputs compared to their limits
• Cost curves for each generator
• Incremental cost curves
• Operating points on the cost curves
These visualizations help in understanding the economic operation of the
power system and verifying that the solution satisfies the equal incremental
cost criterion, adjusted for losses. Visual analysis provides intuitive confir-
mation that the numerical solution is correct and allows quick identification
of potential issues, such as generators operating at their limits.

7.1 Interpretation of Results

When interpreting the results, several key indicators should be examined:

• Generator Operating Points: Check if any generators are at their

limits. If so, the equal incremental cost criterion may not apply to
these generators.
• Incremental Costs: The adjusted incremental costs (including penalty
factors) should be approximately equal for all generators not operating
at their limits. This confirms the optimality of the solution.
• System Losses: The percentage of losses relative to the total de-
mand provides an indication of the efficiency of the dispatch. High
losses might suggest that a different dispatch strategy could be more
economical.
• Total Generation Cost: This is the primary objective function and
should be minimized. Comparing this cost with alternative dispatch
strategies confirms the effectiveness of the optimization.

8 Conclusion
The reduced gradient method provides an effective approach to solving the
Economic Load Dispatch problem with transmission line losses. The imple-
mentation includes:

16
 1. Proper handling of generator limits

2. Accurate modeling of transmission losses

3. Adaptive step size for improved convergence

4. Multiple convergence criteria for solution quality

5. Visualization tools for result analysis

This implementation can be extended to include additional constraints

such as ramp rate limits, prohibited operating zones, and multiple fuels by
modifying the gradient calculation and constraint handling.

8.1 Future Enhancements

Several enhancements could further improve the algorithm:

• Full B-matrix representation: Incorporating the full B-matrix for

loss modeling would provide more accurate results for complex power
systems with significant cross-coupling between generators.

• Valve-point effects: Including valve-point loading effects in the cost

function would provide a more realistic representation of thermal gen-
erator characteristics.

• Multi-objective optimization: Extending the algorithm to consider

both cost and emissions could provide environmentally friendly dis-
patch solutions.

• Integration with renewable sources: Incorporating the stochastic

nature of renewable energy sources would make the algorithm applica-
ble to modern power systems with high renewable penetration.

• Security constraints: Adding line flow constraints would ensure that

the dispatch solution does not violate transmission system security lim-
its.

The reduced gradient method, with its ability to handle constraints effec-
tively, provides a strong foundation for these extensions, making it a valuable
tool for power system operation and planning.

17