Changeset 3658


Ignore:
Timestamp:
05/05/10 23:27:50 (12 years ago)
Author:
swagner
Message:

Worked on refactoring of algorithm analysis and tracing (#999)

  • removed specific analyzer interfaces
  • adapted MultiAnalyzer
Location:
trunk/sources
Files:
3 deleted
38 edited

Legend:

Unmodified
Added
Removed
  • trunk/sources/HeuristicLab.Algorithms.GeneticAlgorithm/3.3/GeneticAlgorithm.cs

    r3618 r3658  
    7878      get { return (ValueParameter<IntValue>)Parameters["Elites"]; }
    7979    }
    80     private ValueParameter<MultiAnalyzer<IPopulationAnalyzer>> AnalyzerParameter {
    81       get { return (ValueParameter<MultiAnalyzer<IPopulationAnalyzer>>)Parameters["Analyzer"]; }
     80    private ValueParameter<MultiAnalyzer> AnalyzerParameter {
     81      get { return (ValueParameter<MultiAnalyzer>)Parameters["Analyzer"]; }
    8282    }
    8383    private ValueParameter<IntValue> MaximumGenerationsParameter {
     
    119119      set { ElitesParameter.Value = value; }
    120120    }
    121     public MultiAnalyzer<IPopulationAnalyzer> Analyzer {
     121    public MultiAnalyzer Analyzer {
    122122      get { return AnalyzerParameter.Value; }
    123123      set { AnalyzerParameter.Value = value; }
     
    153153      Parameters.Add(new OptionalConstrainedValueParameter<IManipulator>("Mutator", "The operator used to mutate solutions."));
    154154      Parameters.Add(new ValueParameter<IntValue>("Elites", "The numer of elite solutions which are kept in each generation.", new IntValue(1)));
    155       Parameters.Add(new ValueParameter<MultiAnalyzer<IPopulationAnalyzer>>("Analyzer", "The operator used to analyze each generation.", new MultiAnalyzer<IPopulationAnalyzer>()));
     155      Parameters.Add(new ValueParameter<MultiAnalyzer>("Analyzer", "The operator used to analyze each generation.", new MultiAnalyzer()));
    156156      Parameters.Add(new ValueParameter<IntValue>("MaximumGenerations", "The maximum number of generations which should be processed.", new IntValue(1000)));
    157157
     
    353353      Analyzer.Operators.Add(qualityAnalyzer);
    354354      if (Problem != null) {
    355         foreach (IPopulationAnalyzer analyzer in Problem.Operators.OfType<IPopulationAnalyzer>().OrderBy(x => x.Name))
     355        foreach (IAnalyzer analyzer in Problem.Operators.OfType<IAnalyzer>().OrderBy(x => x.Name))
    356356          Analyzer.Operators.Add(analyzer);
    357357      }
  • trunk/sources/HeuristicLab.Algorithms.GeneticAlgorithm/3.3/IslandGeneticAlgorithm.cs

    r3650 r3658  
    104104      get { return (ValueParameter<BoolValue>)Parameters["Parallel"]; }
    105105    }
    106     private ValueParameter<MultiAnalyzer<IMultiPopulationAnalyzer>> AnalyzerParameter {
    107       get { return (ValueParameter<MultiAnalyzer<IMultiPopulationAnalyzer>>)Parameters["Analyzer"]; }
    108     }
    109     private ValueParameter<MultiAnalyzer<IPopulationAnalyzer>> IslandAnalyzerParameter {
    110       get { return (ValueParameter<MultiAnalyzer<IPopulationAnalyzer>>)Parameters["IslandAnalyzer"]; }
     106    private ValueParameter<MultiAnalyzer> AnalyzerParameter {
     107      get { return (ValueParameter<MultiAnalyzer>)Parameters["Analyzer"]; }
     108    }
     109    private ValueParameter<MultiAnalyzer> IslandAnalyzerParameter {
     110      get { return (ValueParameter<MultiAnalyzer>)Parameters["IslandAnalyzer"]; }
    111111    }
    112112    #endregion
     
    177177      set { ParallelParameter.Value = value; }
    178178    }
    179     public MultiAnalyzer<IMultiPopulationAnalyzer> Analyzer {
     179    public MultiAnalyzer Analyzer {
    180180      get { return AnalyzerParameter.Value; }
    181181      set { AnalyzerParameter.Value = value; }
    182182    }
    183     public MultiAnalyzer<IPopulationAnalyzer> IslandAnalyzer {
     183    public MultiAnalyzer IslandAnalyzer {
    184184      get { return IslandAnalyzerParameter.Value; }
    185185      set { IslandAnalyzerParameter.Value = value; }
     
    228228      Parameters.Add(new ValueParameter<IntValue>("Elites", "The numer of elite solutions which are kept in each generation.", new IntValue(1)));
    229229      Parameters.Add(new ValueParameter<BoolValue>("Parallel", "True if the islands should be run in parallel (also requires a parallel engine)", new BoolValue(false)));
    230       Parameters.Add(new ValueParameter<MultiAnalyzer<IMultiPopulationAnalyzer>>("Analyzer", "The operator used to analyze the islands.", new MultiAnalyzer<IMultiPopulationAnalyzer>()));
    231       Parameters.Add(new ValueParameter<MultiAnalyzer<IPopulationAnalyzer>>("IslandAnalyzer", "The operator used to analyze each island.", new MultiAnalyzer<IPopulationAnalyzer>()));
     230      Parameters.Add(new ValueParameter<MultiAnalyzer>("Analyzer", "The operator used to analyze the islands.", new MultiAnalyzer()));
     231      Parameters.Add(new ValueParameter<MultiAnalyzer>("IslandAnalyzer", "The operator used to analyze each island.", new MultiAnalyzer()));
    232232     
    233233      RandomCreator randomCreator = new RandomCreator();
     
    513513      //Analyzer.Operators.Add(qualityAnalyzer);
    514514      if (Problem != null) {
    515         foreach (IPopulationAnalyzer analyzer in Problem.Operators.OfType<IPopulationAnalyzer>().OrderBy(x => x.Name)) {
     515        foreach (IAnalyzer analyzer in Problem.Operators.OfType<IAnalyzer>().OrderBy(x => x.Name)) {
    516516          IslandAnalyzer.Operators.Add(analyzer);
    517517        }
    518         foreach (IMultiPopulationAnalyzer analyzer in Problem.Operators.OfType<IMultiPopulationAnalyzer>().OrderBy(x => x.Name))
     518        foreach (IAnalyzer analyzer in Problem.Operators.OfType<IAnalyzer>().OrderBy(x => x.Name))
    519519          Analyzer.Operators.Add(analyzer);
    520520      }
  • trunk/sources/HeuristicLab.Algorithms.LocalSearch/3.3/LocalSearch.cs

    r3636 r3658  
    7272      get { return (ValueParameter<IntValue>)Parameters["SampleSize"]; }
    7373    }
    74     private ValueParameter<MultiAnalyzer<IPopulationAnalyzer>> MoveAnalyzerParameter {
    75       get { return (ValueParameter<MultiAnalyzer<IPopulationAnalyzer>>)Parameters["MoveAnalyzer"]; }
    76     }
    77     private ValueParameter<MultiAnalyzer<ISolutionAnalyzer>> AnalyzerParameter {
    78       get { return (ValueParameter<MultiAnalyzer<ISolutionAnalyzer>>)Parameters["Analyzer"]; }
     74    private ValueParameter<MultiAnalyzer> MoveAnalyzerParameter {
     75      get { return (ValueParameter<MultiAnalyzer>)Parameters["MoveAnalyzer"]; }
     76    }
     77    private ValueParameter<MultiAnalyzer> AnalyzerParameter {
     78      get { return (ValueParameter<MultiAnalyzer>)Parameters["Analyzer"]; }
    7979    }
    8080    #endregion
     
    109109      set { SampleSizeParameter.Value = value; }
    110110    }
    111     public MultiAnalyzer<IPopulationAnalyzer> MoveAnalyzer {
     111    public MultiAnalyzer MoveAnalyzer {
    112112      get { return MoveAnalyzerParameter.Value; }
    113113      set { MoveAnalyzerParameter.Value = value; }
    114114    }
    115     public MultiAnalyzer<ISolutionAnalyzer> Analyzer {
     115    public MultiAnalyzer Analyzer {
    116116      get { return AnalyzerParameter.Value; }
    117117      set { AnalyzerParameter.Value = value; }
     
    140140      Parameters.Add(new ValueParameter<IntValue>("MaximumIterations", "The maximum number of generations which should be processed.", new IntValue(1000)));
    141141      Parameters.Add(new ValueParameter<IntValue>("SampleSize", "Number of moves that MultiMoveGenerators should create. This is ignored for Exhaustive- and SingleMoveGenerators.", new IntValue(100)));
    142       Parameters.Add(new ValueParameter<MultiAnalyzer<IPopulationAnalyzer>>("MoveAnalyzer", "The operator used to analyze the moves.", new MultiAnalyzer<IPopulationAnalyzer>()));
    143       Parameters.Add(new ValueParameter<MultiAnalyzer<ISolutionAnalyzer>>("Analyzer", "The operator used to analyze the solution.", new MultiAnalyzer<ISolutionAnalyzer>()));
     142      Parameters.Add(new ValueParameter<MultiAnalyzer>("MoveAnalyzer", "The operator used to analyze the moves.", new MultiAnalyzer()));
     143      Parameters.Add(new ValueParameter<MultiAnalyzer>("Analyzer", "The operator used to analyze the solution.", new MultiAnalyzer()));
    144144     
    145145      RandomCreator randomCreator = new RandomCreator();
     
    319319      MoveAnalyzer.Operators.Add(moveQualityAnalyzer);
    320320      if (Problem != null) {
    321         foreach (ISolutionAnalyzer analyzer in Problem.Operators.OfType<ISolutionAnalyzer>().OrderBy(x => x.Name))
     321        foreach (IAnalyzer analyzer in Problem.Operators.OfType<IAnalyzer>().OrderBy(x => x.Name))
    322322          Analyzer.Operators.Add(analyzer);
    323323      }
  • trunk/sources/HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm/3.3/IslandOffspringSelectionGeneticAlgorithm.cs

    r3654 r3658  
    121121      get { return (ValueLookupParameter<BoolValue>)Parameters["OffspringSelectionBeforeMutation"]; }
    122122    }
    123     private ValueParameter<MultiAnalyzer<IMultiPopulationAnalyzer>> AnalyzerParameter {
    124       get { return (ValueParameter<MultiAnalyzer<IMultiPopulationAnalyzer>>)Parameters["Analyzer"]; }
    125     }
    126     private ValueParameter<MultiAnalyzer<IPopulationAnalyzer>> IslandAnalyzerParameter {
    127       get { return (ValueParameter<MultiAnalyzer<IPopulationAnalyzer>>)Parameters["IslandAnalyzer"]; }
     123    private ValueParameter<MultiAnalyzer> AnalyzerParameter {
     124      get { return (ValueParameter<MultiAnalyzer>)Parameters["Analyzer"]; }
     125    }
     126    private ValueParameter<MultiAnalyzer> IslandAnalyzerParameter {
     127      get { return (ValueParameter<MultiAnalyzer>)Parameters["IslandAnalyzer"]; }
    128128    }
    129129    #endregion
     
    218218      set { OffspringSelectionBeforeMutationParameter.Value = value; }
    219219    }
    220     public MultiAnalyzer<IMultiPopulationAnalyzer> Analyzer {
     220    public MultiAnalyzer Analyzer {
    221221      get { return AnalyzerParameter.Value; }
    222222      set { AnalyzerParameter.Value = value; }
    223223    }
    224     public MultiAnalyzer<IPopulationAnalyzer> IslandAnalyzer {
     224    public MultiAnalyzer IslandAnalyzer {
    225225      get { return IslandAnalyzerParameter.Value; }
    226226      set { IslandAnalyzerParameter.Value = value; }
     
    276276      Parameters.Add(new ValueLookupParameter<DoubleValue>("MaximumSelectionPressure", "The maximum selection pressure that terminates the algorithm.", new DoubleValue(100)));
    277277      Parameters.Add(new ValueLookupParameter<BoolValue>("OffspringSelectionBeforeMutation", "True if the offspring selection step should be applied before mutation, false if it should be applied after mutation.", new BoolValue(false)));
    278       Parameters.Add(new ValueParameter<MultiAnalyzer<IMultiPopulationAnalyzer>>("Analyzer", "The operator used to analyze the islands.", new MultiAnalyzer<IMultiPopulationAnalyzer>()));
    279       Parameters.Add(new ValueParameter<MultiAnalyzer<IPopulationAnalyzer>>("IslandAnalyzer", "The operator used to analyze each island.", new MultiAnalyzer<IPopulationAnalyzer>()));
     278      Parameters.Add(new ValueParameter<MultiAnalyzer>("Analyzer", "The operator used to analyze the islands.", new MultiAnalyzer()));
     279      Parameters.Add(new ValueParameter<MultiAnalyzer>("IslandAnalyzer", "The operator used to analyze each island.", new MultiAnalyzer()));
    280280     
    281281      RandomCreator randomCreator = new RandomCreator();
     
    613613      //Analyzer.Operators.Add(qualityAnalyzer);
    614614      if (Problem != null) {
    615         foreach (IPopulationAnalyzer analyzer in Problem.Operators.OfType<IPopulationAnalyzer>().OrderBy(x => x.Name)) {
     615        foreach (IAnalyzer analyzer in Problem.Operators.OfType<IAnalyzer>().OrderBy(x => x.Name)) {
    616616          IslandAnalyzer.Operators.Add(analyzer);
    617617        }
    618         foreach (IMultiPopulationAnalyzer analyzer in Problem.Operators.OfType<IMultiPopulationAnalyzer>().OrderBy(x => x.Name))
     618        foreach (IAnalyzer analyzer in Problem.Operators.OfType<IAnalyzer>().OrderBy(x => x.Name))
    619619          Analyzer.Operators.Add(analyzer);
    620620      }
  • trunk/sources/HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm/3.3/OffspringSelectionGeneticAlgorithm.cs

    r3650 r3658  
    101101      get { return (ValueLookupParameter<IntValue>)Parameters["SelectedParents"]; }
    102102    }
    103     private ValueParameter<MultiAnalyzer<IPopulationAnalyzer>> AnalyzerParameter {
    104       get { return (ValueParameter<MultiAnalyzer<IPopulationAnalyzer>>)Parameters["Analyzer"]; }
     103    private ValueParameter<MultiAnalyzer> AnalyzerParameter {
     104      get { return (ValueParameter<MultiAnalyzer>)Parameters["Analyzer"]; }
    105105    }
    106106    #endregion
     
    171171      set { SelectedParentsParameter.Value = value; }
    172172    }
    173     public MultiAnalyzer<IPopulationAnalyzer> Analyzer {
     173    public MultiAnalyzer Analyzer {
    174174      get { return AnalyzerParameter.Value; }
    175175      set { AnalyzerParameter.Value = value; }
     
    211211      Parameters.Add(new ValueLookupParameter<BoolValue>("OffspringSelectionBeforeMutation", "True if the offspring selection step should be applied before mutation, false if it should be applied after mutation.", new BoolValue(false)));
    212212      Parameters.Add(new ValueLookupParameter<IntValue>("SelectedParents", "Should be about 2 * PopulationSize, for large problems use a smaller value to decrease memory footprint.", new IntValue(200)));
    213       Parameters.Add(new ValueParameter<MultiAnalyzer<IPopulationAnalyzer>>("Analyzer", "The operator used to analyze each generation.", new MultiAnalyzer<IPopulationAnalyzer>()));
     213      Parameters.Add(new ValueParameter<MultiAnalyzer>("Analyzer", "The operator used to analyze each generation.", new MultiAnalyzer()));
    214214     
    215215      RandomCreator randomCreator = new RandomCreator();
     
    436436      //Analyzer.Operators.Add(qualityAnalyzer);
    437437      if (Problem != null) {
    438         foreach (IPopulationAnalyzer analyzer in Problem.Operators.OfType<IPopulationAnalyzer>().OrderBy(x => x.Name))
     438        foreach (IAnalyzer analyzer in Problem.Operators.OfType<IAnalyzer>().OrderBy(x => x.Name))
    439439          Analyzer.Operators.Add(analyzer);
    440440      }
  • trunk/sources/HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm/3.3/SASEGASA.cs

    r3656 r3658  
    113113      get { return (ValueLookupParameter<IntValue>)Parameters["SelectedParents"]; }
    114114    }
    115     private ValueParameter<MultiAnalyzer<IMultiPopulationAnalyzer>> AnalyzerParameter {
    116       get { return (ValueParameter<MultiAnalyzer<IMultiPopulationAnalyzer>>)Parameters["Analyzer"]; }
    117     }
    118     private ValueParameter<MultiAnalyzer<IPopulationAnalyzer>> VillageAnalyzerParameter {
    119       get { return (ValueParameter<MultiAnalyzer<IPopulationAnalyzer>>)Parameters["VillageAnalyzer"]; }
     115    private ValueParameter<MultiAnalyzer> AnalyzerParameter {
     116      get { return (ValueParameter<MultiAnalyzer>)Parameters["Analyzer"]; }
     117    }
     118    private ValueParameter<MultiAnalyzer> VillageAnalyzerParameter {
     119      get { return (ValueParameter<MultiAnalyzer>)Parameters["VillageAnalyzer"]; }
    120120    }
    121121    #endregion
     
    198198      set { SelectedParentsParameter.Value = value; }
    199199    }
    200     public MultiAnalyzer<IMultiPopulationAnalyzer> Analyzer {
     200    public MultiAnalyzer Analyzer {
    201201      get { return AnalyzerParameter.Value; }
    202202      set { AnalyzerParameter.Value = value; }
    203203    }
    204     public MultiAnalyzer<IPopulationAnalyzer> VillageAnalyzer {
     204    public MultiAnalyzer VillageAnalyzer {
    205205      get { return VillageAnalyzerParameter.Value; }
    206206      set { VillageAnalyzerParameter.Value = value; }
     
    250250      Parameters.Add(new ValueLookupParameter<BoolValue>("OffspringSelectionBeforeMutation", "True if the offspring selection step should be applied before mutation, false if it should be applied after mutation.", new BoolValue(false)));
    251251      Parameters.Add(new ValueLookupParameter<IntValue>("SelectedParents", "Should be about 2 * PopulationSize, for large problems use a smaller value to decrease memory footprint.", new IntValue(200)));
    252       Parameters.Add(new ValueParameter<MultiAnalyzer<IMultiPopulationAnalyzer>>("Analyzer", "The operator used to analyze the villages.", new MultiAnalyzer<IMultiPopulationAnalyzer>()));
    253       Parameters.Add(new ValueParameter<MultiAnalyzer<IPopulationAnalyzer>>("VillageAnalyzer", "The operator used to analyze each village.", new MultiAnalyzer<IPopulationAnalyzer>()));
     252      Parameters.Add(new ValueParameter<MultiAnalyzer>("Analyzer", "The operator used to analyze the villages.", new MultiAnalyzer()));
     253      Parameters.Add(new ValueParameter<MultiAnalyzer>("VillageAnalyzer", "The operator used to analyze each village.", new MultiAnalyzer()));
    254254     
    255255      RandomCreator randomCreator = new RandomCreator();
     
    523523      //Analyzer.Operators.Add(qualityAnalyzer);
    524524      if (Problem != null) {
    525         foreach (IPopulationAnalyzer analyzer in Problem.Operators.OfType<IPopulationAnalyzer>().OrderBy(x => x.Name)) {
     525        foreach (IAnalyzer analyzer in Problem.Operators.OfType<IAnalyzer>().OrderBy(x => x.Name)) {
    526526          VillageAnalyzer.Operators.Add(analyzer);
    527527        }
    528         foreach (IMultiPopulationAnalyzer analyzer in Problem.Operators.OfType<IMultiPopulationAnalyzer>().OrderBy(x => x.Name))
     528        foreach (IAnalyzer analyzer in Problem.Operators.OfType<IAnalyzer>().OrderBy(x => x.Name))
    529529          Analyzer.Operators.Add(analyzer);
    530530      }
  • trunk/sources/HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm/3.3/SASEGASAMainLoop.cs

    r3656 r3658  
    364364      resultsCollector2.CollectedValues.Add(new LookupParameter<IntValue>("Generations"));
    365365      resultsCollector2.CollectedValues.Add(new LookupParameter<IntValue>("Evaluated Solutions", null, "EvaluatedSolutions"));
    366       resultsCollector1.CollectedValues.Add(new LookupParameter<DoubleValue>("ComparisonFactor", null, "ComparisonFactor"));
    367       resultsCollector1.CollectedValues.Add(new LookupParameter<IntValue>("Terminated Villages", null, "TerminatedVillages"));
     366      resultsCollector2.CollectedValues.Add(new LookupParameter<DoubleValue>("ComparisonFactor", null, "ComparisonFactor"));
     367      resultsCollector2.CollectedValues.Add(new LookupParameter<IntValue>("Terminated Villages", null, "TerminatedVillages"));
    368368      resultsCollector2.CollectedValues.Add(new LookupParameter<IntValue>("Total Active Villages", null, "VillageCount"));
    369369      resultsCollector2.ResultsParameter.ActualName = ResultsParameter.Name;
  • trunk/sources/HeuristicLab.Algorithms.SimulatedAnnealing/3.3/SimulatedAnnealing.cs

    r3626 r3658  
    8181      get { return (ValueParameter<DoubleValue>)Parameters["EndTemperature"]; }
    8282    }
    83     private ValueParameter<MultiAnalyzer<ISolutionAnalyzer>> AnalyzerParameter {
    84       get { return (ValueParameter<MultiAnalyzer<ISolutionAnalyzer>>)Parameters["Analyzer"]; }
     83    private ValueParameter<MultiAnalyzer> AnalyzerParameter {
     84      get { return (ValueParameter<MultiAnalyzer>)Parameters["Analyzer"]; }
    8585    }
    8686    #endregion
     
    123123      set { EndTemperatureParameter.Value = value; }
    124124    }
    125     public MultiAnalyzer<ISolutionAnalyzer> Analyzer {
     125    public MultiAnalyzer Analyzer {
    126126      get { return AnalyzerParameter.Value; }
    127127      set { AnalyzerParameter.Value = value; }
     
    158158      Parameters.Add(new ValueParameter<DoubleValue>("StartTemperature", "The initial temperature.", new DoubleValue(100)));
    159159      Parameters.Add(new ValueParameter<DoubleValue>("EndTemperature", "The final temperature which should be reached when iterations reaches maximum iterations.", new DoubleValue(1e-6)));
    160       Parameters.Add(new ValueParameter<MultiAnalyzer<ISolutionAnalyzer>>("Analyzer", "The operator used to analyze each generation.", new MultiAnalyzer<ISolutionAnalyzer>()));
     160      Parameters.Add(new ValueParameter<MultiAnalyzer>("Analyzer", "The operator used to analyze each generation.", new MultiAnalyzer()));
    161161     
    162162      RandomCreator randomCreator = new RandomCreator();
     
    401401      Analyzer.Operators.Add(qualityAnalyzer);
    402402      if (Problem != null) {
    403         foreach (ISolutionAnalyzer analyzer in Problem.Operators.OfType<ISolutionAnalyzer>().OrderBy(x => x.Name))
     403        foreach (IAnalyzer analyzer in Problem.Operators.OfType<IAnalyzer>().OrderBy(x => x.Name))
    404404          Analyzer.Operators.Add(analyzer);
    405405      }
  • trunk/sources/HeuristicLab.Algorithms.TabuSearch/3.3/TabuNeighborhoodAnalyzer.cs

    r3636 r3658  
    2828
    2929namespace HeuristicLab.Algorithms.TabuSearch {
    30   public class TabuNeighborhoodAnalyzer : SingleSuccessorOperator, IPopulationAnalyzer {
     30  public class TabuNeighborhoodAnalyzer : SingleSuccessorOperator, IAnalyzer {
    3131    public SubScopesLookupParameter<BoolValue> IsTabuParameter {
    3232      get { return (SubScopesLookupParameter<BoolValue>)Parameters["IsTabu"]; }
  • trunk/sources/HeuristicLab.Algorithms.TabuSearch/3.3/TabuSearch.cs

    r3636 r3658  
    8181      get { return (ValueParameter<IntValue>)Parameters["SampleSize"]; }
    8282    }
    83     private ValueParameter<MultiAnalyzer<IPopulationAnalyzer>> MoveAnalyzerParameter {
    84       get { return (ValueParameter<MultiAnalyzer<IPopulationAnalyzer>>)Parameters["MoveAnalyzer"]; }
    85     }
    86     private ValueParameter<MultiAnalyzer<ISolutionAnalyzer>> AnalyzerParameter {
    87       get { return (ValueParameter<MultiAnalyzer<ISolutionAnalyzer>>)Parameters["Analyzer"]; }
     83    private ValueParameter<MultiAnalyzer> MoveAnalyzerParameter {
     84      get { return (ValueParameter<MultiAnalyzer>)Parameters["MoveAnalyzer"]; }
     85    }
     86    private ValueParameter<MultiAnalyzer> AnalyzerParameter {
     87      get { return (ValueParameter<MultiAnalyzer>)Parameters["Analyzer"]; }
    8888    }
    8989    #endregion
     
    126126      set { MaximumIterationsParameter.Value = value; }
    127127    }
    128     public MultiAnalyzer<IPopulationAnalyzer> MoveAnalyzer {
     128    public MultiAnalyzer MoveAnalyzer {
    129129      get { return MoveAnalyzerParameter.Value; }
    130130      set { MoveAnalyzerParameter.Value = value; }
    131131    }
    132     public MultiAnalyzer<ISolutionAnalyzer> Analyzer {
     132    public MultiAnalyzer Analyzer {
    133133      get { return AnalyzerParameter.Value; }
    134134      set { AnalyzerParameter.Value = value; }
     
    159159      Parameters.Add(new ValueParameter<IntValue>("MaximumIterations", "The maximum number of generations which should be processed.", new IntValue(1000)));
    160160      Parameters.Add(new ValueParameter<IntValue>("SampleSize", "The neighborhood size for stochastic sampling move generators", new IntValue(100)));
    161       Parameters.Add(new ValueParameter<MultiAnalyzer<IPopulationAnalyzer>>("MoveAnalyzer", "The operator used to analyze the moves.", new MultiAnalyzer<IPopulationAnalyzer>()));
    162       Parameters.Add(new ValueParameter<MultiAnalyzer<ISolutionAnalyzer>>("Analyzer", "The operator used to analyze the solution.", new MultiAnalyzer<ISolutionAnalyzer>()));
     161      Parameters.Add(new ValueParameter<MultiAnalyzer>("MoveAnalyzer", "The operator used to analyze the moves.", new MultiAnalyzer()));
     162      Parameters.Add(new ValueParameter<MultiAnalyzer>("Analyzer", "The operator used to analyze the solution.", new MultiAnalyzer()));
    163163     
    164164      RandomCreator randomCreator = new RandomCreator();
     
    392392      MoveAnalyzer.Operators.Add(tabuNeighborhoodAnalyzer);
    393393      if (Problem != null) {
    394         foreach (ISolutionAnalyzer analyzer in Problem.Operators.OfType<ISolutionAnalyzer>().OrderBy(x => x.Name))
     394        foreach (IAnalyzer analyzer in Problem.Operators.OfType<IAnalyzer>().OrderBy(x => x.Name))
    395395          Analyzer.Operators.Add(analyzer);
    396396      }
  • trunk/sources/HeuristicLab.Analysis/3.3/MultiAnalyzer.cs

    r3618 r3658  
    3232  /// An analyzer which applies arbitrary many other analyzers.
    3333  /// </summary>
    34   [Item("MultiAnalyzer<T>", "An analyzer which applies arbitrary many other analyzers.")]
     34  [Item("MultiAnalyzer", "An analyzer which applies arbitrary many other analyzers.")]
    3535  [StorableClass]
    36   public class MultiAnalyzer<T> : CheckedMultiOperator<T>, IAnalyzer where T : class, IAnalyzer {
     36  public class MultiAnalyzer : CheckedMultiOperator<IAnalyzer>, IAnalyzer {
    3737    public override bool CanChangeName {
    3838      get { return false; }
     
    6969        counter.Value = 0;
    7070        OperationCollection next = new OperationCollection();
    71         foreach (IndexedItem<T> item in Operators.CheckedItems)
     71        foreach (IndexedItem<IAnalyzer> item in Operators.CheckedItems)
    7272          next.Add(ExecutionContext.CreateOperation(item.Value));
    7373        next.Add(base.Apply());
  • trunk/sources/HeuristicLab.Analysis/3.3/PopulationBestAverageWorstQualityAnalyzer.cs

    r3623 r3658  
    3434  [Item("PopulationBestAverageWorstQualityAnalyzer", "An operator which analyzes the best, average and worst solution quality in the current population.")]
    3535  [StorableClass]
    36   public sealed class PopulationBestAverageWorstQualityAnalyzer : AlgorithmOperator, IPopulationAnalyzer {
     36  public sealed class PopulationBestAverageWorstQualityAnalyzer : AlgorithmOperator, IAnalyzer {
    3737    #region Parameter properties
    3838    public ValueLookupParameter<BoolValue> MaximizationParameter {
  • trunk/sources/HeuristicLab.Analysis/3.3/PopulationMinAverageMaxValueAnalyzer.cs

    r3623 r3658  
    3434  [Item("PopulationMinAverageMaxValueAnalyzer", "An operator which analyzes the minimum, average and maximum of a value in the current population.")]
    3535  [StorableClass]
    36   public sealed class PopulationMinAverageMaxValueAnalyzer : AlgorithmOperator, IPopulationAnalyzer {
     36  public sealed class PopulationMinAverageMaxValueAnalyzer : AlgorithmOperator, IAnalyzer {
    3737    #region Parameter properties
    3838    public SubScopesLookupParameter<DoubleValue> ValueParameter {
  • trunk/sources/HeuristicLab.Analysis/3.3/PopulationQualityAnalyzer.cs

    r3623 r3658  
    3434  [Item("PopulationQualityAnalyzer", "An operator which analyzes the solution qualities in the current population.")]
    3535  [StorableClass]
    36   public sealed class PopulationQualityAnalyzer : AlgorithmOperator, IPopulationAnalyzer {
     36  public sealed class PopulationQualityAnalyzer : AlgorithmOperator, IAnalyzer {
    3737    #region Parameter properties
    3838    public ValueLookupParameter<BoolValue> MaximizationParameter {
  • trunk/sources/HeuristicLab.Analysis/3.3/PopulationValueAnalyzer.cs

    r3623 r3658  
    3434  [Item("PopulationValueAnalyzer", "An operator which analyzes a value in the current population.")]
    3535  [StorableClass]
    36   public sealed class PopulationValueAnalyzer : AlgorithmOperator, IPopulationAnalyzer {
     36  public sealed class PopulationValueAnalyzer : AlgorithmOperator, IAnalyzer {
    3737    #region Parameter properties
    3838    public SubScopesLookupParameter<DoubleValue> ValueParameter {
  • trunk/sources/HeuristicLab.Analysis/3.3/SolutionQualityAnalyzer.cs

    r3623 r3658  
    3434  [Item("SolutionQualityAnalyzer", "An operator which analyzes the quality of the current solution.")]
    3535  [StorableClass]
    36   public sealed class SolutionQualityAnalyzer : AlgorithmOperator, ISolutionAnalyzer {
     36  public sealed class SolutionQualityAnalyzer : AlgorithmOperator, IAnalyzer {
    3737    #region Parameter properties
    3838    public ValueLookupParameter<BoolValue> MaximizationParameter {
  • trunk/sources/HeuristicLab.Analysis/3.3/SolutionValueAnalyzer.cs

    r3623 r3658  
    3434  [Item("SolutionValueAnalyzer", "An operator which analyzes a value of the current solution.")]
    3535  [StorableClass]
    36   public sealed class SolutionValueAnalyzer : AlgorithmOperator, ISolutionAnalyzer {
     36  public sealed class SolutionValueAnalyzer : AlgorithmOperator, IAnalyzer {
    3737    #region Parameter properties
    3838    public LookupParameter<DoubleValue> ValueParameter {
  • trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.3/Interfaces/ISymbolicExpressionTreeAnalyzer.cs

    r3651 r3658  
    3434  /// Interface for analyzers that can be applied to symbolic expression trees.
    3535  /// </summary>
    36   public interface ISymbolicExpressionTreeAnalyzer : ISolutionAnalyzer {
     36  public interface ISymbolicExpressionTreeAnalyzer : IAnalyzer {
    3737    ILookupParameter<SymbolicExpressionTree> SymbolicExpressionTreeParameter { get; }
    3838  }
  • trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.3/Interfaces/ISymbolicExpressionTreeMultiPopulationAnalyzer.cs

    r3651 r3658  
    3434  /// Interface for analyzers that can be applied to multiple populations of symbolic expression trees.
    3535  /// </summary>
    36   public interface ISymbolicExpressionTreeMultiPopulationAnalyzer : IMultiPopulationAnalyzer {
     36  public interface ISymbolicExpressionTreeMultiPopulationAnalyzer : IAnalyzer {
    3737    ILookupParameter<ItemArray<ItemArray<SymbolicExpressionTree>>> SymbolicExpressionTreeParameter { get; }
    3838  }
  • trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.3/Interfaces/ISymbolicExpressionTreePopulationAnalyzer.cs

    r3651 r3658  
    3434  /// Interface for analyzers that can be applied to populations of symbolic expression trees.
    3535  /// </summary>
    36   public interface ISymbolicExpressionTreePopulationAnalyzer : IPopulationAnalyzer {
     36  public interface ISymbolicExpressionTreePopulationAnalyzer : IAnalyzer {
    3737    ILookupParameter<ItemArray<SymbolicExpressionTree>> SymbolicExpressionTreeParameter { get; }
    3838  }
  • trunk/sources/HeuristicLab.MainForm.WindowsForms/3.3/ViewHost.Designer.cs

    r3657 r3658  
    4646    private void InitializeComponent() {
    4747      this.components = new System.ComponentModel.Container();
    48       System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(ViewHost));
    4948      this.viewPanel = new HeuristicLab.MainForm.WindowsForms.ViewHostPanel();
    5049      this.messageLabel = new System.Windows.Forms.Label();
  • trunk/sources/HeuristicLab.Optimization/3.3/HeuristicLab.Optimization-3.3.csproj

    r3618 r3658  
    8787    <Compile Include="Algorithm.cs" />
    8888    <Compile Include="BatchRun.cs" />
    89     <Compile Include="Interfaces\IMultiPopulationAnalyzer.cs" />
    90     <Compile Include="Interfaces\IPopulationAnalyzer.cs" />
    91     <Compile Include="Interfaces\ISolutionAnalyzer.cs" />
    9289    <Compile Include="RunCollectionConstraints\RunCollectionComparisonConstraint.cs" />
    9390    <Compile Include="RunCollectionConstraints\RunCollectionConstraintCollection.cs" />
  • trunk/sources/HeuristicLab.Optimizer/3.3/HeuristicLab.Optimizer-3.3.csproj

    r3529 r3658  
    179179  </ItemGroup>
    180180  <ItemGroup>
    181     <EmbeddedResource Include="Documents\GA_TSP.hl" />
    182181    <EmbeddedResource Include="Properties\Resources.resx">
    183182      <Generator>ResXFileCodeGenerator</Generator>
     
    186185  </ItemGroup>
    187186  <ItemGroup>
    188     <EmbeddedResource Include="Documents\ES_Griewank.hl" />
    189187    <None Include="Documents\Images\New.png" />
    190188    <None Include="Documents\Images\Open.png" />
     
    193191    <None Include="Documents\Images\Restart.png" />
    194192    <None Include="Documents\Images\Stop.png" />
    195     <EmbeddedResource Include="Documents\IslandGA_TSP.hl" />
    196     <EmbeddedResource Include="Documents\LS_OneMax.hl" />
    197     <EmbeddedResource Include="Documents\SA_Rastrigin.hl" />
    198     <EmbeddedResource Include="Documents\TS_TSP.hl" />
    199193  </ItemGroup>
    200194  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
  • trunk/sources/HeuristicLab.Problems.ArtificialAnt/3.3/Analyzers/IAntTrailPopulationAnalyzer.cs

    r3631 r3658  
    2828
    2929namespace HeuristicLab.Problems.ArtificialAnt.Analyzers {
    30   public interface IAntTrailPopulationAnalyzer : IPopulationAnalyzer {
     30  public interface IAntTrailPopulationAnalyzer : IAnalyzer {
    3131    ILookupParameter<ItemArray<DoubleValue>> QualityParameter { get; }
    3232    ILookupParameter<ItemArray<SymbolicExpressionTree>> SymbolicExpressionTreeParameter { get; }
  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/Analyzers/ISymbolicRegressionSolutionPopulationAnalyzer.cs

    r3651 r3658  
    3737
    3838namespace HeuristicLab.Problems.DataAnalysis.Regression.Symbolic.Analyzers {
    39   public interface ISymbolicRegressionSolutionPopulationAnalyzer : IPopulationAnalyzer {
     39  public interface ISymbolicRegressionSolutionPopulationAnalyzer : IAnalyzer {
    4040    ILookupParameter<ItemArray<SymbolicExpressionTree>> SymbolicExpressionTreeParameter { get; }
    4141    ILookupParameter<ResultCollection> ResultsParameter { get; }
  • trunk/sources/HeuristicLab.Problems.Knapsack/3.3/Analyzers/BestKnapsackSolutionAnalyzer.cs

    r3641 r3658  
    3838  [Item("BestKnapsackSolutionAnalyzer", "An operator for analyzing the best solution for a knapsack problem.")]
    3939  [StorableClass]
    40   class BestKnapsackSolutionAnalyzer : SingleSuccessorOperator, IBestKnapsackSolutionAnalyzer, ISolutionAnalyzer {
     40  class BestKnapsackSolutionAnalyzer : SingleSuccessorOperator, IBestKnapsackSolutionAnalyzer, IAnalyzer {
    4141
    4242    public ILookupParameter<BinaryVector> BinaryVectorParameter {
  • trunk/sources/HeuristicLab.Problems.Knapsack/3.3/Analyzers/MultiPopulationBestKnapsackSolutionAnalyzer.cs

    r3641 r3658  
    3838  [Item("MultiPopulationBestKnapsackSolutionAnalyzer", "An operator for analyzing the best solution for a knapsack problem.")]
    3939  [StorableClass]
    40   class MultiPopulationBestKnapsackSolutionAnalyzer : SingleSuccessorOperator, IBestKnapsackSolutionAnalyzer, IMultiPopulationAnalyzer {
     40  class MultiPopulationBestKnapsackSolutionAnalyzer : SingleSuccessorOperator, IBestKnapsackSolutionAnalyzer, IAnalyzer {
    4141
    4242    public ILookupParameter<ItemArray<ItemArray<BinaryVector>>> BinaryVectorParameter {
  • trunk/sources/HeuristicLab.Problems.Knapsack/3.3/Analyzers/PopulationBestKnapsackSolutionAnalyzer.cs

    r3641 r3658  
    3838  [Item("PopulationBestKnapsackSolutionAnalyzer", "An operator for analyzing the best solution for a knapsack problem.")]
    3939  [StorableClass]
    40   class PopulationBestKnapsackSolutionAnalyzer : SingleSuccessorOperator, IBestKnapsackSolutionAnalyzer, IPopulationAnalyzer {
     40  class PopulationBestKnapsackSolutionAnalyzer : SingleSuccessorOperator, IBestKnapsackSolutionAnalyzer, IAnalyzer {
    4141
    4242    public ILookupParameter<ItemArray<BinaryVector>> BinaryVectorParameter {
  • trunk/sources/HeuristicLab.Problems.OneMax/3.3/Analyzers/BestOneMaxSolutionAnalyzer.cs

    r3642 r3658  
    3838  [Item("BestOneMaxSolutionAnalyzer", "An operator for analyzing the best solution for a OneMax problem.")]
    3939  [StorableClass]
    40   class BestOneMaxSolutionAnalyzer : SingleSuccessorOperator, IBestOneMaxSolutionAnalyzer, ISolutionAnalyzer {
     40  class BestOneMaxSolutionAnalyzer : SingleSuccessorOperator, IBestOneMaxSolutionAnalyzer, IAnalyzer {
    4141
    4242    public ILookupParameter<BinaryVector> BinaryVectorParameter {
  • trunk/sources/HeuristicLab.Problems.OneMax/3.3/Analyzers/MultiPopulationBestOneMaxSolutionAnalyzer.cs

    r3642 r3658  
    3838  [Item("MultiPopulationBestOneMaxSolutionAnalyzer", "An operator for analyzing the best solution for a OneMax problem.")]
    3939  [StorableClass]
    40   class MultiPopulationBestOneMaxSolutionAnalyzer : SingleSuccessorOperator, IBestOneMaxSolutionAnalyzer, IMultiPopulationAnalyzer {
     40  class MultiPopulationBestOneMaxSolutionAnalyzer : SingleSuccessorOperator, IBestOneMaxSolutionAnalyzer, IAnalyzer {
    4141
    4242    public ILookupParameter<ItemArray<ItemArray<BinaryVector>>> BinaryVectorParameter {
  • trunk/sources/HeuristicLab.Problems.OneMax/3.3/Analyzers/PopulationBestOneMaxSolutionAnalyzer.cs

    r3642 r3658  
    3838  [Item("PopulationBestOneMaxSolutionAnalyzer", "An operator for analyzing the best solution for a OneMax problem.")]
    3939  [StorableClass]
    40   class PopulationBestOneMaxSolutionAnalyzer : SingleSuccessorOperator, IBestOneMaxSolutionAnalyzer, IPopulationAnalyzer {
     40  class PopulationBestOneMaxSolutionAnalyzer : SingleSuccessorOperator, IBestOneMaxSolutionAnalyzer, IAnalyzer {
    4141
    4242    public ILookupParameter<ItemArray<BinaryVector>> BinaryVectorParameter {
  • trunk/sources/HeuristicLab.Problems.TestFunctions/3.3/Analyzers/BestSingleObjectiveTestFunctionSolutionAnalyzer.cs

    r3647 r3658  
    3838  [Item("BestSingleObjectiveTestFunctionSolutionAnalyzer", "An operator for analyzing the best solution for a SingleObjectiveTestFunction problem.")]
    3939  [StorableClass]
    40   class BestSingleObjectiveTestFunctionSolutionAnalyzer : SingleSuccessorOperator, IBestSingleObjectiveTestFunctionSolutionAnalyzer, ISolutionAnalyzer {
     40  class BestSingleObjectiveTestFunctionSolutionAnalyzer : SingleSuccessorOperator, IBestSingleObjectiveTestFunctionSolutionAnalyzer, IAnalyzer {
    4141
    4242    public ILookupParameter<RealVector> RealVectorParameter {
  • trunk/sources/HeuristicLab.Problems.TestFunctions/3.3/Analyzers/MultiPopulationBestSingleObjectiveTestFunctionSolutionAnalyzer.cs

    r3647 r3658  
    3838  [Item("MultiPopulationBestSingleObjectiveTestFunctionSolutionAnalyzer", "An operator for analyzing the best solution for a SingleObjectiveTestFunction problem.")]
    3939  [StorableClass]
    40   class MultiPopulationBestSingleObjectiveTestFunctionSolutionAnalyzer : SingleSuccessorOperator, IBestSingleObjectiveTestFunctionSolutionAnalyzer, IMultiPopulationAnalyzer {
     40  class MultiPopulationBestSingleObjectiveTestFunctionSolutionAnalyzer : SingleSuccessorOperator, IBestSingleObjectiveTestFunctionSolutionAnalyzer, IAnalyzer {
    4141
    4242    public ILookupParameter<ItemArray<ItemArray<RealVector>>> RealVectorParameter {
  • trunk/sources/HeuristicLab.Problems.TestFunctions/3.3/Analyzers/PopulationBestSingleObjectiveTestFunctionSolutionAnalyzer.cs

    r3647 r3658  
    3838  [Item("PopulationBestSingleObjectiveTestFunctionSolutionAnalyzer", "An operator for analyzing the best solution for a SingleObjectiveTestFunction problem.")]
    3939  [StorableClass]
    40   class PopulationBestSingleObjectiveTestFunctionSolutionAnalyzer : SingleSuccessorOperator, IBestSingleObjectiveTestFunctionSolutionAnalyzer, IPopulationAnalyzer {
     40  class PopulationBestSingleObjectiveTestFunctionSolutionAnalyzer : SingleSuccessorOperator, IBestSingleObjectiveTestFunctionSolutionAnalyzer, IAnalyzer {
    4141
    4242    public ILookupParameter<ItemArray<RealVector>> RealVectorParameter {
  • trunk/sources/HeuristicLab.Problems.TravelingSalesman/3.3/Analyzers/BestTSPSolutionAnalyzer.cs

    r3635 r3658  
    3636  [Item("BestTSPSolutionAnalyzer", "An operator for analyzing the best solution of Traveling Salesman Problems given in path representation using city coordinates.")]
    3737  [StorableClass]
    38   public sealed class BestTSPSolutionAnalyzer : SingleSuccessorOperator, IBestTSPSolutionAnalyzer, ISolutionAnalyzer {
     38  public sealed class BestTSPSolutionAnalyzer : SingleSuccessorOperator, IBestTSPSolutionAnalyzer, IAnalyzer {
    3939    public ILookupParameter<DoubleMatrix> CoordinatesParameter {
    4040      get { return (ILookupParameter<DoubleMatrix>)Parameters["Coordinates"]; }
  • trunk/sources/HeuristicLab.Problems.TravelingSalesman/3.3/Analyzers/MultiPopulationBestTSPSolutionAnalyzer.cs

    r3635 r3658  
    3838  [Item("MultiPopulationBestTSPSolutionAnalyzer", "An operator for analyzing the best solution of Traveling Salesman Problems given in path representation using city coordinates.")]
    3939  [StorableClass]
    40   public sealed class MultiPopulationBestTSPSolutionAnalyzer : SingleSuccessorOperator, IBestTSPSolutionAnalyzer, IMultiPopulationAnalyzer {
     40  public sealed class MultiPopulationBestTSPSolutionAnalyzer : SingleSuccessorOperator, IBestTSPSolutionAnalyzer, IAnalyzer {
    4141    public ILookupParameter<DoubleMatrix> CoordinatesParameter {
    4242      get { return (ILookupParameter<DoubleMatrix>)Parameters["Coordinates"]; }
  • trunk/sources/HeuristicLab.Problems.TravelingSalesman/3.3/Analyzers/PopulationBestTSPSolutionAnalyzer.cs

    r3635 r3658  
    3636  [Item("PopulationBestTSPSolutionAnalyzer", "An operator for analyzing the best solution of Traveling Salesman Problems given in path representation using city coordinates.")]
    3737  [StorableClass]
    38   public sealed class PopulationBestTSPSolutionAnalyzer : SingleSuccessorOperator, IBestTSPSolutionAnalyzer, IPopulationAnalyzer {
     38  public sealed class PopulationBestTSPSolutionAnalyzer : SingleSuccessorOperator, IBestTSPSolutionAnalyzer, IAnalyzer {
    3939    public ILookupParameter<DoubleMatrix> CoordinatesParameter {
    4040      get { return (ILookupParameter<DoubleMatrix>)Parameters["Coordinates"]; }
Note: See TracChangeset for help on using the changeset viewer.