#include <string.h> 
#include <time.h> 
#include <fstream.h> 
#include <stdlib.h> 
#include <string.h> 
#include <stdio.h> 
#include <process.h> 
#include "link1.h" 
#include <math.h> 
 
/* This code is intended to produce VRP/JSP instances 
based on real-life commercial data.  
 
The code is far from perfect.  
It is not optimized regarding size. 
Some of it may be substantially improved 
programming-wise but it works. 
The code assumes you have a data file 
in the following format: 
 
  1 postcode11 postcode21 x1 y1  
  2 postcode12 postcode22 x2 y2  
... 
  i postcode1n postcode2n xn yn 
   
Here 1, 2, ..., i are indexes of your geografic locations. 
postcode1i, postcode2i are alphanumeric symbols representing 
postcodes in Great Britain xi, yi planar coordinates of your locations. 
 
The code iteratively (the number of iterations depends on the desired instance size) 
takes location data without replacement and creates VRP visits. 
Each visit is represented by a line in the output file. 
 
The format of the output file is this: 
 
# instance:       test.txt                                  //lines preceded with '#' are comments.  
# data file:      g:/local/Source/Reformul/Generator/data/g5k.txt 
# generator seed: 5685768 
# Rho:            1 
# Slack:          0.9 
VRP                                                      //problem type 
2 5                                                        //number of vehicles number of customers 
2790.97                                                //vehicle speed, dm/min 
0 1440                                                  //startOfDay endOfDay in minutes: 24-hour shift 
4696 4769                                            // x/y coordinates of the depot 
1 20 1 G2 6BS 23 223 25867 66530 1 2  -1     //first visit, duration 20 min, requires 1 unit of veh capacity, postcodes, earliest start, latest finish, x/y coords, indexes of allowed resources followed by '-1' (ie end of list). 
2 20 1 G22 5RU 1131 1331 25889 66739 1 2  -1 
3 20 1 G4 0TL 709 909 26014 66474 1 2  -1 
4 20 1 G51 3ST 621 821 25472 66530 1 2  -1 
5 20 1 G21 1NS 874 1074 26014 66660 1 2  -1 
0 82932 83163 83023 82537 83209 //these lines occupied by distance matrix, it is redundant in VRPs, but essential for job shop 
82932 0 231 203 395 277 //dimension is n+1 x n+1 where n is the number of customers, first row/column correspond to depot 
83163 231 0 390 626 204  
83023 203 390 0 598 186  
82537 395 626 598 0 672  
83209 277 204 186 672 0  
1 5 //resources section, index of resource followed by capacity 
2 5 
Diff 2   //side constraints section, there are 2 diff constraints specified below 
3 1 
5 4 
Same 1 //there is only 1 same constraint 
4 1 
Precedence 3 //there are 3 precedence constraints 
1 2 
2 3 
4 5 
 
Diff side constraints specify that a pair of visits A and B should 
be on different vehicles, Same constraints specify that A and B 
should be on the same vehicle. Precedence constraints  of type A -> B  
are saying that visit A should be completed before B starts on 
the same or different vehicle. E.g., in our file visit 4 should be 
finished before visit 5 starts. 
 
It is assumed that each visits takes up 1 unit of capacity. 
 
The instances generated may NOT be solvable (there are time windows 
for visits, while side constraints, if you have them, are generated independently).  
You have to check solubility. 
 
Our solubility checker is ILOG Scheduler. I don't know if you are licensed 
to use it. 
 
Time is measured in minutes from midnight. Distance in decameters. 
Never mind the unrealistic value for the vehicles speed (all vehicles 
are assumed to move at the same speed). You could adjust input parameters 
to suit your needs. 
 
For our purposes we just needed precedence side constraints. 
That is why in this version we don't generate diff or same constraints. 
You could easily extend the code to cope with that. 
 
Time windows are generated using random allocation of start times within 
a certain range, and then computing latest finish times based on the given temporal slack 
as defined in the paper "VRP/JSP, whats the difference?" 
 
The input parameters are: 
 
*.exe <VRP/JSP> <datafilename> <outputfilename> 
RandomSeed Rho Slack Spec NbResources NbVisits Dur<int> XBase<int> YBase<int> 
NbJobs SizeOfJob 
 
  1. Type of problem: VRP or JSP 
  2. datafilename: path to the data file (I have hardcoded my own path, please change it accordingly) 
  3. RandomSeed to initialise the rand number generator 
  4. Rho, the ratio of operation duration to transition time. Based on rho, we compute vehicle speed, see our paper 
  5. Slack \in (0,1), we compute time windows according to slack. 
  6. Spec,  specialisation of fleet, corresponds to parameter p in the paper, 1 - a p of 100%, 2 - 80%, etc. 
     The more p gets, the more vehicles are allowed to perform a visit. 
  7. NbResources - number of vehicles; 
  8. NbVisits - number of visits; 
  9. Dur - duration in minutes, assumed constant for all visits; 
  10. X- coordinate of the depot; 
  11. Y- coordinate of the depot; 
  12. NbJobs: 0 for pure VRPs, >0 for VRPs with side constraints, a job is a sequence of visits 
  13. SizeOfJob: 0 for pure VRPs, >0 for VRPs with side constraints, says how many visits there are in a job 
*/ 
const int StartOfDay = 0; 
const int EndOfDay = 1440; 
 
bool RandEarliestStarts = true; 
int NbJobs; 
int SizeOfJob; 
 
int NbVisits, NbResources; 
double Speed;  
double Rho, Slack, Spec; 
int ActDuration; 
 
int ESFactorMorning; //this is the range of earliest start times in the morning; 
                                //we should not disturb the given slack, so max earliest start 
                                //is between the startOfDay+80 in the morning,  
                                //i.e., between 540 and 620; 
int ESFactorEvening;//this is that range but in the evening. 1 hour more; 
/* 
double SpecialisationBag0[] = {1.0}; 
double SpecialisationBag1[] = {0.5}; 
double SpecialisationBag2[] = {0.25}; 
double SpecialisationBag3[] = {0.1}; 
double SpecialisationBag4[] = {0.05}; 
*/ 
int * Capacities; 
int** DataArr; 
int** DistMatr; 
int** ResNumbers; 
int** storeArray; 
 
typedef int * Item; 
 
const int ESMinMorning = StartOfDay; 
//const int ESMinEvening = StartOfDay+240; 
 
inline int myRound(double x) { 
 return (int) (x+0.5); 
} 
 
int getESRange(double slack, int duration, int PrecChainSize) { 
 return myRound((EndOfDay*(1-slack) - PrecChainSize*duration)/(1-slack)) - ESMinMorning; 
// return myRound((EndOfDay - StartOfDay)*(1-slack) - PrecChainSize*duration); 
} 
 
 
int inline computeManhattanDistance(int x1, int y1, int x2, int y2) { 
 return abs(x1-x2) + abs(y1-y2); 
} 
 
int inline computeEucledianDistance(int x1, int y1, int x2, int y2) { 
 return myRound(sqrt((x1-x2)*(x1-x2) + (y1-y2)*(y1-y2))); 
} 
 
void CreateLinkedList(int Length, Node*& loc_head_ptr) { 
  
 Node *loc_prev_ptr,  
         *loc_tail_ptr;         
         
    list_head_insert(loc_head_ptr,1); 
    loc_tail_ptr=loc_head_ptr; 
    loc_prev_ptr = loc_head_ptr; 
 for (int i=2;i<=Length;i++) { 
  list_insert(loc_prev_ptr,i); 
  loc_prev_ptr = loc_prev_ptr->link; 
 } 
} 
 
void outputPair(int N, int PairNb, ofstream& fout) { 
 int k = N-1, sum = 0, sumPrev = 0, ctr = 0; 
 while (true) { 
  sum += k; 
  ctr++; 
  if (sum >= PairNb) { //pair number is between 1 and N*(N-1)/2; 
//    fout<<" ctr = "<<ctr<<endl; 
//    fout<<" sum = "<<sum<<" sumPrev = "<<sumPrev<<endl; 
//    fout<<" dataSaved - sumPrev = "<<dataSaved - sumPrev 
//     <<" ctr + dataSaved - sumPrev = "<<ctr + dataSaved - sumPrev<<endl; 
   fout<<ctr<<" "<<ctr + PairNb - sumPrev<<endl; 
   break; 
  } 
  k = k - 1; 
  sumPrev = sum; 
 } 
 
} 
 
void getPairs(int N, int Number, ofstream& fout) { 
 
 Node * loc_head_ptr = NULL; 
 
 CreateLinkedList(N*(N-1)/2,loc_head_ptr); 
 
 for (int i=0;i<Number;i++) { 
//  print_list(loc_head_ptr,fout,0); 
  int ind1 = 1 + (N*(N-1)/2-i)*rand()/(RAND_MAX+1); 
  Node* loc_curr_ptr = list_locate(loc_head_ptr,ind1); 
  Node* loc_tail_ptr = list_tail_search(loc_head_ptr); 
  Node* loc_prev_ptr; 
  int dataSaved = loc_curr_ptr->data; 
  loc_curr_ptr->data = loc_tail_ptr->data; 
  loc_tail_ptr->data = dataSaved; 
  if (loc_tail_ptr!=loc_head_ptr) { 
   loc_prev_ptr = list_prev_locate(loc_head_ptr,loc_tail_ptr->data); 
   list_node_remove(loc_prev_ptr); 
  } else { 
   list_head_remove(loc_head_ptr); 
  } 
 
  outputPair(N,dataSaved,fout); 
 } 
 list_clear(loc_head_ptr); 
} 
 
void createJobs(int N, int nbJobs, int sizeOfJob, ofstream& fout) { 
 
 int K = nbJobs*sizeOfJob; 
 if (K > N) { 
  cout<<"the number of visits should be gr than or eq to that\n"; 
  cout<<"of operations involved in side constraints\n"; 
  exit(-1); 
 } 
 int i,j; 
 Node * loc_head_ptr = NULL; 
 
 CreateLinkedList(N,loc_head_ptr); // all the visits in the instance are here; 
 storeArray = new int* [nbJobs]; 
 for (i=0; i<nbJobs; i++) { 
  storeArray[i] = new int [sizeOfJob]; 
 } 
 Node** loc_head_ptr_arr; 
 Node** loc_head_ptr_arr_copy; 
 Node** loc_tail_ptr_arr_copy; 
 loc_head_ptr_arr = new Node* [nbJobs]; 
 loc_head_ptr_arr_copy = new Node* [nbJobs]; 
 loc_tail_ptr_arr_copy = new Node* [nbJobs]; 
 for (i=0; i<nbJobs; i++) { 
  loc_head_ptr_arr[i] = NULL; 
  loc_head_ptr_arr_copy[i] = NULL; 
  loc_tail_ptr_arr_copy[i] = NULL; 
 } 
 
 for (i=0;i<nbJobs;i++) { 
  for (j=0;j<sizeOfJob;j++) { 
//   print_list(loc_head_ptr,fout,0); 
   int ind1 = 1 + (N - i*sizeOfJob - j)*rand()/(RAND_MAX+1); 
//   cout<<"i = "<<i<<" j = "<<j<<" ind1 = "<<ind1<<endl; 
   Node* loc_curr_ptr = list_locate(loc_head_ptr,ind1); 
   Node* loc_tail_ptr = list_tail_search(loc_head_ptr); 
   Node* loc_prev_ptr; 
   int dataSaved = loc_curr_ptr->data; 
   loc_curr_ptr->data = loc_tail_ptr->data; 
   loc_tail_ptr->data = dataSaved; 
   if (loc_tail_ptr!=loc_head_ptr) { 
    loc_prev_ptr = list_prev_locate(loc_head_ptr,loc_tail_ptr->data); 
    list_node_remove(loc_prev_ptr); 
   } else { 
    list_head_remove(loc_head_ptr); 
   } 
 
   storeArray[i][j] = dataSaved; 
 
  } 
 } 
 list_clear(loc_head_ptr); 
} 
 
void assignTimeWindowsToChains(int actDur, double slack, int nbJobs, int sizeOfJob, ofstream& fout) { 
 
 int i,j; 
 int ESMaxJob = (int)(EndOfDay - sizeOfJob*actDur - actDur/(1-slack) + actDur); 
 //ESMaxJob is the upper bound of the range in which we can randomly vary earliest starts 
 //so that when computing latest finish times we retain the given slack, end of day and visit duration. 
 cout<<"ESMaxJob = "<<ESMaxJob<<endl; 
 
 for (i=0; i<nbJobs; i++) { 
  DataArr[storeArray[i][0]][4] = ESMaxJob*rand()/(1+RAND_MAX); 
  DataArr[storeArray[i][sizeOfJob-1]][5] = (int)(DataArr[storeArray[i][0]][4]  
                + actDur/(1-slack) - actDur + sizeOfJob*actDur); 
  for (j=1; j<=sizeOfJob-1; j++) { 
   DataArr[storeArray[i][j]][4] = DataArr[storeArray[i][0]][4] + j*actDur; 
  } 
  for (j=sizeOfJob-2;j>=0;j--) { 
   DataArr[storeArray[i][j]][5] = DataArr[storeArray[i][j+1]][5] - actDur; 
  } 
 } 
} 
 
int CheckSolubility(bool Sched, 
     char* fileName,  
     int NbVisitsCurr) { 
 cout<<endl; 
 if (Sched) cout<<"solubility checking by Sched"<<endl; 
 else cout<<"solubility checking by Dispat"<<endl; 
 cout<<endl; 
 char resBuf[1000]; 
 sprintf(resBuf,"%s", fileName); 
 bool insoluble = false; 
 int val; 
 if (Sched) { 
  val = spawnl(P_WAIT, 
     "g:/local/Source/Reformul/Generator/FindSchedFirstSol.exe", 
     "g:/local/Source/Reformul/Generator/FindSchedFirstSol.exe", 
//     "e:/Source/Generator/FindSchedFirstSol.exe", 
//     "e:/Source/Generator/FindSchedFirstSol.exe", 
     resBuf, 
     "test1s.res", 
     "test2s.res", 
     "test3s.res", 
     "1","1","1","5","40","1","0", NULL);  
 } else { 
  val = spawnl(P_WAIT, 
    "g:/local/Source/Reformul/Generator/FindDispatFirstSol.exe", 
    "g:/local/Source/Reformul/Generator/FindDispatFirstSol.exe", 
    resBuf, 
    "test1d.res", 
    "test2d.res", 
    "test3d.res", 
    "0.4","60","1", "0", NULL); 
 } 
 if (val==-1) { 
  cout<<endl; 
  cout<<"val = "<<val<<" instance insoluble"<<endl; 
  cout<<endl; 
 } else { 
  cout<<endl; 
  cout<<"soluble with NbVisits = "<<NbVisitsCurr<<endl; 
 } 
 return val; 
} 
 
 
int main(int argc, char* argv[]) { 
 
 if (argc!=15) { 
  cout<<"Usage: <filename>.exe <VRP/JSP> <datafile1> <resultsfile1>\n"; 
  cout<<"       seed Rho Slack Spec"<<endl; 
  cout<<"       NbResources NbVisits Dur<int> XBase<int> YBase<int>"<<endl; 
  cout<<"       NbJobs SizeOfJob"<<endl; 
  return 0; 
 } 
 
 ofstream fout; 
 ifstream fin; 
 bool VRPFlag = false; 
 
 char * dataFile; 
 char * resultsFile; 
 char * TypeOfProblem; 
 
 TypeOfProblem = argv[1]; 
 cout<<TypeOfProblem<<endl; 
 fin.open(argv[2], ios::in); 
 
 //TypeOfProblem is only to do with opt criterion: 
 //VRP: minTravelTime, JSP: minMakespan 
 if (TypeOfProblem[0]=='V' && 
  TypeOfProblem[1]=='R' && 
  TypeOfProblem[2]=='P') { 
  VRPFlag = true; 
 } else { 
  VRPFlag = false; 
 } 
 
 dataFile = argv[2]; 
 resultsFile = argv[3]; 
 
 unsigned int seed = (unsigned int) atof(argv[4]); 
 cout<<"seed = "<<seed<<endl; 
 
 Rho = atof(argv[5]); 
 cout<<"rho = "<<Rho<<endl; 
 Slack = atof(argv[6]); 
 cout<<"Slack = "<<Slack<<endl; 
 Spec = atof(argv[7]); 
 cout<<"Spec = "<<Spec<<endl; 
 
 int NbResources; 
 srand(seed); 
 
 int ctr = 0; 
 int ctrResources = 0; 
 
 NbResources = atoi(argv[8]); 
 NbVisits = atoi(argv[9]); 
 ActDuration = atoi(argv[10]); 
 int XBase = atoi(argv[11]); 
 int YBase = atoi(argv[12]); 
 NbJobs = atoi(argv[13]); 
 SizeOfJob = atoi(argv[14]); 
 
 bool open = true; 
 
 ResNumbers = new int* [NbVisits]; 
 for (int i = 0; i<NbVisits; i++) { 
  ResNumbers[i] = new int [NbResources]; 
 } 
 for (i = 0; i<NbVisits; i++) { 
  for (int j = 0; j<NbResources; j++) { 
   ResNumbers[i][j] = 0; 
  } 
 } 
 
 DataArr = new int * [NbVisits+1]; 
 DistMatr = new int * [NbVisits+1]; 
 for (i = 0; i<NbVisits+1; i++) { 
  DataArr[i] = new int [5]; 
  DistMatr[i] = new int [NbVisits+1]; 
 } 
 
 for (i = 0; i<NbVisits+1; i++) { 
  for (int j = 0; j<6; j++) { 
   DataArr[i][j] = 0; 
  } 
  for (j = 0; j<NbVisits+1; j++) { 
   if (j==3) DataArr[i][j] = 1; //demands; 
   DistMatr[i][j] = 0; 
  } 
 } 
 
 char buffer1[230], buffer2[230], buffer3[230], buffer4[230], buffer5[230], buffer6[230]; 
 sprintf(buffer1, dataFile); 
 
 // PATHS TO DATA FILES CONTAINING COORDINATES OF LOCATIONS 
  
 sprintf(buffer2, "%s", "g:/local/Source/Reformul/Generator/data/b5k.txt"); 
 sprintf(buffer3, "%s", "g:/local/Source/Reformul/Generator/data/b7k.txt"); 
 sprintf(buffer4, "%s", "g:/local/Source/Reformul/Generator/data/g5k.txt"); 
 sprintf(buffer5, "%s", "g:/local/Source/Reformul/Generator/data/g7k.txt"); 
 sprintf(buffer6, "%s", "g:/local/Source/Reformul/Generator/data/ub.txt"); 
 
 //creating visits; 
 
 //picking coords randomly  from data file without replacement 
    //locations need not be unique 
  
 unsigned int CoordsSeed = rand(); 
 unsigned int TWSeed = rand(); 
 unsigned int SpecSeed = rand(); 
 unsigned int PairsSeed = rand(); 
  
 char** postcode1; 
 char** postcode2; 
 
 postcode1 = new char* [NbVisits]; 
 postcode2 = new char* [NbVisits]; 
 for (i=0;i<NbVisits;i++) { 
  postcode1[i] = new char[28]; 
  postcode2[i] = new char[28]; 
 } 
  
 bool insoluble = true; 
 int insolCount = 0; 
 char rubbish[28];//, postcode1[28], postcode2[28]; 
 
 bool noResourceAlternatives = false; 
 double mult; 
 if (Spec==1) mult = 1; 
 if (Spec==2) mult = 0.8; 
 if (Spec==3) mult = 0.6; 
 if (Spec==4) mult = 0.4; 
 if (Spec==5) { 
  mult = 0.2; 
  noResourceAlternatives = true; 
 } 
 int maxNumberOfResources = myRound(mult*NbResources); 
 
 ///////////////////////////////////////////////////////////////////// 
 // 
 // Generating soluble instances:  
 // pure VRPs and mixed problems moving from VRPs towards JSPs 
 // 
 ///////////////////////////////////////////////////////////////////// 
 
 while (insoluble && insolCount==0 && VRPFlag) { 
   
  Capacities = new int [NbResources]; 
  for (i=0; i<NbResources; i++) { 
   Capacities[i] = NbVisits; 
   //capacity is measured in the number of visits a vehicle can perform; 
   //all vehicles have the same capacity; 
  } 
 
  //cords of the depot 
  DataArr[0][0] = XBase;//for g5k, g7k 25950;  
  DataArr[0][1] = YBase;//for g5k, g7k 66550; 
  DataArr[0][2] = 0; 
  DataArr[0][3] = 0; 
  DataArr[0][4] = StartOfDay; 
  DataArr[0][5] = EndOfDay; 
   
  cout<<"CoordsSeed = "<<CoordsSeed<<endl; 
  cout<<"TWSeed = "<<TWSeed<<endl; 
  cout<<"SpecSeed = "<<SpecSeed<<endl; 
  cout<<"PairsSeed = "<<PairsSeed<<endl; 
 
  fout.open(argv[3], ios::out);  
  fout<<"# instance:       "<<resultsFile<<endl; 
  fout<<"# data file:      "<<dataFile<<endl; 
  fout<<"# generator seed: "<<seed<<endl; 
  fout<<"# Rho:            "<<Rho<<endl; 
  fout<<"# Slack:          "<<Slack<<endl; 
  fout<<TypeOfProblem<<endl; 
 
  int randIndex; 
 
  int ctrGlob = 1; 
 
  ctr = 1; 
 
  srand(CoordsSeed); 
  Node *loc_head_ptr, *loc_curr_ptr, *loc_prev_ptr, *loc_tail_ptr; 
  loc_head_ptr = NULL; 
 
  while (ctr<=NbVisits) { 
   //CAREFUL! The numbers 170,298, 224, etc. show how many 
   //lines there are in the data file test.dat.
    
 
   if (!strcmp(buffer1,buffer2)) { 
    randIndex = (170-ctr)*rand()/(RAND_MAX+1); 
   } else { 
    if (!strcmp(buffer1,buffer3)) { 
     randIndex = (298-ctr)*rand()/(RAND_MAX+1); 
    } else { 
     if (!strcmp(buffer1,buffer4)) { 
      randIndex = (224-ctr)*rand()/(RAND_MAX+1); 
     } else { 
      if (!strcmp(buffer1,buffer5)) { 
       randIndex = (348-ctr)*rand()/(RAND_MAX+1); 
      } else { 
       if (!strcmp(buffer1,buffer6)) { 
        randIndex = (1000-ctr)*rand()/(RAND_MAX+1); 
       } else cout<<"Check processing data files!"<<endl; 
      } 
     } 
    } 
   } 
 
//   cout<<"randIndex = "<<randIndex<<endl; 
 
   int ctr_ = 0; 
   if (!open) { 
    fin.open(dataFile); 
    open = true; 
   } 
   while (ctr_<randIndex-1) { // very careful!!! reading in the lines of the data file 
    fin>>rubbish>>rubbish>>rubbish>>rubbish>>rubbish; 
    ctr_++; 
   } 
   fin>>rubbish>>postcode1[ctr-1]>>postcode2[ctr-1]>>DataArr[ctr][0]>>DataArr[ctr][1]; 
   if (open) { 
    fin.close(); 
    open = false; 
   } 
   ctr++; 
  } 
 
  srand(PairsSeed); 
  createJobs(NbVisits,NbJobs,SizeOfJob,fout); 
  assignTimeWindowsToChains(ActDuration,Slack,NbJobs,SizeOfJob,fout); 
 
  ctr = 1; 
  srand(SpecSeed); 
 
  while (ctr<=NbVisits) { 
 
   //randomly assign alternative resources  
   //respecting specialisation constraint 
 
 
   CreateLinkedList(NbResources,loc_head_ptr); 
 
   for (int i=0;i<maxNumberOfResources;i++) { 
    int randIndex = (NbResources-i)*rand()/(RAND_MAX+1); 
//    cout<<randIndex<<" "<<NbResources<<endl; 
    loc_curr_ptr = list_locate(loc_head_ptr,randIndex); 
//    cout<<loc_curr_ptr->data<<endl; 
    loc_tail_ptr = list_tail_search(loc_head_ptr); 
//    cout<<loc_tail_ptr->data<<endl; 
    ResNumbers[ctr-1][i] = loc_curr_ptr->data; 
//    cout<<"ResNumbers["<<ctr-1<<"]["<<i<<"] = "<<ResNumbers[ctr-1][i]<<endl; 
    int dataSaved = loc_curr_ptr->data; 
    loc_curr_ptr->data = loc_tail_ptr->data; 
    loc_tail_ptr->data = dataSaved; 
    if (loc_tail_ptr!=loc_head_ptr) { 
     loc_prev_ptr = list_prev_locate(loc_head_ptr,loc_tail_ptr->data); 
     list_node_remove(loc_prev_ptr); 
    } else { 
     list_head_remove(loc_head_ptr); 
    } 
   } 
   list_clear(loc_head_ptr); 
   ctr++; 
  } 
 
  ctr=1; 
 
  while (ctr<=NbVisits) { 
   DataArr[ctr][2] = (int) ActDuration; 
   ctr++; 
  } 
 
  ctr = 1; 
  srand(TWSeed); 
 
  while (ctr<=NbVisits) { 
 
   bool isInChain = false; 
   for (int jjj=0;jjj<NbJobs;jjj++) { 
    if (isInChain) break; 
    for (int kkk=0;kkk<SizeOfJob;kkk++) { 
     if (ctr==storeArray[jjj][kkk]) { 
      isInChain = true; 
      break; 
     } 
    } 
   } 
 
   if (!isInChain) { 
    ESFactorMorning = getESRange(Slack,ActDuration,1); 
    DataArr[ctr][4] = (int) ESMinMorning + ESFactorMorning*rand()/(RAND_MAX+1); 
    DataArr[ctr][5] = (int) ((ActDuration + DataArr[ctr][4]*(1 - Slack))/(1 - Slack)); 
   } 
   ctr++; 
  } 
 
  //check for slacks and EndOfDay 
  for (ctr = 1;ctr <= NbVisits; ctr++) { 
   if (DataArr[ctr][5]>EndOfDay) { 
    cout<<"LatestEnd = "<<DataArr[ctr][5]<<" of visit " 
     <<ctr<<" exceeds EndOfDay = "<<EndOfDay<<endl; 
   } 
  } 
 
  //computing the distance matrix, Manhattan distance 
  for (i=0;i<NbVisits+1;i++) { 
   for (int j=0;j<NbVisits+1;j++) { 
    DistMatr[i][j] = (abs(DataArr[i][0] - DataArr[j][0]) + abs(DataArr[i][1] - DataArr[j][1])); 
 //   DistMatr[i][j] =  computeEucledianDistance(DataArr[i][0],DataArr[i][1],DataArr[j][0],DataArr[j][1]); 
   } 
  } 
  double averDist = 0; 
  for (i=0;i<NbVisits+1;i++) { 
   for (int j=0;j<NbVisits+1;j++) { 
    averDist += DistMatr[i][j]; 
   } 
  } 
 
  averDist = 2 * averDist/((NbVisits+1)*NbVisits); 
  cout<<"averDist = "<<averDist<<endl; 
  Speed = Rho * averDist / ActDuration; 
  cout<<"Speed = "<<Speed<<endl; 
   
  fout<<NbResources<<" "<<NbVisits<<endl; 
  fout<<Speed<<endl; 
  fout<<DataArr[0][4]<<" "<<DataArr[0][5]<<endl; 
  fout<<DataArr[0][0]<<" "<<DataArr[0][1]<<endl; 
 
  for (i=0;i<NbVisits;i++) { 
   fout<<i+1<<" "<<DataArr[i+1][2]<<" " 
    <<DataArr[i+1][3]<<" " 
    <<postcode1[i]<<" " 
    <<postcode2[i]<<" " 
    <<DataArr[i+1][4]<<" " 
    <<DataArr[i+1][5]<<" " 
    <<DataArr[i+1][0]<<" " 
    <<DataArr[i+1][1]<<" "; 
   for (int j=0;j<NbResources;j++) { 
    if (ResNumbers[i][j]>0) { 
     fout<<ResNumbers[i][j]<<" "; 
    } 
   } 
   fout<<" -1\n"; 
  } 
 
//  for (i=0;i<NbVisits;i++) { 
//   delete [] postcode1[i]; 
//   delete [] postcode2[i]; 
//  } 
//  delete [] postcode1; 
//  delete [] postcode2; 
 
 
//  for (i = 0; i<NbVisits; i++) { 
//   delete [] ResNumbers[i]; 
//  } 
//  delete [] ResNumbers; 
 
  for (i=0;i<NbVisits+1;i++) { 
   for (int j=0;j<NbVisits+1;j++) { 
    fout<<DistMatr[i][j]<<" "; 
   } 
   fout<<endl; 
  } 
 
  //Resources Section 
 
  ctr = 0; 
  while (ctr<NbResources) { 
   fout<<ctr+1<<" "<<Capacities[ctr]<<endl; 
   ctr++; 
  } 
 
//  delete [] Capacities; 
 
  //Side Constraints Section 
   
  fout<<"Diff\t0"<<endl; 
  fout<<"Same\t0"<<endl; 
  fout<<"Precedence\t"<<NbJobs*(SizeOfJob-1)<<endl; 
  for (i=0;i<NbJobs;i++) { 
   int j = 0; 
   while (j+1<SizeOfJob) { 
    fout<<storeArray[i][j]<<" "<<storeArray[i][j+1]<<endl; 
    j++; 
   } 
  } 
 
  return 0; 
  //solubility testing by Scheduler; 
/* 
  bool Sched = true; 
 
  int val = CheckSolubility(Sched,resultsFile,NbVisits); 
 
  if (val==-1) { 
   cout<<"Instance with "<<NbVisits<<" insoluble"<<endl; 
   PairsSeed = rand(); 
   cout<<endl; 
   cout<<"insolCount = "<<insolCount<<endl; 
   insolCount++; 
   fout.close();  
  } else { 
   insoluble = false; 
   return 0; 
  } 
*/ 
 } 
 
 ///////////////////////////////////////////////////////////////////// 
 // 
 // Generating soluble instances:  
 // pure JSPs and mixed problems moving from JSPs towards VRPs 
 // 
 ///////////////////////////////////////////////////////////////////// 
 
 int nbJobsCur = (int) sqrt (NbVisits); 
 int sizeOfJobCur = (int) sqrt (NbVisits); 
 
 bool noTransitions = true; 
 
 while (insoluble && insolCount==0 && !VRPFlag) { 
 
  Capacities = new int [NbResources]; 
  for (i=0; i<NbResources; i++) { 
   Capacities[i] = NbVisits; 
   //capacity is measured in the number of visits a vehicle can perform; 
   //all vehicles have the same capacity; 
  } 
 
  //cords of the depot 
  if (noTransitions) { 
   DataArr[0][0] = 0;//for g5k, g7k 25950;  
   DataArr[0][1] = 0;//for g5k, g7k 66550; 
  } else { 
   DataArr[0][0] = XBase;//for g5k, g7k 25950;  
   DataArr[0][1] = YBase;//for g5k, g7k 66550; 
  } 
  DataArr[0][2] = 0; 
  DataArr[0][3] = 0; 
  DataArr[0][4] = StartOfDay; 
  DataArr[0][5] = EndOfDay; 
 
  cout<<"CoordsSeed = "<<CoordsSeed<<endl; 
  cout<<"TWSeed = "<<TWSeed<<endl; 
  cout<<"SpecSeed = "<<SpecSeed<<endl; 
  cout<<"PairsSeed = "<<PairsSeed<<endl; 
   
  fout.open(argv[3], ios::out);  
  fout<<"# instance:       "<<resultsFile<<endl; 
  fout<<"# data file:      "<<dataFile<<endl; 
  fout<<"# generator seed: "<<seed<<endl; 
  fout<<"# Rho:            infinity"<<endl; 
  fout<<"# Slack:          "<<Slack<<endl; 
  fout<<TypeOfProblem<<endl; 
 
  int randIndex = 0; 
   
  int ctrGlob = 1; 
 
  ctr = 1; 
 
  srand(CoordsSeed); 
  Node *loc_head_ptr, *loc_curr_ptr, *loc_prev_ptr, *loc_tail_ptr; 
  loc_head_ptr = NULL; 
 
  postcode1[0] = "IGNORE"; 
  postcode2[0] = "IGNORE"; 
 
  while (ctr<=NbVisits) { 
 
   if (!noTransitions) { 
    if (!strcmp(buffer1,buffer2)) { 
     randIndex = (170-ctr)*rand()/(RAND_MAX+1); 
    } else { 
     if (!strcmp(buffer1,buffer3)) { 
      randIndex = (298-ctr)*rand()/(RAND_MAX+1); 
     } else { 
      if (!strcmp(buffer1,buffer4)) { 
       randIndex = (224-ctr)*rand()/(RAND_MAX+1); 
      } else { 
       if (!strcmp(buffer1,buffer5)) { 
        randIndex = (348-ctr)*rand()/(RAND_MAX+1); 
       } else { 
        if (!strcmp(buffer1,buffer6)) { 
         randIndex = (1000-ctr)*rand()/(RAND_MAX+1); 
        } else cout<<"Check processing data files!"<<endl; 
       } 
      } 
     } 
    } 
 
    int ctr_ = 0; 
    if (!open) { 
     fin.open(dataFile); 
     open = true; 
    } 
    while (ctr_<randIndex-1) { // very careful!!! reading in the lines of the data file 
     fin>>rubbish>>rubbish>>rubbish>>rubbish>>rubbish; 
     ctr_++; 
    } 
    fin>>rubbish>>rubbish>>rubbish>>DataArr[ctr][0]>>DataArr[ctr][1]; 
    if (open) { 
     fin.close(); 
     open = false; 
    } 
 
   } else {//i.e., if noTransitions 
    DataArr[ctr][0] = DataArr[0][0]; 
    DataArr[ctr][1] = DataArr[0][1]; 
   } 
    postcode1[ctr] = postcode1[0]; 
    postcode2[ctr] = postcode2[0]; 
 
   ctr++; 
  } 
 
  srand(PairsSeed); 
 
  ctr = 1; 
  srand(SpecSeed); 
  srand(PairsSeed); 
 
  createJobs(NbVisits,nbJobsCur,sizeOfJobCur,fout); 
 
  int* resCtr; 
  resCtr = new int[NbResources]; 
  for (i=0;i<NbResources;i++) { 
   resCtr[i] = 0; 
  } 
 
  bool* isOperationInPrecConstraints; 
  isOperationInPrecConstraints = new bool [NbVisits]; 
  for (i=0;i<NbVisits;i++) { 
   isOperationInPrecConstraints[i] = false; 
  } 
 
  for (i=0;i<NbVisits;i++) { 
   for (int jjj=0;jjj<nbJobsCur;jjj++) { 
    for (int kkk=0;kkk<sizeOfJobCur;kkk++) { 
     if (i+1==storeArray[jjj][kkk]) { 
      isOperationInPrecConstraints[i] = true; 
     } 
    } 
   } 
  } 
 
  if (noResourceAlternatives) { 
   for (int i=0;i<nbJobsCur;i++) { 
    CreateLinkedList(NbResources,loc_head_ptr); 
    for (int j=0;j<sizeOfJobCur;j++) { 
      int index = storeArray[i][j]; 
      int randIndex = (NbResources - j)*rand()/(RAND_MAX+1); 
      loc_curr_ptr = list_locate(loc_head_ptr,randIndex); 
   //    cout<<loc_curr_ptr->data<<endl; 
      loc_tail_ptr = list_tail_search(loc_head_ptr); 
   //    cout<<loc_tail_ptr->data<<endl; 
      ResNumbers[index-1][0] = loc_curr_ptr->data; 
      int dataSaved = loc_curr_ptr->data; 
      loc_curr_ptr->data = loc_tail_ptr->data; 
      loc_tail_ptr->data = dataSaved; 
      if (loc_tail_ptr!=loc_head_ptr) { 
       loc_prev_ptr = list_prev_locate(loc_head_ptr,loc_tail_ptr->data); 
       list_node_remove(loc_prev_ptr); 
      } else { 
       list_head_remove(loc_head_ptr); 
      } 
     } 
     list_clear(loc_head_ptr); 
   } 
  } else { 
   cout<<"maxNumberOfResources = "<<maxNumberOfResources<<endl; 
 
   Node** loc_head_ptr_arr; 
 
   loc_head_ptr_arr = new Node* [nbJobsCur*sizeOfJobCur]; 
   for (i=0; i<nbJobsCur*sizeOfJobCur; i++) { 
    loc_head_ptr_arr[i] = NULL; 
   } 
 
   for (int i=0;i<nbJobsCur;i++) { 
     for (int j=0;j<sizeOfJobCur;j++) { 
      int curr_ind = i*sizeOfJobCur+j; 
      CreateLinkedList(NbResources,loc_head_ptr_arr[curr_ind]); 
      for (int k=0;k<maxNumberOfResources;k++) { 
  //      fout<<endl; 
  //      fout<<"i = "<<i<<" j = "<<j<<" k = "<<k<<endl; 
  //      print_list(loc_head_ptr_arr[curr_ind],fout); 
       int index = storeArray[i][j]; 
  //      fout<<"index = "<<index<<endl; 
       int randIndex = (NbResources - k)*rand()/(RAND_MAX+1); 
  //      fout<<"randIndex = "<<randIndex<<endl; 
       loc_curr_ptr = list_locate(loc_head_ptr_arr[curr_ind],randIndex); 
  //      fout<<"loc_curr_ptr->data: "<<loc_curr_ptr->data<<endl; 
       loc_tail_ptr = list_tail_search(loc_head_ptr_arr[curr_ind]); 
  //      fout<<"loc_tail_ptr->data:   "<<loc_tail_ptr->data<<endl; 
       ResNumbers[index-1][k] = loc_curr_ptr->data; 
       int dataSaved = loc_curr_ptr->data; 
       loc_curr_ptr->data = loc_tail_ptr->data; 
       loc_tail_ptr->data = dataSaved; 
  //      fout<<"***"<<endl; 
 
       if (loc_tail_ptr!=loc_head_ptr_arr[curr_ind]) { 
        loc_prev_ptr = list_prev_locate(loc_head_ptr_arr[curr_ind],loc_tail_ptr->data); 
        list_node_remove(loc_prev_ptr); 
       } else { 
        list_head_remove(loc_head_ptr_arr[curr_ind]); 
       } 
      } 
      list_clear(loc_head_ptr_arr[curr_ind]); 
     } 
   } 
  } 
  ctr=1; 
  while (ctr<=NbVisits) { 
   DataArr[ctr][2] = (int) ActDuration; 
   ctr++; 
  } 
 
  ctr = 1; 
  srand(TWSeed); 
 
  while (ctr<=NbVisits) { 
   DataArr[ctr][4] = StartOfDay; 
   DataArr[ctr][5] = (int)((ActDuration + DataArr[ctr][4]*(1-Slack))/(1-Slack)); 
   ctr++; 
  } 
 
  //check for slacks and EndOfDay 
  for (ctr = 1;ctr <= NbVisits; ctr++) { 
   if (DataArr[ctr][5]>EndOfDay) { 
    cout<<"LatestEnd = "<<DataArr[ctr][5]<<" of visit " 
     <<ctr<<" exceeds EndOfDay = "<<EndOfDay<<endl; 
   } 
  } 
 
  //computing the distance matrix, Manhattan distance 
  for (i=0;i<NbVisits+1;i++) { 
   for (int j=0;j<NbVisits+1;j++) { 
    DistMatr[i][j] = (abs(DataArr[i][0] - DataArr[j][0]) + abs(DataArr[i][1] - DataArr[j][1])); 
   } 
  } 
 
  double averDist = 0; 
  for (i=0;i<NbVisits+1;i++) { 
   for (int j=0;j<NbVisits+1;j++) { 
    averDist += DistMatr[i][j]; 
   } 
  } 
 
  averDist = 2 * averDist/((NbVisits+1)*NbVisits); 
  cout<<"averDist = "<<averDist<<endl; 
  Speed = Rho * averDist / ActDuration; 
  cout<<"Speed = "<<Speed<<endl; 
   
  fout<<NbResources<<" "<<NbVisits<<endl; 
  fout<<Speed<<endl; 
  fout<<DataArr[0][4]<<" "<<DataArr[0][5]<<endl; 
  fout<<DataArr[0][0]<<" "<<DataArr[0][1]<<endl; 
 
  for (i=0;i<NbVisits;i++) { 
   fout<<i+1<<" "<<DataArr[i+1][2]<<" " 
    <<DataArr[i+1][3]<<" " 
    <<postcode1[i]<<" " 
    <<postcode2[i]<<" " 
    <<DataArr[i+1][4]<<" " 
    <<DataArr[i+1][5]<<" " 
    <<DataArr[i+1][0]<<" " 
    <<DataArr[i+1][1]<<" "; 
   for (int j=0;j<NbResources;j++) { 
    if (ResNumbers[i][j]>0) { 
     fout<<ResNumbers[i][j]<<" "; 
    } 
   } 
   fout<<" -1\n"; 
  } 
 
  for (i=0;i<NbVisits+1;i++) { 
   for (int j=0;j<NbVisits+1;j++) { 
    fout<<DistMatr[i][j]<<" "; 
   } 
   fout<<endl; 
  } 
 
  //Resources Section 
 
  ctr = 0; 
  while (ctr<NbResources) { 
   fout<<ctr+1<<" "<<Capacities[ctr]<<endl; 
   ctr++; 
  } 
 
//  delete [] Capacities; 
 
  //Side Constraints Section 
   
  fout<<"Diff\t0"<<endl; 
  fout<<"Same\t0"<<endl; 
  fout<<"Precedence\t"<<NbJobs*(SizeOfJob-1)<<endl; 
 
  for (i=0;i<NbJobs;i++) { 
   int j = 0; 
   while (j+1<SizeOfJob) { 
    fout<<storeArray[i][j]<<" "<<storeArray[i][j+1]<<endl; 
    j++; 
   } 
  } 
 
  //solubility testing by Scheduler; 
 
//  return 0; 
/* 
  bool Sched = true; 
 
  int val = CheckSolubility(Sched,resultsFile,NbVisits); 
 
  if (val==-1) { 
   cout<<"Instance with "<<NbVisits<<" insoluble"<<endl; 
   PairsSeed = rand(); 
   cout<<endl; 
   cout<<"insolCount = "<<insolCount<<endl; 
   insolCount++; 
   fout.close();  
  } else { 
   insoluble = false; 
   return 0; 
  } 
*/ 
 } 
 
 for (i = 0; i<NbVisits+1; i++) { 
  delete [] DistMatr[i]; 
 } 
 delete [] DistMatr; 
 return -1; 
}