Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
11/06/10 01:56:04 (14 years ago)
Author:
swagner
Message:

Merged cloning refactoring branch back into trunk (#922)

Location:
trunk/sources
Files:
47 edited

Legend:

Unmodified
Added
Removed

  • trunk/sources

  • trunk/sources/HeuristicLab.Problems.DataAnalysis

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/DataAnalysisProblem.cs

    r4419 r4722  
    5555    [StorableConstructor]
    5656    protected DataAnalysisProblem(bool deserializing) : base(deserializing) { }
     57    protected DataAnalysisProblem(DataAnalysisProblem original, Cloner cloner)
     58      : base(original, cloner) {
     59      RegisterParameterEvents();
     60      RegisterParameterValueEvents();
     61    }
     62
    5763    public DataAnalysisProblem()
    5864      : base() {
    … …  
    6369
    6470    [StorableHook(HookType.AfterDeserialization)]
    65     private void AfterDeserializationHook() {
     71    private void AfterDeserialization() {
    6672      RegisterParameterEvents();
    6773      RegisterParameterValueEvents();
    … …  
    9197
    9298    public override IDeepCloneable Clone(Cloner cloner) {
    93       DataAnalysisProblem clone = (DataAnalysisProblem)base.Clone(cloner);
    94       clone.RegisterParameterEvents();
    95       clone.RegisterParameterValueEvents();
    96       return clone;
     99      return new DataAnalysisProblem(this, cloner);
    97100    }
    98101

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/DataAnalysisProblemData.cs

    r4543 r4722  
    191191    #endregion
    192192
    193 
     193    [StorableConstructor]
     194    protected DataAnalysisProblemData(bool deserializing) : base(deserializing) { }
     195    protected DataAnalysisProblemData(DataAnalysisProblemData original, Cloner cloner)
     196      : base(original, cloner) {
     197      RegisterParameterEventHandlers();
     198      RegisterParameterValueEventHandlers();
     199    }
    194200    public DataAnalysisProblemData()
    195201      : base() {
    … …  
    233239    }
    234240
    235     [StorableConstructor]
    236     protected DataAnalysisProblemData(bool deserializing) : base(deserializing) { }
     241    public override IDeepCloneable Clone(Cloner cloner) {
     242      return new DataAnalysisProblemData(this, cloner);
     243    }
    237244
    238245    [StorableHook(HookType.AfterDeserialization)]
    239     private void AfterDeserializationHook() {
     246    private void AfterDeserialization() {
    240247      if (!Parameters.ContainsKey("ValidationPercentage"))
    241248        Parameters.Add(new ValueParameter<PercentValue>("ValidationPercentage", "The relative amount of the training samples that should be used as validation set.", new PercentValue(0.5)));
    … …  
    405412      OnProblemDataChanged(EventArgs.Empty);
    406413    }
    407 
    408     public override IDeepCloneable Clone(Cloner cloner) {
    409       DataAnalysisProblemData clone = (DataAnalysisProblemData)base.Clone(cloner);
    410       clone.RegisterParameterEventHandlers();
    411       clone.RegisterParameterValueEventHandlers();
    412       return clone;
    413     }
    414414  }
    415415}

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/DataAnalysisSolution.cs

    r4451 r4722  
    3737    public string Filename { get; set; }
    3838    #endregion
    39    
     39
     40    [StorableConstructor]
     41    protected DataAnalysisSolution(bool deserializing) : base(deserializing) { }
     42    protected DataAnalysisSolution(DataAnalysisSolution original, Cloner cloner)
     43      : base(original, cloner) {
     44      problemData = (DataAnalysisProblemData)cloner.Clone(original.problemData);
     45      model = (IDataAnalysisModel)cloner.Clone(original.model);
     46      lowerEstimationLimit = original.lowerEstimationLimit;
     47      upperEstimationLimit = original.upperEstimationLimit;
     48      AfterDeserialization();
     49    }
    4050    protected DataAnalysisSolution()
    4151      : base() { }
    … …  
    4656      this.lowerEstimationLimit = lowerEstimationLimit;
    4757      this.upperEstimationLimit = upperEstimationLimit;
    48       Initialize();
     58      AfterDeserialization();
    4959    }
    5060
    51     [StorableConstructor]
    52     private DataAnalysisSolution(bool deserializing) : base(deserializing) { }
    5361    [StorableHook(HookType.AfterDeserialization)]
    54     private void Initialize() {
     62    private void AfterDeserialization() {
    5563      if (problemData != null)
    5664        RegisterProblemDataEvents();
    … …  
    140148    public event EventHandler ModelChanged;
    141149    protected virtual void OnModelChanged() {
    142       EventHandler handler = ModelChanged;
    143       if (handler != null)
    144         handler(this, EventArgs.Empty);
     150      EventHandler listeners = ModelChanged;
     151      if (listeners != null)
     152        listeners(this, EventArgs.Empty);
    145153    }
    146154
    … …  
    153161    #endregion
    154162
    155     public override IDeepCloneable Clone(Cloner cloner) {
    156       DataAnalysisSolution clone = (DataAnalysisSolution)base.Clone(cloner);
    157       clone.problemData = (DataAnalysisProblemData)cloner.Clone(problemData);
    158       clone.model = (IDataAnalysisModel)cloner.Clone(model);
    159       clone.lowerEstimationLimit = lowerEstimationLimit;
    160       clone.upperEstimationLimit = upperEstimationLimit;
    161       clone.Initialize();
    162 
    163       return clone;
    164     }
    165163  }
    166164}

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/DataFormatException.cs

    r4239 r4722  
    2121
    2222using System;
     23using System.Runtime.Serialization;
    2324
    2425namespace HeuristicLab.Problems.DataAnalysis {
     26  [Serializable]
    2527  public class DataFormatException : Exception {
    2628    private int line;
    … …  
    3739      this.line = line;
    3840    }
     41
     42    public DataFormatException(SerializationInfo info, StreamingContext context) : base(info, context) { }
    3943  }
    4044}

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Dataset.cs

    r4239 r4722  
    3232  [StorableClass]
    3333  public sealed class Dataset : NamedItem, IStringConvertibleMatrix {
    34     // empty constructor for cloning
    35     private Dataset()
    36       : base() {
    37     }
    38 
    3934    [StorableConstructor]
    40     private Dataset(bool deserializing)
    41       : base(deserializing) {
    42     }
    43 
     35    private Dataset(bool deserializing) : base(deserializing) { }
     36    private Dataset(Dataset original, Cloner cloner)
     37      : base(original, cloner) {
     38      variableNames = original.variableNames;
     39      data = original.data;
     40    }
    4441    public Dataset(IEnumerable<string> variableNames, double[,] data)
    4542      : base() {
    … …  
    122119    }
    123120
    124 
    125 
    126121    public string GetVariableName(int variableIndex) {
    127122      return variableNames[variableIndex];
    … …  
    140135
    141136    public override IDeepCloneable Clone(Cloner cloner) {
    142       Dataset clone = (Dataset)base.Clone(cloner);
    143       clone.variableNames = variableNames;
    144       clone.data = data;
    145       return clone;
     137      return new Dataset(this, cloner);
    146138    }
    147139
    … …  
    197189    public event EventHandler ColumnNamesChanged;
    198190    private void OnColumnNamesChanged() {
    199       EventHandler handler = ColumnNamesChanged;
    200       if (handler != null)
    201         handler(this, EventArgs.Empty);
     191      EventHandler listeners = ColumnNamesChanged;
     192      if (listeners != null)
     193        listeners(this, EventArgs.Empty);
    202194    }
    203195    public event EventHandler RowNamesChanged;
    204196    private void OnRowNamesChanged() {
    205       EventHandler handler = RowNamesChanged;
    206       if (handler != null)
    207         handler(this, EventArgs.Empty);
     197      EventHandler listeners = RowNamesChanged;
     198      if (listeners != null)
     199        listeners(this, EventArgs.Empty);
    208200    }
    209201    public event EventHandler SortableViewChanged;
    210202    private void OnSortableViewChanged() {
    211       EventHandler handler = SortableViewChanged;
    212       if (handler != null)
    213         handler(this, EventArgs.Empty);
     203      EventHandler listeners = SortableViewChanged;
     204      if (listeners != null)
     205        listeners(this, EventArgs.Empty);
    214206    }
    215207    public event EventHandler<EventArgs<int, int>> ItemChanged;
    216208    private void OnItemChanged(int rowIndex, int columnIndex) {
    217       if (ItemChanged != null)
    218         ItemChanged(this, new EventArgs<int, int>(rowIndex, columnIndex));
     209      var listeners = ItemChanged;
     210      if (listeners != null)
     211        listeners(this, new EventArgs<int, int>(rowIndex, columnIndex));
    219212      OnToStringChanged();
    220213    }

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Evaluators/SimpleEvaluator.cs

    r4068 r4722  
    2020#endregion
    2121
     22using HeuristicLab.Common;
    2223using HeuristicLab.Core;
    2324using HeuristicLab.Data;
    2425using HeuristicLab.Operators;
    2526using HeuristicLab.Parameters;
     27using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    2628
    2729namespace HeuristicLab.Problems.DataAnalysis.Evaluators {
    … …  
    3234    public ILookupParameter<DoubleMatrix> ValuesParameter {
    3335      get { return (ILookupParameter<DoubleMatrix>)Parameters["Values"]; }
     36    }
     37    [StorableConstructor]
     38    protected SimpleEvaluator(bool deserializing) : base(deserializing) { }
     39    protected SimpleEvaluator(SimpleEvaluator original, Cloner cloner)
     40      : base(original, cloner) {
    3441    }
    3542    public SimpleEvaluator()

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Evaluators/SimpleMSEEvaluator.cs

    r4239 r4722  
    2323using System.Collections.Generic;
    2424using System.Linq;
     25using HeuristicLab.Common;
    2526using HeuristicLab.Core;
    2627using HeuristicLab.Data;
    2728using HeuristicLab.Parameters;
     29using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    2830
    2931namespace HeuristicLab.Problems.DataAnalysis.Evaluators {
    … …  
    3436    }
    3537
     38    [StorableConstructor]
     39    protected SimpleMSEEvaluator(bool deserializing) : base(deserializing) { }
     40    protected SimpleMSEEvaluator(SimpleMSEEvaluator original, Cloner cloner)
     41      : base(original, cloner) {
     42    }
     43    public override IDeepCloneable Clone(Cloner cloner) {
     44      return new SimpleMSEEvaluator(this, cloner);
     45    }
    3646    public SimpleMSEEvaluator() {
    3747      Parameters.Add(new LookupParameter<DoubleValue>("MeanSquaredError", "The mean squared error of estimated values."));

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Evaluators/SimpleMeanAbsolutePercentageErrorEvaluator.cs

    r4068 r4722  
    2323using System.Collections.Generic;
    2424using System.Linq;
     25using HeuristicLab.Common;
    2526using HeuristicLab.Core;
    2627using HeuristicLab.Data;
    2728using HeuristicLab.Parameters;
     29using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    2830
    2931namespace HeuristicLab.Problems.DataAnalysis.Evaluators {
    … …  
    3335    }
    3436
     37    [StorableConstructor]
     38    protected SimpleMeanAbsolutePercentageErrorEvaluator(bool deserializing) : base(deserializing) { }
     39    protected SimpleMeanAbsolutePercentageErrorEvaluator(SimpleMeanAbsolutePercentageErrorEvaluator original, Cloner cloner)
     40      : base(original, cloner) {
     41    }
    3542    public SimpleMeanAbsolutePercentageErrorEvaluator() {
    3643      Parameters.Add(new LookupParameter<PercentValue>("AverageRelativeError", "The average relative error of estimated values."));
    … …  
    4350                      select values[i, ESTIMATION_INDEX];
    4451      AverageRelativeErrorParameter.ActualValue = new PercentValue(Calculate(original, estimated));
     52    }
     53
     54    public override IDeepCloneable Clone(Cloner cloner) {
     55      return new SimpleMeanAbsolutePercentageErrorEvaluator(this, cloner);
    4556    }
    4657

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Evaluators/SimpleMeanAbsolutePercentageOfRangeErrorEvaluator.cs

    r4068 r4722  
    2727using HeuristicLab.Data;
    2828using HeuristicLab.Parameters;
     29using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    2930
    3031namespace HeuristicLab.Problems.DataAnalysis.Evaluators {
    … …  
    3536    }
    3637
     38    [StorableConstructor]
     39    protected SimpleMeanAbsolutePercentageOfRangeErrorEvaluator(bool deserializing) : base(deserializing) { }
     40    protected SimpleMeanAbsolutePercentageOfRangeErrorEvaluator(SimpleMeanAbsolutePercentageOfRangeErrorEvaluator original, Cloner cloner)
     41      : base(original, cloner) {
     42    }
    3743    public SimpleMeanAbsolutePercentageOfRangeErrorEvaluator() {
    3844      Parameters.Add(new LookupParameter<PercentValue>("AveragePercentageOfRangeError", "The average relative (percentage of range) error of estimated values."));
    … …  
    4551                      select values[i, ESTIMATION_INDEX];
    4652      AveragePercentageOfRangeErrorParameter.ActualValue = new PercentValue(Calculate(original, estimated));
     53    }
     54
     55    public override IDeepCloneable Clone(Cloner cloner) {
     56      return new SimpleMeanAbsolutePercentageOfRangeErrorEvaluator(this, cloner);
    4757    }
    4858

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Evaluators/SimpleNMSEEvaluator.cs

    r4068 r4722  
    2323using System.Collections.Generic;
    2424using System.Linq;
     25using HeuristicLab.Common;
    2526using HeuristicLab.Core;
    2627using HeuristicLab.Data;
    2728using HeuristicLab.Parameters;
     29using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    2830
    2931namespace HeuristicLab.Problems.DataAnalysis.Evaluators {
    … …  
    3436    }
    3537
     38    [StorableConstructor]
     39    protected SimpleNMSEEvaluator(bool deserializing) : base(deserializing) { }
     40    protected SimpleNMSEEvaluator(SimpleNMSEEvaluator original, Cloner cloner)
     41      : base(original, cloner) {
     42    }
     43    public override IDeepCloneable Clone(Cloner cloner) {
     44      return new SimpleNMSEEvaluator(this, cloner);
     45    }
    3646    public SimpleNMSEEvaluator() {
    3747      Parameters.Add(new LookupParameter<DoubleValue>("NormalizedMeanSquaredError", "The normalized mean squared error (divided by variance) of estimated values."));

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Evaluators/SimpleRSquaredEvaluator.cs

    r4068 r4722  
    2323using System.Collections.Generic;
    2424using System.Linq;
     25using HeuristicLab.Common;
    2526using HeuristicLab.Core;
    2627using HeuristicLab.Data;
    2728using HeuristicLab.Parameters;
     29using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    2830
    2931namespace HeuristicLab.Problems.DataAnalysis.Evaluators {
    … …  
    3234      get { return (ILookupParameter<DoubleValue>)Parameters["RSquared"]; }
    3335    }
    34 
     36    [StorableConstructor]
     37    protected SimpleRSquaredEvaluator(bool deserializing) : base(deserializing) { }
     38    protected SimpleRSquaredEvaluator(SimpleRSquaredEvaluator original, Cloner cloner)
     39      : base(original, cloner) {
     40    }
     41    public override IDeepCloneable Clone(Cloner cloner) {
     42      return new SimpleRSquaredEvaluator(this, cloner);
     43    }
    3544    public SimpleRSquaredEvaluator() {
    3645      Parameters.Add(new LookupParameter<DoubleValue>("RSquared", "The squared Pearson's Product Moment Correlation (R²) of estimated values and original values."));

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Evaluators/SimpleVarianceAccountedForEvaluator.cs

    r4068 r4722  
    2727using HeuristicLab.Data;
    2828using HeuristicLab.Parameters;
     29using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    2930
    3031namespace HeuristicLab.Problems.DataAnalysis.Evaluators {
    … …  
    4041    }
    4142
     43    [StorableConstructor]
     44    protected SimpleVarianceAccountedForEvaluator(bool deserializing) : base(deserializing) { }
     45    protected SimpleVarianceAccountedForEvaluator(SimpleVarianceAccountedForEvaluator original, Cloner cloner)
     46      : base(original, cloner) {
     47    }
     48    public override IDeepCloneable Clone(Cloner cloner) {
     49      return new SimpleVarianceAccountedForEvaluator(this, cloner);
     50    }
    4251    public SimpleVarianceAccountedForEvaluator() {
    4352      Parameters.Add(new LookupParameter<DoubleValue>("VarianceAccountedFor", "The variance of the original values accounted for by the estimated values (VAF(y,y') = 1 - var(y-y') / var(y) )."));

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/SupportVectorMachine/SupportVectorMachineCrossValidationEvaluator.cs

    r4543 r4722  
    2121
    2222using System;
     23using System.Collections.Generic;
    2324using System.Linq;
     25using HeuristicLab.Common;
    2426using HeuristicLab.Core;
    2527using HeuristicLab.Data;
    … …  
    2931using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    3032using SVM;
    31 using System.Collections.Generic;
    3233
    3334namespace HeuristicLab.Problems.DataAnalysis.SupportVectorMachine {
    … …  
    126127    #endregion
    127128
     129    [StorableConstructor]
     130    protected SupportVectorMachineCrossValidationEvaluator(bool deserializing) : base(deserializing) { }
     131
     132    protected SupportVectorMachineCrossValidationEvaluator(SupportVectorMachineCrossValidationEvaluator original,
     133      Cloner cloner)
     134      : base(original, cloner) { }
    128135    public SupportVectorMachineCrossValidationEvaluator()
    129136      : base() {
    … …  
    143150    }
    144151
     152    public override IDeepCloneable Clone(Cloner cloner) {
     153      return new SupportVectorMachineCrossValidationEvaluator(this, cloner);
     154    }
     155
    145156    public override IOperation Apply() {
    146157      double reductionRatio = 1.0; // TODO: make parameter
    147158      if (ActualSamplesParameter.ActualValue != null)
    148159        reductionRatio = ActualSamplesParameter.ActualValue.Value;
    149       IEnumerable<int> rows = 
     160      IEnumerable<int> rows =
    150161        Enumerable.Range(SamplesStart.Value, SamplesEnd.Value - SamplesStart.Value)
    151162        .Where(i => i < DataAnalysisProblemData.TestSamplesStart.Value || DataAnalysisProblemData.TestSamplesEnd.Value <= i);
    … …  
    153164      // create a new DataAnalysisProblemData instance
    154165      DataAnalysisProblemData reducedProblemData = (DataAnalysisProblemData)DataAnalysisProblemData.Clone();
    155       reducedProblemData.Dataset = 
     166      reducedProblemData.Dataset =
    156167        CreateReducedDataset(RandomParameter.ActualValue, reducedProblemData.Dataset, rows, reductionRatio);
    157168      reducedProblemData.TrainingSamplesStart.Value = 0;
    … …  
    170181
    171182    private Dataset CreateReducedDataset(IRandom random, Dataset dataset, IEnumerable<int> rowIndices, double reductionRatio) {
    172      
     183
    173184      // must not make a fink:
    174185      // => select n rows randomly from start..end
    … …  
    191202      // take the first n indexes (selected n rowIndexes from start..end)
    192203      // now order by index
    193       int[] orderedRandomIndexes = 
     204      int[] orderedRandomIndexes =
    194205        rowIndexArr.Take(n)
    195206        .OrderBy(x => x)

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/SupportVectorMachine/SupportVectorMachineModel.cs

    r4543 r4722  
    3636  [StorableClass]
    3737  [Item("SupportVectorMachineModel", "Represents a support vector machine model.")]
    38   public class SupportVectorMachineModel : NamedItem, IDataAnalysisModel {
    39     public SupportVectorMachineModel()
    40       : base() {
     38  public sealed class SupportVectorMachineModel : NamedItem, IDataAnalysisModel {
     39    [StorableConstructor]
     40    private SupportVectorMachineModel(bool deserializing) : base(deserializing) { }
     41    private SupportVectorMachineModel(SupportVectorMachineModel original, Cloner cloner)
     42      : base(original, cloner) {
     43      // only using a shallow copy here! (gkronber)
     44      this.model = original.model;
     45      this.rangeTransform = original.rangeTransform;
    4146    }
     47    public SupportVectorMachineModel() : base() { }
    4248
    4349    private SVM.Model model;
    … …  
    131137
    132138    public override IDeepCloneable Clone(Cloner cloner) {
    133       SupportVectorMachineModel clone = (SupportVectorMachineModel)base.Clone(cloner);
    134       // beware we are only using a shallow copy here! (gkronber)
    135       clone.model = model;
    136       clone.rangeTransform = rangeTransform;
    137       return clone;
     139      return new SupportVectorMachineModel(this, cloner);
    138140    }
    139141

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/SupportVectorMachine/SupportVectorMachineModelCreator.cs

    r4543 r4722  
    2121
    2222using System;
     23using System.Collections.Generic;
     24using System.Linq;
     25using HeuristicLab.Common;
    2326using HeuristicLab.Core;
    2427using HeuristicLab.Data;
    … …  
    2730using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    2831using SVM;
    29 using System.Collections.Generic;
    30 using System.Linq;
    3132
    3233namespace HeuristicLab.Problems.DataAnalysis.SupportVectorMachine {
    … …  
    3637  [StorableClass]
    3738  [Item("SupportVectorMachineModelCreator", "Represents an operator that creates a support vector machine model.")]
    38   public class SupportVectorMachineModelCreator : SingleSuccessorOperator {
     39  public sealed class SupportVectorMachineModelCreator : SingleSuccessorOperator {
    3940    private const string DataAnalysisProblemDataParameterName = "DataAnalysisProblemData";
    4041    private const string SvmTypeParameterName = "SvmType";
    … …  
    110111    #endregion
    111112
     113    [StorableConstructor]
     114    private SupportVectorMachineModelCreator(bool deserializing) : base(deserializing) { }
     115    private SupportVectorMachineModelCreator(SupportVectorMachineModelCreator original, Cloner cloner) : base(original, cloner) { }
     116    public override IDeepCloneable Clone(Cloner cloner) {
     117      return new SupportVectorMachineModelCreator(this, cloner);
     118    }
    112119    public SupportVectorMachineModelCreator()
    113120      : base() {
    … …  
    129136      int start = SamplesStart.Value;
    130137      int end = SamplesEnd.Value;
    131       IEnumerable<int> rows = 
    132         Enumerable.Range(start, end-start)
     138      IEnumerable<int> rows =
     139        Enumerable.Range(start, end - start)
    133140        .Where(i => i < DataAnalysisProblemData.TestSamplesStart.Value || DataAnalysisProblemData.TestSamplesEnd.Value <= i);
    134141

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/SupportVectorMachine/SupportVectorMachineModelEvaluator.cs

    r4543 r4722  
    2020#endregion
    2121
     22using System.Collections.Generic;
     23using System.Linq;
     24using HeuristicLab.Common;
    2225using HeuristicLab.Core;
    2326using HeuristicLab.Data;
    … …  
    2629using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    2730using SVM;
    28 using System.Collections.Generic;
    29 using System.Linq;
    3031
    3132namespace HeuristicLab.Problems.DataAnalysis.SupportVectorMachine {
    … …  
    7071    }
    7172    #endregion
     73
     74    [StorableConstructor]
     75    protected SupportVectorMachineModelEvaluator(bool deserializing) : base(deserializing) { }
     76    protected SupportVectorMachineModelEvaluator(SupportVectorMachineModelEvaluator original, Cloner cloner) : base(original, cloner) { }
     77    public override IDeepCloneable Clone(Cloner cloner) {
     78      return new SupportVectorMachineModelEvaluator(this, cloner);
     79    }
    7280    public SupportVectorMachineModelEvaluator()
    7381      : base() {

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/ArithmeticExpressionGrammar.cs

    r4249 r4722  
    2121
    2222using System.Collections.Generic;
     23using HeuristicLab.Common;
    2324using HeuristicLab.Core;
    2425using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
    … …  
    3031  [Item("ArithmeticExpressionGrammar", "Represents a grammar for functional expressions using only arithmetic operations.")]
    3132  public class ArithmeticExpressionGrammar : DefaultSymbolicExpressionGrammar {
     33
     34    [StorableConstructor]
     35    protected ArithmeticExpressionGrammar(bool deserializing) : base(deserializing) { }
     36    protected ArithmeticExpressionGrammar(ArithmeticExpressionGrammar original, Cloner cloner) : base(original, cloner) { }
    3237    public ArithmeticExpressionGrammar()
    3338      : base() {
    3439      Initialize();
    3540    }
    36 
    37     [StorableConstructor]
    38     protected ArithmeticExpressionGrammar(bool deserializing) : base(deserializing) { }
     41    public override IDeepCloneable Clone(Cloner cloner) {
     42      return new ArithmeticExpressionGrammar(this, cloner);
     43    }
    3944
    4045    private void Initialize() {

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/FullFunctionalExpressionGrammar.cs

    r4249 r4722  
    2121
    2222using System.Collections.Generic;
     23using HeuristicLab.Common;
    2324using HeuristicLab.Core;
    2425using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
    … …  
    3031  [Item("FullFunctionalExpressionGrammar", "Represents a grammar for functional expressions using all available functions.")]
    3132  public class FullFunctionalExpressionGrammar : DefaultSymbolicExpressionGrammar {
     33    [StorableConstructor]
     34    protected FullFunctionalExpressionGrammar(bool deserializing) : base(deserializing) { }
     35    protected FullFunctionalExpressionGrammar(FullFunctionalExpressionGrammar original, Cloner cloner) : base(original, cloner) { }
    3236    public FullFunctionalExpressionGrammar()
    3337      : base() {
    3438      Initialize();
    3539    }
    36     [StorableConstructor]
    37     protected FullFunctionalExpressionGrammar(bool deserializing) : base(deserializing) { }
     40
     41    public override IDeepCloneable Clone(Cloner cloner) {
     42      return new FullFunctionalExpressionGrammar(this, cloner);
     43    }
    3844
    3945    private void Initialize() {

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/SimpleArithmeticExpressionInterpreter.cs

    r4068 r4722  
    2222using System;
    2323using System.Collections.Generic;
     24using HeuristicLab.Common;
    2425using HeuristicLab.Core;
    2526using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
    … …  
    3334  [Item("SimpleArithmeticExpressionInterpreter", "Interpreter for arithmetic symbolic expression trees including function calls.")]
    3435  // not thread safe!
    35   public class SimpleArithmeticExpressionInterpreter : NamedItem, ISymbolicExpressionTreeInterpreter {
     36  public sealed class SimpleArithmeticExpressionInterpreter : NamedItem, ISymbolicExpressionTreeInterpreter {
    3637    private class OpCodes {
    3738      public const byte Add = 1;
    … …  
    106107    }
    107108
     109    [StorableConstructor]
     110    private SimpleArithmeticExpressionInterpreter(bool deserializing) : base(deserializing) { }
     111    private SimpleArithmeticExpressionInterpreter(SimpleArithmeticExpressionInterpreter original, Cloner cloner) : base(original, cloner) { }
     112
     113    public override IDeepCloneable Clone(Cloner cloner) {
     114      return new SimpleArithmeticExpressionInterpreter(this, cloner);
     115    }
     116
    108117    public SimpleArithmeticExpressionInterpreter()
    109118      : base() {
    … …  
    286295
    287296    // skips a whole branch
    288     protected void SkipBakedCode() {
     297    private void SkipBakedCode() {
    289298      int i = 1;
    290299      while (i > 0) {

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Addition.cs

    r4068 r4722  
    2020#endregion
    2121
     22using HeuristicLab.Common;
    2223using HeuristicLab.Core;
    2324using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Symbols;
    … …  
    2728  [Item("Addition", "Symbol that represents the + operator.")]
    2829  public sealed class Addition : Symbol {
     30    [StorableConstructor]
     31    private Addition(bool deserializing) : base(deserializing) { }
     32    private Addition(Addition original, Cloner cloner) : base(original, cloner) { }
     33    public override IDeepCloneable Clone(Cloner cloner) {
     34      return new Addition(this, cloner);
     35    }
    2936    public Addition() : base("Addition", "Symbol that represents the + operator.") { }
    3037  }

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/And.cs

    r4068 r4722  
    2020#endregion
    2121
     22using HeuristicLab.Common;
    2223using HeuristicLab.Core;
    2324using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Symbols;
    … …  
    2728  [Item("And", "Symbol that represents the boolean AND operator.")]
    2829  public sealed class And : Symbol {
     30    [StorableConstructor]
     31    private And(bool deserializing) : base(deserializing) { }
     32    private And(And original, Cloner cloner) : base(original, cloner) { }
     33    public override IDeepCloneable Clone(Cloner cloner) {
     34      return new And(this, cloner);
     35    }
    2936    public And() : base("And", "Symbol that represents the boolean AND operator.") { }
    3037  }

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Average.cs

    r4068 r4722  
    2020#endregion
    2121
     22using HeuristicLab.Common;
    2223using HeuristicLab.Core;
    2324using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Symbols;
    … …  
    2728  [Item("Average", "Symbol that represents the average (arithmetic mean) function.")]
    2829  public sealed class Average : Symbol {
     30    [StorableConstructor]
     31    private Average(bool deserializing) : base(deserializing) { }
     32    private Average(Average original, Cloner cloner) : base(original, cloner) { }
     33    public override IDeepCloneable Clone(Cloner cloner) {
     34      return new Average(this, cloner);
     35    }
    2936    public Average() : base("Average", "Symbol that represents the average (arithmetic mean) function.") { }
    3037  }

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Constant.cs

    r4068 r4722  
    7777    }
    7878    #endregion
     79    [StorableConstructor]
     80    private Constant(bool deserializing) : base(deserializing) { }
     81    private Constant(Constant original, Cloner cloner)
     82      : base(original, cloner) {
     83      minValue = original.minValue;
     84      maxValue = original.maxValue;
     85      manipulatorNu = original.manipulatorNu;
     86      manipulatorSigma = original.manipulatorSigma;
     87    }
    7988    public Constant()
    8089      : base("Constant", "Represents a constant value.") {
    … …  
    9099
    91100    public override IDeepCloneable Clone(Cloner cloner) {
    92       Constant clone = (Constant)base.Clone(cloner);
    93       clone.minValue = minValue;
    94       clone.maxValue = maxValue;
    95       clone.manipulatorNu = manipulatorNu;
    96       clone.manipulatorSigma = manipulatorSigma;
    97       return clone;
     101      return new Constant(this, cloner);
    98102    }
    99103  }

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/ConstantTreeNode.cs

    r4068 r4722  
    2020#endregion
    2121
     22using HeuristicLab.Common;
    2223using HeuristicLab.Core;
    2324using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
    … …  
    3839    }
    3940
    40     private ConstantTreeNode() : base() { }
     41    [StorableConstructor]
     42    private ConstantTreeNode(bool deserializing) : base(deserializing) { }
    4143
    42     // copy constructor
    43     private ConstantTreeNode(ConstantTreeNode original)
    44       : base(original) {
     44    private ConstantTreeNode(ConstantTreeNode original, Cloner cloner)
     45      : base(original, cloner) {
    4546      constantValue = original.constantValue;
    4647    }
    4748
     49    private ConstantTreeNode() : base() { }
    4850    public ConstantTreeNode(Constant constantSymbol) : base(constantSymbol) { }
    4951
    … …  
    6567    }
    6668
    67     public override object Clone() {
    68       return new ConstantTreeNode(this);
     69    public override IDeepCloneable Clone(Cloner cloner) {
     70      return new ConstantTreeNode(this, cloner);
    6971    }
    7072

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Cosine.cs

    r4068 r4722  
    2020#endregion
    2121
     22using HeuristicLab.Common;
    2223using HeuristicLab.Core;
    2324using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Symbols;
    … …  
    2728  [Item("Cosine", "Symbol that represents the cosine function.")]
    2829  public sealed class Cosine : Symbol {
     30    [StorableConstructor]
     31    private Cosine(bool deserializing) : base(deserializing) { }
     32    private Cosine(Cosine original, Cloner cloner) : base(original, cloner) { }
     33    public override IDeepCloneable Clone(Cloner cloner) {
     34      return new Cosine(this, cloner);
     35    }
    2936    public Cosine() : base("Cosine", "Symbol that represents the cosine function.") { }
    3037  }

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Division.cs

    r4068 r4722  
    2020#endregion
    2121
     22using HeuristicLab.Common;
    2223using HeuristicLab.Core;
    2324using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Symbols;
    … …  
    2728  [Item("Division", "Symbol that represents the / operator.")]
    2829  public sealed class Division : Symbol {
     30    [StorableConstructor]
     31    private Division(bool deserializing) : base(deserializing) { }
     32    private Division(Division original, Cloner cloner) : base(original, cloner) { }
     33    public override IDeepCloneable Clone(Cloner cloner) {
     34      return new Division(this, cloner);
     35    }
    2936    public Division() : base("Division", "Symbol that represents the / operator.") { }
    3037  }

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Exponential.cs

    r4068 r4722  
    2020#endregion
    2121
     22using HeuristicLab.Common;
    2223using HeuristicLab.Core;
    2324using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Symbols;
    … …  
    2728  [Item("Exponential", "Symbol that represents the exponential function.")]
    2829  public sealed class Exponential : Symbol {
     30    [StorableConstructor]
     31    private Exponential(bool deserializing) : base(deserializing) { }
     32    private Exponential(Exponential original, Cloner cloner) : base(original, cloner) { }
     33    public override IDeepCloneable Clone(Cloner cloner) {
     34      return new Exponential(this, cloner);
     35    }
    2936    public Exponential() : base("Exponential", "Symbol that represents the exponential function.") { }
    3037  }

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/GreaterThan.cs

    r4068 r4722  
    2020#endregion
    2121
     22using HeuristicLab.Common;
    2223using HeuristicLab.Core;
    2324using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Symbols;
    … …  
    2728  [Item("GreaterThan", "Symbol that represents a greater than relation.")]
    2829  public sealed class GreaterThan : Symbol {
     30    [StorableConstructor]
     31    private GreaterThan(bool deserializing) : base(deserializing) { }
     32    private GreaterThan(GreaterThan original, Cloner cloner) : base(original, cloner) { }
     33    public override IDeepCloneable Clone(Cloner cloner) {
     34      return new GreaterThan(this, cloner);
     35    }
    2936    public GreaterThan() : base("GreaterThan", "Symbol that represents a greater than relation.") { }
    3037  }

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/IfThenElse.cs

    r4068 r4722  
    2020#endregion
    2121
     22using HeuristicLab.Common;
    2223using HeuristicLab.Core;
    2324using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Symbols;
    … …  
    2728  [Item("IfThenElse", "Symbol that represents a conditional operator.")]
    2829  public sealed class IfThenElse : Symbol {
     30    [StorableConstructor]
     31    private IfThenElse(bool deserializing) : base(deserializing) { }
     32    private IfThenElse(IfThenElse original, Cloner cloner) : base(original, cloner) { }
     33    public override IDeepCloneable Clone(Cloner cloner) {
     34      return new IfThenElse(this, cloner);
     35    }
    2936    public IfThenElse() : base("IfThenElse", "Symbol that represents a conditional operator.") { }
    3037  }

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/LaggedVariable.cs

    r4068 r4722  
    4040      set { maxLag = value; }
    4141    }
     42    [StorableConstructor]
     43    private LaggedVariable(bool deserializing) : base(deserializing) { }
     44    private LaggedVariable(LaggedVariable original, Cloner cloner)
     45      : base(original, cloner) {
     46      minLag = original.minLag;
     47      maxLag = original.maxLag;
     48    }
    4249    public LaggedVariable()
    4350      : base("LaggedVariable", "Represents a variable value with a time offset.") {
    … …  
    5057
    5158    public override IDeepCloneable Clone(Cloner cloner) {
    52       LaggedVariable clone = (LaggedVariable)base.Clone(cloner);
    53       clone.minLag = minLag;
    54       clone.maxLag = maxLag;
    55       return clone;
     59      return new LaggedVariable(this, cloner);
    5660    }
    5761  }

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/LaggedVariableTreeNode.cs

    r4068 r4722  
    2121
    2222using System;
     23using HeuristicLab.Common;
    2324using HeuristicLab.Core;
    2425using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    … …  
    3637    }
    3738
    38     private LaggedVariableTreeNode() { }
    39 
    40     // copy constructor
    41     private LaggedVariableTreeNode(LaggedVariableTreeNode original)
    42       : base(original) {
     39    [StorableConstructor]
     40    private LaggedVariableTreeNode(bool deserializing) : base(deserializing) { }
     41    private LaggedVariableTreeNode(LaggedVariableTreeNode original, Cloner cloner)
     42      : base(original, cloner) {
    4343      lag = original.lag;
    4444    }
     45    private LaggedVariableTreeNode() { }
    4546
    4647    public LaggedVariableTreeNode(LaggedVariable variableSymbol) : base(variableSymbol) { }
    … …  
    6263    }
    6364
    64 
    65     public override object Clone() {
    66       return new LaggedVariableTreeNode(this);
     65    public override IDeepCloneable Clone(Cloner cloner) {
     66      return new LaggedVariableTreeNode(this, cloner);
    6767    }
    6868

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/LessThan.cs

    r4068 r4722  
    2020#endregion
    2121
     22using HeuristicLab.Common;
    2223using HeuristicLab.Core;
    2324using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Symbols;
    … …  
    2728  [Item("LessThan", "Symbol that represents a less than relation.")]
    2829  public sealed class LessThan : Symbol {
     30    [StorableConstructor]
     31    private LessThan(bool deserializing) : base(deserializing) { }
     32    private LessThan(LessThan original, Cloner cloner) : base(original, cloner) { }
     33    public override IDeepCloneable Clone(Cloner cloner) {
     34      return new LessThan(this, cloner);
     35    }
    2936    public LessThan() : base("LessThan", "Symbol that represents a less than relation.") { }
    3037  }

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Logarithm.cs

    r4068 r4722  
    2020#endregion
    2121
     22using HeuristicLab.Common;
    2223using HeuristicLab.Core;
    2324using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Symbols;
    … …  
    2728  [Item("Logarithm", "Symbol that represents the logarithm function.")]
    2829  public sealed class Logarithm : Symbol {
     30    [StorableConstructor]
     31    private Logarithm(bool deserializing) : base(deserializing) { }
     32    private Logarithm(Logarithm original, Cloner cloner) : base(original, cloner) { }
     33    public override IDeepCloneable Clone(Cloner cloner) {
     34      return new Logarithm(this, cloner);
     35    }
    2936    public Logarithm() : base("Logarithm", "Symbol that represents the logarithm function.") { }
    3037  }

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Multiplication.cs

    r4068 r4722  
    2020#endregion
    2121
     22using HeuristicLab.Common;
    2223using HeuristicLab.Core;
    2324using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Symbols;
    … …  
    2728  [Item("Multiplication", "Symbol that represents the * operator.")]
    2829  public sealed class Multiplication : Symbol {
     30    [StorableConstructor]
     31    private Multiplication(bool deserializing) : base(deserializing) { }
     32    private Multiplication(Multiplication original, Cloner cloner) : base(original, cloner) { }
     33    public override IDeepCloneable Clone(Cloner cloner) {
     34      return new Multiplication(this, cloner);
     35    }
    2936    public Multiplication() : base("Multiplication", "Symbol that represents the * operator.") { }
    3037  }

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Not.cs

    r4068 r4722  
    2020#endregion
    2121
     22using HeuristicLab.Common;
    2223using HeuristicLab.Core;
    2324using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Symbols;
    … …  
    2728  [Item("Not", "Symbol that represents the boolean NOT operator.")]
    2829  public sealed class Not : Symbol {
     30    [StorableConstructor]
     31    private Not(bool deserializing) : base(deserializing) { }
     32    private Not(Not original, Cloner cloner) : base(original, cloner) { }
     33    public override IDeepCloneable Clone(Cloner cloner) {
     34      return new Not(this, cloner);
     35    }
    2936    public Not() : base("Not", "Symbol that represents the boolean NOT operator.") { }
    3037  }

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Or.cs

    r4068 r4722  
    2020#endregion
    2121
     22using HeuristicLab.Common;
    2223using HeuristicLab.Core;
    2324using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Symbols;
    … …  
    2728  [Item("Or", "Symbol that represents the boolean OR operator.")]
    2829  public sealed class Or : Symbol {
     30    [StorableConstructor]
     31    private Or(bool deserializing) : base(deserializing) { }
     32    private Or(Or original, Cloner cloner) : base(original, cloner) { }
     33    public override IDeepCloneable Clone(Cloner cloner) {
     34      return new Or(this, cloner);
     35    }
    2936    public Or() : base("Or", "Symbol that represents the boolean OR operator.") { }
    3037  }

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Sine.cs

    r4068 r4722  
    2020#endregion
    2121
     22using HeuristicLab.Common;
    2223using HeuristicLab.Core;
    2324using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Symbols;
    … …  
    2728  [Item("Sine", "Symbol that represents the sine function.")]
    2829  public sealed class Sine : Symbol {
     30    [StorableConstructor]
     31    private Sine(bool deserializing) : base(deserializing) { }
     32    private Sine(Sine original, Cloner cloner) : base(original, cloner) { }
     33    public override IDeepCloneable Clone(Cloner cloner) {
     34      return new Sine(this, cloner);
     35    }
    2936    public Sine() : base("Sine", "Symbol that represents the sine function.") { }
    3037  }

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Subtraction.cs

    r4068 r4722  
    2020#endregion
    2121
     22using HeuristicLab.Common;
    2223using HeuristicLab.Core;
    2324using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Symbols;
    … …  
    2728  [Item("Subtraction", "Symbol that represents the - operator.")]
    2829  public sealed class Subtraction : Symbol {
     30    [StorableConstructor]
     31    private Subtraction(bool deserializing) : base(deserializing) { }
     32    private Subtraction(Subtraction original, Cloner cloner) : base(original, cloner) { }
     33    public override IDeepCloneable Clone(Cloner cloner) {
     34      return new Subtraction(this, cloner);
     35    }
    2936    public Subtraction() : base("Subtraction", "Symbol that represents the - operator.") { }
    3037  }

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Tangent.cs

    r4068 r4722  
    2020#endregion
    2121
     22using HeuristicLab.Common;
    2223using HeuristicLab.Core;
    2324using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Symbols;
    … …  
    2728  [Item("Tangent", "Symbol that represents the tangent trigonometric function.")]
    2829  public sealed class Tangent : Symbol {
     30    [StorableConstructor]
     31    private Tangent(bool deserializing) : base(deserializing) { }
     32    private Tangent(Tangent original, Cloner cloner) : base(original, cloner) { }
     33    public override IDeepCloneable Clone(Cloner cloner) {
     34      return new Tangent(this, cloner);
     35    }
    2936    public Tangent() : base("Tangent", "Symbol that represents the tangent trigonometric function.") { }
    3037  }

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Variable.cs

    r4068 r4722  
    9090    }
    9191    #endregion
     92    [StorableConstructor]
     93    protected Variable(bool deserializing) : base(deserializing) {
     94      variableNames = new List<string>();
     95    }
     96    protected Variable(Variable original, Cloner cloner)
     97      : base(original, cloner) {
     98      weightNu = original.weightNu;
     99      weightSigma = original.weightSigma;
     100      variableNames = new List<string>(original.variableNames);
     101      weightManipulatorNu = original.weightManipulatorNu;
     102      weightManipulatorSigma = original.weightManipulatorSigma;
     103    }
    92104    public Variable() : this("Variable", "Represents a variable value.") { }
    93105    public Variable(string name, string description)
    … …  
    105117
    106118    public override IDeepCloneable Clone(Cloner cloner) {
    107       Variable clone = (Variable)base.Clone(cloner);
    108       clone.weightNu = weightNu;
    109       clone.weightSigma = weightSigma;
    110       clone.variableNames = new List<string>(variableNames);
    111       clone.weightManipulatorNu = weightManipulatorNu;
    112       clone.weightManipulatorSigma = weightManipulatorSigma;
    113       return clone;
     119      return new Variable(this, cloner);
    114120    }
    115121  }

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/VariableTreeNode.cs

    r4239 r4722  
    2020#endregion
    2121
     22using HeuristicLab.Common;
    2223using HeuristicLab.Core;
    23 using HeuristicLab.Common;
    2424using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
    2525using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    … …  
    4444    }
    4545
    46 
    47     protected VariableTreeNode() { }
    48 
    49     // copy constructor
    50     protected VariableTreeNode(VariableTreeNode original)
    51       : base(original) {
     46    [StorableConstructor]
     47    protected VariableTreeNode(bool deserializing) : base(deserializing) { }
     48    protected VariableTreeNode(VariableTreeNode original, Cloner cloner)
     49      : base(original, cloner) {
    5250      weight = original.weight;
    5351      variableName = original.variableName;
    5452    }
    55 
     53    protected VariableTreeNode() { }
    5654    public VariableTreeNode(Variable variableSymbol) : base(variableSymbol) { }
    5755
    … …  
    7573    }
    7674
    77 
    78     public override object Clone() {
    79       return new VariableTreeNode(this);
     75    public override IDeepCloneable Clone(Cloner cloner) {
     76      return new VariableTreeNode(this, cloner);
    8077    }
    8178

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/VariableFrequencyAnalyser.cs

    r4125 r4722  
    2222using System.Collections.Generic;
    2323using System.Linq;
     24using HeuristicLab.Common;
    2425using HeuristicLab.Core;
    2526using HeuristicLab.Data;
    … …  
    6162    }
    6263    #endregion
     64    [StorableConstructor]
     65    protected VariableFrequencyAnalyser(bool deserializing) : base(deserializing) { }
     66    protected VariableFrequencyAnalyser(VariableFrequencyAnalyser original, Cloner cloner)
     67      : base(original, cloner) {
     68    }
    6369    public VariableFrequencyAnalyser()
    6470      : base() {
    … …  
    8086        VariableFrequencies[lastRowIndex, columnIndex] = pair.Value;
    8187      }
    82       return null;
     88      return base.Apply();
    8389    }
    8490

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Tests/LinearScalingTest.cs

    r4477 r4722  
    2020#endregion
    2121
    22 using System.IO;
    23 using System;
    24 using HeuristicLab.Random;
    25 using HeuristicLab.Common;
    2622using System.Collections.Generic;
    27 using System.Diagnostics;
    28 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
    29 using HeuristicLab.Problems.DataAnalysis.Symbolic;
     23using System.Linq;
     24using HeuristicLab.Problems.DataAnalysis.Regression.Symbolic;
    3025using Microsoft.VisualStudio.TestTools.UnitTesting;
    31 using System.Linq;
    32 using System.Globalization;
    33 using HeuristicLab.Problems.DataAnalysis.Regression.Symbolic;
    3426namespace HeuristicLab.Problems.DataAnalysis.Tests {
    3527

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Tests/StatisticCalculatorsTest.cs

    r4477 r4722  
    2020#endregion
    2121
    22 using System.IO;
    2322using System;
    24 using HeuristicLab.Random;
    25 using HeuristicLab.Common;
    2623using System.Collections.Generic;
    27 using System.Diagnostics;
    28 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
    29 using HeuristicLab.Problems.DataAnalysis.Symbolic;
     24using System.Linq;
     25using HeuristicLab.Problems.DataAnalysis.Evaluators;
    3026using Microsoft.VisualStudio.TestTools.UnitTesting;
    31 using System.Linq;
    32 using System.Globalization;
    33 using HeuristicLab.Problems.DataAnalysis.Regression.Symbolic;
    34 using HeuristicLab.Problems.DataAnalysis.Evaluators;
    3527namespace HeuristicLab.Problems.DataAnalysis.Tests {
    3628

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Tests/SymbolicSimplifierTest.cs

    r4477 r4722  
    2020#endregion
    2121
    22 using System.IO;
    2322using System;
    24 using HeuristicLab.Random;
     23using System.Collections.Generic;
    2524using HeuristicLab.Common;
    26 using System.Collections.Generic;
    27 using System.Diagnostics;
     25using HeuristicLab.Core;
    2826using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
     27using HeuristicLab.Optimization;
     28using HeuristicLab.Problems.DataAnalysis.Regression.Symbolic;
    2929using HeuristicLab.Problems.DataAnalysis.Symbolic;
    3030using Microsoft.VisualStudio.TestTools.UnitTesting;
    31 using System.Linq;
    32 using System.Globalization;
    33 using HeuristicLab.Problems.DataAnalysis.Regression.Symbolic;
    34 using HeuristicLab.Problems.DataAnalysis.Evaluators;
    35 using HeuristicLab.Core;
    36 using HeuristicLab.Optimization;
    37 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Symbols;
    3831namespace HeuristicLab.Problems.DataAnalysis.Tests {
    3932
Note: See TracChangeset for help on using the changeset viewer.