Free cookie consent management tool by TermsFeed Policy Generator

source: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/SingleObjectiveProgrammableProblem.cs @ 11543

Last change on this file since 11543 was 11543, checked in by mkommend, 9 years ago

#2174: Refactoring of encodings to allow wiring of operators within the encoding instead of the problem (work in progress).

File size: 46.5 KB
Line 
1#region License Information
2/* HeuristicLab
3 * Copyright (C) 2002-2014 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.Drawing;
25using System.Linq;
26using HeuristicLab.Analysis;
27using HeuristicLab.Common;
28using HeuristicLab.Core;
29using HeuristicLab.Data;
30using HeuristicLab.Encodings.BinaryVectorEncoding;
31using HeuristicLab.Encodings.IntegerVectorEncoding;
32using HeuristicLab.Encodings.PermutationEncoding;
33using HeuristicLab.Encodings.RealVectorEncoding;
34using HeuristicLab.Optimization;
35using HeuristicLab.Parameters;
36using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
37using HeuristicLab.PluginInfrastructure;
38
39namespace HeuristicLab.Problems.Programmable {
40  [Item("Programmable Problem (single-objective)", "Represents a single-objective problem that can be programmed.")]
41  [Creatable("Problems")]
42  [StorableClass]
43  public class SingleObjectiveProgrammableProblem : SingleObjectiveHeuristicOptimizationProblem<ISingleObjectiveProgrammableProblemEvaluator, ISolutionCreator>, IParameterizedNamedItem, IStorableContent {
44    public string Filename { get; set; }
45
46    public static new Image StaticItemImage {
47      get { return Common.Resources.VSImageLibrary.Script; }
48    }
49
50    public new ParameterCollection Parameters {
51      get { return base.Parameters; }
52    }
53    IKeyedItemCollection<string, IParameter> IParameterizedItem.Parameters {
54      get { return Parameters; }
55    }
56
57    public IValueParameter<ISingleObjectiveProblemDefinition> ProblemDefinitionParameter {
58      get { return (IValueParameter<ISingleObjectiveProblemDefinition>)Parameters["ProblemDefinition"]; }
59    }
60
61    protected IValueParameter<Encoding> EncodingParameter {
62      get { return (IValueParameter<Encoding>)Parameters["Encoding"]; }
63    }
64
65    public ISingleObjectiveProblemDefinition ProblemDefinition {
66      get { return ProblemDefinitionParameter.Value; }
67      set { ProblemDefinitionParameter.Value = value; }
68    }
69
70    [Storable]
71    protected List<IParameter> DynamicEncodingParameters;
72
73    [StorableConstructor]
74    protected SingleObjectiveProgrammableProblem(bool deserializing) : base(deserializing) { }
75
76    protected SingleObjectiveProgrammableProblem(SingleObjectiveProgrammableProblem original, Cloner cloner)
77      : base(original, cloner) {
78      DynamicEncodingParameters = original.DynamicEncodingParameters.Select(cloner.Clone).ToList();
79      RegisterEventHandlers();
80    }
81    public SingleObjectiveProgrammableProblem()
82      : base(new SingleObjectiveEvaluator(), new MultiEncodingCreator()) {
83      Parameters.Add(new ValueParameter<ISingleObjectiveProblemDefinition>("ProblemDefinition", "Defines the problem.", new SingleObjectiveProblemScript() { Name = Name }));
84      Parameters.Add(new ValueParameter<Encoding>("Encoding", "Describes the configuration of the encoding, what the variables are called, what type they are and their bounds if any."));
85
86      DynamicEncodingParameters = new List<IParameter>();
87
88      Operators.Add(new BestScopeSolutionAnalyzer());
89      Operators.Add(new SingleObjectiveAnalyzer());
90      Operators.Add(Evaluator);
91      Operators.Add(SolutionCreator);
92
93      RegisterEventHandlers();
94    }
95
96    public override IDeepCloneable Clone(Cloner cloner) {
97      return new SingleObjectiveProgrammableProblem(this, cloner);
98    }
99
100    [StorableHook(HookType.AfterDeserialization)]
101    // ReSharper disable UnusedMember.Local
102    private void AfterDeserialization() {
103      RegisterEventHandlers();
104    }
105    // ReSharper restore UnusedMember.Local
106
107    private void RegisterEventHandlers() {
108      ProblemDefinitionParameter.ValueChanged += ProblemDefinitionParameterOnValueChanged;
109      RegisterHostInstanceChanges();
110    }
111
112    private void ProblemDefinitionParameterOnValueChanged(object sender, EventArgs eventArgs) {
113      RegisterHostInstanceChanges();
114      Parameterize();
115    }
116
117    private void RegisterHostInstanceChanges() {
118      ProblemDefinitionParameter.Value.ProblemDefinitionChanged += ProblemDefinitionChanged;
119      ProblemDefinitionParameter.Value.NameChanged += ProblemDefinitionHostOnNameChanged;
120    }
121
122    private void ProblemDefinitionHostOnNameChanged(object sender, EventArgs eventArgs) {
123      if (sender != ProblemDefinitionParameter.Value) return;
124      Name = ProblemDefinitionParameter.Value.Name;
125    }
126
127    protected override void OnNameChanged() {
128      base.OnNameChanged();
129      ProblemDefinitionParameter.Value.Name = Name;
130    }
131
132    protected override void OnEvaluatorChanged() {
133      base.OnEvaluatorChanged();
134      Parameterize();
135    }
136
137    protected virtual void ProblemDefinitionChanged(object sender, EventArgs eventArgs) {
138      Parameterize();
139    }
140
141    protected virtual void Parameterize() {
142      var definition = ProblemDefinitionParameter.Value;
143      if (definition == null) return;
144
145      Encoding encoding = definition.Encoding;
146
147      EncodingParameter.Value = encoding;
148      Maximization.Value = definition.IsMaximizationProblem;
149
150      Evaluator.EncodingParameter.ActualName = EncodingParameter.Name;
151      Evaluator.ProblemDefinitionParameter.ActualName = ProblemDefinitionParameter.Name;
152      foreach (var evalOp in Operators.OfType<ISingleObjectiveProgrammableProblemEvaluator>()) {
153        evalOp.EncodingParameter.ActualName = EncodingParameter.Name;
154        evalOp.ProblemDefinitionParameter.ActualName = ProblemDefinitionParameter.Name;
155      }
156      foreach (var analyzeOp in Operators.OfType<ISingleObjectiveProgrammableProblemAnalyzer>()) {
157        analyzeOp.EncodingParameter.ActualName = EncodingParameter.Name;
158        analyzeOp.ProblemDefinitionParameter.ActualName = ProblemDefinitionParameter.Name;
159        analyzeOp.QualityParameter.ActualName = Evaluator.QualityParameter.ActualName;
160      }
161
162      foreach (var param in DynamicEncodingParameters)
163        if (Parameters.Contains(param)) Parameters.Remove(param);
164      DynamicEncodingParameters.Clear();
165
166      var creator = ConfigureCreator(encoding);
167
168      foreach (var param in DynamicEncodingParameters) {
169        param.Hidden = true;
170        Parameters.Add(param);
171      }
172
173      var multiEncoding = encoding as MultiEncoding;
174      if (multiEncoding != null) {
175        ConfigureMultiVectorEncodingOperators((MultiEncodingCreator)creator, multiEncoding);
176      } else {
177        ConfigureSingleEncodingOperators(creator, encoding);
178      }
179      UpdateImprovementOperators();
180      UpdateMoveOperators();
181    }
182
183    protected virtual ISolutionCreator ConfigureCreator(Encoding encoding) {
184      #region Configure MultiEncoding Creator
185      var multiEncoding = encoding as MultiEncoding;
186      if (multiEncoding != null) {
187        var creator = new MultiEncodingCreator();
188        foreach (var enc in multiEncoding.Encodings) {
189          if (enc is MultiEncoding) throw new InvalidOperationException("MultiEncoding within a MultiEncoding is not supported.");
190          creator.Operators.Add(ConfigureCreator(enc));
191        }
192        return creator;
193      }
194      #endregion
195      #region Configure BinaryVector Creator
196      var binEnc = encoding as BinaryEncoding;
197      if (binEnc != null) {
198        var p = new ValueParameter<IntValue>(binEnc.Name + "Length", binEnc.Length);
199        DynamicEncodingParameters.Add(p);
200
201        var creator = new RandomBinaryVectorCreator();
202        creator.BinaryVectorParameter.ActualName = binEnc.Name;
203        creator.LengthParameter.ActualName = p.Name;
204        return creator;
205      }
206      #endregion
207      #region Configure IntegerVector Creator
208      var intEnc = encoding as IntegerEncoding;
209      if (intEnc != null) {
210        var l = new ValueParameter<IntValue>(intEnc.Name + "Length", intEnc.Length);
211        var b = new ValueParameter<IntMatrix>(intEnc.Name + "Bounds", intEnc.Bounds);
212        DynamicEncodingParameters.Add(l);
213        DynamicEncodingParameters.Add(b);
214
215        var creator = new UniformRandomIntegerVectorCreator();
216        creator.IntegerVectorParameter.ActualName = intEnc.Name;
217        creator.LengthParameter.ActualName = l.Name;
218        creator.BoundsParameter.ActualName = b.Name;
219        return creator;
220      }
221      #endregion
222      #region Configure RealVector Creator
223      var realEnc = encoding as RealEncoding;
224      if (realEnc != null) {
225        DynamicEncodingParameters.AddRange(realEnc.EncodingParameters);       
226        return realEnc.SolutionCreator;
227      }
228      #endregion
229      #region Configure Permutation Creator
230      var permEnc = encoding as PermutationEncoding;
231      if (permEnc != null) {
232        var l = new ValueParameter<IntValue>(permEnc.Name + "Length", permEnc.Length);
233        DynamicEncodingParameters.Add(l);
234
235        var creator = new RandomPermutationCreator();
236        creator.PermutationParameter.ActualName = permEnc.Name;
237        creator.LengthParameter.ActualName = l.Name;
238        creator.PermutationTypeParameter.Value = permEnc.Type;
239        return creator;
240      }
241      #endregion
242      throw new ArgumentException(string.Format("Encoding {0} is unknown.", encoding != null ? encoding.GetType().FullName : "(null)"));
243    }
244
245    protected virtual void ConfigureSingleEncodingOperators(ISolutionCreator newCreator, Encoding encoding) {
246      // remove all multiencoding operators
247      Operators.RemoveAll(x => x is MultiEncodingCrossover
248                            || x is MultiEncodingManipulator
249                            || x is MultiEncodingCreator);
250
251      #region Configure Operators for BinaryVectorEncoding
252      var binCreator = newCreator as IBinaryVectorCreator;
253      if (binCreator != null) {
254        var paramName = binCreator.BinaryVectorParameter.ActualName;
255        // do not replace a binary vector creator that was manually set
256        if (!(SolutionCreator is IBinaryVectorCreator) || ((IBinaryVectorCreator)SolutionCreator).BinaryVectorParameter.ActualName != paramName) {
257          Operators.Remove(SolutionCreator);
258          SolutionCreator = newCreator;
259          Operators.Add(SolutionCreator);
260        }
261
262        #region Wire BinaryVector Crossovers
263        var crossovers = Operators.OfType<IBinaryVectorCrossover>()
264          .Union(ApplicationManager.Manager.GetInstances<IBinaryVectorCrossover>(), new TypeEqualityComparer<IBinaryVectorCrossover>())
265          .ToList();
266        foreach (var xo in crossovers) {
267          xo.ChildParameter.ActualName = binCreator.BinaryVectorParameter.ActualName;
268          xo.ChildParameter.Hidden = true;
269          xo.ParentsParameter.ActualName = binCreator.BinaryVectorParameter.ActualName;
270          xo.ParentsParameter.Hidden = true;
271        }
272        Operators.AddRange(crossovers.Except(Operators.OfType<IBinaryVectorCrossover>()));
273        #endregion
274        #region Wire BinaryVector Manipulators
275        var manipulators = Operators.OfType<IBinaryVectorManipulator>()
276          .Union(ApplicationManager.Manager.GetInstances<IBinaryVectorManipulator>(), new TypeEqualityComparer<IBinaryVectorManipulator>())
277          .ToList();
278        foreach (var m in manipulators) {
279          m.BinaryVectorParameter.ActualName = binCreator.BinaryVectorParameter.ActualName;
280          m.BinaryVectorParameter.Hidden = true;
281        }
282        Operators.AddRange(manipulators.Except(Operators.OfType<IBinaryVectorManipulator>()));
283        #endregion
284        #region Wire BinaryVector ShakingOperators
285        var shakingOperators = Operators.OfType<IBinaryVectorMultiNeighborhoodShakingOperator>()
286          .Union(ApplicationManager.Manager.GetInstances<IBinaryVectorMultiNeighborhoodShakingOperator>(), new TypeEqualityComparer<IBinaryVectorMultiNeighborhoodShakingOperator>())
287          .ToList();
288        foreach (var so in shakingOperators) {
289          so.BinaryVectorParameter.ActualName = paramName;
290          so.BinaryVectorParameter.Hidden = true;
291        }
292        Operators.AddRange(shakingOperators.Except(Operators.OfType<IBinaryVectorMultiNeighborhoodShakingOperator>()));
293        #endregion
294      } else {
295        Operators.RemoveAll(x => x is IBinaryVectorCrossover
296          || x is IBinaryVectorManipulator
297          || x is IBinaryVectorMultiNeighborhoodShakingOperator);
298      }
299      #endregion
300      #region Configure Operators for IntegerVectorEncoding
301      var intCreator = newCreator as IIntegerVectorCreator;
302      if (intCreator != null) {
303        var paramName = intCreator.IntegerVectorParameter.ActualName;
304        // do not replace an integer vector creator that was manually set
305        if (!(SolutionCreator is IIntegerVectorCreator)
306          || ((IIntegerVectorCreator)SolutionCreator).IntegerVectorParameter.ActualName != intCreator.IntegerVectorParameter.ActualName) {
307          Operators.Remove(SolutionCreator);
308          SolutionCreator = newCreator;
309          Operators.Add(SolutionCreator);
310        }
311
312        #region Wire IntegerVector Crossovers
313        var crossovers = Operators.OfType<IIntegerVectorCrossover>()
314          .Union(ApplicationManager.Manager.GetInstances<IIntegerVectorCrossover>(), new TypeEqualityComparer<IIntegerVectorCrossover>())
315          .ToList();
316        foreach (var xo in crossovers) {
317          xo.ChildParameter.ActualName = intCreator.IntegerVectorParameter.ActualName;
318          xo.ChildParameter.Hidden = true;
319          xo.ParentsParameter.ActualName = intCreator.IntegerVectorParameter.ActualName;
320          xo.ParentsParameter.Hidden = true;
321          var bx = xo as IBoundedIntegerVectorOperator;
322          if (bx != null) {
323            bx.BoundsParameter.ActualName = intCreator.BoundsParameter.ActualName;
324            bx.BoundsParameter.Hidden = true;
325          }
326        }
327        Operators.AddRange(crossovers.Except(Operators.OfType<IIntegerVectorCrossover>()));
328        #endregion
329        #region Wire IntegerVector Manipulators
330        var manipulators = Operators.OfType<IIntegerVectorManipulator>()
331          .Union(ApplicationManager.Manager.GetInstances<IIntegerVectorManipulator>(), new TypeEqualityComparer<IIntegerVectorManipulator>())
332          .ToList();
333        foreach (var m in manipulators) {
334          m.IntegerVectorParameter.ActualName = intCreator.IntegerVectorParameter.ActualName;
335          m.IntegerVectorParameter.Hidden = true;
336          var sm = m as ISelfAdaptiveManipulator;
337          if (sm != null) {
338            var p = sm.StrategyParameterParameter as ILookupParameter;
339            if (p != null) {
340              p.ActualName = paramName + "Strategy";
341              p.Hidden = true;
342            }
343          }
344          var bm = m as IBoundedIntegerVectorOperator;
345          if (bm != null) {
346            bm.BoundsParameter.ActualName = intCreator.BoundsParameter.ActualName;
347            bm.BoundsParameter.Hidden = true;
348          }
349        }
350        Operators.AddRange(manipulators.Except(Operators.OfType<IIntegerVectorManipulator>()));
351        #region Wire IntegerVector StrategyParameters for SelfAdaptiveManipulators
352        var strategyOperators = Operators.OfType<IIntegerVectorStdDevStrategyParameterOperator>()
353          .Union(ApplicationManager.Manager.GetInstances<IIntegerVectorStdDevStrategyParameterOperator>(), new TypeEqualityComparer<IIntegerVectorStdDevStrategyParameterOperator>())
354          .ToList();
355        var problemSize = ((IntegerEncoding)encoding).Length.Value;
356        var b = ((IntegerEncoding)encoding).Bounds;
357        var bounds = new DoubleMatrix(b.Rows, b.Columns);
358        for (var i = 0; i < bounds.Rows; i++) {
359          bounds[i, 1] = (int)Math.Ceiling(0.33 * (b[i, 1] - b[i, 0]));
360          bounds[i, 0] = 0;
361          if (bounds.Columns > 2) bounds[i, 2] = b[i, 2];
362        }
363        foreach (var s in strategyOperators) {
364          var c = s as IIntegerVectorStdDevStrategyParameterCreator;
365          if (c != null) {
366            c.BoundsParameter.Value = (DoubleMatrix)bounds.Clone();
367            c.LengthParameter.ActualName = intCreator.LengthParameter.ActualName;
368            c.StrategyParameterParameter.ActualName = paramName + "Strategy";
369          }
370          var m = s as IIntegerVectorStdDevStrategyParameterManipulator;
371          if (m != null) {
372            m.BoundsParameter.Value = (DoubleMatrix)bounds.Clone();
373            m.StrategyParameterParameter.ActualName = paramName + "Strategy";
374          }
375          var mm = s as Encodings.IntegerVectorEncoding.StdDevStrategyVectorManipulator;
376          if (mm != null) {
377            mm.GeneralLearningRateParameter.Value = new DoubleValue(1.0 / Math.Sqrt(2 * problemSize));
378            mm.LearningRateParameter.Value = new DoubleValue(1.0 / Math.Sqrt(2 * Math.Sqrt(problemSize)));
379          }
380          var x = s as IIntegerVectorStdDevStrategyParameterCrossover;
381          if (x != null) {
382            x.ParentsParameter.ActualName = paramName + "Strategy";
383            x.StrategyParameterParameter.ActualName = paramName + "Strategy";
384          }
385        }
386        Operators.AddRange(strategyOperators.Except(Operators.OfType<IIntegerVectorStdDevStrategyParameterOperator>()));
387        #endregion
388        #endregion
389        #region Wire IntegerVector ShakingOperators
390        var shakingOperators = Operators.OfType<IIntegerVectorMultiNeighborhoodShakingOperator>()
391          .Union(ApplicationManager.Manager.GetInstances<IIntegerVectorMultiNeighborhoodShakingOperator>(), new TypeEqualityComparer<IIntegerVectorMultiNeighborhoodShakingOperator>())
392          .ToList();
393        foreach (var so in shakingOperators) {
394          so.IntegerVectorParameter.ActualName = paramName;
395          so.IntegerVectorParameter.Hidden = true;
396        }
397        Operators.AddRange(shakingOperators.Except(Operators.OfType<IIntegerVectorMultiNeighborhoodShakingOperator>()));
398        #endregion
399      } else {
400        Operators.RemoveAll(x => x is IIntegerVectorCrossover
401          || x is IIntegerVectorManipulator
402          || x is IIntegerVectorStdDevStrategyParameterOperator
403          || x is IIntegerVectorMultiNeighborhoodShakingOperator);
404      }
405      #endregion
406      #region Configure Operators for RealVectorEncoding
407      var realCreator = newCreator as IRealVectorCreator;
408      if (realCreator != null) {
409        var paramName = realCreator.RealVectorParameter.ActualName;
410        // do not replace a real vector creator that was manually set
411        if (!(SolutionCreator is IRealVectorCreator)
412            || ((IRealVectorCreator)SolutionCreator).RealVectorParameter.ActualName != realCreator.RealVectorParameter.ActualName) {
413          Operators.Remove(SolutionCreator);
414          SolutionCreator = newCreator;
415          Operators.Add(SolutionCreator);
416        }
417
418        #region Wire RealVector Crossovers
419        var crossovers = Operators.OfType<IRealVectorCrossover>()
420          .Union(ApplicationManager.Manager.GetInstances<IRealVectorCrossover>(), new TypeEqualityComparer<IRealVectorCrossover>())
421          .ToList();
422        foreach (var xo in crossovers) {
423          xo.ChildParameter.ActualName = paramName;
424          xo.ChildParameter.Hidden = true;
425          xo.ParentsParameter.ActualName = paramName;
426          xo.ParentsParameter.Hidden = true;
427          xo.BoundsParameter.ActualName = realCreator.BoundsParameter.ActualName;
428          xo.BoundsParameter.Hidden = true;
429        }
430        Operators.AddRange(crossovers.Except(Operators.OfType<IRealVectorCrossover>()));
431        #endregion
432        #region Wire RealVector Manipulators
433        var manipulators = Operators.OfType<IRealVectorManipulator>()
434          .Union(ApplicationManager.Manager.GetInstances<IRealVectorManipulator>(), new TypeEqualityComparer<IRealVectorManipulator>())
435          .ToList();
436        foreach (var m in manipulators) {
437          m.RealVectorParameter.ActualName = paramName;
438          m.RealVectorParameter.Hidden = true;
439          m.BoundsParameter.ActualName = realCreator.BoundsParameter.ActualName;
440          m.BoundsParameter.Hidden = true;
441          var sm = m as ISelfAdaptiveManipulator;
442          if (sm != null) {
443            var p = sm.StrategyParameterParameter as ILookupParameter;
444            if (p != null) {
445              p.ActualName = paramName + "Strategy";
446              p.Hidden = true;
447            }
448          }
449        }
450        Operators.AddRange(manipulators.Except(Operators.OfType<IRealVectorManipulator>()));
451        #region Wire RealVector Strategy Parameters for SelfAdaptiveManipulators
452        var strategyOperators = Operators.OfType<IRealVectorStdDevStrategyParameterOperator>()
453          .Union(ApplicationManager.Manager.GetInstances<IRealVectorStdDevStrategyParameterOperator>(), new TypeEqualityComparer<IRealVectorStdDevStrategyParameterOperator>())
454          .ToList();
455        var problemSize = ((RealEncoding)encoding).Length;
456        var bounds = (DoubleMatrix)((RealEncoding)encoding).Bounds.Clone();
457        for (var i = 0; i < bounds.Rows; i++) {
458          bounds[i, 1] = 0.1 * (bounds[i, 1] - bounds[i, 0]);
459          bounds[i, 0] = 0;
460        }
461        foreach (var s in strategyOperators) {
462          var c = s as IRealVectorStdDevStrategyParameterCreator;
463          if (c != null) {
464            c.BoundsParameter.Value = (DoubleMatrix)bounds.Clone();
465            c.LengthParameter.ActualName = realCreator.LengthParameter.ActualName;
466            c.StrategyParameterParameter.ActualName = paramName + "Strategy";
467          }
468          var m = s as IRealVectorStdDevStrategyParameterManipulator;
469          if (m != null) {
470            m.BoundsParameter.Value = (DoubleMatrix)bounds.Clone();
471            m.StrategyParameterParameter.ActualName = paramName + "Strategy";
472          }
473          var mm = s as Encodings.RealVectorEncoding.StdDevStrategyVectorManipulator;
474          if (mm != null) {
475            mm.GeneralLearningRateParameter.Value = new DoubleValue(1.0 / Math.Sqrt(2 * problemSize));
476            mm.LearningRateParameter.Value = new DoubleValue(1.0 / Math.Sqrt(2 * Math.Sqrt(problemSize)));
477          }
478          var x = s as IRealVectorStdDevStrategyParameterCrossover;
479          if (x != null) {
480            x.ParentsParameter.ActualName = paramName + "Strategy";
481            x.StrategyParameterParameter.ActualName = paramName + "Strategy";
482          }
483        }
484        Operators.AddRange(strategyOperators.Except(Operators.OfType<IRealVectorStdDevStrategyParameterOperator>()));
485        #endregion
486        #endregion
487        #region Wire RealVector ParticleCreators
488        var particleCreators = Operators.OfType<IRealVectorParticleCreator>()
489          .Union(ApplicationManager.Manager.GetInstances<IRealVectorParticleCreator>(), new TypeEqualityComparer<IRealVectorParticleCreator>())
490          .ToList();
491        foreach (var pc in particleCreators) {
492          pc.RealVectorParameter.ActualName = paramName;
493          pc.RealVectorParameter.Hidden = true;
494          pc.BoundsParameter.ActualName = realCreator.BoundsParameter.ActualName;
495          pc.BoundsParameter.Hidden = true;
496          pc.ProblemSizeParameter.ActualName = realCreator.LengthParameter.ActualName;
497          pc.ProblemSizeParameter.Hidden = true;
498        }
499        Operators.AddRange(particleCreators.Except(Operators.OfType<IRealVectorParticleCreator>()));
500        #endregion
501        #region Wire RealVector ParticleUpdaters
502        var particleUpdaters = Operators.OfType<IRealVectorParticleUpdater>()
503          .Union(ApplicationManager.Manager.GetInstances<IRealVectorParticleUpdater>(), new TypeEqualityComparer<IRealVectorParticleUpdater>())
504          .ToList();
505        foreach (var pu in particleUpdaters) {
506          pu.RealVectorParameter.ActualName = paramName;
507          pu.RealVectorParameter.Hidden = true;
508          pu.BoundsParameter.ActualName = realCreator.BoundsParameter.ActualName;
509          pu.BoundsParameter.Hidden = true;
510        }
511        Operators.AddRange(particleUpdaters.Except(Operators.OfType<IRealVectorParticleUpdater>()));
512        #endregion
513        #region Wire RealVector SwarmUpdaters
514        var swarmUpdaters = Operators.OfType<IRealVectorSwarmUpdater>()
515          .Union(ApplicationManager.Manager.GetInstances<IRealVectorSwarmUpdater>(), new TypeEqualityComparer<IRealVectorSwarmUpdater>())
516          .ToList();
517        foreach (var su in swarmUpdaters) {
518          su.RealVectorParameter.ActualName = paramName;
519          su.RealVectorParameter.Hidden = true;
520          su.MaximizationParameter.ActualName = MaximizationParameter.Name;
521          su.MaximizationParameter.Hidden = true;
522        }
523        Operators.AddRange(swarmUpdaters.Except(Operators.OfType<IRealVectorSwarmUpdater>()));
524        #endregion
525        #region Wire RealVector ShakingOperators
526        var shakingOperators = Operators.OfType<IRealVectorMultiNeighborhoodShakingOperator>()
527          .Union(ApplicationManager.Manager.GetInstances<IRealVectorMultiNeighborhoodShakingOperator>(), new TypeEqualityComparer<IRealVectorMultiNeighborhoodShakingOperator>())
528          .ToList();
529        foreach (var so in shakingOperators) {
530          so.RealVectorParameter.ActualName = paramName;
531          so.RealVectorParameter.Hidden = true;
532        }
533        Operators.AddRange(shakingOperators.Except(Operators.OfType<IRealVectorMultiNeighborhoodShakingOperator>()));
534        #endregion
535      } else {
536        Operators.RemoveAll(x => x is IRealVectorCrossover
537          || x is IRealVectorManipulator
538          || x is IRealVectorStdDevStrategyParameterOperator
539          || x is IRealVectorParticleCreator
540          || x is IRealVectorParticleUpdater
541          || x is IRealVectorSwarmUpdater
542          || x is IRealVectorMultiNeighborhoodShakingOperator);
543      }
544      #endregion
545      #region Configure Operators for PermutationEncoding
546      var permCreator = newCreator as IPermutationCreator;
547      if (permCreator != null) {
548        var paramName = permCreator.PermutationParameter.ActualName;
549        // do not replace a permutation creator that was manually set
550        if (!(SolutionCreator is IPermutationCreator)
551            || ((IPermutationCreator)SolutionCreator).PermutationParameter.ActualName != permCreator.PermutationParameter.ActualName) {
552          Operators.Remove(SolutionCreator);
553          SolutionCreator = newCreator;
554          Operators.Add(SolutionCreator);
555        }
556
557        #region Wire Permutation Crossovers
558        var crossovers = Operators.OfType<IPermutationCrossover>()
559          .Union(ApplicationManager.Manager.GetInstances<IPermutationCrossover>(), new TypeEqualityComparer<IPermutationCrossover>())
560          .ToList();
561        foreach (var xo in crossovers) {
562          xo.ChildParameter.ActualName = permCreator.PermutationParameter.ActualName;
563          xo.ChildParameter.Hidden = true;
564          xo.ParentsParameter.ActualName = permCreator.PermutationParameter.ActualName;
565          xo.ParentsParameter.Hidden = true;
566        }
567        Operators.AddRange(crossovers.Except(Operators.OfType<IPermutationCrossover>()));
568        #endregion
569        #region Wire Permutation Manipulators
570        var manipulators = Operators.OfType<IPermutationManipulator>()
571          .Union(ApplicationManager.Manager.GetInstances<IPermutationManipulator>(), new TypeEqualityComparer<IPermutationManipulator>())
572          .ToList();
573        foreach (var m in manipulators) {
574          m.PermutationParameter.ActualName = permCreator.PermutationParameter.ActualName;
575          m.PermutationParameter.Hidden = true;
576        }
577        Operators.AddRange(manipulators.Except(Operators.OfType<IPermutationManipulator>()));
578        #endregion
579        #region Wire Permutation ShakingOperators
580        var shakingOperators = Operators.OfType<IPermutationMultiNeighborhoodShakingOperator>()
581          .Union(ApplicationManager.Manager.GetInstances<IPermutationMultiNeighborhoodShakingOperator>(), new TypeEqualityComparer<IPermutationMultiNeighborhoodShakingOperator>())
582          .ToList();
583        foreach (var op in shakingOperators) {
584          op.PermutationParameter.ActualName = paramName;
585          op.PermutationParameter.Hidden = true;
586        }
587        Operators.AddRange(shakingOperators.Except(Operators.OfType<IPermutationMultiNeighborhoodShakingOperator>()));
588        #endregion
589      } else {
590        Operators.RemoveAll(x => x is IPermutationCrossover
591          || x is IPermutationManipulator
592          || x is IPermutationMultiNeighborhoodShakingOperator);
593      }
594      #endregion
595    }
596
597    protected virtual void ConfigureMultiVectorEncodingOperators(MultiEncodingCreator newCreator, MultiEncoding encoding) {
598      var newBinParams = new HashSet<string>(newCreator.Operators.OfType<IBinaryVectorCreator>().Select(x => x.BinaryVectorParameter.ActualName));
599      var newIntParams = new HashSet<string>(newCreator.Operators.OfType<IIntegerVectorCreator>().Select(x => x.IntegerVectorParameter.ActualName));
600      var newRealParams = new HashSet<string>(newCreator.Operators.OfType<IRealVectorCreator>().Select(x => x.RealVectorParameter.ActualName));
601      var newPermParams = new HashSet<string>(newCreator.Operators.OfType<IPermutationCreator>().Select(x => x.PermutationParameter.ActualName));
602
603      var oldCreator = SolutionCreator as MultiEncodingCreator;
604      if (oldCreator == null) SolutionCreator = newCreator;
605      else {
606        #region Configure BinaryVector Creator
607        var oldBinParams = new HashSet<string>(oldCreator.Operators.OfType<IBinaryVectorCreator>().Select(x => x.BinaryVectorParameter.ActualName));
608        foreach (var toAdd in newBinParams.Except(oldBinParams)) {
609          oldCreator.Operators.Add(newCreator.Operators.OfType<IBinaryVectorCreator>().Single(x => x.BinaryVectorParameter.ActualName == toAdd));
610        }
611        foreach (var toRemove in oldBinParams.Except(newBinParams)) {
612          var op = oldCreator.Operators.OfType<IBinaryVectorCreator>().SingleOrDefault(x => x.BinaryVectorParameter.ActualName == toRemove);
613          if (op != null) oldCreator.Operators.Remove(op);
614        }
615        #endregion
616
617        #region Configure IntegerVector Creator
618        var oldIntParams = new HashSet<string>(oldCreator.Operators.OfType<IIntegerVectorCreator>().Select(x => x.IntegerVectorParameter.ActualName));
619        foreach (var toAdd in newIntParams.Except(oldIntParams)) {
620          oldCreator.Operators.Add(newCreator.Operators.OfType<IIntegerVectorCreator>().Single(x => x.IntegerVectorParameter.ActualName == toAdd));
621        }
622        foreach (var toRemove in oldIntParams.Except(newIntParams)) {
623          var op = oldCreator.Operators.OfType<IIntegerVectorCreator>().SingleOrDefault(x => x.IntegerVectorParameter.ActualName == toRemove);
624          if (op != null) oldCreator.Operators.Remove(op);
625        }
626        #endregion
627
628        #region Configure RealVector Creator
629        var oldRealParams = new HashSet<string>(oldCreator.Operators.OfType<IRealVectorCreator>().Select(x => x.RealVectorParameter.ActualName));
630        foreach (var toAdd in newRealParams.Except(oldRealParams)) {
631          oldCreator.Operators.Add(newCreator.Operators.OfType<IRealVectorCreator>().Single(x => x.RealVectorParameter.ActualName == toAdd));
632        }
633        foreach (var toRemove in oldRealParams.Except(newRealParams)) {
634          var op = oldCreator.Operators.OfType<IRealVectorCreator>().SingleOrDefault(x => x.RealVectorParameter.ActualName == toRemove);
635          if (op != null) oldCreator.Operators.Remove(op);
636        }
637        #endregion
638
639        #region Configure Permutation Creator
640        var oldPermParams = new HashSet<string>(oldCreator.Operators.OfType<IPermutationCreator>().Select(x => x.PermutationParameter.ActualName));
641        foreach (var toAdd in newPermParams.Except(oldPermParams)) {
642          oldCreator.Operators.Add(newCreator.Operators.OfType<IPermutationCreator>().Single(x => x.PermutationParameter.ActualName == toAdd));
643        }
644        foreach (var toRemove in oldPermParams.Except(newPermParams)) {
645          var op = oldCreator.Operators.OfType<IPermutationCreator>().SingleOrDefault(x => x.PermutationParameter.ActualName == toRemove);
646          if (op != null) oldCreator.Operators.Remove(op);
647        }
648        // we also have to sync the permutation type (in case this changes, as it is a value parameter)
649        foreach (var intersect in newPermParams.Intersect(oldPermParams)) {
650          var oldPermCreator = oldCreator.Operators.OfType<IPermutationCreator>().Single(x => x.PermutationParameter.ActualName == intersect);
651          var newPermCreator = newCreator.Operators.OfType<IPermutationCreator>().Single(x => x.PermutationParameter.ActualName == intersect);
652          oldPermCreator.PermutationTypeParameter.Value = newPermCreator.PermutationTypeParameter.Value;
653        }
654        #endregion
655
656      }
657
658      // crossover and manipulator for multi-vector encoding
659      // the condition checks if a multi-vector encoding is to be updated (there already exists ParameterVectorCrossover and ParameterVectorManipulator)
660      if (Operators.OfType<MultiEncodingCrossover>().Any() && Operators.OfType<MultiEncodingManipulator>().Any()) {
661        #region Update existing multi-vector encoding
662        #region Update ParameterVector Crossover ...
663        foreach (var oldXo in Operators.OfType<MultiEncodingCrossover>()) {
664          #region ... for binary parameters
665          var oldBinParams = new HashSet<string>(oldXo.Operators.OfType<IBinaryVectorCrossover>().Select(x => x.ChildParameter.ActualName));
666          foreach (var toAdd in newBinParams.Except(oldBinParams))
667            oldXo.Operators.Add(GetDefaultBinaryCrossover(toAdd, encoding));
668          foreach (var toRemove in oldBinParams.Except(newBinParams)) {
669            var op = oldXo.Operators.OfType<IBinaryVectorCrossover>().SingleOrDefault(x => x.ChildParameter.ActualName == toRemove);
670            if (op != null) oldXo.Operators.Remove(op);
671          }
672          #endregion
673          #region ... for integer parameters
674          var oldIntParams = new HashSet<string>(oldXo.Operators.OfType<IIntegerVectorCrossover>().Select(x => x.ChildParameter.ActualName));
675          foreach (var toAdd in newIntParams.Except(oldIntParams))
676            oldXo.Operators.Add(GetDefaultIntegerCrossover(toAdd, encoding));
677          foreach (var toRemove in oldIntParams.Except(newIntParams)) {
678            var op = oldXo.Operators.OfType<IIntegerVectorCrossover>().SingleOrDefault(x => x.ChildParameter.ActualName == toRemove);
679            if (op != null) oldXo.Operators.Remove(op);
680          }
681          #endregion
682          #region ... for real parameters
683          var oldRealParams = new HashSet<string>(oldXo.Operators.OfType<IRealVectorCrossover>().Select(x => x.ChildParameter.ActualName));
684          foreach (var toAdd in newRealParams.Except(oldRealParams))
685            oldXo.Operators.Add(GetDefaultRealCrossover(toAdd, encoding));
686          foreach (var toRemove in oldRealParams.Except(newRealParams)) {
687            var op = oldXo.Operators.OfType<IRealVectorCrossover>().SingleOrDefault(x => x.ChildParameter.ActualName == toRemove);
688            if (op != null) oldXo.Operators.Remove(op);
689          }
690          #endregion
691          #region ... for permutation parameters
692          var oldPermParams = new HashSet<string>(oldXo.Operators.OfType<IPermutationCrossover>().Select(x => x.ChildParameter.ActualName));
693          foreach (var toAdd in newPermParams.Except(oldPermParams))
694            oldXo.Operators.Add(GetDefaultPermutationCrossover(toAdd, encoding));
695          foreach (var toRemove in oldPermParams.Except(newPermParams)) {
696            var op = oldXo.Operators.OfType<IPermutationCrossover>().SingleOrDefault(x => x.ChildParameter.ActualName == toRemove);
697            if (op != null) oldXo.Operators.Remove(op);
698          }
699          #endregion
700        }
701        #endregion
702        #region Update ParameterVector Manipulator ...
703        foreach (var oldM in Operators.OfType<MultiEncodingManipulator>()) {
704          #region ... for binary parameters
705          var oldBinParams = new HashSet<string>(oldM.Operators.OfType<IBinaryVectorManipulator>().Select(x => x.BinaryVectorParameter.ActualName));
706          foreach (var toAdd in newBinParams.Except(oldBinParams))
707            oldM.Operators.Add(GetDefaultBinaryManipulator(toAdd, encoding));
708          foreach (var toRemove in oldBinParams.Except(newBinParams)) {
709            var op = oldM.Operators.OfType<IBinaryVectorManipulator>().SingleOrDefault(x => x.BinaryVectorParameter.ActualName == toRemove);
710            if (op != null) oldM.Operators.Remove(op);
711          }
712          #endregion
713          #region ... for integer parameters
714          var oldIntParams = new HashSet<string>(oldM.Operators.OfType<IIntegerVectorManipulator>().Select(x => x.IntegerVectorParameter.ActualName));
715          foreach (var toAdd in newIntParams.Except(oldIntParams))
716            oldM.Operators.Add(GetDefaultIntegerManipulator(toAdd, encoding));
717          foreach (var toRemove in oldIntParams.Except(newIntParams)) {
718            var op = oldM.Operators.OfType<IIntegerVectorManipulator>().SingleOrDefault(x => x.IntegerVectorParameter.ActualName == toRemove);
719            if (op != null) oldM.Operators.Remove(op);
720          }
721          #endregion
722          #region ... for real parameters
723          var oldRealParams = new HashSet<string>(oldM.Operators.OfType<IRealVectorManipulator>().Select(x => x.RealVectorParameter.ActualName));
724          foreach (var toAdd in newRealParams.Except(oldRealParams))
725            oldM.Operators.Add(GetDefaultRealManipulator(toAdd, encoding));
726          foreach (var toRemove in oldRealParams.Except(newRealParams)) {
727            var op = oldM.Operators.OfType<IRealVectorManipulator>().SingleOrDefault(x => x.RealVectorParameter.ActualName == toRemove);
728            if (op != null) oldM.Operators.Remove(op);
729          }
730          #endregion
731          #region ... for permutation parameters
732          var oldPermParams = new HashSet<string>(oldM.Operators.OfType<IPermutationManipulator>().Select(x => x.PermutationParameter.ActualName));
733          foreach (var toAdd in newPermParams.Except(oldPermParams))
734            oldM.Operators.Add(GetDefaultPermutationManipulator(toAdd, encoding));
735          foreach (var toRemove in oldPermParams.Except(newPermParams)) {
736            var op = oldM.Operators.OfType<IPermutationManipulator>().SingleOrDefault(x => x.PermutationParameter.ActualName == toRemove);
737            if (op != null) oldM.Operators.Remove(op);
738          }
739          #endregion
740        }
741        #endregion
742        #endregion
743      } else {
744        #region Handle transition from single-vector to multi-vector encoding
745        Operators.RemoveAll(x => x is ICrossover);
746        Operators.RemoveAll(x => x is IManipulator);
747        Operators.RemoveAll(x => x is IStrategyParameterCreator || x is IStrategyParameterManipulator || x is IStrategyParameterCrossover);
748        Operators.RemoveAll(x => x is IParticleCreator);
749        Operators.RemoveAll(x => x is IParticleUpdater);
750        Operators.RemoveAll(x => x is ISwarmUpdater);
751        Operators.RemoveAll(x => x is IMultiNeighborhoodShakingOperator);
752
753        var crossover = new MultiEncodingCrossover();
754        var manipulator = new MultiEncodingManipulator();
755        foreach (var enc in encoding.Encodings) {
756          if (enc is BinaryEncoding) {
757            crossover.Operators.Add(GetDefaultBinaryCrossover(enc.Name, encoding));
758            manipulator.Operators.Add(GetDefaultBinaryManipulator(enc.Name, encoding));
759            continue;
760          }
761          var intConfig = enc as IntegerEncoding;
762          if (intConfig != null) {
763            crossover.Operators.Add(GetDefaultIntegerCrossover(enc.Name, encoding));
764            manipulator.Operators.Add(GetDefaultIntegerManipulator(enc.Name, encoding));
765            continue;
766          }
767          var realConfig = enc as RealEncoding;
768          if (realConfig != null) {
769            crossover.Operators.Add(GetDefaultRealCrossover(enc.Name, encoding));
770            manipulator.Operators.Add(GetDefaultRealManipulator(enc.Name, encoding));
771            continue;
772          }
773          var permConfig = enc as PermutationEncoding;
774          if (permConfig != null) {
775            crossover.Operators.Add(GetDefaultPermutationCrossover(enc.Name, encoding));
776            manipulator.Operators.Add(GetDefaultPermutationManipulator(enc.Name, encoding));
777            continue;
778          }
779          throw new InvalidOperationException("Unknown type for parameter " + enc.Name);
780        }
781        Operators.Add(crossover);
782        Operators.Add(manipulator);
783        #endregion
784      }
785    }
786
787    protected virtual void UpdateImprovementOperators() {
788      if (!Operators.Any(x => x is SingleObjectiveImprover))
789        Operators.Add(new SingleObjectiveImprover());
790      foreach (var improver in Operators.OfType<SingleObjectiveImprover>()) {
791        improver.EncodingParameter.ActualName = EncodingParameter.Name;
792        improver.MaximizationParameter.ActualName = MaximizationParameter.Name;
793        improver.ProblemDefinitionParameter.ActualName = ProblemDefinitionParameter.Name;
794        improver.QualityParameter.ActualName = Evaluator.QualityParameter.ActualName;
795      }
796    }
797
798    protected virtual void UpdateMoveOperators() {
799      if (!Operators.Any(x => x is SingleObjectiveMoveGenerator))
800        Operators.Add(new SingleObjectiveMoveGenerator());
801      if (!Operators.Any(x => x is SingleObjectiveMoveEvaluator))
802        Operators.Add(new SingleObjectiveMoveEvaluator());
803      if (!Operators.Any(x => x is SingleObjectiveMoveMaker))
804        Operators.Add(new SingleObjectiveMoveMaker());
805
806      foreach (var generator in Operators.OfType<SingleObjectiveMoveGenerator>()) {
807        generator.EncodingParameter.ActualName = EncodingParameter.Name;
808        generator.ProblemDefinitionParameter.ActualName = ProblemDefinitionParameter.Name;
809      }
810      foreach (var evaluator in Operators.OfType<SingleObjectiveMoveEvaluator>()) {
811        evaluator.EncodingParameter.ActualName = EncodingParameter.Name;
812        evaluator.QualityParameter.ActualName = Evaluator.QualityParameter.ActualName;
813        evaluator.ProblemDefinitionParameter.ActualName = ProblemDefinitionParameter.Name;
814      }
815      foreach (var maker in Operators.OfType<SingleObjectiveMoveMaker>()) {
816        maker.EncodingParameter.ActualName = EncodingParameter.Name;
817        maker.MoveQualityParameter.ActualName = Operators.OfType<SingleObjectiveMoveEvaluator>().First().MoveQualityParameter.ActualName;
818        maker.QualityParameter.ActualName = Evaluator.QualityParameter.ActualName;
819      }
820    }
821
822    #region GetDefaultOperators for Crossovers and Manipulators
823    // ReSharper disable RedundantNameQualifier
824    protected virtual IBinaryVectorCrossover GetDefaultBinaryCrossover(string paramName, MultiEncoding config) {
825      var binConfig = (BinaryEncoding)config.Encodings[paramName];
826      IBinaryVectorCrossover binXo;
827      if (binConfig.Length.Value > 3) binXo = new Encodings.BinaryVectorEncoding.SinglePointCrossover();
828      else binXo = new Encodings.BinaryVectorEncoding.UniformCrossover();
829      binXo.ChildParameter.ActualName = paramName;
830      binXo.ParentsParameter.ActualName = paramName;
831      return binXo;
832    }
833
834    protected virtual IBinaryVectorManipulator GetDefaultBinaryManipulator(string paramName, MultiEncoding config) {
835      var binM = new Encodings.BinaryVectorEncoding.SomePositionsBitflipManipulator();
836      binM.BinaryVectorParameter.ActualName = paramName;
837      binM.MutationProbabilityParameter.Value = new DoubleValue(0.1);
838      return binM;
839    }
840
841    protected virtual IIntegerVectorCrossover GetDefaultIntegerCrossover(string paramName, MultiEncoding config) {
842      var intXo = new Encodings.IntegerVectorEncoding.RoundedBlendAlphaBetaCrossover();
843      intXo.ChildParameter.ActualName = paramName;
844      intXo.ParentsParameter.ActualName = paramName;
845      intXo.BoundsParameter.ActualName = paramName + "Bounds";
846      intXo.QualityParameter.ActualName = Evaluator.QualityParameter.ActualName;
847      intXo.MaximizationParameter.ActualName = MaximizationParameter.Name;
848      return intXo;
849    }
850
851    protected virtual IIntegerVectorManipulator GetDefaultIntegerManipulator(string paramName, MultiEncoding configuration) {
852      var intM = new Encodings.IntegerVectorEncoding.UniformSomePositionsManipulator();
853      intM.IntegerVectorParameter.ActualName = paramName;
854      intM.BoundsParameter.ActualName = paramName + "Bounds";
855      intM.ProbabilityParameter.Value = new DoubleValue(0.1);
856      return intM;
857    }
858
859    protected virtual IRealVectorCrossover GetDefaultRealCrossover(string paramName, MultiEncoding configuration) {
860      var realXo = new Encodings.RealVectorEncoding.BlendAlphaBetaCrossover();
861      realXo.ChildParameter.ActualName = paramName;
862      realXo.ParentsParameter.ActualName = paramName;
863      realXo.BoundsParameter.ActualName = paramName + "Bounds";
864      realXo.QualityParameter.ActualName = Evaluator.QualityParameter.ActualName;
865      realXo.MaximizationParameter.ActualName = MaximizationParameter.Name;
866      return realXo;
867    }
868
869    protected virtual IRealVectorManipulator GetDefaultRealManipulator(string paramName, MultiEncoding configuration) {
870      var realM = new Encodings.RealVectorEncoding.BreederGeneticAlgorithmManipulator();
871      realM.RealVectorParameter.ActualName = paramName;
872      realM.BoundsParameter.ActualName = paramName + "Bounds";
873      return realM;
874    }
875
876    protected virtual IPermutationCrossover GetDefaultPermutationCrossover(string paramName, MultiEncoding configuration) {
877      var permXo = new Encodings.PermutationEncoding.PartiallyMatchedCrossover();
878      permXo.ChildParameter.ActualName = paramName;
879      permXo.ParentsParameter.ActualName = paramName;
880      return permXo;
881    }
882
883    protected virtual IPermutationManipulator GetDefaultPermutationManipulator(string paramName, MultiEncoding configuration) {
884      var permM = new Encodings.PermutationEncoding.Swap2Manipulator();
885      permM.PermutationParameter.ActualName = paramName;
886      return permM;
887    }
888    // ReSharper restore RedundantNameQualifier
889    #endregion
890  }
891}
Note: See TracBrowser for help on using the repository browser.