Ejemplo n.º 1
0
        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);
        }
Ejemplo n.º 2
0
        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);
        }
Ejemplo n.º 4
0
        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);
        }