Free cookie consent management tool by TermsFeed Policy Generator

source: trunk/sources/HeuristicLab.Optimizer/3.3/CreateExperimentDialog.cs @ 8474

Last change on this file since 8474 was 8474, checked in by abeham, 10 years ago

#1914:

  • Set name of batch run to "repetitions times optimizer name"
  • Added parent experiment for each instance when there are more than one instance and more than one variation per instance
File size: 37.7 KB
Line 
1#region License Information
2/* HeuristicLab
3 * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
4 *
5 * This file is part of HeuristicLab.
6 *
7 * HeuristicLab is free software: you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation, either version 3 of the License, or
10 * (at your option) any later version.
11 *
12 * HeuristicLab is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
19 */
20#endregion
21
22using System;
23using System.Collections.Generic;
24using System.ComponentModel;
25using System.Globalization;
26using System.Linq;
27using System.Text;
28using System.Threading;
29using System.Windows.Forms;
30using HeuristicLab.Core;
31using HeuristicLab.Data;
32using HeuristicLab.Optimization;
33using HeuristicLab.Parameters;
34using HeuristicLab.Problems.Instances;
35
36namespace HeuristicLab.Optimizer {
37  public partial class CreateExperimentDialog : Form {
38    private enum DialogMode { Normal = 1, DiscoveringInstances = 2, CreatingExperiment = 3, PreparingExperiment = 4 };
39
40    private IOptimizer optimizer;
41    public IOptimizer Optimizer {
42      get { return optimizer; }
43      set {
44        optimizer = value;
45        Experiment = null;
46        okButton.Enabled = optimizer != null;
47        SetTabControlVisibility();
48        FillInstanceTreeViewAsync();
49        FillParametersListView();
50      }
51    }
52
53    public Experiment Experiment { get; private set; }
54
55    private bool createBatchRun;
56    private int repetitions;
57    private Dictionary<IProblemInstanceProvider, HashSet<IDataDescriptor>> instances;
58    private Dictionary<IValueParameter, IntArray> intParameters;
59    private Dictionary<IValueParameter, DoubleArray> doubleParameters;
60    private HashSet<IValueParameter> boolParameters;
61    private Dictionary<IValueParameter, HashSet<IItem>> multipleChoiceParameters;
62    private IItem optionalNullChoice = new BoolValue(); // any item will do
63
64    private StringBuilder failedInstances;
65    private EventWaitHandle backgroundWorkerWaitHandle = new ManualResetEvent(false);
66    private bool suppressTreeViewEventHandling, suppressCheckAllNoneEventHandling;
67
68    public CreateExperimentDialog() : this(null) { }
69    public CreateExperimentDialog(IOptimizer optimizer) {
70      InitializeComponent();
71      instanceDiscoveryProgressLabel.BackColor = instancesTabPage.BackColor;
72      createBatchRun = createBatchRunCheckBox.Checked;
73      repetitions = (int)repetitionsNumericUpDown.Value;
74      // do not set the Optimizer property here, because we want to delay instance discovery to the time when the form loads
75      this.optimizer = optimizer;
76      Experiment = null;
77      okButton.Enabled = optimizer != null;
78
79      instances = new Dictionary<IProblemInstanceProvider, HashSet<IDataDescriptor>>();
80      intParameters = new Dictionary<IValueParameter, IntArray>();
81      doubleParameters = new Dictionary<IValueParameter, DoubleArray>();
82      boolParameters = new HashSet<IValueParameter>();
83      multipleChoiceParameters = new Dictionary<IValueParameter, HashSet<IItem>>();
84    }
85
86    #region Event handlers
87    private void CreateExperimentDialog_Load(object sender, EventArgs e) {
88      SetTabControlVisibility();
89      FillInstanceTreeViewAsync();
90      FillParametersListView();
91    }
92
93    private void CreateExperimentDialog_FormClosing(object sender, FormClosingEventArgs e) {
94      if (experimentCreationBackgroundWorker.IsBusy) {
95        if (DialogResult != System.Windows.Forms.DialogResult.OK) {
96          if (experimentCreationBackgroundWorker.IsBusy) experimentCreationBackgroundWorker.CancelAsync();
97          if (instanceDiscoveryBackgroundWorker.IsBusy) instanceDiscoveryBackgroundWorker.CancelAsync();
98        }
99        e.Cancel = true;
100      }
101    }
102
103    private void okButton_Click(object sender, EventArgs e) {
104      SetMode(DialogMode.CreatingExperiment);
105      experimentCreationBackgroundWorker.RunWorkerAsync();
106      backgroundWorkerWaitHandle.WaitOne(); // make sure the background worker has started before exiting
107    }
108
109    #region Parameters variation
110    private void parametersListView_ItemChecked(object sender, ItemCheckedEventArgs e) {
111      var parameter = (IValueParameter)e.Item.Tag;
112      var isConstrainedValueParameter = typeof(OptionalConstrainedValueParameter<>).Equals(parameter.GetType().GetGenericTypeDefinition())
113        || typeof(ConstrainedValueParameter<>).Equals(parameter.GetType().GetGenericTypeDefinition());
114
115      if (!isConstrainedValueParameter && parameter.Value == null) {
116        if (e.Item.Checked) e.Item.Checked = false;
117        return;
118      }
119
120      if (isConstrainedValueParameter) {
121        if (e.Item.Checked) multipleChoiceParameters.Add(parameter, new HashSet<IItem>());
122        else multipleChoiceParameters.Remove(parameter);
123      }
124
125      var intValue = parameter.Value as ValueTypeValue<int>;
126      if (intValue != null) {
127        if (e.Item.Checked) {
128          IntArray initialValues;
129          if (intValue.Value == int.MinValue)
130            initialValues = new IntArray(new int[] { -100, -50, 5 });
131          else if (intValue.Value == int.MaxValue)
132            initialValues = new IntArray(new int[] { 5, 50, 100 });
133          else if (intValue.Value == 0)
134            initialValues = new IntArray(new int[] { 0, 1, 2 });
135          else if (Math.Abs(intValue.Value) < 10)
136            initialValues = new IntArray(new int[] { intValue.Value - 1, intValue.Value, intValue.Value + 1 });
137          else initialValues = new IntArray(new int[] { intValue.Value / 2, intValue.Value, intValue.Value * 2 });
138          intParameters.Add(parameter, initialValues);
139          intParameters[parameter].Reset += new EventHandler(ValuesArray_Reset);
140        } else intParameters.Remove(parameter);
141      }
142
143      var doubleValue = parameter.Value as ValueTypeValue<double>;
144      if (doubleValue != null) {
145        if (e.Item.Checked) {
146          DoubleArray initialValues;
147          if (doubleValue.Value == double.MinValue)
148            initialValues = new DoubleArray(new double[] { -1, -0.5, 0 });
149          else if (doubleValue.Value == double.MaxValue)
150            initialValues = new DoubleArray(new double[] { 0, 0.5, 1 });
151          else if (doubleValue.Value == 0.0)
152            initialValues = new DoubleArray(new double[] { 0, 0.1, 0.2 });
153          else if (Math.Abs(doubleValue.Value) <= 1.0) {
154            if (doubleValue.Value > 0.9 || (doubleValue.Value < 0.0 && doubleValue.Value > -0.1))
155              initialValues = new DoubleArray(new double[] { doubleValue.Value - 0.2, doubleValue.Value - 0.1, doubleValue.Value });
156            else if (doubleValue.Value < -0.9 || (doubleValue.Value > 0 && doubleValue.Value < 0.1))
157              initialValues = new DoubleArray(new double[] { doubleValue.Value, doubleValue.Value + 0.1, doubleValue.Value + 0.2 });
158            else initialValues = new DoubleArray(new double[] { doubleValue.Value - 0.1, doubleValue.Value, doubleValue.Value + 0.1 });
159          } else initialValues = new DoubleArray(new double[] { doubleValue.Value / 2.0, doubleValue.Value, doubleValue.Value * 2.0 });
160          doubleParameters.Add(parameter, initialValues);
161          doubleParameters[parameter].Reset += new EventHandler(ValuesArray_Reset);
162        } else doubleParameters.Remove(parameter);
163      }
164
165      var boolValue = parameter.Value as ValueTypeValue<bool>;
166      if (boolValue != null) {
167        if (e.Item.Checked) boolParameters.Add(parameter);
168        else boolParameters.Remove(parameter);
169      }
170
171      UpdateVariationsLabel();
172      if (e.Item.Selected) UpdateDetailsView(parameter);
173      else e.Item.Selected = true;
174    }
175
176    private void parametersListView_SelectedIndexChanged(object sender, EventArgs e) {
177      if (parametersListView.SelectedItems.Count == 0) {
178        ClearDetailsView();
179      } else {
180        var parameter = parametersListView.SelectedItems[0].Tag as IValueParameter;
181        UpdateDetailsView(parameter);
182      }
183    }
184
185    private void UpdateDetailsView(IValueParameter parameter) {
186      ClearDetailsView();
187
188      var isOptionalConstrainedValueParameter = typeof(OptionalConstrainedValueParameter<>).IsAssignableFrom(parameter.GetType().GetGenericTypeDefinition());
189      var isConstrainedValueParameter =
190        isOptionalConstrainedValueParameter
191        || typeof(ConstrainedValueParameter<>).Equals(parameter.GetType().GetGenericTypeDefinition());
192
193      if (isConstrainedValueParameter) {
194        detailsTypeLabel.Text = "Choices:";
195        choicesListView.Tag = parameter;
196
197        if (isOptionalConstrainedValueParameter) {
198          choicesListView.Items.Add(new ListViewItem("-") {
199            Tag = optionalNullChoice,
200            Checked = multipleChoiceParameters.ContainsKey(parameter)
201            && multipleChoiceParameters[parameter].Contains(optionalNullChoice)
202          });
203        }
204        dynamic constrainedValuedParameter = parameter;
205        dynamic validValues = constrainedValuedParameter.ValidValues;
206        foreach (var choice in validValues) {
207          choicesListView.Items.Add(new ListViewItem(choice.ToString()) {
208            Tag = choice,
209            Checked = multipleChoiceParameters.ContainsKey(parameter)
210            && multipleChoiceParameters[parameter].Contains(choice)
211          });
212        }
213        choicesListView.Enabled = multipleChoiceParameters.ContainsKey(parameter);
214        detailsTypeLabel.Visible = true;
215        choicesListView.Visible = true;
216        return;
217      }
218
219      if (parameter.Value is ValueTypeValue<bool>) {
220        detailsTypeLabel.Text = "Boolean parameter: True / False";
221        detailsTypeLabel.Visible = true;
222      }
223
224      var intValue = parameter.Value as ValueTypeValue<int>;
225      if (intValue != null) {
226        if (intParameters.ContainsKey(parameter))
227          stringConvertibleArrayView.Content = intParameters[parameter];
228        stringConvertibleArrayView.Visible = true;
229        stringConvertibleArrayView.ReadOnly = !intParameters.ContainsKey(parameter);
230        generateButton.Tag = parameter;
231        generateButton.Enabled = intParameters.ContainsKey(parameter);
232        generateButton.Visible = true;
233        return;
234      }
235
236      var doubleValue = parameter.Value as ValueTypeValue<double>;
237      if (doubleValue != null) {
238        if (doubleParameters.ContainsKey(parameter))
239          stringConvertibleArrayView.Content = doubleParameters[parameter];
240        stringConvertibleArrayView.Visible = true;
241        stringConvertibleArrayView.ReadOnly = !doubleParameters.ContainsKey(parameter);
242        generateButton.Tag = parameter;
243        generateButton.Enabled = doubleParameters.ContainsKey(parameter);
244        generateButton.Visible = true;
245        return;
246      }
247    }
248
249    #region Detail controls
250    private void choiceListView_ItemChecked(object sender, ItemCheckedEventArgs e) {
251      var parameter = (IValueParameter)choicesListView.Tag;
252      if (multipleChoiceParameters.ContainsKey(parameter)) {
253        if (e.Item.Checked) {
254          multipleChoiceParameters[parameter].Add((IItem)e.Item.Tag);
255        } else multipleChoiceParameters[parameter].Remove((IItem)e.Item.Tag);
256
257        UpdateVariationsLabel();
258      }
259    }
260
261    private void generateButton_Click(object sender, EventArgs e) {
262      var parameter = (IValueParameter)generateButton.Tag;
263      bool integerOnly = intParameters.ContainsKey(parameter);
264      double min = 0, max = 1, step = 1;
265      #region Try to calculate some meaningful values
266      if (integerOnly) {
267        int len = intParameters[parameter].Length;
268        if (len > 0) {
269          min = intParameters[parameter].Min();
270          max = intParameters[parameter].Max();
271          step = len >= 2 ? Math.Abs((intParameters[parameter][len - 1] - intParameters[parameter][len - 2])) : 1;
272        }
273      } else {
274        int len = doubleParameters[parameter].Length;
275        if (len > 0) {
276          min = doubleParameters[parameter].Min();
277          max = doubleParameters[parameter].Max();
278          step = len >= 2 ? Math.Abs((doubleParameters[parameter][len - 1] - doubleParameters[parameter][len - 2])) : 1;
279        }
280      }
281      #endregion
282      using (var dialog = new DefineArithmeticProgressionDialog(integerOnly, min, max, step)) {
283        if (dialog.ShowDialog(this) == DialogResult.OK) {
284          var values = dialog.Values;
285          if (integerOnly) {
286            intParameters[parameter].Reset -= new EventHandler(ValuesArray_Reset);
287            intParameters[parameter] = new IntArray(values.Select(x => (int)x).ToArray());
288            intParameters[parameter].Reset += new EventHandler(ValuesArray_Reset);
289            stringConvertibleArrayView.Content = intParameters[parameter];
290          } else {
291            doubleParameters[parameter].Reset -= new EventHandler(ValuesArray_Reset);
292            doubleParameters[parameter] = new DoubleArray(values.ToArray());
293            doubleParameters[parameter].Reset += new EventHandler(ValuesArray_Reset);
294            stringConvertibleArrayView.Content = doubleParameters[parameter];
295          }
296          UpdateVariationsLabel();
297        }
298      }
299    }
300
301    private void ValuesArray_Reset(object sender, EventArgs e) {
302      UpdateVariationsLabel();
303    }
304    #endregion
305    #endregion
306
307    #region Instances
308    private void instancesTreeView_AfterCheck(object sender, TreeViewEventArgs e) {
309      if (!suppressTreeViewEventHandling) {
310        if (e.Node.Nodes.Count > 0) { // provider node was (un)checked
311          SyncProviderNode(e.Node);
312        } else { // descriptor node was (un)checked
313          SyncInstanceNode(e.Node);
314        }
315
316        suppressCheckAllNoneEventHandling = true;
317        try {
318          var treeViewNodes = instancesTreeView.Nodes.OfType<TreeNode>().SelectMany(x => x.Nodes.OfType<TreeNode>());
319          selectAllCheckBox.Checked = treeViewNodes.Count() == instances.SelectMany(x => x.Value).Count();
320          selectNoneCheckBox.Checked = !treeViewNodes.Any(x => x.Checked);
321        } finally { suppressCheckAllNoneEventHandling = false; }
322        UpdateVariationsLabel();
323      }
324    }
325
326    private void SyncProviderNode(TreeNode node) {
327      suppressTreeViewEventHandling = true;
328      try {
329        foreach (TreeNode n in node.Nodes) {
330          if (n.Checked != node.Checked) {
331            n.Checked = node.Checked;
332            SyncInstanceNode(n, false);
333          }
334        }
335      } finally { suppressTreeViewEventHandling = false; }
336    }
337
338    private void SyncInstanceNode(TreeNode node, bool providerCheck = true) {
339      var provider = (IProblemInstanceProvider)node.Parent.Tag;
340      var descriptor = (IDataDescriptor)node.Tag;
341      if (node.Checked) {
342        if (!instances.ContainsKey(provider))
343          instances.Add(provider, new HashSet<IDataDescriptor>());
344        instances[provider].Add(descriptor);
345      } else {
346        if (instances.ContainsKey(provider)) {
347          instances[provider].Remove(descriptor);
348          if (instances[provider].Count == 0)
349            instances.Remove(provider);
350        }
351      }
352      if (providerCheck) {
353        bool allChecked = node.Parent.Nodes.OfType<TreeNode>().All(x => x.Checked);
354        suppressTreeViewEventHandling = true;
355        try {
356          node.Parent.Checked = allChecked;
357        } finally { suppressTreeViewEventHandling = false; }
358      }
359    }
360
361    private void selectAllCheckBox_CheckedChanged(object sender, EventArgs e) {
362      if (!suppressCheckAllNoneEventHandling) {
363        if (selectAllCheckBox.Checked) {
364          suppressCheckAllNoneEventHandling = true;
365          try { selectNoneCheckBox.Checked = false; } finally { suppressCheckAllNoneEventHandling = false; }
366          try {
367            suppressTreeViewEventHandling = true;
368            foreach (TreeNode node in instancesTreeView.Nodes) {
369              if (!node.Checked) {
370                node.Checked = true;
371                SyncProviderNode(node);
372              }
373            }
374          } finally { suppressTreeViewEventHandling = false; }
375        }
376        UpdateVariationsLabel();
377      }
378    }
379
380    private void selectNoneCheckBox_CheckedChanged(object sender, EventArgs e) {
381      if (!suppressCheckAllNoneEventHandling) {
382        if (selectNoneCheckBox.Checked) {
383          suppressCheckAllNoneEventHandling = true;
384          try { selectAllCheckBox.Checked = false; } finally { suppressCheckAllNoneEventHandling = false; }
385          try {
386            suppressTreeViewEventHandling = true;
387            foreach (TreeNode node in instancesTreeView.Nodes) {
388              if (node.Checked) {
389                node.Checked = false;
390                SyncProviderNode(node);
391              }
392            }
393          } finally { suppressTreeViewEventHandling = false; }
394        }
395        UpdateVariationsLabel();
396      }
397    }
398    #endregion
399
400    private void createBatchRunCheckBox_CheckedChanged(object sender, EventArgs e) {
401      repetitionsNumericUpDown.Enabled = createBatchRunCheckBox.Checked;
402      createBatchRun = createBatchRunCheckBox.Checked;
403    }
404
405    private void repetitionsNumericUpDown_Validated(object sender, EventArgs e) {
406      if (repetitionsNumericUpDown.Text == string.Empty)
407        repetitionsNumericUpDown.Text = repetitionsNumericUpDown.Value.ToString();
408      repetitions = (int)repetitionsNumericUpDown.Value;
409    }
410
411    private void experimentsLabel_TextChanged(object sender, EventArgs e) {
412      long number;
413      if (long.TryParse(variationsLabel.Text, NumberStyles.AllowThousands, CultureInfo.CurrentCulture.NumberFormat, out number)) {
414        if (number > 1000) warningProvider.SetError(variationsLabel, "Consider reducing the number of variations!");
415        else warningProvider.SetError(variationsLabel, null);
416      }
417    }
418    #endregion
419
420    #region Helpers
421    private void SetTabControlVisibility() {
422      bool isAlgorithm = optimizer != null && optimizer is IAlgorithm;
423      bool instancesAvailable = isAlgorithm
424        && ((IAlgorithm)optimizer).Problem != null
425        && ProblemInstanceManager.GetProviders(((IAlgorithm)optimizer).Problem).Any();
426      if (instancesAvailable && tabControl.TabCount == 1)
427        tabControl.TabPages.Add(instancesTabPage);
428      else if (!instancesAvailable && tabControl.TabCount == 2)
429        tabControl.TabPages.Remove(instancesTabPage);
430      tabControl.Visible = isAlgorithm;
431      if (isAlgorithm) {
432        variationsLabel.Visible = true;
433        experimentsToCreateDescriptionLabel.Visible = true;
434        Height = 450;
435      } else {
436        variationsLabel.Visible = false;
437        experimentsToCreateDescriptionLabel.Visible = false;
438        Height = 130;
439      }
440    }
441
442    private void FillParametersListView() {
443      parametersListView.Items.Clear();
444      intParameters.Clear();
445      doubleParameters.Clear();
446      boolParameters.Clear();
447      multipleChoiceParameters.Clear();
448
449      if (Optimizer is IAlgorithm) {
450        var parameters = ((IAlgorithm)optimizer).Parameters;
451        foreach (var param in parameters) {
452          var valueParam = param as IValueParameter;
453          if (valueParam != null && (valueParam.Value is ValueTypeValue<bool>
454              || valueParam.Value is ValueTypeValue<int>
455              || valueParam.Value is ValueTypeValue<double>)
456            || typeof(OptionalConstrainedValueParameter<>).IsAssignableFrom(param.GetType().GetGenericTypeDefinition())
457            || typeof(ConstrainedValueParameter<>).IsAssignableFrom(param.GetType().GetGenericTypeDefinition()))
458            parametersListView.Items.Add(new ListViewItem(param.Name) { Tag = param });
459        }
460      }
461    }
462
463    private void FillInstanceTreeViewAsync() {
464      instances.Clear();
465      instancesTreeView.Nodes.Clear();
466
467      if (Optimizer is IAlgorithm && ((IAlgorithm)Optimizer).Problem != null) {
468        SetMode(DialogMode.DiscoveringInstances);
469        instanceDiscoveryBackgroundWorker.RunWorkerAsync();
470      }
471    }
472
473    private void AddOptimizer(IOptimizer optimizer, Experiment experiment) {
474      if (createBatchRun) {
475        var batchRun = new BatchRun(repetitions.ToString() + "x " + optimizer.Name) {
476          Repetitions = repetitions,
477          Optimizer = optimizer
478        };
479        experiment.Optimizers.Add(batchRun);
480      } else {
481        experiment.Optimizers.Add(optimizer);
482      }
483    }
484
485    private int GetNumberOfVariations() {
486      int instancesCount = 1;
487      if (instances.Values.Any())
488        instancesCount = Math.Max(instances.Values.SelectMany(x => x).Count(), 1);
489
490      int intParameterVariations = 1;
491      foreach (var intParam in intParameters.Values) {
492        intParameterVariations *= Math.Max(intParam.Length, 1);
493      }
494      int doubleParameterVariations = 1;
495      foreach (var doubleParam in doubleParameters.Values) {
496        doubleParameterVariations *= Math.Max(doubleParam.Length, 1);
497      }
498      int boolParameterVariations = 1;
499      foreach (var boolParam in boolParameters) {
500        boolParameterVariations *= 2;
501      }
502      int choiceParameterVariations = 1;
503      foreach (var choiceParam in multipleChoiceParameters.Values) {
504        choiceParameterVariations *= Math.Max(choiceParam.Count, 1);
505      }
506
507      return (instancesCount * intParameterVariations * doubleParameterVariations * boolParameterVariations * choiceParameterVariations);
508    }
509
510    private void SetMode(DialogMode mode) {
511      if (InvokeRequired) Invoke((Action<DialogMode>)SetMode, mode);
512      else {
513        createBatchRunCheckBox.Enabled = mode == DialogMode.Normal;
514        repetitionsNumericUpDown.Enabled = mode == DialogMode.Normal;
515        parametersSplitContainer.Enabled = mode == DialogMode.Normal || mode == DialogMode.DiscoveringInstances;
516        selectAllCheckBox.Enabled = mode == DialogMode.Normal;
517        selectNoneCheckBox.Enabled = mode == DialogMode.Normal;
518        instancesTreeView.Enabled = mode == DialogMode.Normal;
519        instancesTreeView.Visible = mode == DialogMode.Normal || mode == DialogMode.CreatingExperiment || mode == DialogMode.PreparingExperiment;
520        okButton.Enabled = mode == DialogMode.Normal;
521        okButton.Visible = mode != DialogMode.CreatingExperiment && mode != DialogMode.PreparingExperiment;
522        cancelButton.Enabled = mode != DialogMode.PreparingExperiment;
523        instanceDiscoveryProgressLabel.Visible = mode == DialogMode.DiscoveringInstances;
524        instanceDiscoveryProgressBar.Visible = mode == DialogMode.DiscoveringInstances;
525        experimentCreationProgressBar.Visible = mode == DialogMode.CreatingExperiment || mode == DialogMode.PreparingExperiment;
526      }
527    }
528
529    private void ClearDetailsView() {
530      stringConvertibleArrayView.Visible = false;
531      stringConvertibleArrayView.Content = null;
532      stringConvertibleArrayView.ReadOnly = true;
533      generateButton.Visible = false;
534      detailsTypeLabel.Visible = false;
535      choicesListView.Items.Clear();
536      choicesListView.Enabled = false;
537      choicesListView.Visible = false;
538    }
539
540    private void UpdateVariationsLabel() {
541      variationsLabel.Text = GetNumberOfVariations().ToString("#,#", CultureInfo.CurrentCulture);
542    }
543
544    #region Retrieve parameter combinations
545    private IEnumerable<Dictionary<IValueParameter, int>> GetIntParameterConfigurations() {
546      var configuration = new Dictionary<IValueParameter, int>();
547      var enumerators = new Dictionary<IValueParameter, IEnumerator<int>>();
548      bool finished;
549      do {
550        foreach (var p in intParameters) {
551          if (!enumerators.ContainsKey(p.Key)) {
552            enumerators[p.Key] = p.Value.GetEnumerator();
553            enumerators[p.Key].MoveNext();
554          }
555          configuration[p.Key] = enumerators[p.Key].Current;
556        }
557        yield return configuration;
558
559        finished = true;
560        foreach (var p in intParameters) {
561          if (!enumerators[p.Key].MoveNext()) {
562            enumerators[p.Key] = p.Value.GetEnumerator();
563            enumerators[p.Key].MoveNext();
564          } else {
565            finished = false;
566            break;
567          }
568        }
569      } while (!finished);
570    }
571
572    private IEnumerable<Dictionary<IValueParameter, double>> GetDoubleParameterConfigurations() {
573      var configuration = new Dictionary<IValueParameter, double>();
574      var enumerators = new Dictionary<IValueParameter, IEnumerator<double>>();
575      bool finished;
576      do {
577        foreach (var p in doubleParameters) {
578          if (!enumerators.ContainsKey(p.Key)) {
579            enumerators[p.Key] = p.Value.GetEnumerator();
580            enumerators[p.Key].MoveNext();
581          }
582          configuration[p.Key] = enumerators[p.Key].Current;
583        }
584        yield return configuration;
585
586        finished = true;
587        foreach (var p in doubleParameters) {
588          if (!enumerators[p.Key].MoveNext()) {
589            enumerators[p.Key] = p.Value.GetEnumerator();
590            enumerators[p.Key].MoveNext();
591          } else {
592            finished = false;
593            break;
594          }
595        }
596      } while (!finished);
597    }
598
599    private IEnumerable<Dictionary<IValueParameter, bool>> GetBoolParameterConfigurations() {
600      var configuration = new Dictionary<IValueParameter, bool>();
601      bool finished;
602      do {
603        finished = true;
604        foreach (var p in boolParameters) {
605          if (!configuration.ContainsKey(p)) configuration.Add(p, false);
606          else {
607            if (configuration[p]) {
608              configuration[p] = false;
609            } else {
610              configuration[p] = true;
611              finished = false;
612              break;
613            }
614          }
615        }
616        yield return configuration;
617      } while (!finished);
618    }
619
620    private IEnumerable<Dictionary<IValueParameter, IItem>> GetMultipleChoiceConfigurations() {
621      var configuration = new Dictionary<IValueParameter, IItem>();
622      var enumerators = new Dictionary<IValueParameter, IEnumerator<IItem>>();
623      bool finished;
624      do {
625        foreach (var p in multipleChoiceParameters.Keys.ToArray()) {
626          if (!enumerators.ContainsKey(p)) {
627            enumerators.Add(p, multipleChoiceParameters[p].GetEnumerator());
628            if (!enumerators[p].MoveNext()) {
629              multipleChoiceParameters.Remove(p);
630              continue;
631            }
632          }
633          configuration[p] = enumerators[p].Current;
634        }
635
636        finished = true;
637        foreach (var p in multipleChoiceParameters.Keys) {
638          if (!enumerators[p].MoveNext()) {
639            enumerators[p] = multipleChoiceParameters[p].GetEnumerator();
640            enumerators[p].MoveNext();
641          } else {
642            finished = false;
643            break;
644          }
645        }
646        yield return configuration;
647      } while (!finished);
648    }
649    #endregion
650    #endregion
651
652    #region Background workers
653    #region Instance discovery
654    private void instanceDiscoveryBackgroundWorker_DoWork(object sender, DoWorkEventArgs e) {
655      instanceDiscoveryBackgroundWorker.ReportProgress(0, "Finding instance providers...");
656      var instanceProviders = ProblemInstanceManager.GetProviders(((IAlgorithm)Optimizer).Problem).ToArray();
657      var nodes = new List<TreeNode>(instanceProviders.Length);
658      for (int i = 0; i < instanceProviders.Length; i++) {
659        var provider = instanceProviders[i];
660        var providerNode = new TreeNode(provider.Name) { Tag = provider };
661        var descriptors = ProblemInstanceManager.GetDataDescriptors(provider);
662        foreach (var desc in descriptors) {
663          #region Check cancellation request
664          if (instanceDiscoveryBackgroundWorker.CancellationPending) {
665            e.Cancel = true;
666            e.Result = nodes.ToArray();
667            return;
668          }
669          #endregion
670          var node = new TreeNode(desc.Name) { Tag = desc };
671          providerNode.Nodes.Add(node);
672          if (providerNode.Nodes.Count == 1)
673            nodes.Add(providerNode);
674        }
675        double progress = nodes.Count > 0 ? i / (double)nodes.Count : 0.0;
676        instanceDiscoveryBackgroundWorker.ReportProgress((int)(100 * progress), provider.Name);
677      }
678      e.Result = nodes.ToArray();
679      instanceDiscoveryBackgroundWorker.ReportProgress(100, string.Empty);
680    }
681
682    private void instanceDiscoveryBackgroundWorker_ProgressChanged(object sender, ProgressChangedEventArgs e) {
683      if (instanceDiscoveryProgressBar.Value != e.ProgressPercentage)
684        instanceDiscoveryProgressBar.Value = e.ProgressPercentage;
685      instanceDiscoveryProgressLabel.Text = (string)e.UserState;
686    }
687
688    private void instanceDiscoveryBackgroundWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e) {
689      try {
690        if (((TreeNode[])e.Result).Length > 0) {
691          instancesTreeView.Nodes.AddRange((TreeNode[])e.Result);
692          foreach (TreeNode node in instancesTreeView.Nodes)
693            node.Collapse();
694        }
695        selectNoneCheckBox.Checked = true;
696      } catch { }
697      try {
698        SetMode(DialogMode.Normal);
699        if (e.Error != null) MessageBox.Show(e.Error.Message, "Error occurred", MessageBoxButtons.OK, MessageBoxIcon.Error);
700      } catch { }
701    }
702    #endregion
703
704    #region Experiment creation
705    private void experimentCreationBackgroundWorker_DoWork(object sender, DoWorkEventArgs e) {
706      backgroundWorkerWaitHandle.Set(); // notify the ok button that we're busy now
707      failedInstances = new StringBuilder();
708      var localExperiment = new Experiment();
709
710      int counter = 0, totalVariations = GetNumberOfVariations();
711      int totalInstances = instances.Values.SelectMany(x => x).Count();
712      if (totalInstances == 0) {
713        try {
714          AddParameterVariations(Optimizer, localExperiment, ref counter, totalVariations);
715        } catch (OperationCanceledException) {
716          e.Cancel = true;
717          return;
718        }
719        experimentCreationBackgroundWorker.ReportProgress(100, string.Empty);
720      } else {
721        foreach (var provider in instances.Keys) {
722          foreach (var descriptor in instances[provider]) {
723            var algorithm = (IAlgorithm)Optimizer.Clone();
724            bool failed = false;
725            try {
726              ProblemInstanceManager.LoadData(provider, descriptor, (IProblemInstanceConsumer)algorithm.Problem);
727            } catch (Exception ex) {
728              failedInstances.AppendLine(descriptor.Name + ": " + ex.Message);
729              failed = true;
730            }
731            if (!failed) {
732              try {
733                if (totalInstances > 1 && totalVariations / totalInstances > 1) {
734                  var experiment = new Experiment(descriptor.Name);
735                  AddParameterVariations(algorithm, experiment, ref counter, totalVariations);
736                  localExperiment.Optimizers.Add(experiment);
737                } else {
738                  AddParameterVariations(algorithm, localExperiment, ref counter, totalVariations);
739                }
740              } catch (OperationCanceledException) {
741                e.Cancel = true;
742                return;
743              }
744            } else experimentCreationBackgroundWorker.ReportProgress((int)Math.Round((100.0 * counter) / totalVariations), "Loading failed (" + descriptor.Name + ")");
745          }
746        }
747      }
748      // this step can take some time
749      SetMode(DialogMode.PreparingExperiment);
750      experimentCreationBackgroundWorker.ReportProgress(-1);
751      localExperiment.Prepare(true);
752      experimentCreationBackgroundWorker.ReportProgress(100);
753      Experiment = localExperiment;
754    }
755
756    private void AddParameterVariations(IOptimizer optimizer, Experiment localExperiment, ref int counter, int totalVariations) {
757      var variations = CalculateParameterVariations(optimizer);
758      foreach (var v in variations) {
759        if (experimentCreationBackgroundWorker.CancellationPending)
760          throw new OperationCanceledException();
761        AddOptimizer(v, localExperiment);
762        counter++;
763        experimentCreationBackgroundWorker.ReportProgress((int)Math.Round((100.0 * counter) / totalVariations), string.Empty);
764      }
765    }
766
767    private IEnumerable<IOptimizer> CalculateParameterVariations(IOptimizer optimizer) {
768      if (!boolParameters.Any() && !intParameters.Any() && !doubleParameters.Any() && !multipleChoiceParameters.Any()) {
769        var o = (IOptimizer)optimizer.Clone();
770        o.Runs.Clear();
771        yield return o;
772        yield break;
773      }
774      bool finished;
775      var mcEnumerator = GetMultipleChoiceConfigurations().GetEnumerator();
776      var boolEnumerator = GetBoolParameterConfigurations().GetEnumerator();
777      var intEnumerator = GetIntParameterConfigurations().GetEnumerator();
778      var doubleEnumerator = GetDoubleParameterConfigurations().GetEnumerator();
779      mcEnumerator.MoveNext(); boolEnumerator.MoveNext(); intEnumerator.MoveNext(); doubleEnumerator.MoveNext();
780      do {
781        var variant = (IAlgorithm)optimizer.Clone();
782        variant.Runs.Clear();
783        variant.Name += " {";
784        finished = true;
785        if (doubleParameters.Any()) {
786          foreach (var d in doubleEnumerator.Current) {
787            var value = (ValueTypeValue<double>)((IValueParameter)variant.Parameters[d.Key.Name]).Value;
788            value.Value = d.Value;
789            variant.Name += d.Key.Name + "=" + d.Value.ToString() + ", ";
790          }
791          if (finished) {
792            if (doubleEnumerator.MoveNext()) {
793              finished = false;
794            } else {
795              doubleEnumerator = GetDoubleParameterConfigurations().GetEnumerator();
796              doubleEnumerator.MoveNext();
797            }
798          }
799        }
800        if (intParameters.Any()) {
801          foreach (var i in intEnumerator.Current) {
802            var value = (ValueTypeValue<int>)((IValueParameter)variant.Parameters[i.Key.Name]).Value;
803            value.Value = i.Value;
804            variant.Name += i.Key.Name + "=" + i.Value.ToString() + ", ";
805          }
806          if (finished) {
807            if (intEnumerator.MoveNext()) {
808              finished = false;
809            } else {
810              intEnumerator = GetIntParameterConfigurations().GetEnumerator();
811              intEnumerator.MoveNext();
812            }
813          }
814        }
815        if (boolParameters.Any()) {
816          foreach (var b in boolEnumerator.Current) {
817            var value = (ValueTypeValue<bool>)((IValueParameter)variant.Parameters[b.Key.Name]).Value;
818            value.Value = b.Value;
819            variant.Name += b.Key.Name + "=" + b.Value.ToString() + ", ";
820          }
821          if (finished) {
822            if (boolEnumerator.MoveNext()) {
823              finished = false;
824            } else {
825              boolEnumerator = GetBoolParameterConfigurations().GetEnumerator();
826              boolEnumerator.MoveNext();
827            }
828          }
829        }
830        if (multipleChoiceParameters.Any()) {
831          foreach (var m in mcEnumerator.Current) {
832            dynamic variantParam = variant.Parameters[m.Key.Name];
833            if (m.Value == optionalNullChoice) {
834              variantParam.Value = null;
835              variant.Name += m.Key.Name + "=null, ";
836              continue;
837            }
838            var variantEnumerator = ((IEnumerable<object>)variantParam.ValidValues).GetEnumerator();
839            var originalEnumerator = ((IEnumerable<object>)((dynamic)m.Key).ValidValues).GetEnumerator();
840            while (variantEnumerator.MoveNext() && originalEnumerator.MoveNext()) {
841              if (m.Value == (IItem)originalEnumerator.Current) {
842                variantParam.Value = (dynamic)variantEnumerator.Current;
843                if (m.Value is INamedItem)
844                  variant.Name += m.Key.Name + "=" + ((INamedItem)m.Value).Name + ", ";
845                else variant.Name += m.Key.Name + "=" + m.Value.ToString() + ", ";
846                break;
847              }
848            }
849          }
850          if (finished) {
851            if (mcEnumerator.MoveNext()) {
852              finished = false;
853            } else {
854              mcEnumerator = GetMultipleChoiceConfigurations().GetEnumerator();
855              mcEnumerator.MoveNext();
856            }
857          }
858        }
859        variant.Name = variant.Name.Substring(0, variant.Name.Length - 2) + "}";
860        yield return variant;
861      } while (!finished);
862    }
863
864    private void experimentCreationBackgroundWorker_ProgressChanged(object sender, ProgressChangedEventArgs e) {
865      if (e.ProgressPercentage >= 0 && e.ProgressPercentage <= 100) {
866        experimentCreationProgressBar.Style = ProgressBarStyle.Continuous;
867        experimentCreationProgressBar.Value = e.ProgressPercentage;
868      } else {
869        experimentCreationProgressBar.Style = ProgressBarStyle.Marquee;
870      }
871    }
872
873    private void experimentCreationBackgroundWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e) {
874      try {
875        SetMode(DialogMode.Normal);
876        if (e.Error != null) MessageBox.Show(e.Error.Message, "Error occurred", MessageBoxButtons.OK, MessageBoxIcon.Error);
877        if (failedInstances.Length > 0) MessageBox.Show("Some instances could not be loaded: " + Environment.NewLine + failedInstances.ToString(), "Some instances failed to load", MessageBoxButtons.OK, MessageBoxIcon.Error);
878        if (!e.Cancelled && e.Error == null) {
879          DialogResult = System.Windows.Forms.DialogResult.OK;
880          Close();
881        }
882      } catch { }
883    }
884    #endregion
885    #endregion
886  }
887}
Note: See TracBrowser for help on using the repository browser.