Context Navigation

HeuristicLab.FixedOperators

Timestamp:

07/02/09 12:25:32 (16 years ago)

Author:

dtraxing

Message:

Algorithm continuation bug fixed. (ticket #580)

Location:

trunk/sources/HeuristicLab.FixedOperators/3.2

Files:

-                      r2120
+                      r2129
       IScope s;
       IScope s2;
+      bool loopSkipped = true;
+      bool running = false;
       DoubleData selectionPressure = null;
 …
               Execute(wofc, s2);
               Execute(sr, s2);
+              loopSkipped = false;
+            } // foreach
+            } // foreach
+            subscopeNr.Data = 0;
+            // if for loop skipped, we had to add skiped operations
+            // to execution pointer.
+            if (loopSkipped)
+              executionPointer += 5;
             Execute(sorter, s);
             ////// END Create Children //////
+          } while (os.Execute(scope) != null);
+            running = ExecuteFirstOperator(os, scope);
+            if (running) subscopeNr.Data = 0;
+          } while (running);
           DoReplacement(scope);
 …
             break;
+          subscopeNr.Data = 0;
           ResetExecutionPointer();
         } // for i generations

-                      r2120
+                      r2129
     } // SetRegion
+    /// <summary>
+    /// Executes only the operator op, suboperator are wont be executed.
+    /// </summary>
+    /// <param name="op">Operator to execute.</param>
+    /// <param name="scope">Scope on which operator is executed.</param>
+    /// <returns>True, if operator has suboperators after execution. </returns>
+    protected virtual bool ExecuteFirstOperator(IOperator op, IScope scope){
+      bool suboperatorsExist = false;
+      if (!IsExecuted()) {
+        suboperatorsExist = op.Execute(scope) != null;
+        persistedExecutionPointer.Data++;
+      } // if not executed
+      executionPointer++;
+      if (Canceled)
+        throw new CancelException();
+      return suboperatorsExist;
+    } // ExecuteFirstOperator
     protected virtual void Execute(IOperator op, IScope scope) {
       if (!IsExecuted()) {
 …
+        }
       } else {
+        executionStack = new Stack<IOperation>(persistedOperations);
+        executionStack = new Stack<IOperation>(persistedOperations);
+        persistedOperations.Clear();
+      }
 …
     private void SaveExecutionStack(Stack<IOperation> stack) {
       persistedOperations = new ItemList<IOperation>();
+      persistedOperations.Clear();
       persistedOperations.AddRange(stack.ToArray());
     } // SaveExecutionStack

-                      r2120
+                      r2129
       IScope s;
       IScope s2;
+      bool loopSkipped = true;
+      tempExePointer = new int[10];
+      tempPersExePointer = new int[10];
       try {
         for (; nrOfGenerations.Data < maxGenerations.Data; nrOfGenerations.Data++) {
 …
             Execute(sr, s2);
             Execute(counter, s2);
+            loopSkipped = false;
           } // foreach
+          // if for loop skipped, we had to add skiped operations
+          // to execution pointer.
+          if (loopSkipped)
+            executionPointer += 5;
           Execute(sorter, s);
 …
         return new AtomicOperation(this, scope);
+      }
+      catch (Exception ex) {
+        ex.ToString();
+      }
       return null;

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