Free cookie consent management tool by TermsFeed Policy Generator

Changeset 7477


Ignore:
Timestamp:
02/16/12 13:53:28 (13 years ago)
Author:
bburlacu
Message:

#1682: Added missing files (that were previously incorrectly referencing the old branch), added unit tests, recommitted lost changes.

Location:
branches/HeuristicLab.Crossovers
Files:
10 added
18 edited

Legend:

Unmodified
Added
Removed

  • branches/HeuristicLab.Crossovers

    • Property svn:ignore

      •  

        old new  
        1919protoc.exe
        2020*.user
         21_ReSharper.HeuristicLab.Crossovers

  • branches/HeuristicLab.Crossovers/HeuristicLab.Crossovers.sln

    r7344 r7477  
    77  ProjectSection(SolutionItems) = preProject
    88    Build.cmd = Build.cmd
     9    HeuristicLab.Crossovers.vsmdi = HeuristicLab.Crossovers.vsmdi
     10    Local.testsettings = Local.testsettings
    911    PreBuildEvent.cmd = PreBuildEvent.cmd
     12    TraceAndTestImpact.testsettings = TraceAndTestImpact.testsettings
    1013  EndProjectSection
    1114EndProject
    1215Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.Encodings.SymbolicExpressionTreeEncoding-3.4", "HeuristicLab.Encodings.SymbolicExpressionTreeEncoding\3.4\HeuristicLab.Encodings.SymbolicExpressionTreeEncoding-3.4.csproj", "{06D4A186-9319-48A0-BADE-A2058D462EEA}"
    1316EndProject
     17Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.Tests", "HeuristicLab.Tests\HeuristicLab.Tests.csproj", "{A878E2D8-C909-4108-8A0F-06CB3E3609D6}"
     18EndProject
    1419Global
     20  GlobalSection(TestCaseManagementSettings) = postSolution
     21    CategoryFile = HeuristicLab.Crossovers.vsmdi
     22  EndGlobalSection
    1523  GlobalSection(SolutionConfigurationPlatforms) = preSolution
    1624    Debug|Any CPU = Debug|Any CPU
    … …  
    4654    {06D4A186-9319-48A0-BADE-A2058D462EEA}.Release|x86.ActiveCfg = Release|x86
    4755    {06D4A186-9319-48A0-BADE-A2058D462EEA}.Release|x86.Build.0 = Release|x86
     56    {A878E2D8-C909-4108-8A0F-06CB3E3609D6}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
     57    {A878E2D8-C909-4108-8A0F-06CB3E3609D6}.Debug|Any CPU.Build.0 = Debug|Any CPU
     58    {A878E2D8-C909-4108-8A0F-06CB3E3609D6}.Debug|x64.ActiveCfg = Debug|Any CPU
     59    {A878E2D8-C909-4108-8A0F-06CB3E3609D6}.Debug|x86.ActiveCfg = Debug|Any CPU
     60    {A878E2D8-C909-4108-8A0F-06CB3E3609D6}.Release|Any CPU.ActiveCfg = Release|Any CPU
     61    {A878E2D8-C909-4108-8A0F-06CB3E3609D6}.Release|Any CPU.Build.0 = Release|Any CPU
     62    {A878E2D8-C909-4108-8A0F-06CB3E3609D6}.Release|x64.ActiveCfg = Release|Any CPU
     63    {A878E2D8-C909-4108-8A0F-06CB3E3609D6}.Release|x86.ActiveCfg = Release|Any CPU
    4864  EndGlobalSection
    4965  GlobalSection(SolutionProperties) = preSolution

  • branches/HeuristicLab.Crossovers/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4

    • Property svn:ignore

      •  

        old new  
        55*.vs10x
        66Plugin.cs
         7*.bak

  • branches/HeuristicLab.Crossovers/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Crossovers

    • Property svn:ignore set to
      *.bak

  • branches/HeuristicLab.Crossovers/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Crossovers/SubtreeCrossover.cs

    r7259 r7477  
    2828using HeuristicLab.Parameters;
    2929using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
     30using HeuristicLab.PluginInfrastructure;
    3031
    3132namespace HeuristicLab.Encodings.SymbolicExpressionTreeEncoding {
    … …  
    3738  /// </summary> 
    3839  [Item("SubtreeCrossover", "An operator which performs subtree swapping crossover.")]
     40  [NonDiscoverableType]
    3941  [StorableClass]
    40   public sealed class SubtreeCrossover : SymbolicExpressionTreeCrossover, ISymbolicExpressionTreeSizeConstraintOperator {
     42  public class SubtreeCrossover : SymbolicExpressionTreeCrossover, ISymbolicExpressionTreeSizeConstraintOperator {
    4143    private const string InternalCrossoverPointProbabilityParameterName = "InternalCrossoverPointProbability";
    4244    private const string MaximumSymbolicExpressionTreeLengthParameterName = "MaximumSymbolicExpressionTreeLength";
    4345    private const string MaximumSymbolicExpressionTreeDepthParameterName = "MaximumSymbolicExpressionTreeDepth";
     46    private const string SymbolicDataAnalysisEvaluationPartitionParameterName = "EvaluationPartition";
     47
    4448    #region Parameter Properties
    4549    public IValueLookupParameter<PercentValue> InternalCrossoverPointProbabilityParameter {
    … …  
    5155    public IValueLookupParameter<IntValue> MaximumSymbolicExpressionTreeDepthParameter {
    5256      get { return (IValueLookupParameter<IntValue>)Parameters[MaximumSymbolicExpressionTreeDepthParameterName]; }
     57    }
     58    public IValueLookupParameter<IntRange> SymbolicDataAnalysisEvaluationPartitionParameter {
     59      get { return (IValueLookupParameter<IntRange>)Parameters[SymbolicDataAnalysisEvaluationPartitionParameterName]; }
    5360    }
    5461    #endregion
    … …  
    6572    #endregion
    6673    [StorableConstructor]
    67     private SubtreeCrossover(bool deserializing) : base(deserializing) { }
    68     private SubtreeCrossover(SubtreeCrossover original, Cloner cloner) : base(original, cloner) { }
     74    protected SubtreeCrossover(bool deserializing) : base(deserializing) { }
     75    protected SubtreeCrossover(SubtreeCrossover original, Cloner cloner) : base(original, cloner) { }
    6976    public SubtreeCrossover()
    7077      : base() {
    … …  
    7279      Parameters.Add(new ValueLookupParameter<IntValue>(MaximumSymbolicExpressionTreeDepthParameterName, "The maximal depth of the symbolic expression tree (a tree with one node has depth = 0)."));
    7380      Parameters.Add(new ValueLookupParameter<PercentValue>(InternalCrossoverPointProbabilityParameterName, "The probability to select an internal crossover point (instead of a leaf node).", new PercentValue(0.9)));
     81      Parameters.Add(new ValueLookupParameter<IntRange>(SymbolicDataAnalysisEvaluationPartitionParameterName, "The start index of the dataset partition on which the symbolic data analysis solution should be evaluated."));
    7482    }
    7583
    … …  
    8290      return Cross(random, parent0, parent1, InternalCrossoverPointProbability.Value,
    8391        MaximumSymbolicExpressionTreeLength.Value, MaximumSymbolicExpressionTreeDepth.Value);
     92    }
     93
     94    public ISymbolicExpressionTree Crossover(IRandom random, ISymbolicExpressionTree parent0, ISymbolicExpressionTree parent1) {
     95      return Cross(random, parent0, parent1);
    8496    }
    8597
    … …  
    94106      // calculate the max length and depth that the inserted branch can have
    95107      int maxInsertedBranchLength = maxTreeLength - (parent0.Length - childLength);
    96       int maxInsertedBranchDepth = maxTreeDepth - GetBranchLevel(parent0.Root, crossoverPoint0.Parent);
     108      int maxInsertedBranchDepth = maxTreeDepth - parent0.Root.GetBranchLevel(crossoverPoint0.Parent);
    97109
    98110      List<ISymbolicExpressionTreeNode> allowedBranches = new List<ISymbolicExpressionTreeNode>();
    99111      parent1.Root.ForEachNodePostfix((n) => {
    100112        if (n.GetLength() <= maxInsertedBranchLength &&
    101             n.GetDepth() <= maxInsertedBranchDepth &&
    102             IsMatchingPointType(crossoverPoint0, n))
     113            n.GetDepth() <= maxInsertedBranchDepth && crossoverPoint0.IsMatchingPointType(n))
    103114          allowedBranches.Add(n);
    104115      });
    105116      // empty branch
    106       if (IsMatchingPointType(crossoverPoint0, null)) allowedBranches.Add(null);
     117      if (crossoverPoint0.IsMatchingPointType(null)) allowedBranches.Add(null);
    107118
    108119      if (allowedBranches.Count == 0) {
    … …  
    125136        }
    126137        return parent0;
    127       }
    128     }
    129 
    130     private static bool IsMatchingPointType(CutPoint cutPoint, ISymbolicExpressionTreeNode newChild) {
    131       var parent = cutPoint.Parent;
    132       if (newChild == null) {
    133         // make sure that one subtree can be removed and that only the last subtree is removed
    134         return parent.Grammar.GetMinimumSubtreeCount(parent.Symbol) < parent.SubtreeCount &&
    135           cutPoint.ChildIndex == parent.SubtreeCount - 1;
    136       } else {
    137         // check syntax constraints of direct parent - child relation
    138         if (!parent.Grammar.ContainsSymbol(newChild.Symbol) ||
    139             !parent.Grammar.IsAllowedChildSymbol(parent.Symbol, newChild.Symbol, cutPoint.ChildIndex)) return false;
    140 
    141         bool result = true;
    142         // check point type for the whole branch
    143         newChild.ForEachNodePostfix((n) => {
    144           result =
    145             result &&
    146             parent.Grammar.ContainsSymbol(n.Symbol) &&
    147             n.SubtreeCount >= parent.Grammar.GetMinimumSubtreeCount(n.Symbol) &&
    148             n.SubtreeCount <= parent.Grammar.GetMaximumSubtreeCount(n.Symbol);
    149         });
    150         return result;
    151138      }
    152139    }
    … …  
    226213      }
    227214    }
    228 
    229     private static int GetBranchLevel(ISymbolicExpressionTreeNode root, ISymbolicExpressionTreeNode point) {
    230       if (root == point) return 0;
    231       foreach (var subtree in root.Subtrees) {
    232         int branchLevel = GetBranchLevel(subtree, point);
    233         if (branchLevel < int.MaxValue) return 1 + branchLevel;
    234       }
    235       return int.MaxValue;
    236     }
    237215  }
    238216}

  • branches/HeuristicLab.Crossovers/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/CutPoint.cs

    r7259 r7477  
    2222
    2323namespace HeuristicLab.Encodings.SymbolicExpressionTreeEncoding {
    24   internal class CutPoint {
     24  public class CutPoint {
    2525    public ISymbolicExpressionTreeNode Parent { get; set; }
    2626    public ISymbolicExpressionTreeNode Child { get; set; }
    … …  
    3939      this.Child = null;
    4040    }
     41
     42    public bool IsMatchingPointType(ISymbolicExpressionTreeNode newChild) {
     43      var parent = this.Parent;
     44      if (newChild == null) {
     45        // make sure that one subtree can be removed and that only the last subtree is removed
     46        return parent.Grammar.GetMinimumSubtreeCount(parent.Symbol) < parent.SubtreeCount &&
     47          this.ChildIndex == parent.SubtreeCount - 1;
     48      } else {
     49        // check syntax constraints of direct parent - child relation
     50        if (!parent.Grammar.ContainsSymbol(newChild.Symbol) ||
     51            !parent.Grammar.IsAllowedChildSymbol(parent.Symbol, newChild.Symbol, this.ChildIndex))
     52          return false;
     53
     54        bool result = true;
     55        // check point type for the whole branch
     56        newChild.ForEachNodePostfix((n) => {
     57          result =
     58            result &&
     59            parent.Grammar.ContainsSymbol(n.Symbol) &&
     60            n.SubtreeCount >= parent.Grammar.GetMinimumSubtreeCount(n.Symbol) &&
     61            n.SubtreeCount <= parent.Grammar.GetMaximumSubtreeCount(n.Symbol);
     62        });
     63        return result;
     64      }
     65    }
    4166  }
    4267}

  • branches/HeuristicLab.Crossovers/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding-3.4.csproj

    r7475 r7477  
    4141    <DebugType>full</DebugType>
    4242    <Optimize>false</Optimize>
    43     <OutputPath>$(SolutionDir)\bin\</OutputPath>
     43    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
    4444    <DefineConstants>DEBUG;TRACE</DefineConstants>
    4545    <ErrorReport>prompt</ErrorReport>
    … …  
    5151    <DebugType>pdbonly</DebugType>
    5252    <Optimize>true</Optimize>
    53     <OutputPath>$(SolutionDir)\bin\</OutputPath>
     53    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
    5454    <DefineConstants>TRACE</DefineConstants>
    5555    <ErrorReport>prompt</ErrorReport>

  • branches/HeuristicLab.Crossovers/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Interfaces

    • Property svn:ignore set to
      *.bak

  • branches/HeuristicLab.Crossovers/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Interfaces/ISymbolicExpressionTreeNode.cs

    r7259 r7477  
    3232    int GetDepth();
    3333    int GetLength();
     34    int GetBranchLevel(ISymbolicExpressionTreeNode child);
    3435
    3536    IEnumerable<ISymbolicExpressionTreeNode> IterateNodesPostfix();

  • branches/HeuristicLab.Crossovers/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/SymbolicExpressionTreeNode.cs

    r7259 r7477  
    125125    }
    126126
     127    public int GetBranchLevel(ISymbolicExpressionTreeNode child) {
     128      return GetBranchLevel(this, child);
     129    }
     130
     131    private static int GetBranchLevel(ISymbolicExpressionTreeNode root, ISymbolicExpressionTreeNode point) {
     132      if (root == point)
     133        return 0;
     134      foreach (var subtree in root.Subtrees) {
     135        int branchLevel = GetBranchLevel(subtree, point);
     136        if (branchLevel < int.MaxValue)
     137          return 1 + branchLevel;
     138      }
     139      return int.MaxValue;
     140    }
     141
    127142    public virtual void ResetLocalParameters(IRandom random) { }
    128143    public virtual void ShakeLocalParameters(IRandom random, double shakingFactor) { }

  • branches/HeuristicLab.Crossovers/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4

    • Property svn:ignore

      •  

        old new  
        55*.vs10x
        66Plugin.cs
         7*.bak

  • branches/HeuristicLab.Crossovers/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Crossovers/SymbolicDataAnalysisExpressionSizefairCrossover.cs

    r7476 r7477  
    2020#endregion
    2121
     22using HeuristicLab.Data;
    2223using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
    2324using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;

  • branches/HeuristicLab.Crossovers/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj

    r7475 r7477  
    4141    <DebugType>full</DebugType>
    4242    <Optimize>false</Optimize>
    43     <OutputPath>$(SolutionDir)\bin\</OutputPath>
     43    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
    4444    <DefineConstants>DEBUG;TRACE</DefineConstants>
    4545    <ErrorReport>prompt</ErrorReport>
    … …  
    5050    <DebugType>pdbonly</DebugType>
    5151    <Optimize>true</Optimize>
    52     <OutputPath>$(SolutionDir)\bin\</OutputPath>
     52    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
    5353    <DefineConstants>TRACE</DefineConstants>
    5454    <ErrorReport>prompt</ErrorReport>
    … …  
    168168    <Compile Include="Creators\SymbolicDataAnalysisExpressionRampedHalfAndHalfTreeCreator.cs" />
    169169    <Compile Include="Creators\SymbolicDataAnalysisExpressionTreeCreator.cs" />
     170    <Compile Include="Crossovers\MultiSymbolicDataAnalysisExpressionCrossover.cs" />
     171    <Compile Include="Crossovers\SymbolicDataAnalysisExpressionContextAwareCrossover.cs" />
     172    <Compile Include="Crossovers\SymbolicDataAnalysisExpressionCrossover.cs" />
     173    <Compile Include="Crossovers\SymbolicDataAnalysisExpressionDepthConstrainedCrossover.cs" />
     174    <Compile Include="Crossovers\SymbolicDataAnalysisExpressionDeterministicBestCrossover.cs" />
     175    <Compile Include="Crossovers\SymbolicDataAnalysisExpressionProbabilisticFunctionalCrossover.cs" />
     176    <Compile Include="Crossovers\SymbolicDataAnalysisExpressionSemanticSimilarityCrossover.cs" />
     177    <Compile Include="Crossovers\SymbolicDataAnalysisExpressionSizefairCrossover.cs" />
     178    <Compile Include="Interfaces\ISymbolicDataAnalysisExpressionCrossover.cs" />
    170179    <Compile Include="Plugin.cs" />
    171180    <Compile Include="SymbolicDataAnalysisExpressionTreeILEmittingInterpreter.cs" />

  • branches/HeuristicLab.Crossovers/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interfaces

    • Property svn:ignore set to
      *.bak

  • branches/HeuristicLab.Crossovers/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interfaces/ISymbolicDataAnalysisExpressionTreeInterpreter.cs

    r7259 r7477  
    2222using System.Collections.Generic;
    2323using HeuristicLab.Core;
     24using HeuristicLab.Data;
    2425using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
    2526
    2627namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
    27   public interface ISymbolicDataAnalysisExpressionTreeInterpreter : INamedItem {
     28  public interface ISymbolicDataAnalysisExpressionTreeInterpreter : INamedItem, IStatefulItem {
    2829    IEnumerable<double> GetSymbolicExpressionTreeValues(ISymbolicExpressionTree tree, Dataset dataset, IEnumerable<int> rows);
     30    IntValue EvaluatedSolutions { get; set; }
    2931  }
    3032}

  • branches/HeuristicLab.Crossovers/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisExpressionTreeILEmittingInterpreter.cs

    r7259 r7477  
    4848    internal delegate double CompiledFunction(int sampleIndex, IList<double>[] columns);
    4949    private const string CheckExpressionsWithIntervalArithmeticParameterName = "CheckExpressionsWithIntervalArithmetic";
     50    private const string EvaluatedSolutionsParameterName = "EvaluatedSolutions";
    5051    #region private classes
    5152    private class InterpreterState {
    … …  
    156157      get { return (IValueParameter<BoolValue>)Parameters[CheckExpressionsWithIntervalArithmeticParameterName]; }
    157158    }
     159
     160    public IValueParameter<IntValue> EvaluatedSolutionsParameter {
     161      get { return (IValueParameter<IntValue>)Parameters[EvaluatedSolutionsParameterName]; }
     162    }
    158163    #endregion
    159164
    … …  
    162167      get { return CheckExpressionsWithIntervalArithmeticParameter.Value; }
    163168      set { CheckExpressionsWithIntervalArithmeticParameter.Value = value; }
     169    }
     170
     171    public IntValue EvaluatedSolutions {
     172      get { return EvaluatedSolutionsParameter.Value; }
     173      set { EvaluatedSolutionsParameter.Value = value; }
    164174    }
    165175    #endregion
    … …  
    176186      : base("SymbolicDataAnalysisExpressionTreeILEmittingInterpreter", "Interpreter for symbolic expression trees.") {
    177187      Parameters.Add(new ValueParameter<BoolValue>(CheckExpressionsWithIntervalArithmeticParameterName, "Switch that determines if the interpreter checks the validity of expressions with interval arithmetic before evaluating the expression.", new BoolValue(false)));
    178     }
     188      Parameters.Add(new ValueParameter<IntValue>(EvaluatedSolutionsParameterName, "A counter for the total number of solutions the interpreter has evaluated", new IntValue(0)));
     189    }
     190
     191    #region state
     192    public void InitializeState() {
     193      EvaluatedSolutions.Value = 0;
     194    }
     195
     196    public void ClearState() {
     197      EvaluatedSolutions.Value = 0;
     198    }
     199    #endregion
    179200
    180201    public IEnumerable<double> GetSymbolicExpressionTreeValues(ISymbolicExpressionTree tree, Dataset dataset, IEnumerable<int> rows) {

  • branches/HeuristicLab.Crossovers/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisExpressionTreeInterpreter.cs

    r7259 r7477  
    3434  public sealed class SymbolicDataAnalysisExpressionTreeInterpreter : ParameterizedNamedItem, ISymbolicDataAnalysisExpressionTreeInterpreter {
    3535    private const string CheckExpressionsWithIntervalArithmeticParameterName = "CheckExpressionsWithIntervalArithmetic";
     36    private const string EvaluatedSolutionsParameterName = "EvaluatedSolutions";
    3637    #region private classes
    3738    private class InterpreterState {
    … …  
    176177      get { return (IValueParameter<BoolValue>)Parameters[CheckExpressionsWithIntervalArithmeticParameterName]; }
    177178    }
     179
     180    public IValueParameter<IntValue> EvaluatedSolutionsParameter {
     181      get { return (IValueParameter<IntValue>)Parameters[EvaluatedSolutionsParameterName]; }
     182    }
    178183    #endregion
    179184
    … …  
    183188      set { CheckExpressionsWithIntervalArithmeticParameter.Value = value; }
    184189    }
     190
     191    public IntValue EvaluatedSolutions {
     192      get { return EvaluatedSolutionsParameter.Value; }
     193      set { EvaluatedSolutionsParameter.Value = value; }
     194    }
    185195    #endregion
    186 
    187196
    188197    [StorableConstructor]
    … …  
    196205      : base("SymbolicDataAnalysisExpressionTreeInterpreter", "Interpreter for symbolic expression trees including automatically defined functions.") {
    197206      Parameters.Add(new ValueParameter<BoolValue>(CheckExpressionsWithIntervalArithmeticParameterName, "Switch that determines if the interpreter checks the validity of expressions with interval arithmetic before evaluating the expression.", new BoolValue(false)));
    198     }
     207      Parameters.Add(new ValueParameter<IntValue>(EvaluatedSolutionsParameterName, "A counter for the total number of solutions the interpreter has evaluated", new IntValue(0)));
     208    }
     209
     210    #region state
     211    public void InitializeState() {
     212      EvaluatedSolutions.Value = 0;
     213    }
     214
     215    public void ClearState() {
     216    }
     217    #endregion
    199218
    200219    public IEnumerable<double> GetSymbolicExpressionTreeValues(ISymbolicExpressionTree tree, Dataset dataset, IEnumerable<int> rows) {
     220      EvaluatedSolutions.Value++; // increment the evaluated solutions counter
    201221      if (CheckExpressionsWithIntervalArithmetic.Value)
    202222        throw new NotSupportedException("Interval arithmetic is not yet supported in the symbolic data analysis interpreter.");

  • branches/HeuristicLab.Crossovers/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisProblem.cs

    r7259 r7477  
    3232using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    3333using HeuristicLab.PluginInfrastructure;
     34using HeuristicLab.Problems.DataAnalysis.Symbolic.Crossovers;
    3435
    3536namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
    … …  
    198199    private void InitializeOperators() {
    199200      Operators.AddRange(ApplicationManager.Manager.GetInstances<ISymbolicExpressionTreeOperator>());
     201      Operators.AddRange(ApplicationManager.Manager.GetInstances<ISymbolicDataAnalysisExpressionCrossover<T>>());
    200202      Operators.Add(new SymbolicExpressionSymbolFrequencyAnalyzer());
    201203      Operators.Add(new SymbolicDataAnalysisVariableFrequencyAnalyzer());
    … …  
    307309        op.SymbolicDataAnalysisTreeInterpreterParameter.ActualName = SymbolicExpressionTreeInterpreterParameterName;
    308310      }
     311      foreach (var op in operators.OfType<ISymbolicDataAnalysisExpressionCrossover<T>>()) {
     312        op.SymbolicDataAnalysisEvaluationPartitionParameter.ActualName = FitnessCalculationPartitionParameterName;
     313      }
    309314    }
    310315
Note: See TracChangeset for help on using the changeset viewer.