/*

  24 Jan 2002

  TSP graph Transformations due to Chris Beck (transform1) and Patrick Prosser (transform2).
  After writing footnotes 698,699 and checking
  the validity of the transformation for more than 1 route.

  Fixed a small but harmful bug to do with capacity constraint encoding
  Checked Chris' transformation.

  Checking Patrick's transformation.
  Lex, maxmin, minmin - checked;

  NOT CHECKED: TIME WINDOWS AFTER PATRICK'S TRANSFORMATION!!!

*/

#include <ilsched/iloscheduler.h> 
#include <conio.h> 
#include <string.h> 
#include <time.h> 
#include <dos.h> 

ILOSTLBEGIN 

IloInt Capacity; 
IloInt SetupActivityDuration; 
IloInt TeardownActivityDuration; 
IloInt NbMachines; 
IloInt MinTransition;
IloInt SummedDurationSaved = 0;
IloInt SummedDuration = 0;
IloInt NbCustomers; 
IloInt BasicTimeLimit;  
IloInt TrueCost;

char Problem[128];
//in seconds, overall amount of time spent on search 
IloInt NbFailsSummed; 
IloInt NbChoicePointsSummed; 
IloBool TransformFlag, TransformIndex;
IloInt LastNbOfMachinesUsed = 0; 
IloInt DiscrepancyCount; 
 
IloInt  ResourceSelector, 
        ResourceConstraintSelector, 
		PossibleResourceSelector, 
		ActivitySelector; 
 
IloInt NbActPerTour;  
//the maximum number of activities per tour (setup + all the customers + teardown) 
IloInt NbAct;         
//the overall number of activities (group 1 and group 2 ones) 
 
IloNum VrpData [400*7];

IloNum* VrpDataSaved;
IloInt** TransMatrSaved;  


/* 
inline IloInt computeDistance(IloInt i, IloInt j) { 
	return (IloInt) IloFloor(0.5 + IloPower((VrpData[i*7+1]-VrpData[j*7+1])* 
		                    (VrpData[i*7+1]-VrpData[j*7+1])+ 
							(VrpData[i*7+2]-VrpData[j*7+2])* 
				            (VrpData[i*7+2]-VrpData[j*7+2]), 0.5)); 
} 
*/

inline IloInt computeDistance(IloInt i, IloInt j) { 
	return (IloInt) IloPower((VrpData[i*7+1]-VrpData[j*7+1])* 
		                 (VrpData[i*7+1]-VrpData[j*7+1])+ 
		                 (VrpData[i*7+2]-VrpData[j*7+2])* 
				 (VrpData[i*7+2]-VrpData[j*7+2]), 0.5); 
} 


inline IloNum getDemand (IloInt i) { 
	return VrpData[i*7+3]; 
} 
 
inline IloNum getEarliestStartTime (IloInt i) { 
	return VrpData[i*7+4]; 
} 
 
inline IloNum getLatestStartTime (IloInt i) { 
	return VrpData[i*7+5]; 
} 
 
inline IloNum getActivityDuration (IloInt i) { 
	return VrpData[i*7+6]; 
} 

IloInt MakeTransformation(IloTransitionParam& ttParam,
						  IloInt order,
						  ofstream& fout) {
//	cout<<"by Patrick"<<endl;
	IloInt i,j;
	if (order==2) {
		//Process all activities in lexicographic order (i.e., as they are)
		IloInt min_transition_index = 0;
		for (i = 0; i < NbActPerTour; i++) { 
//			fout<<"i = "<<i<<endl;
			IloInt min_transition = 1e6;
			for (j = 0; j < NbActPerTour; j++) {
				if (i==0&&j==NbActPerTour-1) continue;
				if (i==j) continue;
				if (i==NbActPerTour-1&&j==0) continue;
				if (ttParam.getValue(i,j)<min_transition) {
					min_transition = ttParam.getValue(i,j);
					min_transition_index = j;
				}
			}	
		

//			fout<<"min_transition = "<<min_transition<<" j = "<<min_transition_index<<endl;

			//increase by min_transition the duration of activity whose
			//index is criticalActivytIndex

			if (i==0 || i==NbActPerTour-1) {
				VrpData[i*7+6] += min_transition;
			}
			else {
				VrpData[i*7+6] += 2*min_transition;
			}
			
			//update other transitions

			for (j = 0; j < NbActPerTour; j++) {
				if (i==0&&j==NbActPerTour-1) continue;
				if (i==j) continue;
				if (i==NbActPerTour-1&&j==0) continue;
				ttParam.setValue(i,j,ttParam.getValue(i,j)-min_transition);
				ttParam.setValue(j,i,ttParam.getValue(j,i)-min_transition);
			}	
/*
			fout<<endl;
			fout<<"TRANSFORMED VrpData"<<endl;
			fout<<endl;
			IloInt count = 0;
			for (int ii=0;ii<NbActPerTour*7;ii++) {
				fout<<VrpData[ii]<<"\t";
				count++;
				if (count==7) {
					count=0;
					fout<<endl;
				}
			}
			fout<<endl;
			fout<<"TRANSFORMED TRANSITION TABLE"<<endl;
			fout<<endl;
			for (ii = 0; ii < NbActPerTour; ii++) {
				for (j = 0; j < NbActPerTour; j++) {
					fout<<ttParam.getValue(ii,j)<<"\t";
				}
				fout<<endl;
			}	
			fout<<endl;
*/
		}
	}
	if (order==3) {
		//Process activities in max min order
		IloInt ctr = 0;
		while (true) {
			ctr++;
//			fout<<endl;
//			fout<<"ctr = "<<ctr<<endl;
//			fout<<endl;
			IloInt max_min_transition = 0;
			IloInt min_transition_index = 0;
			IloInt min_transition;
			for (i = 0; i < NbActPerTour; i++) { 
//				fout<<"i = "<<i<<endl;
				min_transition = 1e6;
				for (j = 0; j < NbActPerTour; j++) {
					if (i==0&&j==NbActPerTour-1) continue;
					if (i==j) continue;
					if (i==NbActPerTour-1&&j==0) continue;
					if (ttParam.getValue(i,j)<min_transition) {
						min_transition = ttParam.getValue(i,j);
					}
				}	
				if (max_min_transition<min_transition) {
					max_min_transition = min_transition;
					min_transition_index = i;
				}
//				fout<<"max_min_transition   = "<<max_min_transition<<endl;
//				fout<<"min_transition_index = "<<min_transition_index<<endl;
			}

			if (max_min_transition==0) {
//				fout<<"breaking"<<endl;
				break;
			}

			if (min_transition_index==0 || min_transition_index==NbActPerTour-1) {
				VrpData[min_transition_index*7+6] += max_min_transition;
			}
			else {
				VrpData[min_transition_index*7+6] += 2*max_min_transition;
			}
			
			//update other transitions

			for (j = 0; j < NbActPerTour; j++) {
				if (min_transition_index==0&&j==NbActPerTour-1) continue;
				if (min_transition_index==j) continue;
				if (min_transition_index==NbActPerTour-1&&j==0) continue;
				ttParam.setValue(min_transition_index,j,
					             ttParam.getValue(min_transition_index,j)-max_min_transition);
				ttParam.setValue(j,min_transition_index,
					             ttParam.getValue(j,min_transition_index)-max_min_transition);
			}	
/*
			fout<<endl;
			fout<<"TRANSFORMED VrpData"<<endl;
			fout<<endl;
			IloInt count = 0;
			for (int ii=0;ii<NbActPerTour*7;ii++) {
				fout<<VrpData[ii]<<"\t";
				count++;
				if (count==7) {
					count=0;
					fout<<endl;
				}
			}
			fout<<endl;
			fout<<"TRANSFORMED TRANSITION TABLE"<<endl;
			fout<<endl;
			for (ii = 0; ii < NbActPerTour; ii++) {
				for (j = 0; j < NbActPerTour; j++) {
					fout<<ttParam.getValue(ii,j)<<"\t";
				}
				fout<<endl;
			}	
			fout<<endl;
*/
		}
	}
	if (order==4) {
		//Process activities in min min order
		IloInt ctr = 0;
		IloBool * ProcessedRow;
		ProcessedRow  = new IloBool [NbActPerTour];
		for (i=0;i<NbActPerTour;i++) {
			ProcessedRow[i] = IloFalse;
		}
		while (true) {

			ctr++;
//			fout<<endl;
//			fout<<"ctr = "<<ctr<<endl;
//			fout<<endl;
			IloInt min_min_transition = 1e6;
			IloInt min_transition_index = 0;
			IloInt min_transition;

			for (i = 0; i < NbActPerTour; i++) { 
				min_transition = 1e6;
			    if (ProcessedRow[i]) continue;
				for (j = 0; j < NbActPerTour; j++) {
					if (i==0&&j==NbActPerTour-1) continue;
					if (i==j) continue;
					if (i==NbActPerTour-1&&j==0) continue;
					if (ttParam.getValue(i,j)<min_transition) {
						min_transition = ttParam.getValue(i,j);
					}
				}	
				if (min_transition==0) {
					ProcessedRow[i] = IloTrue;
					continue;
				}
				if (min_min_transition>min_transition) {
					min_min_transition = min_transition;
					min_transition_index = i;
				}
//				fout<<"min_min_transition   = "<<min_min_transition<<endl;
//				fout<<"min_transition_index = "<<min_transition_index<<endl;
			}

			ProcessedRow[min_transition_index] = IloTrue;

			if (min_min_transition==1e6) break;

			if (min_transition_index==0 || min_transition_index==NbActPerTour-1) {
				VrpData[min_transition_index*7+6] += min_min_transition;
			}
			else {
				VrpData[min_transition_index*7+6] += 2*min_min_transition;
			}
			
			//update other transitions

			for (j = 0; j < NbActPerTour; j++) {
				if (min_transition_index==0&&j==NbActPerTour-1) continue;
				if (min_transition_index==j) continue;
				if (min_transition_index==NbActPerTour-1&&j==0) continue;
				ttParam.setValue(min_transition_index,j,
					             ttParam.getValue(min_transition_index,j)-min_min_transition);
				ttParam.setValue(j,min_transition_index,
					             ttParam.getValue(j,min_transition_index)-min_min_transition);
			}	
	
/*			fout<<endl;
			fout<<"TRANSFORMED VrpData"<<endl;
			fout<<endl;
			IloInt count = 0;
			for (int ii=0;ii<NbActPerTour*7;ii++) {
				fout<<VrpData[ii]<<"\t";
				count++;
				if (count==7) {
					count=0;
					fout<<endl;
				}
			}

			fout<<endl;
			fout<<"TRANSFORMED TRANSITION TABLE"<<endl;
			fout<<endl;
			for (ii = 0; ii < NbActPerTour; ii++) {
				for (j = 0; j < NbActPerTour; j++) {
					fout<<ttParam.getValue(ii,j)<<"\t";
				}
				fout<<endl;
			}	
			fout<<endl;
*/
		}
	}
	fout<<endl;
	fout<<"TRANSFORMED VrpData"<<endl;
	fout<<endl;
	IloInt count = 0;
	for (int ii=0;ii<NbActPerTour*7;ii++) {
		fout<<VrpData[ii]<<"\t";
		count++;
		if (count==7) {
			count=0;
			fout<<endl;
		}
	}
	fout<<endl;
	fout<<"TRANSFORMED TRANSITION TABLE"<<endl;
	fout<<endl;
	for (ii = 0; ii < NbActPerTour; ii++) {
		for (j = 0; j < NbActPerTour; j++) {
			fout<<ttParam.getValue(ii,j)<<"\t";
		}
		fout<<endl;
	}	
	fout<<endl;

	SummedDuration = 0;
	count = 0;
	for (ii=0;ii<NbActPerTour*7;ii++) {
		if (count==6) {
			SummedDuration += VrpData[ii];
			count=-1;
		}
		count++;
	}

	return 0;
}


IloInt MakeTransformation(IloTransitionParam& ttParam,
						  ofstream& fout) {

//	cout<<"by Chris"<<endl;
   
	//1st stage;
	for (int i=0;i<NbActPerTour;i++) {
		IloInt min_transition = 1e6;
		for (int j=0;j<NbActPerTour;j++) {
			if (i==j) continue;
			if (i==0&&j==NbActPerTour-1) continue;
			if (i==NbActPerTour-1&&j==0) continue;
			if (ttParam.getValue(i,j)<min_transition) {
				min_transition = ttParam.getValue(i,j);
//				fout<<"i = "<<i<<" j = "<<j<<" min_transition = "<<min_transition<<endl;
			}
		}
		VrpData[i*7+6] += 2*min_transition;
	}
	IloInt count = 0, ii;
	
/*	fout<<endl;
	fout<<"TRANSFORMED VrpData"<<endl;
	fout<<endl;
	count = 0;
	for (int =0;ii<NbActPerTour*7;ii++) {
		fout<<VrpData[ii]<<"\t";
		count++;
		if (count==7) {
			count=0;
			fout<<endl;
		}
	}
	fout<<endl;
	fout<<"TRANSFORMED TRANSITION TABLE"<<endl;
	fout<<endl;
	for (ii = 0; ii < NbActPerTour; ii++) {
		for (int j = 0; j < NbActPerTour; j++) {
			fout<<ttParam.getValue(ii,j)<<"\t";
		}
		fout<<endl;
	}	
	fout<<endl;
*/
	//2nd stage
//	fout<<"second stage"<<endl;
	for (i=0;i<NbActPerTour;i++) {
		for (int j=0;j<NbActPerTour;j++) {
			if (i==j) continue;
			if (i==0&&j==NbActPerTour-1) continue;
			if (i==NbActPerTour-1&&j==0) continue;
//			fout<<"i = "<<i<<" j = "<<j<<" "<<ttParam.getValue(i,j)<<" - "<<(VrpData[i*7+6]-VrpDataSaved[i*7+6])*0.5;
			ttParam.setValue(i,j,ttParam.getValue(i,j)
				                            - (VrpData[i*7+6]-VrpDataSaved[i*7+6])*0.5 
											- (VrpData[j*7+6]-VrpDataSaved[j*7+6])*0.5);
//			fout<<" = "<<ttParam.getValue(i,j)<<endl;
		}
	}

	IloInt min_transition = 1e6;
	for (i=0;i<NbActPerTour;i++) {
		for (int j=0;j<NbActPerTour;j++) {
			if (i==j) continue;
			if (i==0&&j==NbActPerTour-1) continue;
			if (i==NbActPerTour-1&&j==0) continue;
			if (ttParam.getValue(i,j)<min_transition) {
				min_transition = ttParam.getValue(i,j);
//				fout<<"i = "<<i<<" j = "<<j<<" min_transition = "<<min_transition<<endl;
			}
		}
	}
	
	fout<<endl;
//	fout<<"min_transition = "<<min_transition<<endl;
	MinTransition = min_transition;

/*	fout<<endl;
	fout<<"TRANSFORMED VrpData"<<endl;
	fout<<endl;
	count = 0;
	for (ii=0;ii<NbActPerTour*7;ii++) {
		fout<<VrpData[ii]<<"\t";
		count++;
		if (count==7) {
			count=0;
			fout<<endl;
		}
	}
	fout<<endl;
	fout<<"TRANSFORMED TRANSITION TABLE"<<endl;
	fout<<endl;
	for (ii = 0; ii < NbActPerTour; ii++) {
		for (int j = 0; j < NbActPerTour; j++) {
			fout<<ttParam.getValue(ii,j)<<"\t";
		}
		fout<<endl;
	}	
	fout<<endl;
*/
	//3rd stage
//	fout<<"third stage"<<endl;
	if (MinTransition<0) {
		for (i=0;i<NbActPerTour;i++) {
			for (int j=0;j<NbActPerTour;j++) {
				if (i==j) continue;
				if (i==0&&j==NbActPerTour-1) continue;
				if (i==NbActPerTour-1&&j==0) continue;
				ttParam.setValue(i,j,ttParam.getValue(i,j)-min_transition);
			}
		}
	}

	fout<<endl;
	fout<<"TRANSFORMED VrpData"<<endl;
	fout<<endl;
	count = 0;
	for (ii=0;ii<NbActPerTour*7;ii++) {
		fout<<VrpData[ii]<<"\t";
		count++;
		if (count==7) {
			count=0;
			fout<<endl;
		}
	}

	fout<<endl;
	fout<<"TRANSFORMED TRANSITION TABLE"<<endl;
	fout<<endl;
	for (ii = 0; ii < NbActPerTour; ii++) {
		for (int j = 0; j < NbActPerTour; j++) {
			fout<<ttParam.getValue(ii,j)<<"\t";
		}
		fout<<endl;
	}	
	fout<<endl;

	SummedDuration = 0;
	count = 0;
	for (ii=0;ii<(NbActPerTour-1)*7;ii++) {
		if (count==6) {
			SummedDuration += VrpData[ii];
			count=-1;
		}
		count++;
	}
	return 0;
}

IloInt ChangeTimeWindows(const IloBool transformFlag,
			  		     const IloInt transformIndex,
					     IloNum& horiz) {

	if (!transformFlag) return 0;

	int i;

	for (i=0;i<NbActPerTour;i++) {
		IloInt delta = VrpData[i*7+6] - VrpDataSaved[i*7+6];
//		cout <<"i = "<<i<<" delta = "<<delta<<endl;
		if (i==0 || i==NbActPerTour-1) {
			VrpData[i*7+5] += delta;
		} else {
			VrpData[i*7+4] -= 0.5*delta;
			VrpData[i*7+5] += 0.5*delta;
		}
	}

	horiz = VrpData[5];

/*	cout<<endl;
	cout<<"VrpDataSaved"<<endl;
	cout<<endl;
	int count = 0;
	for (int ii=0;ii<NbActPerTour*7;ii++) {
		cout<<VrpDataSaved[ii]<<"\t";
		count++;
		if (count==7) {
			count=0;
			cout<<endl;
		}
	}

	cout<<endl;
	cout<<"TRANSFORMED VrpData"<<endl;
	cout<<endl;
	count = 0;
	for (ii=0;ii<NbActPerTour*7;ii++) {
		cout<<VrpData[ii]<<"\t";
		count++;
		if (count==7) {
			count=0;
			cout<<endl;
		}
	}
*/
	return 0;
	
}



IloModel DefineModel(const IloEnv env,  
		     IloNumVar& transCostSum, 
		     IloNumVarArray& transCostArr, 
		     IloTransitionParam& ttParam, 
		     ofstream& fout) { 
 
	IloModel model(env); 
	IloInt i,j; 
	char buffer[128]; 
 
	IloNum origin  = VrpData[4]; 
	IloNum horizon = VrpData[5]; 
 
	IloSchedulerEnv schedEnv(env); 
 
	schedEnv.getResourceParam().setCapacityEnforcement(IloHigh); 
	schedEnv.setHorizon(horizon); 
 
	//Initializing two pairs of resources representing two machines 
	IloUnaryResourceArray unarResources(env,NbMachines); 
 
	for (i = 0;i<NbMachines;i++) { 
		sprintf(buffer,"unar_machine%d", i+1);		 
		unarResources[i] = IloUnaryResource(env, buffer); 
		unarResources[i].setCapacityMax(origin,horizon,1); 
		unarResources[i].setCapacityMin(origin,horizon,0); 
	} 
 
	//transition times and costs 
	ttParam = IloTransitionParam(env, NbActPerTour, IloFalse); 
 
	IloInt sum = 0; 
 
	for (i = 0; i < NbActPerTour; i++) { 
		for (j = 0; j < NbActPerTour; j++) { 
			ttParam.setValue(i,j,computeDistance(i,j)); 
			if (i==0) sum += 2*computeDistance(i,j); 
		} 
	}	 
//	fout<<"The upper bound is "<<sum<<endl; 

	fout<<"TRANSITION TABLE"<<endl;
	fout<<endl;

	for (i = 0; i < NbActPerTour; i++) { 
		for (j = 0; j < NbActPerTour; j++) { 
			ttParam.setValue(i,j,computeDistance(i,j)); 
			if (i==0) sum += 2*computeDistance(i,j); 
			fout<<ttParam.getValue(i,j)<<"\t";
			TransMatrSaved[i][j] = ttParam.getValue(i,j);
		} 
		fout<<endl;
	}	 
 
	fout<<endl;
	fout<<"TRANSITION TABLE SAVED"<<endl;
	fout<<endl;

	for (i = 0; i < NbActPerTour; i++) { 
		for (j = 0; j < NbActPerTour; j++) { 
			fout<<TransMatrSaved[i][j]<<"\t";
		} 
		fout<<endl;
	}	 

	fout<<endl;

	
	if (TransformFlag) {
		if (TransformIndex==1) {//by Chris
			MakeTransformation(ttParam,fout);
			SetupActivityDuration = VrpData[6];
			TeardownActivityDuration = VrpData[6];
		} else {//by Patrick
			MakeTransformation(ttParam,TransformIndex,fout);
			SetupActivityDuration = VrpData[6];
			TeardownActivityDuration = VrpData[6];
		}
	} else {
		if (VrpData[6]==0) {
			SetupActivityDuration = 1;
			TeardownActivityDuration = 1;
		} else {
			SetupActivityDuration = VrpData[6];
			TeardownActivityDuration = VrpData[6];
		}
	}
	 
	IloTransitionCost enrTrans; 
 
	for (i = 0; i<NbMachines; i++) { 
		IloTransitionTime(unarResources[i],ttParam); 
		enrTrans = IloTransitionCost(unarResources[i],ttParam); 
		model.add(transCostArr[i]==enrTrans.getCostSumVar()); 
	} 
 
	model.add(IloSum(transCostArr) == transCostSum); 
 
	IloActivityArray activities(env,NbAct);
 
	//Each activity should have a unique name  
	//and its distinct transition type  
 
	//Setup activities. They consume nothing 
 
	IloInt index = 1; 
	for (i = 0;i<NbMachines;i++) { 
		sprintf(buffer, "setup%d",index); 
		activities[i] = IloActivity(env, SetupActivityDuration, 0, buffer); 
		index++; 
	} 
	 
	//actual activities 
	index = 1; 
	for (i = NbMachines; i<NbAct-NbMachines; i++) { 
		sprintf(buffer,"task%d", index); 
		activities[i] = IloActivity(env, getActivityDuration(index), index, buffer); 
		index++; 
	} 
 
	//teardown activities. They consume nothing 
	index = 1; 
	for (i = NbAct-NbMachines; i<NbAct; i++) { 
		sprintf(buffer, "teardown%d", index); 
		activities[i] = IloActivity(env, TeardownActivityDuration, NbActPerTour-1, buffer); 
		index++; 
	} 
 
	//Temporal constraints 
	ChangeTimeWindows(TransformFlag,TransformIndex,horizon);

	for (i = 0;i<NbMachines;i++) { 
		model.add(activities[i].startsAfter(origin)); 
	} 

	index = 1; 
	for (i = NbMachines; i<NbAct-NbMachines; i++) { 
		model.add(activities[i].startsAfter(getEarliestStartTime(index))); 
		model.add(activities[i].endsBefore(getLatestStartTime(index) 
									   + getActivityDuration(index))); 
		index++; 
	} 
	 
	for (i = NbAct-NbMachines; i<NbAct; i++) { 
		model.add(activities[i].endsBefore(horizon)); 
	}
 
/*	if (!TransformFlag) { 

		for (i = 0;i<NbMachines;i++) { 
			model.add(activities[i].startsAfter(origin)); 
		} 

		index = 1; 
		for (i = NbMachines; i<NbAct-NbMachines; i++) { 
			model.add(activities[i].startsAfter(getEarliestStartTime(index))); 
			model.add(activities[i].endsBefore(getLatestStartTime(index) 
										   + getActivityDuration(index))); 
			index++; 
		} 
		 
		for (i = NbAct-NbMachines; i<NbAct; i++) { 
			model.add(activities[i].endsBefore(horizon)); 
		}
		
	} else {
		//if we use transformation (with TransformIndex = 2,3,..,4)
		//we have to shrink the time windows as these types of transformaiton
		//widen the time bounds of an activity.

		//we don't change this
		for (i = 0;i<NbMachines;i++) { 
			model.add(activities[i].startsAfter(origin)); 
		} 

		index = 1; 
		for (i = NbMachines; i<NbAct-NbMachines; i++) { 
			model.add(activities[i].startsAfter(getEarliestStartTime(index))); 
			model.add(activities[i].endsBefore(getLatestStartTime(index) 
										   + getActivityDuration(index))); 
			index++; 
		} 
		 
		for (i = NbAct-NbMachines; i<NbAct; i++) { 
			model.add(activities[i].endsBefore(horizon)); 
		}

	}
*/
	//Resource constraints 
	IloResourceConstraint rc1,rc2; 
	for (i = 0; i<NbMachines; i++) { 
		rc1 = activities[i].requires(unarResources[i]); 
		rc1.setSetup(); 
		model.add(rc1); 
	} 
 
	//Creating an alternative set of discrete resources 
	IloAltResSet ResourcesAltSet(env); 
	for (i = 0; i<NbMachines; i++) { 
		ResourcesAltSet.add(unarResources[i]); 
	} 
 
	IloAltResConstraint alternative; 
	IloActivity activity; 


	//taking into account capacity constraints

	IloNumVarArray selected(env,NbMachines*NbAct,0,1,ILOINT); 

	for (i = NbMachines; i < NbAct-NbMachines; i++) { 
		activity = activities[i]; 
		alternative = activity.requires(ResourcesAltSet,1); 

		for (j=0;j<NbMachines;j++) {                           //for machines
			model.add((alternative.select(unarResources[j])) ==
				      (selected[j*NbAct+(i-NbMachines)]==1));
		}

		model.add(alternative);
	}
		
	//introducing expression to account capacities
	IloExpr expr(env);

	for (j=0;j<NbMachines;j++) {
		for (i=NbMachines;i<NbAct-NbMachines;i++) {
			expr += selected[j*NbAct+(i-NbMachines)]*getDemand(i-NbMachines+1);
		}
		model.add(expr<=Capacity);
		expr.remove(selected);
	}

	index = 0; 
	for (i = NbAct-NbMachines; i<NbAct; i++) { 
		rc1 = activities[i].requires(unarResources[index]); 
		rc1.setTeardown(); 
		model.add(rc1); 
		index++; 
	} 
 
	//adding for future extraction by the solver 
	model.add(transCostSum); 
	model.add(transCostArr); 
 
	return model; 
} 
 
/////////////////////////////////////////////////////////////////////////////// 
// 
// PRINTING SOLUTIONS 
// 
/////////////////////////////////////////////////////////////////////////////// 

IloInt getTrueCost(IloInt transformFlag,
				   IloInt TransformIndex,
				   const IloSolver solver,
				   const IloNumVar transCostSum,
				   ofstream& fout) {


 IlcScheduler scheduler(solver); 
 IloEnv env = solver.getEnv(); 
 IloInt trueCost = 0;

 //this is the cost value after transformation
 trueCost = solver.getIntVar(transCostSum).getMin(); 

 if (!transformFlag) return trueCost;
	

 //getting the right cost value;
 //for Chris's transform
 if (TransformIndex==1) {


	 //in order to compute the true cost value
	 //first we have to compute the number of edges in the solution
	 //and count the number of used vehicles;
	 IlcInt NbEdges = 0, NbVehiclesUsed = 0;

	 for (IlcUnaryResourceIterator ur_i(scheduler); ur_i.ok(); ++ur_i) {
		 IlcUnaryResource machine =*ur_i;
		 IlcInt index = machine.getSetupVar().getValue();
		 IlcInt sink = machine.getTeardownIndex();
		 
		 //this counter just counts the number of edges on a resource
		 //which is used
		 IlcInt ctr = 0;

		 while (index != sink) {
			 IlcResourceConstraint task = machine.getSequenceRC(index);
			 index = task.getNextVar().getValue();
			 ctr++;
		 }

		 if (ctr>2) {
			 NbEdges += ctr-1;
			 NbVehiclesUsed++;
		 }
	 }

	 //increase trueCost by the sum of the performed activities
	 //bearing in mind that with each new vehicle used
	 //we have to add the duration of the starting activity;
	 //SummedDuration is the sum of durations of all visits to
	 //customers + base;

	 fout<<"NbVehiclesUsed = "<<NbVehiclesUsed<<endl;
	 fout<<"NbEdges = "<<NbEdges<<endl;
	 fout<<"MinTransition = "<<MinTransition<<endl;
	 fout<<"SummedDuration = "<<SummedDuration<<endl;
	 fout<<"SummedDurationSaved = "<<SummedDurationSaved<<endl;


	 //this is basically the cost of a TSP tour
	 trueCost += SummedDuration + (NbVehiclesUsed-1)*VrpData[6]; 

	 //now we have to subtract from it the sum of durations of the
	 //activities as they were BEFORE the transformation;
	 //Moreover, we also have to subtract abs(MinTransition)*NbEdges;
	 trueCost -= (SummedDurationSaved + (NbVehiclesUsed-1)*VrpDataSaved[6])
				+ abs(MinTransition)*NbEdges;

	 return trueCost;
 } else {
	//for Patrick's transform

	  IlcInt NbVehiclesUsed = 0;
	  for (IlcUnaryResourceIterator ur_i(scheduler); ur_i.ok(); ++ur_i) {
		 IlcUnaryResource machine =*ur_i;
		 IlcInt index = machine.getSetupVar().getValue();
		 IlcInt sink = machine.getTeardownIndex();
		 
		 //this counter just counts the number of edges on a resource
		 //which is used
		 IlcInt ctr = 0;

		 while (index != sink) {
			 IlcResourceConstraint task = machine.getSequenceRC(index);
			 index = task.getNextVar().getValue();
			 ctr++;
		 }

		 if (ctr>2) {
			 NbVehiclesUsed++;
		 }
	  }

	  fout<<"NbVehiclesUsed = "<<NbVehiclesUsed<<endl;
	  fout<<"SummedDuration = "<<SummedDuration<<endl;
	  fout<<"SummedDurationSaved = "<<SummedDurationSaved<<endl;
	  //this is basically the cost of a TSP tour
	  trueCost += SummedDuration + (NbVehiclesUsed-1)*2*VrpData[6]; 


	  //now we have to subtract from it the sum of durations of the
	  //activities as they were BEFORE the transformation;
	  //Moreover, we also have to subtract abs(MinTransition)*NbEdges;
	  trueCost -= (SummedDurationSaved + (NbVehiclesUsed-1)*2*VrpDataSaved[6]);

	  return trueCost;//solver.getIntVar(transCostSum).getMin() + Delta;
 }
}

void PrintSolution(const IloSolver solver,  
		   const IloNumVar transCostSum,  
		   const IloNumVarArray transCostArr, 
		   ofstream& fout, 
		   ofstream& fout1, 
		   const IloInt SolutionNb, 
		   const IloInt NbFailsSummed, 
		   const IloInt NbChoicePointsSummed,
		   IloBool LastSolution)
{ 

 
 IlcScheduler scheduler(solver); 
 IloEnv env = solver.getEnv(); 
 IloInt NbMachinesUsed = 0; 
 const IloAny ACTIVITY_PRINTED = (IloAny)1; 
 if (LastSolution) {
	 fout1<<SolutionNb-1<<" "<<LastNbOfMachinesUsed<<" "<<TrueCost<<" "<<NbChoicePointsSummed<<" "<<NbFailsSummed;
 } else {

	 fout << "Cost Function Value: "<<TrueCost<<endl; 
	 fout << endl; 

	 //output tours

	 for (IlcUnaryResourceIterator ur_I(scheduler); ur_I.ok(); ++ur_I) {
		 IlcUnaryResource machine =*ur_I;
		 fout<<endl<<machine.getName()<<endl;
		 IlcInt index = machine.getSetupVar().getValue();
		 IlcInt sink = machine.getTeardownIndex();
		 IlcInt ctr = 0;
		 while (index != sink) {
			 IlcResourceConstraint task = machine.getSequenceRC(index);
			 fout<<"\t"<<task.getActivity()<<endl;
			 index = task.getNextVar().getValue();
			 ctr++;
		 }
	 }

	  fout<<endl; 
	  fout << "Number of fails             : " << solver.getNumberOfFails()<<endl; 
	  fout << "Number of choice points     : " << solver.getNumberOfChoicePoints()<<endl; 
	  fout << "Number of constraints       : " << solver.getNumberOfConstraints()<<endl; 
	  fout << "Elapsed time since creation : " << solver.getTime()<<endl; 

	  fout<<endl; 
	 fout<<"The sums of transition costs on each machine: "<<endl; 

	 for (int i = 0; i<NbMachines; i++) { 
		fout<<"transCostArr["<<i<<"]: min = "<<solver.getIntVar(transCostArr[i]).getMin() 
 			<<" max = "<<solver.getIntVar(transCostArr[i]).getMax()<<endl; 
		if (solver.getIntVar(transCostArr[i]).getMin()!=0) NbMachinesUsed++; 
	}
	LastNbOfMachinesUsed = NbMachinesUsed;
	 fout<<endl; 
	 fout<<"The sum of transition costs on all machines: " 
		 <<" min = "<<solver.getIntVar(transCostSum).getMin() 
		 <<" max = "<<solver.getIntVar(transCostSum).getMax()<<endl; 

	 if (SolutionNb==1) {
		 fout1<<NbMachinesUsed<<" "<<TrueCost<<" "<<solver.getNumberOfChoicePoints()<<" "
			  <<solver.getNumberOfFails()<<" ";
	 }
 }

} 
 

/////////////////////////////////////////////////////////////////////////////// 
// 
// MAIN FUNCTION 
// 
/////////////////////////////////////////////////////////////////////////////// 

int main(int argc, char* argv[]) { 
 
  try { 
 
	IloEnv env; 
 
	if (argc!=15) { 
		cout<<endl; 
		cout<<"Usage A: <file_name>.exe <data_file_name> <resfile1_name> <resfile2_name>\n"; 
		cout<<"         NbMachines  NbCustomers VehicleCapacity <int>\n"; 
		cout<<"         TransformFlag <should be 1 - turned on> \n";
		cout<<"         TransformIndex<1 - Chris,2 - lex,3 - maxmin,4 - minmin>\n";
		cout<<"         ResourceSelector <1..4> ResConstrSelector <1..4>\n"; 
		cout<<"         AltResSelector <1..4> DiscrepancyCount <1,2,..> TimeLimit <s>\n"; 
		cout<<"         OutputStartFlag <0/1>\n";
/*		cout<<endl;
		cout<<"Usage B: <file_name>.exe <data_file_name> <resfile1_name> <resfile2_name>\n"; 
		cout<<"         NbMachines  NbCustomers VehicleCapacity <int>\n"; 
		cout<<"         TransformFlag <should be 0 - turned off> \n";
		cout<<"         ResourceSelector <1..4> ResConstrSelector <1..4>\n"; 
		cout<<"         AltResSelector <1..4> DiscrepancyCount <1,2,..> TimeLimit <s>\n"; 
		cout<<"         OutputStartFlag <0/1>\n";
*/
		return 0; 
	} 
	
	ofstream fout,fout1; 
	ifstream fin; 
	IloBool startFlag;
	
	startFlag = atoi(argv[14]);

	fin.open(argv[1], ios::in); 
	sprintf(Problem,argv[1]);
	fout.open(argv[2], ios::out);
	if (startFlag) { 
		fout1.open(argv[3], ios::out); 
	} else {
		fout1.open(argv[3], ios::app); 
	}
 
 	NbMachines = atoi(argv[4]); 
	fout<<"NbMachines                 : "<<NbMachines<<endl; 

	NbCustomers = atoi(argv[5]); 
	fout<<"NbCustomers                : "<<NbCustomers<<endl; 

	Capacity = atoi(argv[6]); 
	fout<<"Capacity                   : "<<Capacity<<endl;  

	TransformFlag = atoi(argv[7]); 

	if (TransformFlag)	{
		fout<<"Transformation             : ON "<<endl; 
		TransformIndex = atoi(argv[8]);
		if (TransformIndex==1)	fout<<"TransformIndex             : by Chris"<<endl;  
		else {
			if (TransformIndex==2) fout<<"TransformIndex             : lex"<<endl;  
			if (TransformIndex==3) fout<<"TransformIndex             : maxmin"<<endl;  
			if (TransformIndex==4) fout<<"TransformIndex             : minmin"<<endl;  
		}

	}

	else {
		fout<<"Transformation             : OFF "<<endl; 
		TransformIndex = 0;
	}

	ResourceSelector = atoi(argv[9]); 
	fout<<"ResourceSelector           : "<<ResourceSelector<<endl;  

	ResourceConstraintSelector = atoi(argv[10]); 
	fout<<"ResourceConstraintSelector : "<<ResourceConstraintSelector<<endl;  

	PossibleResourceSelector = atoi(argv[11]); 
	fout<<"PossibleResourceSelector   : "<<PossibleResourceSelector<<endl;  

	DiscrepancyCount = atoi(argv[12]); 
	fout<<"DiscrepancyCount           : "<<DiscrepancyCount<<endl;  

	BasicTimeLimit = atoi(argv[13]); 
	fout<<"BasicTimeLimit             : "<<BasicTimeLimit<<endl;  

 
	IloResourceSelector rSel; 
	if (ResourceSelector==1) rSel = IloSelResMinGlobalSlack; //default 
	if (ResourceSelector==2) rSel = IloSelResMinLocalSlack; 
	if (ResourceSelector==3) rSel = IloSelResSequenceMinGlobalSlack; 
	if (ResourceSelector==4) rSel = IloSelResSequenceMinLocalSlack; 
 
	IloResourceConstraintSelector rcSel; 
	if (ResourceConstraintSelector==1) rcSel = IloSelFirstRCMinEndMax; //default 
	if (ResourceConstraintSelector==2) rcSel = IloSelFirstRCMinStartMax; 
	if (ResourceConstraintSelector==3) rcSel = IloSelLastRCMaxEndMin; 
	if (ResourceConstraintSelector==4) rcSel = IloSelLastRCMaxStartMin; 
 
	IloResourceSelector prSel; 
	if (PossibleResourceSelector==1) prSel = IloSelResMinGlobalSlack; 
	if (PossibleResourceSelector==2) prSel = IloSelResMinLocalSlack; 
	if (PossibleResourceSelector==3) prSel = IloSelResMinCapacity; 
	if (PossibleResourceSelector==4) prSel = IloSelAltRes; //default 


	if (TransformFlag && TransformIndex==1) {
		fout<<"Sorry... Transformation by Chris not working with TWs so far..."<<endl;
		cout<<"Sorry... Transformation by Chris not working with TWs so far..."<<endl;
	}


	NbAct = NbCustomers + 2 + 2*(NbMachines - 1);	 
	NbActPerTour = NbCustomers + 2;  

    ///////////////////////////////////////////////////////////////////////////// 
    // 
    // Reading in data from the data file 
    // 
    ///////////////////////////////////////////////////////////////////////////// 

	IloInt i; 
 
	//We use the VrpData array to store the read in data

	for (i=0;i<NbActPerTour*7;i++) { //*7 because of the format of data files 
		if (i<7*NbActPerTour-7)  
			fin>>VrpData[i];  
		else   
			VrpData[i] = VrpData[i-7*NbActPerTour+7];  
		        //additional line corresponding to teardown activity, repeats the first one 
	} 

	fout<<endl;
	fout<<"VrpData"<<endl;
	fout<<endl;
	IloInt count = 0;
	for (int ii=0;ii<NbActPerTour*7;ii++) {
		fout<<VrpData[ii]<<"\t";
		count++;
		if (count==7) {
			count=0;
			fout<<endl;
		}
	}
	fout<<endl;

	IloInt size = NbActPerTour*7;

	VrpDataSaved = new (env) IloNum [size];
	for (i=0;i<size;i++) {
		VrpDataSaved[i]=VrpData[i];
	}
	
	fout<<endl;
	fout<<"VrpDataSaved"<<endl;
	fout<<endl;
	count = 0;
	for (ii=0;ii<NbActPerTour*7;ii++) {
		fout<<VrpDataSaved[ii]<<"\t";
		count++;
		if (count==7) {
			count=0;
			fout<<endl;
		}
	}
	fout<<endl;
	
	size = NbActPerTour;
	TransMatrSaved = new (env) IloInt * [size];
	for (i=0;i<size;i++) {
		TransMatrSaved[i] = new IloInt [size];
	}
	for (i=0;i<size;i++) {
		for (int j=0;j<size;j++) {
			TransMatrSaved[i][j]=0;
		}
	}


	if (TransformFlag) {
		SummedDurationSaved = 0;
		if (TransformIndex==1) {//by Chris
			count = 0;
			for (ii=0;ii<(NbActPerTour-1)*7;ii++) {
				if (count==6) {
					SummedDurationSaved += VrpData[ii];
					count=-1;
				}
				count++;
			}
		}
		else { //by Patrick
			count = 0;
			for (ii=0;ii<NbActPerTour*7;ii++) {
				if (count==6) {
					SummedDurationSaved += VrpData[ii];
					count=-1;
				}
				count++;
			}
		}
	}	
	//transCostSum variable is to store the sum of transition 
	//costs on all machines (more precisely, on all unary 
	//resources associated with machines); 
	//An element of the transCostArr array stores the sum of transition 
	//costs on a particular machine (more precisely, on the  
	//respective unary resource 
 
	IloNumVar transCostSum(env,0,IloInfinity,ILOINT); 
	IloNumVarArray transCostArr(env,NbMachines,0,IloInfinity,ILOINT); 
	IloSchedulerSolution solution(env); 
	IloTransitionParam ttParam; 
 
	IloModel model = DefineModel(env,  
		                         transCostSum,  
								 transCostArr, 
                                 ttParam, 
								 fout); 

    // Algorithm 
	IloSolver solver(model); 
	IlcScheduler scheduler(solver); 
 
	//The Search Goal 
	IloGoal goal = IloRankForward(env,rSel,rcSel)
                   &&IloAssignAlternative(env,prSel);
 
	//Applying LDS 
	goal = IloApply (env, goal, IloLDSEvaluator(env, DiscrepancyCount)); 
 
	//Getting the First Solution  
	//(getting it separately is necessary  
	//to obtain the first value of the objective function) 
 
	NbFailsSummed = 0; 
	NbChoicePointsSummed = 0; 

 
	struct tm *ptr; 
	time_t lt; 
 
 
	clock_t start,finish; 
	start = clock(); 
 
	lt = time(NULL); 
	ptr = localtime(&lt); 
	fout<<asctime(ptr); 
	cout<<asctime(ptr); 

	IloBool LastSolution = IloFalse;
 
	/////////////////////////////////////////////////////////////
	//
	// Searching for solutions
	//
	/////////////////////////////////////////////////////////////

	// the first solution

	if (solver.solve(IloLimitSearch(env, goal, IloTimeLimit(env, BasicTimeLimit)))) { //if there is a solution 
		finish = clock()-start; 
		fout<<endl; 
		fout<<"****************** Solution 1 ******************"<<endl; 
		//at first calculate the true cost
		TrueCost = getTrueCost(TransformFlag,TransformIndex,solver,transCostSum,fout);

		PrintSolution(solver,transCostSum,transCostArr,
                              fout,fout1,1,NbFailsSummed,NbChoicePointsSummed,LastSolution); 
		env.out()<<endl; 
		env.out()<<"Solution 1 : " 
			 <<TrueCost<<endl; 
	
		env.out()<<endl; 
		solver.printInformation(); 
        NbFailsSummed += solver.getNumberOfFails(); 
		NbChoicePointsSummed += solver.getNumberOfChoicePoints(); 
	} else { 
		solver.out() << "No Solutions" << endl; 
		lt = time(NULL); 
		ptr = localtime(&lt); 
		fout<<asctime(ptr); 
		cout<<asctime(ptr); 
		fout.close(); 
		fout1.close(); 
		env.end(); 
		exit(1); 
	} 


	//if you are DELETING exit(1), DELETE ALSO these lines:
	fout1<<endl;
	fout.close(); 
	fout1.close(); 
	env.end(); 

/*	IloInt SolutionCtr = 2; 
	// Getting the var TimeLimit depending on how much time is spent previously on search. 
	// In fact, Time Limit is what is left for search from BasicTimeLimit. 

	IloNum TimeSpent = (double) finish / CLOCKS_PER_SEC; 
	cout<<"TimeSpent : "<<TimeSpent<<endl; 
	fout1<<" "<<TimeSpent<<"    ";
 
	IloNum TimeLimit = BasicTimeLimit - TimeSpent; 
	cout<<"TimeLimit : "<<TimeLimit<<endl; 
 
	start = clock(); 
	
	// subsequent solutions of less cost
	
	while (TimeLimit>0 && solver.solve(IloAddConstraint(transCostSum <= solver.getIntVar(transCostSum).getMin()-1) 
		                           && IloLimitSearch(env, goal, IloTimeLimit(env,TimeLimit)))) { 
		fout<<endl; 
		fout<<"****************** Solution "<<SolutionCtr<<" ******************"<<endl; 
		//at first calculate the true cost
		TrueCost = getTrueCost(TransformFlag,TransformIndex,solver,transCostSum,fout);
		PrintSolution(solver,transCostSum,transCostArr,
                              fout,fout1,SolutionCtr,NbFailsSummed,NbChoicePointsSummed,LastSolution); 
		env.out()<<endl; 
		env.out()<<"Solution "<<SolutionCtr<<" : " 
			 <<TrueCost<<endl; 
	
		env.out()<<endl; 
		solver.printInformation(); 
        NbFailsSummed += solver.getNumberOfFails(); 
		NbChoicePointsSummed += solver.getNumberOfChoicePoints(); 

		finish = clock(); 
		TimeSpent += (double) (finish - start) / CLOCKS_PER_SEC; 
		cout<<"TimeSpent : "<<TimeSpent<<endl; 
		TimeLimit = BasicTimeLimit - TimeSpent; 
		cout<<"TimeLimit : "<<TimeLimit<<endl; 
		start = finish; 
		SolutionCtr++; 
	} 
 
	cout<<"No More Solutions"<<endl; 
	LastSolution = IloTrue;
	PrintSolution(solver,transCostSum,transCostArr,
                              fout,fout1,SolutionCtr,NbFailsSummed,NbChoicePointsSummed,LastSolution); 
	fout1<<" "<<TimeSpent<<endl;

	lt = time(NULL); 
	ptr = localtime(&lt); 
	fout<<asctime(ptr); 
	cout<<asctime(ptr); 
	fout.close(); 
	fout1.close(); 
	env.end(); 
*/    
  } catch (IloException& exc) { 
    cout << exc << endl; 
  } 
  return 0; 
}