Free cookie consent management tool by TermsFeed Policy Generator

Changeset 9407


Ignore:
Timestamp:
04/30/13 10:54:12 (11 years ago)
Author:
jkarder
Message:

#2029: applied the changes suggested by gkronber in comment:5:ticket:2029

Files:
20 edited

Legend:

Unmodified
Added
Removed

  • branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/TestFunctions/CustomAdditiveMoveEvaluator.cs

    r9346 r9407  
    5656      var eval = EvaluatorParameter.ActualValue as CustomEvaluator;
    5757      if (eval != null)
    58         return eval.EvaluateFunction(vector);
     58        return eval.Evaluate(vector);
    5959      throw new InvalidOperationException("evaluator is not a custom evaluator");
    6060    }

  • branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/TestFunctions/CustomEvaluator.cs

    r9346 r9407  
    6464    }
    6565
    66     public override double EvaluateFunction(RealVector point) {
     66    public override double Evaluate(RealVector point) {
    6767      if (point[0] < 0 || point[1] < 0)
    6868        return 0;

  • trunk/sources/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/AckleyEvaluator.cs

    r9345 r9407  
    109109    /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
    110110    /// <returns>The result value of the Ackley function at the given point.</returns>
    111     public override double EvaluateFunction(RealVector point) {
     111    public override double Evaluate(RealVector point) {
    112112      return Apply(point);
    113113    }

  • trunk/sources/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/BealeEvaluator.cs

    r9345 r9407  
    9898    /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
    9999    /// <returns>The result value of the Beale function at the given point.</returns>
    100     public override double EvaluateFunction(RealVector point) {
     100    public override double Evaluate(RealVector point) {
    101101      return Apply(point);
    102102    }

  • trunk/sources/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/BoothEvaluator.cs

    r9345 r9407  
    9494    /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
    9595    /// <returns>The result value of the Booth function at the given point.</returns>
    96     public override double EvaluateFunction(RealVector point) {
     96    public override double Evaluate(RealVector point) {
    9797      return Apply(point);
    9898    }

  • trunk/sources/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/GriewankEvaluator.cs

    r9345 r9407  
    133133    /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
    134134    /// <returns>The result value of the Griewank function at the given point.</returns>
    135     public override double EvaluateFunction(RealVector point) {
     135    public override double Evaluate(RealVector point) {
    136136      if (point.Length > 100)
    137137        return Apply(point);

  • trunk/sources/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/LevyEvaluator.cs

    r9345 r9407  
    111111    /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
    112112    /// <returns>The result value of the Levy function at the given point.</returns>
    113     public override double EvaluateFunction(RealVector point) {
     113    public override double Evaluate(RealVector point) {
    114114      return Apply(point);
    115115    }

  • trunk/sources/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/MatyasEvaluator.cs

    r9345 r9407  
    9393    /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
    9494    /// <returns>The result value of the Matyas function at the given point.</returns>
    95     public override double EvaluateFunction(RealVector point) {
     95    public override double Evaluate(RealVector point) {
    9696      return Apply(point);
    9797    }

  • trunk/sources/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/MultinormalEvaluator.cs

    r9345 r9407  
    101101
    102102    private double FastFindOptimum(out RealVector bestSolution) {
    103       var optima = centers.Select((c, i) => new { f = EvaluateFunction(c), i }).OrderBy(v => v.f).ToList();
     103      var optima = centers.Select((c, i) => new { f = Evaluate(c), i }).OrderBy(v => v.f).ToList();
    104104      if (optima.Count == 0) {
    105105        bestSolution = new RealVector();
    … …  
    161161    }
    162162
    163     public override double EvaluateFunction(RealVector point) {
     163    public override double Evaluate(RealVector point) {
    164164      double value = 0;
    165165      if (centers.Count == 0) {

  • trunk/sources/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/RandomEvaluator.cs

    r9345 r9407  
    8686    }
    8787
    88     public override double EvaluateFunction(RealVector point) {
     88    public override double Evaluate(RealVector point) {
    8989      return ExecutionContext == null ? new System.Random().NextDouble() : RandomParameter.ActualValue.NextDouble();
    9090    }

  • trunk/sources/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/RastriginEvaluator.cs

    r9345 r9407  
    119119    /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
    120120    /// <returns>The result value of the Rastrigin function at the given point.</returns>
    121     public override double EvaluateFunction(RealVector point) {
     121    public override double Evaluate(RealVector point) {
    122122      return Apply(point, A.Value);
    123123    }

  • trunk/sources/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/RosenbrockEvaluator.cs

    r9345 r9407  
    105105    /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
    106106    /// <returns>The result value of the Rosenbrock function at the given point.</returns>
    107     public override double EvaluateFunction(RealVector point) {
     107    public override double Evaluate(RealVector point) {
    108108      return Apply(point);
    109109    }

  • trunk/sources/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/SchwefelEvaluator.cs

    r9345 r9407  
    9696    /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
    9797    /// <returns>The result value of the Schwefel function at the given point.</returns>
    98     public override double EvaluateFunction(RealVector point) {
     98    public override double Evaluate(RealVector point) {
    9999      return Apply(point);
    100100    }

  • trunk/sources/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/SingleObjectiveTestFunctionProblemEvaluator.cs

    r9345 r9407  
    8484    public override IOperation Apply() {
    8585      RealVector point = PointParameter.ActualValue;
    86       double quality = EvaluateFunction(point);
     86      double quality = Evaluate(point);
    8787      QualityParameter.ActualValue = new DoubleValue(quality);
    8888      return base.Apply();
    … …  
    9090
    9191    public virtual double Evaluate2D(double x, double y) {
    92       return EvaluateFunction(new RealVector(new double[] { x, y }));
     92      return Evaluate(new RealVector(new double[] { x, y }));
    9393    }
    9494
    … …  
    9898    /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
    9999    /// <returns>The result value of the function at the given point.</returns>
    100     public abstract double EvaluateFunction(RealVector point);
     100    public abstract double Evaluate(RealVector point);
    101101
    102102    /// <summary>

  • trunk/sources/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/SphereEvaluator.cs

    r9345 r9407  
    132132    /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
    133133    /// <returns>The result value of the Sphere function at the given point.</returns>
    134     public override double EvaluateFunction(RealVector point) {
     134    public override double Evaluate(RealVector point) {
    135135      return Apply(point, C.Value, Alpha.Value);
    136136    }

  • trunk/sources/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/SumSquaresEvaluator.cs

    r9345 r9407  
    9696    /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
    9797    /// <returns>The result value of the Sum Squares function at the given point.</returns>
    98     public override double EvaluateFunction(RealVector point) {
     98    public override double Evaluate(RealVector point) {
    9999      return Apply(point);
    100100    }

  • trunk/sources/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/ZakharovEvaluator.cs

    r9345 r9407  
    100100    /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
    101101    /// <returns>The result value of the Zakharov function at the given point.</returns>
    102     public override double EvaluateFunction(RealVector point) {
     102    public override double Evaluate(RealVector point) {
    103103      return Apply(point);
    104104    }

  • trunk/sources/HeuristicLab.Problems.TestFunctions/3.3/Improvers/SingleObjectiveTestFunctionImprovementOperator.cs

    r9345 r9407  
    125125        throw new ArgumentException("Cannot improve solution because it has the wrong type.");
    126126
    127       double bestSolQuality = Evaluator.EvaluateFunction(bestSol);
     127      var evaluator = Evaluator;
     128
     129      double bestSolQuality = evaluator.Evaluate(bestSol);
    128130
    129131      // create perturbed solutions
    … …  
    139141      for (int i = 0; i < ImprovementAttempts.Value; i++) {
    140142        // order according to their objective function value
    141         Array.Sort(simplex, (x, y) => Evaluator.EvaluateFunction(x).CompareTo(Evaluator.EvaluateFunction(y)));
     143        Array.Sort(simplex, (x, y) => evaluator.Evaluate(x).CompareTo(evaluator.Evaluate(y)));
    142144
    143145        // calculate centroid
    … …  
    153155        for (int j = 0; j < reflectionPoint.Length; j++)
    154156          reflectionPoint[j] = centroid[j] + Alpha.Value * (centroid[j] - simplex[simplex.Length - 1][j]);
    155         double reflectionPointQuality = Evaluator.EvaluateFunction(reflectionPoint);
    156         if (Evaluator.EvaluateFunction(simplex[0]) <= reflectionPointQuality
    157             && reflectionPointQuality < Evaluator.EvaluateFunction(simplex[simplex.Length - 2]))
     157        double reflectionPointQuality = evaluator.Evaluate(reflectionPoint);
     158        if (evaluator.Evaluate(simplex[0]) <= reflectionPointQuality
     159            && reflectionPointQuality < evaluator.Evaluate(simplex[simplex.Length - 2]))
    158160          simplex[simplex.Length - 1] = reflectionPoint;
    159161
    160162        // expansion
    161         if (reflectionPointQuality < Evaluator.EvaluateFunction(simplex[0])) {
     163        if (reflectionPointQuality < evaluator.Evaluate(simplex[0])) {
    162164          RealVector expansionPoint = new RealVector(bestSol.Length);
    163165          for (int j = 0; j < expansionPoint.Length; j++)
    164166            expansionPoint[j] = centroid[j] + Beta.Value * (reflectionPoint[j] - centroid[j]);
    165           simplex[simplex.Length - 1] = Evaluator.EvaluateFunction(expansionPoint) < reflectionPointQuality ? expansionPoint : reflectionPoint;
     167          simplex[simplex.Length - 1] = evaluator.Evaluate(expansionPoint) < reflectionPointQuality ? expansionPoint : reflectionPoint;
    166168        }
    167169
    168170        // contraction
    169         if (Evaluator.EvaluateFunction(simplex[simplex.Length - 2]) <= reflectionPointQuality
    170             && reflectionPointQuality < Evaluator.EvaluateFunction(simplex[simplex.Length - 1])) {
     171        if (evaluator.Evaluate(simplex[simplex.Length - 2]) <= reflectionPointQuality
     172            && reflectionPointQuality < evaluator.Evaluate(simplex[simplex.Length - 1])) {
    171173          RealVector outsideContractionPoint = new RealVector(bestSol.Length);
    172174          for (int j = 0; j < outsideContractionPoint.Length; j++)
    173175            outsideContractionPoint[j] = centroid[j] + Gamma.Value * (reflectionPoint[j] - centroid[j]);
    174           if (Evaluator.EvaluateFunction(outsideContractionPoint) <= reflectionPointQuality) {
     176          if (evaluator.Evaluate(outsideContractionPoint) <= reflectionPointQuality) {
    175177            simplex[simplex.Length - 1] = outsideContractionPoint;
    176             if (Evaluator.EvaluateFunction(reflectionPoint) >= Evaluator.EvaluateFunction(simplex[simplex.Length - 1])) {
     178            if (evaluator.Evaluate(reflectionPoint) >= evaluator.Evaluate(simplex[simplex.Length - 1])) {
    177179              RealVector insideContractionPoint = new RealVector(bestSol.Length);
    178180              for (int j = 0; j < insideContractionPoint.Length; j++)
    179181                insideContractionPoint[j] = centroid[j] - Gamma.Value * (reflectionPoint[j] - centroid[j]);
    180               if (Evaluator.EvaluateFunction(insideContractionPoint) < Evaluator.EvaluateFunction(simplex[simplex.Length - 1])) simplex[simplex.Length - 1] = insideContractionPoint;
     182              if (evaluator.Evaluate(insideContractionPoint) < evaluator.Evaluate(simplex[simplex.Length - 1])) simplex[simplex.Length - 1] = insideContractionPoint;
    181183            }
    182184          }

  • trunk/sources/HeuristicLab.Problems.TestFunctions/3.3/Interfaces/ISingleObjectiveTestFunctionProblemEvaluator.cs

    r9345 r9407  
    3939
    4040    double Evaluate2D(double x, double y);
    41     double EvaluateFunction(RealVector point);
     41    double Evaluate(RealVector point);
    4242    RealVector GetBestKnownSolution(int dimension);
    4343  }

  • trunk/sources/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/MultinormalAdditiveMoveEvaluator.cs

    r9345 r9407  
    5555      var eval = EvaluatorParameter.ActualValue as MultinormalEvaluator;
    5656      if (eval != null)
    57         return eval.EvaluateFunction(wrapper);
     57        return eval.Evaluate(wrapper);
    5858      throw new InvalidOperationException("evaluator is not a multinormal evaluator");
    5959    }
Note: See TracChangeset for help on using the changeset viewer.