#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 *
 * This file is part of HeuristicLab.
 *
 * HeuristicLab is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * HeuristicLab is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
 */
#endregion

using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Data;
using HeuristicLab.Encodings.ConditionActionEncoding;
using HeuristicLab.Encodings.IntegerVectorEncoding;
using HeuristicLab.Operators;
using HeuristicLab.Optimization;
using HeuristicLab.Optimization.Operators;
using HeuristicLab.Parameters;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
using HeuristicLab.Selection;

namespace HeuristicLab.Algorithms.LearningClassifierSystems {
  /// <summary>
  /// An operator which represents the main loop of a learning classifier system.
  /// </summary>
  [Item("LearningClassifierSystemMainLoop", "An operator which represents the main loop of a learning classifier system.")]
  [StorableClass]
  public sealed class LearningClassifierSystemMainLoop : AlgorithmOperator {

    #region Parameter Properties
    public IConstrainedValueParameter<ISelector> SelectorParameter {
      get { return (IConstrainedValueParameter<ISelector>)Parameters["Selector"]; }
    }
    public IConstrainedValueParameter<ICrossover> CrossoverParameter {
      get { return (IConstrainedValueParameter<ICrossover>)Parameters["Crossover"]; }
    }
    public IConstrainedValueParameter<IManipulator> MutatorParameter {
      get { return (IConstrainedValueParameter<IManipulator>)Parameters["Mutator"]; }
    }
    public IConstrainedValueParameter<IOperator> AfterCrossoverParameter {
      get { return (IConstrainedValueParameter<IOperator>)Parameters["AfterCrossover"]; }
    }
    #endregion

    #region private properties
    private SolutionsCreator initialSolutionsCreator;
    private MatchConditionOperator matchConditionOperator;
    private PredictionArrayCalculator predictionArrayCalculator;
    private ActionSelector actionSelector;
    private DoDeletionBeforeCoveringOperator doDeletionBeforeCovering;
    private CoveringOperator covering;
    private ConditionalSelector subsumptionSelector;

    private Placeholder evaluator;
    private Placeholder actionExecuter;
    private Placeholder classifierFetcher;
    private Placeholder actionSetSubsumption;
    #endregion

    [StorableConstructor]
    private LearningClassifierSystemMainLoop(bool deserializing) : base(deserializing) { }
    private LearningClassifierSystemMainLoop(LearningClassifierSystemMainLoop original, Cloner cloner)
      : base(original, cloner) {
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new LearningClassifierSystemMainLoop(this, cloner);
    }
    public LearningClassifierSystemMainLoop()
      : base() {
      Initialize();
    }

    private void Initialize() {
      #region Create parameters
      Parameters.Add(new ConstrainedValueParameter<ISelector>("Selector", "The operator used to select solutions for reproduction.", new ItemSet<ISelector>() { new ProportionalSelector() }, new ProportionalSelector()));
      Parameters.Add(new ConstrainedValueParameter<ICrossover>("Crossover", "The operator used to cross solutions.", new ItemSet<ICrossover>() { new HeuristicLab.Encodings.CombinedIntegerVectorEncoding.SinglePointCrossover() }, new HeuristicLab.Encodings.CombinedIntegerVectorEncoding.SinglePointCrossover()));
      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."));
      UniformOnePositionManipulator test = new UniformOnePositionManipulator();
      test.IntegerVectorParameter.ActualName = "CombinedIntegerVector";
      Parameters.Add(new OptionalConstrainedValueParameter<IManipulator>("Mutator", "The operator used to mutate solutions.", new ItemSet<IManipulator>() { new UniformOnePositionManipulator() }, test));
      XCSAfterCrossoverOperator afterCrossover = new XCSAfterCrossoverOperator();
      Parameters.Add(new ConstrainedValueParameter<IOperator>("AfterCrossover", "The operator used to select solutions for reproduction.", new ItemSet<IOperator>() { new XCSAfterCrossoverOperator() }, afterCrossover));
      #endregion

      #region Create operators
      VariableCreator variableCreator = new VariableCreator();
      ConditionalBranch initialPopulationConditionalBranch = new ConditionalBranch();
      initialSolutionsCreator = new SolutionsCreator();
      Assigner initialPopulationSizeAssigner = new Assigner();
      IntCounter iterationCounter = new IntCounter();
      UniformSubScopesProcessor matchCondtionSubScopesProcessor = new UniformSubScopesProcessor();
      matchConditionOperator = new MatchConditionOperator();
      predictionArrayCalculator = new PredictionArrayCalculator();
      actionSelector = new ActionSelector();
      UniformSubScopesProcessor matchActionSubScopesProcessor = new UniformSubScopesProcessor();
      MatchActionOperator matchActionOperator = new MatchActionOperator();
      ConditionalSelector conditionMatchSelector = new ConditionalSelector();
      ConditionalSelector actionMatchSelector = new ConditionalSelector();
      SubScopesProcessor matchSetSubScopesProcessor = new SubScopesProcessor();
      CountNumberOfUniqueActions countNumberOfUniqueActions = new CountNumberOfUniqueActions();
      doDeletionBeforeCovering = new DoDeletionBeforeCoveringOperator();
      ConditionalBranch doDeletionBeforeCoveringConditionalBranch = new ConditionalBranch();
      MergingReducer matchSetMergingReducerForDeletion = new MergingReducer();
      SubScopeVariableCopier subscopeVariableCopier = new SubScopeVariableCopier();
      XCSDeletionOperator deletionOperator = new XCSDeletionOperator();
      ConditionalSelector deletionSelector = new ConditionalSelector();
      LeftReducer leftReducerAfterDeletionSelection = new LeftReducer();
      UniformSubScopesProcessor matchConditionAfterDeletionSubScopesProcessor = new UniformSubScopesProcessor();
      ConditionalSelector conditionMatchSelectorAfterDeletion = new ConditionalSelector();
      SubScopesProcessor matchSetAfterDeletionSubScopesProcessor = new SubScopesProcessor();
      CountNumberOfUniqueActions countNumberOfUniqueActionsAfterDeletion = new CountNumberOfUniqueActions();
      SubScopesProcessor coveringAfterDeletionSubScopesProcessor = new SubScopesProcessor();
      covering = new CoveringOperator();
      MergingReducer actionSetMergingReducer = new MergingReducer();
      MergingReducer matchSetMergingReducer = new MergingReducer();
      evaluator = new Placeholder();
      SubScopesProcessor actionSetSubScopesProcessor = new SubScopesProcessor();
      DataReducer actionSetSizeDataReducer = new DataReducer();
      UniformSubScopesProcessor accuracySubScopesProcessor = new UniformSubScopesProcessor();
      CalculateAccuracy calculateAccuracy = new CalculateAccuracy();
      SumAccuracy sumAccuracy = new SumAccuracy();
      UniformSubScopesProcessor updateParametersSubScopesProcessor = new UniformSubScopesProcessor();
      ConditionalBranch actionSetSubsumptionBranch = new ConditionalBranch();
      subsumptionSelector = new ConditionalSelector();
      LeftReducer leftReducer = new LeftReducer();
      XCSCheckIfGAShouldBeApplied checkIfGAShouldRun = new XCSCheckIfGAShouldBeApplied();
      ConditionalBranch runGAConditionalBranch = new ConditionalBranch();
      UniformSubScopesProcessor timestampAssignerSubscopeProcessor = new UniformSubScopesProcessor();
      Assigner timestampAssigner = new Assigner();
      LCSAdaptedGeneticAlgorithm adaptedGeneticAlgorithmMainLoop = new LCSAdaptedGeneticAlgorithm();
      IntCounter currentPopulationSizeCounter = new IntCounter();
      CalculateNumberOfDeletionsOperator calculateNumberOfDeletions = new CalculateNumberOfDeletionsOperator();
      XCSDeletionOperator deletionOperatorAfterGA = new XCSDeletionOperator();
      ConditionalSelector deletionSelectorAfterGA = new ConditionalSelector();
      LeftReducer leftReducerAfterGA = new LeftReducer();

      classifierFetcher = new Placeholder();
      actionExecuter = new Placeholder();
      actionSetSubsumption = new Placeholder();

      variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("ZeroIntValue", new IntValue(0)));
      variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("OneIntValue", new IntValue(1)));
      variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Iteration", new IntValue(0)));
      variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("CurrentPopulationSize", new IntValue(0)));

      initialPopulationConditionalBranch.ConditionParameter.ActualName = "CreateInitialPopulation";

      initialSolutionsCreator.NumberOfSolutionsParameter.ActualName = "N";

      initialPopulationSizeAssigner.LeftSideParameter.ActualName = "CurrentPopulationSize";
      initialPopulationSizeAssigner.RightSideParameter.ActualName = "N";

      iterationCounter.ValueParameter.ActualName = "Iteration";
      iterationCounter.IncrementParameter.ActualName = "OneIntValue";

      matchConditionOperator.MatchParameter.ActualName = "CombinedIntegerVector";

      conditionMatchSelector.CopySelected = new BoolValue(false);
      conditionMatchSelector.ConditionParameter.ActualName = "MatchCondition";

      conditionMatchSelectorAfterDeletion.CopySelected = new BoolValue(false);
      conditionMatchSelectorAfterDeletion.ConditionParameter.ActualName = "MatchCondition";

      countNumberOfUniqueActions.ClassifiersParameter.ActualName = "CombinedIntegerVector";

      countNumberOfUniqueActionsAfterDeletion.ClassifiersParameter.ActualName = "CombinedIntegerVector";

      subscopeVariableCopier.SubScopeIndexParameter.Value = new IntValue(1);

      doDeletionBeforeCovering.CurrentPopulationSizeParameter.ActualName = "CurrentPopulationSize";
      doDeletionBeforeCovering.NumberOfUniqueActionsParameter.ActualName = countNumberOfUniqueActions.NumberOfUniqueActionsParameter.ActualName;
      doDeletionBeforeCovering.PopulationSizeParameter.ActualName = "N";

      doDeletionBeforeCoveringConditionalBranch.ConditionParameter.ActualName = doDeletionBeforeCovering.DoDeletionParameter.ActualName;

      deletionOperator.NumberToDeleteParameter.ActualName = doDeletionBeforeCovering.NumberToDeleteParameter.ActualName;
      deletionOperator.AverageActionSetSizesParameter.ActualName = "AverageActionSetSize";
      deletionOperator.FitnessesParameter.ActualName = "Fitness";
      deletionOperator.NumerositiesParameter.ActualName = "Numerosity";
      deletionOperator.ExperiencesParameter.ActualName = "Experience";
      deletionOperator.ThetaDeletionParameter.ActualName = "ThetaDeletion";
      deletionOperator.DeltaParameter.ActualName = "Delta";
      deletionOperator.RandomParameter.ActualName = "Random";

      deletionSelector.ConditionParameter.ActualName = deletionOperator.HasToBeDeletedVariableName;
      deletionSelector.CopySelected = new BoolValue(false);

      covering.ActionsInMatchSetParameter.ActualName = countNumberOfUniqueActions.UniqueActionsParameter.ActualName;
      covering.ParallelParameter.Value.Value = true;
      covering.RandomParameter.ActualName = "Random";
      covering.CurrentPopulationSizeParameter.ActualName = "CurrentPopulationSize";

      matchActionSubScopesProcessor.Operator = matchActionOperator;

      matchActionOperator.MatchParameter.ActualName = "CombinedIntegerVector";
      matchActionOperator.TargetMatchParameter.ActualName = actionSelector.SelectedActionParameter.ActualName;

      predictionArrayCalculator.MatchParameter.ActualName = "CombinedIntegerVector";

      actionSelector.PredictionArrayParameter.ActualName = predictionArrayCalculator.PredictionArrayParameter.Name;
      actionSelector.RandomParameter.ActualName = "Random";
      actionSelector.ExplorationProbabilityParameter.ActualName = "ExplorationProbability";

      actionMatchSelector.CopySelected = new BoolValue(false);
      actionMatchSelector.ConditionParameter.ActualName = "MatchAction";

      actionSetSubsumptionBranch.ConditionParameter.ActualName = "DoActionSetSubsumption";

      subsumptionSelector.CopySelected = new BoolValue(false);

      SelectorParameter.Value.CopySelected = new BoolValue(true);
      SelectorParameter.Value.NumberOfSelectedSubScopesParameter.Value = new IntValue(4);

      evaluator.Name = "Evaluator";

      classifierFetcher.Name = "ClassifierFetcher";

      actionExecuter.Name = "ActionExecuter";

      actionSetSizeDataReducer.TargetParameter.ActualName = "CurrentActionSetSize";
      actionSetSizeDataReducer.ParameterToReduce.ActualName = "Numerosity";
      actionSetSizeDataReducer.ReductionOperation.Value = new ReductionOperation(ReductionOperations.Sum);
      actionSetSizeDataReducer.TargetOperation.Value = new ReductionOperation(ReductionOperations.Assign);

      calculateAccuracy.AlphaParameter.ActualName = "Alpha";
      calculateAccuracy.ErrorParameter.ActualName = "Error";
      calculateAccuracy.ErrorZeroParameter.ActualName = "ErrorZero";
      calculateAccuracy.PowerParameter.ActualName = "v";

      sumAccuracy.AccuracyParameter.ActualName = calculateAccuracy.AccuracyParameter.ActualName;
      sumAccuracy.NumerosityParameter.ActualName = "Numerosity";

      //BEGIN parameters have to be set differently
      checkIfGAShouldRun.TimeStampsParameter.ActualName = "Timestamp";
      checkIfGAShouldRun.NumerositiesParameter.ActualName = "Numerosity";
      checkIfGAShouldRun.ThetaGAParameter.ActualName = "ThetaGA";
      //END
      checkIfGAShouldRun.IterationParameter.ActualName = iterationCounter.ValueParameter.ActualName;

      runGAConditionalBranch.ConditionParameter.ActualName = checkIfGAShouldRun.RunGAParameter.ActualName;

      timestampAssigner.LeftSideParameter.ActualName = "Timestamp";
      timestampAssigner.RightSideParameter.ActualName = iterationCounter.ValueParameter.ActualName;

      afterCrossover.NumerosityParameter.ActualName = "Numerosity";
      afterCrossover.ExperienceParameter.ActualName = "Experience";
      afterCrossover.TimestampParameter.ActualName = "Timestamp";
      afterCrossover.CurrentIterationParameter.ActualName = "Iteration";
      afterCrossover.FitnessParameter.ActualName = "Fitness";
      afterCrossover.AverageActionSetSizeParameter.ActualName = "AverageActionSetSize";
      afterCrossover.PredictionParameter.ActualName = "Prediction";
      afterCrossover.ErrorParameter.ActualName = "Error";
      afterCrossover.ParentFitnessParameter.ActualName = "Fitness";
      afterCrossover.ParentErrorParameter.ActualName = "Error";
      afterCrossover.ParentPredictionParameter.ActualName = "Prediction";
      afterCrossover.ParentAverageActionSetSizeParameter.ActualName = "AverageActionSetSize";

      adaptedGeneticAlgorithmMainLoop.SelectorParameter.ActualName = SelectorParameter.Name;
      adaptedGeneticAlgorithmMainLoop.CrossoverParameter.ActualName = CrossoverParameter.Name;
      adaptedGeneticAlgorithmMainLoop.MutatorParameter.ActualName = MutatorParameter.Name;
      adaptedGeneticAlgorithmMainLoop.RandomParameter.ActualName = "Random";
      adaptedGeneticAlgorithmMainLoop.MaximumGenerationsParameter.ActualName = "ZeroIntValue";
      adaptedGeneticAlgorithmMainLoop.QualityParameter.ActualName = "Fitness";
      adaptedGeneticAlgorithmMainLoop.MutationProbabilityParameter.Value = new PercentValue(10);
      adaptedGeneticAlgorithmMainLoop.MaximizationParameter.Value = new BoolValue(true);
      adaptedGeneticAlgorithmMainLoop.AfterCrossoverParameter.ActualName = AfterCrossoverParameter.Name;

      currentPopulationSizeCounter.ValueParameter.ActualName = "CurrentPopulationSize";
      currentPopulationSizeCounter.Increment = new IntValue(2);

      calculateNumberOfDeletions.CurrentPopulationSizeParameter.ActualName = "CurrentPopulationSize";
      calculateNumberOfDeletions.PopulationSizeParameter.ActualName = "N";

      deletionOperatorAfterGA.NumberToDeleteParameter.ActualName = calculateNumberOfDeletions.NumberOfDeletionsParameter.ActualName;
      deletionOperatorAfterGA.AverageActionSetSizesParameter.ActualName = "AverageActionSetSize";
      deletionOperatorAfterGA.FitnessesParameter.ActualName = "Fitness";
      deletionOperatorAfterGA.NumerositiesParameter.ActualName = "Numerosity";
      deletionOperatorAfterGA.ExperiencesParameter.ActualName = "Experience";
      deletionOperatorAfterGA.ThetaDeletionParameter.ActualName = "ThetaDeletion";
      deletionOperatorAfterGA.DeltaParameter.ActualName = "Delta";
      deletionOperatorAfterGA.RandomParameter.ActualName = "Random";

      deletionSelectorAfterGA.ConditionParameter.ActualName = deletionOperatorAfterGA.HasToBeDeletedVariableName;
      deletionSelectorAfterGA.CopySelected = new BoolValue(false);
      #endregion

      #region Create operator graph
      OperatorGraph.InitialOperator = variableCreator;

      variableCreator.Successor = initialPopulationConditionalBranch;
      initialPopulationConditionalBranch.TrueBranch = initialSolutionsCreator;
      initialSolutionsCreator.Successor = initialPopulationSizeAssigner;
      initialPopulationConditionalBranch.FalseBranch = new EmptyOperator();
      initialPopulationConditionalBranch.Successor = classifierFetcher;
      classifierFetcher.Successor = matchCondtionSubScopesProcessor;
      matchCondtionSubScopesProcessor.Operator = matchConditionOperator;
      matchCondtionSubScopesProcessor.Successor = conditionMatchSelector;
      conditionMatchSelector.Successor = matchSetSubScopesProcessor;
      matchSetSubScopesProcessor.Operators.Add(new EmptyOperator());
      matchSetSubScopesProcessor.Operators.Add(countNumberOfUniqueActions);
      matchSetSubScopesProcessor.Successor = subscopeVariableCopier;
      subscopeVariableCopier.Successor = doDeletionBeforeCovering;
      doDeletionBeforeCovering.Successor = doDeletionBeforeCoveringConditionalBranch;
      doDeletionBeforeCoveringConditionalBranch.TrueBranch = matchSetMergingReducerForDeletion;
      matchSetMergingReducerForDeletion.Successor = deletionOperator;
      deletionOperator.Successor = deletionSelector;
      deletionSelector.Successor = leftReducerAfterDeletionSelection;
      leftReducerAfterDeletionSelection.Successor = matchConditionAfterDeletionSubScopesProcessor;
      doDeletionBeforeCoveringConditionalBranch.FalseBranch = coveringAfterDeletionSubScopesProcessor;
      coveringAfterDeletionSubScopesProcessor.Operators.Add(new EmptyOperator());
      coveringAfterDeletionSubScopesProcessor.Operators.Add(covering);
      coveringAfterDeletionSubScopesProcessor.Successor = matchSetMergingReducer;
      matchConditionAfterDeletionSubScopesProcessor.Operator = matchConditionOperator;
      matchConditionAfterDeletionSubScopesProcessor.Successor = conditionMatchSelectorAfterDeletion;
      conditionMatchSelectorAfterDeletion.Successor = matchSetAfterDeletionSubScopesProcessor;
      matchSetAfterDeletionSubScopesProcessor.Operators.Add(new EmptyOperator());
      matchSetAfterDeletionSubScopesProcessor.Operators.Add(countNumberOfUniqueActionsAfterDeletion);
      matchSetAfterDeletionSubScopesProcessor.Successor = matchSetMergingReducer;
      countNumberOfUniqueActionsAfterDeletion.Successor = covering;

      covering.Successor = predictionArrayCalculator;
      predictionArrayCalculator.Successor = actionSelector;
      actionSelector.Successor = matchActionSubScopesProcessor;
      matchActionSubScopesProcessor.Successor = actionMatchSelector;
      actionMatchSelector.Successor = actionExecuter;
      actionExecuter.Successor = actionSetSubScopesProcessor;
      actionSetSubScopesProcessor.Operators.Add(new EmptyOperator());
      actionSetSubScopesProcessor.Operators.Add(actionSetSizeDataReducer);
      actionSetSizeDataReducer.Successor = accuracySubScopesProcessor;
      accuracySubScopesProcessor.Operator = calculateAccuracy;
      accuracySubScopesProcessor.Successor = sumAccuracy;
      sumAccuracy.Successor = updateParametersSubScopesProcessor;
      updateParametersSubScopesProcessor.Operator = evaluator;
      updateParametersSubScopesProcessor.Successor = actionSetSubsumptionBranch;
      actionSetSubsumptionBranch.TrueBranch = actionSetSubsumption;
      actionSetSubsumption.Successor = subsumptionSelector;
      subsumptionSelector.Successor = leftReducer;
      actionSetSubsumptionBranch.FalseBranch = new EmptyOperator();
      actionSetSubsumptionBranch.Successor = checkIfGAShouldRun;
      checkIfGAShouldRun.Successor = runGAConditionalBranch;
      runGAConditionalBranch.TrueBranch = timestampAssignerSubscopeProcessor;
      runGAConditionalBranch.FalseBranch = new EmptyOperator();
      timestampAssignerSubscopeProcessor.Operator = timestampAssigner;
      timestampAssignerSubscopeProcessor.Successor = adaptedGeneticAlgorithmMainLoop;
      adaptedGeneticAlgorithmMainLoop.Successor = currentPopulationSizeCounter;

      actionSetSubScopesProcessor.Successor = actionSetMergingReducer;

      matchSetMergingReducer.Successor = calculateNumberOfDeletions;
      calculateNumberOfDeletions.Successor = deletionOperatorAfterGA;
      deletionOperatorAfterGA.Successor = deletionSelectorAfterGA;
      deletionSelectorAfterGA.Successor = leftReducerAfterGA;
      leftReducerAfterGA.Successor = iterationCounter;
      iterationCounter.Successor = classifierFetcher;
      #endregion
    }

    private void ParameterizeStochasticOperator(IOperator op) {
      IStochasticOperator stochasticOp = op as IStochasticOperator;
      if (stochasticOp != null) {
        stochasticOp.RandomParameter.ActualName = "Random";
        stochasticOp.RandomParameter.Hidden = true;
      }
    }

    internal void SetCurrentProblem(IConditionActionProblem problem) {
      initialSolutionsCreator.SolutionCreatorParameter.ActualName = problem.SolutionCreatorParameter.Name;
      initialSolutionsCreator.EvaluatorParameter.ActualName = problem.EvaluatorParameter.Name;

      problem.ActionExecuter.SelectedActionParameter.ActualName = actionSelector.SelectedActionParameter.ActualName;

      problem.ClassifierFetcher.IterationParameter.ActualName = "Iteration";

      evaluator.OperatorParameter.ActualName = problem.EvaluatorParameter.Name;

      classifierFetcher.OperatorParameter.ActualName = problem.ClassifierFetcherParameter.Name;

      actionExecuter.OperatorParameter.ActualName = problem.ActionExecuterParameter.Name;

      problem.ActionSetSubsumptionOperator.ThetaSubsumptionParameter.ActualName = "ThetaSubsumption";
      problem.ActionSetSubsumptionOperator.ErrorsParameter.ActualName = "Error";
      problem.ActionSetSubsumptionOperator.ErrorZeroParameter.ActualName = "ErrorZero";
      problem.ActionSetSubsumptionOperator.ExperiencesParameter.ActualName = "Experience";
      problem.ActionSetSubsumptionOperator.NumerositiesParameter.ActualName = "Numerosity";

      subsumptionSelector.ConditionParameter.ActualName = problem.ActionSetSubsumptionOperator.HasBeenSubsumedParameterName;

      actionSetSubsumption.OperatorParameter.ActualName = problem.ActionSetSubsumptionOperatorParameter.Name;

      matchConditionOperator.TargetMatchParameter.ActualName = problem.ClassifierFetcher.CurrentClassifierToMatchParameter.ActualName;

      doDeletionBeforeCovering.MinimalNumberOfUniqueActionsParameter.ActualName = problem.ThetaMinimalNumberOfActionsParameter.Name;

      covering.SolutionCreatorParameter.ActualName = problem.CoveringSolutionCreatorParameter.Name;
      covering.EvaluatorParameter.ActualName = problem.EvaluatorParameter.Name;
      covering.MinimalNumberOfUniqueActionsParameter.ActualName = problem.ThetaMinimalNumberOfActionsParameter.Name;
      covering.PossibleActionsParameter.ActualName = problem.PossibleActionsParameter.Name;

      predictionArrayCalculator.PredictionParameter.ActualName = problem.Evaluator.PredictionParameter.ActualName;
      predictionArrayCalculator.FitnessParameter.ActualName = problem.Evaluator.FitnessParameter.ActualName;
    }
    //private void ParameterizeSelectors() {
    //  foreach (ISelector selector in SelectorParameter.ValidValues) {
    //    selector.CopySelected = new BoolValue(true);
    //    //set value by parameter!
    //    selector.NumberOfSelectedSubScopesParameter.Value = new IntValue(5);
    //    selector.NumberOfSelectedSubScopesParameter.Hidden = true;
    //    ParameterizeStochasticOperator(selector);
    //  }
    //  if (Problem != null) {
    //    foreach (ISingleObjectiveSelector selector in SelectorParameter.ValidValues.OfType<ISingleObjectiveSelector>()) {
    //      selector.MaximizationParameter.Value = new BoolValue(true);
    //      selector.MaximizationParameter.Hidden = true;
    //      selector.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
    //      selector.QualityParameter.Hidden = true;
    //    }
    //  }
    //}
  }
}