public IntegralCriterionMethodResult FindDecision(Model model)
{
var result = new IntegralCriterionMethodResult("Мультипликативный критерий", "Значение мультипликативного критерия");
// Нормализуем критерии и определим их тип
foreach (Criterion crit in model.Criteria.Values)
{
Dictionary <TId, double> normalizedCrit = NormalizationHelper.NormalizeCriterionValues(model.Experiments, crit);
result.AddNormalizedCriterion(normalizedCrit, crit.Id);
}
// Вычислим значения мультипликативного критерия для каждого из
// экспериментов
var multiplicativeCriterion = new Dictionary <TId, double>();
foreach (Experiment exp in model.Experiments.Values)
{
if (exp.IsActive)
{
double multiplicativeCriterionValue = 1;
foreach (Criterion crit in model.Criteria.Values)
{
double normalizedCriterionValue =
result.GetNormalizedCriterion(crit.Id)[exp.Id];
normalizedCriterionValue = Math.Pow(normalizedCriterionValue, crit.Weight);
// Вычислим
multiplicativeCriterionValue *= normalizedCriterionValue;
}
multiplicativeCriterion.Add(exp.Id, multiplicativeCriterionValue);
}
}
// Отсортируем результаты по возрастанию
List <SortableDouble> sortedValues = multiplicativeCriterion.Select <KeyValuePair <TId, double>, SortableDouble>(
kvp => new SortableDouble()
{
Direction = SortDirection.Ascending, Id = kvp.Key, Value = kvp.Value
}
).ToList();
sortedValues.Sort();
// Заполним результаты
foreach (SortableDouble sortedValue in sortedValues)
{
result.SortedPoints.Add(sortedValue.Id);
result.AdditionalData.Add(sortedValue.Id, sortedValue.Value);
}
return(result);
}
private static Dictionary <TId, Experiment> PrepareCriteria(Model model)
{
var experiments = new Dictionary <TId, Experiment>();
foreach (Experiment exp in model.Experiments.Values)
{
if (!exp.IsActive)
{
continue;
}
experiments.Add(exp.Id, new Experiment(exp.Id, exp.Number));
}
foreach (Criterion crit in model.Criteria.Values)
{
foreach (Experiment exp in model.Experiments.Values)
{
if (!exp.IsActive)
{
continue;
}
//if (crit.Type == CriterionType.Maximizing)
//{
// double oldCriterionValue = exp.CriterionValues[crit.Id];
// if (oldCriterionValue == 0.0)
// {
// oldCriterionValue = 0.00001;
// }
// experiments[exp.Id].CriterionValues.Add(crit.Id, 1.0/oldCriterionValue);
//}
//else
//{
experiments[exp.Id].CriterionValues.Add(crit.Id, exp.CriterionValues[crit.Id]);
//}
}
Dictionary <TId, double> normalizedCrit = NormalizationHelper.NormalizeCriterionValues(experiments, crit);
//Normalization.NormalizeCriterion(experiments, crit);
foreach (Experiment exp in experiments.Values)
{
exp.CriterionValues[crit.Id] = normalizedCrit[exp.Id];
}
}
return(experiments);
}
public IntegralCriterionMethodResult FindDecision(Model model)
{
IntegralCriterionMethodResult result = new IntegralCriterionMethodResult("Метод минимакса", "Максимальное из значений локальных критериев");
// Нормализуем критерии
foreach (Criterion criterion in model.Criteria.Values)
{
Dictionary <TId, double> normalizedCrit = NormalizationHelper.NormalizeCriterionValues(model.Experiments, criterion);
result.AddNormalizedCriterion(normalizedCrit, criterion.Id);
}
// Обнаружим максимальные значения
List <SortableDouble> sortedMaxLocalCriterionValues = new List <SortableDouble>(model.Experiments.CountActiveExperiments());
foreach (Experiment experiment in model.Experiments.Values)
{
if (experiment.IsActive)
{
var normalizedCriteriaForExp = new List <double>();
foreach (Criterion crit in model.Criteria.Values)
{
double normalizedCriterionValue = result.GetNormalizedCriterion(crit.Id)[experiment.Id];
normalizedCriterionValue *= crit.Weight;
normalizedCriteriaForExp.Add(normalizedCriterionValue);
}
double maxLocalCriterion = normalizedCriteriaForExp.Max();
sortedMaxLocalCriterionValues.Add(new SortableDouble()
{
Direction = SortDirection.Ascending, Id = experiment.Id, Value = maxLocalCriterion
});
}
}
sortedMaxLocalCriterionValues.Sort();
// Заполним результаты
foreach (SortableDouble sortedMaxLocalCriterionValue in sortedMaxLocalCriterionValues)
{
result.SortedPoints.Add(sortedMaxLocalCriterionValue.Id);
result.AdditionalData.Add(sortedMaxLocalCriterionValue.Id, sortedMaxLocalCriterionValue.Value);
}
return(result);
}
public IntegralCriterionMethodResult FindDecision(Model model)
{
var result =
new IntegralCriterionMethodResult("Аддитивный критерий", "Значение аддитивного критерия");
// Нормализуем критерии
foreach (Criterion crit in model.Criteria.Values)
{
Dictionary <TId, double> normalizedCrit = NormalizationHelper.NormalizeCriterionValues(model.Experiments, crit);
//Normalization.NormalizeCriterion(model.Experiments, crit);
result.AddNormalizedCriterion(normalizedCrit, crit.Id);
}
// Вычислим значения аддитивного критерия для каждого из
// экспериментов
var additiveCriterion = new Dictionary <TId, double>();
foreach (Experiment exp in model.Experiments.Values)
{
if (exp.IsActive)
{
double additiveCriterionValue = 0;
foreach (Criterion crit in model.Criteria.Values)
{
double normalizedCriterionValue =
result.GetNormalizedCriterion(crit.Id)[exp.Id];
normalizedCriterionValue *= crit.Weight;
//switch (crit.Type)
//{
// case CriterionType.Maximizing:
// additiveCriterionValue -= normalizedCriterionValue;
// break;
// case CriterionType.Minimizing:
additiveCriterionValue += normalizedCriterionValue;
// break;
//}
}
additiveCriterion.Add(exp.Id, additiveCriterionValue);
}
}
// Отсортируем результаты по возрастанию по значению
// аддитивного критерия (меньше - лучше)
List <SortableDouble> sortedAdditiveCriterionValues = additiveCriterion.Select <KeyValuePair <TId, double>, SortableDouble>(
kvp => new SortableDouble()
{
Direction = SortDirection.Ascending, Id = kvp.Key, Value = kvp.Value
}
).ToList();
sortedAdditiveCriterionValues.Sort();
// Заполним результаты
foreach (SortableDouble sortedAdditiveCriterionValue in sortedAdditiveCriterionValues)
{
result.SortedPoints.Add(sortedAdditiveCriterionValue.Id);
result.AdditionalData.Add(sortedAdditiveCriterionValue.Id, sortedAdditiveCriterionValue.Value);
}
return(result);
}