Economic Load Dispatch Using Newton

Method
Power System Optimization
March 15, 2025

Contents
1 Introduction 3

2 Problem Formulation 3
2.1 Objective Function . . . . . . . . . . . . . . . . . . . . . . . . 3
2.2 Constraints . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2.3 Loss Model . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

3 Data File Implementation 4

4 Newton Method Function 5

4.1 Function Description . . . . . . . . . . . . . . . . . . . . . . . 8
4.2 Algorithm Steps . . . . . . . . . . . . . . . . . . . . . . . . . . 8
4.3 Key Components . . . . . . . . . . . . . . . . . . . . . . . . . 9
4.3.1 Gradient Vector . . . . . . . . . . . . . . . . . . . . . . 9
4.3.2 Jacobian Matrix . . . . . . . . . . . . . . . . . . . . . . 9
4.3.3 Correction Vector . . . . . . . . . . . . . . . . . . . . . 9

5 Main ELD Program 9

5.1 Main Program Structure . . . . . . . . . . . . . . . . . . . . . 13
5.2 Key Components . . . . . . . . . . . . . . . . . . . . . . . . . 14
5.2.1 Initialization Strategy . . . . . . . . . . . . . . . . . . 14
5.2.2 Convergence Criteria . . . . . . . . . . . . . . . . . . . 14
5.2.3 Variable Updates . . . . . . . . . . . . . . . . . . . . . 15
5.2.4 Final Adjustment Mechanism . . . . . . . . . . . . . . 15

1
6 Theoretical Background 15
6.1 Newton Method for ELD . . . . . . . . . . . . . . . . . . . . . 15
6.2 Handling Generator Limits . . . . . . . . . . . . . . . . . . . . 16

7 Optimization Results and Analysis 16

7.1 Convergence Behavior . . . . . . . . . . . . . . . . . . . . . . 16
7.2 Analysis of Results . . . . . . . . . . . . . . . . . . . . . . . . 16
7.3 Optimal Generation Dispatch . . . . . . . . . . . . . . . . . . 17

8 Conclusion 17

A MATLAB Files Summary 17

2
1 Introduction
This document provides a comprehensive explanation of an Economic Load
Dispatch (ELD) solution using the Newton method. ELD is a fundamen-
tal optimization problem in power systems that aims to allocate generation
among multiple generators to meet the load demand while minimizing the
total operating cost. The implementation accounts for power losses in the
system and enforces generator constraints.
The solution is divided into three main components:
1. Main ELD code

2. Newton method optimization function

3. Input data file

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

where Fi (PGi ) = ai PG2 i + bi PGi + ci is the cost function of generator i.

2.2 Constraints
The optimization is subject to the following constraints:

1. Power Balance Constraint:

N
X
PGi = PD + PL (2)
i=1

where PD is the total load demand and PL is the total transmission

loss.

2. Generator Limits:

PGmin
i
≤ PGi ≤ PGmax
i
(3)

3
 where PGmin
i
and PGmax
i
are the minimum and maximum generation limits
of generator i.

2.3 Loss Model

The transmission losses are modeled using simplified loss coefficients:

PLi = αi · PG2 i (4)

where αi is the loss coefficient for generator i.
The penalty factor for generator i is calculated as:
1
P Fi = (5)
1 − 2αi PGi

3 Data File Implementation

The data file defines the system parameters, including generator cost coeffi-
cients, operating limits, and loss coefficients.
1 % % ELD_data . m - Economic Load Dispatch Data
2 % This file contains the data for the Economic Load Dispatch
problem
3 % including generator parameters and system constraints .
4
5 % Generator parameters :
6 % Column 1: a - Quadratic cost coefficient ( $ / MW ^2 h )
7 % Column 2: b - Linear cost coefficient ( $ / MWh )
8 % Column 3: c - Constant cost coefficient ( $ / h )
9 % Column 4: pg_min - Minimum generation limit ( MW )
10 % Column 5: pg_max - Maximum generation limit ( MW )
11 % Column 6: Initial generation ( MW ) - not used in the program
12 % Column 7: ploss_coeff - Loss coefficient for each generator
13
14 % Generator data : [a , b , c , pg_min , pg_max , pg_initial ,
ploss_coeff ]
15 PG_data = [
16 0.004 , 5.3 , 500 , 200 , 450 , 0 , 0.00003;
17 0.006 , 5.5 , 400 , 150 , 350 , 0 , 0.00009;
18 0.009 , 5.8 , 200 , 100 , 225 , 0 , 0.00012
19 ];
20
21 % Note : The simplified loss formula used is :
22 % ploss_i = ploss_coeff_i * ( pg_i ) ^2
23 % Total ploss = sum ( ploss_i ) for all generators
Listing 1: ELD data.m - Economic Load Dispatch Data

4
 4 Newton Method Function
The Newton method function uses iterative approach to solve the ELD prob-
lem by finding the optimal generator outputs and system incremental cost
(lambda).
1 function [ pg_final_calculated , l a m b d a _ f i n a l _ c a l c u l a t e d ] =
n e w t o n _ m e t h o d _ f u n c t i o n ( pd , lambda , N , a , b , pg_min , pg_max
, ploss_coeff , pg , ploss , pf )
2 % Initialize variables
3 error_tolerance = 0.0001;
4 max_iterations = 50;
5
6 % Start with current values
7 p g_ f i na l _ c al c u la t e d = pg ;
8 l a m b d a _ f i n a l _ c a l c u l a t e d = lambda ;
9
10 for iter = 1: max_iterations
11 % Calculate updated loss and penalty factors based on
current generation
12 ploss_current = zeros (1 , N ) ;
13 pf_current = zeros (1 , N ) ;
14 for j = 1: N
15 pf_current ( j ) = 1/(1 -(2* p g _ fi n a l_ c a lc u l at e d ( j ) *
ploss_coeff ( j ) ) ) ;
16 ploss_current ( j ) = ( p g _ fi n a l_ c a lc u l at e d ( j ) ^2) *
ploss_coeff ( j ) ;
17 end
18

19 % Build gradient vector ( mismatch equations )

20 gradient_vector = zeros ( N +1 , 1) ;
21 for j = 1: N
22 gradient_vector ( j ) = (2* a ( j ) * p g _ fi n a l_ c a lc u l at e d (
j ) ) + b ( j ) - ( l a m b d a _ f i n a l _ c a l c u l a t e d / pf_current ( j ) ) ;
23 end
24 gradient_vector ( N +1) = pd + sum ( ploss_current ) - sum (
p g _f i n al _ c al c u la t e d ) ;
25
26 % Check convergence on both optimality conditions and
power balance
27 if max ( abs ( gradient_vector (1: N ) ) ) < error_tolerance
&& abs ( gradient_vector ( N +1) ) < error_tolerance
28 break ;
29 end
30
31 % Build Jacobian matrix
32 jacobian_matrix = zeros ( N +1 , N +1) ;
33 for k = 1: N
34 % Diagonal elements for generators

5
35 jacobian_matrix (k , k ) = 2* a ( k ) ;
36
37 % Lambda column
38 jacobian_matrix (k , N +1) = -1/ pf_current ( k ) ;
39
40 % Power balance row - include the effect of
losses
41 dloss_dpg = 2* ploss_coeff ( k ) * p g _ fi n a l_ c a lc u l at e d (
k);
42 jacobian_matrix ( N +1 , k ) = dloss_dpg - 1;
43 end
44 jacobian_matrix ( N +1 , N +1) = 0;
45

46 % Solve for correction vector using \ operator ( more

stable than inv () )
47 corr ection _vect or = - jacobian_matrix \
gradient_vector ;
48
49 % Apply corrections with damping factor to improve
convergence
50 damping = 1.0; % Can be reduced if convergence is
difficult
51
52 % Update lambda first
53 lambda_final_calculated = lambda_final_calculated +
damping * co rrecti on_vec tor ( N +1) ;
54
55 % Then update generator outputs with constraints
56 for l = 1: N
57 % Update with damping
58 p g _f i n al _ c al c u la t e d ( l ) = p g _f i n al _ c al c u la t e d ( l ) +
damping * c orrect ion_ve ctor ( l ) ;
59
60 % Enforce generator limits
61 if p g_ f i na l _ ca l c ul a t ed ( l ) < pg_min ( l )
62 p g _f i n al _ c al c u la t e d ( l ) = pg_min ( l ) ;
63 elseif p g_ f i na l _ ca l c ul a t ed ( l ) > pg_max ( l )
64 p g _f i n al _ c al c u la t e d ( l ) = pg_max ( l ) ;
65 end
66 end
67
68 % If we ’ ve reached max iterations , try to enforce
power balance directly
69 if iter == max_iterations
70 % Calculate current losses
71 total_losses = 0;
72 for j = 1: N
73 total_losses = total_losses + (
p g _f i n al _ c al c u la t e d ( j ) ^2) * ploss_coeff ( j ) ;

6
 74 end
75
76 % Calculate required generation
77 r e qu i r ed _ g en e r at i o n = pd + total_losses ;
78 cu rr en t_ ge ne ra ti on = sum ( p g _ fi n a l_ c a lc u l at e d ) ;
79
80 % Adjust generation if needed and possible
81 if abs ( r eq u i re d _ ge n e ra t i on - cur re nt _g en er at io n )
> error_tolerance
82 shortage = r e q ui r e d_ g e ne r a ti o n -
cu rr en t_ ge ne ra ti on ;
83
84 % Find generators that can be adjusted
85 adjustable_gens = [];
86 for j = 1: N
87 if shortage > 0 && p g_ f i na l _ ca l c ul a t ed ( j )
< pg_max ( j )
88 adjustable_gens = [ adjustable_gens j
];
89 elseif shortage < 0 &&
p g _f i n al _ c al c u la t e d ( j ) > pg_min ( j )
90 adjustable_gens = [ adjustable_gens j
];
91 end
92 end
93
94 % Distribute the shortage among adjustable
generators
95 if ~ isempty ( adjustable_gens )
96 adjustment = shortage / length (
adjustable_gens ) ;
97 for j = adjustable_gens
98 p g_ f i na l _ c al c u la t e d ( j ) =
p g _f i n al _ c al c u la t e d ( j ) + adjustment ;
99
100 % Re - check limits after adjustment
101 if p g_ f i na l _ ca l c ul a t ed ( j ) < pg_min ( j )
102 p g_ f i na l _ ca l c ul a t e d ( j ) = pg_min ( j
);
103 elseif pg _ f in a l _ ca l c ul a t ed ( j ) >
pg_max ( j )
104 p g_ f i na l _ ca l c ul a t e d ( j ) = pg_max ( j
);
105 end
106 end
107 end
108 end
109 end
110 end

7
111 end
Listing 2: newton method function.m - Newton Method Implementation

4.1 Function Description

The Newton method function takes the following inputs:

• pd: Power demand

• lambda: Initial lambda (incremental cost) value

• N: Number of generators

• a, b: Cost function coefficients

• pg min, pg max: Generator limits

• ploss coeff: Loss coefficients

• pg: Initial generator outputs

• ploss: Initial power losses

• pf: Initial penalty factors

It returns:

• pg final calculated: Optimized generator outputs

• lambda final calculated: Final lambda value (system incremental

cost)

4.2 Algorithm Steps

1. Initialization: Set up variables and starting values.

2. Iterative Process:

• Calculate updated loss and penalty factors

• Build the gradient vector (optimality conditions and power bal-
ance)
• Check for convergence
• Build the Jacobian matrix

8
 • Solve for correction vector
• Update lambda and generator outputs with constraints

3. Final Adjustment: If needed, enforce power balance directly by ad-

justing available generators.

4.3 Key Components

4.3.1 Gradient Vector
The gradient vector contains the mismatch equations:

• For generators (1 to N): ∂Fi

∂PGi
− λ
P Fi
=0

• For power balance (N+1): PD + PL −

P
PGi = 0

4.3.2 Jacobian Matrix

The Jacobian matrix contains the derivatives of the gradient vector:
∂ 2 Fk
• Diagonal elements (k,k): ∂PG 2 = 2ak
k

• Lambda column (k,N+1): ∂

( λ )
∂λ P Fk
= − P 1Fk

• Power balance row (N+1,k): ∂PL

∂PGk
− 1 = 2αk PGk − 1

4.3.3 Correction Vector

The correction vector is calculated by solving the linear system:

J · ∆x = −g (6)

where J is the Jacobian matrix, g is the gradient vector, and ∆x contains

the corrections for generator outputs and lambda.

5 Main ELD Program

The main program coordinates the overall solution process, handles itera-
tions, and reports results.

9
 1 clear all
2 clc
3 ELD_Data % Load the data
4
5 % Extract generator parameters
6 N = size ( PG_data , 1) ;
7 a = PG_data (: , 1) ;
8 b = PG_data (: , 2) ;
9 c = PG_data (: , 3) ;
10 pg_min = PG_data (: , 4) ;
11 pg_max = PG_data (: , 5) ;
12 ploss_coeff = PG_data (: , 7) ;
13 pd = 975; % Load demand
14
15 % Initialize variables with a feasible starting point
16 pg = zeros (1 , N ) ;
17 total_min = sum ( pg_min ) ;
18 total_max = sum ( pg_max ) ;
19

20 if pd < total_min
21 error ( ’ Demand is less than minimum generation capacity ’) ;
22 elseif pd > total_max
23 error ( ’ Demand exceeds maximum generation capacity ’) ;
24 else
25 % Distribute load proportionally between min and max
limits
26 for i = 1: N
27 pg ( i ) = pg_min ( i ) + ( pg_max ( i ) - pg_min ( i ) ) * ( pd -
total_min ) / ( total_max - total_min ) ;
28 end
29 end
30
31 % Better initial lambda estimate based on average marginal
cost
32 lambda_init = 0;
33 for i = 1: N
34 lambda_init = lambda_init + 2* a ( i ) * pg ( i ) + b ( i ) ;
35 end
36 lambda = lambda_init / N ;
37
38 error_tolerance = 0.01; % Tolerance for convergence
39 max_iterations = 100; % Maximum iterations
40
41 % Initialize loss and penalty factors
42 ploss = zeros (1 , N ) ;
43 pf = zeros (1 , N ) ;
44
45 % Calculate initial ploss and pf
46 for i = 1: N

10
47 pf ( i ) = 1/(1 -(2* pg ( i ) * ploss_coeff ( i ) ) ) ;
48 ploss ( i ) = ( pg ( i ) ^2) * ploss_coeff ( i ) ;
49 end
50
51 total_ploss = sum ( ploss ) ;
52 fprintf ( ’ Initial : Gen : %.2 f MW , Demand : %.2 f MW , Loss : %.2 f
MW , Balance : %.2 f MW \ n ’ , sum ( pg ) , pd , total_ploss , sum ( pg )
- ( pd + total_ploss ) ) ;
53
54 % Main iteration loop
55 for iter = 1: max_iterations
56 % Call Newton method to update pg and lambda
57 [ pg_new , lambda_new ] = n e w t o n _ m e t h o d _ f u n c t i o n ( pd , lambda ,
N , a , b , pg_min , pg_max , ploss_coeff , pg , ploss , pf ) ;
58
59 % Calculate new loss and penalty factors
60 ploss_new = zeros (1 , N ) ;
61 pf_new = zeros (1 , N ) ;
62 for j = 1: N
63 pf_new ( j ) = 1/(1 -(2* pg_new ( j ) * ploss_coeff ( j ) ) ) ;
64 ploss_new ( j ) = ( pg_new ( j ) ^2) * ploss_coeff ( j ) ;
65 end
66
67 % Calculate changes for convergence check
68 total_ploss_new = sum ( ploss_new ) ;
69 power_balance = sum ( pg_new ) - ( pd + total_ploss_new ) ;
70
71 % Print iteration details
72 fprintf ( ’ Iter %2 d : Gen : %.2 f MW , Loss : %.2 f MW , Balance :
%.6 f MW , Lambda : %.6 f \ n ’ , iter , sum ( pg_new ) ,
total_ploss_new , power_balance , lambda_new ) ;
73
74 % Update values for next iteration
75 pg = pg_new ;
76 lambda = lambda_new ;
77 ploss = ploss_new ;
78 pf = pf_new ;
79
80 % Check convergence on power balance
81 if abs ( power_balance ) < error_tolerance
82 fprintf ( ’\ nConverged after % d iterations !\ n ’ , iter ) ;
83 break ;
84 end
85
86 % If we ’ re at the last iteration and still not converged ,
try one final adjustment
87 if iter == max_iterations
88 fprintf ( ’\ nReached maximum iterations . Performing
final adjustment ...\ n ’) ;

11
 89

90 % Calculate current total loss

91 total_ploss = sum ( ploss ) ;
92
93 % Calculate required total generation
94 r eq u i re d _ ge n e ra t i on = pd + total_ploss ;
95

96 % Find generators not at their limits

97 adjustable_gens = [];
98 for i = 1: N
99 if pg ( i ) > pg_min ( i ) && pg ( i ) < pg_max ( i )
100 adjustable_gens = [ adjustable_gens i ];
101 end
102 end
103
104 if ~ isempty ( adjustable_gens )
105 % Calculate current imbalance
106 curr ent_im balanc e = sum ( pg ) - re q u ir e d _g e n er a t io n
;
107
108 % Distribute the adjustment among available
generators
109 ad ju st me nt _p er _g en = curre nt_imb alance / length (
adjustable_gens ) ;
110

111 for i = adjustable_gens

112 pg ( i ) = pg ( i ) - a dj us tm en t_ pe r_ ge n ;
113
114 % Ensure limits are respected
115 if pg ( i ) < pg_min ( i )
116 pg ( i ) = pg_min ( i ) ;
117 elseif pg ( i ) > pg_max ( i )
118 pg ( i ) = pg_max ( i ) ;
119 end
120
121 % Update loss for this generator
122 ploss ( i ) = ( pg ( i ) ^2) * ploss_coeff ( i ) ;
123 end
124
125 % Recalculate power balance
126 total_ploss = sum ( ploss ) ;
127 power_balance = sum ( pg ) - ( pd + total_ploss ) ;
128
129 fprintf ( ’ After adjustment : Gen : %.2 f MW , Loss :
%.2 f MW , Balance : %.6 f MW \ n ’ , sum ( pg ) , total_ploss ,
power_balance ) ;
130 end
131 end
132 end

12
133

134 % Print final results

135 fprintf ( ’\ nFinal Results :\ n ’) ;
136 fprintf ( ’ Generator \ tOutput ( MW ) \ tMin ( MW ) \ tMax ( MW ) \ tMarginal
Cost ( $ / MWh ) \ n ’) ;
137 for i = 1: N
138 fprintf ( ’% d \ t \ t %.2 f \ t \ t %.2 f \ t \ t %.2 f \ t \ t %.6 f \ n ’ , i , pg ( i ) ,
pg_min ( i ) , pg_max ( i ) , 2* a ( i ) * pg ( i ) + b ( i ) ) ;
139 end
140
141 fprintf ( ’\ nTotal generation : %.2 f MW \ n ’ , sum ( pg ) ) ;
142 fprintf ( ’ Total demand : %.2 f MW \ n ’ , pd ) ;
143 fprintf ( ’ Total losses : %.2 f MW \ n ’ , sum ( ploss ) ) ;
144 fprintf ( ’ Power balance : %.6 f MW \ n ’ , sum ( pg ) - ( pd + sum ( ploss
)));
145 fprintf ( ’ Final lambda ( system marginal cost ) : %.6 f $ / MWh \ n ’ ,
lambda ) ;
146
147 % Calculate total cost
148 total_cost = 0;
149 for i = 1: N
150 gen_cost = a ( i ) * pg ( i ) ^2 + b ( i ) * pg ( i ) + c ( i ) ;
151 total_cost = total_cost + gen_cost ;
152 fprintf ( ’ Generator % d cost : $ %.2 f / h \ n ’ , i , gen_cost ) ;
153 end
154 fprintf ( ’ Total system cost : $ %.2 f / h \ n ’ , total_cost ) ;
Listing 3: main ELD.m - Main Economic Load Dispatch Program

5.1 Main Program Structure

The main program follows these general steps:

1. Data Preparation and Initialization:

• Load generator data

• Extract parameters (cost coefficients, limits, etc.)
• Initialize generator outputs and lambda
• Set up convergence criteria

2. Initial Calculations:

• Calculate initial penalty factors and losses

• Verify feasibility of the problem

3. Main Iteration Loop:

13
 • Call Newton method function to update generator outputs and
lambda
• Calculate new losses and penalty factors
• Check for convergence based on power balance
• Update all variables for next iteration

4. Final Adjustment (if needed):

• Find adjustable generators (not at their limits)

• Distribute any remaining imbalance
• Recalculate power balance

5. Results Reporting:

• Print detailed information about generator outputs

• Report system performance metrics (total generation, losses, etc.)
• Calculate and display total cost

5.2 Key Components

5.2.1 Initialization Strategy
The program uses a smart initialization strategy:

• Distributes initial generation proportionally between minimum and

maximum limits

• Estimates initial lambda based on average marginal costs

5.2.2 Convergence Criteria

The primary convergence criterion is the power balance:

|PG − (PD + PL )| < ϵ (7)

where ϵ is the error tolerance (0.01 MW in this implementation).

14
5.2.3 Variable Updates
Between iterations, all key variables are properly updated:
• Generator outputs (pg)
• System incremental cost (lambda)
• Power losses (ploss)
• Penalty factors (pf)

5.2.4 Final Adjustment Mechanism

If normal iterations don’t achieve power balance, a direct adjustment mech-
anism:
1. Identifies generators not at their limits
2. Calculates the remaining imbalance
3. Distributes the adjustment among available generators
4. Enforces generator limits
5. Recalculates the final power balance

6 Theoretical Background
6.1 Newton Method for ELD
The Newton method for ELD is based on solving the Lagrangian function:
N N
!
X X
L= Fi (PGi ) − λ PGi − PD − PL (8)
i=1 i=1

The first-order optimality conditions are:

 
∂L ∂Fi ∂ ∂PL
= −λ· 1− =0 (9)
∂PGi ∂PGi ∂PGi ∂PGi
When including transmission losses, this becomes:
∂Fi
= λ · P Fi (10)
∂PGi
where P Fi is the penalty factor for generator i.

15
6.2 Handling Generator Limits
When a generator output reaches its limit, that generator is fixed at the
limit, and the optimization continues with the remaining generators. This is
implemented by enforcing the limits after each update:

min
P G i
 if PGi < PGmin
i

PG i = PG i min
if PGi ≤ PGi ≤ PGmax
i
(11)

 max max
PG i if PGi > PGi

7 Optimization Results and Analysis

7.1 Convergence Behavior
The implementation typically converges within a few iterations for well-
behaved systems. Convergence is monitored by:

1. Tracking the power balance error

2. Monitoring changes in power losses

3. Verifying that optimality conditions are satisfied

7.2 Analysis of Results

The final results provide comprehensive information:

• Individual generator outputs and their marginal costs

• Total system generation and demand

• Total transmission losses

• Final power balance verification

• System marginal cost (lambda)

• Total generation cost

16
7.3 Optimal Generation Dispatch
The optimal dispatch follows the equal incremental cost principle, adjusted
by penalty factors:
1 ∂F1 1 ∂F2 1 ∂FN
= = ··· = =λ (12)
P F1 ∂PG1 P F2 ∂PG2 P FN ∂PGN
Generators with lower costs and lower loss impacts are dispatched more
heavily, subject to their operating limits.

8 Conclusion
The Economic Load Dispatch solution using the Newton method provides
an efficient approach to optimally allocate generation among multiple gener-
ators while accounting for transmission losses and enforcing generator con-
straints. The implementation presented here demonstrates a robust solution
that achieves:

1. Cost Optimization: Minimizes the total generation cost

2. Constraint Satisfaction: Respects generator operating limits
3. Power Balance: Ensures generation matches demand plus losses
4. Numerical Stability: Uses techniques to enhance convergence

This implementation can be used as a foundation for more complex power

system optimization problems and can be extended to include additional
constraints and considerations specific to power system operations.

A MATLAB Files Summary

To implement the Economic Load Dispatch solution presented in this docu-
ment, three MATLAB files are needed:

1. ELD Data.m: Contains generator parameters, cost coefficients, and loss

coefficients.
2. newton method function.m: Implements the Newton method for ELD
optimization.
3. main ELD.m: Main program that coordinates the overall solution pro-
cess.

17
 These files should be placed in the same directory and executed by run-
ning the main ELD.m script in MATLAB.

18