Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
11/16/11 15:07:36 (12 years ago)
Author:
ascheibe
Message:

#1659 updated branch from trunk

Location:
branches/Benchmarking
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • branches/Benchmarking

  • branches/Benchmarking/sources

  • branches/Benchmarking/sources/HeuristicLab.Problems.DataAnalysis

  • branches/Benchmarking/sources/HeuristicLab.Problems.DataAnalysis/3.4/OnlineCalculators/OnlineWeightedDirectionalSymmetryCalculator.cs

    r6807 r7000  
    2222using System;
    2323using System.Collections.Generic;
     24using HeuristicLab.Common;
    2425
    2526
    2627namespace HeuristicLab.Problems.DataAnalysis {
    27   public class OnlineWeightedDirectionalSymmetryCalculator : IOnlineCalculator {
    28     private double prevEstimated;
    29     private double prevOriginal;
     28  public class OnlineWeightedDirectionalSymmetryCalculator : IOnlineTimeSeriesCalculator {
    3029    private int n;
    3130    private double correctSum;
     
    5251    }
    5352
    54     public void Add(double original, double estimated) {
    55       if (double.IsNaN(estimated) || double.IsInfinity(estimated) || double.IsNaN(original) || double.IsInfinity(original) || (errorState & OnlineCalculatorError.InvalidValueAdded) > 0) {
     53    public void Add(double startValue, IEnumerable<double> actualContinuation, IEnumerable<double> predictedContinuation) {
     54      if (double.IsNaN(startValue) || (errorState & OnlineCalculatorError.InvalidValueAdded) > 0) {
    5655        errorState = errorState | OnlineCalculatorError.InvalidValueAdded;
    57       } else if (n == 0) {
    58         prevOriginal = original;
    59         prevEstimated = estimated;
    60         n++;
    6156      } else {
    62         double err = Math.Abs(original - estimated);
    63         if ((original - prevOriginal) * (estimated - prevEstimated) >= 0.0) {
    64           correctSum += err;
     57        var actualEnumerator = actualContinuation.GetEnumerator();
     58        var predictedEnumerator = predictedContinuation.GetEnumerator();
     59        while (actualEnumerator.MoveNext() & predictedEnumerator.MoveNext() & errorState != OnlineCalculatorError.InvalidValueAdded) {
     60          double actual = actualEnumerator.Current;
     61          double predicted = predictedEnumerator.Current;
     62          if (double.IsNaN(actual) || double.IsNaN(predicted)) {
     63            errorState = errorState | OnlineCalculatorError.InvalidValueAdded;
     64          } else {
     65            double err = Math.Abs(actual - predicted);
     66            // count as correct only if the trend (positive/negative/no change) is predicted correctly
     67            if ((actual - startValue) * (predicted - startValue) > 0.0 ||
     68              (actual - startValue).IsAlmost(predicted - startValue)) {
     69              correctSum += err;
     70            } else {
     71              incorrectSum += err;
     72            }
     73            n++;
     74          }
     75        }
     76        // check if both enumerators are at the end to make sure both enumerations have the same length
     77        if (actualEnumerator.MoveNext() || predictedEnumerator.MoveNext()) {
     78          errorState = errorState | OnlineCalculatorError.InvalidValueAdded;
    6579        } else {
    66           incorrectSum += err;
     80          errorState = errorState & (~OnlineCalculatorError.InsufficientElementsAdded); // n >= 1
    6781        }
    68         n++;
    69         errorState = errorState & (~OnlineCalculatorError.InsufficientElementsAdded);        // n >= 1
    70         prevOriginal = original;
    71         prevEstimated = estimated;
    7282      }
    7383    }
     
    7787      correctSum = 0;
    7888      incorrectSum = 0;
    79       prevOriginal = double.NaN;
    80       prevEstimated = double.NaN;
    8189      errorState = OnlineCalculatorError.InsufficientElementsAdded;
    8290    }
    8391
    8492
    85     public static double Calculate(IEnumerable<double> first, IEnumerable<double> second, out OnlineCalculatorError errorState) {
    86       IEnumerator<double> firstEnumerator = first.GetEnumerator();
    87       IEnumerator<double> secondEnumerator = second.GetEnumerator();
    88       OnlineWeightedDirectionalSymmetryCalculator dsCalculator = new OnlineWeightedDirectionalSymmetryCalculator();
    89      
    90       // add first element of time series as a reference point
    91       firstEnumerator.MoveNext();
    92       secondEnumerator.MoveNext();
    93       dsCalculator.Add(firstEnumerator.Current, secondEnumerator.Current);
     93    public static double Calculate(IEnumerable<double> startValues, IEnumerable<IEnumerable<double>> actualContinuations, IEnumerable<IEnumerable<double>> predictedContinuations, out OnlineCalculatorError errorState) {
     94      IEnumerator<double> startValueEnumerator = startValues.GetEnumerator();
     95      IEnumerator<IEnumerable<double>> actualContinuationsEnumerator = actualContinuations.GetEnumerator();
     96      IEnumerator<IEnumerable<double>> predictedContinuationsEnumerator = predictedContinuations.GetEnumerator();
     97      OnlineWeightedDirectionalSymmetryCalculator calculator = new OnlineWeightedDirectionalSymmetryCalculator();
    9498
    95       // always move forward both enumerators (do not use short-circuit evaluation!)
    96       while (firstEnumerator.MoveNext() & secondEnumerator.MoveNext()) {
    97         double estimated = secondEnumerator.Current;
    98         double original = firstEnumerator.Current;
    99         dsCalculator.Add(original, estimated);
    100         if (dsCalculator.ErrorState != OnlineCalculatorError.None) break;
     99      // always move forward all enumerators (do not use short-circuit evaluation!)
     100      while (startValueEnumerator.MoveNext() & actualContinuationsEnumerator.MoveNext() & predictedContinuationsEnumerator.MoveNext()) {
     101        calculator.Add(startValueEnumerator.Current, actualContinuationsEnumerator.Current, predictedContinuationsEnumerator.Current);
     102        if (calculator.ErrorState != OnlineCalculatorError.None) break;
    101103      }
    102104
    103       // check if both enumerators are at the end to make sure both enumerations have the same length
    104       if (dsCalculator.ErrorState == OnlineCalculatorError.None &&
    105           (secondEnumerator.MoveNext() || firstEnumerator.MoveNext())) {
    106         throw new ArgumentException("Number of elements in first and second enumeration doesn't match.");
     105      // check if all enumerators are at the end to make sure both enumerations have the same length
     106      if (calculator.ErrorState == OnlineCalculatorError.None &&
     107          (startValueEnumerator.MoveNext() || actualContinuationsEnumerator.MoveNext() || predictedContinuationsEnumerator.MoveNext())) {
     108        throw new ArgumentException("Number of elements in startValues, actualContinuations and estimatedValues predictedContinuations doesn't match.");
    107109      } else {
    108         errorState = dsCalculator.ErrorState;
    109         return dsCalculator.WeightedDirectionalSymmetry;
     110        errorState = calculator.ErrorState;
     111        return calculator.WeightedDirectionalSymmetry;
    110112      }
    111113    }
Note: See TracChangeset for help on using the changeset viewer.