Metadata-Version: 2.1
Name: almetro
Version: 1.0.7
Summary: A python library to measure algorithms execution time and compare with its theoretical complexity
Home-page: https://github.com/arnour/almetro
Author: Arnour Sabino
Author-email: arnour.sabino@gmail.com
License: Apache License
Description: Almetro Library
        ===============================
        
        version number: 1.0.7
        author: Arnour Sabino
        
        Overview
        --------
        
        A python library to measure algorithms execution time and compare with its theoretical complexity.
        
        [![Build Status](https://travis-ci.org/arnour/almetro.svg?branch=master)](https://travis-ci.org/arnour/almetro)
        
        Installation / Usage
        --------------------
        
        To install use pip:
        
            $ pip install almetro
        
        
        Or clone the repo:
        
            $ git clone https://github.com/arnour/almetro.git
            $ python setup.py install
        
        Information
        --------------------
        
        Almetro uses timeit module from python to time your algorithms.
        
        See more [here](https://docs.python.org/3/library/timeit.html)
        
        
        Examples
        --------------------
        
        Applying Almetro to a quadratic algorithm:
        
        ```python
        import almetro
        from almetro.algorithms import loop_n_quadratic
        from almetro.complexity import cn_quadratic
        from almetro.instance import growing
        
        metro = almetro\
                    .new()\
                    .with_execution(trials=5)\
                    .with_instances(instances=20, provider=growing(initial_size=100, growth_size=100))\
                    .metro(algorithm=loop_n_quadratic, complexity=cn_quadratic)
        
        chart = metro.chart()
        
        chart.show()
        ```
        
        ![Chart Almetro n quadratic](https://raw.githubusercontent.com/arnour/almetro/master/images/chart_almetro_n_quadratic.png)
        
        ---
        
        Applying Almetro to a lg n algorithm:
        
        ```python
        import almetro
        from almetro.algorithms import loop_n_log
        from almetro.complexity import clog_n
        from almetro.instance import growing
        
        metro = almetro\
                    .new()\
                    .with_execution(trials=100)\
                    .with_instances(instances=20, provider=growing(initial_size=10000, growth_size=10000))\
                    .metro(algorithm=loop_n_log, complexity=clog_n)
        
        chart = metro.chart()
        
        chart.show()
        ```
        
        ![Chart Almetro lg n](https://github.com/arnour/almetro/blob/master/images/chart_almetro_lg_n.png?raw=true)
        
        
        ---
        
        Customazing execution:
        
        ```python
        import almetro
        from almetro.complexity import Complexity
        from almetro.instance import generator
        
        my_custom_complexity = Complexity(
            theoretical=lambda v=1, e=1, c=1: v * v,
            experimental=lambda v=1, e=1, c=1: v + e,
            text='O(v^2)',
            latex=r'$\mathcal{O}(v^2)$'
        )
        
        # You need to provide instances as dict: {'name': '', 'size': {}, 'value': {}}
        # Size must contains all needed theoretical complexity arguments
        # Value must contain all needed algorithms arguments
        
        def my_custom_instances(n):
            g = create_some_graph()
            for _ in range(n):
                yield {
                    'name': 'my instance name',
                    'size': {'v': len(g.nodes()), 'e': len(g.edges())}, 'c': some_order_value(),
                    'value': {
                        'graph': g,
                        'v': len(g.nodes())
                    }
                }
        
        def my_custom_algorithm(graph, v):
            # Do some stuff
            pass
        
        N = 50
        
        instances_generator = my_custom_instances(N)
        
        # Trials determine how many times each instance will be repeated for Almetro to pick the min time.
        metro = almetro\
                    .new()\
                    .with_execution(trials=5)\
                    .with_instances(instances=N, provider=generator(instances_generator)\
                    .metro(algorithm=my_custom_algorithm, complexity=my_custom_complexity)
        
        metro.chart().show()
        ```
        
        ![Chart Almetro v^2](https://github.com/arnour/almetro/blob/master/images/chart_v_quadratic_graph.png?raw=true)
        
        
        ```python
        metro.table().show()
        ```
        
        ![Table Almetro v^2](https://github.com/arnour/almetro/blob/master/images/table_v_quadratic_graph.png?raw=true)
        
        ---
Platform: UNKNOWN
Description-Content-Type: text/markdown
Provides-Extra: test
