public ParameterForm()
{
InitializeComponent();
_parameterId = -1;
_model = null;
Text = "Ошибка! Вызван неверный конструктор!";
}
public MainCriterionMethodResult FindDecision(Model model, TId mainCriterionId)
{
// Сюда приходит модель с уже отсеянными по
// критериальным ограничениям экспериментами
// Остается только отсортировать их по
// главному критерию
var result = new MainCriterionMethodResult("Метод главного критерия", mainCriterionId);
List <SortableDouble> sortedExperiments = model.Experiments.Values.Select <Experiment, SortableDouble>(
e => new SortableDouble()
{
Direction = model.Criteria[mainCriterionId].SortDirection, Id = e.Id, Value = e.CriterionValues[mainCriterionId]
}
).ToList();
sortedExperiments.Sort();
foreach (SortableDouble sortedExperiment in sortedExperiments)
{
result.SortedPoints.Add(sortedExperiment.Id);
}
return(result);
}
/// <summary>
/// 删除Node
/// </summary>
public void DeleteNode(TreeNode node)
{
ItemNode item = (ItemNode)node;
string name = item[TId.ToString()].ToString();
DeleteNode(Nodes, name);
}
public CriteriaListItem(
string text,
TId criterionId)
{
Text = text;
CriterionId = criterionId;
}
private bool ParseUserValues()
{
foreach (DataGridViewRow row in dgvData.Rows)
{
TId critId = (TId)row.Cells[0].Value;
double critValue = double.NaN;
var critInput = (string)row.Cells[2].Value;
if (string.IsNullOrEmpty(critInput))
{
MessageBoxHelper.ShowExclamation("Для критерия '" + _criteria[critId].Name + "' не введено значение!");
return(false);
}
try
{
critValue = Convert.ToDouble(critInput);
}
catch (Exception ex)
{
MessageBoxHelper.ShowExclamation(
"Не удалось преобразовать введенное для критерия '" +
_criteria[critId].Name + "' значение в число!" +
"\nОригинальное сообщение: " + ex.Message);
return(false);
}
_idealPt[critId] = critValue;
}
return(true);
}
/// <summary>
/// 更新Node
/// </summary>
public void UpdateNode(TreeNode node)
{
ItemNode item = (ItemNode)node;
string name = item[TId.ToString()].ToString();
UpdateNode(Nodes, item.DataRow, name);
}
/// <summary>
/// Метод для применения критериальных ограничений к
/// набору экспериментов в оптимизационной модели
/// </summary>
/// <param name="model">Модель, к которой они должны быть
/// применены</param>
public void ApplyCriterialConstraints(ref Model model)
{
// Сделаем все эксперименты активными
foreach (Experiment exp in model.Experiments.Values)
{
exp.IsActive = true;
}
// Проверим по очереди все ограничения
foreach (CriterialConstraint constr in this)
{
TId critId = constr.CriterionId;
// Проверим все эксперименты на соответствие
// данному ограничению
foreach (Experiment exp in model.Experiments.Values)
{
// Проверять есть смысл, только если эксперимент
// активен, потому что если он неактивен, то
// значит не прошел по другому ограничению и нечего
// тратить на него время
if (exp.IsActive)
{
double expCriterionValue = exp.CriterionValues[critId];
if (!Comparer.CompareValuesWithSign(
expCriterionValue,
constr.Value,
constr.Relation))
{
exp.IsActive = false;
}
}
}
}
}
public CriterialConstraintForm(
Dictionary <TId, Criterion> criteria,
TId mainCriterionId,
CriterialConstraint constraint)
{
InitializeComponent();
this._constraint = constraint;
this._criteria = criteria;
this._mainCriterionId = mainCriterionId;
this.Text = "Редактировать критериальное ограничение";
this.FillCriteriaList();
this.FillSignsList();
this.nudConstraintValue.DecimalPlaces = Program.ApplicationSettings.ValuesDecimalPlaces;
this.SelectProperCriterion();
this.cmbConstraintSign.SelectedItem = RelationManager.GetRelationName(this._constraint.Relation);
try
{
this.nudConstraintValue.Value = Convert.ToDecimal(this._constraint.Value);
}
catch (ArgumentOutOfRangeException ex)
{
MessageBoxHelper.ShowError("'Value' of 'Constraint' class object is out of range\nOriginal message: " + ex.Message);
this.DialogResult = DialogResult.Cancel;
this.Close();
}
}
private void btnRefresh_Click(object sender, EventArgs e)
{
bool valuesOk = true;
foreach (DataGridViewRow row in this.dgvConcessions.Rows)
{
// Идентификатор критерия, для которого будет задана уступка,
// считанная из этого рядка
TId critId = (TId)row.Cells[0].Value;
// Считаем и превратим в число значение уступки
string concessionValueString = row.Cells[2].Value.ToString().Trim();
if (string.IsNullOrEmpty(concessionValueString))
{
break;
}
double concessionValue = double.NaN;
try
{
concessionValue = Convert.ToDouble(concessionValueString);
}
catch (Exception ex)
{
MessageBoxHelper.ShowError(
"Не удалось преобразовать в число значение уступки для критерия '" +
this._model.Criteria[critId].Name + "'\nОригинальное сообщение: " +
ex.Message);
valuesOk = false;
break;
}
// Проверим, положительное ли значение уступки - оно должно задаваться по
// абсолютной величине
if (concessionValue < 0)
{
DialogResult result = MessageBox.Show("Значение уступки, введенное для критерия '" + this._model.Criteria[critId].Name + "', отрицательное, а должно быть положительным\nИзменить знак?", Program.ApplicationSettings.ApplicationName, MessageBoxButtons.YesNo, MessageBoxIcon.Question);
if (result == DialogResult.Yes)
{
concessionValue *= -1;
row.Cells[2].Value = concessionValue.ToString(SettingsManager.Instance.DoubleStringFormat);
}
else
{
valuesOk = false;
break;
}
}
// Теперь, кажется, все в порядке, можно применять это значение
this._concessions[critId].Concession = concessionValue;
this._concessions[critId].IsUsable = true;
}
// Когда все нужные значения прочитаны, можно решить задачу
// методом последовательных уступок
if (valuesOk)
{
this.FindDecision();
}
}
private void RefreshBionicModel(TId fitnessCriterionId)
{
ClearBionicModel();
ModelsConverterSettings conversionSettings = new ModelsConverterSettings()
{
FitnessCriterionId = fitnessCriterionId,
NeighborhoodSizePercent = Program.ApplicationSettings.NeighborhoodSizePercent,
UseRecordPoint = Program.ApplicationSettings.UseRecordPoint
};
try
{
bionicModel = ModelsConverter.ModelToBionicModel(optModel, conversionSettings);
}
catch (Exception ex)
{
// TODO: Move application name to settings
MessageBox.Show(ex.Message, "opt.Bionic", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
if (bionicModel == null)
{
// TODO: Handle this properly
return;
}
ListParameters();
}
public ParameterForm(Model model, TId parameterId)
{
InitializeComponent();
_parameterId = parameterId;
_model = model;
Text = "Редактировать оптимизируемый параметр";
nudParameterMinValue.DecimalPlaces = Program.ApplicationSettings.ValuesDecimalPlaces;
nudParameterMaxValue.DecimalPlaces = Program.ApplicationSettings.ValuesDecimalPlaces;
// Заполним поля значениями
Parameter parameter = _model.Parameters[_parameterId];
txtParameterName.Text = parameter.Name;
txtParameterVariableIdentifier.Text = parameter.VariableIdentifier;
try
{
nudParameterMinValue.Value = Convert.ToDecimal(parameter.MinValue);
nudParameterMaxValue.Value = Convert.ToDecimal(parameter.MaxValue);
}
catch (ArgumentOutOfRangeException ex)
{
MessageBoxHelper.ShowError("'MinValue' or 'MaxValue' of 'Parameter' class object is out of range\nOriginal message: " + ex.Message);
DialogResult = DialogResult.Cancel;
Close();
}
}
public ConstraintForm(
Model model,
TId constraintId)
{
InitializeComponent();
this._model = model;
this._constraintId = constraintId;
this.Text = "Редактировать функциональное ограничение";
this.FillSignsList();
this.nudConstraintValue.DecimalPlaces = Program.ApplicationSettings.ValuesDecimalPlaces;
#if DUMMY
this.DummyMode();
#endif
// Заполним поля данными
Constraint constraint = this._model.FunctionalConstraints[this._constraintId];
this.txtConstraintName.Text = constraint.Name;
this.txtConstraintVariableIdentifier.Text = constraint.VariableIdentifier;
this.cmbConstraintSign.SelectedItem = RelationManager.GetRelationName(constraint.ConstraintRelation);
try
{
this.nudConstraintValue.Value = Convert.ToDecimal(constraint.Value);
}
catch (ArgumentOutOfRangeException ex)
{
MessageBoxHelper.ShowError("'Value' of 'Constraint' class object is out of range\nOriginal message: " + ex.Message);
this.DialogResult = DialogResult.Cancel;
this.Close();
}
this.txtConstraintExpression.Text = constraint.Expression;
}
private string CreateText(DataRow dr)
{
string text = null;
for (int i = 0; i < _items.Count; i++)
{
if (_items[i].Type == TreeItemType.Text)
{
text = string.Format("{0}{1},", text, dr[_items[i].Name]);
}
else
{
text = string.Format("{0}Image,", text);
}
}
if (text == null)
{
text = dr[TId.ToString()].ToString();
}
else
{
text = text.TrimEnd(',');
}
return(text);
}
public ConstraintForm()
{
InitializeComponent();
this._model = null;
this._constraintId = -1;
this.Text = "Ошибка! Вызван неверный конструктор!";
}
public CriterionComboBoxItem(
TId critId,
string critName)
{
this.criterionId = critId;
this.criterionName = critName;
}
/// <summary>
/// Метод для установки UI в состояние, пригодное для
/// ввода/просмотра значений функции полезности
/// </summary>
/// <param name="critArrayId">Индекс критерия в
/// МАССИВЕ КРИТЕРИЕВ this._modelCriteria</param>
private void SetUtilityFunctionUI(TId critArrayId)
{
Criterion crit = this._modelCriteria[critArrayId];
UtilityFunction utFunc = this._utFuncs[crit.Id];
// ХАРДКОД ahead !!! мне так стыдно
if (utFunc.FixedPoints.Count != 10)
{
MessageBoxHelper.ShowError("Фиксированных точек больше или меньше, чем нужно!");
}
this.lblCriterionName.Text = crit.Name;
int fpCounter = 0;
foreach (KeyValuePair <double, double> ufPoint in utFunc.FixedPoints)
{
this._trackBars[fpCounter].Value = Convert.ToInt32(ufPoint.Value * 100);
this._critValLabels[fpCounter].Text = ufPoint.Key.ToString(SettingsManager.Instance.DoubleStringFormat);
this._uFValLabels[fpCounter].Text = ufPoint.Value.ToString("F2");
// Запомним, какой из фиксированных точек соответствуют данные
// контролы
this._trackBars[fpCounter].Tag = ufPoint.Key;
fpCounter++;
}
// Перерисуем графичек
UtilityFunctionDrawer.DrawUtilityFunction(
this.pbUtilityFunction.CreateGraphics(),
this._utFuncs[this._currentCriterionId]);
}
public CriterionForm()
{
InitializeComponent();
this._model = null;
this._criterionId = -1;
this.Text = "Ошибка! Вызван неверный конструктор!";
}
/// <summary>
/// Метод добавляет в коллекцию функций полезности
/// новую функцию полезности С КОПИРОВАНИЕМ
/// </summary>
/// <param name="utilityFunctionValues">Словарь со значениями функции полезности</param>
/// <param name="criterionId">ID критерия оптимальности, для которого были
/// найдены значения функции полезности</param>
public void AddUtilityFunction(
Dictionary <TId, double> utilityFunctionValues,
TId criterionId)
{
_utilityFunctionValues.Add(
criterionId,
new Dictionary <TId, double>(utilityFunctionValues));
}
public static Expression <Func <TAggregateRoot, bool> > GetEqual(TId value)
{
var findValue = Expression.Constant(value, typeof(TId));
var compareExp = Expression.Equal(PropertyExpress, findValue);
var exp = Expression.Lambda <Func <TAggregateRoot, bool> >(compareExp, ArgumentExpress);
return(exp);
}
public IActionResult DeleteEmloyee([FromBody] TId tId)
{
var employee = _db.Users.Find(tId.Id);
_db.Users.Remove(employee);
_db.SaveChanges();
return(Json(true));
}
public Instance(TId modelId)
{
_modelId = modelId;
_spout = new Subject <IObservable <TModel> >();
_subject = new BehaviorSubject <TModel>(value: null);
_spout.Switch().Subscribe(OnNext);
}
public RegisteredLifetimeScope(ILifetimeScope parentScope, object tag, TId id, LifetimeScopeConfigurator <TId> configurator)
{
_parentScope = parentScope;
_configurator = configurator;
_tag = tag;
_id = id;
_scope = new Lazy <ILifetimeScope>(CreateScope);
}
/// <summary>
/// Initializes new instance of <see cref="CriterialConstraint"/>
/// </summary>
/// <param name="id">Constraint identifier</param>
/// <param name="criterionId">Identifier of the criterion which current constraint relates to</param>
/// <param name="relation">Constraint relation</param>
/// <param name="value">Constraint value</param>
public CriterialConstraintNew(
TId id,
TId criterionId,
Relation relation,
double value)
: base(id, string.Empty, string.Empty, relation, value)
{
CriterionId = criterionId;
}
public bool Add(IFdbTransaction trans, TId id, TValue value)
{
if (this.Schema.IndexNullValues || value != null)
{
trans.Set(this.Subspace[value, id], Slice.Empty);
return(true);
}
return(false);
}
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();
}
public ParameterForm(Model model)
{
InitializeComponent();
_parameterId = -1;
_model = model;
Text = "Новый оптимизируемый параметр";
nudParameterMinValue.DecimalPlaces = Program.ApplicationSettings.ValuesDecimalPlaces;
nudParameterMaxValue.DecimalPlaces = Program.ApplicationSettings.ValuesDecimalPlaces;
}
private void cmbMainCriterion_SelectedIndexChanged(object sender, EventArgs e)
{
TId newSelectionId =
((CriterionComboBoxItem)this.cmbMainCriterion.SelectedItem).criterionId;
// Посмотрим, если ли в списке ограничения на выбранный критерий
bool constraintsExist = false;
foreach (CriterialConstraint constr in this._criterialConstraints)
{
if (constr.CriterionId == newSelectionId)
{
constraintsExist = true;
break;
}
}
// Если в списке есть ограничения на выбранный критерий,
// скажем пользователю, что они будут удалены и хочет ли
// он сменить главный критерий
if (constraintsExist)
{
string message = "В списке ограничений имеются ограничения на только что " +
"выбранный в выпадающем списке критерий\n" +
"В случае выбора данного критерия в качестве главного эти ограничения " +
"будут удалены\n" +
"Установить выбранный критерий в качестве главного?";
DialogResult result = MessageBox.Show(
message,
Program.ApplicationSettings.ApplicationName,
MessageBoxButtons.YesNo,
MessageBoxIcon.Question);
if (result == DialogResult.Yes)
{
this._mainCriterionId = newSelectionId;
this.UpdateCriterialConstraints();
}
else
{
foreach (object item in this.cmbMainCriterion.Items)
{
TId itemCritId = ((CriterionComboBoxItem)item).criterionId;
if (itemCritId == this._mainCriterionId)
{
this.cmbMainCriterion.SelectedItem = item;
break;
}
}
}
}
else
{
// Если нет, то просто сменим критерий
this._mainCriterionId = newSelectionId;
}
}
private void FillDataGrid()
{
foreach (IdentificationExperiment experiment in ModelStorage.Instance.Model.IdentificationExperiments.Values)
{
int ind = this.dgvResults.Rows.Add();
TId idRealExp = experiment.RealExperimentId;
if (idRealExp % 2 != 0)
{
// TODO: Number will be better than ID...
this.dgvResults.Rows[ind].DefaultCellStyle.BackColor = Color.LightGray;
}
this.dgvResults[2, ind].Value = ModelStorage.Instance.Model.RealExperiments[idRealExp].Number;
this.dgvResults[3, ind].Value = ModelStorage.Instance.Model.IdentificationExperiments[experiment.Id].Number;
int offset = 4;
int parameterNumber = 0;
foreach (double paramValue in ModelStorage.Instance.Model.RealExperiments[idRealExp].ParameterValues.Values)
{
this.dgvResults[offset + parameterNumber, ind].Value = paramValue.ToString(SettingsManager.Instance.DoubleStringFormat);
parameterNumber++;
}
offset += ModelStorage.Instance.Model.OptimizationParameters.Count;
parameterNumber = 0;
foreach (double paramValue in experiment.IdentificationParameterValues.Values)
{
this.dgvResults[offset + parameterNumber, ind].Value = paramValue.ToString(SettingsManager.Instance.DoubleStringFormat);
parameterNumber++;
}
offset += ModelStorage.Instance.Model.IdentificationParameters.Count;
parameterNumber = 0;
foreach (double critValue in ModelStorage.Instance.Model.RealExperiments[idRealExp].CriterionValues.Values)
{
this.dgvResults[offset + parameterNumber, ind].Value = critValue.ToString(SettingsManager.Instance.DoubleStringFormat);
parameterNumber++;
}
offset += ModelStorage.Instance.Model.Criteria.Count;
parameterNumber = 0;
foreach (double critValue in experiment.MathematicalCriterionValues.Values)
{
this.dgvResults[offset + parameterNumber, ind].Value = critValue.ToString(SettingsManager.Instance.DoubleStringFormat);
parameterNumber++;
}
offset += ModelStorage.Instance.Model.Criteria.Count;
parameterNumber = 0;
foreach (double critValue in experiment.AdequacyCriterionValues.Values)
{
this.dgvResults[offset + parameterNumber, ind].Value = critValue.ToString(SettingsManager.Instance.DoubleStringFormat);
parameterNumber++;
}
}
}
/// <summary>
/// Construct a CachingBuilder.
/// </summary>
protected CachingBuilder(SingleValueTable <TId, TValue> valueTable)
{
ValueTable = valueTable;
// Prepopulate the dictionary that does the caching
for (int i = 0; i < ValueTable.Count; i++)
{
TId id = default(TId).CreateFrom(i + 1);
Entries.Add(ValueTable[id], id);
}
}
/// <summary>
/// Initializes new instance of <see cref="PromotableConstant"/>
/// </summary>
/// <param name="id">Promotable constant identifier</param>
/// <param name="name">Promotable constant name</param>
/// <param name="variableIdentifier">Promotable constant variable identifier</param>
/// <param name="value">Promotable constant value</param>
/// <remarks>New instance is in non-promoted state; MinValue is -1.0, MaxValue is 1.0</remarks>
public PromotableConstant(
TId id,
string name,
string variableIdentifier,
double value)
: base(id, name, variableIdentifier, -1.0, 1.0)
{
Value = value;
IsPromoted = false;
}