Aircraft Allocation

    {  airsp.mpl  }

    {  GAMS Model Library, http://www.gams.com/modlib/libhtml/aircraft.htm  }

    {  Aircraft Allocation Under Uncertain Demand, Routing,  Version1:- Size: 11 x 42, Version2:- Size: 56 x 72 }

#define Version1
!#define Version2

TITLE
    aircraft;

INDEX
    i := (a, b, c, d);
    j := (route_1, route_2, route_3, route_4, route_5);
    h := 1..5
    hp := h;

DATA

    Dd[j,h] := (
!                 1     2     3     4     5
 {route-1}      200,  220,  250,  270,  300,
 {route-2}       50,  150,    0,    0,    0,
 {route-3}      140,  160,  180,  200,  220,
 {route-4}       10,   50,   80,  100,  340,
 {route-5}      580,  600,  620,    0,    0);

    Lambda[j,h] := (
!                 1     2     3     4     5
 {route-1}      0.2, 0.05, 0.35,  0.2,  0.2,
 {route-2}      0.3,  0.7,    0,    0,    0,
 {route-3}      0.1,  0.2,  0.4,  0.2,  0.1,
 {route-4}      0.2,  0.2,  0.3,  0.2,  0.1,
 {route-5}      0.1,  0.8,  0.1,    0,    0);

    C[i,j] := (
!          route-1 route-2 route-3 route-4 route-5
 {a}          18,     21,     18,     16,     10,
 {b}           0,     15,     16,     14,      9,
 {c}           0,     10,      0,      9,      6,
 {d}          17,     16,     17,     15,     10);

    P[i,j] := (
!          route-1 route-2 route-3 route-4 route-5
 {a}          16,     15,     28,     23,     81,
 {b}           0,     10,     14,     15,     57,
 {c}           0,      5,      0,      7,     29,
 {d}           9,     11,     22,     17,     55);

    Aa[i] := (10, 19, 25, 15);

    K[j]  := (13, 13, 7, 7, 1);

    Ed[j] := SUM(h: Lambda * Dd);

    Gamma[j,h] := SUM(hp: Lambda[h:=hp] WHERE (hp >= h));

    Deltb[j,h] := Dd WHERE (Dd > 0) - Dd[h-1] WHERE (Dd > 0);


VARIABLE
    X[i,j];
    Y[j,h];
    B[j,h];
    Oc;
    Bc;

MODEL

    MIN Phi = Oc + Bc;

SUBJECT TO

    Ab[i]:   SUM(j: X) <= Aa;

    Ocd:     Oc = SUM(i,j: C * X);

#ifdef Version1
    Db[j]:   SUM(i: P * X) >= SUM(h: Y WHERE (Deltb > 0));

    Bcd1:    Bc = SUM(j: K * (Ed - SUM(h: Gamma * Y)));
#endif

#ifdef Version2
    Bd[j,h]: B = Dd - Y;

    Yd[j,h]: Y <= SUM(i: P * X);

    Bcd2:    Bc = SUM(j,h: K * Lambda * B);
#endif

BOUNDS

#ifdef Version1
    Y <= Deltb;
#endif

END