Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
07/03/12 16:46:35 (12 years ago)
Author:
gkronber
Message:

#1847: merged r8084:8205 from trunk into GP move operators branch

Location:
branches/GP-MoveOperators
Files:
1 deleted
10 edited

Legend:

Unmodified
Added
Removed

  • branches/GP-MoveOperators

  • branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisSingleObjectiveTrainingParetoBestSolutionAnalyzer.cs

    r7734 r8206  
    2020#endregion
    2121
     22using System;
    2223using System.Collections.Generic;
    2324using System.Linq;
    … …  
    2627using HeuristicLab.Data;
    2728using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
    28 using HeuristicLab.Operators;
    2929using HeuristicLab.Optimization;
    3030using HeuristicLab.Parameters;
    3131using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    32 using System;
    3332
    3433namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
    … …  
    3837  [Item("SymbolicDataAnalysisSingleObjectiveTrainingParetoBestSolutionAnalyzer", "An operator that analyzes the Pareto-best symbolic data analysis solution for single objective symbolic data analysis problems.")]
    3938  [StorableClass]
    40   public abstract class SymbolicDataAnalysisSingleObjectiveTrainingParetoBestSolutionAnalyzer<T> : SymbolicDataAnalysisSingleObjectiveAnalyzer
    41     where T : class, ISymbolicDataAnalysisSolution {
     39  public abstract class SymbolicDataAnalysisSingleObjectiveTrainingParetoBestSolutionAnalyzer<S, T> : SymbolicDataAnalysisSingleObjectiveAnalyzer, ISymbolicDataAnalysisInterpreterOperator, ISymbolicDataAnalysisBoundedOperator
     40    where T : class, ISymbolicDataAnalysisSolution
     41    where S : class, IDataAnalysisProblemData {
     42    private const string ProblemDataParameterName = "ProblemData";
    4243    private const string TrainingBestSolutionsParameterName = "Best training solutions";
    4344    private const string TrainingBestSolutionQualitiesParameterName = "Best training solution qualities";
    4445    private const string ComplexityParameterName = "Complexity";
     46    private const string SymbolicDataAnalysisTreeInterpreterParameterName = "SymbolicDataAnalysisTreeInterpreter";
     47    private const string EstimationLimitsParameterName = "EstimationLimits";
    4548
    4649    public override bool EnabledByDefault {
    … …  
    5861      get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters[ComplexityParameterName]; }
    5962    }
     63    public ILookupParameter<ISymbolicDataAnalysisExpressionTreeInterpreter> SymbolicDataAnalysisTreeInterpreterParameter {
     64      get { return (ILookupParameter<ISymbolicDataAnalysisExpressionTreeInterpreter>)Parameters[SymbolicDataAnalysisTreeInterpreterParameterName]; }
     65    }
     66    public ILookupParameter<S> ProblemDataParameter {
     67      get { return (ILookupParameter<S>)Parameters[ProblemDataParameterName]; }
     68    }
     69    public IValueLookupParameter<DoubleLimit> EstimationLimitsParameter {
     70      get { return (IValueLookupParameter<DoubleLimit>)Parameters[EstimationLimitsParameterName]; }
     71    }
    6072    #endregion
    6173    #region properties
    … …  
    7284    [StorableConstructor]
    7385    protected SymbolicDataAnalysisSingleObjectiveTrainingParetoBestSolutionAnalyzer(bool deserializing) : base(deserializing) { }
    74     protected SymbolicDataAnalysisSingleObjectiveTrainingParetoBestSolutionAnalyzer(SymbolicDataAnalysisSingleObjectiveTrainingParetoBestSolutionAnalyzer<T> original, Cloner cloner) : base(original, cloner) { }
     86    protected SymbolicDataAnalysisSingleObjectiveTrainingParetoBestSolutionAnalyzer(SymbolicDataAnalysisSingleObjectiveTrainingParetoBestSolutionAnalyzer<S, T> original, Cloner cloner) : base(original, cloner) { }
    7587    public SymbolicDataAnalysisSingleObjectiveTrainingParetoBestSolutionAnalyzer()
    7688      : base() {
     89      Parameters.Add(new LookupParameter<S>(ProblemDataParameterName, "The problem data for the symbolic data analysis solution."));
    7790      Parameters.Add(new LookupParameter<ItemList<T>>(TrainingBestSolutionsParameterName, "The training best (Pareto-optimal) symbolic data analysis solutions."));
    7891      Parameters.Add(new LookupParameter<ItemList<DoubleArray>>(TrainingBestSolutionQualitiesParameterName, "The qualities of the training best (Pareto-optimal) solutions."));
    7992      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>(ComplexityParameterName, "The complexity of each tree."));
     93      Parameters.Add(new LookupParameter<ISymbolicDataAnalysisExpressionTreeInterpreter>(SymbolicDataAnalysisTreeInterpreterParameterName, "The symbolic data analysis tree interpreter for the symbolic expression tree."));
     94      Parameters.Add(new ValueLookupParameter<DoubleLimit>(EstimationLimitsParameterName, "The lower and upper limit for the estimated values produced by the symbolic classification model."));
    8095    }
    8196
    … …  
    100115
    101116      List<double> complexities;
    102       if (ComplexityParameter.ActualValue != null) {
     117      if (ComplexityParameter.ActualValue != null && ComplexityParameter.ActualValue.Length == qualities.Count) {
    103118        complexities = ComplexityParameter.ActualValue.Select(x => x.Value).ToList();
    104119      } else {

  • branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisSingleObjectiveValidationParetoBestSolutionAnalyzer.cs

    r7734 r8206  
    2020#endregion
    2121
     22using System;
    2223using System.Collections.Generic;
    2324using System.Linq;
    … …  
    2627using HeuristicLab.Data;
    2728using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
    28 using HeuristicLab.Operators;
    2929using HeuristicLab.Optimization;
    3030using HeuristicLab.Parameters;
    3131using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    32 using System;
    3332
    3433namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
    … …  
    3837  [Item("SymbolicDataAnalysisSingleObjectiveValidationParetoBestSolutionAnalyzer", "An operator that analyzes the Pareto-best symbolic data analysis solution for single objective symbolic data analysis problems.")]
    3938  [StorableClass]
    40   public abstract class SymbolicDataAnalysisSingleObjectiveValidationParetoBestSolutionAnalyzer<S, T, U> : SymbolicDataAnalysisSingleObjectiveValidationAnalyzer<T, U>
     39  public abstract class SymbolicDataAnalysisSingleObjectiveValidationParetoBestSolutionAnalyzer<S, T, U> : SymbolicDataAnalysisSingleObjectiveValidationAnalyzer<T, U>, ISymbolicDataAnalysisBoundedOperator
    4140    where S : class, ISymbolicDataAnalysisSolution
    4241    where T : class, ISymbolicDataAnalysisSingleObjectiveEvaluator<U>
    … …  
    4544    private const string ValidationBestSolutionQualitiesParameterName = "Best validation solution qualities";
    4645    private const string ComplexityParameterName = "Complexity";
     46    private const string EstimationLimitsParameterName = "EstimationLimits";
    4747
    4848    public override bool EnabledByDefault {
    … …  
    6060      get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters[ComplexityParameterName]; }
    6161    }
     62    public IValueLookupParameter<DoubleLimit> EstimationLimitsParameter {
     63      get { return (IValueLookupParameter<DoubleLimit>)Parameters[EstimationLimitsParameterName]; }
     64    }
     65
    6266    #endregion
    6367    #region properties
    … …  
    8084      Parameters.Add(new LookupParameter<ItemList<DoubleArray>>(ValidationBestSolutionQualitiesParameterName, "The qualities of the validation best (Pareto-optimal) solutions."));
    8185      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>(ComplexityParameterName, "The complexity of each tree."));
     86      Parameters.Add(new ValueLookupParameter<DoubleLimit>(EstimationLimitsParameterName, "The lower and upper limit for the estimated values produced by the symbolic classification model."));
    8287    }
    8388
    … …  
    137142
    138143      List<double> complexities;
    139       if (ComplexityParameter.ActualValue != null) {
     144      if (ComplexityParameter.ActualValue != null && ComplexityParameter.ActualValue.Length == trainingQuality.Length) {
    140145        complexities = ComplexityParameter.ActualValue.Select(x => x.Value).ToList();
    141146      } else {

  • branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Crossovers/SymbolicDataAnalysisExpressionDepthConstrainedCrossover.cs

    r7521 r8206  
    4141
    4242    #region Parameter properties
    43     public ConstrainedValueParameter<StringValue> DepthRangeParameter {
    44       get { return (ConstrainedValueParameter<StringValue>)Parameters[DepthRangeParameterName]; }
     43    public IConstrainedValueParameter<StringValue> DepthRangeParameter {
     44      get { return (IConstrainedValueParameter<StringValue>)Parameters[DepthRangeParameterName]; }
    4545    }
    4646    #endregion
    … …  
    8989      var depthRange = new IntRange();
    9090      const int depthOffset = 2; // skip the first 2 levels (root + startNode)
    91       switch ((int)Enum.Parse(typeof(Ranges), mode)) {
    92         case (int)Ranges.HighLevel:
     91      switch ((Ranges)Enum.Parse(typeof(Ranges), mode)) {
     92        case Ranges.HighLevel:
    9393          depthRange.Start = depthOffset; // skip the first 2 levels (root + startNode)
    9494          depthRange.End = depthRange.Start + (int)Math.Round(depth * 0.25);
    9595          break;
    96         case (int)Ranges.Standard:
     96        case Ranges.Standard:
    9797          depthRange.Start = depthOffset + (int)Math.Round(depth * 0.25);
    9898          depthRange.End = depthRange.Start + (int)Math.Round(depth * 0.5);
    9999          break;
    100         case (int)Ranges.LowLevel:
     100        case Ranges.LowLevel:
    101101          depthRange.Start = depthOffset + (int)Math.Round(depth * 0.75);
    102102          depthRange.End = Math.Max(depthRange.Start, depth);

  • branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionMATLABFormatter.cs

    r7695 r8206  
    231231        stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
    232232        stringBuilder.Append(")");
     233      } else if (node.Symbol is AiryA) {
     234        stringBuilder.Append("airy(");
     235        stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
     236        stringBuilder.Append(")");
     237      } else if (node.Symbol is AiryB) {
     238        stringBuilder.Append("airy(2, ");
     239        stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
     240        stringBuilder.Append(")");
     241      } else if (node.Symbol is Bessel) {
     242        stringBuilder.Append("besseli(0.0,");
     243        stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
     244        stringBuilder.Append(")");
     245      } else if (node.Symbol is CosineIntegral) {
     246        stringBuilder.Append("cosint(");
     247        stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
     248        stringBuilder.Append(")");
     249      } else if (node.Symbol is Dawson) {
     250        stringBuilder.Append("dawson(");
     251        stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
     252        stringBuilder.Append(")");
     253      } else if (node.Symbol is Erf) {
     254        stringBuilder.Append("erf(");
     255        stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
     256        stringBuilder.Append(")");
     257      } else if (node.Symbol is ExponentialIntegralEi) {
     258        stringBuilder.Append("expint(");
     259        stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
     260        stringBuilder.Append(")");
     261      } else if (node.Symbol is FresnelCosineIntegral) {
     262        stringBuilder.Append("FresnelC(");
     263        stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
     264        stringBuilder.Append(")");
     265      } else if (node.Symbol is FresnelSineIntegral) {
     266        stringBuilder.Append("FresnelS(");
     267        stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
     268        stringBuilder.Append(")");
     269      } else if (node.Symbol is Gamma) {
     270        stringBuilder.Append("gamma(");
     271        stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
     272        stringBuilder.Append(")");
     273      } else if (node.Symbol is HyperbolicCosineIntegral) {
     274        stringBuilder.Append("Chi(");
     275        stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
     276        stringBuilder.Append(")");
     277      } else if (node.Symbol is HyperbolicSineIntegral) {
     278        stringBuilder.Append("Shi(");
     279        stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
     280        stringBuilder.Append(")");
     281      } else if (node.Symbol is Norm) {
     282        stringBuilder.Append("normpdf(");
     283        stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
     284        stringBuilder.Append(")");
     285      } else if (node.Symbol is Psi) {
     286        stringBuilder.Append("psi(");
     287        stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
     288        stringBuilder.Append(")");
     289      } else if (node.Symbol is SineIntegral) {
     290        stringBuilder.Append("sinint(");
     291        stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
     292        stringBuilder.Append(")");
    233293      } else if (symbol is HeuristicLab.Problems.DataAnalysis.Symbolic.Variable) {
    234294        VariableTreeNode variableTreeNode = node as VariableTreeNode;

  • branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj

    r8085 r8206  
    113113  <ItemGroup>
    114114    <Compile Include="Analyzers\SymbolicDataAnalysisSingleObjectiveValidationParetoBestSolutionAnalyzer.cs" />
    115     <Compile Include="Analyzers\SymbolicDataAnalysisComplexityAnalyzer.cs" />
    116115    <Compile Include="Analyzers\SymbolicDataAnalysisSingleObjectiveTrainingParetoBestSolutionAnalyzer.cs" />
    117116    <Compile Include="Analyzers\SymbolicDataAnalysisMultiObjectiveValidationAnalyzer.cs" />

  • branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisExpressionTreeILEmittingInterpreter.cs

    r7708 r8206  
    837837    public static double Psi(double x) {
    838838      if (double.IsNaN(x)) return double.NaN;
    839       else if (x.IsAlmost(0.0)) return double.NaN;
    840       else if ((Math.Floor(x) - x).IsAlmost(0.0)) return double.NaN;
     839      else if (x <= 0 && (Math.Floor(x) - x).IsAlmost(0)) return double.NaN;
    841840      return alglib.psi(x);
    842841    }
    … …  
    865864      double shi, chi;
    866865      alglib.hyperbolicsinecosineintegrals(x, out shi, out chi);
    867       return chi;
     866      return shi;
    868867    }
    869868

  • branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisExpressionTreeInterpreter.cs

    r7708 r8206  
    198198      { typeof(Norm), OpCodes.Norm},
    199199      { typeof(Erf), OpCodes.Erf},
    200       { typeof(Bessel), OpCodes.Bessel}     
     200      { typeof(Bessel), OpCodes.Bessel}
    201201    };
    202202
    … …  
    370370            var x = Evaluate(dataset, ref row, state);
    371371            if (double.IsNaN(x)) return double.NaN;
    372             else if (x.IsAlmost(0.0)) return double.NaN;
    373             else if ((Math.Floor(x) - x).IsAlmost(0)) return double.NaN;
     372            else if (x <= 0 && (Math.Floor(x) - x).IsAlmost(0)) return double.NaN;
    374373            return alglib.psi(x);
    375374          }

  • branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisProblem.cs

    r8085 r8206  
    203203      Operators.Add(new SymbolicExpressionSymbolFrequencyAnalyzer());
    204204      Operators.Add(new SymbolicDataAnalysisVariableFrequencyAnalyzer());
    205       Operators.Add(new SymbolicDataAnalysisComplexityAnalyzer());
    206205      Operators.Add(new MinAverageMaxSymbolicExpressionTreeLengthAnalyzer());
    207206      Operators.Add(new SymbolicExpressionTreeLengthAnalyzer());
    … …  
    313312      foreach (var op in operators.OfType<ISymbolicDataAnalysisExpressionCrossover<T>>()) {
    314313        op.EvaluationPartitionParameter.ActualName = FitnessCalculationPartitionParameterName;
    315       }
    316       foreach (var op in operators.OfType<ISymbolicDataAnalysisExpressionCrossover<T>>()) {
    317314        op.ProblemDataParameter.ActualName = ProblemDataParameter.Name;
    318315        op.EvaluationPartitionParameter.ActualName = FitnessCalculationPartitionParameter.Name;

  • branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/VariableCondition.cs

    r8085 r8206  
    152152    #region persistence and cloning
    153153    [StorableConstructor]
    154     private VariableCondition(bool deserializing)
    155       : base(deserializing) {
    156       variableNames = new List<string>();
    157     }
     154    private VariableCondition(bool deserializing) : base(deserializing) { }
    158155    private VariableCondition(VariableCondition original, Cloner cloner)
    159156      : base(original, cloner) {
Note: See TracChangeset for help on using the changeset viewer.