added example 4.2_17

4.2_17.py

+#!/usr/bin/env python
+# encoding=utf-8 (pep 0263)
+
+from linked_lists import LinkedList, Cons, Nil
+from best_search import best_search
+
+biggest = 99
+start = (LinkedList([("t1", 4), ("t2", 2), ("t3", 2), ("t4", 20),
+                     ("t5", 20), ("t6", 11), ("t7", 11)]),
+         LinkedList([("idle", 0), ("idle", 0), ("idle", 0)]), 0)
+
+precedence = dict(
+    t1=["t4", "t5"],
+    t2=["t4", "t5"],
+    t3=["t5", "t6", "t7"])
+
+def goes_before(T1, T2):
+    if T1 in precedence:
+        if T2 in precedence[T1]:
+            return True
+        for T in precedence[T1]:
+            if goes_before(T, T2):
+                return True
+    return False
+
+def is_goal(state):
+    waiting, _, _ = state
+    return waiting == Nil
+
+def move_anyYC(state):
+    tasks1, active, fin1 = state
+    _, f = active.head
+    active1 = active.tail
+    for (task, d), tasks2 in del1_anyX(tasks1):
+        permissible = True
+        for t, _ in member_anyX(tasks2):
+            if goes_before(t, task):
+                permissible = False
+        for t1, f1 in member_anyX(active1):
+            if f < f1 and goes_before(t1, task):
+                permissible = False
+        if not permissible:
+            continue
+        active2, fin2 = insert((task, f+d), active1, fin1)
+        cost = fin2 - fin1
+        yield ((tasks2, active2, fin2), cost)
+    for active3 in insert_idle(f, active1):
+        yield ((tasks1, active3, fin1), 0)
+
+def insert(task, active, f1):
+    s, a = task
+    if active == Nil:
+        return (Cons((s, a), Nil), a)
+    t, b = active.head
+    l = active.tail
+    if a <= b:
+        return (Cons((s, a), active), f1)
+    l1, f2 = insert((s, a), l, f1)
+    return (Cons((t, b), l1), f2)
+
+def insert_idle(a, active):
+    if active == Nil:
+        return
+    t, b = active.head
+    l = active.tail
+    if a < b:
+        yield Cons(("idle", b), active)
+    else:
+        for l1 in insert_idle(a, l):
+            yield Cons((t, b), l1)
+
+def h(state):
+    waiting, active, fin = state
+    waiting_time = 0
+    for _, execution_time in waiting:
+        waiting_time = waiting_time + execution_time
+    active_time = 0
+    cpu_number = 0
+    for _, finishing_time in active:
+        active_time = active_time + finishing_time
+        cpu_number = cpu_number + 1
+    finall = (waiting_time + active_time) / cpu_number
+    return max(finall - fin, 0)
+
+def del1_anyX(ys):
+    if ys == Nil:
+        return
+    yield (ys.head, ys.tail)
+    for (z, zs) in del1_anyX(ys.tail):
+        yield (z, Cons(ys.head, zs))
+
+def member_anyX(xs):
+    if xs == Nil:
+        return
+    yield xs.head
+    for x in member_anyX(xs.tail):
+        yield x
+
+def writelist(xs):
+    writelist_(xs, 1)
+
+def writelist_(xs, i):
+    if xs != Nil:
+        print("%d: %s" % (i, xs.head))
+        writelist_(xs.tail, i+1)
+
+# demonstracni vypis
+if __name__ == "__main__":
+    print("Rozvrh prace procesoru, algoritmus A*\n")
+    print("Pocatecni stav: %s" % (start,))
+
+    print("\nNalezene reseni:")
+    solution, searched, cost_ = next(best_search(start, biggest, is_goal, move_anyYC, h))
+    print("Prohledano %d stavu, vysledne reseni ma cenu %d." % (searched, cost_))
+    writelist(solution.reverse())