Chapter 3 (Fig. 3.16) – The Mathematical Formulation Of The Input DEA Congestion Using Slack Variables With The Corresponding GAMS Formulation

$Title Chapter 3 (Fig. 3.16)
$Title The Mathematical Formulation Of The Input DEA Congestion Using Slack Variables With The Corresponding GAMS Formulation

$onText

If using this code, please cite:

---------------------------------------------------------------------------------
Emrouznejad, A., P. Petridis, and V. Charles (2023). Data Envelopment Analysis
with GAMS: A Handbook on Productivity Analysis, and Performance Measurement,
Springer, ISBN: 978-3-031-30700-3.
---------------------------------------------------------------------------------

Website: https://dataenvelopment.com/GAMS/

$offText

Sets    j DMUs /DMU1*DMU10/
        g Inputs and Outputs /ProdCost, TrnCost, 
                             HoldInv, SatDem, Rev, CO2/

        i(g)  Inputs under managerial control /ProdCost, 
                                               TrnCost, 
                                               HoldInv/
        r(g) Desirable outputs /SatDem, Rev/;
        alias(jj,j);
        alias(kk,jj);
Table Data(j,g) Data for inputs and outputs

           ProdCost     TrnCost      HoldInv     SatDem      Rev
DMU1        0.255        0.161        0.373        20        2.64
DMU2        0.98         0.248        0.606        6         5.29
DMU3        0.507        0.937        0.749        17        2.43
DMU4        0.305        0.249        0.841        2         8.99
DMU5        0.659        0.248        0.979        19        2.94
DMU6        0.568        0.508        0.919        17        0.75
DMU7        0.583        0.628        0.732        17        6.36
DMU8        0.627        0.675        0.738        10        7.2
DMU9        0.772        0.657        0.486        9         2.16
DMU10       0.917        0.639        0.234        8         7.3;

  Variables efficiency    objective function for model 1
            efficiency1   objective function for model 2
            Theta          Strong disposability efficiency
            Theta_tilde    Weak disposability efficiency
            zeta(i)        Congestion with slack measures
            Lambda(j) dual weights (Lambda values)
Nonnegative Variables          
          Lambda(j) dual weights (Lambda values)
          sminus(i)      slack variable assigned to input
          splus(r)       slack variable assigned to output;
Parameters DMU_data(g) slice of data
             eff_Theta(j)   Strong disposability efficiency  
                            values
             res_eff_2(j)   results for sum of zeta variables
             res_zeta(j,i)   Results for zeta variable  
             Lamres_s(j,j)   peers for each DMU for strong 
                             disposability model  

             slice_Theta     slice of efficiency
             slice_xproj(i)  slice for input projection
             slice_yproj(r)  slice for output projection
             slice_sminus(i) slice for input slack
             slack_in(j,i)   results for input slack variables
             slack_out(j,r)  results for output slack variables
             xproj(j,i)      projected values for inputs for 
                             each DMU
             yproj(j,r)      projected values for outputs for 
                             each DMU;

  Equations OBJ_s objective function for strong disposability
            CON1_s(i) input constraint for strong disposability
            CON2_s(r) output constraint for strong disposability
            OBJ_w objective function for weak disposability
            CON1_w(i) input constraint for weak disposability
            CON2_w(r) output constraint for weak disposability
            CON3_w(i) slack constraint
            VRS    VRS constraint;
            
  OBJ_s..    efficiency=E=Theta-1E-3*(SUM(i,sminus(i))+SUM(r,splus(r)));   
  CON1_s(i)..  SUM(j, Lambda(j)*Data(j,i))=L=Theta*DMU_data(i);
  CON2_s(r)..  SUM(j, Lambda(j)*Data(j,r))=G=DMU_data(r);
  OBJ_w..       efficiency1=E=SUM(i,zeta(i));
  CON1_w(i)..  SUM(j, Lambda(j)*Data(j,i))-
             zeta(i)=E=slice_xproj(i);  
  CON2_w(r)..  SUM(j, Lambda(j)*Data(j,r))=E=slice_yproj(r);
  VRS.. SUM(j, Lambda(j))=E=1;
  model Input_DEA_strong_disposability Input oriented DEA model for strong disposability /OBJ_s, CON1_s, CON2_s, VRS/;
  model Input_DEA_weak_disposability_slack  Input oriented DEA model for weak disposability with slack measures /OBJ_w, CON1_w, 
                                         CON2_w, CON3_w, VRS/;
 loop(jj,
   DMU_data(g) = Data(jj,g);
   
       solve Input_DEA_strong_disposability using LP 
             minimizing Theta;
       eff_Theta(jj)=Theta.l;
       slack_in(jj,i)=sminus.l(i);
       slack_out(jj,r)=splus.l(r);
       xproj(jj,i)=eff_theta(jj)*Data(jj,i)-
                   slack_in(jj,i);
       yproj(jj,r)=Data(jj,r)+slack_out(jj,r);
       slice_xproj(i)=xproj(jj,i);
       slice_yproj(r)=yproj(jj,r);
       slice_Theta=eff_Theta(jj);
       slice_sminus(i)=slack_in(jj,i);
       solve Input_DEA_strong_disposability using LP minimizing Theta;
       eff_Theta(jj)=Theta.l;
      slack_in(jj,i)=sminus.l(i); slack_out(jj,r)=splus.l(r);
      
    xproj(jj,i)=eff_theta(jj)*Data(jj,i)-slack_in(jj,i); yproj(jj,r)=Data(jj,r)+slack_out(jj,r);
    slice_xproj(i)=xproj(jj,i); slice_yproj(r)=yproj(jj,r); slice_Theta=eff_Theta(jj); slice_sminus(i)=slack_in(jj,i);
    
    solve Input_DEA_weak_disposability_slack using LP maximizing efficiency1;
    res_zeta(jj,i)=zeta.l(i);
    res_eff_2(jj)=SUM(i,zeta.l(i));
    );
    Display eff_Theta, res_zeta, res_eff_2;