Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
07/25/13 13:39:13 (11 years ago)
Author:
mkommend
Message:

#1997: Merged trunk changes in data analysis island GA branch.

Location:
branches/DataAnalysis.IslandAlgorithms
Files:
18 edited

Legend:

Unmodified
Added
Removed

  • branches/DataAnalysis.IslandAlgorithms/HeuristicLab.Algorithms.GeneticAlgorithm

  • branches/DataAnalysis.IslandAlgorithms/HeuristicLab.Algorithms.GeneticAlgorithm/3.3/GeneticAlgorithm.cs

    r8351 r9756  
    11#region License Information
    22/* HeuristicLab
    3  * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
     3 * Copyright (C) 2002-2013 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
    44 *
    55 * This file is part of HeuristicLab.
    … …  
    7979      get { return (ValueParameter<IntValue>)Parameters["Elites"]; }
    8080    }
     81    private IFixedValueParameter<BoolValue> ReevaluateElitesParameter {
     82      get { return (IFixedValueParameter<BoolValue>)Parameters["ReevaluateElites"]; }
     83    }
    8184    private ValueParameter<MultiAnalyzer> AnalyzerParameter {
    8285      get { return (ValueParameter<MultiAnalyzer>)Parameters["Analyzer"]; }
    … …  
    119122      get { return ElitesParameter.Value; }
    120123      set { ElitesParameter.Value = value; }
     124    }
     125    public bool ReevaluteElites {
     126      get { return ReevaluateElitesParameter.Value.Value; }
     127      set { ReevaluateElitesParameter.Value.Value = value; }
    121128    }
    122129    public MultiAnalyzer Analyzer {
    … …  
    151158      Parameters.Add(new OptionalConstrainedValueParameter<IManipulator>("Mutator", "The operator used to mutate solutions."));
    152159      Parameters.Add(new ValueParameter<IntValue>("Elites", "The numer of elite solutions which are kept in each generation.", new IntValue(1)));
     160      Parameters.Add(new FixedValueParameter<BoolValue>("ReevaluateElites", "Flag to determine if elite individuals should be reevaluated (i.e., if stochastic fitness functions are used.)", new BoolValue(false)) { Hidden = true });
    153161      Parameters.Add(new ValueParameter<MultiAnalyzer>("Analyzer", "The operator used to analyze each generation.", new MultiAnalyzer()));
    154162      Parameters.Add(new ValueParameter<IntValue>("MaximumGenerations", "The maximum number of generations which should be processed.", new IntValue(1000)));
    … …  
    182190      mainLoop.CrossoverParameter.ActualName = CrossoverParameter.Name;
    183191      mainLoop.ElitesParameter.ActualName = ElitesParameter.Name;
     192      mainLoop.ReevaluateElitesParameter.ActualName = ReevaluateElitesParameter.Name;
    184193      mainLoop.MaximumGenerationsParameter.ActualName = MaximumGenerationsParameter.Name;
    185194      mainLoop.MutatorParameter.ActualName = MutatorParameter.Name;
    … …  
    207216    [StorableHook(HookType.AfterDeserialization)]
    208217    private void AfterDeserialization() {
     218      // BackwardsCompatibility3.3
     219      #region Backwards compatible code, remove with 3.4
     220      if (!Parameters.ContainsKey("ReevaluateElites")) {
     221        Parameters.Add(new FixedValueParameter<BoolValue>("ReevaluateElites", "Flag to determine if elite individuals should be reevaluated (i.e., if stochastic fitness functions are used.)", (BoolValue)new BoolValue(false).AsReadOnly()) { Hidden = true });
     222      }
     223      #endregion
     224
    209225      Initialize();
    210226    }
     227
     228
    211229
    212230    private GeneticAlgorithm(GeneticAlgorithm original, Cloner cloner)

  • branches/DataAnalysis.IslandAlgorithms/HeuristicLab.Algorithms.GeneticAlgorithm/3.3/GeneticAlgorithmMainLoop.cs

    r7259 r9756  
    11#region License Information
    22/* HeuristicLab
    3  * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
     3 * Copyright (C) 2002-2013 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
    44 *
    55 * This file is part of HeuristicLab.
    … …  
    6363    public ValueLookupParameter<IntValue> ElitesParameter {
    6464      get { return (ValueLookupParameter<IntValue>)Parameters["Elites"]; }
     65    }
     66    public IValueLookupParameter<BoolValue> ReevaluateElitesParameter {
     67      get { return (IValueLookupParameter<BoolValue>)Parameters["ReevaluateElites"]; }
    6568    }
    6669    public ValueLookupParameter<IntValue> MaximumGenerationsParameter {
    … …  
    112115      Parameters.Add(new ValueLookupParameter<IOperator>("Evaluator", "The operator used to evaluate solutions. This operator is executed in parallel, if an engine is used which supports parallelization."));
    113116      Parameters.Add(new ValueLookupParameter<IntValue>("Elites", "The numer of elite solutions which are kept in each generation."));
     117      Parameters.Add(new ValueLookupParameter<BoolValue>("ReevaluateElites", "Flag to determine if elite individuals should be reevaluated (i.e., if stochastic fitness functions are used.)"));
    114118      Parameters.Add(new ValueLookupParameter<IntValue>("MaximumGenerations", "The maximum number of generations which should be processed."));
    115119      Parameters.Add(new ValueLookupParameter<VariableCollection>("Results", "The variable collection where results should be stored."));
    … …  
    143147      Placeholder analyzer2 = new Placeholder();
    144148      ConditionalBranch conditionalBranch = new ConditionalBranch();
     149      ConditionalBranch reevaluateElitesBranch = new ConditionalBranch();
    145150
    146151      variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Generations", new IntValue(0))); // Class GeneticAlgorithm expects this to be called Generations
    … …  
    193198
    194199      conditionalBranch.ConditionParameter.ActualName = "Terminate";
     200
     201      reevaluateElitesBranch.ConditionParameter.ActualName = "ReevaluateElites";
     202      reevaluateElitesBranch.Name = "Reevaluate elites ?";
    195203      #endregion
    196204
    … …  
    221229      subScopesProcessor2.Successor = mergingReducer;
    222230      bestSelector.Successor = rightReducer;
    223       rightReducer.Successor = null;
     231      rightReducer.Successor = reevaluateElitesBranch;
     232      reevaluateElitesBranch.TrueBranch = uniformSubScopesProcessor2;
     233      reevaluateElitesBranch.FalseBranch = null;
     234      reevaluateElitesBranch.Successor = null;
    224235      mergingReducer.Successor = intCounter;
    225236      intCounter.Successor = comparator;
    … …  
    232243    }
    233244
     245    [StorableHook(HookType.AfterDeserialization)]
     246    private void AfterDeserialization() {
     247      // BackwardsCompatibility3.3
     248      #region Backwards compatible code, remove with 3.4
     249      if (!Parameters.ContainsKey("ReevaluateElites")) {
     250        Parameters.Add(new ValueLookupParameter<BoolValue>("ReevaluateElites", "Flag to determine if elite individuals should be reevaluated (i.e., if stochastic fitness functions are used.)"));
     251      }
     252      #endregion
     253    }
     254
    234255    public override IOperation Apply() {
    235256      if (CrossoverParameter.ActualValue == null)

  • branches/DataAnalysis.IslandAlgorithms/HeuristicLab.Algorithms.GeneticAlgorithm/3.3/IslandGeneticAlgorithm.cs

    r9077 r9756  
    11#region License Information
    22/* HeuristicLab
    3  * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
     3 * Copyright (C) 2002-2013 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
    44 *
    55 * This file is part of HeuristicLab.
    … …  
    4141  [Creatable("Algorithms")]
    4242  [StorableClass]
    43   public class IslandGeneticAlgorithm : HeuristicOptimizationEngineAlgorithm, IStorableContent {
     43  public sealed class IslandGeneticAlgorithm : HeuristicOptimizationEngineAlgorithm, IStorableContent {
    4444    public string Filename { get; set; }
    4545
    … …  
    5555
    5656    #region Parameter Properties
    57     public ValueParameter<IntValue> SeedParameter {
     57    private ValueParameter<IntValue> SeedParameter {
    5858      get { return (ValueParameter<IntValue>)Parameters["Seed"]; }
    5959    }
    60     public ValueParameter<BoolValue> SetSeedRandomlyParameter {
     60    private ValueParameter<BoolValue> SetSeedRandomlyParameter {
    6161      get { return (ValueParameter<BoolValue>)Parameters["SetSeedRandomly"]; }
    6262    }
    63     public ValueParameter<IntValue> NumberOfIslandsParameter {
     63    private ValueParameter<IntValue> NumberOfIslandsParameter {
    6464      get { return (ValueParameter<IntValue>)Parameters["NumberOfIslands"]; }
    6565    }
    66     public ValueParameter<IntValue> MigrationIntervalParameter {
     66    private ValueParameter<IntValue> MigrationIntervalParameter {
    6767      get { return (ValueParameter<IntValue>)Parameters["MigrationInterval"]; }
    6868    }
    69     public ValueParameter<PercentValue> MigrationRateParameter {
     69    private ValueParameter<PercentValue> MigrationRateParameter {
    7070      get { return (ValueParameter<PercentValue>)Parameters["MigrationRate"]; }
    7171    }
    … …  
    7979      get { return (IConstrainedValueParameter<IReplacer>)Parameters["ImmigrationReplacer"]; }
    8080    }
    81     public ValueParameter<IntValue> PopulationSizeParameter {
     81    private ValueParameter<IntValue> PopulationSizeParameter {
    8282      get { return (ValueParameter<IntValue>)Parameters["PopulationSize"]; }
    8383    }
    84     public ValueParameter<IntValue> MaximumGenerationsParameter {
     84    private ValueParameter<IntValue> MaximumGenerationsParameter {
    8585      get { return (ValueParameter<IntValue>)Parameters["MaximumGenerations"]; }
    8686    }
    … …  
    9191      get { return (IConstrainedValueParameter<ICrossover>)Parameters["Crossover"]; }
    9292    }
    93     public ValueParameter<PercentValue> MutationProbabilityParameter {
     93    private ValueParameter<PercentValue> MutationProbabilityParameter {
    9494      get { return (ValueParameter<PercentValue>)Parameters["MutationProbability"]; }
    9595    }
    … …  
    9797      get { return (IConstrainedValueParameter<IManipulator>)Parameters["Mutator"]; }
    9898    }
    99     public ValueParameter<IntValue> ElitesParameter {
     99    private ValueParameter<IntValue> ElitesParameter {
    100100      get { return (ValueParameter<IntValue>)Parameters["Elites"]; }
    101101    }
    102     public ValueParameter<MultiAnalyzer> AnalyzerParameter {
     102    private IFixedValueParameter<BoolValue> ReevaluateElitesParameter {
     103      get { return (IFixedValueParameter<BoolValue>)Parameters["ReevaluateElites"]; }
     104    }
     105    private ValueParameter<MultiAnalyzer> AnalyzerParameter {
    103106      get { return (ValueParameter<MultiAnalyzer>)Parameters["Analyzer"]; }
    104107    }
    105     public ValueParameter<MultiAnalyzer> IslandAnalyzerParameter {
     108    private ValueParameter<MultiAnalyzer> IslandAnalyzerParameter {
    106109      get { return (ValueParameter<MultiAnalyzer>)Parameters["IslandAnalyzer"]; }
    107110    }
    … …  
    169172      set { ElitesParameter.Value = value; }
    170173    }
     174    public bool ReevaluteElites {
     175      get { return ReevaluateElitesParameter.Value.Value; }
     176      set { ReevaluateElitesParameter.Value.Value = value; }
     177    }
    171178    public MultiAnalyzer Analyzer {
    172179      get { return AnalyzerParameter.Value; }
    … …  
    177184      set { IslandAnalyzerParameter.Value = value; }
    178185    }
    179     protected RandomCreator RandomCreator {
     186    private RandomCreator RandomCreator {
    180187      get { return (RandomCreator)OperatorGraph.InitialOperator; }
    181188    }
    182     protected UniformSubScopesProcessor IslandProcessor {
     189    private UniformSubScopesProcessor IslandProcessor {
    183190      get { return OperatorGraph.Iterate().OfType<UniformSubScopesProcessor>().First(x => x.Operator is SolutionsCreator); }
    184191    }
    185     protected SolutionsCreator SolutionsCreator {
     192    private SolutionsCreator SolutionsCreator {
    186193      get { return (SolutionsCreator)IslandProcessor.Operator; }
    187194    }
    188     protected IslandGeneticAlgorithmMainLoop MainLoop {
     195    private IslandGeneticAlgorithmMainLoop MainLoop {
    189196      get { return FindMainLoop(IslandProcessor.Successor); }
    190197    }
    … …  
    196203
    197204    [StorableConstructor]
    198     protected IslandGeneticAlgorithm(bool deserializing) : base(deserializing) { }
     205    private IslandGeneticAlgorithm(bool deserializing) : base(deserializing) { }
    199206    [StorableHook(HookType.AfterDeserialization)]
    200207    private void AfterDeserialization() {
     208      // BackwardsCompatibility3.3
     209      #region Backwards compatible code, remove with 3.4
     210      if (!Parameters.ContainsKey("ReevaluateElites")) {
     211        Parameters.Add(new FixedValueParameter<BoolValue>("ReevaluateElites", "Flag to determine if elite individuals should be reevaluated (i.e., if stochastic fitness functions are used.)", (BoolValue)new BoolValue(false).AsReadOnly()) { Hidden = true });
     212      }
     213      #endregion
     214
    201215      Initialize();
    202216    }
    203     protected IslandGeneticAlgorithm(IslandGeneticAlgorithm original, Cloner cloner)
     217    private IslandGeneticAlgorithm(IslandGeneticAlgorithm original, Cloner cloner)
    204218      : base(original, cloner) {
    205219      islandQualityAnalyzer = cloner.Clone(original.islandQualityAnalyzer);
    … …  
    228242      Parameters.Add(new OptionalConstrainedValueParameter<IManipulator>("Mutator", "The operator used to mutate solutions."));
    229243      Parameters.Add(new ValueParameter<IntValue>("Elites", "The numer of elite solutions which are kept in each generation.", new IntValue(1)));
     244      Parameters.Add(new FixedValueParameter<BoolValue>("ReevaluateElites", "Flag to determine if elite individuals should be reevaluated (i.e., if stochastic fitness functions are used.)", new BoolValue(false)) { Hidden = true });
    230245      Parameters.Add(new ValueParameter<MultiAnalyzer>("Analyzer", "The operator used to analyze the islands.", new MultiAnalyzer()));
    231246      Parameters.Add(new ValueParameter<MultiAnalyzer>("IslandAnalyzer", "The operator used to analyze each island.", new MultiAnalyzer()));
    … …  
    260275      // BackwardsCompatibility3.3
    261276      // the global random is resetted to ensure the same algorithm results
    262       #region Backwards compatible code, remove with 3.4
     277      #region Backwards compatible code, remove global random resetter with 3.4 and rewire the operator graph
    263278      globalRandomResetter.RandomParameter.ActualName = "GlobalRandom";
    264279      globalRandomResetter.SeedParameter.ActualName = SeedParameter.Name;
    … …  
    301316      mainLoop.CrossoverParameter.ActualName = CrossoverParameter.Name;
    302317      mainLoop.ElitesParameter.ActualName = ElitesParameter.Name;
     318      mainLoop.ReevaluateElitesParameter.ActualName = ReevaluateElitesParameter.Name;
    303319      mainLoop.MutatorParameter.ActualName = MutatorParameter.Name;
    304320      mainLoop.MutationProbabilityParameter.ActualName = MutationProbabilityParameter.Name;
    … …  
    417433      }
    418434    }
    419     protected virtual void ParameterizeSolutionsCreator() {
     435    private void ParameterizeSolutionsCreator() {
    420436      SolutionsCreator.EvaluatorParameter.ActualName = Problem.EvaluatorParameter.Name;
    421437      SolutionsCreator.SolutionCreatorParameter.ActualName = Problem.SolutionCreatorParameter.Name;
    422438    }
    423     protected virtual void ParameterizeMainLoop() {
     439    private void ParameterizeMainLoop() {
    424440      MainLoop.BestKnownQualityParameter.ActualName = Problem.BestKnownQualityParameter.Name;
    425441      MainLoop.EvaluatorParameter.ActualName = Problem.EvaluatorParameter.Name;
    … …  
    427443      MainLoop.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
    428444    }
    429     protected void ParameterizeStochasticOperator(IOperator op) {
     445    private void ParameterizeStochasticOperator(IOperator op) {
    430446      IStochasticOperator stochasticOp = op as IStochasticOperator;
    431447      if (stochasticOp != null) {
    … …  
    434450      }
    435451    }
    436     protected void ParameterizeStochasticOperatorForIsland(IOperator op) {
     452    private void ParameterizeStochasticOperatorForIsland(IOperator op) {
    437453      IStochasticOperator stochasticOp = op as IStochasticOperator;
    438454      if (stochasticOp != null) {

  • branches/DataAnalysis.IslandAlgorithms/HeuristicLab.Algorithms.GeneticAlgorithm/3.3/IslandGeneticAlgorithmMainLoop.cs

    r9039 r9756  
    11#region License Information
    22/* HeuristicLab
    3  * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
     3 * Copyright (C) 2002-2013 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
    44 *
    55 * This file is part of HeuristicLab.
    … …  
    9191    public ValueLookupParameter<IntValue> ElitesParameter {
    9292      get { return (ValueLookupParameter<IntValue>)Parameters["Elites"]; }
     93    }
     94    public IValueLookupParameter<BoolValue> ReevaluateElitesParameter {
     95      get { return (IValueLookupParameter<BoolValue>)Parameters["ReevaluateElites"]; }
    9396    }
    9497    public ValueLookupParameter<ResultCollection> ResultsParameter {
    … …  
    144147      Parameters.Add(new ValueLookupParameter<IOperator>("Evaluator", "The operator used to evaluate solutions."));
    145148      Parameters.Add(new ValueLookupParameter<IntValue>("Elites", "The numer of elite solutions which are kept in each generation."));
     149      Parameters.Add(new ValueLookupParameter<BoolValue>("ReevaluateElites", "Flag to determine if elite individuals should be reevaluated (i.e., if stochastic fitness functions are used.)"));
    146150      Parameters.Add(new ValueLookupParameter<ResultCollection>("Results", "The results collection to store the results."));
    147151      Parameters.Add(new ValueLookupParameter<IOperator>("Analyzer", "The operator used to the analyze the islands."));
    … …  
    194198      Placeholder analyzer2 = new Placeholder();
    195199      ConditionalBranch generationsTerminationCondition = new ConditionalBranch();
     200      ConditionalBranch reevaluateElitesBranch = new ConditionalBranch();
    196201
    197202
    … …  
    305310      generationsTerminationCondition.Name = "Terminate?";
    306311      generationsTerminationCondition.ConditionParameter.ActualName = "TerminateGenerations";
     312
     313      reevaluateElitesBranch.ConditionParameter.ActualName = "ReevaluateElites";
     314      reevaluateElitesBranch.Name = "Reevaluate elites ?";
    307315      #endregion
    308316
    … …  
    315323      // BackwardsCompatibility3.3
    316324      //the local randoms are created by the island GA itself and are only here to ensure same algorithm results
    317       #region Backwards compatible code, remove with 3.4
     325      #region Backwards compatible code, remove local random creator with 3.4 and rewire the operator graph
    318326      islandAnalyzer1.Successor = localRandomCreator;
    319327      localRandomCreator.Successor = null;
    … …  
    345353      evaluator.Successor = null;
    346354      subScopesCounter.Successor = null;
    347       subScopesCounter.Successor = null;
    348355      subScopesProcessor2.Operators.Add(bestSelector);
    349356      subScopesProcessor2.Operators.Add(new EmptyOperator());
    … …  
    351358      mergingReducer.Successor = islandAnalyzer2;
    352359      bestSelector.Successor = rightReducer;
    353       rightReducer.Successor = null;
     360      rightReducer.Successor = reevaluateElitesBranch;
     361      reevaluateElitesBranch.TrueBranch = uniformSubScopesProcessor3;
     362      reevaluateElitesBranch.FalseBranch = null;
     363      reevaluateElitesBranch.Successor = null;
    354364      islandAnalyzer2.Successor = islandGenerationsCounter;
    355365      islandGenerationsCounter.Successor = checkIslandGenerationsReachedMaximum;
    … …  
    369379    }
    370380
     381    [StorableHook(HookType.AfterDeserialization)]
     382    private void AfterDeserialization() {
     383      // BackwardsCompatibility3.3
     384      #region Backwards compatible code, remove with 3.4
     385      if (!Parameters.ContainsKey("ReevaluateElites")) {
     386        Parameters.Add(new ValueLookupParameter<BoolValue>("ReevaluateElites", "Flag to determine if elite individuals should be reevaluated (i.e., if stochastic fitness functions are used.)"));
     387      }
     388      #endregion
     389    }
     390
    371391    public override IOperation Apply() {
    372392      if (CrossoverParameter.ActualValue == null)

  • branches/DataAnalysis.IslandAlgorithms/HeuristicLab.Algorithms.GeneticAlgorithm/3.3/Plugin.cs.frame

    r8399 r9756  
    11#region License Information
    22/* HeuristicLab
    3  * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
     3 * Copyright (C) 2002-2013 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
    44 *
    55 * This file is part of HeuristicLab.
    … …  
    2626  /// Plugin class for HeuristicLab.Algorithms.GeneticAlgorithm plugin.
    2727  /// </summary>
    28   [Plugin("HeuristicLab.Algorithms.GeneticAlgorithm", "3.3.7.$WCREV$")]
     28  [Plugin("HeuristicLab.Algorithms.GeneticAlgorithm", "3.3.8.$WCREV$")]
    2929  [PluginFile("HeuristicLab.Algorithms.GeneticAlgorithm-3.3.dll", PluginFileType.Assembly)]
    3030  [PluginDependency("HeuristicLab.Analysis", "3.3")]

  • branches/DataAnalysis.IslandAlgorithms/HeuristicLab.Algorithms.GeneticAlgorithm/3.3/Properties/AssemblyInfo.cs.frame

    r8246 r9756  
    11#region License Information
    22/* HeuristicLab
    3  * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
     3 * Copyright (C) 2002-2013 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
    44 *
    55 * This file is part of HeuristicLab.
    … …  
    3131[assembly: AssemblyCompany("")]
    3232[assembly: AssemblyProduct("HeuristicLab")]
    33 [assembly: AssemblyCopyright("(c) 2002-2012 HEAL")]
     33[assembly: AssemblyCopyright("(c) 2002-2013 HEAL")]
    3434[assembly: AssemblyTrademark("")]
    3535[assembly: AssemblyCulture("")]
    … …  
    5353// by using the '*' as shown below:
    5454[assembly: AssemblyVersion("3.3.0.0")]
    55 [assembly: AssemblyFileVersion("3.3.7.$WCREV$")]
     55[assembly: AssemblyFileVersion("3.3.8.$WCREV$")]

  • branches/DataAnalysis.IslandAlgorithms/HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm

  • branches/DataAnalysis.IslandAlgorithms/HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm/3.3/IslandOffspringSelectionGeneticAlgorithm.cs

    r8121 r9756  
    11#region License Information
    22/* HeuristicLab
    3  * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
     3 * Copyright (C) 2002-2013 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
    44 *
    55 * This file is part of HeuristicLab.
    … …  
    100100      get { return (ValueParameter<IntValue>)Parameters["Elites"]; }
    101101    }
     102    private IFixedValueParameter<BoolValue> ReevaluateElitesParameter {
     103      get { return (IFixedValueParameter<BoolValue>)Parameters["ReevaluateElites"]; }
     104    }
    102105    private ValueLookupParameter<DoubleValue> SuccessRatioParameter {
    103106      get { return (ValueLookupParameter<DoubleValue>)Parameters["SuccessRatio"]; }
    … …  
    192195      get { return ElitesParameter.Value; }
    193196      set { ElitesParameter.Value = value; }
     197    }
     198    public bool ReevaluteElites {
     199      get { return ReevaluateElitesParameter.Value.Value; }
     200      set { ReevaluateElitesParameter.Value.Value = value; }
    194201    }
    195202    private DoubleValue SuccessRatio {
    … …  
    257264    [StorableHook(HookType.AfterDeserialization)]
    258265    private void AfterDeserialization() {
    259       #region Backwards Compatibility
     266      // BackwardsCompatibility3.3
     267      #region Backwards compatible code, remove with 3.4
    260268      if (successfulOffspringAnalyzer == null)
    261269        successfulOffspringAnalyzer = new SuccessfulOffspringAnalyzer();
     270      if (!Parameters.ContainsKey("ReevaluateElites")) {
     271        Parameters.Add(new FixedValueParameter<BoolValue>("ReevaluateElites", "Flag to determine if elite individuals should be reevaluated (i.e., if stochastic fitness functions are used.)", (BoolValue)new BoolValue(false).AsReadOnly()) { Hidden = true });
     272      }
    262273      #endregion
    263274
    … …  
    293304      Parameters.Add(new OptionalConstrainedValueParameter<IManipulator>("Mutator", "The operator used to mutate solutions."));
    294305      Parameters.Add(new ValueParameter<IntValue>("Elites", "The numer of elite solutions which are kept in each generation.", new IntValue(1)));
     306      Parameters.Add(new FixedValueParameter<BoolValue>("ReevaluateElites", "Flag to determine if elite individuals should be reevaluated (i.e., if stochastic fitness functions are used.)", new BoolValue(false)) { Hidden = true });
    295307      Parameters.Add(new ValueLookupParameter<DoubleValue>("SuccessRatio", "The ratio of successful to total children that should be achieved.", new DoubleValue(1)));
    296308      Parameters.Add(new ValueLookupParameter<DoubleValue>("ComparisonFactorLowerBound", "The lower bound of the comparison factor (start).", new DoubleValue(0)));
    … …  
    355367      mainLoop.CrossoverParameter.ActualName = CrossoverParameter.Name;
    356368      mainLoop.ElitesParameter.ActualName = ElitesParameter.Name;
     369      mainLoop.ReevaluateElitesParameter.ActualName = ReevaluateElitesParameter.Name;
    357370      mainLoop.MutatorParameter.ActualName = MutatorParameter.Name;
    358371      mainLoop.MutationProbabilityParameter.ActualName = MutationProbabilityParameter.Name;

  • branches/DataAnalysis.IslandAlgorithms/HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm/3.3/IslandOffspringSelectionGeneticAlgorithmMainLoop.cs

    r7259 r9756  
    11#region License Information
    22/* HeuristicLab
    3  * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
     3 * Copyright (C) 2002-2013 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
    44 *
    55 * This file is part of HeuristicLab.
    … …  
    9090    public ValueLookupParameter<IntValue> ElitesParameter {
    9191      get { return (ValueLookupParameter<IntValue>)Parameters["Elites"]; }
     92    }
     93    public IValueLookupParameter<BoolValue> ReevaluateElitesParameter {
     94      get { return (IValueLookupParameter<BoolValue>)Parameters["ReevaluateElites"]; }
    9295    }
    9396    public ValueLookupParameter<ResultCollection> ResultsParameter {
    … …  
    158161      Parameters.Add(new ValueLookupParameter<IOperator>("Evaluator", "The operator used to evaluate solutions. This operator is executed in parallel, if an engine is used which supports parallelization."));
    159162      Parameters.Add(new ValueLookupParameter<IntValue>("Elites", "The numer of elite solutions which are kept in each generation."));
     163      Parameters.Add(new ValueLookupParameter<BoolValue>("ReevaluateElites", "Flag to determine if elite individuals should be reevaluated (i.e., if stochastic fitness functions are used.)"));
    160164      Parameters.Add(new ValueLookupParameter<ResultCollection>("Results", "The results collection to store the results."));
    161165      Parameters.Add(new ValueLookupParameter<IOperator>("Visualizer", "The operator used to visualize solutions."));
    … …  
    248252      mainOperator.CurrentSuccessRatioParameter.ActualName = "CurrentSuccessRatio";
    249253      mainOperator.ElitesParameter.ActualName = ElitesParameter.Name;
     254      mainOperator.ReevaluateElitesParameter.ActualName = ReevaluateElitesParameter.Name;
    250255      mainOperator.EvaluatedSolutionsParameter.ActualName = EvaluatedSolutionsParameter.Name;
    251256      mainOperator.EvaluatorParameter.ActualName = EvaluatorParameter.Name;
    … …  
    414419    }
    415420
     421    [StorableHook(HookType.AfterDeserialization)]
     422    private void AfterDeserialization() {
     423      // BackwardsCompatibility3.3
     424      #region Backwards compatible code, remove with 3.4
     425      if (!Parameters.ContainsKey("ReevaluateElites")) {
     426        Parameters.Add(new ValueLookupParameter<BoolValue>("ReevaluateElites", "Flag to determine if elite individuals should be reevaluated (i.e., if stochastic fitness functions are used.)"));
     427      }
     428      #endregion
     429    }
     430
    416431    public override IOperation Apply() {
    417432      if (CrossoverParameter.ActualValue == null)

  • branches/DataAnalysis.IslandAlgorithms/HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm/3.3/OffspringSelectionGeneticAlgorithm.cs

    r8121 r9756  
    11#region License Information
    22/* HeuristicLab
    3  * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
     3 * Copyright (C) 2002-2013 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
    44 *
    55 * This file is part of HeuristicLab.
    … …  
    7979      get { return (ValueParameter<IntValue>)Parameters["Elites"]; }
    8080    }
     81    private IFixedValueParameter<BoolValue> ReevaluateElitesParameter {
     82      get { return (IFixedValueParameter<BoolValue>)Parameters["ReevaluateElites"]; }
     83    }
    8184    private ValueParameter<IntValue> MaximumGenerationsParameter {
    8285      get { return (ValueParameter<IntValue>)Parameters["MaximumGenerations"]; }
    … …  
    143146      get { return ElitesParameter.Value; }
    144147      set { ElitesParameter.Value = value; }
     148    }
     149    public bool ReevaluteElites {
     150      get { return ReevaluateElitesParameter.Value.Value; }
     151      set { ReevaluateElitesParameter.Value.Value = value; }
    145152    }
    146153    public IntValue MaximumGenerations {
    … …  
    205212    [StorableHook(HookType.AfterDeserialization)]
    206213    private void AfterDeserialization() {
    207       #region Backwards Compatibility
     214      // BackwardsCompatibility3.3
     215      #region Backwards compatible code, remove with 3.4
    208216      if (successfulOffspringAnalyzer == null)
    209217        successfulOffspringAnalyzer = new SuccessfulOffspringAnalyzer();
     218      if (!Parameters.ContainsKey("ReevaluateElites")) {
     219        Parameters.Add(new FixedValueParameter<BoolValue>("ReevaluateElites", "Flag to determine if elite individuals should be reevaluated (i.e., if stochastic fitness functions are used.)", (BoolValue)new BoolValue(false).AsReadOnly()) { Hidden = true });
     220      }
    210221      #endregion
    211222
    … …  
    232243      Parameters.Add(new OptionalConstrainedValueParameter<IManipulator>("Mutator", "The operator used to mutate solutions."));
    233244      Parameters.Add(new ValueParameter<IntValue>("Elites", "The numer of elite solutions which are kept in each generation.", new IntValue(1)));
     245      Parameters.Add(new FixedValueParameter<BoolValue>("ReevaluateElites", "Flag to determine if elite individuals should be reevaluated (i.e., if stochastic fitness functions are used.)", new BoolValue(false)) { Hidden = true });
    234246      Parameters.Add(new ValueParameter<IntValue>("MaximumGenerations", "The maximum number of generations which should be processed.", new IntValue(1000)));
    235247      Parameters.Add(new ValueLookupParameter<DoubleValue>("SuccessRatio", "The ratio of successful to total children that should be achieved.", new DoubleValue(1)));
    … …  
    274286      mainLoop.CrossoverParameter.ActualName = CrossoverParameter.Name;
    275287      mainLoop.ElitesParameter.ActualName = ElitesParameter.Name;
     288      mainLoop.ReevaluateElitesParameter.ActualName = ReevaluateElitesParameter.Name;
    276289      mainLoop.EvaluatedSolutionsParameter.ActualName = "EvaluatedSolutions";
    277290      mainLoop.MaximumGenerationsParameter.ActualName = MaximumGenerationsParameter.Name;

  • branches/DataAnalysis.IslandAlgorithms/HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm/3.3/OffspringSelectionGeneticAlgorithmMainLoop.cs

    r7259 r9756  
    11#region License Information
    22/* HeuristicLab
    3  * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
     3 * Copyright (C) 2002-2013 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
    44 *
    55 * This file is part of HeuristicLab.
    … …  
    6363      get { return (ValueLookupParameter<IntValue>)Parameters["Elites"]; }
    6464    }
     65    public IValueLookupParameter<BoolValue> ReevaluateElitesParameter {
     66      get { return (IValueLookupParameter<BoolValue>)Parameters["ReevaluateElites"]; }
     67    }
    6568    public ValueLookupParameter<IntValue> MaximumGenerationsParameter {
    6669      get { return (ValueLookupParameter<IntValue>)Parameters["MaximumGenerations"]; }
    … …  
    106109      : base() {
    107110      Initialize();
     111    }
     112
     113    [StorableHook(HookType.AfterDeserialization)]
     114    private void AfterDeserialization() {
     115      // BackwardsCompatibility3.3
     116      #region Backwards compatible code, remove with 3.4
     117      if (!Parameters.ContainsKey("ReevaluateElites")) {
     118        Parameters.Add(new ValueLookupParameter<BoolValue>("ReevaluateElites", "Flag to determine if elite individuals should be reevaluated (i.e., if stochastic fitness functions are used.)"));
     119      }
     120      #endregion
    108121    }
    109122
    … …  
    120133      Parameters.Add(new ValueLookupParameter<IOperator>("Evaluator", "The operator used to evaluate solutions. This operator is executed in parallel, if an engine is used which supports parallelization."));
    121134      Parameters.Add(new ValueLookupParameter<IntValue>("Elites", "The numer of elite solutions which are kept in each generation."));
     135      Parameters.Add(new ValueLookupParameter<BoolValue>("ReevaluateElites", "Flag to determine if elite individuals should be reevaluated (i.e., if stochastic fitness functions are used.)"));
    122136      Parameters.Add(new ValueLookupParameter<IntValue>("MaximumGenerations", "The maximum number of generations which should be processed."));
    123137      Parameters.Add(new ValueLookupParameter<VariableCollection>("Results", "The variable collection where results should be stored."));
    … …  
    170184      mainOperator.CurrentSuccessRatioParameter.ActualName = "CurrentSuccessRatio";
    171185      mainOperator.ElitesParameter.ActualName = ElitesParameter.Name;
     186      mainOperator.ReevaluateElitesParameter.ActualName = ReevaluateElitesParameter.Name;
    172187      mainOperator.EvaluatedSolutionsParameter.ActualName = EvaluatedSolutionsParameter.Name;
    173188      mainOperator.EvaluatorParameter.ActualName = EvaluatorParameter.Name;

  • branches/DataAnalysis.IslandAlgorithms/HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm/3.3/OffspringSelectionGeneticAlgorithmMainOperator.cs

    r7259 r9756  
    11#region License Information
    22/* HeuristicLab
    3  * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
     3 * Copyright (C) 2002-2013 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
    44 *
    55 * This file is part of HeuristicLab.
    … …  
    6767      get { return (ValueLookupParameter<IntValue>)Parameters["Elites"]; }
    6868    }
     69    public IValueLookupParameter<BoolValue> ReevaluateElitesParameter {
     70      get { return (IValueLookupParameter<BoolValue>)Parameters["ReevaluateElites"]; }
     71    }
    6972    public LookupParameter<DoubleValue> ComparisonFactorParameter {
    7073      get { return (LookupParameter<DoubleValue>)Parameters["ComparisonFactor"]; }
    … …  
    98101      : base() {
    99102      Initialize();
     103    }
     104
     105    [StorableHook(HookType.AfterDeserialization)]
     106    private void AfterDeserialization() {
     107      // BackwardsCompatibility3.3
     108      #region Backwards compatible code, remove with 3.4
     109      if (!Parameters.ContainsKey("ReevaluateElites")) {
     110        Parameters.Add(new ValueLookupParameter<BoolValue>("ReevaluateElites", "Flag to determine if elite individuals should be reevaluated (i.e., if stochastic fitness functions are used.)"));
     111      }
     112      #endregion
    100113    }
    101114
    … …  
    112125      Parameters.Add(new LookupParameter<IntValue>("EvaluatedSolutions", "The number of evaluated solutions."));
    113126      Parameters.Add(new ValueLookupParameter<IntValue>("Elites", "The numer of elite solutions which are kept in each generation."));
     127      Parameters.Add(new ValueLookupParameter<BoolValue>("ReevaluateElites", "Flag to determine if elite individuals should be reevaluated (i.e., if stochastic fitness functions are used.)"));
    114128      Parameters.Add(new LookupParameter<DoubleValue>("ComparisonFactor", "The comparison factor is used to determine whether the offspring should be compared to the better parent, the worse parent or a quality value linearly interpolated between them. It is in the range [0;1]."));
    115129      Parameters.Add(new LookupParameter<DoubleValue>("CurrentSuccessRatio", "The current success ratio."));
    … …  
    159173      LeftReducer leftReducer = new LeftReducer();
    160174      MergingReducer mergingReducer2 = new MergingReducer();
     175      ConditionalBranch reevaluateElitesBranch = new ConditionalBranch();
     176      UniformSubScopesProcessor uniformSubScopesProcessor7 = new UniformSubScopesProcessor();
     177      Placeholder evaluator4 = new Placeholder();
     178      SubScopesCounter subScopesCounter4 = new SubScopesCounter();
    161179
    162180      selector.Name = "Selector (placeholder)";
    … …  
    253271      worstSelector.NumberOfSelectedSubScopesParameter.ActualName = ElitesParameter.Name;
    254272      worstSelector.QualityParameter.ActualName = QualityParameter.Name;
     273
     274      reevaluateElitesBranch.ConditionParameter.ActualName = "ReevaluateElites";
     275      reevaluateElitesBranch.Name = "Reevaluate elites ?";
     276
     277      uniformSubScopesProcessor7.Parallel.Value = true;
     278
     279      evaluator4.Name = "Evaluator (placeholder)";
     280      evaluator4.OperatorParameter.ActualName = EvaluatorParameter.Name;
     281
     282      subScopesCounter4.Name = "Increment EvaluatedSolutions";
     283      subScopesCounter4.ValueParameter.ActualName = EvaluatedSolutionsParameter.Name;
    255284      #endregion
    256285
    … …  
    310339      subScopesProcessor3.Successor = mergingReducer2;
    311340      bestSelector.Successor = rightReducer;
    312       rightReducer.Successor = null;
     341      rightReducer.Successor = reevaluateElitesBranch;
     342      reevaluateElitesBranch.TrueBranch = uniformSubScopesProcessor7;
     343      uniformSubScopesProcessor7.Operator = evaluator4;
     344      uniformSubScopesProcessor7.Successor = subScopesCounter4;
     345      subScopesCounter4.Successor = null;
     346      reevaluateElitesBranch.FalseBranch = null;
     347      reevaluateElitesBranch.Successor = null;
    313348      worstSelector.Successor = leftReducer;
    314349      leftReducer.Successor = null;

  • branches/DataAnalysis.IslandAlgorithms/HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm/3.3/Plugin.cs.frame

    r8246 r9756  
    11#region License Information
    22/* HeuristicLab
    3  * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
     3 * Copyright (C) 2002-2013 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
    44 *
    55 * This file is part of HeuristicLab.
    … …  
    2626  /// Plugin class for HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm plugin.
    2727  /// </summary>
    28   [Plugin("HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm", "3.3.7.$WCREV$")]
     28  [Plugin("HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm", "3.3.8.$WCREV$")]
    2929  [PluginFile("HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm-3.3.dll", PluginFileType.Assembly)]
    3030  [PluginDependency("HeuristicLab.Analysis", "3.3")]

  • branches/DataAnalysis.IslandAlgorithms/HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm/3.3/Properties/AssemblyInfo.cs.frame

    r8246 r9756  
    11#region License Information
    22/* HeuristicLab
    3  * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
     3 * Copyright (C) 2002-2013 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
    44 *
    55 * This file is part of HeuristicLab.
    … …  
    3131[assembly: AssemblyCompany("")]
    3232[assembly: AssemblyProduct("HeuristicLab")]
    33 [assembly: AssemblyCopyright("(c) 2002-2012 HEAL")]
     33[assembly: AssemblyCopyright("(c) 2002-2013 HEAL")]
    3434[assembly: AssemblyTrademark("")]
    3535[assembly: AssemblyCulture("")]
    … …  
    5353// by using the '*' as shown below:
    5454[assembly: AssemblyVersion("3.3.0.0")]
    55 [assembly: AssemblyFileVersion("3.3.7.$WCREV$")]
     55[assembly: AssemblyFileVersion("3.3.8.$WCREV$")]

  • branches/DataAnalysis.IslandAlgorithms/HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm/3.3/SASEGASA.cs

    r8121 r9756  
    11#region License Information
    22/* HeuristicLab
    3  * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
     3 * Copyright (C) 2002-2013 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
    44 *
    55 * This file is part of HeuristicLab.
    … …  
    8585      get { return (ValueParameter<IntValue>)Parameters["Elites"]; }
    8686    }
     87    private IFixedValueParameter<BoolValue> ReevaluateElitesParameter {
     88      get { return (IFixedValueParameter<BoolValue>)Parameters["ReevaluateElites"]; }
     89    }
    8790    private ValueLookupParameter<DoubleValue> SuccessRatioParameter {
    8891      get { return (ValueLookupParameter<DoubleValue>)Parameters["SuccessRatio"]; }
    … …  
    160163      get { return ElitesParameter.Value; }
    161164      set { ElitesParameter.Value = value; }
     165    }
     166    public bool ReevaluteElites {
     167      get { return ReevaluateElitesParameter.Value.Value; }
     168      set { ReevaluateElitesParameter.Value.Value = value; }
    162169    }
    163170    public DoubleValue SuccessRatio {
    … …  
    233240    [StorableHook(HookType.AfterDeserialization)]
    234241    private void AfterDeserialization() {
    235       #region Backwards Compatibility
     242      // BackwardsCompatibility3.3
     243      #region Backwards compatible code, remove with 3.4
    236244      if (successfulOffspringAnalyzer == null)
    237245        successfulOffspringAnalyzer = new SuccessfulOffspringAnalyzer();
     246      if (!Parameters.ContainsKey("ReevaluateElites")) {
     247        Parameters.Add(new FixedValueParameter<BoolValue>("ReevaluateElites", "Flag to determine if elite individuals should be reevaluated (i.e., if stochastic fitness functions are used.)", (BoolValue)new BoolValue(false).AsReadOnly()) { Hidden = true });
     248      }
    238249      #endregion
    239250
    … …  
    264275      Parameters.Add(new OptionalConstrainedValueParameter<IManipulator>("Mutator", "The operator used to mutate solutions."));
    265276      Parameters.Add(new ValueParameter<IntValue>("Elites", "The numer of elite solutions which are kept in each generation.", new IntValue(1)));
     277      Parameters.Add(new FixedValueParameter<BoolValue>("ReevaluateElites", "Flag to determine if elite individuals should be reevaluated (i.e., if stochastic fitness functions are used.)", new BoolValue(false)) { Hidden = true });
    266278      Parameters.Add(new ValueLookupParameter<DoubleValue>("SuccessRatio", "The ratio of successful to total children that should be achieved.", new DoubleValue(1)));
    267279      Parameters.Add(new ValueLookupParameter<DoubleValue>("ComparisonFactorLowerBound", "The lower bound of the comparison factor (start).", new DoubleValue(0.3)));
    … …  
    321333      mainLoop.CrossoverParameter.ActualName = CrossoverParameter.Name;
    322334      mainLoop.ElitesParameter.ActualName = ElitesParameter.Name;
     335      mainLoop.ReevaluateElitesParameter.ActualName = ReevaluateElitesParameter.Name;
    323336      mainLoop.MutatorParameter.ActualName = MutatorParameter.Name;
    324337      mainLoop.MutationProbabilityParameter.ActualName = MutationProbabilityParameter.Name;

  • branches/DataAnalysis.IslandAlgorithms/HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm/3.3/SASEGASAMainLoop.cs

    r7259 r9756  
    11#region License Information
    22/* HeuristicLab
    3  * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
     3 * Copyright (C) 2002-2013 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
    44 *
    55 * This file is part of HeuristicLab.
    … …  
    7373      get { return (ValueLookupParameter<IntValue>)Parameters["Elites"]; }
    7474    }
     75    public IValueLookupParameter<BoolValue> ReevaluateElitesParameter {
     76      get { return (IValueLookupParameter<BoolValue>)Parameters["ReevaluateElites"]; }
     77    }
    7578    public ValueLookupParameter<ResultCollection> ResultsParameter {
    7679      get { return (ValueLookupParameter<ResultCollection>)Parameters["Results"]; }
    … …  
    134137      Parameters.Add(new ValueLookupParameter<IOperator>("Evaluator", "The operator used to evaluate solutions. This operator is executed in parallel, if an engine is used which supports parallelization."));
    135138      Parameters.Add(new ValueLookupParameter<IntValue>("Elites", "The numer of elite solutions which are kept in each generation."));
     139      Parameters.Add(new ValueLookupParameter<BoolValue>("ReevaluateElites", "Flag to determine if elite individuals should be reevaluated (i.e., if stochastic fitness functions are used.)"));
    136140      Parameters.Add(new ValueLookupParameter<ResultCollection>("Results", "The results collection to store the results."));
    137141      Parameters.Add(new ValueLookupParameter<IOperator>("Analyzer", "The operator used to the analyze the villages."));
    … …  
    236240      mainOperator.CurrentSuccessRatioParameter.ActualName = "CurrentSuccessRatio";
    237241      mainOperator.ElitesParameter.ActualName = ElitesParameter.Name;
     242      mainOperator.ReevaluateElitesParameter.ActualName = ReevaluateElitesParameter.Name;
    238243      mainOperator.EvaluatedSolutionsParameter.ActualName = EvaluatedSolutionsParameter.Name;
    239244      mainOperator.EvaluatorParameter.ActualName = EvaluatorParameter.Name;
    … …  
    424429    }
    425430
     431    [StorableHook(HookType.AfterDeserialization)]
     432    private void AfterDeserialization() {
     433      // BackwardsCompatibility3.3
     434      #region Backwards compatible code, remove with 3.4
     435      if (!Parameters.ContainsKey("ReevaluateElites")) {
     436        Parameters.Add(new ValueLookupParameter<BoolValue>("ReevaluateElites", "Flag to determine if elite individuals should be reevaluated (i.e., if stochastic fitness functions are used.)"));
     437      }
     438      #endregion
     439    }
     440
    426441    public override IOperation Apply() {
    427442      if (CrossoverParameter.ActualValue == null)

  • branches/DataAnalysis.IslandAlgorithms/HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm/3.3/SuccessfulOffspringAnalysis/SuccessfulOffspringAnalyzer.cs

    r7259 r9756  
    11#region License Information
    22/* HeuristicLab
    3  * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
     3 * Copyright (C) 2002-2013 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
    44 *
    55 * This file is part of HeuristicLab.
Note: See TracChangeset for help on using the changeset viewer.