public void ShouldBuildPlanForSimpleCase1()
{
//Arrange
var firstJob = new Job(1, 10, null, .1, 2);
var secondJob = new Job(2, 10, new List<int> { 1 }, .1, 2);
var thirdJob = new Job(3, 20, new List<int> { 1, 2 }, .1, 2);
var jobs = new List<Job> { firstJob, secondJob, thirdJob };
var resource1 = new Resource(1, 20);
var resources = new List<Resource> { resource1 };
var dependencies = new List<double[]> { new double[] { 7 }, new double[] { 14 }, new double[] { 10 } };
var planBuilder = new JobPlanBuilder();
//Act
var plan = planBuilder.GetBasePlan(resources, jobs, dependencies);
//Assert
AreEqual(plan.Count(), 3);
AreEqual(plan[0].ExecutingJobs.Count, 1);
AreEqual(plan[0].ExecutingJobs[0].JobReference.Number, 1);
True(plan[0].ExecutingJobs[0].Intencity.FloatEquals(2));
True(plan[0].TimeDelta.FloatEquals(5));
AreEqual(plan[1].ExecutingJobs.Count, 1);
AreEqual(plan[1].ExecutingJobs[0].JobReference.Number, 2);
True(plan[1].ExecutingJobs[0].Intencity.FloatEquals(1.42857142857));
True(plan[1].TimeDelta.FloatEquals(7));
AreEqual(plan[2].ExecutingJobs.Count, 1);
AreEqual(plan[2].ExecutingJobs[0].JobReference.Number, 3);
AreEqual(plan[2].ExecutingJobs[0].Intencity, 2);
True(plan[2].TimeDelta.FloatEquals(10));
}
public RunningJob(Job jobReference, double intencity, double runTime, double startTime)
{
JobReference = jobReference;
Intencity = intencity;
RunTime = runTime;
StartTime = startTime;
EndTime = StartTime + RunTime;
WorkAmount = RunTime*Intencity;
}
public void ShouldCreateCorrectDataContainer()
{
//Arrange
var firstJob = new Job(1, 100, null, 1, 10);
var secondJob = new Job(2, 100, new List<int> {1}, 1, 10);
var thirdJob = new Job(3, 200, new List<int>{1, 2}, 1, 20);
var jobs = new List<Job> { firstJob, secondJob, thirdJob };
var resource1 = new Resource(1, 10);
var resource2 = new Resource(2, 30);
var resources = new List<Resource> { resource1, resource2 };
var dependencies = new List<double[]> { new[] {0.7, 1.2} , new[] {1.4, 0.8}, new[] {1.0,2.0} };
//Act
var container = new SchedulingDataContainer(resources, jobs, dependencies);
//Assert
AreEqual(container.Jobs, jobs);
AreEqual(container.Resources, resources);
AreEqual(container.Jobs[0].Number, 1);
AreEqual(container.Jobs[0].FullWorkVolume, 100);
AreEqual(container.Jobs[0].MinimumIntensity, 1);
AreEqual(container.Jobs[0].MaximumIntensity, 10);
AreEqual(container.Jobs[0].ResourceDependencies.Count, 2);
AreEqual(container.Jobs[0].PrecedingJobs.Count, 0);
AreEqual(container.Jobs[0].NumberOfDependants, 2);
AreEqual(container.Jobs[0].ResourceDependencies[0].Job, firstJob);
AreEqual(container.Jobs[0].ResourceDependencies[0].Resource, resource1);
AreEqual(container.Jobs[0].ResourceDependencies[0].Value, 0.7);
AreEqual(container.Jobs[0].ResourceDependencies[1].Job, firstJob);
AreEqual(container.Jobs[0].ResourceDependencies[1].Resource, resource2);
AreEqual(container.Jobs[0].ResourceDependencies[1].Value, 1.2);
AreEqual(container.Jobs[1].Number, 2);
AreEqual(container.Jobs[1].PrecedingJobs.Count, 1);
AreEqual(container.Jobs[1].PrecedingJobs[0], firstJob);
AreEqual(container.Jobs[1].NumberOfDependants, 1);
AreEqual(container.Jobs[1].ResourceDependencies.Count, 2);
AreEqual(container.Jobs[1].ResourceDependencies[0].Job, secondJob);
AreEqual(container.Jobs[1].ResourceDependencies[0].Resource, resource1);
AreEqual(container.Jobs[1].ResourceDependencies[0].Value, 1.4);
AreEqual(container.Jobs[1].ResourceDependencies[1].Job, secondJob);
AreEqual(container.Jobs[1].ResourceDependencies[1].Resource, resource2);
AreEqual(container.Jobs[1].ResourceDependencies[1].Value, 0.8);
AreEqual(container.Jobs[2].Number, 3);
AreEqual(container.Jobs[2].PrecedingJobs.Count, 2);
AreEqual(container.Jobs[2].PrecedingJobs[0], firstJob);
AreEqual(container.Jobs[2].PrecedingJobs[1], secondJob);
AreEqual(container.Jobs[2].ResourceDependencies.Count, 2);
AreEqual(container.Jobs[2].ResourceDependencies[0].Job, thirdJob);
AreEqual(container.Jobs[2].ResourceDependencies[0].Resource, resource1);
AreEqual(container.Jobs[2].ResourceDependencies[0].Value, 1.0);
AreEqual(container.Jobs[2].ResourceDependencies[1].Job, thirdJob);
AreEqual(container.Jobs[2].ResourceDependencies[1].Resource, resource2);
AreEqual(container.Jobs[2].ResourceDependencies[1].Value, 2.0);
}
public void ShouldGivePriorityJobWithBiggerVolume()
{
//Arrange
var job1 = new Job(1, 10, null, 1, 10);
var job2 = new Job(2, 20, null, 1, 10);
var comparer = new JobGreedyComparer();
//Act
var compareResult = comparer.Compare(job1, job2);
//Assert
AreEqual(compareResult, -1);
}
public void ShouldGivePriorityJobWithDependant()
{
//Arrange
var job1 = new Job(1, 10, null, 1, 10);
var job2 = new Job(2, 10, null, 1, 10);
var job3 = new Job(3, 10, null, 1, 10);
job1.DependantJobs.Add(job3);
var comparer = new JobGreedyComparer();
//Act
var compareResult = comparer.Compare(job1, job2);
//Assert
AreEqual(compareResult, 1);
}
public void ShouldNotCompareJobsThatCannotStart()
{
//Arrange
var job1 = new Job(1, 10, null, 1, 10);
var job2 = new Job(2, 10, null, 1, 10);
var job3 = new Job(3, 10, null, 1, 10);
var job4 = new Job(4, 10, null, 1, 10);
job2.PrecedingJobs.Add(job1);
job3.PrecedingJobs.Add(job2);
job3.PrecedingJobs.Add(job4);
var comparer = new JobGreedyComparer();
//Act and Assert
// ReSharper disable ReturnValueOfPureMethodIsNotUsed
Throws<InvalidOperationException>(()=>comparer.Compare(job2, job3));
// ReSharper restore ReturnValueOfPureMethodIsNotUsed
}
private PlanModel CreateFakePlanModel()
{
var firstJob = new Job(1, 10, null, .1, 2);
var secondJob = new Job(2, 10, new List<int> {1}, .1, 2);
var thirdJob = new Job(3, 20, new List<int> {1, 2}, .1, 2);
var fourthJob = new Job(4, 20, null, .1, 2);
var jobs = new List<Job> {firstJob, secondJob, thirdJob, fourthJob};
var resource1 = new Resource(1, 20);
var resources = new List<Resource> {resource1};
var dependencies = new List<double[]> {new double[] {7}, new double[] {14}, new double[] {10}, new double[] {6}};
var planBuilder = new JobPlanBuilder();
var plan = planBuilder.GetBasePlan(resources, jobs, dependencies);
var planModel = new PlanModel(plan);
return planModel;
}
public void ShouldCountFullVolumeWithDependant()
{
//Arrange
var job1 = new Job(1, 10, null, 1, 10);
var job2 = new Job(2, 10, null, 1, 10);
var job3 = new Job(3, 10, null, 1, 10);
var job4 = new Job(4, 10, null, 1, 10);
job1.DependantJobs.Add(job2);
job1.DependantJobs.Add(job3);
job4.DependantJobs.Add(job3);
//Act
var fullVolumeWithDependant1 = Job.GetFullVolumeWithDependantJobs(job1);
var fullVolumeWithDependant2 = Job.GetFullVolumeWithDependantJobs(job2);
var fullVolumeWithDependant3 = Job.GetFullVolumeWithDependantJobs(job3);
var fullVolumeWithDependant4 = Job.GetFullVolumeWithDependantJobs(job4);
//Assert
AreEqual(fullVolumeWithDependant1, 30);
AreEqual(fullVolumeWithDependant2, 10);
AreEqual(fullVolumeWithDependant3, 10);
AreEqual(fullVolumeWithDependant4, 20);
}
public void ShouldBeAbleToStartJob()
{
//Arrange
var job1 = new Job(1, 10, null, 1, 10);
var job2 = new Job(2, 10, null, 1, 10);
var job3 = new Job(3, 10, null, 1, 10);
var job4 = new Job(4, 10, null, 1, 10);
job2.PrecedingJobs.Add(job1);
job3.PrecedingJobs.Add(job2);
job3.PrecedingJobs.Add(job4);
//Act
var result1 = job1.CanStart();
var result2 = job2.CanStart();
var result3 = job3.CanStart();
var result4 = job4.CanStart();
//Assert
True(result1);
False(result2);
False(result3);
True(result4);
}
public void ShouldCreateLinearProgramFromBasePlan1()
{
//Arrange
var job1 = new Job(1, 100, null, 1, 10);
var job2 = new Job(2, 50, new[] {1}, 1, 10);
var job3 = new Job(3, 50, null, 1, 10);
var jobArr = new List<Job> {job1, job2, job3};
var resourceArray = new List<Resource> {new Resource(1, 20), new Resource(2, 50)};
var dependencies = new List<double[]>
{
new double[] {1, 2},
new double[] {2, 2},
new double[] {0.7, 3.5}
};
var baseStepList = (new JobPlanBuilder()).GetBasePlan(resourceArray, jobArr, dependencies);
//Act
var result = (new SimplexInputBuilder()).BuildFromBasePlan(baseStepList, jobArr, resourceArray, dependencies);
//Assert
NotNull(result);
AreEqual(new double[] {1, 1, 1, 0, 0, 0, 0}, result.ObjFuncCoeffs.ToArray());
AreEqual(ObjectiveFunctionType.Min, result.Type);
AreEqual(27, result.EqualityCoeffs.RowCount);
//Step1
//intencity
AreEqual(new double[] {1, 0, 0, -1, 0, 0, 0}, result.EqualityCoeffs.Row(7).ToArray());
AreEqual(new double[] {-10, 0, 0, 1, 0, 0, 0}, result.EqualityCoeffs.Row(8).ToArray());
AreEqual(new double[] {1, 0, 0, 0, -1, 0, 0}, result.EqualityCoeffs.Row(9).ToArray());
AreEqual(new double[] {-10, 0, 0, 0, 1, 0, 0}, result.EqualityCoeffs.Row(10).ToArray());
//resources
AreEqual(new double[] {-20, 0, 0, 1, 0.7, 0, 0}, result.EqualityCoeffs.Row(11).ToArray());
AreEqual(new double[] {-50, 0, 0, 2, 3.5, 0, 0}, result.EqualityCoeffs.Row(12).ToArray());
//Step2
//intencity
AreEqual(new double[] {0, 1, 0, 0, 0, -1, 0}, result.EqualityCoeffs.Row(13).ToArray());
AreEqual(new double[] {0, -10, 0, 0, 0, 1, 0}, result.EqualityCoeffs.Row(14).ToArray());
//resources
AreEqual(new double[] {0, -20, 0, 0, 0, 1, 0}, result.EqualityCoeffs.Row(15).ToArray());
AreEqual(new double[] {0, -50, 0, 0, 0, 2, 0}, result.EqualityCoeffs.Row(16).ToArray());
//Step3
//intencity
AreEqual(new double[] {0, 0, 1, 0, 0, 0, -1}, result.EqualityCoeffs.Row(17).ToArray());
AreEqual(new double[] {0, 0, -10, 0, 0, 0, 1}, result.EqualityCoeffs.Row(18).ToArray());
//resources
AreEqual(new double[] {0, 0, -20, 0, 0, 0, 2}, result.EqualityCoeffs.Row(19).ToArray());
AreEqual(new double[] {0, 0, -50, 0, 0, 0, 2}, result.EqualityCoeffs.Row(20).ToArray());
//Full work volumes
AreEqual(new double[] {0, 0, 0, 1, 0, 1, 0}, result.EqualityCoeffs.Row(21).ToArray());
AreEqual(100, result.FreeTerms.ToArray()[21]);
AreEqual(new double[] {0, 0, 0, -1, 0, -1, 0}, result.EqualityCoeffs.Row(22).ToArray());
AreEqual(-100, result.FreeTerms.ToArray()[22]);
AreEqual(new double[] {0, 0, 0, 0, 0, 0, 1}, result.EqualityCoeffs.Row(23).ToArray());
AreEqual(50, result.FreeTerms.ToArray()[23]);
AreEqual(new double[] {0, 0, 0, 0, 0, 0, -1}, result.EqualityCoeffs.Row(24).ToArray());
AreEqual(-50, result.FreeTerms.ToArray()[24]);
AreEqual(new double[] {0, 0, 0, 0, 1, 0, 0}, result.EqualityCoeffs.Row(25).ToArray());
AreEqual(50, result.FreeTerms.ToArray()[25]);
AreEqual(new double[] {0, 0, 0, 0, -1, 0, 0}, result.EqualityCoeffs.Row(26).ToArray());
AreEqual(-50, result.FreeTerms.ToArray()[26]);
}
internal double CalcMaxPossibleIntensity(Job jobToExecute, IEnumerable<Resource> resourcesForStep)
{
var maxJobIntensity = Double.MaxValue;
foreach (var resource in resourcesForStep)
{
var jobResourceDependency = jobToExecute.ResourceDependencies.FirstOrDefault(d => d.Resource.Number == resource.Number);
if (jobResourceDependency == null) continue;
var resourceDependencyValue = jobResourceDependency.Value;
var upperbound = resourceDependencyValue*jobToExecute.MaximumIntensity;
maxJobIntensity = Math.Min(maxJobIntensity,
(upperbound <= resource.Value ? jobToExecute.MaximumIntensity : (resource.Value / resourceDependencyValue)));
}
//Check if we are not below minimum intensity
return maxJobIntensity < jobToExecute.MinimumIntensity ? 0 : maxJobIntensity;
}
public void ShouldCalculateMaxIntensity1()
{
//Arrange
var firstJob = new Job(1, 10, null, .1, 2);
var resource1 = new Resource(1, 20);
var dependency = new JobResourceDependency(firstJob, resource1, 7);
firstJob.ResourceDependencies.Add(dependency);
var planBuilder = new JobPlanBuilder();
//Act
var maxIntensity = planBuilder.CalcMaxPossibleIntensity(firstJob, new[] {resource1});
//Assert
True(maxIntensity.FloatEquals(2));
}
protected bool Equals(Job other)
{
return Number == other.Number;
}
//TODO: This recursion can cause stack overflow if we will have incorrect configuration, check it.
//TODO: Also make it lazy field of job instance, not static, assign after we compute it one time. Will reduce number of recursive calls significantly
public static double GetFullVolumeWithDependantJobs(Job job)
{
var dependantVolume = 0.0;
if (job.NumberOfDependants != 0)
{
dependantVolume += job.DependantJobs.Sum(depJob => GetFullVolumeWithDependantJobs(depJob));
}
return job.FullWorkVolume+dependantVolume;
}
