Free cookie consent management tool by TermsFeed Policy Generator

Changeset 3993


Ignore:
Timestamp:
07/02/10 11:38:04 (14 years ago)
Author:
mkommend
Message:

changed symbols and grammars to be more efficient in respect to cloning, construction and deserialization (ticket #1073)

Location:
trunk/sources
Files:
37 edited

Legend:

Unmodified
Added
Removed
  • trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.3/DefaultSymbolicExpressionGrammar.cs

    r3541 r3993  
    6363      }
    6464      set {
    65         allowedChildSymbols = new Dictionary<string, List<HashSet<string>>>();
     65        allowedChildSymbols = new Dictionary<string, List<List<string>>>();
    6666        foreach (var pair in value) {
    67           allowedChildSymbols[pair.Key] = new List<HashSet<string>>();
     67          allowedChildSymbols[pair.Key] = new List<List<string>>();
    6868          foreach (var entry in pair.Value) {
    69             var hashSet = new HashSet<string>();
     69            var hashSet = new List<string>();
    7070            foreach (string child in entry) {
    7171              hashSet.Add(child);
     
    8585    private Dictionary<string, int> minSubTreeCount;
    8686    private Dictionary<string, int> maxSubTreeCount;
    87     private Dictionary<string, List<HashSet<string>>> allowedChildSymbols;
     87    private Dictionary<string, List<List<string>>> allowedChildSymbols;
    8888    private Dictionary<string, Symbol> allSymbols;
    8989    [Storable]
     
    9292    public DefaultSymbolicExpressionGrammar()
    9393      : base() {
    94       Clear();
    95     }
    96 
    97     public void Clear() {
    9894      minSubTreeCount = new Dictionary<string, int>();
    9995      maxSubTreeCount = new Dictionary<string, int>();
    100       allowedChildSymbols = new Dictionary<string, List<HashSet<string>>>();
     96      allowedChildSymbols = new Dictionary<string, List<List<string>>>();
    10197      allSymbols = new Dictionary<string, Symbol>();
     98
    10299      cachedMinExpressionLength = new Dictionary<string, int>();
    103100      cachedMaxExpressionLength = new Dictionary<string, int>();
     
    110107    }
    111108
     109    //copy constructor for cloning
     110    protected DefaultSymbolicExpressionGrammar(DefaultSymbolicExpressionGrammar copy) :base() {
     111      this.minSubTreeCount = new Dictionary<string, int>(copy.minSubTreeCount);
     112      this.maxSubTreeCount = new Dictionary<string, int>(copy.maxSubTreeCount);
     113     
     114      this.startSymbol = copy.startSymbol;
     115      this.allowedChildSymbols = new Dictionary<string, List<List<string>>>();
     116      foreach (var entry in copy.allowedChildSymbols) {
     117        this.allowedChildSymbols[entry.Key] = new List<List<string>>(entry.Value.Count);
     118        foreach (var set in entry.Value) {
     119          this.allowedChildSymbols[entry.Key].Add(new List<string>(set));
     120        }
     121      }
     122      this.allSymbols = new Dictionary<string, Symbol>(copy.allSymbols);
     123
     124      cachedMinExpressionLength = new Dictionary<string, int>();
     125      cachedMaxExpressionLength = new Dictionary<string, int>();
     126      cachedMinExpressionDepth = new Dictionary<string, int>();
     127    }
     128
     129    [StorableConstructor]
     130    protected DefaultSymbolicExpressionGrammar(bool deserializing)
     131      : base(deserializing) {
     132      cachedMinExpressionLength = new Dictionary<string, int>();
     133      cachedMaxExpressionLength = new Dictionary<string, int>();
     134      cachedMinExpressionDepth = new Dictionary<string, int>();
     135    }
     136
     137    public void Clear() {
     138      minSubTreeCount.Clear();
     139      maxSubTreeCount.Clear();
     140      allowedChildSymbols.Clear();
     141      allSymbols.Clear();
     142
     143      cachedMaxExpressionLength.Clear();
     144      cachedMinExpressionLength.Clear();
     145      cachedMinExpressionDepth.Clear();
     146
     147      startSymbol = new StartSymbol();
     148      AddSymbol(startSymbol);
     149      SetMinSubtreeCount(startSymbol, 1);
     150      SetMaxSubtreeCount(startSymbol, 1);
     151    }
     152
    112153    #region ISymbolicExpressionGrammar Members
    113154
     
    117158    }
    118159
    119 
    120160    public void AddSymbol(Symbol symbol) {
    121161      if (ContainsSymbol(symbol)) throw new ArgumentException("Symbol " + symbol + " is already defined.");
    122162      allSymbols.Add(symbol.Name, symbol);
    123       allowedChildSymbols[symbol.Name] = new List<HashSet<string>>();
     163      allowedChildSymbols[symbol.Name] = new List<List<string>>();
    124164      ClearCaches();
    125165    }
     
    211251      maxSubTreeCount[symbol.Name] = nSubTrees;
    212252      while (allowedChildSymbols[symbol.Name].Count <= nSubTrees)
    213         allowedChildSymbols[symbol.Name].Add(new HashSet<string>());
     253        allowedChildSymbols[symbol.Name].Add(new List<string>());
    214254      while (allowedChildSymbols[symbol.Name].Count > nSubTrees) {
    215255        allowedChildSymbols[symbol.Name].RemoveAt(allowedChildSymbols[symbol.Name].Count - 1);
     
    243283
    244284    public override IDeepCloneable Clone(Cloner cloner) {
    245       DefaultSymbolicExpressionGrammar clone = (DefaultSymbolicExpressionGrammar)base.Clone(cloner);
    246       clone.maxSubTreeCount = new Dictionary<string, int>(maxSubTreeCount);
    247       clone.minSubTreeCount = new Dictionary<string, int>(minSubTreeCount);
    248       clone.startSymbol = startSymbol;
    249       clone.allowedChildSymbols = new Dictionary<string, List<HashSet<string>>>();
    250       foreach (var entry in allowedChildSymbols) {
    251         clone.allowedChildSymbols[entry.Key] = new List<HashSet<string>>();
    252         foreach (var set in entry.Value) {
    253           clone.allowedChildSymbols[entry.Key].Add(new HashSet<string>(set));
    254         }
    255       }
    256       clone.allSymbols = new Dictionary<string, Symbol>(allSymbols);
     285      DefaultSymbolicExpressionGrammar clone = new DefaultSymbolicExpressionGrammar(this);
     286      cloner.RegisterClonedObject(this, clone);
    257287      return clone;
    258288    }
  • trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.3/GlobalSymbolicExpressionGrammar.cs

    r3990 r3993  
    7272    private Defun defunSymbol;
    7373
    74     public GlobalSymbolicExpressionGrammar() : base() { } // empty constructor for cloning
     74
    7575
    7676    public GlobalSymbolicExpressionGrammar(ISymbolicExpressionGrammar mainBranchGrammar )
     
    7979      maxFunctionDefinitions = 3;
    8080      Initialize(mainBranchGrammar);
     81    }
     82
     83    //copy constructor for cloning
     84    protected GlobalSymbolicExpressionGrammar(GlobalSymbolicExpressionGrammar copy)
     85      : base(copy) {
     86      this.maxFunctionArguments = copy.maxFunctionArguments;
     87      this.minFunctionArguments = copy.minFunctionArguments;
     88      this.maxFunctionDefinitions = copy.maxFunctionDefinitions;
     89      this.minFunctionDefinitions = copy.minFunctionDefinitions;
     90    }
     91
     92    [StorableConstructor]
     93    protected GlobalSymbolicExpressionGrammar(bool deserializing)
     94      : base(deserializing) {
    8195    }
    8296
     
    142156
    143157    public override IDeepCloneable Clone(Cloner cloner) {
    144       GlobalSymbolicExpressionGrammar clone = (GlobalSymbolicExpressionGrammar)base.Clone(cloner);
    145       clone.defunSymbol = defunSymbol;
    146       clone.maxFunctionArguments = maxFunctionArguments;
    147       clone.maxFunctionDefinitions = maxFunctionDefinitions;
    148       clone.minFunctionArguments = minFunctionArguments;
    149       clone.minFunctionDefinitions = minFunctionDefinitions;
     158      GlobalSymbolicExpressionGrammar clone = new GlobalSymbolicExpressionGrammar(this);
     159      cloner.RegisterClonedObject(this, clone);
    150160      return clone;
    151161    }
  • trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.3/Symbols/Argument.cs

    r3824 r3993  
    2828  /// </summary>
    2929  [StorableClass]
    30   [Item("Argument", "Symbol that represents a function argument.")]
     30  [Item(Argument.ArgumentName, Argument.ArgumentDescription)]
    3131  public sealed class Argument : ReadOnlySymbol {
     32    public const string ArgumentName = "Argument";
     33    public const string ArgumentDescription = "Symbol that represents a function argument.";
    3234    [Storable]
    3335    private int argumentIndex;
     
    3638    }
    3739
     40    public override bool CanChangeDescription {
     41      get { return false; }
     42    }
     43
     44    [StorableConstructor]
    3845    private Argument() : base() { }
    3946
    4047    public Argument(int argumentIndex)
    41       : base() {
     48      : base("ARG" + argumentIndex, Argument.ArgumentDescription) {
    4249      this.argumentIndex = argumentIndex;
    4350      this.name = "ARG" + argumentIndex;
  • trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.3/Symbols/Defun.cs

    r3983 r3993  
    2828  /// </summary>
    2929  [StorableClass]
    30   [Item("Defun", "Symbol that represents a function defining node.")]
     30  [Item(Defun.DefunName, Defun.DefunDescription)]
    3131  public sealed class Defun : ReadOnlySymbol {
    32     public Defun() : base() { }
     32    public const string DefunName = "Defun";
     33    public const string DefunDescription = "Symbol that represents a function defining node.";
     34
     35    public Defun() : base(Defun.DefunName, Defun.DefunDescription) { }
     36    [StorableConstructor]
     37    protected Defun(bool deserializing) : base(deserializing) { }
    3338
    3439    public override SymbolicExpressionTreeNode CreateTreeNode() {
  • trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.3/Symbols/InvokeFunction.cs

    r3824 r3993  
    2929  /// </summary>
    3030  [StorableClass]
    31   [Item("InvokeFunction", "Symbol that the invokation of another function.")]
     31  [Item(InvokeFunction.InvokeFunctionName, InvokeFunction.InvokeFunctionDescription)]
    3232  public sealed class InvokeFunction : ReadOnlySymbol {
     33    public const string InvokeFunctionName = "InvokeFunction";
     34    public const string InvokeFunctionDescription = "Symbol that the invokation of another function.";
    3335    public override bool CanChangeName {
    3436      get {
     
    4648    }
    4749
    48     private InvokeFunction() : base() { }
    49 
     50    [StorableConstructor]
     51    private InvokeFunction(bool deserializing) : base(deserializing) { }
    5052    public InvokeFunction(string functionName)
    51       : base() {
     53      : base("Invoke: " + functionName, InvokeFunction.InvokeFunctionDescription) {
    5254      this.FunctionName = functionName;
    53       this.name = "Invoke: " + functionName;
    5455    }
    5556
  • trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.3/Symbols/ProgramRootSymbol.cs

    r3824 r3993  
    2525namespace HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Symbols {
    2626  [StorableClass]
    27   [Item("ProgramRootSymbol", "Special symbol that represents the program root node of a symbolic expression tree.")]
     27  [Item(ProgramRootSymbol.ProgramRootSymbolName, ProgramRootSymbol.ProgramRootSymbolDescription)]
    2828  public sealed class ProgramRootSymbol : ReadOnlySymbol {
     29    public const string ProgramRootSymbolName = "ProgramRootSymbol";
     30    public const string ProgramRootSymbolDescription = "Special symbol that represents the program root node of a symbolic expression tree.";
     31
     32    public ProgramRootSymbol() : base(ProgramRootSymbol.ProgramRootSymbolName, ProgramRootSymbol.ProgramRootSymbolDescription) { }
     33    [StorableConstructor]
     34    private ProgramRootSymbol(bool deserializing) : base(deserializing) { }
     35
    2936    public override SymbolicExpressionTreeNode CreateTreeNode() {
    3037      return new SymbolicExpressionTreeTopLevelNode(this);
  • trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.3/Symbols/ReadOnlySymbol.cs

    r3824 r3993  
    5050    }
    5151
    52     protected ReadOnlySymbol()
    53       : base() {
    54       this.name = ItemName;
    55       this.description = ItemDescription;
    56       initialFrequency = 1.0;
    57     }
     52    protected ReadOnlySymbol() : base() { }
     53    protected ReadOnlySymbol(string name, string description) : base(name, description) { }
     54    [StorableConstructor]
     55    protected ReadOnlySymbol(bool deserializing) : base(deserializing) { }
    5856  }
    5957}
  • trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.3/Symbols/Symbol.cs

    r3824 r3993  
    5454    protected Symbol()
    5555      : base() {
    56       this.name = ItemName;
    57       this.description = ItemDescription;
    5856      initialFrequency = 1.0;
    5957    }
     58
     59    protected Symbol(string name, string description)
     60      : base(name, description) {
     61      initialFrequency = 1.0;
     62    }
     63
     64    [StorableConstructor]
     65    protected Symbol(bool deserializing) : base(deserializing) { }
    6066
    6167    public virtual SymbolicExpressionTreeNode CreateTreeNode() {
  • trunk/sources/HeuristicLab.Operators.Views.GraphVisualization/3.3/General/GraphVisualizationInfoView.cs

    r3904 r3993  
    8484
    8585    private void UpdateContent() {
    86       foreach (IConnectionInfo connectionInfo in this.connectionInfoConnectionMapping.FirstValues)
     86      foreach (IConnectionInfo connectionInfo in this.connectionInfoConnectionMapping.FirstValues.ToList())
    8787        this.RemoveConnectionInfo(connectionInfo);
    8888      this.connectionInfoConnectionMapping.Clear();
    89       foreach (IShapeInfo shapeInfo in this.shapeInfoShapeMapping.FirstValues)
     89      foreach (IShapeInfo shapeInfo in this.shapeInfoShapeMapping.FirstValues.ToList())
    9090        this.RemoveShapeInfo(shapeInfo);
    9191      this.shapeInfoShapeMapping.Clear();
  • trunk/sources/HeuristicLab.Problems.ArtificialAnt/3.3/ArtificialAntExpressionGrammar.cs

    r3462 r3993  
    3838      Initialize();
    3939    }
     40    [StorableConstructor]
     41    protected ArtificialAntExpressionGrammar(bool deserializing) : base(deserializing) { }
    4042
    4143    private void Initialize() {
  • trunk/sources/HeuristicLab.Problems.ArtificialAnt/3.3/Symbols/IfFoodAhead.cs

    r3462 r3993  
    2929  [Item("IfFoodAhead", "Represents the if-food-ahead symbol in a artificial ant expression.")]
    3030  public sealed class IfFoodAhead : Symbol {
     31    public IfFoodAhead() : base("IfFoodAhead", "Represents the if-food-ahead symbol in a artificial ant expression.") { }
    3132  }
    3233}
  • trunk/sources/HeuristicLab.Problems.ArtificialAnt/3.3/Symbols/Left.cs

    r3462 r3993  
    2929  [Item("Left", "Represents the turn-left symbol in a artificial ant expression.")]
    3030  public sealed class Left : Symbol {
     31    public Left() : base("Left", "Represents the turn-left symbol in a artificial ant expression.") { }
    3132  }
    3233}
  • trunk/sources/HeuristicLab.Problems.ArtificialAnt/3.3/Symbols/Move.cs

    r3462 r3993  
    2929  [Item("Move", "Represents the move-forward symbol in a artificial ant expression.")]
    3030  public sealed class Move : Symbol {
     31    public Move() : base("Move", "Represents the move-forward symbol in a artificial ant expression.") { }
    3132  }
    3233}
  • trunk/sources/HeuristicLab.Problems.ArtificialAnt/3.3/Symbols/Prog2.cs

    r3462 r3993  
    3030  [Item("Prog2", "Represents the sequence symbol with 2 sub-trees in a artificial ant expression.")]
    3131  public sealed class Prog2 : Symbol {
     32    public Prog2() : base("Prog2", "Represents the sequence symbol with 2 sub-trees in a artificial ant expression.") { }
    3233  }
    3334}
  • trunk/sources/HeuristicLab.Problems.ArtificialAnt/3.3/Symbols/Prog3.cs

    r3462 r3993  
    2929  [Item("Prog3", "Represents the sequence symbol with 3 sub-trees in a artificial ant expression.")]
    3030  public sealed class Prog3 : Symbol {
     31    public Prog3() : base("Prog3", "Represents the sequence symbol with 3 sub-trees in a artificial ant expression.") { }
    3132  }
    3233}
  • trunk/sources/HeuristicLab.Problems.ArtificialAnt/3.3/Symbols/Right.cs

    r3462 r3993  
    2929  [Item("Right", "Represents the turn-right symbol in a artificial ant expression.")]
    3030  public sealed class Right : Symbol {
     31    public Right() : base("Right", "Represents the turn-right symbol in a artificial ant expression.") { }
    3132  }
    3233}
  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/ArithmeticExpressionGrammar.cs

    r3462 r3993  
    4242    }
    4343
     44    [StorableConstructor]
     45    protected ArithmeticExpressionGrammar(bool deserializing) : base(deserializing) { }
     46
    4447    private void Initialize() {
    4548      var add = new Addition();
  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/FullFunctionalExpressionGrammar.cs

    r3841 r3993  
    4141      Initialize();
    4242    }
     43    [StorableConstructor]
     44    protected FullFunctionalExpressionGrammar(bool deserializing) : base(deserializing) { }
    4345
    4446    private void Initialize() {
     
    6769      var unaryFunctionSymbols = new List<Symbol>() { sin, cos, tan, log, exp, not };
    6870      var binaryFunctionSymbols = new List<Symbol>() { gt, lt };
    69       var functionSymbols = new List<Symbol>() { add, sub, mul, div, mean, and, or};
     71      var functionSymbols = new List<Symbol>() { add, sub, mul, div, mean, and, or };
    7072
    7173      foreach (var symb in allSymbols)
  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Addition.cs

    r3462 r3993  
    2828  [Item("Addition", "Symbol that represents the + operator.")]
    2929  public sealed class Addition : Symbol {
     30    public Addition() :base("Addition","Symbol that represents the + operator.") {}
    3031  }
    3132}
  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/And.cs

    r3841 r3993  
    2828  [Item("And", "Symbol that represents the boolean AND operator.")]
    2929  public sealed class And : Symbol {
     30    public And() : base("And", "Symbol that represents the boolean AND operator.") { }
    3031  }
    3132}
  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Average.cs

    r3841 r3993  
    2828  [Item("Average", "Symbol that represents the average (arithmetic mean) function.")]
    2929  public sealed class Average : Symbol {
     30    public Average() : base("Average", "Symbol that represents the average (arithmetic mean) function.") { }
    3031  }
    3132}
  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Constant.cs

    r3824 r3993  
    8181    #endregion
    8282    public Constant()
    83       : base() {
     83      : base("Constant", "Represents a constant value.") {
    8484      manipulatorNu = 0.0;
    8585      manipulatorSigma = 1.0;
  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Cosine.cs

    r3841 r3993  
    2828  [Item("Cosine", "Symbol that represents the cosine function.")]
    2929  public sealed class Cosine : Symbol {
     30    public Cosine() : base("Cosine", "Symbol that represents the cosine function.") { }
    3031  }
    3132}
  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Division.cs

    r3462 r3993  
    2828  [Item("Division", "Symbol that represents the / operator.")]
    2929  public sealed class Division : Symbol {
     30    public Division() : base("Division", "Symbol that represents the / operator.") { }
    3031  }
    3132}
  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Exponential.cs

    r3841 r3993  
    2828  [Item("Exponential", "Symbol that represents the exponential function.")]
    2929  public sealed class Exponential : Symbol {
     30    public Exponential() : base("Exponential", "Symbol that represents the exponential function.") { }
    3031  }
    3132}
  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/GreaterThan.cs

    r3841 r3993  
    2828  [Item("GreaterThan", "Symbol that represents a greater than relation.")]
    2929  public sealed class GreaterThan : Symbol {
     30    public GreaterThan() : base("GreaterThan", "Symbol that represents a greater than relation.") { }
    3031  }
    3132}
  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/IfThenElse.cs

    r3841 r3993  
    2828  [Item("IfThenElse", "Symbol that represents a conditional operator.")]
    2929  public sealed class IfThenElse : Symbol {
     30    public IfThenElse() : base("IfThenElse", "Symbol that represents a conditional operator.") { }
    3031  }
    3132}
  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/LaggedVariable.cs

    r3841 r3993  
    9090    #endregion
    9191    public LaggedVariable()
    92       : base() {
     92      : base("LaggedVariable", "Represents a variable value with a time offset.") {
    9393      weightNu = 1.0;
    9494      weightSigma = 1.0;
  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/LessThan.cs

    r3841 r3993  
    2828  [Item("LessThan", "Symbol that represents a less than relation.")]
    2929  public sealed class LessThan : Symbol {
     30    public LessThan() : base("LessThan", "Symbol that represents a less than relation.") { }
    3031  }
    3132}
  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Logarithm.cs

    r3841 r3993  
    2828  [Item("Logarithm", "Symbol that represents the logarithm function.")]
    2929  public sealed class Logarithm : Symbol {
     30    public Logarithm() : base("Logarithm", "Symbol that represents the logarithm function.") { }
    3031  }
    3132}
  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Multiplication.cs

    r3462 r3993  
    2828  [Item("Multiplication", "Symbol that represents the * operator.")]
    2929  public sealed class Multiplication : Symbol {
     30    public Multiplication() : base("Multiplication", "Symbol that represents the * operator.") { }
    3031  }
    3132}
  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Not.cs

    r3841 r3993  
    2828  [Item("Not", "Symbol that represents the boolean NOT operator.")]
    2929  public sealed class Not : Symbol {
     30    public Not() : base("Not", "Symbol that represents the boolean NOT operator.") { }
    3031  }
    3132}
  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Or.cs

    r3841 r3993  
    2828  [Item("Or", "Symbol that represents the boolean OR operator.")]
    2929  public sealed class Or : Symbol {
     30    public Or() : base("Or", "Symbol that represents the boolean OR operator.") { }
    3031  }
    3132}
  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Sine.cs

    r3841 r3993  
    2828  [Item("Sine", "Symbol that represents the sine function.")]
    2929  public sealed class Sine : Symbol {
     30    public Sine() : base("Sine", "Symbol that represents the sine function.") { }
    3031  }
    3132}
  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Subtraction.cs

    r3462 r3993  
    2828  [Item("Subtraction", "Symbol that represents the - operator.")]
    2929  public sealed class Subtraction : Symbol {
     30    public Subtraction() : base("Subtraction", "Symbol that represents the - operator.") { }
    3031  }
    3132}
  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Tangent.cs

    r3841 r3993  
    2828  [Item("Tangent", "Symbol that represents the tangent trigonometric function.")]
    2929  public sealed class Tangent : Symbol {
     30    public Tangent() : base("Tangent", "Symbol that represents the tangent trigonometric function.") { }
    3031  }
    3132}
  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Variable.cs

    r3824 r3993  
    9595    #endregion
    9696    public Variable()
    97       : base() {
     97      : base("Variable", "Represents a variable value.") {
    9898      weightNu = 1.0;
    9999      weightSigma = 1.0;
Note: See TracChangeset for help on using the changeset viewer.