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;
//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;
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[,] 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;
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 List <int> GetRanksTAXONOMY()
{
IDecisionProvider provider = new TAXONOMYDecisionProvider();
IDecisionConfiguration config = new DecisionConfigurationBase
{
CriteriaRanks = _criterias.GetNormalizedWeight()
};
provider.Init(config);
AlternativesBase alternatives = GetAlternativesBases(MethodsEnum.TAXONOMY);
List <int> result = provider.Solve(alternatives).Ranks;
return(result);
}
public List <int> GetRanksWASPAS()
{
WASPASDecisionProvider provider = new WASPASDecisionProvider();
WASPASDecisionConfiguration config = new WASPASDecisionConfiguration
{
CriteriaRanks = _criterias.GetNormalizedWeight(),
Lambda = WASPASLambda
};
provider.Init(config);
AlternativesBase alternatives = GetAlternativesBases(MethodsEnum.WASPAS);
List <int> result = provider.Solve(alternatives).Ranks;
return(result);
}
public List <int> GetRanksPROMETHEE()
{
PROMETHEEDecisionProvider provider = new PROMETHEEDecisionProvider();
PROMETHEEDecisionConfiguration config = new PROMETHEEDecisionConfiguration
{
CriteriaRanks = _criterias.GetNormalizedWeight(),
PreferenceFunctions = _criterias.GetPreferenceFunctions()
};
provider.Init(config);
AlternativesBase alternatives = GetAlternativesBases(MethodsEnum.PROMETHEE);
List <int> result = provider.Solve(alternatives).Ranks;
return(result);
}
public List <int> GetRanksSMART()
{
SMARTDecisionProvider provider = new SMARTDecisionProvider();
SMARTDecisionConfiguration config = new SMARTDecisionConfiguration
{
CriteriaRanks = _criterias.GetWeights(),
Epsilon = 1
};
provider.Init(config);
AlternativesBase alternatives = GetAlternativesBases(MethodsEnum.SMART);
List <int> result = provider.Solve(alternatives).Ranks;
return(result);
}
public List <int> GetRanksELECTRE()
{
ELECTREDecisionProvider provider = new ELECTREDecisionProvider();
ELECTREDecisionConfiguration config = new ELECTREDecisionConfiguration
{
CriteriaRanks = _criterias.GetNormalizedWeight(),
Parameters = _criterias.GetELECTREParameters(),
alpha = ELECTREAlpha,
beta = ELECTREBeta
};
provider.Init(config);
AlternativesBase alternatives = GetAlternativesBases(MethodsEnum.REGIME);
List <int> result = provider.Solve(alternatives).Ranks;
int MinResult = result.Min();
for (int i = 0; i < result.Count; ++i)
{
result[i] -= (MinResult - 1);
}
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);
}
public void TestREGIMEDecision()
{
REGIMEDecisionProvider provider = new REGIMEDecisionProvider();
DecisionConfigurationBase configuration = new DecisionConfigurationBase
{
CriteriaRanks = new List <double> {
0.1, 0.175, 0.25, 0.35, 0.125
}
};
provider.Init(configuration);
var alternatives = new AlternativesBase
{
Criterias = new List <ICriteria>
{
new CriteriaBase {
CriteriaDirection = CriteriaDirectionType.Minimization
}, //cost
new QualitativeCriteriaBase {
CriteriaDirection = CriteriaDirectionType.Maximization
}, //strength
new QualitativeCriteriaBase {
CriteriaDirection = CriteriaDirectionType.Maximization
}, //national reputation
new CriteriaBase {
CriteriaDirection = CriteriaDirectionType.Maximization
}, // capacity
new QualitativeCriteriaBase {
CriteriaDirection = CriteriaDirectionType.Minimization
}, // work hardness
},
Alternatives = new List <AlternativeBase>
{
new AlternativeBase
{
Values = new List <IAlternativeValue>
{
new AlternativeValueBase(3),
new QualitativeAlternativeValue(QualitativeCriteriaEnum.Medium, new QualitativeCriteriaBase()),
new QualitativeAlternativeValue(QualitativeCriteriaEnum.VeryGood, new QualitativeCriteriaBase()),
new AlternativeValueBase(24000),
new QualitativeAlternativeValue(QualitativeCriteriaEnum.FairlyWeak, new QualitativeCriteriaBase())
}
},
new AlternativeBase
{
Values = new List <IAlternativeValue>
{
new AlternativeValueBase(1.2),
new QualitativeAlternativeValue(QualitativeCriteriaEnum.Good, new QualitativeCriteriaBase()),
new QualitativeAlternativeValue(QualitativeCriteriaEnum.Medium, new QualitativeCriteriaBase()),
new AlternativeValueBase(25000),
new QualitativeAlternativeValue(QualitativeCriteriaEnum.Medium, new QualitativeCriteriaBase())
}
},
new AlternativeBase
{
Values = new List <IAlternativeValue>
{
new AlternativeValueBase(1.5),
new QualitativeAlternativeValue(QualitativeCriteriaEnum.VeryGood, new QualitativeCriteriaBase()),
new QualitativeAlternativeValue(QualitativeCriteriaEnum.Poor, new QualitativeCriteriaBase()),
new AlternativeValueBase(32000),
new QualitativeAlternativeValue(QualitativeCriteriaEnum.Excellent, new QualitativeCriteriaBase())
}
}
}
};
var result = provider.Solve(alternatives);
Assert.IsTrue(result.Ranks.Count == 3);
Assert.IsTrue(result.Ranks[0] == 3);
Assert.IsTrue(result.Ranks[1] == 2);
Assert.IsTrue(result.Ranks[2] == 1);
}
public void TestELECTREDecision()
{
ELECTREDecisionProvider provider = new ELECTREDecisionProvider();
ELECTREDecisionConfiguration configuration = new ELECTREDecisionConfiguration
{
CriteriaRanks = new List <double> {
0.179, 0.062, 0.211, 0.017, 0.531
},
alpha = 0.05,
beta = 0.5,
Parameters = new List <ELECTREParameters>
{
new ELECTREParameters {
v = 0.09, p = 0.08, q = 0.02
},
new ELECTREParameters {
v = 0.02, p = 0.015, q = 0.005
},
new ELECTREParameters {
v = 0.11, p = 0.1, q = 0.05
},
new ELECTREParameters {
v = 0.001, p = 0.001, q = 0
},
new ELECTREParameters {
v = 0.35, p = 0.33, q = 0.15
},
}
};
provider.Init(configuration);
var alternatives = new AlternativesBase
{
Criterias = new List <ICriteria>
{
new CriteriaBase {
CriteriaDirection = CriteriaDirectionType.Minimization
}, //cost
new QualitativeCriteriaBase {
CriteriaDirection = CriteriaDirectionType.Maximization
}, //strength
new QualitativeCriteriaBase {
CriteriaDirection = CriteriaDirectionType.Maximization
}, //national reputation
new CriteriaBase {
CriteriaDirection = CriteriaDirectionType.Maximization
}, // capacity
new QualitativeCriteriaBase {
CriteriaDirection = CriteriaDirectionType.Minimization
}, // work hardness
},
Alternatives = new List <AlternativeBase>
{
new AlternativeBase
{
Values = new List <IAlternativeValue>
{
new AlternativeValueBase(3),
new QualitativeAlternativeValue(QualitativeCriteriaEnum.Medium, new QualitativeCriteriaBase()),
new QualitativeAlternativeValue(QualitativeCriteriaEnum.VeryGood, new QualitativeCriteriaBase()),
new AlternativeValueBase(24000),
new QualitativeAlternativeValue(QualitativeCriteriaEnum.FairlyWeak, new QualitativeCriteriaBase())
}
},
new AlternativeBase
{
Values = new List <IAlternativeValue>
{
new AlternativeValueBase(1.2),
new QualitativeAlternativeValue(QualitativeCriteriaEnum.Good, new QualitativeCriteriaBase()),
new QualitativeAlternativeValue(QualitativeCriteriaEnum.Medium, new QualitativeCriteriaBase()),
new AlternativeValueBase(25000),
new QualitativeAlternativeValue(QualitativeCriteriaEnum.Good, new QualitativeCriteriaBase())
}
},
new AlternativeBase
{
Values = new List <IAlternativeValue>
{
new AlternativeValueBase(1.5),
new QualitativeAlternativeValue(QualitativeCriteriaEnum.Excellent, new QualitativeCriteriaBase()),
new QualitativeAlternativeValue(QualitativeCriteriaEnum.FairlyWeak, new QualitativeCriteriaBase()),
new AlternativeValueBase(32000),
new QualitativeAlternativeValue(QualitativeCriteriaEnum.Excellent, new QualitativeCriteriaBase())
}
}
}
};
var result = provider.Solve(alternatives);
Assert.IsTrue(result.Ranks.Count == 3);
Assert.IsTrue(result.Ranks[0] == 3);
Assert.IsTrue(result.Ranks[1] == 2);
Assert.IsTrue(result.Ranks[2] == 1);
}
public void TestWASPASDecision()
{
WASPASDecisionProvider provider = new WASPASDecisionProvider();
WASPASDecisionConfiguration config = new WASPASDecisionConfiguration
{
Lambda = 0.2,
CriteriaRanks = new List <double>
{
0.331, 0.181, 0.369, 0.072, 0.047
}
};
provider.Init(config);
var alternatives = new AlternativesBase
{
Criterias = new List <ICriteria>
{
new CriteriaBase {
CriteriaDirection = CriteriaDirectionType.Minimization
},
new CriteriaBase {
CriteriaDirection = CriteriaDirectionType.Minimization
},
new CriteriaBase {
CriteriaDirection = CriteriaDirectionType.Maximization
},
new CriteriaBase {
CriteriaDirection = CriteriaDirectionType.Minimization
},
new CriteriaBase {
CriteriaDirection = CriteriaDirectionType.Maximization
},
},
Alternatives = new List <AlternativeBase>
{
new AlternativeBase
{
Values = new List <IAlternativeValue>
{
new AlternativeValueBase(0.035),
new AlternativeValueBase(847),
new AlternativeValueBase(0.335),
new AlternativeValueBase(1.760),
new AlternativeValueBase(0.590),
}
},
new AlternativeBase
{
Values = new List <IAlternativeValue>
{
new AlternativeValueBase(0.027),
new AlternativeValueBase(834),
new AlternativeValueBase(0.335),
new AlternativeValueBase(1.680),
new AlternativeValueBase(0.665),
}
},
new AlternativeBase
{
Values = new List <IAlternativeValue>
{
new AlternativeValueBase(0.037),
new AlternativeValueBase(808),
new AlternativeValueBase(0.590),
new AlternativeValueBase(2.400),
new AlternativeValueBase(0.500),
}
},
new AlternativeBase
{
Values = new List <IAlternativeValue>
{
new AlternativeValueBase(0.028),
new AlternativeValueBase(821),
new AlternativeValueBase(0.500),
new AlternativeValueBase(1.590),
new AlternativeValueBase(0.410),
}
}
}
};
var result = provider.Solve(alternatives);
Assert.IsTrue(result.Ranks.Count == 4);
Assert.IsTrue(result.Ranks[0] == 4);
Assert.IsTrue(result.Ranks[1] == 3);
Assert.IsTrue(result.Ranks[2] == 2);
Assert.IsTrue(result.Ranks[3] == 1);
}
public void TestSMARTDecision()
{
SMARTDecisionProvider provider = new SMARTDecisionProvider();
SMARTDecisionConfiguration configuration = new SMARTDecisionConfiguration
{
Epsilon = 1,
CriteriaRanks = new List <double> {
9, 5, 7, 6
}
};
provider.Init(configuration);
var alternatives = new AlternativesBase
{
Criterias = new List <ICriteria>
{
new CriteriaBase {
MinValue = 20000, MaxValue = 40000, CriteriaDirection = CriteriaDirectionType.Minimization
}, //Consumer price
new CriteriaBase {
MinValue = 140, MaxValue = 220, CriteriaDirection = CriteriaDirectionType.Maximization
}, //Maximum speed
new CriteriaBase {
MinValue = 8, MaxValue = 20, CriteriaDirection = CriteriaDirectionType.Minimization
}, //Acceleration 0–100
new CriteriaBase {
MinValue = 200, MaxValue = 2000, CriteriaDirection = CriteriaDirectionType.Maximization
} //Trunk volume of car
},
Alternatives = new List <AlternativeBase>
{
new AlternativeBase
{
Values = new List <IAlternativeValue>
{
new AlternativeValueBase(25000),
new AlternativeValueBase(153),
new AlternativeValueBase(15.3),
new AlternativeValueBase(250)
}
},
new AlternativeBase
{
Values = new List <IAlternativeValue>
{
new AlternativeValueBase(33000),
new AlternativeValueBase(177),
new AlternativeValueBase(12.3),
new AlternativeValueBase(380)
}
},
new AlternativeBase
{
Values = new List <IAlternativeValue>
{
new AlternativeValueBase(40000),
new AlternativeValueBase(199),
new AlternativeValueBase(11.1),
new AlternativeValueBase(480)
}
}
}
};
var result = provider.Solve(alternatives);
Assert.IsTrue(result.Ranks.Count == 3);
Assert.IsTrue(result.Ranks[0] == 3);
Assert.IsTrue(result.Ranks[1] == 2);
Assert.IsTrue(result.Ranks[2] == 1);
}
public void TestPROMETHEEDecision()
{
PROMETHEEDecisionProvider provider = new PROMETHEEDecisionProvider();
PROMETHEEDecisionConfiguration config = new PROMETHEEDecisionConfiguration
{
CriteriaRanks = new List <double> {
1.0 / 6, 1.0 / 6, 1.0 / 6, 1.0 / 6, 1.0 / 6, 1.0 / 6
},
PreferenceFunctions = new List <PreferenceFunction>
{
new PreferenceFunction(
PreferenceFunctionEnum.QuasiCriterion,
new List <double> {
10
}
),
new PreferenceFunction(
PreferenceFunctionEnum.VShapeCriterion,
new List <double> {
30
}
),
new PreferenceFunction(
PreferenceFunctionEnum.LinearCriterion,
new List <double> {
50, 450
}
),
new PreferenceFunction(
PreferenceFunctionEnum.LevelCriterion,
new List <double> {
10, 50
}
),
new PreferenceFunction(
PreferenceFunctionEnum.UsualCriterion,
new List <double>()
),
new PreferenceFunction(
PreferenceFunctionEnum.GaussianCriterion,
new List <double> {
5
}
)
}
};
provider.Init(config);
var Alternatives = new AlternativesBase
{
Criterias = new List <ICriteria>
{
new CriteriaBase {
CriteriaDirection = CriteriaDirectionType.Minimization
},
new CriteriaBase {
CriteriaDirection = CriteriaDirectionType.Maximization
},
new CriteriaBase {
CriteriaDirection = CriteriaDirectionType.Minimization
},
new CriteriaBase {
CriteriaDirection = CriteriaDirectionType.Minimization
},
new CriteriaBase {
CriteriaDirection = CriteriaDirectionType.Minimization
},
new CriteriaBase {
CriteriaDirection = CriteriaDirectionType.Maximization
}
},
Alternatives = new List <AlternativeBase>
{
new AlternativeBase
{
Values = new List <IAlternativeValue>
{
new AlternativeValueBase(80),
new AlternativeValueBase(90),
new AlternativeValueBase(600),
new AlternativeValueBase(54),
new AlternativeValueBase(8),
new AlternativeValueBase(5)
}
},
new AlternativeBase
{
Values = new List <IAlternativeValue>
{
new AlternativeValueBase(65),
new AlternativeValueBase(58),
new AlternativeValueBase(200),
new AlternativeValueBase(97),
new AlternativeValueBase(1),
new AlternativeValueBase(1)
}
},
new AlternativeBase
{
Values = new List <IAlternativeValue>
{
new AlternativeValueBase(83),
new AlternativeValueBase(60),
new AlternativeValueBase(400),
new AlternativeValueBase(72),
new AlternativeValueBase(4),
new AlternativeValueBase(7)
}
},
new AlternativeBase
{
Values = new List <IAlternativeValue>
{
new AlternativeValueBase(40),
new AlternativeValueBase(80),
new AlternativeValueBase(1000),
new AlternativeValueBase(75),
new AlternativeValueBase(7),
new AlternativeValueBase(10)
}
},
new AlternativeBase
{
Values = new List <IAlternativeValue>
{
new AlternativeValueBase(52),
new AlternativeValueBase(72),
new AlternativeValueBase(600),
new AlternativeValueBase(20),
new AlternativeValueBase(3),
new AlternativeValueBase(8)
}
},
new AlternativeBase
{
Values = new List <IAlternativeValue>
{
new AlternativeValueBase(94),
new AlternativeValueBase(96),
new AlternativeValueBase(700),
new AlternativeValueBase(36),
new AlternativeValueBase(5),
new AlternativeValueBase(6)
}
}
}
};
var result = provider.Solve(Alternatives);
Assert.IsTrue(result.Ranks.Count == 6);
Assert.IsTrue(result.Ranks[0] == 6);
Assert.IsTrue(result.Ranks[1] == 2);
Assert.IsTrue(result.Ranks[2] == 5);
Assert.IsTrue(result.Ranks[3] == 3);
Assert.IsTrue(result.Ranks[4] == 1);
Assert.IsTrue(result.Ranks[5] == 4);
}
public List <DataGridViewRow> GetSolutionsAsDataGrid()
{
REGIMEDecisionProvider resultProvider = new REGIMEDecisionProvider();
DecisionConfigurationBase resultBase = new DecisionConfigurationBase
{
CriteriaRanks = GetResultRanks()
};
AlternativesBase resultAlternatives = PrepareResultAlternativesBase();
List <DataGridViewRow> result = new List <DataGridViewRow>();
if (_methods[MethodsEnum.SMART] == true)
{
DataGridViewRow NewRow = new DataGridViewRow();
DataGridViewTextBoxCell TitleCell = new DataGridViewTextBoxCell();
TitleCell.Value = "SMART";
NewRow.Cells.Add(TitleCell);
List <int> localRanks = GetRanksSMART();
for (int i = 0; i < localRanks.Count; ++i)
{
resultAlternatives.Alternatives[i].Values.Add(new AlternativeValueBase(localRanks[i]));
}
foreach (int value in localRanks)
{
DataGridViewTextBoxCell newCell = new DataGridViewTextBoxCell();
newCell.Value = value.ToString();
NewRow.Cells.Add(newCell);
}
result.Add(NewRow);
}
if (_methods[MethodsEnum.REGIME] == true)
{
DataGridViewRow NewRow = new DataGridViewRow();
DataGridViewTextBoxCell TitleCell = new DataGridViewTextBoxCell();
TitleCell.Value = "REGIME";
NewRow.Cells.Add(TitleCell);
List <int> localRanks = GetRanksREGIME();
for (int i = 0; i < localRanks.Count; ++i)
{
resultAlternatives.Alternatives[i].Values.Add(new AlternativeValueBase(localRanks[i]));
}
foreach (int value in localRanks)
{
DataGridViewTextBoxCell newCell = new DataGridViewTextBoxCell();
newCell.Value = value.ToString();
NewRow.Cells.Add(newCell);
}
result.Add(NewRow);
}
if (_methods[MethodsEnum.PROMETHEE] == true)
{
DataGridViewRow NewRow = new DataGridViewRow();
DataGridViewTextBoxCell TitleCell = new DataGridViewTextBoxCell();
TitleCell.Value = "PROMETHEE";
NewRow.Cells.Add(TitleCell);
List <int> localRanks = GetRanksPROMETHEE();
for (int i = 0; i < localRanks.Count; ++i)
{
resultAlternatives.Alternatives[i].Values.Add(new AlternativeValueBase(localRanks[i]));
}
foreach (int value in localRanks)
{
DataGridViewTextBoxCell newCell = new DataGridViewTextBoxCell();
newCell.Value = value.ToString();
NewRow.Cells.Add(newCell);
}
result.Add(NewRow);
}
if (_methods[MethodsEnum.WASPAS] == true)
{
DataGridViewRow NewRow = new DataGridViewRow();
DataGridViewTextBoxCell TitleCell = new DataGridViewTextBoxCell();
TitleCell.Value = "WASPAS";
NewRow.Cells.Add(TitleCell);
List <int> localRanks = GetRanksWASPAS();
for (int i = 0; i < localRanks.Count; ++i)
{
resultAlternatives.Alternatives[i].Values.Add(new AlternativeValueBase(localRanks[i]));
}
foreach (int value in localRanks)
{
DataGridViewTextBoxCell newCell = new DataGridViewTextBoxCell();
newCell.Value = value.ToString();
NewRow.Cells.Add(newCell);
}
result.Add(NewRow);
}
if (_methods[MethodsEnum.TAXONOMY] == true)
{
DataGridViewRow NewRow = new DataGridViewRow();
DataGridViewTextBoxCell TitleCell = new DataGridViewTextBoxCell();
TitleCell.Value = "TAXONOMY";
NewRow.Cells.Add(TitleCell);
List <int> localRanks = GetRanksTAXONOMY();
for (int i = 0; i < localRanks.Count; ++i)
{
resultAlternatives.Alternatives[i].Values.Add(new AlternativeValueBase(localRanks[i]));
}
foreach (int value in localRanks)
{
DataGridViewTextBoxCell newCell = new DataGridViewTextBoxCell();
newCell.Value = value.ToString();
NewRow.Cells.Add(newCell);
}
result.Add(NewRow);
}
if (_methods[MethodsEnum.ELECTRE] == true)
{
DataGridViewRow NewRow = new DataGridViewRow();
DataGridViewTextBoxCell TitleCell = new DataGridViewTextBoxCell();
TitleCell.Value = "ELECTRE";
NewRow.Cells.Add(TitleCell);
List <int> localRanks;
try
{
localRanks = GetRanksELECTRE();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
localRanks = new List <int>();
for (int i = 0; i < _alternatives.Alternatives.Count; ++i)
{
localRanks.Add(1);
}
}
for (int i = 0; i < localRanks.Count; ++i)
{
resultAlternatives.Alternatives[i].Values.Add(new AlternativeValueBase(localRanks[i]));
}
foreach (int value in localRanks)
{
DataGridViewTextBoxCell newCell = new DataGridViewTextBoxCell();
newCell.Value = value.ToString();
NewRow.Cells.Add(newCell);
}
result.Add(NewRow);
}
resultProvider.Init(resultBase);
List <int> ranks = resultProvider.Solve(resultAlternatives).Ranks;
DataGridViewRow NewRowResult = new DataGridViewRow();
DataGridViewTextBoxCell TitleCellResult = new DataGridViewTextBoxCell();
TitleCellResult.Value = "RESULT";
NewRowResult.Cells.Add(TitleCellResult);
foreach (int value in ranks)
{
DataGridViewTextBoxCell newCell = new DataGridViewTextBoxCell();
newCell.Value = value.ToString();
NewRowResult.Cells.Add(newCell);
}
result.Add(NewRowResult);
return(result);
}
