Electric Power Systems Research 190 (2021) 106720

Contents lists available at ScienceDirect

Electric Power Systems Research

journal homepage: www.elsevier.com/locate/epsr

An improved algorithm for single-unit commitment with ramping limits T

⁎,a,b a c
Rogier Hans Wuijts , Marjan van den Akker , Machteld van den Broek
a
Department of Information and Computing Sciences, Utrecht University, the Netherlands
b
Copernicus Institute for Sustainable Development, Utrecht University, the Netherlands
c
Integrated Research on Energy, Environment and Society (IREES), Energy Research Institute Groningen (ESRIG), University of Groningen, the Netherlands

A RT ICLE INFO ABSTRACT

Keywords: The single-unit commitment problem (1UC) is the problem of finding a cost optimal schedule for a single
Dynamic programming generator given a time series of electricity prices subject to generation limits, minimum up- and downtime and
Single-unit commitment problem ramping limits. In this paper we present two efficient dynamic programming algorithms. For each time step we
Polynomial-time algorithm, keep track of a set of functions that represent the cost of optimal schedules until that time step. We show that we
can combine a subset of these functions by only considering their minimum. We can construct this minimum
either implicitly or explicitly. Experiments show both methods scale linear in the amount of time steps and result
in a significant speedup compared to the state-of-the-art for piece-wise linear as well as quadratic generation
cost. Therefore using these methods could lead to significant improvements for solving large scale unit com­
mitment problems with Lagrangian relaxation or related methods that use 1UC as subproblem.

1. Introduction first part of the algorithm is to define on-periods. A on-period is a sub­

sequence of time steps of where the generator is on and must be larger or
The unit commitment (UC) problem revolves around finding the equal to the minimum up time. Every on-period has an optimal power
least cost power generation schedule for a set of generators such that output subsequence. Finding the optimal power output subsequence for
the demand is met at each time step subject to technical restrictions [1]. each on-period is an optimization problem. Fan et al. solved this with a
The single-unit commitment problem (1UC) is a special case of the dynamic programming algorithm that recursively partitions the con­
UC problem in which the least cost schedule is searched for only one tinuous state space by finding corner points of the cost-to-go function.
generator subject to its technical restrictions [2]. In this case, the In the second part, these on-periods weighted by the optimal eco­
generator is not required to meet a demand, but a time series of elec­ nomic dispatch costs, are combined in an optimal schedule by solving a
tricity prices is given that determines how much revenue the generator shortest path problem. Every path in the graph corresponds to an un­
can make at each time step. In this paper we will study 1UC with ique configuration of binary decisions (x).
generation limits, minimum up- and downtime and ramping limits. Frangioni and Gentile [2] improved this method by making it more
The relevance of 1UC lies in the fact that it arises as a subproblem in general. Their method of calculating the optimal economic dispatch
the Lagrangian relaxation or column generation, which have been works for any convex cost function. Their algorithm calculates the
shown to be competitive for UC [1]. For the efficiency of these algo­ optimal economic dispatch of all on-periods in O(n3) and finds the
rithms, the efficiency of solving 1UC is crucial. shortest path in another O(n3). Frangioni and Gentile [12] found that a
A solution to 1UC is a schedule that for every time step specifies whe­ redefinition of the commitment state space graph can speed up this
ther the generator is on or off and how much power it is producing. The cost second part to O(n2).
associated with power production is the generation cost and consists of the In 2010, Zhai et al. [5] presented a similar algorithm in which IUC is
cost of operating the generator minus the revenue. The generation cost is also split into two parts, but which has the advantage that it also works
assumed to be convex and in the often modeled as a linear, piece-wise linear for non-convex piece-wise linear cost functions.
or quadratic function. When 1UC is used as a subproblem in the Lagrangian In 2018 Yongpei Guan, Pan, and Zhou [3] introduced an algorithm
relaxation this revenue corresponds to the Lagrangian multipliers. to solve 1UC in O(n) time. However, as a restriction it only works with
Fan, Xiaohong Guan, and Zhai [4] solved 1UC with piece-wise linear convex piece-wise linear generation cost and when the ramp up and
generation cost in O(n3) time by splitting the problem in two parts. The ramp down limits are equal to each other. They solved 1UC by keeping

⁎
Corresponding author at: Department of Information and Computing Sciences Utrecht University, the Netherlands.
E-mail addresses: [email protected] (R.H. Wuijts), [email protected] (M. van den Akker), [email protected] (M. van den Broek).

https://doi.org/10.1016/j.epsr.2020.106720
Received 4 October 2019; Received in revised form 18 April 2020; Accepted 2 August 2020
Available online 12 September 2020
0378-7796/ © 2020 The Author(s). Published by Elsevier B.V. This is an open access article under the CC BY license
(http://creativecommons.org/licenses/by/4.0/).
R.H. Wuijts, et al. Electric Power Systems Research 190 (2021) 106720

Nomenclature cstop Stop cost ($)

Ramp-down limit ( MW )
h
ft(pt) The cost of producing pt at time t ( $ ) SU Start-up ramp limit (MW)
MW
P Minimum generation (MW) SD Shut-down ramp limit (MW)
P Maximum generation (MW) Mup Minimum up time (h)
+
Ramp-up limit ( MW ) Mdown Minimum down time (h)
h
cstart Time independent start cost ($)

track of a finite number of points where the power production could be 3. Problem definition
optimal.
A solution is represented as two vectors x ∈ {0, 1}n and p n.

Where x = x1 xn represents the binary commitment variables i.e. xt is 1

2. Outlook when the generator is on at time t and 0 otherwise. The vector
p = p1 pn represents the continuous power output variables that for
In this paper we present two algorithms for solving 1UC that im­ each time step indicates how much power a generator provides at that
prove upon previous algorithms in terms of generality, time complexity time. The associated cost of a solution is determined by time dependant
and computation time in practice. Both algorithms are based on two generation cost function ft. Here ft(pt) is a function that returns the
equivalent recurrence relations. generation cost of providing pt power at time t. If the generator is on
The idea for both relations is as follows: for each time step we define then the production must be between the minimum generation P and
all states the generator can attain and all valid state transitions. After that the maximum generation P . Moreover, if the generator is turned on
we define the recurrence relation that represents for each state at each (off), it must stay on(off) for at least Mup(Mdown) time steps. Finally,
time step the value of the optimal schedule that ends in that state. there are four ramping limits. There is a ramp-up ( +) and ramp-down
However, since the amount of states is infinite as the power output is ( ) constraint that limits how much two consecutive power output
continuous we cannot solve these recurrence relations directly. Therefore, levels pt and pt + 1 can differ from each other. These limits only hold for
1UC is reformulated in terms of recurrence relations on functions, later two consecutive time steps where the generator is on. Special ramping
defined as Ft and Ht . These functions can be constructed by partitioning limits apply when a generator starts or shuts down, the startup limit SU
their domain as was previously done to calculate the optimal economic and shutdown limit SD. We assume the generator can be in any state at
dispatch for on-periods.1 However, instead of computing the optimal t = 1.2 We can now define 1UC as the following mixed integer program:
economic dispatch of an on-period beforehand Ft and Ht represent the
cost of the complete 1UC schedule from time 1 up until time t. min ccycle (x) + ft (pt ) subject to
t {1, , n} (10)
The first dynamic programming algorithm we defined, enables the
identification of superfluous functions Ft that are always dominated by Px t pt P xt , t = 1 n (11)
other functions i.e. for every power output level pt there is another func­
tion with a lower cost. If we remove superfluous functions the overall pt + 1 pt + xt + + (1 x t ) SU , t = 1 n 1 (12)
computation time can be reduced. Identification of these functions comes
at a cost and has a worst case time complexity of O(n3). However, in pt pt + 1 + xt + 1 + (1 xt + 1) SD, t = 1 n 1 (13)
practice it has little computational overhead. Moreover, we describe the
conditions in which this algorithm grows linear with the amount of time
x X , pt (14)
steps and show these conditions are met for the instances we studied. This ccycle(x) consists of the start-up cstart and shutdown cost cdown of the
results in a speedup of the algorithm of Frangioni and Gentile [2]. commitment vector x. X is the set of feasible commitment vectors with
The second dynamic programming algorithm we defined, combines respect to the minimum up- and downtime (14).
subsets of on-states and thus reduces the total amount of states. At the
same time, the number of functions the recurrence relation consists of 4. First recurrence relation
diminishes, as multiple functions are replaced by their combined
minimum. When ft is piece-wise linear we can create this function by
only keeping track of a finite number of points similar to the algorithm c (off t ) = 0 t = 1 (1)
of Guan et al. [3]. However, in contrast to the algorithm of Guan et al. ’
our algorithm, is more generic as it also works for ramp up and ramp c (off t ) = min min c (ont 1, pt 1 ) + cstop t>1 =1
pt 1 [ P , SD] ’ {Mup t} (2)
down rates which differ from each other. Moreover, we show how to
efficiently compute the values at those points. This results in an im­ c (off t 11 )
c (off t ) = t>1 1< < Mdown (3)
proved algorithm in terms of generality and time complexity.
In Section 3 we formally define the 1UC problem. In Section 4 we c (off t ) = min{c (off t 11 ), c (offt 1 )} t > 1 = Mdown (4)
will state the recurrence relation that solves 1UC and in Section 5 we
define and analyse a dynamic programming algorithm, RRF+, that uses c (ont , pt ) = ft (pt ) t=1 P pt P (5)
this recurrence relation. In Section 7 we show an equivalent recurrence
relation and in Section 8 we define and analyse a dynamic program­ c (ont , pt ) = ft (pt ) + c (off tMdown
1 ) + cstart t > 1, =1 P pt SU
ming algorithm, RRH, that uses this recurrence relation when the (6)
generation cost function is piece-wise linear. At last we conclude this
1
paper in Section 9 with experiments regarding our two algorithms for c (ont , pt ) = ft (pt ) + min+ c (ont 1, pt 1 ) t
pt 1 [pt , pt + ]
both piece-wise linear and quadratic generation cost and show that they
significantly decrease the computation time compared to previous > 1, >1 P pt P (7)
methods.
2
Here we ignore the transition constraints and cost between t = 0 and t = 1.
1
cost-to-go functions Lt in [4] and zhk in [2]. Alternatively, the state at t = 0 can also be provided as input to the problem.

2
R.H. Wuijts, et al. Electric Power Systems Research 190 (2021) 106720

c (_) = otherwise (8) chapter we will present a method to construct Ft equivalent to Fran­
gioni and Gentile [2] but in a declarative way which is in our opinion
ft (pt ) t = 1, P pt P more intuitive.
ft (pt ) + c (off tM1down ) + cstart t > 1, = 1, P pt SU Constructing the first Ft1 is easy since ft is given as input and
c (off tM1down ) is just a single value. The hard part of constructing Ft is
Ft (pt ) = ft (pt ) + min+ Ft 11 t > 1, > 1, P pt P
pt 1 [pt , pt + ] taking the sliding window minimum of Ft 11. Suppose pt* 1 is a point in
(pt 1 ) [ P , P ] for which Ft 11 is minimal:
otherwise 1
pt* 1 = argmin pt F
1 [ P, P ] t 1
(pt 1 )
(9)
In this section we define the state space and the corresponding recur­ To find the value of min pt 1 [pt +, pt + ] Ft 11 (pt 1 ) for a given pt three
rence relation that solves it. cases can be identified equivalent to those of Frangioni and Gentile [2]:
The state space represents the possible states of the generator for
1
each time step. Every state at time t has a set of feasible transitions to Ft 1 (pt + ) pt < pt* 1
states at time t + 1 which depends on ramping limits and minimum up min+ Ft 11 (pt 1 ) = Ft 11 (pt* 1 ) pt* 1 pt pt* 1 + +

and down time. It is therefore necessary to keep track of how long a pt 1 [pt , pt + ]
Ft 11 (pt +) pt > pt* 1 + +
generator has been on or off, until the minimum up- or downtime is
reached, and to keep track of the power output pt [ P , P ] when a (16)
generator is on. The set of states that a generator can be in at time t is
In other words, if pt can be reached from pt* 1 within the ramping
defined as:
limits, i.e. with a subtraction smaller than or an addition smaller
{off t {1 Mdown}} than + then min pt 1 [pt +, pt + ] Ft 11 (pt 1 ) = Ft 11 (pt* 1 ) . Otherwise pt is
St = either smaller than pt* 1 or larger than pt* 1 + +. In the first case,
{(ont , pt ) {1 max(t , Mup )}, pt [ P , P ]} (15)
since this function is convex, the largest feasible pt 1 is optimal. Which
See Fig. 1 for the binary commitment variables statespace and is given by pt 1 = pt + . Similar for the second case the smallest
transitions. The state off t represents the state at time t where the gen­ feasible pt 1 is optimal. Which is given by pt 1 = pt +. The idea is

erator is off for τ time steps, but when = Mdown it represents that the illustrated in Fig. 2.
generator is off for at least Mdown time steps. The state (ont , pt ) re­ Suppose the function Ft 11 consists of m piece-wise functions
presents that at time t a generator is on for τ time steps and produces pt gt 1 gtm 1 over m intervals:
1

at time t.
[ P , pt1 1 ], [pt1 1 , pt2 1 ], , [ptm 1 1 , P ] (17)
We will now define the recurrence relation c(st) that for each state st
returns the cost of the optimal 1UC schedule at time t that ends in st
(1)–(8). For each state st this is defined as the cost of that state, the gti 1 (pt 1 ) = Ft 1
1 (pt 1 ) pt 1 [pti 1
pti 1 ] (18)
1,
minimum of c (st 1) over states st 1 that can transition towards st and the
transitions costs. Suppose pt* 1 falls in interval k, pt* 1 [ptk 11 , ptk 1 ]. We now observe that
At t = 1 the generator can be in any state with only the cost of being pt min pt 1 [pt +, pt + ] Ft 1 1 (pt 1 ) consists of m + 2 piece-wise
in that state and no transition cost, (1) and (5). functions gt1 gtm + 2 which we can explicitly construct from the previous
For t > 1 we can formulate every possible state transition that re­ intervals. These intervals are given by:
spects ramping limits and minimum up- and downtime and define the
recurrent part of the recurrence relation by (2)–(4) and (6)–(7). [ P , pt1 ], , [ptk , ptk + 1 ], , [ptm + 1 , P ] (19)
There are three types of transitions to a state where the generator is
off. First, we can get to the first off-state offt1 from an on-state (ont 1, pt )
where the generator is on for at least Mup time steps and produces less max( P , pti 1 ) i<k
than the shutdown limit SD (2). Secondly we can get to the off-state off t max( P , pt* 1 ) i=k
pti =
that is off for τ > 1 time steps from an off-state that is off for 1 time min(P , pt* 1 + +) i=k+1
steps (3). Thirdly, If = Mdown we can also get to the last off-state
min(P , pti 12 + +) i k+2 (20)
off tMdown from off tM1down (4).
For the on-states it is almost similar. We can only get to the on-state
(ont1, pt ), where pt is less than the startup limit SU, from an off-state
off tM1down where the generator is off for at least Mdown time steps (6). We
can get to on-state (ont , pt ) that is on for τ > 1 time steps from an on-
state (ont 11, pt 1 ) if the difference between pt and pt 1 respects the
ramp-up + and ramp-down limit (7).

5. Constructing Ft

Because the set of on-states is infinite, we cannot calculate the cost

of every possible on-state, (ont , pt ), explicitly. Therefore we construct
for every t {1, , n}, {1, , max(t , Mup)} a function Ft such that
Ft (pt ) = c (ont , pt ), the function is given by (9). Moreover Ft has a
piece-wise nature and is convex.3 In order to solve 1UC we need
iteratively determine c (off t ) and Ft for each t and τ. Solving 1UC ef­
ficiently boils down to constructing Ft efficiently for all t and τ. In this

3
Proof is omitted for brevity but convexity is easy to see if you look at the Fig. 1. The commitment statespace and transitions of 7 time steps. The off-
epigraph of the new function created in (16). states are represented as white nodes and the on-states as black nodes.

3
R.H. Wuijts, et al. Electric Power Systems Research 190 (2021) 106720

Table 1
Overview 1UC algorithms .
ft is convex

Author/ Name Time Time Detailed Note

3
Frangioni et al. [2] O(n )
Frangioni et al. [12] O(n3) O(n2m) m= max intervals
RRF (this work) O(n3) O(n2m)
RRF+ (this work) O(n4) O(nmk2) k= max relevant functions

m= max intervals (Ft )

Fig. 2. Visualising (16). Here the bottom axis represents how the domain of t {1, , n} {1, , t} (22)
Ft 11 (17) is partitioned and how its mapped to the domain of
pt min pt 1 [pt +, pt + ] Ft 11 (pt 1 ) (19). {1, , t }, p [P, P ]
k= max | | |
t {1, , n} Ft (p) min Ft (p)
{1, , t} (23)
gti 1 (p + ) i<k
Regarding the complexity of RRF(+), Line 7 is repeated O(nkm)
gti (p) = gti 1 *
(p ) i=k+1
1 t 1 times since the O(k) relevant functions have O(m) intervals. Line 9 is
i 2 +)
gt 1 (p i k+2 (21) repeated O(n) times and has a cost of O(mk2) since the maximum
number of intersections that can occur for O(k) functions with O(m)
Intervals that become [P, P] or [P , P ] are redundant and can be intervals is O(mk2).
removed. Moreover if the optimal point lies on the end point of an Therefore, the total time complexity of RRF+ is O(nmk2) and RRF is
interval, say pt* 1 = ptk 1 , then the k + 2 st interval becomes a single O(n2m) since line 9 is skipped in which irrelevant functions are re­
point and can be removed. Also note that if gt1 1 gtm 1 are linear func­ moved. As the numbers k and m theoretically could both be O(n) the
tions then the optimal point always lies on a breakpoint. Therefore if ft time complexity of RRF+ and RRF are O(n4) and O(n3) respectively.
is piece-wise linear only one extra interval is introduced. However, we found that every function only has a small number of
intervals when we use generator data from specific UC problems de­
scribed in the literature. Moreover only a small (most of the time only
6. Algorithm RRF(+) one) number of functions is minimal at some point pt [ P , P ]. In this
case our algorithm RRF+ runs in linear time (Table 1).
Solving c with Ft is similar to the algorithm of Frangioni and
Gentile [2]. The major difference is that instead of pre-calculating the 7. Second recurrence relation
optimal economic dispatch for on-periods we now inductively for each
time step create a set of functions Ft . These functions represent the
Mup
optimal 1UC schedule up until time t which includes the optimal eco­ c ’ (offt ) = min c ’ (ont 1 , pt 1 ) + cstop t > 1 = 1
nomic dispatch. This has the advantage that we can identify functions
pt 1 [ P , SD] (24)
that will not lead to optimality and do not have to calculate the next 1
c ’ (ont , pt ) = ft (pt ) + min+ min{c ’ (ont 1, pt 1 ), c ’ (ont 1, pt 1 )} t
function Ft ++11. This is based on the following proposition: pt 1 [pt , pt + ]

Proposition 6.1. If a function Ft has the property p [P, P ] > 1 = Mup P pt P (25)
Ft (p) > min [Mup, t ] Ft (p) then a schedule in which the generator at time
t is on for τ time steps cannot be optimal. ft (pt ) t = 1, P pt P

Proof is omitted for brevity. The idea is that for any t and pt [ P , P ] ft (pt ) + c (offtMdown
1 ) + cstart t > 1, = 1, P pt
all states (ont , pt ) where τ ∈ {Mup, t} have equivalent state transitions. SU
Therefore the antecedent implies there exists a better schedule for every 1
ft (pt ) + min+ Ht t > 1, 1 < < Mup, P
pt [ P , P ]. Therefore Ft (p) can be forgotten and consequently all
1
pt 1 [pt , pt + ]
Ht (pt ) = pt P
following Ft ++i i , 1 ≤ i < n. (pt 1 )
Irrelevant functions can be identified in multiple ways. One way is
ft (pt ) + min+ min t > 1, = Mup, P pt
to trace the minimum of all Ft functions and mark those that are part of pt 1 [pt , pt + ]
the minimum. After that we can remove those functions Ft that are not 1 P
{Ht 1 (pt 1 ), Ht 1 (pt 1 )}
marked. The minimum can be traced by finding the function Ft that has
the minimal value at P. This function is part of the minimum and if it
otherwise (26)
intersects with another function at any point in [ P , P ] then that function In this section we present a different but equivalent recurrence re­
is also part of the minimum. We can find every function by iteratively lation that is based on the fact that it is only necessary to keep track of
finding intersections. how long a generator has been on up until the minimum uptime is
We call the algorithm that solves the recurrent relation (1)–(8) by reached. Therefore we could reduce the state space by reformulating
constructing the Ft functions without removing irrelevant ones: RRF the states St (15) to St :
and the algorithm that removes the irrelevant functions RRF+. The
whole procedure of RRF and RRF+ is outlined in Algorithm 1. {offt {1 Mdown}}
St =
{(ont , pt ) {1 Mup}, pt [ P , P ]} (27)
6.1. Time complexity See Fig. 3 for the binary commitment variables statespace and transi­
tions. Now the state (ont , p) represents the state at time t where the
Let m be the maximum number of intervals of all Ft functions at any generator is on for τ time steps and produces pt at time t but when
time and let k be the maximum number of relevant functions at any = Mup it represents that the generator is on for at least Mup time steps.
time: Besides reducing the state space this also introduces an additional

4
R.H. Wuijts, et al. Electric Power Systems Research 190 (2021) 106720

3. if p ∈ Q and p + < P then p + Q

All proofs regarding B and Q are in the Appendix. When we solve

the recurrence relation c′ we need to construct Ht for every
t {1, , n}, {1, , Mup} and pt ∈ Q.
For a single function Ht where τ > 1 and for every pt ∈ Q we need to
find the point pt 1 [pt +, p +
t ] Q where Ht 11 (pt 1 ) is
minimal. Finding this point can be trivially done in O(|Q|) resulting in a
total time complexity of O(|Q|2).
However if τ < Mup then Ht is still a convex function and the
Fig. 3. The new commitment statespace and transitions of 7 time steps. The off- minimal point in Q is given as the argument of the minimum of (16) and
states are represented as white nodes and the on-states as black nodes. can be computed in O(1).
The case where = Mup could also be improved. We can make use of
the property that for two consecutive points pt , pt Q the set re­
type of state transition that can be made. Now we can also get to the last
M M presenting the interval around the points Q [pt +, p + ] and
on-state (ont up , pt ) from (ont up
1 , pt 1 ) if the difference between pt 1 and
t
Q [pt +, p + ] shares the majority of elements. To find to
pt respects the ramping limits. We define a new recurrence relation c′(st) t
minimum value for all points is finding the sliding minimum over an
similar to c(st). For brevity we only show the parts of the recurrence
array. All minimal points can be found with a double-ended queue in O
relation that differ from c(st) in (24) and (25).
(|Q|). The full Algorithm RRH is described in Algorithm 2.
Again since we cannot compute the cost c′(s) for every possible state
Creating all Ht has a time complexity of O(n · |Q|). The overall time
s we need to construct a function Ht such that: Ht (pt ) = c (ont , pt ) and
complexity of RRH therefore becomes O(n · |Q|) which is an improve­
is defined in (26). Now it is easy to see that t {Mup n} :
ment to complexity of O(n · |Q|2) from Guan et al. [3] (Table 2).
Mup
Ht (p ) = min Ft (p) p [P, P ]
{Mup t} (28)
9. Computational results
M
Because is the minimum of multiple Ft functions is the reasons we
Ht up
can remove irrelevant functions in Section 5. Effectively we are trying To test the efficiency we have implemented five algorithms for
M
to find the smallest subset of Ft that represents Ht up . linear and quadratic generation cost and tested it on generator data
We can solve 1UC either by constructing Ft or Ht . For Ft there from instances in the UC literature. We gathered the generator data of
exists an efficient method to construct these functions and to identify power systems from the following sources:
redundant functions. Constructing Ht for any convex function ft is
harder since we need to iteratively take the point-wise sliding minimum • A110, 110 generator instance (Orero and Irving [6]).
of two functions, one convex HtMdown 1
and one non-convex HtMdown see • TAI38, 38 generator instance (Huang et al. [7]).
• GA10, 10 generator instance (Kazarlis et al. [8]).
1 1
(26).
• KOR140, 140 generator instance (Park et al. [9]).
8. Algorithm RRH • RCUC200, 200 generator instance (Frangioni et al. [10]).
We will now show a way to construct Ht when ft is piece-wise linear For all instances we solved the problem with 10 different time series
by storing Ht at a finite set of points. When solving the recurrence of electricity prices for every generator for 10 different horizons
relation in this way the state space becomes equivalent to the state {100, 200, , 1000} . For every time step, ft is constructed from the
space of Guan et al. [3]. But we found a mistake in their formulation, generation cost of the generator and Lagrangian multipliers. In total we
fixed that mistake4 and made the algorithm more general. Our algo­ ran 49,900 different 1UC problems and compared the following algo­
rithm also works with non-equal ramping limits. Moreover, by a more rithms:
in-depth analysis of the recurrence relation we make the algorithm
more efficient. • RRF+, here we solve the recurrence relation c by constructing F t
When ft is piece-wise linear we can represent Ht by only storing a and remove irrelevant functions as described in Section 6.
finite set of points that must contain the optimum of Ft and, by a • RRH, here we solve the recurrence relation c′ by constructing H t
consequence of (28), of Ht . This set also contains the points that are with values in Q efficiently by the method described in Section 8.
required to compute the optimum. These are the points that are com­ • Guan*, here we solve the recurrence relation c′ by constructing H t
puted when solving the recurrence relation, i.e. points that are on the with values in Q but without the proposed time complexity im­
path found by backtracking from optimal points. We use B ft to denote provements. Here the algorithm is equivalent to the algorithm of
the set of breakpoints of the piece-wise linear cost function ft. We use B Guan et al. [3] if the formulation was complete and extended for
to denote the set of all possible optimal points. We use Q to denote the non-equal ramping limits (hence the star).
set of all optimal points plus those points required to compute Ht (b) for • RRF, here we solve recurrence relation c by constructing Ft without
b ∈ B. Let the set B be defined as: removing irrelevant functions. This algorithm is, therefore, com­
parable to Frangioni and Gentile [2] with the graph reduction
1. { P , SU , P } B ft B mentioned in [12].
2. if p ∈ B and p + + < P then p + + B • Gurobi, at last we implemented the problem as a MI(Q)P in Gurobi
3. if p ∈ B and p > P then p B with a standard 3-bin formulation [11].

Let the set Q be defined as: All algorithms where written in C# and run on an i7-8700K
3.70 GHz processor running on Windows 10.
1. B ∪ {SD}⊆Q
2. if p ∈ Q and p + > P then p + Q 9.1. Results

The results are given in Tables 3, 4, Figs. 4 and 5. Table 3 contains

4
For example the point SU where = + = should also be included. the average running time in milliseconds of 1UC problems. Table 4

5
R.H. Wuijts, et al. Electric Power Systems Research 190 (2021) 106720

Table 2 1UC problems and k was at most 5 and m at most 10 (Table 4). These
Overview 1UC algorithms. values where the same across all time horizons and did not increase
ft is convex piece-wise linear when we increased n. We can also see the direct result of the linear vs
quadratic growth in Fig. 4.
Author/ Name Time Time Detailed Restrictions The algorithm RRH is a direct improvement to Guan*. For some
Fan et al. [4] O(n3) + = , SU = SD instances where the set of optimal points Q is small (Table 4) there is
Guan et al. [3] O(n) O(n · |Q|2) + = , SU = SD
little to no difference (A110,GA10) but for other instances where Q is
RRH (this work) O(n) O(n · |Q|)
much larger this difference becomes significant (see TAI38 and

Table 3
Average computation time to solve 1UC of 10 time series of electricity prices for all generators in 5 instances for 3 horizons (100, 500, and 1000 time steps), both for
the piece-wise linear and quadratic cost function (in milliseconds).
ft is linear ft is quadratic

Instance n RRH Guan* RRF+ RRF Gurobi RRF+ RRF Gurobi

GA10 100 0.2 0.3 0.8 2.2 17.1 0.6 2.5 22.6
TAI38 1 37.2 0.4 1.7 16.1 0.4 2.1 100
A110 0.1 0.2 0.4 1.6 13.1 0.3 2.1 17.4
KOR140 0.2 0.8 0.4 1.5 12.4 0.3 2 141.4
RCUC200 2.3 101.5 0.5 1.9 20.9 0.4 2.3 105.4
GA10 500 0.7 1.6 3.5 55.1 162.9 2.7 60.3 453.4
TAI38 4.3 191.9 2.4 44.1 44.8 1.7 52.6 853.2
A110 0.5 0.7 1.5 38.8 56.8 1.2 51.2 317.4
KOR140 1.1 3.8 2.4 38.4 55.2 1.7 49.7 2436.5
RCUC200 11 497.4 2.5 49.5 141.2 1.9 57.3 3410.9
GA10 1000 1.4 3.5 6.7 213.4 395.5 5.3 237.7 1355.8
TAI38 8.7 380.7 4.7 167.9 112.8 3.4 208.4 3838.3
A110 0.8 1.3 2.9 148.5 128.2 2.4 198.3 977.2
KOR140 2.2 7.8 4.8 152 122.2 3.4 198.9 3398.6
RCUC200 21.8 991.1 4.9 192 391.2 3.8 225.7 4980

Table 4
Per instance, maximum values of m, k and |Q| all generators in all time steps of
10 horizons with 10 time series of electricity prices.
ft is linear ft is quadratic

Instance max |Q| max m max k max m max k

GA10 15 6 5 9 5
TAI38 284 5 2 7 2
A110 12 6 5 9 5
KOR140 32 6 4 10 4
RCUC200 251 7 4 8 4

contains for each instance the maximum amount of points in Q, the

maximum number of intervals and the maximum number of relevant
functions for all experiments. Fig. 4 shows the growth in computation
time when the time horizon is increased and Fig. 5 shows the ratio of
problems solved for different performance ratios.
For all problem instances RRF+ and RRH outperform the other
algorithms in terms of computation time. From Fig. 5 you can see that
in 40% of the cases RRH and in 60% of the cases RRF+ has the lowest
computation time.
When the generation cost is linear the geometric average speed up
of RRH compared to RRF+, Guan*, RRF and Gurobi is 1.3, 7.3, 17.6 and
45.8. The geometric average speed up of RRF+ compared to Guan*, Fig. 4. The growth of the average computation time in milliseconds when the
RRF and Gurobi is 5.7, 13.6 and 35.7. When the generation cost is amount of time steps increases when the generation cost function is linear.
quadratic the geometric average speed up of RRF+ compared to Guan*,
RRF and Gurobi is 22.0 and 387.9. Table 3 shows that even for large RCUC200 in Table 3).
time steps both algorithms solve 1UC in few milliseconds.
The fact that Gurobi performs as one of the worst is also not sur­
10. Conclusion
prising since it is a general solver that tries to compete with algorithms
specifically designed for 1UC.
We introduced a recurrence relation that solves 1UC. In order to
RRF+ outperforms RRF as it is a direct improvement of RRF with a
solve this recurrence relation we created multiple functions Ft that for
little computational overhead to identify redundant functions. In theory
each pt [ P , P ] return the cost of the optimal schedule that is on at
(for now) the worst case analysis of RRF+ is worse than RRF but in
time t for τ time steps and produces pt. By creating these functions in­
practice it reduces the amount of functions needed from O(n) to some
ductively we were able to identify irrelevant functions and remove
small amount. For these experiments we considered 49,900 different
them. Resulting in a time complexity of O(nmk2) where k is the

6
R.H. Wuijts, et al. Electric Power Systems Research 190 (2021) 106720

steps which improves the previous quadratic growth.

We introduced a different recurrence relation Ht that requires fewer
functions to be stored. These functions are harder to create than Ft .
However we showed that in the special case where generation cost is
piece-wise linear we only need to keep track of a finite number of points
Q to represent these functions. The method of representing cost only at
a finite number of points is similar to the DP algorithm of Guan et al.
However our method works for non-equal ramping limits and we
showed how to efficiently compute the value at Q, resulting in an im­
proved algorithm in terms of generality and time complexity of O
(n · |Q|).
We performed computational experiments with generator data from
multiple power systems. The results show that our algorithm, RRF+,
that identifies and removes irrelevant functions Ft and our algorithm,
RRH, of representing Ht as a finite set points outperforms other
methods with piece-wise linear and quadratic generation cost.
Both methods increase the efficiency and can solve the single-unit
Fig. 5. Graph that shows for increasing performance ratios the ratio of pro­ commitment problem for large time horizons in a few milliseconds. This
blems that are solved within a factor, the performance ratio, of the best per­ could lead to significant improvements for solving large scale unit
forming algorithm for each instance. commitment problems with Lagrangian relaxation or related methods.

1: Initialise F1τ and c(o f f1τ ) Declaration of Competing Interest

2: for all t ∈ {2, . . . , n} do
3: for all τ ∈ {1, . . . , Mdown } do The authors declare that they do not have any financial or non­
4: Determine c(o f ftτ ) with (2), (3) and (4) financial conflict of interests
5: end for
6: for all τ ∈ {1, . . . , max(t, Mup )}/Irrelevant do Acknowledgement
7: Determine Ftτ with (9), (19), (20) and (21)
This work is part of the research programme “Energie: Systeem
8: end for
Integratie en Big Data” with project number 647.003.005, which is fi­
9: (Remove irrelevant functions by finding intersections) nanced by the Dutch Research Council (NWO).
10: end for
11: Backtrack to get the solution Appendix A. proofs about B and Q
Algorithm 1. RRF(+).
Proposition A.1. If ft is a piece-wise linear function then the break points of
1: Initialise H1τand c(o ff1τ ) Ft are only in B
2: for all t ∈ {2, . . . , n} do Proof. For = 1 its trivial. For τ > 1 assume Ft 11 only has breakpoints
3: Compute c(o f ftτ ) with (2), (24) and (25) in B. Recall that min pt 1 [pt +, pt + ] Ft 11 (pt 1 ) is constructed from Ft 11
4: for all τ ∈ {2, . . . , Mup − 1} do by shifting the intervals of Ft 11 and introducing one new interval in the
case where ft is a piece-wise linear cost function. The new breakpoints
5: Determine Htτ (pt ) with (26),(16) for all pt ∈ Q
are those already in B but shifted down by or up by + and if they
6: end for exceed P or P they become P or P . In the first case those new points are
7: Create Dequeue D in B by definition 2) and 3), in the later case they are in B by 1). The
8: for all p ∈ Q do addition of ft can add breakpoints caused by the fact that ft is piece-wise
9: for all q ∈ (Q ∩ [p − ∆+ , p + ∆− ]) − D do linear with breakpoints at B ft . □
10: Remove elements from end of D that Proposition A.2. If Ft is a piece-wise linear function then a minimal point
M M −1
11: have value > max{Ht up (q), Ht up (q)} in interval [p, p′] of Ft is in B ∪ {p, p′}
12: Add q to the end of D
Proof. Suppose the optimal point pt* lies in [p, p′]. Then from
13: end for Proposition Appendix A.1 we know pt* B . Suppose pt* [p , p ]
14: Remove q ∈ D − (Q ∩ [p − ∆+ , p + ∆− ]) from D since Ft is convex the minimal point in [p, p′] is as close as possible
15: q ← the front of D to pt* bounded by the interval, this is either p or p′. □
M M −1
16: Htτ (p) = max{Ht up (q), Ht up (q)} + ft (p) Proposition A.3. If Ft is a piece-wise linear function then then the
17: end for minimum value at the end of a on-period has a production value in
18: end for B ∪ {SD}.
19: Backtrack to get the solution Proof. If the generator is last on at t then it can only produce pt ∈ [P,
Algorithm 2. RRH. SD]. Combined with Proposition Appendix A.2 this is minimal in
B ∪ {SD}. □
maximum number of relevant functions and m is the maximum number The minimum value at the end of a on-period has a production value
of intervals of those functions. We showed that for the instances studied in B ∪ {SD}. These points however do not only depend on points in
k was at most 5 and m at most 10 and did not increase when we in­ B ∪ {SD}. Optimal points can also depend on non-optimal points. We
creased the amount of time steps. We show experimentally that this can iteratively capture these additional points by the set Q. That is a set
results in a computation time that grows linear in the amount of time of all the points from which Ft is minimal plus all the points that are

7
R.H. Wuijts, et al. Electric Power Systems Research 190 (2021) 106720

needed to compute the minimal points. for unit commitment problems, IISE Trans. 50 (8) (2018) 735–751.
The recursive rules of Q come from the following observation: [4] W. Fan, X. Guan, Q. Zhai, A new method for unit commitment with ramping con­
straints, Electr. Power Syst. Res. 62 (3) (2002) 215–224.
suppose we want to know the value of Ft (pt ) for some point [5] Q. Zhai, X. Guan, F. Gao, Optimization based production planning with hybrid
pt ∈ {B ∪ SD}. The value of this point is constructed from the minimum dynamics and constraints, IEEE Trans. Autom. Control 55 (12) (2010) 2778–2792.
in [pt +, p + ]. From Proposition Appendix A.2 we know this [6] S.O. Orero, M.R. Irving, Large scale unit commitment using a hybrid genetic al­
t
gorithm, Int. J. Electr. Power Energy Syst. 19 (1) (1997) 45–55.
minimum is in Q {pt +, p + } . The set Q therefore needs to
t [7] K.-Y. Huang, H.-T. Yang, C.-L. Huang, A new thermal unit commitment approach
contain all the points that are on the path found by backtracking from using constraint logic programming, IEEE Proceedings of the 20th International
optimal points. Conference on Power Industry Computer Applications, (1997), pp. 176–185.
[8] S.A. Kazarlis, A.G. Bakirtzis, V. Petridis, A genetic algorithm solution to the unit
From (28) its easy to see the three propositions also hold for Ht .
commitment problem, IEEE Trans. Power Syst. 11 (1) (1996) 83–92.
Moreover Q are the only points we need to store to represent Ht . [9] J.-B. Park, et al., An improved particle swarm optimization for nonconvex economic
dispatch problems, IEEE Trans. Power Syst. 25 (1) (2010) 156–166.
References [10] A. Frangioni, C. Gentile, F. Lacalandra, Tighter ap proximated MILP formulations
for unit commitment problems, IEEE Trans. Power Syst. 24 (1) (2009) 105–113.
[11] J. Ostrowski, M.F. Anjos, A. Vannelli, Tight mixed integer linear programming
[1] I.D.L. Wim van Ackooij, A. Frangioni, Fabrizio lacalandra and milad tahanan, large- formulations for the unit commitment problem, IEEE Trans. Power Syst. 27 (1)
scale unit commitment under uncertainty: an updated literature survey, Ann. Oper. (2009) 39–46.
Res. 271 (1) (2018) 11–85. [12] A. Frangioni, C. Gentile, New MIP formulations for the singleunit commitment
[2] A. Frangioni, C. Gentile, Solving nonlinear single-unit commitment problems with problems with ramping constraints, IASI Research Report (2015).
ramping constraints, Oper. Res. 54 (4) (2006) 767–775.
[3] Y. Guan, K. Pan, K. Zhou, Polynomial time algorithms and extended formulations