Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
01/11/11 15:03:46 (14 years ago)
Author:
gkronber
Message:

Merged changes from trunk to data analysis exploration branch and added fractional distance metric evaluator. #1142

Location:
branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols
Files:
24 edited

Legend:

Unmodified
Added
Removed

  • branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Addition.cs

    r4068 r5275  
    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  }

  • branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/And.cs

    r4068 r5275  
    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  }

  • branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Average.cs

    r4068 r5275  
    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  }

  • branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Constant.cs

    r4068 r5275  
    5454    }
    5555    [Storable]
    56     private double manipulatorNu;
    57     public double ManipulatorNu {
    58       get { return manipulatorNu; }
     56    private double manipulatorMu;
     57    public double ManipulatorMu {
     58      get { return manipulatorMu; }
    5959      set {
    60         if (value != manipulatorNu) {
    61           manipulatorNu = value;
     60        if (value != manipulatorMu) {
     61          manipulatorMu = value;
    6262          OnChanged(EventArgs.Empty);
    6363        }
    … …  
    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      manipulatorMu = original.manipulatorMu;
     86      manipulatorSigma = original.manipulatorSigma;
     87    }
    7988    public Constant()
    8089      : base("Constant", "Represents a constant value.") {
    81       manipulatorNu = 0.0;
     90      manipulatorMu = 0.0;
    8291      manipulatorSigma = 1.0;
    8392      minValue = -20.0;
    … …  
    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  }

  • branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/ConstantTreeNode.cs

    r4068 r5275  
    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
    … …  
    6163    public override void ShakeLocalParameters(IRandom random, double shakingFactor) {
    6264      base.ShakeLocalParameters(random, shakingFactor);
    63       double x = NormalDistributedRandom.NextDouble(random, Symbol.ManipulatorNu, Symbol.ManipulatorSigma);
     65      double x = NormalDistributedRandom.NextDouble(random, Symbol.ManipulatorMu, Symbol.ManipulatorSigma);
    6466      Value = Value + x * shakingFactor;
    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

  • branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Cosine.cs

    r4068 r5275  
    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  }

  • branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/DifferentialVariable.cs

    r4193 r5275  
    2828  [Item("DifferentialVariable", "Represents the differential of a variable value.")]
    2929  public sealed class DifferentialVariable : Variable {
     30    [StorableConstructor]
     31    private DifferentialVariable(bool deserializing) : base(deserializing) { }
     32    private DifferentialVariable(DifferentialVariable original, Cloner cloner)
     33      : base(original, cloner) {
     34    }
    3035    public DifferentialVariable()
    3136      : base("DifferentialVariable", "Represents the differential of a variable value.") {
    … …  
    3540      return new DifferentialVariableTreeNode(this);
    3641    }
    37 
    3842    public override IDeepCloneable Clone(Cloner cloner) {
    39       DifferentialVariable clone = (DifferentialVariable)base.Clone(cloner);
    40       return clone;
     43      return new DifferentialVariable(this, cloner);
    4144    }
    4245  }

  • branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/DifferentialVariableTreeNode.cs

    r4193 r5275  
    2323using HeuristicLab.Core;
    2424using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
     25using HeuristicLab.Common;
    2526namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Symbols {
    2627  [StorableClass]
    … …  
    3031    }
    3132
     33    [StorableConstructor]
     34    protected DifferentialVariableTreeNode(bool deserializing) : base(deserializing) { }
     35    protected DifferentialVariableTreeNode(DifferentialVariableTreeNode original, Cloner cloner)
     36      : base(original, cloner) {
     37    }
    3238    private DifferentialVariableTreeNode() { }
    33 
    34     // copy constructor
    35     private DifferentialVariableTreeNode(DifferentialVariableTreeNode original)
    36       : base(original) {
    37     }
    3839
    3940    public DifferentialVariableTreeNode(DifferentialVariable differentialSymbol) : base(differentialSymbol) { }
    4041
    4142
    42     public override object Clone() {
    43       return new DifferentialVariableTreeNode(this);
     43    public override IDeepCloneable Clone(Cloner cloner) {
     44      return new DifferentialVariableTreeNode(this, cloner);
    4445    }
    45 
    4646  }
    4747}

  • branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Division.cs

    r4068 r5275  
    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  }

  • branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Exponential.cs

    r4068 r5275  
    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  }

  • branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/GreaterThan.cs

    r4068 r5275  
    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  }

  • branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/IfThenElse.cs

    r4068 r5275  
    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  }

  • branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/LaggedVariable.cs

    r4068 r5275  
    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  }

  • branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/LaggedVariableTreeNode.cs

    r4068 r5275  
    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

  • branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/LessThan.cs

    r4068 r5275  
    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  }

  • branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Logarithm.cs

    r4068 r5275  
    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  }

  • branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Multiplication.cs

    r4068 r5275  
    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  }

  • branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Not.cs

    r4068 r5275  
    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  }

  • branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Or.cs

    r4068 r5275  
    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  }

  • branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Sine.cs

    r4068 r5275  
    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  }

  • branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Subtraction.cs

    r4068 r5275  
    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  }

  • branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Tangent.cs

    r4068 r5275  
    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  }

  • branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Variable.cs

    r4068 r5275  
    3333    #region Properties
    3434    [Storable]
    35     private double weightNu;
    36     public double WeightNu {
    37       get { return weightNu; }
     35    private double weightMu;
     36    public double WeightMu {
     37      get { return weightMu; }
    3838      set {
    39         if (value != weightNu) {
    40           weightNu = value;
     39        if (value != weightMu) {
     40          weightMu = value;
    4141          OnChanged(EventArgs.Empty);
    4242        }
    … …  
    5656    }
    5757    [Storable]
    58     private double weightManipulatorNu;
    59     public double WeightManipulatorNu {
    60       get { return weightManipulatorNu; }
     58    private double weightManipulatorMu;
     59    public double WeightManipulatorMu {
     60      get { return weightManipulatorMu; }
    6161      set {
    62         if (value != weightManipulatorNu) {
    63           weightManipulatorNu = value;
     62        if (value != weightManipulatorMu) {
     63          weightManipulatorMu = value;
    6464          OnChanged(EventArgs.Empty);
    6565        }
    … …  
    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      weightMu = original.weightMu;
     99      weightSigma = original.weightSigma;
     100      variableNames = new List<string>(original.variableNames);
     101      weightManipulatorMu = original.weightManipulatorMu;
     102      weightManipulatorSigma = original.weightManipulatorSigma;
     103    }
    92104    public Variable() : this("Variable", "Represents a variable value.") { }
    93105    public Variable(string name, string description)
    94106      : base(name, description) {
    95       weightNu = 1.0;
     107      weightMu = 1.0;
    96108      weightSigma = 1.0;
    97       weightManipulatorNu = 0.0;
     109      weightManipulatorMu = 0.0;
    98110      weightManipulatorSigma = 1.0;
    99111      variableNames = new List<string>();
    … …  
    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  }

  • branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/VariableTreeNode.cs

    r4220 r5275  
    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
    … …  
    6462    public override void ResetLocalParameters(IRandom random) {
    6563      base.ResetLocalParameters(random);
    66       weight = NormalDistributedRandom.NextDouble(random, Symbol.WeightNu, Symbol.WeightSigma);
     64      weight = NormalDistributedRandom.NextDouble(random, Symbol.WeightMu, Symbol.WeightSigma);
    6765      variableName = Symbol.VariableNames.SelectRandom(random);
    6866    }
    … …  
    7068    public override void ShakeLocalParameters(IRandom random, double shakingFactor) {
    7169      base.ShakeLocalParameters(random, shakingFactor);
    72       double x = NormalDistributedRandom.NextDouble(random, Symbol.WeightManipulatorNu, Symbol.WeightManipulatorSigma);
     70      double x = NormalDistributedRandom.NextDouble(random, Symbol.WeightManipulatorMu, Symbol.WeightManipulatorSigma);
    7371      weight = weight + x * shakingFactor;
    7472      variableName = Symbol.VariableNames.SelectRandom(random);
    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
Note: See TracChangeset for help on using the changeset viewer.