Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
10/13/16 19:47:41 (8 years ago)
Author:
gkronber
Message:

#2650 Merged r14282:14322 from trunk to branch (fixing conflicts)

Location:
branches/symbreg-factors-2650
Files:
25 edited

Legend:

Unmodified
Added
Removed

  • branches/symbreg-factors-2650

  • branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis

  • branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationModel.cs

    r13992 r14330  
    2020#endregion
    2121
     22using System;
    2223using System.Collections.Generic;
    2324using HeuristicLab.Common;
    … …  
    3334    public string TargetVariable {
    3435      get { return targetVariable; }
    35       protected set { targetVariable = value; }
     36      set {
     37        if (string.IsNullOrEmpty(value) || targetVariable == value) return;
     38        targetVariable = value;
     39        OnTargetVariableChanged(this, EventArgs.Empty);
     40      }
    3641    }
    3742
    38     protected ClassificationModel(bool deserializing) : base(deserializing) { }
     43    protected ClassificationModel(bool deserializing)
     44      : base(deserializing) {
     45      targetVariable = string.Empty;
     46    }
    3947    protected ClassificationModel(ClassificationModel original, Cloner cloner)
    4048      : base(original, cloner) {
    … …  
    5563    }
    5664
    57     [StorableHook(HookType.AfterDeserialization)]
    58     private void AfterDeserialization() {
    59       // BackwardsCompatibility3.3
    60       #region Backwards compatible code, remove with 3.4
    61       targetVariable = string.Empty;
    62       #endregion
    63     }
    64 
    6565    public abstract IEnumerable<double> GetEstimatedClassValues(IDataset dataset, IEnumerable<int> rows);
    6666    public abstract IClassificationSolution CreateClassificationSolution(IClassificationProblemData problemData);
     67
     68    #region events
     69    public event EventHandler TargetVariableChanged;
     70    private void OnTargetVariableChanged(object sender, EventArgs args) {
     71      var changed = TargetVariableChanged;
     72      if (changed != null)
     73        changed(sender, args);
     74    }
     75    #endregion
    6776  }
    6877}

  • branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationSolutionBase.cs

    r14185 r14330  
    8888    [StorableHook(HookType.AfterDeserialization)]
    8989    private void AfterDeserialization() {
     90      if (string.IsNullOrEmpty(Model.TargetVariable))
     91        Model.TargetVariable = this.ProblemData.TargetVariable;
     92
    9093      if (!this.ContainsKey(TrainingNormalizedGiniCoefficientResultName))
    9194        Add(new Result(TrainingNormalizedGiniCoefficientResultName, "Normalized Gini coefficient of the model on the training partition.", new DoubleValue()));

  • branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionModel.cs

    r13992 r14330  
    2020#endregion
    2121
     22using System;
    2223using System.Collections.Generic;
    2324using HeuristicLab.Common;
    … …  
    3334    public string TargetVariable {
    3435      get { return targetVariable; }
    35       protected set { targetVariable = value; }
     36      set {
     37        if (string.IsNullOrEmpty(value) || targetVariable == value) return;
     38        targetVariable = value;
     39        OnTargetVariableChanged(this, EventArgs.Empty);
     40      }
    3641    }
    3742
    38     protected RegressionModel(bool deserializing) : base(deserializing) { }
     43    protected RegressionModel(bool deserializing)
     44      : base(deserializing) {
     45      targetVariable = string.Empty;
     46    }
    3947
    4048    protected RegressionModel(RegressionModel original, Cloner cloner)
    … …  
    5664    }
    5765
    58     [StorableHook(HookType.AfterDeserialization)]
    59     private void AfterDeserialization() {
    60       // BackwardsCompatibility3.3
    61       #region Backwards compatible code, remove with 3.4
    62       targetVariable = string.Empty;
    63       #endregion
    64     }
    6566    public abstract IEnumerable<double> GetEstimatedValues(IDataset dataset, IEnumerable<int> rows);
    6667    public abstract IRegressionSolution CreateRegressionSolution(IRegressionProblemData problemData);
     68
     69    #region events
     70    public event EventHandler TargetVariableChanged;
     71    private void OnTargetVariableChanged(object sender, EventArgs args) {
     72      var changed = TargetVariableChanged;
     73      if (changed != null)
     74        changed(sender, args);
     75    }
     76    #endregion
    6777  }
    6878}

  • branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionSolutionBase.cs

    r14185 r14330  
    176176    [StorableHook(HookType.AfterDeserialization)]
    177177    private void AfterDeserialization() {
     178      if (string.IsNullOrEmpty(Model.TargetVariable))
     179        Model.TargetVariable = this.ProblemData.TargetVariable;
     180
    178181      // BackwardsCompatibility3.4
    179182      #region Backwards compatible code, remove with 3.5
    … …  
    230233
    231234      double trainingR = OnlinePearsonsRCalculator.Calculate(originalTrainingValues, estimatedTrainingValues, out errorState);
    232       TrainingRSquared = errorState == OnlineCalculatorError.None ? trainingR*trainingR : double.NaN;
     235      TrainingRSquared = errorState == OnlineCalculatorError.None ? trainingR * trainingR : double.NaN;
    233236      double testR = OnlinePearsonsRCalculator.Calculate(originalTestValues, estimatedTestValues, out errorState);
    234       TestRSquared = errorState == OnlineCalculatorError.None ? testR*testR : double.NaN;
     237      TestRSquared = errorState == OnlineCalculatorError.None ? testR * testR : double.NaN;
    235238
    236239      double trainingRelError = OnlineMeanAbsolutePercentageErrorCalculator.Calculate(originalTrainingValues, estimatedTrainingValues, out errorState);

  • branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/Classification/IClassificationModel.cs

    r14239 r14330  
    2020#endregion
    2121
     22using System;
    2223using System.Collections.Generic;
     24
    2325namespace HeuristicLab.Problems.DataAnalysis {
    2426  /// <summary>
    … …  
    2931    IEnumerable<double> GetEstimatedClassValues(IDataset dataset, IEnumerable<int> rows);
    3032    IClassificationSolution CreateClassificationSolution(IClassificationProblemData problemData);
    31     string TargetVariable { get; }
     33    string TargetVariable { get; set; }
     34    event EventHandler TargetVariableChanged;
    3235  }
    3336}

  • branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/Regression/IRegressionModel.cs

    r14239 r14330  
    2020#endregion
    2121
     22using System;
    2223using System.Collections.Generic;
    2324
    … …  
    3031    IEnumerable<double> GetEstimatedValues(IDataset dataset, IEnumerable<int> rows);
    3132    IRegressionSolution CreateRegressionSolution(IRegressionProblemData problemData);
    32     string TargetVariable { get; }
     33    string TargetVariable { get; set; }
     34    event EventHandler TargetVariableChanged;
    3335  }
    3436}

  • branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis/3.4/OnlineCalculators/ClassificationPerformanceMeasuresCalculator.cs

    r14185 r14330  
    2323using System.Collections.Generic;
    2424using HeuristicLab.Common;
    25 using HeuristicLab.Problems.DataAnalysis.OnlineCalculators;
    2625
    2726namespace HeuristicLab.Problems.DataAnalysis {
    28   public class ClassificationPerformanceMeasuresCalculator {
     27  public class ClassificationPerformanceMeasuresCalculator : IDeepCloneable {
    2928
    3029    public ClassificationPerformanceMeasuresCalculator(string positiveClassName, double positiveClassValue) {
    … …  
    3231      this.positiveClassValue = positiveClassValue;
    3332      Reset();
     33    }
     34
     35    protected ClassificationPerformanceMeasuresCalculator(ClassificationPerformanceMeasuresCalculator original, Cloner cloner = null) {
     36      positiveClassName = original.positiveClassName;
     37      positiveClassValue = original.positiveClassValue;
     38      truePositiveCount = original.truePositiveCount;
     39      falsePositiveCount = original.falsePositiveCount;
     40      trueNegativeCount = original.trueNegativeCount;
     41      falseNegativeCount = original.falseNegativeCount;
     42      errorState = original.errorState;
    3443    }
    3544
    … …  
    138147      errorState = ErrorState;
    139148    }
     149
     150    // IDeepCloneable interface members
     151    public object Clone() {
     152      return new ClassificationPerformanceMeasuresCalculator(this);
     153    }
     154
     155    public IDeepCloneable Clone(Cloner cloner) {
     156      var clone = cloner.GetClone(this);
     157      if (clone == null) {
     158        clone = new ClassificationPerformanceMeasuresCalculator(this);
     159        cloner.RegisterClonedObject(this, clone);
     160      }
     161      return clone;
     162    }
    140163  }
    141164}

  • branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis/3.4/OnlineCalculators/OnlineAccuracyCalculator.cs

    r14185 r14330  
    2525
    2626namespace HeuristicLab.Problems.DataAnalysis {
    27   public class OnlineAccuracyCalculator : IOnlineCalculator {
     27  public class OnlineAccuracyCalculator : IOnlineCalculator, IDeepCloneable {
    2828
    2929    private int correctlyClassified;
    … …  
    3737    public OnlineAccuracyCalculator() {
    3838      Reset();
     39    }
     40
     41    // private constructor used internally by the Clone() method
     42    protected OnlineAccuracyCalculator(OnlineAccuracyCalculator other, Cloner cloner = null) {
     43      correctlyClassified = other.correctlyClassified;
     44      n = other.n;
     45      errorState = other.errorState;
    3946    }
    4047
    … …  
    9097      }
    9198    }
     99
     100    // IDeepCloneable interface members
     101    public object Clone() {
     102      return new OnlineAccuracyCalculator(this);
     103    }
     104
     105    public IDeepCloneable Clone(Cloner cloner) {
     106      var clone = cloner.GetClone(this);
     107      if (clone == null) {
     108        clone = new OnlineAccuracyCalculator(this);
     109        cloner.RegisterClonedObject(this, clone);
     110      }
     111      return clone;
     112    }
    92113  }
    93114}

  • branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis/3.4/OnlineCalculators/OnlineBoundedMeanSquaredErrorCalculator.cs

    r14185 r14330  
    2222using System;
    2323using System.Collections.Generic;
     24using HeuristicLab.Common;
    2425
    2526namespace HeuristicLab.Problems.DataAnalysis {
    26   public class OnlineBoundedMeanSquaredErrorCalculator : IOnlineCalculator {
     27  public class OnlineBoundedMeanSquaredErrorCalculator : IOnlineCalculator, IDeepCloneable {
    2728
    2829    private double errorSum;
    … …  
    3839
    3940
    40     public OnlineBoundedMeanSquaredErrorCalculator(double lowerBound, double upperbound) {
     41    public OnlineBoundedMeanSquaredErrorCalculator(double lowerBound, double upperBound) {
    4142      LowerBound = lowerBound;
    42       UpperBound = upperbound;
     43      UpperBound = upperBound;
    4344      Reset();
     45    }
     46
     47    protected OnlineBoundedMeanSquaredErrorCalculator(OnlineBoundedMeanSquaredErrorCalculator original, Cloner cloner = null) {
     48      LowerBound = original.LowerBound;
     49      UpperBound = original.UpperBound;
     50      n = original.n;
     51      errorSum = original.errorSum;
     52      errorState = original.ErrorState;
    4453    }
    4554
    … …  
    96105      }
    97106    }
     107
     108    // IDeepCloneable interface members
     109    public object Clone() {
     110      return new OnlineBoundedMeanSquaredErrorCalculator(this);
     111    }
     112
     113    public IDeepCloneable Clone(Cloner cloner) {
     114      var clone = cloner.GetClone(this);
     115      if (clone == null) {
     116        clone = new OnlineBoundedMeanSquaredErrorCalculator(this);
     117        cloner.RegisterClonedObject(this, clone);
     118      }
     119      return clone;
     120    }
    98121  }
    99122}

  • branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis/3.4/OnlineCalculators/OnlineCovarianceCalculator.cs

    r14185 r14330  
    2222using System;
    2323using System.Collections.Generic;
     24using HeuristicLab.Common;
    2425
    2526namespace HeuristicLab.Problems.DataAnalysis {
    26   public class OnlineCovarianceCalculator : IOnlineCalculator {
     27  public class OnlineCovarianceCalculator : IOnlineCalculator, IDeepCloneable {
    2728
    2829    private double xMean, yMean, Cn;
    … …  
    3637    public OnlineCovarianceCalculator() {
    3738      Reset();
     39    }
     40
     41    protected OnlineCovarianceCalculator(OnlineCovarianceCalculator other, Cloner cloner = null) {
     42      Cn = other.Cn;
     43      xMean = other.xMean;
     44      yMean = other.yMean;
     45      n = other.n;
     46      errorState = other.errorState;
    3847    }
    3948
    … …  
    94103      }
    95104    }
     105
     106    // IDeepCloneable interface members
     107    public object Clone() {
     108      return new OnlineCovarianceCalculator(this);
     109    }
     110
     111    public IDeepCloneable Clone(Cloner cloner) {
     112      var clone = cloner.GetClone(this);
     113      if (clone == null) {
     114        clone = new OnlineCovarianceCalculator(this);
     115        cloner.RegisterClonedObject(this, clone);
     116      }
     117      return clone;
     118    }
    96119  }
    97120}

  • branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis/3.4/OnlineCalculators/OnlineDirectionalSymmetryCalculator.cs

    r14185 r14330  
    2626
    2727namespace HeuristicLab.Problems.DataAnalysis {
    28   public class OnlineDirectionalSymmetryCalculator : IOnlineTimeSeriesCalculator {
     28  public class OnlineDirectionalSymmetryCalculator : IOnlineTimeSeriesCalculator, IDeepCloneable {
    2929    private int n;
    3030    private int nCorrect;
    … …  
    3939    public OnlineDirectionalSymmetryCalculator() {
    4040      Reset();
     41    }
     42
     43    protected OnlineDirectionalSymmetryCalculator(OnlineDirectionalSymmetryCalculator other, Cloner cloner = null) {
     44      n = other.n;
     45      nCorrect = other.nCorrect;
     46      errorState = other.errorState;
    4147    }
    4248
    … …  
    94100      return dsCalculator.DirectionalSymmetry;
    95101    }
    96    
     102
    97103    public static double Calculate(IEnumerable<double> startValues, IEnumerable<IEnumerable<double>> actualContinuations, IEnumerable<IEnumerable<double>> predictedContinuations, out OnlineCalculatorError errorState) {
    98104      IEnumerator<double> startValueEnumerator = startValues.GetEnumerator();
    … …  
    116122      }
    117123    }
     124
     125    // IDeepCloneable interface members
     126    public object Clone() {
     127      return new OnlineDirectionalSymmetryCalculator(this);
     128    }
     129
     130    public IDeepCloneable Clone(Cloner cloner) {
     131      var clone = cloner.GetClone(this);
     132      if (clone == null) {
     133        clone = new OnlineDirectionalSymmetryCalculator(this);
     134        cloner.RegisterClonedObject(this, clone);
     135      }
     136      return clone;
     137    }
    118138  }
    119139}

  • branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis/3.4/OnlineCalculators/OnlineLinearScalingParameterCalculator.cs

    r14185 r14330  
    2525
    2626namespace HeuristicLab.Problems.DataAnalysis {
    27   public class OnlineLinearScalingParameterCalculator {
     27  public class OnlineLinearScalingParameterCalculator : IDeepCloneable {
    2828
    2929    /// <summary>
    … …  
    6565      Reset();
    6666    }
     67
     68    protected OnlineLinearScalingParameterCalculator(OnlineLinearScalingParameterCalculator other, Cloner cloner) {
     69      targetMeanCalculator = (OnlineMeanAndVarianceCalculator)other.targetMeanCalculator.Clone(cloner);
     70      originalMeanAndVarianceCalculator = (OnlineMeanAndVarianceCalculator)other.originalMeanAndVarianceCalculator.Clone(cloner);
     71      originalTargetCovarianceCalculator = (OnlineCovarianceCalculator)other.originalTargetCovarianceCalculator.Clone(cloner);
     72      // do not reset the calculators here
     73    }
     74
    6775
    6876    public void Reset() {
    … …  
    117125      }
    118126    }
     127
     128    // IDeepCloneable interface members
     129    public object Clone() {
     130      var cloner = new Cloner();
     131      return new OnlineLinearScalingParameterCalculator(this, cloner);
     132    }
     133
     134    public IDeepCloneable Clone(Cloner cloner) {
     135      var clone = cloner.GetClone(this);
     136      if (clone == null) {
     137        clone = new OnlineLinearScalingParameterCalculator(this, cloner);
     138        cloner.RegisterClonedObject(this, clone);
     139      }
     140      return clone;
     141    }
    119142  }
    120143}

  • branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis/3.4/OnlineCalculators/OnlineMaxAbsoluteErrorCalculator.cs

    r14185 r14330  
    2222using System;
    2323using System.Collections.Generic;
     24using HeuristicLab.Common;
    2425
    2526namespace HeuristicLab.Problems.DataAnalysis {
    26   public class OnlineMaxAbsoluteErrorCalculator : IOnlineCalculator {
     27  public class OnlineMaxAbsoluteErrorCalculator : IOnlineCalculator, IDeepCloneable {
    2728
    2829    private double mae;
    … …  
    3637    public OnlineMaxAbsoluteErrorCalculator() {
    3738      Reset();
     39    }
     40
     41    protected OnlineMaxAbsoluteErrorCalculator(OnlineMaxAbsoluteErrorCalculator other, Cloner cloner = null) {
     42      mae = other.mae;
     43      n = other.n;
     44      errorState = other.errorState;
    3845    }
    3946
    … …  
    8895      }
    8996    }
     97
     98    // IDeepCloneable interface members
     99    public object Clone() {
     100      return new OnlineMaxAbsoluteErrorCalculator(this);
     101    }
     102
     103    public IDeepCloneable Clone(Cloner cloner) {
     104      var clone = cloner.GetClone(this);
     105      if (clone == null) {
     106        clone = new OnlineMaxAbsoluteErrorCalculator(this);
     107        cloner.RegisterClonedObject(this, clone);
     108      }
     109      return clone;
     110    }
    90111  }
    91112}

  • branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis/3.4/OnlineCalculators/OnlineMeanAbsoluteErrorCalculator.cs

    r14185 r14330  
    2222using System;
    2323using System.Collections.Generic;
     24using HeuristicLab.Common;
    2425
    2526namespace HeuristicLab.Problems.DataAnalysis {
    26   public class OnlineMeanAbsoluteErrorCalculator : IOnlineCalculator {
     27  public class OnlineMeanAbsoluteErrorCalculator : IOnlineCalculator, IDeepCloneable {
    2728
    2829    private double sae;
    … …  
    3637    public OnlineMeanAbsoluteErrorCalculator() {
    3738      Reset();
     39    }
     40
     41    protected OnlineMeanAbsoluteErrorCalculator(OnlineMeanAbsoluteErrorCalculator other, Cloner cloner = null) {
     42      sae = other.sae;
     43      n = other.n;
     44      errorState = other.errorState;
    3845    }
    3946
    … …  
    8794      }
    8895    }
     96
     97    // IDeepCloneable interface members
     98    public object Clone() {
     99      return new OnlineMeanAbsoluteErrorCalculator(this);
     100    }
     101
     102    public IDeepCloneable Clone(Cloner cloner) {
     103      var clone = cloner.GetClone(this);
     104      if (clone == null) {
     105        clone = new OnlineMeanAbsoluteErrorCalculator(this);
     106        cloner.RegisterClonedObject(this, clone);
     107      }
     108      return clone;
     109    }
    89110  }
    90111}

  • branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis/3.4/OnlineCalculators/OnlineMeanAbsolutePercentageErrorCalculator.cs

    r14185 r14330  
    2525
    2626namespace HeuristicLab.Problems.DataAnalysis {
    27   public class OnlineMeanAbsolutePercentageErrorCalculator : IOnlineCalculator {
     27  public class OnlineMeanAbsolutePercentageErrorCalculator : IOnlineCalculator, IDeepCloneable {
    2828
    2929    private double sre;
    … …  
    3737    public OnlineMeanAbsolutePercentageErrorCalculator() {
    3838      Reset();
     39    }
     40
     41    protected OnlineMeanAbsolutePercentageErrorCalculator(OnlineMeanAbsolutePercentageErrorCalculator other, Cloner cloner = null) {
     42      sre = other.sre;
     43      n = other.n;
     44      errorState = other.errorState;
    3945    }
    4046
    … …  
    8995      }
    9096    }
     97
     98    // IDeepCloneable interface members
     99    public object Clone() {
     100      return new OnlineMeanAbsolutePercentageErrorCalculator(this);
     101    }
     102
     103    public IDeepCloneable Clone(Cloner cloner) {
     104      var clone = cloner.GetClone(this);
     105      if (clone == null) {
     106        clone = new OnlineMeanAbsolutePercentageErrorCalculator(this);
     107        cloner.RegisterClonedObject(this, clone);
     108      }
     109      return clone;
     110    }
    91111  }
    92112}

  • branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis/3.4/OnlineCalculators/OnlineMeanAndVarianceCalculator.cs

    r14185 r14330  
    2121
    2222using System.Collections.Generic;
     23using HeuristicLab.Common;
    2324
    2425namespace HeuristicLab.Problems.DataAnalysis {
    25   public class OnlineMeanAndVarianceCalculator {
     26  public class OnlineMeanAndVarianceCalculator : IDeepCloneable {
    2627
    2728    private double m_oldM, m_newM, m_oldS, m_newS;
    … …  
    6667    }
    6768
     69    protected OnlineMeanAndVarianceCalculator(OnlineMeanAndVarianceCalculator other, Cloner cloner = null) {
     70      m_oldS = other.m_oldS;
     71      m_oldM = other.m_oldM;
     72      m_newS = other.m_newS;
     73      m_newM = other.m_newM;
     74      n = other.n;
     75      errorState = other.errorState;
     76      varianceErrorState = other.varianceErrorState;
     77    }
     78
    6879    public void Reset() {
    6980      n = 0;
    … …  
    7586      if (double.IsNaN(x) || double.IsInfinity(x) || x > 1E13 || x < -1E13 || (errorState & OnlineCalculatorError.InvalidValueAdded) > 0) {
    7687        errorState = errorState | OnlineCalculatorError.InvalidValueAdded;
    77         varianceErrorState = errorState | OnlineCalculatorError.InvalidValueAdded;
     88        varianceErrorState = varianceErrorState | OnlineCalculatorError.InvalidValueAdded;
    7889      } else {
    7990        n++;
    … …  
    106117      varianceErrorState = meanAndVarianceCalculator.VarianceErrorState;
    107118    }
     119
     120    // IDeepCloneable members
     121    public object Clone() {
     122      return new OnlineMeanAndVarianceCalculator(this);
     123    }
     124
     125    public IDeepCloneable Clone(Cloner cloner) {
     126      var clone = cloner.GetClone(this);
     127      if (clone == null) {
     128        clone = new OnlineMeanAndVarianceCalculator(this);
     129        cloner.RegisterClonedObject(this, clone);
     130      }
     131      return clone;
     132    }
    108133  }
    109134}

  • branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis/3.4/OnlineCalculators/OnlineMeanErrorCalculator.cs

    r14185 r14330  
    2222using System;
    2323using System.Collections.Generic;
     24using HeuristicLab.Common;
    2425
    2526namespace HeuristicLab.Problems.DataAnalysis {
    26   public class OnlineMeanErrorCalculator : IOnlineCalculator {
     27  public class OnlineMeanErrorCalculator : IOnlineCalculator, IDeepCloneable {
    2728
    2829    private readonly OnlineMeanAndVarianceCalculator meanAndVarianceCalculator;
    … …  
    3435      meanAndVarianceCalculator = new OnlineMeanAndVarianceCalculator();
    3536      Reset();
     37    }
     38
     39    protected OnlineMeanErrorCalculator(OnlineMeanErrorCalculator other, Cloner cloner) {
     40      meanAndVarianceCalculator = (OnlineMeanAndVarianceCalculator)other.meanAndVarianceCalculator.Clone(cloner);
    3641    }
    3742
    … …  
    7479      }
    7580    }
     81
     82    // IDeepCloneable members
     83    public object Clone() {
     84      var cloner = new Cloner();
     85      return new OnlineMeanErrorCalculator(this, cloner);
     86    }
     87
     88    public IDeepCloneable Clone(Cloner cloner) {
     89      var clone = cloner.GetClone(this);
     90      if (clone == null) {
     91        clone = new OnlineMeanErrorCalculator(this, cloner);
     92        cloner.RegisterClonedObject(this, clone);
     93      }
     94      return clone;
     95    }
    7696  }
    7797}

  • branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis/3.4/OnlineCalculators/OnlineMeanSquaredErrorCalculator.cs

    r14185 r14330  
    2222using System;
    2323using System.Collections.Generic;
     24using HeuristicLab.Common;
    2425
    2526namespace HeuristicLab.Problems.DataAnalysis {
    26   public class OnlineMeanSquaredErrorCalculator : IOnlineCalculator {
     27  public class OnlineMeanSquaredErrorCalculator : IOnlineCalculator, IDeepCloneable {
    2728
    2829    private double sse;
    … …  
    3637    public OnlineMeanSquaredErrorCalculator() {
    3738      Reset();
     39    }
     40
     41    protected OnlineMeanSquaredErrorCalculator(OnlineMeanSquaredErrorCalculator other, Cloner cloner = null) {
     42      sse = other.sse;
     43      n = other.n;
     44      errorState = other.errorState;
    3845    }
    3946
    … …  
    8794      }
    8895    }
     96
     97    // IDeepCloneable members
     98    public object Clone() {
     99      return new OnlineMeanSquaredErrorCalculator(this);
     100    }
     101
     102    public IDeepCloneable Clone(Cloner cloner) {
     103      var clone = cloner.GetClone(this);
     104      if (clone == null) {
     105        clone = new OnlineMeanSquaredErrorCalculator(this);
     106        cloner.RegisterClonedObject(this, clone);
     107      }
     108      return clone;
     109    }
    89110  }
    90111}

  • branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis/3.4/OnlineCalculators/OnlineNormalizedMeanSquaredErrorCalculator.cs

    r14226 r14330  
    2222using System;
    2323using System.Collections.Generic;
     24using HeuristicLab.Common;
    2425
    2526namespace HeuristicLab.Problems.DataAnalysis {
    26   public class OnlineNormalizedMeanSquaredErrorCalculator : IOnlineCalculator {
     27  public class OnlineNormalizedMeanSquaredErrorCalculator : IOnlineCalculator, IDeepCloneable {
    2728    private OnlineMeanAndVarianceCalculator meanSquaredErrorCalculator;
    2829    private OnlineMeanAndVarianceCalculator originalVarianceCalculator;
    … …  
    4041      originalVarianceCalculator = new OnlineMeanAndVarianceCalculator();
    4142      Reset();
     43    }
     44
     45    protected OnlineNormalizedMeanSquaredErrorCalculator(OnlineNormalizedMeanSquaredErrorCalculator other, Cloner cloner) {
     46      meanSquaredErrorCalculator = (OnlineMeanAndVarianceCalculator)other.meanSquaredErrorCalculator.Clone(cloner);
     47      originalVarianceCalculator = (OnlineMeanAndVarianceCalculator)other.originalVarianceCalculator.Clone(cloner);
    4248    }
    4349
    … …  
    9298      }
    9399    }
     100
     101    // IDeepCloneable members
     102    public object Clone() {
     103      var cloner = new Cloner();
     104      return new OnlineNormalizedMeanSquaredErrorCalculator(this, cloner);
     105    }
     106
     107    public IDeepCloneable Clone(Cloner cloner) {
     108      var clone = cloner.GetClone(this);
     109      if (clone == null) {
     110        clone = new OnlineNormalizedMeanSquaredErrorCalculator(this, cloner);
     111        cloner.RegisterClonedObject(this, clone);
     112      }
     113      return clone;
     114    }
    94115  }
    95116}

  • branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis/3.4/OnlineCalculators/OnlinePearsonsRCalculator.cs

    r14185 r14330  
    2525
    2626namespace HeuristicLab.Problems.DataAnalysis {
    27   public class OnlinePearsonsRCalculator : IOnlineCalculator {
     27  public class OnlinePearsonsRCalculator : IOnlineCalculator, IDeepCloneable {
    2828    private OnlineCovarianceCalculator covCalculator = new OnlineCovarianceCalculator();
    2929    private OnlineMeanAndVarianceCalculator sxCalculator = new OnlineMeanAndVarianceCalculator();
    … …  
    4646
    4747    public OnlinePearsonsRCalculator() { }
     48
     49    protected OnlinePearsonsRCalculator(OnlinePearsonsRCalculator other, Cloner cloner) {
     50      covCalculator = (OnlineCovarianceCalculator)other.covCalculator.Clone(cloner);
     51      sxCalculator = (OnlineMeanAndVarianceCalculator)other.sxCalculator.Clone(cloner);
     52      syCalculator = (OnlineMeanAndVarianceCalculator)other.syCalculator.Clone(cloner);
     53    }
    4854
    4955    #region IOnlineCalculator Members
    … …  
    9197      }
    9298    }
     99
     100    // IDeepCloneable members
     101    public object Clone() {
     102      var cloner = new Cloner();
     103      return new OnlinePearsonsRCalculator(this, cloner);
     104    }
     105
     106    public IDeepCloneable Clone(Cloner cloner) {
     107      var clone = cloner.GetClone(this);
     108      if (clone == null) {
     109        clone = new OnlinePearsonsRCalculator(this, cloner);
     110        cloner.RegisterClonedObject(this, clone);
     111      }
     112      return clone;
     113    }
    93114  }
    94115}

  • branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis/3.4/OnlineCalculators/OnlinePearsonsRSquaredCalculator.cs

    r14185 r14330  
    2626namespace HeuristicLab.Problems.DataAnalysis {
    2727  [Obsolete("Use OnlinePearsonsRCalculator directly")]
    28   public class OnlinePearsonsRSquaredCalculator : IOnlineCalculator {
     28  public class OnlinePearsonsRSquaredCalculator : IOnlineCalculator, IDeepCloneable {
    2929    private readonly OnlinePearsonsRCalculator rCalculator = new OnlinePearsonsRCalculator();
    3030
    … …  
    3737
    3838    public OnlinePearsonsRSquaredCalculator() { }
     39
     40    protected OnlinePearsonsRSquaredCalculator(OnlinePearsonsRSquaredCalculator other, Cloner cloner) {
     41      this.rCalculator = (OnlinePearsonsRCalculator)other.rCalculator.Clone(cloner);
     42    }
    3943
    4044    #region IOnlineCalculator Members
    … …  
    5963      return r * r;
    6064    }
     65
     66    // IDeepCloneable members
     67    public object Clone() {
     68      var cloner = new Cloner();
     69      return new OnlinePearsonsRSquaredCalculator(this, cloner);
     70    }
     71
     72    public IDeepCloneable Clone(Cloner cloner) {
     73      var clone = cloner.GetClone(this);
     74      if (clone == null) {
     75        clone = new OnlinePearsonsRSquaredCalculator(this, cloner);
     76        cloner.RegisterClonedObject(this, clone);
     77      }
     78      return clone;
     79    }
    6180  }
    6281}

  • branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis/3.4/OnlineCalculators/OnlineTheilsUStatisticCalculator.cs

    r14185 r14330  
    2222using System;
    2323using System.Collections.Generic;
     24using HeuristicLab.Common;
    2425
    2526namespace HeuristicLab.Problems.DataAnalysis {
    26   public class OnlineTheilsUStatisticCalculator : IOnlineTimeSeriesCalculator {
     27  public class OnlineTheilsUStatisticCalculator : IOnlineTimeSeriesCalculator, IDeepCloneable {
    2728    private OnlineMeanAndVarianceCalculator squaredErrorMeanCalculator;
    2829    private OnlineMeanAndVarianceCalculator unbiasedEstimatorMeanCalculator;
    … …  
    4344      unbiasedEstimatorMeanCalculator = new OnlineMeanAndVarianceCalculator();
    4445      Reset();
     46    }
     47
     48    protected OnlineTheilsUStatisticCalculator(OnlineTheilsUStatisticCalculator other, Cloner cloner) {
     49      squaredErrorMeanCalculator = (OnlineMeanAndVarianceCalculator)other.squaredErrorMeanCalculator.Clone(cloner);
     50      unbiasedEstimatorMeanCalculator = (OnlineMeanAndVarianceCalculator)other.unbiasedEstimatorMeanCalculator.Clone(cloner);
    4551    }
    4652
    … …  
    125131      }
    126132    }
     133
     134    // IDeepCloneable members
     135    public object Clone() {
     136      var cloner = new Cloner();
     137      return new OnlineTheilsUStatisticCalculator(this, cloner);
     138    }
     139
     140    public IDeepCloneable Clone(Cloner cloner) {
     141      var clone = cloner.GetClone(this);
     142      if (clone == null) {
     143        clone = new OnlineTheilsUStatisticCalculator(this, cloner);
     144        cloner.RegisterClonedObject(this, clone);
     145      }
     146      return clone;
     147    }
    127148  }
    128149}

  • branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis/3.4/OnlineCalculators/OnlineWeightedDirectionalSymmetryCalculator.cs

    r14185 r14330  
    2626
    2727namespace HeuristicLab.Problems.DataAnalysis {
    28   public class OnlineWeightedDirectionalSymmetryCalculator : IOnlineTimeSeriesCalculator {
     28  public class OnlineWeightedDirectionalSymmetryCalculator : IOnlineTimeSeriesCalculator, IDeepCloneable {
    2929    private int n;
    3030    private double correctSum;
    … …  
    4040    public OnlineWeightedDirectionalSymmetryCalculator() {
    4141      Reset();
     42    }
     43
     44    protected OnlineWeightedDirectionalSymmetryCalculator(OnlineWeightedDirectionalSymmetryCalculator other, Cloner cloner = null) {
     45      n = other.n;
     46      correctSum = other.correctSum;
     47      incorrectSum = other.incorrectSum;
     48      errorState = other.errorState;
    4249    }
    4350
    … …  
    118125      }
    119126    }
     127
     128    // IDeepCloneable members
     129    public object Clone() {
     130      return new OnlineWeightedDirectionalSymmetryCalculator(this);
     131    }
     132
     133    public IDeepCloneable Clone(Cloner cloner) {
     134      var clone = cloner.GetClone(this);
     135      if (clone == null) {
     136        clone = new OnlineWeightedDirectionalSymmetryCalculator(this);
     137        cloner.RegisterClonedObject(this, clone);
     138      }
     139      return clone;
     140    }
    120141  }
    121142}
Note: See TracChangeset for help on using the changeset viewer.