Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Encodings/BinaryEncoding.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Encodings/BinaryEncoding.cs	(revision 11595)
+++ branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Encodings/BinaryEncoding.cs	(revision 11598)
@@ -36,4 +36,5 @@
   public sealed class BinaryEncoding : Encoding<IBinaryVectorCreator> {
     #region Encoding Parameters
+    [Storable]
     private IFixedValueParameter<IntValue> lengthParameter;
     public IFixedValueParameter<IntValue> LengthParameter {
Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Encodings/Encoding.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Encodings/Encoding.cs	(revision 11595)
+++ branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Encodings/Encoding.cs	(revision 11598)
@@ -76,4 +76,7 @@
     protected Encoding(string name) : base(name) { }
 
+    public virtual  Individual CreateIndividual(IScope scope) {
+      return new Individual(this, scope);
+    }
 
     public abstract void ConfigureOperators(IEnumerable<IOperator> operators);
Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Encodings/Individual.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Encodings/Individual.cs	(revision 11595)
+++ branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Encodings/Individual.cs	(revision 11598)
@@ -20,104 +20,82 @@
 #endregion
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using HeuristicLab.Common;
+using HeuristicLab.Core;
 using HeuristicLab.Encodings.BinaryVectorEncoding;
 using HeuristicLab.Encodings.IntegerVectorEncoding;
 using HeuristicLab.Encodings.PermutationEncoding;
 using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
 namespace HeuristicLab.Problems.Programmable {
-  public sealed class Individual : IDeepCloneable {
-    private readonly Dictionary<string, BinaryVector> binaryVectors;
-    private readonly Dictionary<string, IntegerVector> integerVectors;
-    private readonly Dictionary<string, RealVector> realVectors;
-    private readonly Dictionary<string, Permutation> permutationVectors;
+  [StorableClass]
+  public class Individual : Item {
+    [Storable]
+    public IEncoding Encoding { get; private set; }
+    [Storable]
+    protected IScope Scope { get; private set; }
 
-    public Individual(IEnumerable<KeyValuePair<string, BinaryVector>> binaryVectors = null,
-      IEnumerable<KeyValuePair<string, IntegerVector>> integerVectors = null,
-      IEnumerable<KeyValuePair<string, RealVector>> realVectors = null,
-      IEnumerable<KeyValuePair<string, Permutation>> permutations = null) {
-      // prevent unnecessary allocation of dictionaries for unused vectors
-      if (binaryVectors != null) this.binaryVectors = binaryVectors.ToDictionary(x => x.Key, x => x.Value);
-      if (integerVectors != null) this.integerVectors = integerVectors.ToDictionary(x => x.Key, x => x.Value);
-      if (realVectors != null) this.realVectors = realVectors.ToDictionary(x => x.Key, x => x.Value);
-      if (permutations != null) this.permutationVectors = permutations.ToDictionary(x => x.Key, x => x.Value);
-    }
-    private Individual(Individual original, Cloner cloner) {
-      cloner.RegisterClonedObject(original, this);
-      if (original.binaryVectors != null) {
-        binaryVectors = new Dictionary<string, BinaryVector>(original.binaryVectors.Comparer);
-        foreach (var param in original.binaryVectors)
-          binaryVectors[param.Key] = cloner.Clone(param.Value);
-      }
-      if (original.integerVectors != null) {
-        integerVectors = new Dictionary<string, IntegerVector>(original.integerVectors.Comparer);
-        foreach (var param in original.integerVectors)
-          integerVectors[param.Key] = cloner.Clone(param.Value);
-      }
-      if (original.realVectors != null) {
-        realVectors = new Dictionary<string, RealVector>(original.realVectors.Comparer);
-        foreach (var param in original.realVectors)
-          realVectors[param.Key] = cloner.Clone(param.Value);
-      }
-      if (original.permutationVectors != null) {
-        permutationVectors = new Dictionary<string, Permutation>(original.permutationVectors.Comparer);
-        foreach (var param in original.permutationVectors)
-          permutationVectors[param.Key] = cloner.Clone(param.Value);
-      }
+    public Individual(IEncoding encoding, IScope scope) {
+      Encoding = encoding;
+      Scope = scope;
     }
 
-    public object Clone() {
-      return Clone(new Cloner());
+    [StorableConstructor]
+    protected Individual(bool deserializing) : base(deserializing) { }
+
+    public override IDeepCloneable Clone(Cloner cloner) { return new Individual(this, cloner); }
+    protected Individual(Individual original, Cloner cloner)
+      : base(original, cloner) {
+      Encoding = cloner.Clone(original.Encoding);
+      Scope = cloner.Clone(original.Scope);
     }
 
-    public IDeepCloneable Clone(Cloner cloner) {
-      return new Individual(this, cloner);
+    public virtual IItem this[string name] {
+      get { return ExtractScopeValue(name, Encoding.Name, Scope); }
+      set { SetScopeValue(name, Encoding.Name, Scope, value); }
     }
 
-    public BinaryVector BinaryVector(string name) {
-      return binaryVectors[name];
+    internal virtual Individual Copy(IScope scope) {
+      var individual = Encoding.CreateIndividual(scope);
+      individual[Encoding.Name] = this[Encoding.Name];
+      return individual;
     }
 
-    public bool BinaryValue(string name, int index) {
-      return binaryVectors[name][index];
+    protected static IItem ExtractScopeValue(string name, string encodingName, IScope scope) {
+      if (name != encodingName) throw new ArgumentException(string.Format("{0} is not part of the specified encoding.", name));
+      if (!scope.Variables.ContainsKey(name)) throw new ArgumentException(string.Format("Encoding part {0} cannot be found in the provided scope.", name));
+      var value = scope.Variables[name].Value;
+      if (value == null) throw new ArgumentException(string.Format("Encoding part {0} is null.", name));
+      return value;
     }
 
-    public IEnumerable<string> BinaryNames {
-      get { return binaryVectors != null ? binaryVectors.Keys : Enumerable.Empty<string>(); }
-    }
+    protected static void SetScopeValue(string name, string encodingName, IScope scope, IItem value) {
+      if (name != encodingName) throw new ArgumentException(string.Format("{0} is not part of the specified encoding.", name));
+      if (value == null) throw new ArgumentNullException("value");
 
-    public IntegerVector IntegerVector(string name) {
-      return integerVectors[name];
-    }
-
-    public int IntegerValue(string name, int index) {
-      return integerVectors[name][index];
-    }
-
-    public IEnumerable<string> IntegerNames {
-      get { return integerVectors != null ? integerVectors.Keys : Enumerable.Empty<string>(); }
-    }
-
-    public RealVector RealVector(string name) {
-      return realVectors[name];
-    }
-
-    public double RealValue(string name, int index) {
-      return realVectors[name][index];
-    }
-
-    public IEnumerable<string> RealNames {
-      get { return realVectors != null ? realVectors.Keys : Enumerable.Empty<string>(); }
-    }
-
-    public Permutation Permutation(string name) {
-      return permutationVectors[name];
-    }
-
-    public IEnumerable<string> PermutationNames {
-      get { return permutationVectors != null ? permutationVectors.Keys : Enumerable.Empty<string>(); }
+      if (!scope.Variables.ContainsKey(name)) scope.Variables.Add(new Variable(name, value));
+      else scope.Variables[name].Value = value;
+      var variable = scope.Variables[name];
     }
   }
+
+  #region extension methods
+  public static class IndividualExtensionMethods {
+    public static BinaryVector BinaryVector(this Individual individual, string name) {
+      return (BinaryVector)individual[name];
+    }
+    public static IntegerVector IntegerVector(this Individual individual, string name) {
+      return (IntegerVector)individual[name];
+    }
+    public static Permutation Permutation(this Individual individual, string name) {
+      return (Permutation)individual[name];
+    }
+    public static RealVector RealVector(this Individual individual, string name) {
+      return (RealVector)individual[name];
+    }
+  }
+  #endregion
 }
Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Encodings/IntegerEncoding.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Encodings/IntegerEncoding.cs	(revision 11595)
+++ branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Encodings/IntegerEncoding.cs	(revision 11598)
@@ -37,4 +37,5 @@
   public class IntegerEncoding : Encoding<IIntegerVectorCreator> {
     #region Encoding Parameters
+    [Storable]
     private IFixedValueParameter<IntValue> lengthParameter;
     public IFixedValueParameter<IntValue> LengthParameter {
@@ -52,4 +53,5 @@
     }
 
+    [Storable]
     private IValueParameter<IntMatrix> boundsParameter;
     public IValueParameter<IntMatrix> BoundsParameter {
Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Encodings/MultiEncoding.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Encodings/MultiEncoding.cs	(revision 11595)
+++ branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Encodings/MultiEncoding.cs	(revision 11598)
@@ -27,4 +27,5 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 using HeuristicLab.PluginInfrastructure;
+using HeuristicLab.Problems.Programmable.Encodings;
 using HeuristicLab.Problems.Programmable.Interfaces;
 
@@ -32,5 +33,5 @@
   [Item("MultiEncoding", "Describes a combined encoding consisting of multiple simpler encodings.")]
   [StorableClass]
-  public class MultiEncoding : Encoding<MultiEncodingCreator> {
+  public sealed class MultiEncoding : Encoding<MultiEncodingCreator> {
 
     private readonly List<IEncoding> encodings;
@@ -43,5 +44,5 @@
 
     [StorableConstructor]
-    protected MultiEncoding(bool deserializing)
+    private MultiEncoding(bool deserializing)
       : base(deserializing) {
       encodings = new List<IEncoding>();
@@ -49,5 +50,5 @@
 
     public override IDeepCloneable Clone(Cloner cloner) { return new MultiEncoding(this, cloner); }
-    protected MultiEncoding(MultiEncoding original, Cloner cloner)
+    private MultiEncoding(MultiEncoding original, Cloner cloner)
       : base(original, cloner) {
       encodings = new List<IEncoding>(original.Encodings.Select(cloner.Clone));
@@ -60,4 +61,8 @@
       foreach (var @operator in ApplicationManager.Manager.GetInstances<IMultiEncodingOperator>())
         encodingOperators.Add(@operator);
+    }
+
+    public override Individual CreateIndividual(IScope scope) {
+      return new MultiEncodingIndividual(this, scope);
     }
 
Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Encodings/MultiEncodingIndividual.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Encodings/MultiEncodingIndividual.cs	(revision 11598)
+++ branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Encodings/MultiEncodingIndividual.cs	(revision 11598)
@@ -0,0 +1,68 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.Programmable.Encodings {
+  public sealed class MultiEncodingIndividual : Individual {
+    public new MultiEncoding Encoding {
+      get { return (MultiEncoding)base.Encoding; }
+    }
+
+    public MultiEncodingIndividual(IEncoding encoding, IScope scope)
+      : base(encoding, scope) {
+      if (encoding.GetType() != typeof(MultiEncoding))
+        throw new ArgumentException("Encoding must be of type MultiEncoding.k");
+    }
+
+    [StorableConstructor]
+    private MultiEncodingIndividual(bool deserializing) : base(deserializing) { }
+
+    public override IDeepCloneable Clone(Cloner cloner) { return new MultiEncodingIndividual(this, cloner); }
+    private MultiEncodingIndividual(Individual original, Cloner cloner) : base(original, cloner) { }
+
+    public override IItem this[string name] {
+      get {
+        var encoding = Encoding.Encodings.FirstOrDefault(e => e.Name == name);
+        if (encoding == null) throw new ArgumentException(string.Format("{0} is not part of the specified encoding.", name));
+        return ExtractScopeValue(name, encoding.Name, Scope);
+      }
+      set {
+        var encoding = Encoding.Encodings.FirstOrDefault(e => e.Name == name);
+        if (encoding == null) throw new ArgumentException(string.Format("{0} is not part of the specified encoding.", name));
+        SetScopeValue(name, encoding.Name, Scope, value);
+      }
+    }
+
+    internal override Individual Copy(IScope scope) {
+      var individual = Encoding.CreateIndividual(scope);
+      foreach (var encoding in Encoding.Encodings)
+        individual[encoding.Name] = this[encoding.Name];
+      return individual;
+    }
+  }
+}
Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Encodings/PermutationEncoding.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Encodings/PermutationEncoding.cs	(revision 11595)
+++ branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Encodings/PermutationEncoding.cs	(revision 11598)
@@ -36,4 +36,5 @@
   public sealed class PermutationEncoding : Encoding<IPermutationCreator> {
     #region encoding parameters
+    [Storable]
     private IFixedValueParameter<IntValue> lengthParameter;
     public IFixedValueParameter<IntValue> LengthParameter {
@@ -51,4 +52,5 @@
     }
 
+    [Storable]
     private IFixedValueParameter<PermutationType> permutationTypeParameter;
     public IFixedValueParameter<PermutationType> PermutationTypeParameter {
Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Encodings/RealEncoding.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Encodings/RealEncoding.cs	(revision 11595)
+++ branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Encodings/RealEncoding.cs	(revision 11598)
@@ -37,4 +37,5 @@
   public sealed class RealEncoding : Encoding<IRealVectorCreator> {
     #region Encoding Parameters
+    [Storable]
     private IFixedValueParameter<IntValue> lengthParameter;
     public IFixedValueParameter<IntValue> LengthParameter {
@@ -51,5 +52,5 @@
       }
     }
-
+    [Storable]
     private IValueParameter<DoubleMatrix> boundsParameter;
     public IValueParameter<DoubleMatrix> BoundsParameter {
Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Helper.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Helper.cs	(revision 11595)
+++ 	(revision )
@@ -1,115 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System;
-using System.Collections.Generic;
-using HeuristicLab.Core;
-using HeuristicLab.Encodings.BinaryVectorEncoding;
-using HeuristicLab.Encodings.IntegerVectorEncoding;
-using HeuristicLab.Encodings.PermutationEncoding;
-using HeuristicLab.Encodings.RealVectorEncoding;
-
-namespace HeuristicLab.Problems.Programmable {
-  internal static class Helper {
-    internal static Individual Extract(IScope scope, IEncoding encoding) {
-      Dictionary<string, BinaryVector> binDict = null;
-      Dictionary<string, IntegerVector> intDict = null;
-      Dictionary<string, RealVector> realDict = null;
-      Dictionary<string, Permutation> permDict = null;
-      var multiEncoding = encoding as MultiEncoding;
-      if (multiEncoding != null) {
-        foreach (var enc in multiEncoding.Encodings) {
-          var binConfig = enc as BinaryEncoding;
-          if (binConfig != null) {
-            if (binDict == null) binDict = new Dictionary<string, BinaryVector>();
-            binDict.Add(enc.Name, (BinaryVector)scope.Variables[enc.Name].Value);
-            continue;
-          }
-          var intConfig = enc as IntegerEncoding;
-          if (intConfig != null) {
-            if (intDict == null) intDict = new Dictionary<string, IntegerVector>();
-            intDict.Add(enc.Name, (IntegerVector)scope.Variables[enc.Name].Value);
-            continue;
-          }
-          var realConfig = enc as RealEncoding;
-          if (realConfig != null) {
-            if (realDict == null) realDict = new Dictionary<string, RealVector>();
-            realDict.Add(enc.Name, (RealVector)scope.Variables[enc.Name].Value);
-            continue;
-          }
-          var permConfig = enc as PermutationEncoding;
-          if (permConfig != null) {
-            if (permDict == null) permDict = new Dictionary<string, Permutation>();
-            permDict.Add(enc.Name, (Permutation)scope.Variables[enc.Name].Value);
-            continue;
-          }
-          throw new InvalidOperationException("Encoding for variable " + enc.Name + " not recognized.");
-        }
-      } else {
-        var binaryEncoding = encoding as BinaryEncoding;
-        var handled = binaryEncoding != null;
-        if (binaryEncoding != null) binDict = new Dictionary<string, BinaryVector>(capacity: 1) {
-            {binaryEncoding.Name, (BinaryVector)scope.Variables[binaryEncoding.Name].Value}
-          };
-        var integerEncoding = encoding as IntegerEncoding;
-        handled = handled || integerEncoding != null;
-        if (integerEncoding != null) intDict = new Dictionary<string, IntegerVector>(capacity: 1) {
-            {integerEncoding.Name, (IntegerVector)scope.Variables[integerEncoding.Name].Value}
-          };
-        var realEncoding = encoding as RealEncoding;
-        handled = handled || realEncoding != null;
-        if (realEncoding != null) realDict = new Dictionary<string, RealVector>(capacity: 1) {
-            {realEncoding.Name, (RealVector)scope.Variables[realEncoding.Name].Value}
-          };
-        var permEncoding = encoding as PermutationEncoding;
-        handled = handled || permEncoding != null;
-        if (permEncoding != null) permDict = new Dictionary<string, Permutation>(capacity: 1) {
-            {permEncoding.ItemName, (Permutation)scope.Variables[permEncoding.ItemName].Value}
-          };
-        if (!handled) throw new InvalidOperationException("Encoding for variable " + encoding.Name + " not recognized.");
-      }
-      return new Individual(binDict, intDict, realDict, permDict);
-    }
-
-    internal static void Write(IScope scope, Individual vector) {
-      foreach (var param in vector.BinaryNames) {
-        if (scope.Variables.ContainsKey(param))
-          scope.Variables[param].Value = vector.BinaryVector(param);
-        else scope.Variables.Add(new Variable(param, vector.BinaryVector(param)));
-      }
-      foreach (var param in vector.IntegerNames) {
-        if (scope.Variables.ContainsKey(param))
-          scope.Variables[param].Value = vector.IntegerVector(param);
-        else scope.Variables.Add(new Variable(param, vector.IntegerVector(param)));
-      }
-      foreach (var param in vector.RealNames) {
-        if (scope.Variables.ContainsKey(param))
-          scope.Variables[param].Value = vector.RealVector(param);
-        else scope.Variables.Add(new Variable(param, vector.RealVector(param)));
-      }
-      foreach (var param in vector.PermutationNames) {
-        if (scope.Variables.ContainsKey(param))
-          scope.Variables[param].Value = vector.Permutation(param);
-        else scope.Variables.Add(new Variable(param, vector.Permutation(param)));
-      }
-    }
-  }
-}
Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/HeuristicLab.Problems.Programmable-3.3.csproj
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/HeuristicLab.Problems.Programmable-3.3.csproj	(revision 11595)
+++ branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/HeuristicLab.Problems.Programmable-3.3.csproj	(revision 11598)
@@ -127,4 +127,5 @@
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Encodings\MultiEncodingIndividual.cs" />
     <Compile Include="Encodings\PermutationEncoding.cs" />
     <Compile Include="Encodings\RealEncoding.cs" />
@@ -134,5 +135,4 @@
     <Compile Include="Encodings\Encoding.cs" />
     <Compile Include="Encodings\Individual.cs" />
-    <Compile Include="Helper.cs" />
     <Compile Include="Interfaces\IEncoding.cs" />
     <Compile Include="Interfaces\IMultiEncodingOperator.cs" />
Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Interfaces/IEncoding.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Interfaces/IEncoding.cs	(revision 11595)
+++ branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Interfaces/IEncoding.cs	(revision 11598)
@@ -32,4 +32,5 @@
     //event EventHandler ParameterConfigurationChanged;
 
+    Individual CreateIndividual(IScope scope);
     void ConfigureOperator(IOperator @operator);
     void ConfigureOperators(IEnumerable<IOperator> operators);
Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Operators/MultiObjectiveAnalyzer.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Operators/MultiObjectiveAnalyzer.cs	(revision 11595)
+++ branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Operators/MultiObjectiveAnalyzer.cs	(revision 11598)
@@ -50,5 +50,5 @@
       var definition = ProblemDefinitionParameter.ActualValue;
       if (definition == null) throw new InvalidOperationException("Problem definition is null.");
-      var config = EncodingParameter.ActualValue;
+      var encoding = EncodingParameter.ActualValue;
       var results = ResultsParameter.ActualValue;
 
@@ -57,6 +57,6 @@
         scopes = scopes.Select(x => (IEnumerable<IScope>)x.SubScopes).Aggregate((a, b) => a.Concat(b));
 
-      var vectors = scopes.Select(scope => Helper.Extract(scope, config)).ToArray();
-      definition.Analyze(vectors, QualitiesParameter.ActualValue.Select(x => x.ToArray()).ToArray(), results);
+      var individuals = scopes.Select(encoding.CreateIndividual).ToArray();
+      definition.Analyze(individuals, QualitiesParameter.ActualValue.Select(x => x.ToArray()).ToArray(), results);
       return base.Apply();
     }
Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Operators/MultiObjectiveEvaluator.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Operators/MultiObjectiveEvaluator.cs	(revision 11595)
+++ branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Operators/MultiObjectiveEvaluator.cs	(revision 11598)
@@ -68,7 +68,7 @@
       var definition = ProblemDefinitionParameter.ActualValue;
       if (definition == null) throw new InvalidOperationException("Problem definition is null.");
-      var config = EncodingParameter.ActualValue;
-      var vector = Helper.Extract(ExecutionContext.Scope, config);
-      QualitiesParameter.ActualValue = new DoubleArray(definition.Evaluate(random, vector));
+      var encoding = EncodingParameter.ActualValue;
+      var individual = encoding.CreateIndividual(ExecutionContext.Scope);
+      QualitiesParameter.ActualValue = new DoubleArray(definition.Evaluate(random, individual));
       return base.Apply();
     }
Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Operators/SingleObjectiveAnalyzer.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Operators/SingleObjectiveAnalyzer.cs	(revision 11595)
+++ branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Operators/SingleObjectiveAnalyzer.cs	(revision 11598)
@@ -50,5 +50,5 @@
       var definition = ProblemDefinitionParameter.ActualValue;
       if (definition == null) throw new InvalidOperationException("Problem definition is null");
-      var config = EncodingParameter.ActualValue;
+      var encoding = EncodingParameter.ActualValue;
       var results = ResultsParameter.ActualValue;
 
@@ -57,6 +57,6 @@
         scopes = scopes.Select(x => (IEnumerable<IScope>)x.SubScopes).Aggregate((a, b) => a.Concat(b));
 
-      var vectors = scopes.Select(scope => Helper.Extract(scope, config)).ToArray();
-      definition.Analyze(vectors, QualityParameter.ActualValue.Select(x => x.Value).ToArray(), results);
+      var individuals = scopes.Select(encoding.CreateIndividual).ToArray();
+      definition.Analyze(individuals, QualityParameter.ActualValue.Select(x => x.Value).ToArray(), results);
       return base.Apply();
     }
Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Operators/SingleObjectiveEvaluator.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Operators/SingleObjectiveEvaluator.cs	(revision 11595)
+++ branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Operators/SingleObjectiveEvaluator.cs	(revision 11598)
@@ -68,7 +68,7 @@
       var definition = ProblemDefinitionParameter.ActualValue;
       if (definition == null) throw new InvalidOperationException("Problem definition is null.");
-      var config = EncodingParameter.ActualValue;
-      var vector = Helper.Extract(ExecutionContext.Scope, config);
-      QualityParameter.ActualValue = new DoubleValue(definition.Evaluate(random, vector));
+      var encoding = EncodingParameter.ActualValue;
+      var individual = encoding.CreateIndividual(ExecutionContext.Scope);
+      QualityParameter.ActualValue = new DoubleValue(definition.Evaluate(random, individual));
       return base.Apply();
     }
Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Operators/SingleObjectiveImprover.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Operators/SingleObjectiveImprover.cs	(revision 11595)
+++ branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Operators/SingleObjectiveImprover.cs	(revision 11598)
@@ -75,6 +75,6 @@
       var maxAttempts = ImprovementAttemptsParameter.ActualValue.Value;
       var sampleSize = SampleSizeParameter.ActualValue.Value;
-      var vector = Helper.Extract(ExecutionContext.Scope, encoding);
-      var quality = QualityParameter.ActualValue == null ? definition.Evaluate(random, vector) : QualityParameter.ActualValue.Value;
+      var individual = encoding.CreateIndividual(ExecutionContext.Scope);
+      var quality = QualityParameter.ActualValue == null ? definition.Evaluate(random, individual) : QualityParameter.ActualValue.Value;
 
       var count = 0;
@@ -82,5 +82,5 @@
         Individual best = null;
         var bestQuality = quality;
-        foreach (var neighbor in definition.GetNeighbors(random, vector).Take(sampleSize)) {
+        foreach (var neighbor in definition.GetNeighbors(random, individual).Take(sampleSize)) {
           var q = definition.Evaluate(random, neighbor);
           count++;
@@ -90,10 +90,10 @@
         }
         if (best == null) break;
-        vector = best;
+        individual = best;
         quality = bestQuality;
       }
 
       LocalEvaluatedSolutionsParameter.ActualValue = new IntValue(count);
-      Helper.Write(ExecutionContext.Scope, vector);
+      individual.Copy(ExecutionContext.Scope);
       return base.Apply();
     }
Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Operators/SingleObjectiveMoveEvaluator.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Operators/SingleObjectiveMoveEvaluator.cs	(revision 11595)
+++ branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Operators/SingleObjectiveMoveEvaluator.cs	(revision 11598)
@@ -73,7 +73,7 @@
       var definition = ProblemDefinitionParameter.ActualValue;
       if (definition == null) throw new InvalidOperationException("Problem definition is null.");
-      var config = EncodingParameter.ActualValue;
-      var vector = Helper.Extract(ExecutionContext.Scope, config);
-      MoveQualityParameter.ActualValue = new DoubleValue(definition.Evaluate(random, vector));
+      var encoding = EncodingParameter.ActualValue;
+      var individual = encoding.CreateIndividual(ExecutionContext.Scope);
+      MoveQualityParameter.ActualValue = new DoubleValue(definition.Evaluate(random, individual));
       return base.InstrumentedApply();
     }
Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Operators/SingleObjectiveMoveGenerator.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Operators/SingleObjectiveMoveGenerator.cs	(revision 11595)
+++ branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Operators/SingleObjectiveMoveGenerator.cs	(revision 11598)
@@ -73,11 +73,11 @@
       var sampleSize = SampleSizeParameter.ActualValue.Value;
       var encoding = EncodingParameter.ActualValue;
-      var vector = Helper.Extract(ExecutionContext.Scope, encoding);
-      var nbhood = definition.GetNeighbors(random, vector).Take(sampleSize).ToList();
+      var individual = encoding.CreateIndividual(ExecutionContext.Scope);
+      var nbhood = definition.GetNeighbors(random, individual).Take(sampleSize).ToList();
 
       var moveScopes = new Scope[nbhood.Count];
       for (int i = 0; i < moveScopes.Length; i++) {
         moveScopes[i] = new Scope(i.ToString(CultureInfo.InvariantCulture.NumberFormat));
-        Helper.Write(moveScopes[i], nbhood[i]);
+        nbhood[i].Copy(moveScopes[i]);
       }
       ExecutionContext.Scope.SubScopes.AddRange(moveScopes);
Index: branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Operators/SingleObjectiveMoveMaker.cs
===================================================================
--- branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Operators/SingleObjectiveMoveMaker.cs	(revision 11595)
+++ branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Operators/SingleObjectiveMoveMaker.cs	(revision 11598)
@@ -62,5 +62,6 @@
 
       var encoding = EncodingParameter.ActualValue;
-      Helper.Write(ExecutionContext.Scope.Parent, Helper.Extract(ExecutionContext.Scope, encoding));
+      var individual = encoding.CreateIndividual(ExecutionContext.Scope);
+      individual.Copy(ExecutionContext.Scope.Parent);
 
       if (QualityParameter.ActualValue == null) QualityParameter.ActualValue = new DoubleValue(MoveQualityParameter.ActualValue.Value);
