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);
}
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 override CustomProperty Clone()
{
IntegralCriterionMethodResult copy = new IntegralCriterionMethodResult()
{
AdditionalData = new Dictionary <TId, double>(this.AdditionalData),
AdditionalDataDescription = this.AdditionalDataDescription,
MethodName = this.MethodName,
SortedPoints = new List <TId>(this.SortedPoints)
};
foreach (KeyValuePair <TId, Dictionary <TId, double> > normalizedCriterion in _normalizedCriteria)
{
copy._normalizedCriteria.Add(normalizedCriterion.Key, new Dictionary <TId, double>(normalizedCriterion.Value));
}
foreach (KeyValuePair <TId, Dictionary <TId, double> > utilityFunctionValue in _utilityFunctionValues)
{
copy._utilityFunctionValues.Add(utilityFunctionValue.Key, new Dictionary <TId, double>(utilityFunctionValue.Value));
}
return(copy);
}
public static void FillDataGridWithUtilityFunction(
Model model,
Dictionary <TId, UtilityFunction> utFuncs,
IntegralCriterionMethodResult result,
DataGridView table,
bool showUtilityFunctionValues)
{
table.SuspendLayout();
table.Rows.Clear();
table.Columns.Clear();
// Колонки для параметров
foreach (KeyValuePair <TId, Parameter> kvp in model.Parameters)
{
var paramCol = new DataGridViewColumn();
paramCol.CellTemplate = new DataGridViewTextBoxCell();
paramCol.SortMode = DataGridViewColumnSortMode.NotSortable;
paramCol.HeaderText = kvp.Value.Name;
paramCol.Name = "param_" + kvp.Key;
paramCol.HeaderCell.ToolTipText = kvp.Value.GetDescription();
table.Columns.Add(paramCol);
}
// Колонки для критериев
foreach (KeyValuePair <TId, Criterion> kvp in model.Criteria)
{
var critCol = new DataGridViewColumn();
critCol.CellTemplate = new DataGridViewTextBoxCell();
critCol.SortMode = DataGridViewColumnSortMode.NotSortable;
critCol.HeaderText = kvp.Value.Name;
critCol.Name = "crit_" + kvp.Key;
critCol.HeaderCell.ToolTipText = kvp.Value.GetDescription();
table.Columns.Add(critCol);
if (showUtilityFunctionValues)
{
var utFuncCol = new DataGridViewColumn();
utFuncCol.CellTemplate = new DataGridViewTextBoxCell();
utFuncCol.SortMode = DataGridViewColumnSortMode.NotSortable;
utFuncCol.CellTemplate.Style.BackColor = Color.PowderBlue;
utFuncCol.HeaderText = kvp.Value.Name + " (Значение Ф.П.)";
utFuncCol.Name = "ut_func_" + kvp.Key;
table.Columns.Add(utFuncCol);
}
}
// Колонки для функциональных ограничения
foreach (KeyValuePair <TId, Constraint> kvp in model.FunctionalConstraints)
{
var constrCol = new DataGridViewColumn();
constrCol.CellTemplate = new DataGridViewTextBoxCell();
constrCol.SortMode = DataGridViewColumnSortMode.NotSortable;
constrCol.HeaderText = kvp.Value.Name;
constrCol.Name = "constr_" + kvp.Key;
constrCol.HeaderCell.ToolTipText = kvp.Value.GetDescription();
table.Columns.Add(constrCol);
}
// Колонка для дополнительных данных
var additionalCol = new DataGridViewColumn();
additionalCol.CellTemplate = new DataGridViewTextBoxCell();
additionalCol.SortMode = DataGridViewColumnSortMode.NotSortable;
additionalCol.HeaderText = result.AdditionalDataDescription;
additionalCol.Name = "additional_col";
table.Columns.Add(additionalCol);
foreach (TId expId in result.SortedPoints)
{
// Добавим рядок
int rowInd = table.Rows.Add();
// Запишем в хедер номер эксперимента
table.Rows[rowInd].HeaderCell.Value = model.Experiments[expId].Number.ToString();
// Запишем в ячейки значения оптимизируемых параметров
foreach (KeyValuePair <TId, double> pvs in model.Experiments[expId].ParameterValues)
{
int colInd = 0;
try
{
colInd = table.Columns["param_" + pvs.Key].Index;
}
catch (Exception ex)
{
MessageBoxHelper.ShowError(ex.Message);
return;
}
table[colInd, rowInd].Value = pvs.Value.ToString(SettingsManager.Instance.DoubleStringFormat);
}
// Запишем в ячейки значения критериев оптимальности
foreach (KeyValuePair <TId, double> pvs in model.Experiments[expId].CriterionValues)
{
int colInd = 0;
try
{
colInd = table.Columns["crit_" + pvs.Key].Index;
}
catch (Exception ex)
{
MessageBoxHelper.ShowError(ex.Message);
return;
}
table[colInd, rowInd].Value = pvs.Value.ToString(SettingsManager.Instance.DoubleStringFormat);
}
// Запишем в ячейки значения нормализованных критериев, если надо
if (showUtilityFunctionValues)
{
foreach (Criterion crit in model.Criteria.Values)
{
int colInd = 0;
try
{
colInd = table.Columns["ut_func_" + crit.Id].Index;
}
catch (Exception ex)
{
MessageBoxHelper.ShowError(ex.Message);
return;
}
table[colInd, rowInd].Value = result.GetUtilityFunction(crit.Id)[expId].ToString(SettingsManager.Instance.DoubleStringFormat);
}
}
// Запишем в ячейки значения ФО
foreach (KeyValuePair <TId, double> pvs in model.Experiments[expId].ConstraintValues)
{
int colInd = 0;
if (table.Columns["constr_" + pvs.Key] != null)
{
colInd = table.Columns["constr_" + pvs.Key].Index;
table[colInd, rowInd].Value = pvs.Value.ToString(SettingsManager.Instance.DoubleStringFormat);
}
}
// Запишем в ячейки дополнительные данные
int colId = 0;
colId = table.Columns["additional_col"].Index;
table[colId, rowInd].Style.BackColor = Color.LightGray;
table[colId, rowInd].Value = result.AdditionalData[expId].ToString(SettingsManager.Instance.DoubleStringFormat);
}
table.ResumeLayout();
}
public IntegralCriterionMethodResult FindDecisionWithUtilityFunction(
Model model,
Dictionary <TId, UtilityFunction> uFunctions)
{
var result = new IntegralCriterionMethodResult("Аддитивный критерий с учетом функции полезности", "Значение аддитивного критерия с учетом функции полезности");
// Найдем значения функций полезности для каждого эксперимента
// по каждому из критериев
foreach (Criterion crit in model.Criteria.Values)
{
var utilityFunctionValues = new Dictionary <TId, double>();
foreach (Experiment exp in model.Experiments.Values)
{
UtilityFunction utFunc = uFunctions[crit.Id];
double criterionValue = exp.CriterionValues[crit.Id];
double utilityFunctionValue = utFunc.GetUtilityFunctionValue(criterionValue);
utilityFunctionValues.Add(exp.Id, utilityFunctionValue);
}
result.AddUtilityFunction(utilityFunctionValues, 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 utilityFunctionValue =
result.GetUtilityFunction(crit.Id)[exp.Id];
utilityFunctionValue *= crit.Weight;
additiveCriterionValue += utilityFunctionValue;
}
additiveCriterion.Add(exp.Id, additiveCriterionValue);
}
}
// Отсортируем результаты по убыванию по значению
// аддитивного критерия (больше - лучше)
List <SortableDouble> sortedAdditiveCriterionValues = additiveCriterion.Select <KeyValuePair <TId, double>, SortableDouble>(
kvp => new SortableDouble()
{
Direction = SortDirection.Descending, 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);
}
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);
}
