Changeset 11814 for branches/ProgrammableProblem/HeuristicLab.Problems.Programmable

Timestamp:

01/21/15 13:10:24 (10 years ago)

Author:

mkommend

Message:

#2174: Renamed scriptable to programmable problem.

Location:

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3

Files:

• HeuristicLab.Problems.Programmable-3.3.csproj (modified) (2 diffs)
• New/BasicProblem.cs (modified) (4 diffs)
• New/MultiObjectiveBasicProblem.cs (modified) (1 diff)
• New/MultiObjectiveProgrammableProblem.cs (moved) (moved from branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/New/MultiObjectiveScriptableProblem.cs) (3 diffs)
• New/OneMaxNew.cs (modified) (1 diff)
• New/SingleObjectiveBasicProblem.cs (modified) (1 diff)
• New/SingleObjectiveProgrammableProblem.cs (moved) (moved from branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/New/SingleObjectiveScriptableProblem.cs) (3 diffs)

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/HeuristicLab.Problems.Programmable-3.3.csproj

@@ -150 +150 @@
     <Compile Include="New\BasicProblem.cs" />
     <Compile Include="New\MultiObjectiveBasicProblem.cs" />
-    <Compile Include="New\MultiObjectiveScriptableProblem.cs" />
+    <Compile Include="New\MultiObjectiveProgrammableProblem.cs" />
     <Compile Include="New\Scripts\Templates\CompiledMultiObjectiveProblemDefinition.cs" />
     <Compile Include="New\Scripts\Templates\CompiledSingleObjectiveProblemDefinition.cs" />
@@ -176 +176 @@
     <Compile Include="New\OneMaxNew.cs" />
     <Compile Include="New\SingleObjectiveBasicProblem.cs" />
-    <Compile Include="New\SingleObjectiveScriptableProblem.cs" />
+    <Compile Include="New\SingleObjectiveProgrammableProblem.cs" />
     <Compile Include="New\Scripts\MultiObjectiveProblemDefinitionScript.cs" />
     <Compile Include="New\Scripts\SingleObjectiveProblemDefinitionScript.cs" />

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/New/BasicProblem.cs

@@ -31 +31 @@
 namespace HeuristicLab.Problems.Programmable {
   [StorableClass]
-  public abstract class ProgrammableProblem<TEncoding, TEvaluator> : HeuristicOptimizationProblem<TEvaluator, ISolutionCreator>, IProblemDefinition, IStorableContent
+  public abstract class BasicProblem<TEncoding, TEvaluator> : HeuristicOptimizationProblem<TEvaluator, ISolutionCreator>, IProblemDefinition, IStorableContent
     where TEncoding : class, IEncoding
     where TEvaluator : class, IEvaluator {
@@ -64 +64 @@
     }
 
-    protected ProgrammableProblem()
+    protected BasicProblem()
       : base() {
       Parameters.Add(new ValueParameter<TEncoding>("Encoding", "Describes the configuration of the encoding, what the variables are called, what type they are and their bounds if any."));
@@ -71 +71 @@
     }
 
-    protected ProgrammableProblem(ProgrammableProblem<TEncoding, TEvaluator> original, Cloner cloner)
+    protected BasicProblem(BasicProblem<TEncoding, TEvaluator> original, Cloner cloner)
       : base(original, cloner) {
       oldEncoding = cloner.Clone(original.oldEncoding);
@@ -78 +78 @@
 
     [StorableConstructor]
-    protected ProgrammableProblem(bool deserializing) : base(deserializing) { }
+    protected BasicProblem(bool deserializing) : base(deserializing) { }
     [StorableHook(HookType.AfterDeserialization)]
     private void AfterDeserialization() {

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/New/MultiObjectiveBasicProblem.cs

@@ -30 +30 @@
 namespace HeuristicLab.Problems.Programmable {
   [StorableClass]
-  public abstract class MultiObjectiveProgrammableProblem<TEncoding> : ProgrammableProblem<TEncoding, MultiObjectiveEvaluator>, IMultiObjectiveHeuristicOptimizationProblem, IMultiObjectiveProblemDefinition
+  public abstract class MultiObjectiveBasicProblem<TEncoding> : BasicProblem<TEncoding, MultiObjectiveEvaluator>, IMultiObjectiveHeuristicOptimizationProblem, IMultiObjectiveProblemDefinition
   where TEncoding : class, IEncoding {
     [StorableConstructor]
-    protected MultiObjectiveProgrammableProblem(bool deserializing) : base(deserializing) { }
+    protected MultiObjectiveBasicProblem(bool deserializing) : base(deserializing) { }
 
-    protected MultiObjectiveProgrammableProblem(MultiObjectiveProgrammableProblem<TEncoding> original, Cloner cloner)
+    protected MultiObjectiveBasicProblem(MultiObjectiveBasicProblem<TEncoding> original, Cloner cloner)
       : base(original, cloner) {
       ParameterizeOperators();
     }
 
-    protected MultiObjectiveProgrammableProblem()
+    protected MultiObjectiveBasicProblem()
       : base() {
       Parameters.Add(new ValueParameter<BoolArray>("Maximization", "Set to false if the problem should be minimized.", new BoolArray()));

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/New/MultiObjectiveProgrammableProblem.cs

@@ -28 +28 @@
 
 namespace HeuristicLab.Problems.Programmable {
-  [Item("Scriptable Problem (multi-objective)", "Represents a multi-objective problem that can be scripted.")]
+  [Item("Programmable Problem (multi-objective)", "Represents a multi-objective problem that can be programmed with a script.")]
   [Creatable("1 Test")]
   [StorableClass]
-  public sealed class MultiObjectiveScriptableProblem : MultiObjectiveProgrammableProblem<IEncoding> {
+  public sealed class MultiObjectiveProgrammableProblem : MultiObjectiveBasicProblem<IEncoding> {
 
     private FixedValueParameter<MultiObjectiveProblemDefinitionScript> MultiObjectiveProblemScriptParameter {
@@ -45 +45 @@
     }
 
-    private MultiObjectiveScriptableProblem(MultiObjectiveScriptableProblem original, Cloner cloner)
+    private MultiObjectiveProgrammableProblem(MultiObjectiveProgrammableProblem original, Cloner cloner)
       : base(original, cloner) {
       RegisterEvents();
@@ -55 +55 @@
       }
     }
-    public override IDeepCloneable Clone(Cloner cloner) { return new MultiObjectiveScriptableProblem(this, cloner); }
+    public override IDeepCloneable Clone(Cloner cloner) { return new MultiObjectiveProgrammableProblem(this, cloner); }
 
 
     [StorableConstructor]
-    private MultiObjectiveScriptableProblem(bool deserializing) : base(deserializing) { }
+    private MultiObjectiveProgrammableProblem(bool deserializing) : base(deserializing) { }
 
-    public MultiObjectiveScriptableProblem()
+    public MultiObjectiveProgrammableProblem()
       : base() {
       Parameters.Add(new FixedValueParameter<MultiObjectiveProblemDefinitionScript>("ProblemScript", "Defines the problem.", new MultiObjectiveProblemDefinitionScript() { Name = Name }));

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/New/OneMaxNew.cs

@@ -32 +32 @@
   [Creatable("1 Test")]
   [StorableClass]
-  public class OneMaxNew : SingleObjectiveProgrammableProblem<BinaryEncoding> {
+  public class OneMaxNew : SingleObjectiveBasicProblem<BinaryEncoding> {
     public override bool Maximization {
       get { return true; }

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/New/SingleObjectiveBasicProblem.cs

@@ -32 +32 @@
 namespace HeuristicLab.Problems.Programmable {
   [StorableClass]
-  public abstract class SingleObjectiveProgrammableProblem<TEncoding> : ProgrammableProblem<TEncoding, SingleObjectiveEvaluator>,
+  public abstract class SingleObjectiveBasicProblem<TEncoding> : BasicProblem<TEncoding, SingleObjectiveEvaluator>,
     ISingleObjectiveProblemDefinition, ISingleObjectiveHeuristicOptimizationProblem
   where TEncoding : class, IEncoding {
     [StorableConstructor]
-    protected SingleObjectiveProgrammableProblem(bool deserializing) : base(deserializing) { }
+    protected SingleObjectiveBasicProblem(bool deserializing) : base(deserializing) { }
 
-    protected SingleObjectiveProgrammableProblem(SingleObjectiveProgrammableProblem<TEncoding> original, Cloner cloner)
+    protected SingleObjectiveBasicProblem(SingleObjectiveBasicProblem<TEncoding> original, Cloner cloner)
       : base(original, cloner) {
       ParameterizeOperators();
     }
 
-    protected SingleObjectiveProgrammableProblem()
+    protected SingleObjectiveBasicProblem()
       : base() {
       Parameters.Add(new FixedValueParameter<BoolValue>("Maximization", "Set to false if the problem should be minimized.", new BoolValue()));

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/New/SingleObjectiveProgrammableProblem.cs

@@ -29 +29 @@
 
 namespace HeuristicLab.Problems.Programmable {
-  [Item("Scriptable Problem (single-objective)", "Represents a single-objective problem that can be scripted.")]
+  [Item("Programmable Problem (single-objective)", "Represents a single-objective problem that can be programmed with a script.")]
   [Creatable("1 Test")]
   [StorableClass]
-  public sealed class SingleObjectiveScriptableProblem : SingleObjectiveProgrammableProblem<IEncoding> {
+  public sealed class SingleObjectiveProgrammableProblem : SingleObjectiveBasicProblem<IEncoding> {
 
     private FixedValueParameter<SingleObjectiveProblemDefinitionScript> SingleObjectiveProblemScriptParameter {
@@ -46 +46 @@
     }
 
-    private SingleObjectiveScriptableProblem(SingleObjectiveScriptableProblem original, Cloner cloner)
+    private SingleObjectiveProgrammableProblem(SingleObjectiveProgrammableProblem original, Cloner cloner)
       : base(original, cloner) {
       RegisterEvents();
@@ -56 +56 @@
       }
     }
-    public override IDeepCloneable Clone(Cloner cloner) { return new SingleObjectiveScriptableProblem(this, cloner); }
+    public override IDeepCloneable Clone(Cloner cloner) { return new SingleObjectiveProgrammableProblem(this, cloner); }
 
 
     [StorableConstructor]
-    private SingleObjectiveScriptableProblem(bool deserializing) : base(deserializing) { }
+    private SingleObjectiveProgrammableProblem(bool deserializing) : base(deserializing) { }
 
-    public SingleObjectiveScriptableProblem()
+    public SingleObjectiveProgrammableProblem()
       : base() {
       Parameters.Add(new FixedValueParameter<SingleObjectiveProblemDefinitionScript>("ProblemScript", "Defines the problem.", new SingleObjectiveProblemDefinitionScript() { Name = Name }));