Metadata-Version: 1.0
Name: Decision-Tree-Generator
Version: 0.0.2
Summary: Program for generating decision tree LaTeX code for array-based algorithms
Home-page: https://github.com/KYDronePilot/Decision-Tree-Generator
Author: KYDronePilot
Author-email: 33381603+KYDronePilot@users.noreply.github.com
License: GPL-3.0
Description: # Decision-Tree-Generator
        Program for generating decision tree LaTeX code for array-based algorithms
        
        ![Insertion Sort Decision Tree](example/insertion_sort.png)
        
        ## Overview
        This project began with the idea of being able to generate a pruned, valid decision tree for any simple algorithm 
        that performs operations on a small list of data. Above is an example of such a tree for the Insertion Sort algorithm 
        with the list of elements `['x', 'y', 'z', 'a']`.
        
        ## Usage
        When run on a particular algorithm, the program generates complete Latex code to form a pruned, valid decision tree 
        for that algorithm.
        
        The main package provides a class `TreeGenerator`, which should be inherited with the `algorithm()` method 
        overrided. In that method, an algorithm should be entered that performs operations on the `self.data` list.
        Whenever a comparison of records is to be made in your algorithm, substitute the comparison with the following method
        call:
        ```python
        self.comp(<first record (self.data[x])>, <comparison operator ('<')>, <second record (self.data[y])>)
        ```
        
        This method will return boolean values to control how the algorithm operates.
        
        To generate the decision tree, follow these steps:
        * Create an instance of your algorithm's class.
        * Run the `execute()` method on this object.
        * Run the `render()` method and save/print the outputted Latex code.
        
        From there, the Latex code can be placed into a `.tex` file and compiled using a Latex processor.
        
        ## Example
        Example algorithms and usage can be found in `src/example.py`.
        
        ## How it Works
        The main `execute()` method starts by initially calling the algorithm implementation. Whenever a comparison is made, 
        the program saves a "state" of the program execution and adds a node to a tree structure for printing the Latex code.
        It then returns `True` to cause the program to make a left branch. With each comparison made, it checks to verify the
        last comparison is valid and prunes the node if not. If the comparison is not valid, it puts the algorithm in "lame 
        duck" mode, which instructs the comparison method to always return `False`, letting the algorithm run out its course.
        It continues this process until the algorithm exits.
        
        Once the algorithm exits, the program figures out what boolean values the `comp()` function must return in order to 
        restore the execution state to the latest left (`True`) branch in the algorithm. It then makes a right branch and 
        continues the process all over again.
        
        In this way, it explores all possible valid paths the algorithm could take, given the input data and generates a tree
        structure to represent it. From there, the `render()` method performs a pre-order traversal of that tree, generating 
        the Latex code as it goes.
        
        ## Contribution
        If you have an addition you would like to make or find an issue, please either open an issue or submit a pull request
        and I'll try to handle it as soon as possible.
        
Platform: UNKNOWN
