private void btnOK_Click(object sender, EventArgs e)
        {
            //get values
            string   constrName = this.txtConstraintName.Text.Trim();
            string   constrVariableIdentifier = this.txtConstraintVariableIdentifier.Text.Trim();
            Relation constrSign  = RelationManager.ParseName(this.cmbConstraintSign.Text);
            double   constrValue = Convert.ToDouble(this.nudConstraintValue.Value);

            //validation
            if (string.IsNullOrEmpty(constrName))
            {
                MessageBoxHelper.ShowExclamation("Введите имя Функционального ограничения");
                return;
            }

            if (!string.IsNullOrEmpty(constrVariableIdentifier))
            {
                if (!VariableIdentifierChecker.RegExCheck(constrVariableIdentifier))
                {
                    MessageBoxHelper.ShowExclamation("Идентификатор переменной должен наинаться только с заглавной или строчной буквы \nлатинского алфавита и содержать заглавные и строчные буквы латинского алфавита,\n цифры и символ подчеркивания");
                    return;
                }

                if (constraint == null || constraint.VariableIdentifier != constrVariableIdentifier)
                {
                    if (model.CheckConstraintVariableIdentifier(constrVariableIdentifier))
                    {
                        MessageBoxHelper.ShowExclamation("Параметр с таким идентификатором переменной уже существует в модели");
                        return;
                    }
                }
            }

            //init
            if (constraint == null)
            {
                TId constrId = model.FunctionalConstraints.GetFreeConsequentId();
                constraint = new Constraint(
                    constrId,
                    constrName,
                    constrVariableIdentifier,
                    constrSign,
                    constrValue,
                    "");
                model.FunctionalConstraints.Add(constraint);
            }
            else
            {
                constraint.Name = constrName;
                constraint.VariableIdentifier = constrVariableIdentifier;
                constraint.ConstraintRelation = constrSign;
                constraint.Value = constrValue;
            }

            this.DialogResult = DialogResult.OK;
            this.Close();
        }
        private void btnOK_Click(object sender, EventArgs e)
        {
            string critName = this.txtCriterionName.Text.Trim();
            string critVariableIdentifier  = this.txtCriterionVariableIdentifier.Text.Trim();
            AdequacyCriterionType critType = AdequacyCriterionTypeManager.ParseName(this.cmbAdequacyCriterionType.Text);

            if (string.IsNullOrEmpty(critName))
            {
                MessageBoxHelper.ShowExclamation("Введите имя критерия оптимальности");
                return;
            }

            if (!string.IsNullOrEmpty(critVariableIdentifier))
            {
                if (!VariableIdentifierChecker.RegExCheck(critVariableIdentifier))
                {
                    MessageBoxHelper.ShowExclamation("Идентификатор переменной должен начинаться только с заглавной или строчной буквы \nлатинского алфавита и содержать заглавные и строчные буквы латинского алфавита,\n цифры и символ подчеркивания");
                    return;
                }

                if (criterion == null || criterion.VariableIdentifier != critVariableIdentifier)
                {
                    if (model.CheckCriterionVariableIdentifier(critVariableIdentifier))
                    {
                        MessageBoxHelper.ShowExclamation("Параметр с таким идентификатором переменной уже существует в модели");
                        return;
                    }
                }
            }

            if (criterion == null)
            {
                TId criterionId = model.Criteria.GetFreeConsequentId();
                criterion = new AdequacyCriterion(
                    criterionId,
                    critName,
                    critVariableIdentifier,
                    critType);
                model.Criteria.Add(criterion);
            }
            else
            {
                criterion.Name = critName;
                criterion.VariableIdentifier = critVariableIdentifier;
                criterion.AdequacyType       = critType;
            }

            this.DialogResult = DialogResult.OK;
            this.Close();
        }
Exemple #3
0
        private void btnOK_Click(object sender, EventArgs e)
        {
            string paramName = txtParameterName.Text.Trim();
            string paramVariableIdentifier = txtParameterVariableIdentifier.Text.Trim();
            double paramMinValue           = Convert.ToDouble(nudParameterMinValue.Value);
            double paramMaxValue           = Convert.ToDouble(nudParameterMaxValue.Value);

            if (string.IsNullOrEmpty(paramName))
            {
                MessageBoxHelper.ShowExclamation("Введите имя оптимизируемого параметра");
                return;
            }

            if (!string.IsNullOrEmpty(paramVariableIdentifier))
            {
                if (!VariableIdentifierChecker.RegExCheck(paramVariableIdentifier))
                {
                    MessageBoxHelper.ShowExclamation("Идентификатор переменной должен наинаться только с заглавной или строчной буквы \nлатинского алфавита и содержать заглавные и строчные буквы латинского алфавита,\n цифры и символ подчеркивания");
                    return;
                }

                if (parameter == null || parameter.VariableIdentifier != paramVariableIdentifier)
                {
                    if (CheckExistence(paramVariableIdentifier))
                    {
                        MessageBoxHelper.ShowExclamation("Параметр с таким идентификатором переменной уже существует в модели");
                        return;
                    }
                }
            }

            if (paramMinValue >= paramMaxValue)
            {
                MessageBoxHelper.ShowExclamation("Минимальное значение оптимизируемого параметра должно быть меньше максимального");
                return;
            }

            //can change if an empty constructor will be - Parameter()
            if (parameter == null)
            {
                TId parameterId = -1;
                switch (parameterType)
                {
                case ParameterType.Identification:
                    parameterId = model.IdentificationParameters.GetFreeConsequentId();
                    break;

                case ParameterType.Optimization:
                    parameterId = model.OptimizationParameters.GetFreeConsequentId();
                    break;
                }

                parameter = new Parameter(
                    parameterId,
                    paramName,
                    paramVariableIdentifier,
                    paramMinValue,
                    paramMaxValue);

                switch (parameterType)
                {
                case ParameterType.Identification:
                    model.IdentificationParameters.Add(parameter);
                    break;

                case ParameterType.Optimization:
                    model.OptimizationParameters.Add(parameter);
                    break;
                }
            }
            else
            {
                parameter.Name = paramName;
                parameter.VariableIdentifier = paramVariableIdentifier;
                parameter.MinValue           = paramMinValue;
                parameter.MaxValue           = paramMaxValue;
            }

            DialogResult = DialogResult.OK;
            Close();
        }
Exemple #4
0
        private void btnOK_Click(object sender, EventArgs e)
        {
            string paramName = txtParameterName.Text.Trim();
            string paramVariableIdentifier = txtParameterVariableIdentifier.Text.Trim();
            double paramMinValue           = Convert.ToDouble(nudParameterMinValue.Value);
            double paramMaxValue           = Convert.ToDouble(nudParameterMaxValue.Value);

            if (string.IsNullOrEmpty(paramName))
            {
                MessageBoxHelper.ShowExclamation("Введите имя оптимизируемого параметра");
                return;
            }

            if (!string.IsNullOrEmpty(paramVariableIdentifier))
            {
                if (!VariableIdentifierChecker.RegExCheck(paramVariableIdentifier))
                {
                    MessageBoxHelper.ShowExclamation("Идентификатор переменной должен начинаться только с заглавной или строчной буквы \nлатинского алфавита и содержать заглавные и строчные буквы латинского алфавита,\n цифры и символ подчеркивания");
                    return;
                }

                if (VariableIdentifierChecker.IsInRestrictedList(paramVariableIdentifier, Program.ApplicationSettings.RestrictedVariableIdentifiers))
                {
                    MessageBoxHelper.ShowExclamation("Идентификатор переменной совпадает с одним из запрещенных вариантов");
                    return;
                }

                if (_parameterId == -1)
                {
                    // Если это новый параметр, то надо безусловно проверить
                    // идентификатор
                    if (_model.CheckParameterVariableIdentifier(paramVariableIdentifier))
                    {
                        MessageBoxHelper.ShowExclamation("Оптимизируемый параметр с таким идентификатором переменной уже существует в модели");
                        return;
                    }
                }
                else
                {
                    // Если параметр редактируется, то если идентификатор
                    // не изменялся, то можно его не проверять
                    if (_model.Parameters[this._parameterId].VariableIdentifier != paramVariableIdentifier &&
                        _model.CheckParameterVariableIdentifier(paramVariableIdentifier))
                    {
                        MessageBoxHelper.ShowExclamation("Оптимизируемый параметр с таким идентификатором переменной уже существует в модели");
                        return;
                    }
                }
            }

            if (paramMinValue >= paramMaxValue)
            {
                MessageBoxHelper.ShowExclamation("Минимальное значение оптимизируемого параметра должно быть меньше максимального");
                return;
            }

            if (_parameterId == -1)
            {
                _parameterId = _model.Parameters.GetFreeConsequentId();
                Parameter parameter = new Parameter(
                    _parameterId,
                    paramName,
                    paramVariableIdentifier,
                    paramMinValue,
                    paramMaxValue);
                _model.Parameters.Add(parameter);

                DialogResult = DialogResult.OK;
                Close();
            }
            else
            {
                Parameter parameter = _model.Parameters[_parameterId];
                parameter.Name = paramName;
                parameter.VariableIdentifier = paramVariableIdentifier;
                parameter.MinValue           = paramMinValue;
                parameter.MaxValue           = paramMaxValue;

                DialogResult = DialogResult.OK;
                Close();
            }
        }
Exemple #5
0
        private void btnOK_Click(object sender, EventArgs e)
        {
            string   constrName = this.txtConstraintName.Text.Trim();
            string   constrVariableIdentifier = this.txtConstraintVariableIdentifier.Text.Trim();
            Relation constrSign  = RelationManager.ParseName(this.cmbConstraintSign.Text);
            double   constrValue = Convert.ToDouble(this.nudConstraintValue.Value);

#if DUMMY
            string constrExpression = string.Empty;
#else
            string constrExpression = this.txtConstraintExpression.Text.Trim();
#endif

            if (string.IsNullOrEmpty(constrName))
            {
                MessageBoxHelper.ShowExclamation("Введите имя Функционального ограничения");
                return;
            }
            if (!string.IsNullOrEmpty(constrVariableIdentifier))
            {
                if (!VariableIdentifierChecker.RegExCheck(constrVariableIdentifier))
                {
                    MessageBoxHelper.ShowExclamation("Идентификатор переменной должен начинаться только с заглавной или строчной буквы \nлатинского алфавита и содержать заглавные и строчные буквы латинского алфавита,\n цифры и символ подчеркивания");
                    return;
                }
                if (VariableIdentifierChecker.IsInRestrictedList(constrVariableIdentifier, Program.ApplicationSettings.RestrictedVariableIdentifiers))
                {
                    MessageBoxHelper.ShowExclamation("Идентификатор переменной совпадает с одним из запрещенных вариантов");
                    return;
                }
                if (this._constraintId == -1)
                {
                    // Если это новое ограничение, то надо безусловно проверить
                    // идентификатор
                    if (this._model.CheckConstraintVariableIdentifier(constrVariableIdentifier))
                    {
                        MessageBoxHelper.ShowExclamation("Функциональное ограничение с таким идентификатором переменной уже существует в модели");
                        return;
                    }
                }
                else
                {
                    // Если ограничение редактируется, то если идентификатор
                    // не изменялся, то можно его не проверять
                    if (this._model.FunctionalConstraints[this._constraintId].VariableIdentifier != constrVariableIdentifier &&
                        this._model.CheckConstraintVariableIdentifier(constrVariableIdentifier))
                    {
                        MessageBoxHelper.ShowExclamation("Функциональное ограничение с таким идентификатором переменной уже существует в модели");
                        return;
                    }
                }
            }

            if (this._constraintId == -1)
            {
                this._constraintId = this._model.FunctionalConstraints.GetFreeConsequentId();
                Constraint constraint = new Constraint(
                    this._constraintId,
                    constrName,
                    constrVariableIdentifier,
                    constrSign,
                    constrValue,
                    constrExpression);
                this._model.FunctionalConstraints.Add(constraint);

                this.DialogResult = DialogResult.OK;
                this.Close();
            }
            else
            {
                Constraint constraint = this._model.FunctionalConstraints[this._constraintId];
                constraint.Name = constrName;
                constraint.VariableIdentifier = constrVariableIdentifier;
                constraint.ConstraintRelation = constrSign;
                constraint.Value      = constrValue;
                constraint.Expression = constrExpression;

                this.DialogResult = DialogResult.OK;
                this.Close();
            }
        }
Exemple #6
0
        private void btnOK_Click(object sender, EventArgs e)
        {
            string        critName = this.txtCriterionName.Text.Trim();
            string        critVariableIdentifier = this.txtCriterionVariableIdentifier.Text.Trim();
            CriterionType critType = CriterionTypeManager.ParseName(this.cmbCriterionType.Text);

#if DUMMY
            string critExpression = string.Empty;
#else
            string critExpression = this.txtCriterionExpression.Text.Trim();
#endif

            if (string.IsNullOrEmpty(critName))
            {
                MessageBoxHelper.ShowExclamation("Введите имя критерия оптимальности");
                return;
            }
            if (!string.IsNullOrEmpty(critVariableIdentifier))
            {
                if (!VariableIdentifierChecker.RegExCheck(critVariableIdentifier))
                {
                    MessageBoxHelper.ShowExclamation("Идентификатор переменной должен начинаться только с заглавной или строчной буквы \nлатинского алфавита и содержать заглавные и строчные буквы латинского алфавита,\n цифры и символ подчеркивания");
                    return;
                }
                if (VariableIdentifierChecker.IsInRestrictedList(critVariableIdentifier, Program.ApplicationSettings.RestrictedVariableIdentifiers))
                {
                    MessageBoxHelper.ShowExclamation("Идентификатор переменной совпадает с одним из запрещенных вариантов");
                    return;
                }
                if (this._criterionId == -1)
                {
                    // Если это новый критерий, то надо безусловно проверить
                    // идентификатор
                    if (this._model.CheckCriterionVariableIdentifier(critVariableIdentifier))
                    {
                        MessageBoxHelper.ShowExclamation("Критерий оптимальности с таким идентификатором переменной уже существует в модели");
                        return;
                    }
                }
                else
                {
                    // Если критерий редактируется, то если идентификатор
                    // не изменялся, то можно его не проверять
                    if (this._model.Criteria[this._criterionId].VariableIdentifier != critVariableIdentifier &&
                        this._model.CheckCriterionVariableIdentifier(critVariableIdentifier))
                    {
                        MessageBoxHelper.ShowExclamation("Критерий оптимальности с таким идентификатором переменной уже существует в модели");
                        return;
                    }
                }
            }

            if (this._criterionId == -1)
            {
                this._criterionId = this._model.Criteria.GetFreeConsequentId();
                Criterion criterion = new Criterion(
                    this._criterionId,
                    critName,
                    critVariableIdentifier,
                    critType,
                    critExpression);
                this._model.Criteria.Add(criterion);

                this.DialogResult = DialogResult.OK;
                this.Close();
            }
            else
            {
                Criterion criterion = this._model.Criteria[this._criterionId];
                criterion.Name = critName;
                criterion.VariableIdentifier = critVariableIdentifier;
                criterion.Type       = critType;
                criterion.Expression = critExpression;

                this.DialogResult = DialogResult.OK;
                this.Close();
            }
        }