Context Navigation

HeuristicLab.Encodings.SymbolicExpressionTreeEncoding

Timestamp:

04/22/10 08:51:33 (15 years ago)

Author:

gkronber

Message:

Bug fixes in cloning and persistence. #937 (Data types and operators for symbolic expression tree encoding)

Location:

Files:

-                      r3462
+                      r3484
+    }
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserializationHook() {
+      Reset();
+    }
     private new void Reset() {
       base.Reset();

-                      r3462
+                      r3484
     [Storable]
     private Symbol symbol;
+    public Symbol Symbol {
+      get { return symbol; }
+      protected set { symbol = value; }
+    }
     // parent relation is not persisted or cloned (will be set on AddSubtree or RemoveSubtree)
     private SymbolicExpressionTreeNode parent;
     public SymbolicExpressionTreeNode() {
       subTrees = new List<SymbolicExpressionTreeNode>();
+    internal SymbolicExpressionTreeNode Parent {
+      get { return parent; }
+      set { parent = value; }
+    }
+    public SymbolicExpressionTreeNode(Symbol symbol)
+      : this() {
+    public SymbolicExpressionTreeNode() { }
+    public SymbolicExpressionTreeNode(Symbol symbol) {
+      subTrees = new List<SymbolicExpressionTreeNode>();
       this.symbol = symbol;
+    }
 …
     public virtual IList<SymbolicExpressionTreeNode> SubTrees {
       get { return subTrees; }
+    }
-    public Symbol Symbol {
-      get { return symbol; }
-      protected set { symbol = value; }
+    }
-    internal SymbolicExpressionTreeNode Parent {
-      get { return parent; }
-      set { parent = value; }
+    }

-                      r3462
+                      r3484
 namespace HeuristicLab.Encodings.SymbolicExpressionTreeEncoding {
+  [StorableClass]
   public abstract class SymbolicExpressionTreeTerminalNode : SymbolicExpressionTreeNode {
     private static List<SymbolicExpressionTreeNode> emptyList = new List<SymbolicExpressionTreeNode>();
+    protected SymbolicExpressionTreeTerminalNode(Symbol symbol) : base(symbol) { }
+    protected SymbolicExpressionTreeTerminalNode(SymbolicExpressionTreeTerminalNode original)
+      : base(original) {
+    protected SymbolicExpressionTreeTerminalNode() : base() { }
+    // don't call  base constructors to prevent allocation of sub-trees list in base!
+    protected SymbolicExpressionTreeTerminalNode(Symbol symbol) {
+      this.Symbol = symbol;
+    }
+    // don't call  base constructors to prevent allocation of sub-trees list in base!
+    protected SymbolicExpressionTreeTerminalNode(SymbolicExpressionTreeTerminalNode original) {
+      this.Symbol = original.Symbol;
+    }

r3462	r3484
35	35	}
36	36	}
37
	37	[Storable]
38	38	private int argumentIndex;
39	39	public int ArgumentIndex {
40	40	get { return argumentIndex; }
41	41	}
	42
	43	private Argument() : base() { }
42	44
43	45	public Argument(int argumentIndex)
…	…
50	52	return new ArgumentTreeNode(this);
51	53	}
	54
	55	public override IDeepCloneable Clone(Cloner cloner) {
	56	Argument clone = (Argument)base.Clone(cloner);
	57	clone.argumentIndex = argumentIndex;
	58	clone.name = "ARG" + argumentIndex;
	59	return clone;
	60	}
52	61	}
53	62	}

-                      r3462
+                      r3484
       set {
         if (value == null) throw new ArgumentNullException();
         if(!(value is Argument)) throw new ArgumentException();
         base.Symbol = value;
+        if (!(value is Argument)) throw new ArgumentException();
+        base.Symbol = value;
+      }
+    }
+    private ArgumentTreeNode() : base() { }
     // copy constructor
     private ArgumentTreeNode(ArgumentTreeNode original)

r3462	r3484
40	40	}
41	41
	42	private DefunTreeNode() : base() { }
	43
42	44	// copy constructor
43	45	private DefunTreeNode(DefunTreeNode original)

-                      r3462
+                      r3484
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using System;
 namespace HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Symbols {
   /// <summary>
 …
+      }
+    }
+    public string FunctionName { get; set; }
+    [Storable]
+    private string functionName;
+    public string FunctionName {
+      get { return functionName; }
+      set {
+        if (value == null) throw new ArgumentNullException();
+        functionName = value;
+      }
+    }
+    private InvokeFunction() : base() { }
     public InvokeFunction(string functionName)
 …
       return new InvokeFunctionTreeNode(this);
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      InvokeFunction clone = (InvokeFunction)base.Clone(cloner);
+      clone.functionName = functionName;
+      clone.name = "Invoke: " + functionName;
+      return clone;
+    }
+  }
+}

r3462	r3484
34	34	}
35	35
	36	private InvokeFunctionTreeNode() : base() { }
	37
36	38	// copy constructor
37	39	private InvokeFunctionTreeNode(InvokeFunctionTreeNode original)

-                      r3462
+                      r3484
   public abstract class Symbol : NamedItem {
     #region Properties
+    [Storable]
     private double initialFrequency;
     public double InitialFrequency {
 …
       return new SymbolicExpressionTreeNode(this);
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      Symbol clone = (Symbol) base.Clone(cloner);
+      clone.initialFrequency = initialFrequency;
+      return clone;
+    }
+  }
+}

Note: See TracChangeset for help on using the changeset viewer.