public static ISolution Build(Double fitness, ShiftMatrix m, int evaluatedSolutions, int numberOfItems)
{
var sw = new Stopwatch();
sw.Start();
var r = new int?[m.Days, m.Slots];
for (int day = 0; day < m.Days; day++)
{
for (int slot = 0; slot < m.Slots; slot++)
{
r[day, slot] = null;
}
}
for (int day = 0; day < m.Days; day++)
{
for (int slot = 0; slot < m.Slots; slot++)
{
r[day, slot] = m[day, slot].ChosenItem;
}
}
sw.Stop();
log.DebugFormat("Solution built in {0} ms", sw.ElapsedMilliseconds);
return(new Solution(numberOfItems)
{
Fitness = fitness,
Allocations = r,
EvaluatedSolutions = evaluatedSolutions
});
}
public float Evaluate(ShiftMatrix matrix)
{
for (int item = 0; item < matrix.Items; item++)
{
slotItemOccurrencies[item] = 0;
}
Single value = 0;
for (int slot = 0; slot < matrix.Slots; slot++)
{
for (int day = 0; day < matrix.Days; day++)
{
var all = matrix[day, slot];
if (all.ChosenItem.HasValue)
{
slotItemOccurrencies[all.ChosenItem.Value]++;
}
}
value += Utils.MathUtils.StandardDeviation(slotItemOccurrencies);
for (int item = 0; item < matrix.Items; item++)
{
slotItemOccurrencies[item] = 0;
}
}
var result = 1 - (value / (matrix.Slots * matrix.Items));
Debug.Assert(result >= 0 && result <= 1);
return(result);
}
public ChromosomeProcessor(
ShiftMatrix matrix,
IMatrixEnumerator enumerator,
IList <IConstraintEnforcer> rules)
{
this.matrix = matrix;
this.enumerator = enumerator;
this.rules = rules;
}
public void EnforceConstraint(ShiftMatrix matrix, int day, int slot)
{
if (matrix[day, slot].ChosenItem.HasValue)
{
var chosenItem = matrix[day, slot].ChosenItem.Value;
for (int d = day; d < day + slotLengths[slot]; d++)
{
for (int s = 0; s < matrix.Slots; s++)
{
var all = matrix[day, s];
if ((!all.Processed) && (!compatibleSlots[slot, s]))
{
all.CurrentAptitudes[chosenItem] = 0;
}
}
}
}
}
private void SetNormalizer(ShiftMatrix matrix)
{
//set the normalizer the first time
if ((lastMatrix == null) || !object.ReferenceEquals(matrix, lastMatrix))
{
lastMatrix = matrix;
lastNormalizer = 0;
for (int day = 0; day < matrix.Days; day++)
{
for (int slot = 0; slot < matrix.Slots; slot++)
{
if (!matrix[day, slot].Forced)
{
lastNormalizer += matrix[day, slot].InitialAptitudes.Max();
}
}
}
}
}
private void SetNormalizer(ShiftMatrix matrix)
{
//set the normalizer the first time
if ((lastMatrix == null) || !object.ReferenceEquals(matrix, lastMatrix))
{
lastMatrix = matrix;
lastNormalizer = 0;
for (int day = 0; day < matrix.Days; day++)
{
for (int slot = 0; slot < matrix.Slots; slot++)
{
var all = matrix[day, slot];
if (!all.Forced)
{
lastNormalizer += (slotValues != null ? slotValues[slot] : 1);
}
}
}
}
}
public float Evaluate(ShiftMatrix matrix)
{
Array.Copy(itemStartupEfforts, _itemEfforts, itemStartupEfforts.Length);
for (int day = 0; day < matrix.Days; day++)
{
for (int slot = 0; slot < matrix.Slots; slot++)
{
var all = matrix[day, slot];
if (all.ChosenItem.HasValue)
{
_itemEfforts[all.ChosenItem.Value] += slotWeights[slot] * itemWeights[all.ChosenItem.Value];
}
}
}
var result = 1 - (Utils.MathUtils.StandardDeviation(_itemEfforts) / normalizer);
Debug.Assert(result >= 0 && result <= 1);
return(result);
}
public void EnforceConstraint(ShiftMatrix matrix, int day, int slot)
{
int?chosenItem = matrix[day, slot].ChosenItem;
if (chosenItem.HasValue)
{
int nextDayToEnforce = day + slotLengths[slot];
if (nextDayToEnforce < matrix.Days)
{
for (int s = 0; s < matrix.Slots; s++)
{
var all = matrix[nextDayToEnforce, s];
if (!all.Processed)
{
all.CurrentAptitudes[chosenItem.Value] =
all.CurrentAptitudes[chosenItem.Value]
* multipliers[slot, s];
}
}
}
}
}
public void EnforceConstraint(ShiftMatrix matrix, int day, int slot)
{
if (matrix[day, slot].ChosenItem.HasValue)
{
int item = matrix[day, slot].ChosenItem.Value;
for (int s = 0; s < matrix.Slots; s++)
{
for (int i = 0; i < matrix.Items; i++)
{
if ((item != i) && (slot != s))
{
var all = matrix[day, s];
if (!all.Processed && multipliers[slot, s, item, i] != 1)
{
all.CurrentAptitudes[i] =
all.CurrentAptitudes[i]
* multipliers[slot, s, item, i];
}
}
}
}
}
}
public void EnforceConstraint(ShiftMatrix matrix, int day, int slot)
{
if (matrix[day, slot].ChosenItem.HasValue)
{
var untilDay = day + lengths[slot] - 1;
if (untilDay >= matrix.Days)
{
untilDay = matrix.Days - 1;
}
for (int d = day + 1; d <= untilDay; d++)
{
for (int s = 0; s < matrix.Slots; s++)
{
var all = matrix[d, s];
if (!all.Processed)
{
all.CurrentAptitudes[matrix[day, slot].ChosenItem.Value] = 0;
}
}
}
}
}
public float Evaluate(ShiftMatrix matrix)
{
SetNormalizer(matrix);
Single value = 0;
for (int day = 0; day < matrix.Days; day++)
{
for (int slot = 0; slot < matrix.Slots; slot++)
{
var all = matrix[day, slot];
if ((!all.Forced) && (all.ChosenItem.HasValue))
{
value += all.InitialAptitudes[all.ChosenItem.Value];
}
}
}
var result = value / lastNormalizer;
Debug.Assert(result >= 0 && result <= 1);
return(result);
}
public double Evaluate(ShiftMatrix matrix)
{
return(dimensions.Average(x => x.Evaluate(matrix)));
}
public FitnessFunction(ChromosomeProcessor processor, FitnessEvaluator evaluator, ShiftMatrix matrix)
{
this.processor = processor;
this.evaluator = evaluator;
this.matrix = matrix;
}
public void EnforceConstraint(ShiftMatrix matrix, int day, int slot)
{
if (matrix[day, slot].ChosenItem.HasValue)
{
int item = matrix[day, slot].ChosenItem.Value;
int workingDays = 1;
{
var d = day - 1;
while ((d >= 0) && (workingDays < maxWorkingDays))
{
bool found = false;
for (int s = 0; s < matrix.Slots; s++)
{
if ((matrix[d, s].ChosenItem.HasValue) && (matrix[d, s].ChosenItem.Value == item))
{
found = true;
break;
}
}
if (found)
{
workingDays++;
}
else
{
break;
}
d--;
}
}
if (workingDays > maxWorkingDays)
{
throw new InvalidOperationException();
}
{
if (workingDays == maxWorkingDays)
{
var untilDay = day + restAfterMaxWorkingDaysReached;
if (untilDay >= matrix.Days)
{
untilDay = matrix.Days - 1;
}
for (int d = day + 1; d <= untilDay; d++)
{
for (int s = 0; s < matrix.Slots; s++)
{
if (!matrix[d, s].Processed)
{
matrix[d, s].CurrentAptitudes[item] = 0;
}
}
}
}
}
}
}
public void SetUp()
{
m = new ShiftMatrix(days, slots, items, defApt);
}
