Ejemplo n.º 1
0
 def stream_write():
     cmd_title('Thread starting in WRITE mode', newlines=False)
     global n_val
     while n_val < MAX_ITERATIONS:
         time.sleep(ADD_INTERVAL)
         data_stream.add(n_val)
         n_val += 1
Ejemplo n.º 2
0
 def stream_write():
     cmd_title('Thread starting in WRITE mode', newlines=False)
     global n_val
     while n_val < MAX_ITERATIONS:
         time.sleep(ADD_INTERVAL)
         data_stream.add(n_val)
         n_val += 1
Ejemplo n.º 3
0
    def evaluate(self, value, fromkey=None):
        """Evaluate a value against the tree.

        Evaluations start from the top if no fromkey is specified.
        A sum is returned for the total of all resulting path evaluations."""
        total = 0

        def _eval(node):
            print('func', node['func'](value))
            res = node['func'](value)
            # Update based on evaluation function results.
            path = 0 if res else 1
            total = node['next'][path]
            print('took path: {} with val {}'.format(path, value))
            return total

        for k, v in self.vertices.items():
            divider()
            cmd_title('NODE: {}'.format(k))
            node = self.vertices[k]['fork']
            if fromkey is not None:
                if k == fromkey:
                    total += _eval(node)
                    print('new total: ', total)
                else:
                    continue
            else:
                total += _eval(node)
                print('new total: ', total)
        print('FINAL value ', total)
Ejemplo n.º 4
0
    def evaluate(self, value, fromkey=None):
        """Evaluate a value against the tree.

        Evaluations start from the top if no fromkey is specified.
        A sum is returned for the total of all resulting path evaluations."""
        total = 0

        def _eval(node):
            print('func', node['func'](value))
            res = node['func'](value)
            # Update based on evaluation function results.
            path = 0 if res else 1
            total = node['next'][path]
            print('took path: {} with val {}'.format(path, value))
            return total

        for k, v in self.vertices.items():
            divider()
            cmd_title('NODE: {}'.format(k))
            node = self.vertices[k]['fork']
            if fromkey is not None:
                if k == fromkey:
                    total += _eval(node)
                    print('new total: ', total)
                else:
                    continue
            else:
                total += _eval(node)
                print('new total: ', total)
        print('FINAL value ', total)
Ejemplo n.º 5
0
 def stream_read():
     cmd_title('Thread starting in READ mode', newlines=False)
     # Force an initial warm up so it doesn't terminate early.
     time.sleep(0.2)
     # Here (in the while loop), we use a different termination strategy
     # so we can simulate draining the stream until all items are clear.
     while data_stream.not_empty():
         time.sleep(READ_INTERVAL)
         data_stream.read()
Ejemplo n.º 6
0
    def __init__(self, program=None):
        """Setup initial conditions

        Function argument reference [From Wikipedia]
        ------------------------------------------------------------------
        Register #2 contains "2", (initially)
        Registers #0, #1 and #3 are empty (contain "0").
        Register #0 remains unchanged throughout calculations
            because it is used for the unconditional jump.
        Register #1 is a scratch pad.

        4 registers, plus 'scratch pad register'"

        `z` = [z]ero aka, jump register (0)
        `s` = [s]cratch register (1)
        `c` = [c]urrent register (2)
        `d` = [d]estination register (3)

        Example instruction set used for the initial program.
        ------------------------------------------------------------------
        1   2   3   4   5   6   7   8   9   10  <- Instruction (address)
        JZ  DEC INC INC JZ  JZ  DEC INC JZ  H   <- Instruction
        2   2   3   1   0   1   1   2   0       <- Register
        6               1   10          6       <- Jump-to instruction

        """
        self.DEBUG = True
        # Time delay, only used for effect in demonstration.
        self.DELAY = 0
        if self.DEBUG:
            cmd_title('Prepping')
        if program is None:
            self.program = {
                1: {'code': 'JZ', 'fn': self.jz, 'reg': 2, 'jump': 6},
                2: {'code': 'DEC', 'fn': self.dec, 'reg': 2, 'jump': None},
                3: {'code': 'INC', 'fn': self.inc, 'reg': 3, 'jump': None},
                4: {'code': 'INC', 'fn': self.inc, 'reg': 1, 'jump': None},
                5: {'code': 'JZ', 'fn': self.jz, 'reg': 0, 'jump': 1},
                6: {'code': 'JZ', 'fn': self.jz, 'reg': 1, 'jump': 10},
                7: {'code': 'DEC', 'fn': self.dec, 'reg': 1, 'jump': None},
                8: {'code': 'INC', 'fn': self.inc, 'reg': 2, 'jump': 0},
                9: {'code': 'JZ', 'fn': self.jz, 'reg': 0, 'jump': 6},
                10: {'code': 'H', 'fn': self.halt, 'reg': None, 'jump': None},
            }
        else:
            self.program = program
        self.halted = False
        # Internal tracking of how many steps have been run - has no bearing
        # on the actual control flow or outcome of the program.
        self._step = 0
        self.default_register_count = 2
        self.curr_register = self.default_register_count
        # The program begins with instruction 1
        # (aka index 1 -- if the index is off, the program
        # will not run correctly, and may raise KeyErrors).
        self.curr_instruction = 1
        self.registers = {'z': 0, 's': 0, 'c': 2, 'd': 0, '': 0}
Ejemplo n.º 7
0
 def stream_read():
     cmd_title('Thread starting in READ mode', newlines=False)
     # Force an initial warm up so it doesn't terminate early.
     time.sleep(0.2)
     # Here (in the while loop), we use a different termination strategy
     # so we can simulate draining the stream until all items are clear.
     while data_stream.not_empty():
         time.sleep(READ_INTERVAL)
         data_stream.read()
Ejemplo n.º 8
0
 def read(self):
     try:
         end = self.items.pop()
     except IndexError:
         cmd_title('All items have been read.')
         return None
     if DEBUG:
         print('Reading new item from stream... {}\n'.format(end))
         print('[CURRENT STREAM] {}\n'.format(' -- '.join(self.items)))
     self.total_read += 1
     return end
Ejemplo n.º 9
0
 def read(self):
     try:
         end = self.items.pop()
     except IndexError:
         cmd_title('All items have been read.')
         return None
     if DEBUG:
         print('Reading new item from stream... {}\n'.format(end))
         print('[CURRENT STREAM] {}\n'.format(' -- '.join(self.items)))
     self.total_read += 1
     return end
Ejemplo n.º 10
0
 def halt(self):
     """Whether or not this machine actually does halt,
     this method must be called to prevent stack overflow
     (for infinite examples)."""
     cmd_title('HALTING')
     self.running = False
     # Reset any state
     self.tape = None
     self.transitions = None
     self.current_state = None
     self.tape_index = None
     self.result = ''
Ejemplo n.º 11
0
 def halt(self):
     """Whether or not this machine actually does halt,
     this method must be called to prevent stack overflow
     (for infinite examples)."""
     cmd_title('HALTING')
     self.running = False
     # Reset any state
     self.tape = None
     self.transitions = None
     self.current_state = None
     self.tape_index = None
     self.result = ''
Ejemplo n.º 12
0
 def halt(self):
     if self.DEBUG:
         cmd_title('Halting')
     self.halted = True
     # From Wikipedia:
     # The program HALTs with the contents of register #2
     # at its original count and the contents of register #3
     # equal to the original contents of register #2...
     cnt = self.registers['c']
     # Update register three
     self.registers['d'] = cnt
     # Reset register 2 after transferring contents to register #3
     self.registers['c'] = self.default_register_count
     if self.DEBUG:
         print('Final contents of all registers: {}'.format(self.registers))
Ejemplo n.º 13
0
def print_nodes(node):
    def _fmt(node):
        return '[<{}.{}>] {divider} '.format(
            node.title,
            node.cargo,
            divider='....' if node.next is not None else '') \
            if node is not None else ''

    path, count = '', 0
    cmd_title('Printing Nodes')
    # Follows a node along it's next target, until next is None.
    while node is not None:
        path += _fmt(node)
        count += 1
        node = node.next
    prnt('Linked List\n', path, newlines=False)
Ejemplo n.º 14
0
 def _run(self):
     cmd_title('STARTING VISUALIZATION')
     while self.running:
         for _ in range(self.max_states):
             # Sleep so that each step is delayed, for effect.
             time.sleep(self.DELAY)
             if self.DEBUG:
                 print('Old state {}'.format(self.current_state))
             self.transition()
             if self.DEBUG:
                 print('New state {}'.format(self.current_state))
                 self._show_program()
             self._get_tape_visualization()
         if self.DEBUG:
             print('Ending with state: {}'.format(self.current_state))
         # Eventually time out, since it can't *really* run forever.
         self.halt()
Ejemplo n.º 15
0
 def _run(self):
     cmd_title('STARTING VISUALIZATION')
     while self.running:
         for _ in range(self.max_states):
             # Sleep so that each step is delayed, for effect.
             time.sleep(self.DELAY)
             if self.DEBUG:
                 print('Old state {}'.format(self.current_state))
             self.transition()
             if self.DEBUG:
                 print('New state {}'.format(self.current_state))
                 self._show_program()
             self._get_tape_visualization()
         if self.DEBUG:
             print('Ending with state: {}'.format(self.current_state))
         # Eventually time out, since it can't *really* run forever.
         self.halt()
Ejemplo n.º 16
0
Archivo: tree.py Proyecto: kvnlnt/MoAL
            9: {'edges': [], 'parent': 5},
            10: {'edges': [11, 12], 'parent': 6},
            11: {'edges': [], 'parent': 10},
            12: {'edges': [], 'parent': 10},
        }

        tree = Tree(graph)
        tree[9] = {'edges': [], 'parent': 5}
        prnt('Tree, subclassed from graph', tree)
        tree.render_tree('tree-example.png')
        divider(newline=False)

        for n in range(len(graph)):
            print('Testing get: {} ... {}'.format(n, graph[n]))

        cmd_title('Testing: children_count', newlines=False)
        assert tree.children_count(1) == 2
        assert tree.children_count(2) == 1
        assert tree.children_count(3) == 2
        assert tree.children_count(9) == 0

        # Correctness testing

        cmd_title('Testing: get_root', newlines=False)
        assert tree.get_root().get('val') == 'i am the root!'
        tree[0].update({'val': 'i am still the root!'})
        assert tree.get_root().get('val') == 'i am still the root!'

        cmd_title('Testing: has_sibling', newlines=False)
        assert not tree.has_sibling(7, sibling_name=9)
        assert tree.has_sibling(8, sibling_name=9)
Ejemplo n.º 17
0
 def _show_program(self):
     cmd_title('PROGRAM')
     print_simple('States list', self.states)
     print_simple('Transitions', self.transitions)
     print_simple('Tape', self.tape)
Ejemplo n.º 18
0
        of only being able to use the preset register, for copy/updates."""
        self.registers[reg] = val


if __name__ == '__main__':
    with Section('Counter Machines'):
        classes = [
            SheperdsonSturgis, Minsky, Program, Abacus, Lambek,
            Successor, SuccessorRAM, ElgotRobinsonRASP,
        ]

        for klass in classes:
            prnt('Testing machine...', repr(klass))
            klass().run()

            cmd_title('New program')
            singleton = CounterMachine()
            singleton._generate_program()
            ppr(singleton.program)
            try:
                singleton.run()
            except TypeError:
                print('Inoperable program was generated :(')
            except NotImplementedError:
                print_error('Not implemented: {}'.format(klass))
            finally:
                singleton.halt()

        print_h2('Random Access Machine (multi-register counter machine)')
        ram = RandomAccessMachine()
        ram.run()
Ejemplo n.º 19
0
 def activate(self):
     cmd_title('ACTIVATING')
     self.running = True
Ejemplo n.º 20
0
 def halt(self):
     if self.DEBUG:
         cmd_title('Halting')
     self.halted = True
Ejemplo n.º 21
0

class JonesIOne(PointerMachine):
    pass


class JonesITwo(PointerMachine):
    pass


if __name__ == '__main__':
    with Section('Pointer Machines'):
        classes = [
            KolmogorovUspenskii,
            KnuthLinking,
            SchonhageStorageModification,
            AtomisticPureLISP,
            AtomisticFullLISP,
            GeneralAtomistic,
            JonesIOne,
            JonesITwo,
        ]

        for _class in classes:
            # Decouple abstract class / stubbing from demo by suppression.
            try:
                cmd_title('Testing machine... {}'.format(repr(_class)))
                _class().run()
            except NotImplementedError:
                continue
Ejemplo n.º 22
0
 def halt(self):
     if self.DEBUG:
         cmd_title('Halting')
     self.halted = True
Ejemplo n.º 23
0
class GeneralAtomistic(PointerMachine):
    pass


class JonesIOne(PointerMachine):
    pass


class JonesITwo(PointerMachine):
    pass


if __name__ == '__main__':
    with Section('Pointer Machines'):
        classes = [
            KolmogorovUspenskii,
            KnuthLinking,
            SchonhageStorageModification,
            AtomisticPureLISP, AtomisticFullLISP,
            GeneralAtomistic,
            JonesIOne, JonesITwo,
        ]

        for _class in classes:
            # Decouple abstract class / stubbing from demo by suppression.
            try:
                cmd_title('Testing machine... {}'.format(repr(_class)))
                _class().run()
            except NotImplementedError:
                continue
Ejemplo n.º 24
0
                'edges': [],
                'parent': 1
            },
            4: {
                'edges': [],
                'parent': 2
            },
            5: {
                'edges': [],
                'parent': 2
            },
        }
        btree = BinaryTree(data)
        print(btree)

        print_h4('Binary trees',
                 desc=('They can have no more than two nodes, '
                       'so adding new edges that do not conform'
                       ' should throw an error.'))
        try:
            btree[6] = {'edges': [7, 8, 9], 'parent': 3}
        except InvalidChildNodeCount:
            cmd_title('Error called successfully', newlines=False)

        bst = NaiveBinarySearchTree(data)
        print(bst)

        bst.add_child(5, 6)
        bst.add_siblings(5, [10, 11])
        print(bst)
Ejemplo n.º 25
0
Archivo: tree.py Proyecto: terry07/MoAL
            9: {'edges': [], 'parent': 5},
            10: {'edges': [11, 12], 'parent': 6},
            11: {'edges': [], 'parent': 10},
            12: {'edges': [], 'parent': 10},
        }

        tree = Tree(graph)
        tree[9] = {'edges': [], 'parent': 5}
        prnt('Tree, subclassed from graph', tree)
        tree.render_tree('tree-example.png')
        divider(newline=False)

        for n in range(len(graph)):
            print('Testing get: {} ... {}'.format(n, graph[n]))

        cmd_title('Testing: children_count', newlines=False)
        assert tree.children_count(1) == 2
        assert tree.children_count(2) == 1
        assert tree.children_count(3) == 2
        assert tree.children_count(9) == 0

        # Correctness testing

        cmd_title('Testing: get_root', newlines=False)
        assert tree.get_root().get('val') == 'i am the root!'
        tree[0].update({'val': 'i am still the root!'})
        assert tree.get_root().get('val') == 'i am still the root!'

        cmd_title('Testing: has_sibling', newlines=False)
        assert not tree.has_sibling(7, sibling_name=9)
        assert tree.has_sibling(8, sibling_name=9)
Ejemplo n.º 26
0
        data = {
            0: {"edges": [1, 2], "is_root": True},
            1: {"edges": [3], "parent": 0},
            2: {"edges": [4, 5], "parent": 0},
            3: {"edges": [], "parent": 1},
            4: {"edges": [], "parent": 2},
            5: {"edges": [], "parent": 2},
        }
        btree = BinaryTree(data)
        print(btree)

        print_h4(
            "Binary trees",
            desc=(
                "They can have no more than two nodes, "
                "so adding new edges that do not conform"
                " should throw an error."
            ),
        )
        try:
            btree[6] = {"edges": [7, 8, 9], "parent": 3}
        except InvalidChildNodeCount:
            cmd_title("Error called successfully", newlines=False)

        bst = NaiveBinarySearchTree(data)
        print(bst)

        bst.add_child(5, 6)
        bst.add_siblings(5, [10, 11])
        print(bst)
Ejemplo n.º 27
0
from MOAL.helpers.display import cmd_title
from parsimonious.grammar import Grammar

DEBUG = True if __name__ == '__main__' else False

if DEBUG:
    with Section('Embedded Domain Specific Language (EDSL)'):
        print_h2('Parsing a grammar using the "parsimonious" library')
        button_grammar = Grammar(r"""
            btn = btn1 / btn2
            btn2 = "[" text "]"
            btn1 = "((" text "))"
            text = ~"[A-Z 0-9]*"i
            """)

        cmd_title('Printing [mybutton] and ((mybutton)) &', newlines=False)
        print(button_grammar.parse('[ mybutton ]'))
        print(button_grammar.parse('(( mybutton ))'))

        # Order matters - e.g. `tag` must come first, as it builds from the
        # previous tokens. This is obviously extremely naive, as it doesn't
        # check valid HTML-matching elements, nesting, single + wrapped
        # combos, attributes, etc....
        html = Grammar(r"""
            html = wrapped_tag+ / single_tag+
            wrapped_tag = opening content closing_wrapped
            single_tag = left content closing
            left = "<"
            right = ">"
            closer = "/"
            opening = left content right
Ejemplo n.º 28
0
 def activate(self):
     cmd_title('ACTIVATING')
     self.running = True
Ejemplo n.º 29
0
 def _show_program(self):
     cmd_title('PROGRAM')
     print_simple('States list', self.states)
     print_simple('Transitions', self.transitions)
     print_simple('Tape', self.tape)