Metadata-Version: 2.1
Name: pyseagull
Version: 1.0.0b3
Summary: Python library for simulating Conway's Game of Life
Home-page: https://github.com/ljvmiranda921/seagull
Author: Lester James V. Miranda
Author-email: ljvmiranda@gmail.com
License: MIT license
Description: <p align="center">
            <img src="https://imgur.com/Vgt6a5y.png" width="200">
        </p>
        
        <p align="center">
            <a href="https://pypi.org/project/pyseagull/"><img src="https://img.shields.io/pypi/v/pyseagull.svg?color=brightgreen&logo=python&logoColor=white"></img></a>
            <a href="https://dev.azure.com/ljvmiranda/ljvmiranda/_build/latest?definitionId=3&branchName=master"><img src="https://dev.azure.com/ljvmiranda/ljvmiranda/_apis/build/status/ljvmiranda921.seagull?branchName=master"></img></a>
            <a href="https://pyseagull.readthedocs.io/en/latest/?badge=latest"><img src="https://readthedocs.org/projects/pyseagull/badge/?version=latest"></img></a>
            <a href="https://opensource.org/licenses/MIT"><img src="https://img.shields.io/github/license/ljvmiranda921/seagull.svg?color=blue"></img></a>
            <a href="https://mybinder.org/v2/gh/ljvmiranda921/seagull/master?filepath=docs%2Fnotebooks"><img src="https://mybinder.org/badge_logo.svg"></img></a>
        </p>
        
        
        A Python library for Conway's Game of Life
        
        This framework allows you to create and simulate various artificial lifeforms
        and cellular automata easily: simply define your board, add your lifeforms,
        and execute the `run` command! It also provides a myriad of pre-made
        lifeforms while allowing you to create your own.
        
        **Why name it Seagull?** Conway's Game of Life is quite a mouthful, so I just refer to
        its acronym, CGoL. The word "seagull" is just a pun of that.
        
        Simulate your first lifeforms in few lines of code:
        
        ```python
        import seagull as sg
        from seagull.lifeforms import Pulsar
        
        # Initialize board
        board = sg.Board(size=(19,60))  
        
        # Add three Pulsar lifeforms in various locations
        board.add(Pulsar(), loc=(1,1))
        board.add(Pulsar(), loc=(1,22))
        board.add(Pulsar(), loc=(1,42))
        
        # Simulate board
        sim = sg.Simulator(board)      
        sim.run(sg.rules.conway_classic, iters=1000)
        ```
        
        Optionally, you can animate the simulation by running `sim.animate()`:
        
        <p align="center">
          <img src="https://imgur.com/sgCrP9f.gif" width="720">
        </p>
        
        Aside from `Pulsar`, we have a [nice collection of
        lifeforms](https://pyseagull.readthedocs.io/en/latest/api/seagull.lifeforms.html)
        for you to choose from!
        
        ## Installation
        
        To install Seagull, run this command in your terminal:
        
        ```shell
        pip install pyseagull
        ```
        
        This is the preferred method to install Seagull, as it will always install
        the most recent stable release.
        
        In case you want to install the bleeding-edge version, clone this repo:
        
        ```shell
        git clone https://github.com/ljvmiranda921/seagull.git
        ```
        
        and then run
        
        ```shell
        cd seagull
        python setup.py install
        ```
        
        ## Usage
        
        There are three main components for an artificial life simulation:
        
        * The `Board` or the environment in which the lifeforms will move around
        * The `Lifeform` that will interact with the environment, and  
        * The `rules` that dictate if a particular cell will survive or not
        
        In Seagull, you simply define your `Board`, add your `Lifeform`/s, and run the
        `Simulator` given a `rule`. You can add multiple lifeforms as you want:
        
        ```python
        import seagull as sg
        from seagull import lifeforms as lf
        
        board = sg.Board(size=(30,30))
        board.add(lf.Blinker(length=3), loc=(4,4))
        board.add(lf.Glider(), loc=(10,4))
        board.add(lf.Glider(), loc=(15,4))
        board.add(lf.Pulsar(), loc=(5,12))
        board.view()  # View the current state of the board
        ```
        
        Then you can simply run the simulation, and animate it when needed:
        
        ```python
        sim = sg.Simulator(board)
        hist = sim.run(sg.rules.conway_classic, iters=1000)  # Save simulation history
        sim.animate()
        ```
        
        ### Adding custom lifeforms
        
        You can manually create your lifeforms by using the `Custom` class:
        
        ```python
        import seagull as sg
        from seagull.lifeforms import Custom
        
        board = sg.Board(size=(30,30))
        board.add(Custom([[0,1,1,0], [0,0,1,1]]), loc=(0,0))
        ```
        
        ### Obtaining simulation statistics and history 
        
        By default, the simulation statistics will always be returned after calling the
        `run()` method. In addition, you can also obtain the history by calling the
        `get_history()` method.
        
        ```python
        # The run() command returns the run statistics
        stats = sim.run(sg.rules.conway_classic, iters=1000)
        # You can also get it using get_history()
        hist = sim.get_history()
        ```
        
        ## Examples
        
        You can find more examples in the
        [documentation](https://pyseagull.readthedocs.io/en/latest/examples.html)
        
        ## Contributing
        
        This project is open for contributors! Contibutions can come in the form of
        feature requests, bug fixes, documentation, tutorials and the like! We highly
        recommend to file an Issue first before submitting a [Pull
        Request](https://help.github.com/en/articles/creating-a-pull-request).
        
        Simply fork this repository and make a Pull Request! We'd definitely
        appreciate:
        
        * Implementation of new features
        * Bug Reports
        * Documentation
        * Testing
        
        
        ## License
        
        MIT License (c) 2019, Lester James V. Miranda
        
Keywords: conway game of lifemathematics,cellular automata
Platform: UNKNOWN
Classifier: Development Status :: 4 - Beta
Classifier: Intended Audience :: Developers
Classifier: Intended Audience :: Education
Classifier: Intended Audience :: Science/Research
Classifier: License :: OSI Approved :: MIT License
Classifier: Natural Language :: English
Classifier: Topic :: Scientific/Engineering
Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
Classifier: Topic :: Scientific/Engineering :: Mathematics
Classifier: Topic :: Scientific/Engineering :: Artificial Life
Classifier: Topic :: Software Development :: Libraries :: Python Modules
Classifier: Programming Language :: Python :: 3.6
Classifier: Programming Language :: Python :: 3.5
Classifier: Typing :: Typed
Description-Content-Type: text/markdown
