public DecisionResultBase Solve(AlternativesBase alternatives)
{
_alternatives = alternatives;
double[,] normalize = GetNormalizedMatrix();
List <double>[,] discordanceSets = GetDiscordances(normalize);
double[,] concordances = GetConcordances(normalize);
double[,] nonDiscordance = GetNonDiscordanceIndices(discordanceSets, concordances);
double[,] generalPreference = GetGeneralPreferences(concordances, nonDiscordance);
int[,] rangeMatrix = GetResultMatrix(generalPreference);
int[,] finalRange = GetFinalRanking(rangeMatrix);
DecisionResultBase result = new DecisionResultBase();
for (int i = 0; i < _alternatives.Alternatives.Count; ++i)
{
int rank = _alternatives.Alternatives.Count;
for (int j = 0; j < _alternatives.Alternatives.Count; ++j)
{
rank -= finalRange[i, j];
}
result.Ranks.Add(rank);
}
return(result);
}
public DecisionResultBase Solve(AlternativesBase alternatives)
{
_alternatives = alternatives;
double[,] normalizedDecisionMarix = GetNormalizedMatrix();
double[] ranks = GetResultValues(
GetAdditiveValues(normalizedDecisionMarix),
GetMultiplicativeValues(normalizedDecisionMarix)
);
//calculate range with pairwise comparison
DecisionResultBase result = new DecisionResultBase();
for (int i = 0; i < alternatives.Alternatives.Count; ++i)
{
int dominated = 0;
for (int j = 0; j < alternatives.Alternatives.Count; ++j)
{
if (i != j && ranks[i] >= ranks[j])
{
++dominated;
}
}
result.Ranks.Add(alternatives.Alternatives.Count - dominated);
}
return(result);
}
public DecisionResultBase Solve(AlternativesBase alternatives)
{
double epsilon = 1e-3;// epsilon for double comparison
_alternatives = alternatives;
var PreferenceIndex = ComputePreferenceMatrix();
double[,] Flows = ComputeIOFlows(PreferenceIndex, _alternatives.Alternatives.Count);
double [] NetFlows = ComputeNetFlows(Flows, _alternatives.Alternatives.Count);
List <int> Ranks = new List <int>();
for (int i = 0; i < _alternatives.Alternatives.Count; ++i)
{
int Rank = 1;
for (int j = 0; j < _alternatives.Alternatives.Count; ++j)
{
if (i != j && NetFlows[i] - NetFlows[j] < epsilon)
{
++Rank;
}
}
Ranks.Add(Rank);
}
var Result = new DecisionResultBase();
Result.Ranks = Ranks;
return(Result);
}
public DecisionResultBase Solve(AlternativesBase alternatives)
{
_alternatives = alternatives;
double[,] normalizeWeights = GetNormalizedMatrix();
double[] bestAlternative = GetBestAlternative(normalizeWeights);
double[] distances = GetBlockDistances(
normalizeWeights,
bestAlternative
);
DecisionResultBase result = new DecisionResultBase();
for (int i = 0; i < distances.Length; ++i)
{
int rank = distances.Length;
for (int j = 0; j < distances.Length; ++j)
{
if (i != j && distances[i] <= distances[j])
{
--rank;
}
}
result.Ranks.Add(rank);
}
return(result);
}
public DecisionResultBase Solve(AlternativesBase alternatives)
{
_alternatives = alternatives;
//Impacts Matrix
double[,] impact_matrix = CalculateImpactMatrix();
//calculate range with pairwise comparison
DecisionResultBase result = new DecisionResultBase();
for (int i = 0; i < alternatives.Alternatives.Count; ++i)
{
int dominated = 0;
for (int j = 0; j < alternatives.Alternatives.Count; ++j)
{
if (i != j)
{
if (impact_matrix[i, j] - impact_matrix[j, i] >= 0)
{
dominated++;
}
}
}
result.Ranks.Add(alternatives.Alternatives.Count - dominated);
}
return(result);
}
public DecisionResultBase Solve(AlternativesBase alternatives)
{
_alternatives = alternatives;
//Main constant for algorithm
var basis = 1.0 + _configuration.Epsilon;
var intervals = 6;
var factor = Math.Pow(basis, intervals); // = 64 (default)
var root2 = Math.Sqrt(2.0);
double[,] g = new double[_alternatives.Criterias.Count, _alternatives.Alternatives.Count];
int i, j;
for (i = 0; i < _alternatives.Criterias.Count; i++) //i - criteria number
{
var critera = _alternatives.Criterias[i];
var minCriteriaValue = critera.MinValue;
var maxCriteriaValue = critera.MaxValue;
//posible correcting minCriteraValue
//minCriteriaValue += (maxCriteriaValue - minCriteriaValue) / factor;
var deltaCriteraValue = maxCriteriaValue - minCriteriaValue;
for (j = 0; j < _alternatives.Alternatives.Count; j++) // j - alternative number
{
var alternative = _alternatives.Alternatives[j];
if (critera is IQualitativeCriteria)
{
g[i, j] = alternative.Values[i].Value;
}
else
{
double v;
v = Math.Log((alternative.Values[i].Value - minCriteriaValue) * factor / deltaCriteraValue, basis);
g[i, j] = critera.CriteriaDirection == CriteriaDirectionType.Maximization ? 4 + v : 10 - v;
}
}
}
var w = new double[_alternatives.Criterias.Count];
if (IsCriterialWeightsNormalized() == false)
{
double sum = 0;
for (i = 0; i < alternatives.Criterias.Count; i++)
{
w[i] = Math.Pow(root2, _configuration.CriteriaRanks[i]);
sum += w[i];
}
//Normalizing w
for (i = 0; i < alternatives.Criterias.Count; i++)
{
w[i] /= sum;
}
}
else
{
for (i = 0; i < alternatives.Criterias.Count; i++)
{
w[i] = _configuration.CriteriaRanks[i];
}
}
var f = new double[alternatives.Alternatives.Count];
//count alternative ranks
for (j = 0; j < alternatives.Alternatives.Count; j++)
{
f[j] = 0;
for (i = 0; i < alternatives.Criterias.Count; i++)
{
f[j] += w[i] * g[i, j];
}
}
var permutation = new int[alternatives.Alternatives.Count];
var number = new int[alternatives.Alternatives.Count];
for (j = 0; j < alternatives.Alternatives.Count; j++)
{
number[j] = j;
}
for (int j1 = 0; j1 < alternatives.Alternatives.Count - 1; j1++)
{
var maxIndex = j1;
for (int j2 = j1 + 1; j2 < alternatives.Alternatives.Count; j2++)
{
if (f[j2] > f[maxIndex])
{
maxIndex = j2;
}
}
var temp = f[j1];
f[j1] = f[maxIndex];
f[maxIndex] = temp;
var tempNumber = number[j1];
number[j1] = number[maxIndex];
number[maxIndex] = tempNumber;
permutation[number[j1]] = j1;
}
permutation[number[alternatives.Alternatives.Count - 1]] = alternatives.Alternatives.Count - 1;
var result = new DecisionResultBase();
for (j = 0; j < alternatives.Alternatives.Count; j++)
{
result.Ranks.Add(permutation[j] + 1);
}
return(result);
}
