public void UpdatePreserveKendallCoefficient(bool preserveKendallCoefficient)
{
var referenceAlternatives = new FinalRanking();
foreach (var finalAlternative in Result.FinalRanking.FinalRankingCollection)
{
foreach (var partialAlternative in arternativesList)
{
if (finalAlternative.Alternative.Name == partialAlternative.Name)
{
referenceAlternatives.FinalRankingCollection.Add(finalAlternative);
}
}
}
var recalculatedMatrix = RecreateMatrix(referenceAlternatives);
restrictionsMatrix = CalculateRestrictions(recalculatedMatrix, referenceAlternatives);
PreserveKendallCoefficient = preserveKendallCoefficient;
UpdateMinMax();
var finalReferenceList = CreateRanking(arrayOfValues, transientMatrix, arternativesList);
var finalReferenceRanking = new FinalRanking(finalReferenceList);
var tau = CalculateKendallCoefficient(finalReferenceRanking);
var restOfReferenceList = CreateRanking(arrayOfValues, otherAlternativesMatrix, otherAlternatives);
var allFinalRankingEntry = finalReferenceList.Concat(restOfReferenceList).ToList();
allFinalRankingEntry = allFinalRankingEntry.OrderByDescending(o => o.Utility).ToList();
for (var i = 0; i < allFinalRankingEntry.Count; i++)
{
allFinalRankingEntry[i].Position = i + 1;
}
Result.FinalRanking.FinalRankingCollection = new ObservableCollection <FinalRankingEntry>(allFinalRankingEntry);
Result.KendallCoefficient = tau;
}
public void Calculate()
{
var heightOfPrimaryMatrix = variantsList[0].Key.CriteriaValuesList.Count;
var height = variantsList.Count;
var width = WidthOfSimplexMatrix(variantsList[0].Key);
List <PartialUtility> partialUtilityList;
transientMatrix = CreateMatrix(arternativesList);
var createdSimplexMatrix = CreateSimplexMatrix(height, width, transientMatrix);
var simplex =
new Simplex(createdSimplexMatrix, basicVariables, vectorCj);
simplex.Run(NumberOfIteration);
solution = simplex.solution;
(partialUtilityList, arrayOfValues) = MakePartialUtilityFunction(solution);
var finalReferenceList = CreateRanking(arrayOfValues, transientMatrix, arternativesList);
var finalReferenceRanking = new FinalRanking(finalReferenceList);
var recalculate = false;
var widthWithoutSlack = width - height - equals.Count;
for (var i = criterionFieldsCount; i < width; i++)
{
if (solution.ContainsKey(i))
{
recalculate = true;
}
}
if (recalculate)
{
var recalculatedMatrix = RecreateMatrix(finalReferenceRanking);
restrictionsMatrix = CalculateRestrictions(recalculatedMatrix, finalReferenceRanking);
}
else
{
restrictionsMatrix = CalculateRestrictions(transientMatrix, finalReferenceRanking);
}
var tau = CalculateKendallCoefficient(finalReferenceRanking);
var restOfReferenceList = CreateRanking(arrayOfValues, otherAlternativesMatrix, otherAlternatives);
var allFinalRankingEntry = finalReferenceList.Concat(restOfReferenceList).ToList();
allFinalRankingEntry = allFinalRankingEntry.OrderByDescending(o => o.Utility).ToList();
for (var i = 0; i < allFinalRankingEntry.Count; i++)
{
allFinalRankingEntry[i].Position = i + 1;
}
Result.PartialUtilityFunctions = partialUtilityList;
UpdateMinMax();
Result.FinalRanking.FinalRankingCollection = new ObservableCollection <FinalRankingEntry>(allFinalRankingEntry);
Result.KendallCoefficient = tau;
}
private double[,] CreateKendallMatrix(FinalRanking ranking)
{
var rankingMatrix = new double[ranking.FinalRankingCollection.Count, ranking.FinalRankingCollection.Count];
for (var row = 0; row < rankingMatrix.GetLength(0); row++)
{
var indexRow = -1;
for (var rowInRanking = 0; rowInRanking < rankingMatrix.GetLength(0); rowInRanking++)
{
if (ranking.FinalRankingCollection[row].Alternative.Name == variantsList[rowInRanking].Key.Name)
{
indexRow = rowInRanking;
break;
}
}
for (var c = 0; c < rankingMatrix.GetLength(1); c++)
{
var indexCol = -1;
for (var colInRanking = 0; colInRanking < rankingMatrix.GetLength(0); colInRanking++)
{
if (ranking.FinalRankingCollection[c].Alternative.Name == variantsList[colInRanking].Key.Name)
{
indexCol = colInRanking;
break;
}
}
if (indexRow == indexCol ||
Math.Round(ranking.FinalRankingCollection[c].Utility - ranking.FinalRankingCollection[row].Utility, 10) >=
DeltaThreshold)
{
rankingMatrix[indexRow, indexCol] = 0;
}
else if (Math.Abs(
Math.Round(ranking.FinalRankingCollection[c].Utility - ranking.FinalRankingCollection[row].Utility, 10)) <
DeltaThreshold)
{
rankingMatrix[indexRow, indexCol] = 0.5;
}
else
{
rankingMatrix[indexRow, indexCol] = 1;
}
}
}
return(rankingMatrix);
}
public double[,] RecreateMatrix(FinalRanking finalRanking)
{
var finalRankingEntryList = finalRanking.FinalRankingCollection;
var matrix = new double[finalRankingEntryList.Count, criterionFieldsCount];
for (var i = 0; i < variantsList.Count; i++)
{
var row = GenerateRow(criterionFieldsCount, finalRankingEntryList[i].Alternative);
for (var j = 0; j < criterionFieldsCount; j++)
{
matrix[i, j] = row[j];
}
}
return(matrix);
}
private double[,] CalculateRestrictions(double[,] recalculatedMatrix, FinalRanking finalRanking)
{
var height = finalRanking.FinalRankingCollection.Count - 2 > 0
? factorialRecursion(variantsList.Count) /
factorialRecursion(variantsList.Count - 2)
: 2;
var matrix = new double[height, criterionFieldsCount + 1];
var extra = -1;
for (var row1 = 0; row1 < variantsList.Count; row1++)
{
for (var row2 = row1; row2 < variantsList.Count; row2++)
{
if (row1 != row2)
{
if (Math.Round(finalRanking.FinalRankingCollection[row1].Utility - finalRanking.FinalRankingCollection[row2].Utility,
14) >=
DeltaThreshold)
{
extra++;
for (var c = 0; c < criterionFieldsCount; c++)
{
matrix[extra, c] = Math.Round(recalculatedMatrix[row1, c] - recalculatedMatrix[row2, c], 14);
}
matrix[extra, matrix.GetLength(1) - 1] = DeltaThreshold;
}
else
{
extra++;
for (var c = 0; c < criterionFieldsCount; c++)
{
matrix[extra, c] = Math.Round(recalculatedMatrix[row1, c] - recalculatedMatrix[row2, c], 14);
}
matrix[extra, matrix.GetLength(1) - 1] = 0;
extra++;
for (var c = 0; c < criterionFieldsCount; c++)
{
matrix[extra, c] = Math.Round(recalculatedMatrix[row2, c] - recalculatedMatrix[row1, c], 14);
}
matrix[extra, matrix.GetLength(1) - 1] = 0;
}
}
}
}
return(matrix);
}
private double CalculateKendallCoefficient(FinalRanking finalReferenceRanking)
{
var matrix1 = CreateKendallMatrix();
var matrix2 = CreateKendallMatrix(finalReferenceRanking);
double lengthBetweenMatrix = 0, tau;
for (var row = 0; row < matrix1.GetLength(0); row++)
{
for (var c = 0; c < matrix1.GetLength(1); c++)
{
lengthBetweenMatrix += Math.Abs(matrix1[row, c] - matrix2[row, c]);
}
}
lengthBetweenMatrix /= 2;
tau = 1 - 4 * lengthBetweenMatrix /
(finalReferenceRanking.FinalRankingCollection.Count * (finalReferenceRanking.FinalRankingCollection.Count - 1));
return(tau);
}
public void ChangeValue(double value, PartialUtility partialUtility, int indexOfPointValue)
{
if (value < partialUtility.PointsValues[indexOfPointValue].MinValue ||
value > partialUtility.PointsValues[indexOfPointValue].MaxValue)
{
throw new ArgumentException("Value not in range", "PointsValues.Y");
}
var count = 0;
var criterionIndex = -1;
for (var numOfCriterion = 0; numOfCriterion < Result.PartialUtilityFunctions.Count; numOfCriterion++)
{
if (Result.PartialUtilityFunctions[numOfCriterion].Criterion.Name == partialUtility.Criterion.Name)
{
criterionIndex = numOfCriterion;
break;
}
else
{
count += Result.PartialUtilityFunctions[numOfCriterion].Criterion.LinearSegments;
}
}
if (indexOfPointValue < partialUtility.PointsValues.Count - 1)
{
if (indexOfPointValue > 0)
{
arrayOfValues[count - 1 + indexOfPointValue + 1] += partialUtility.PointsValues[indexOfPointValue].Y - value;
arrayOfValues[count - 1 + indexOfPointValue] -= partialUtility.PointsValues[indexOfPointValue].Y - value;
partialUtility.PointsValues[indexOfPointValue].Y = value;
Result.PartialUtilityFunctions[criterionIndex] = partialUtility;
}
}
else
{
var currentCount = 0;
var subValue = (partialUtility.PointsValues[indexOfPointValue].Y - value) / (Result.PartialUtilityFunctions.Count - 1);
for (var partialUtilityIndex = 0; partialUtilityIndex < Result.PartialUtilityFunctions.Count; partialUtilityIndex++)
{
currentCount += Result.PartialUtilityFunctions[partialUtilityIndex].Criterion.LinearSegments;
if (partialUtilityIndex != criterionIndex)
{
var pointValue = Result.PartialUtilityFunctions[partialUtilityIndex].PointsValues;
pointValue[pointValue.Count - 1].Y += subValue;
arrayOfValues[currentCount - 1] += subValue;
Result.PartialUtilityFunctions[partialUtilityIndex].PointsValues = pointValue;
}
}
partialUtility.PointsValues[indexOfPointValue].Y -= subValue * (Result.PartialUtilityFunctions.Count - 1);
arrayOfValues[count - 1 + indexOfPointValue] -= subValue * (Result.PartialUtilityFunctions.Count - 1);
Result.PartialUtilityFunctions[criterionIndex] = partialUtility;
}
UpdateMinMax();
var finalReferenceList = CreateRanking(arrayOfValues, transientMatrix, arternativesList);
var finalReferenceRanking = new FinalRanking(finalReferenceList);
var tau = CalculateKendallCoefficient(finalReferenceRanking);
var restOfReferenceList = CreateRanking(arrayOfValues, otherAlternativesMatrix, otherAlternatives);
var allFinalRankingEntry = finalReferenceList.Concat(restOfReferenceList).ToList();
allFinalRankingEntry = allFinalRankingEntry.OrderByDescending(o => o.Utility).ToList();
for (var i = 0; i < allFinalRankingEntry.Count; i++)
{
allFinalRankingEntry[i].Position = i + 1;
}
Result.FinalRanking.FinalRankingCollection = new ObservableCollection <FinalRankingEntry>(allFinalRankingEntry);
Result.KendallCoefficient = tau;
}
public void LoadState(List <PartialUtility> partialUtilityList, List <List <Alternative> > referenceRankingList,
List <Alternative> notRankedAlternatives, Results results, bool preserveKendallCoefficient = true)
{
Result = results;
variantsList = new List <KeyValuePair <Alternative, int> >();
arternativesList = new List <Alternative>();
for (var rank = 0; rank < referenceRankingList.Count; rank++)
{
foreach (var alternative in referenceRankingList[rank])
{
variantsList.Add(new KeyValuePair <Alternative, int>(alternative, rank));
arternativesList.Add(alternative);
}
}
otherAlternatives = notRankedAlternatives;
otherAlternativesMatrix = CreateMatrix(otherAlternatives);
transientMatrix = CreateMatrix(arternativesList);
var cfc = 0;
foreach (var partialUtility in partialUtilityList)
{
cfc += partialUtility.Criterion.LinearSegments;
}
criterionFieldsCount = cfc;
arrayOfValues = new double[criterionFieldsCount];
var count = 0;
for (var numOfCriterion = 0; numOfCriterion < partialUtilityList.Count; numOfCriterion++)
{
var sum = 0.0;
for (var i = 1; i < partialUtilityList[numOfCriterion].PointsValues.Count; i++)
{
var newValue = partialUtilityList[numOfCriterion].PointsValues[i].Y - sum;
arrayOfValues[count] = newValue;
sum += newValue;
count++;
}
}
PreserveKendallCoefficient = preserveKendallCoefficient;
var finalReferenceList = CreateRanking(arrayOfValues, transientMatrix, arternativesList);
var finalReferenceRanking = new FinalRanking(finalReferenceList);
var recalculatedMatrix = RecreateMatrix(finalReferenceRanking);
restrictionsMatrix = CalculateRestrictions(recalculatedMatrix, finalReferenceRanking);
var tau = CalculateKendallCoefficient(finalReferenceRanking);
var restOfReferenceList = CreateRanking(arrayOfValues, otherAlternativesMatrix, otherAlternatives);
var allFinalRankingEntry = finalReferenceList.Concat(restOfReferenceList).ToList();
allFinalRankingEntry = allFinalRankingEntry.OrderByDescending(o => o.Utility).ToList();
for (var i = 0; i < allFinalRankingEntry.Count; i++)
{
allFinalRankingEntry[i].Position = i + 1;
}
Result.PartialUtilityFunctions = partialUtilityList;
UpdateMinMax();
Result.FinalRanking.FinalRankingCollection = new ObservableCollection <FinalRankingEntry>(allFinalRankingEntry);
Result.KendallCoefficient = tau;
}
