timesteps.gms : Accessing previous (or next) time steps in an equation fast

**Description**

In dynamic models one often needs access to previous or next time steps. Access to single time steps can be easly implemented via the lag and lead operator. It gets more difficult if one needs access to a larger set of time steps. the expression sum(tt$(ord(tt)<=ord(t) and ord(tt)>=ord(t)-n), ...) where t is the current time step controlled from the outside can be very slow. The following example model shows how to do this fast in GAMS using an example from power generation modeling. We have a set of time steps and a number of generators. A generator can only start once in a given time slice. We implement the equation that enforces this in three different ways: 1) naive GAMS syntax via ord() calculation 2) calculate a set of time slices for any given active time step 3) fast implementation directly in the equation using the same idas to create the set in 2 fast Solution 2 is actually the fastest, but it consumes a lot of memory. We will eventually require this much memory in the model generation (we have many non-zero entires in the equation) but we can safe the extra amount inside GAMS data by using method 3.

**Reference**

- GAMS Development Corporation, Formulation and Language Example.

**Large Model of Type :** GAMS

**Category :** GAMS Model library

**Main file :** timesteps.gms

```
$title Accessing previous (or next) time steps in an equation fast (TIMESTEPS,SEQ=413)
$Ontext
In dynamic models one often needs access to previous or next time steps. Access
to single time steps can be easly implemented via the lag and lead operator.
It gets more difficult if one needs access to a larger set of time steps.
the expression sum(tt$(ord(tt)<=ord(t) and ord(tt)>=ord(t)-n), ...) where t is
the current time step controlled from the outside can be very slow.
The following example model shows how to do this fast in GAMS using an example
from power generation modeling. We have a set of time steps and a number of
generators. A generator can only start once in a given time slice. We implement
the equation that enforces this in three different ways:
1) naive GAMS syntax via ord() calculation
2) calculate a set of time slices for any given active time step
3) fast implementation directly in the equation using the same idas to create
the set in 2 fast
Solution 2 is actually the fastest, but it consumes a lot of memory. We will
eventually require this much memory in the model generation (we have many
non-zero entires in the equation) but we can safe the extra amount inside GAMS
data by using method 3.
$Offtext
$if not set mt $set mt 2016
$if not set mg $set mg 17
$if not set mindt $set mindt 10
$if not set maxdt $set maxdt 40
$ife %mindt%>%maxdt% $abort minimum downtime is larger than maximum downtime
set t hours / t1*t%mt% /
g generators / g1*g%mg% /;
Parameter
pMinDown(g,t) minimum downtime;
pMinDown(g,t) = uniformInt(%mindt%,%maxdt%);
alias (t,t1,t2);
set sMinDown(g,t1,t2) hours t2 g cannot start if we start g in t1
sMinDownFast(g,t1,t2) hours t2 g cannot start if we start g in t1
tt(t) max downtime hours / t1*t%maxdt% /;
* Slow and fast calculation for the set of time slices t2 for a given time step t1
* Output from profile=1
*---- 50 Assignment sMinDown 5.819 5.819 SECS 26 MB 850713
*---- 51 Assignment sMinDownFast 0.187 6.006 SECS 48 MB 850713
sMinDown(g,t1,t2) = ord(t1)>=ord(t2) and ord(t2)>ord(t1)-pMinDown(g,t1);
sMinDownFast(g,t1,t+(ord(t1)-pMinDown(g,t1)))$(tt(t) and ord(t)<=pMinDown(g,t1)) = yes;
set diff(g,t1,t2);
diff(g,t1,t2) = sMinDown(g,t1,t2) xor sMinDownFast(g,t1,t2);
abort$card(diff) 'sets are different', diff;
binary variable vStart(g,t);
variable z;
* Slow, fast, and fastest (but memory intensive way because we need to store sMinDownFast) way to write the equation
* Output from profile=1
*---- 67 Equation eStartNaive 6.099 12.215 SECS 106 MB 34272
*---- 68 Equation eStartFast 0.593 12.808 SECS 144 MB 34272
*---- 69 Equation eStartFaster 0.468 13.276 SECS 180 MB 34272
equation eStartNaive(g,t), eStartFast(g,t), eStartFaster(g,t), defobj;
eStartNaive(g,t1).. sum(t2$(ord(t1)>=ord(t2) and ord(t2)>ord(t1)-pMinDown(g,t1)), vStart(g,t2)) =l= 1;
eStartFast(g,t1).. sum(tt(t)$(ord(t)<=pMinDown(g,t1)), vStart(g,t+(ord(t1)-pMinDown(g,t1)))) =l= 1;
eStartFaster(g,t1).. sum(sMinDownFast(g,t1,t2), vStart(g,t2)) =l= 1;
defobj.. z =e= sum((g,t), vStart(g,t));
model maxStarts / all /;
solve maxStarts max z us mip;
```