Metadata-Version: 2.0
Name: Boolean-Solver
Version: 0.2.0
Summary: Fast development with generated boolean expressions.
Home-page: https://github.com/jisazaTappsi/BooleanSolver
Author: Juan Pablo Isaza
Author-email: biosolardecolombia@gmail.com
License: MIT
Keywords: Quine McCluskey,Boolean,code,automatic code generation,expression,Boolean expression
Platform: UNKNOWN
Classifier: Development Status :: 3 - Alpha
Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python :: 2.7
Classifier: Intended Audience :: Developers
Classifier: Topic :: Software Development :: Build Tools

BooleanSolver
=============

Introduction
------------

A picture is worth a thousand words and a vid is worth a thousand
pictures, so watch a `short intro <https://youtu.be/w8tuJ9kqjJc>`__ or
continue reading...

This is a `python 2
project <https://pypi.python.org/pypi/Boolean-Solver>`__ to speed up
boolean expression coding. Sometimes we need to crack a problem by
combining boolean operators such as: ``and``, ``or`` & ``not``. We as
humans are prone to err, specially when expressions get big. But there
is an algorithm (Quine-McCluskey) to get this expressions with zero
error. Just specify your specs in a test and set a dummy function on
your code. When you run your tests a solver will take your specs and
code them into a simple boolean expression, enjoy :).

Package Setup
-------------

1. Install Boolean-Solver package: ``$ pip install Boolean-Solver``

Short Example
-------------

Add new script(start.py) with a mock function:

::

    from boolean_solver import solver as s

    @s.solve_boolean()
    def and_function(a, b):
        return False

Add a unittest(test.py) with specs:

::

    import unittest
    from boolean_solver import solver
    import start


    class MyTest(unittest.TestCase):
        """
        1. Set the truth table of your boolean function (at least for rows where output=True)
        2. run solver.execute(self, callable, table) where callable is the boolean function
         with the decorator=@solve_boolean() in functions1.
         See examples below:
        """
        def test_AND_function(self):

        #                  b1     b0    output
        truth_table = {((False, False), False),
                       ((False, True), False),
                       ((True, False), False),
                       ((True, True), True)}

        solver.execute(self, start.and_function, truth_table)

Then run ``$ python -m unittest test`` and see the result below
``def and_function(a, b)``.

Source Code
-----------

Setup with source code
----------------------

1. Clone repository:
   ``$ git clone git@github.com:jisazaTappsi/BooleanSolver.git``

Intro Example with source code
------------------------------

1. Enter ``boolean_solver``: ``$ cd boolean_solver/``

2. Run: ``$ python start_sample.py``

   ::

       Sorry, run:
       $ python -m unittest test_sample
       first, to solve the riddle :)

3. So, run test with: ``$ python -m unittest test_sample``

   ::

       Solved and tested and_function_3_variables
       .Solved and tested and_function
       .Solved and tested or_function
       .Solved and tested xor_function
       .
       ----------------------------------------------------------------------
       Ran 4 tests in 0.006s

       OK

4. Run: ``$ python start_sample.py``

   ::

         You made it, Congrats !!!
         Now, see the functions, enjoy :)

You just solved 4 boolean expressions: ``and``, ``or``, ``xor`` &
``and3``. Specs for these functions are in ``test_sample.py``.

How does Boolean Solver works?
------------------------------

Takes a function and a truth\_table which is processed using the
`Quine-McCluskey
Algorithm <https://en.wikipedia.org/wiki/Quine%E2%80%93McCluskey_algorithm>`__.
Then finds a optimal boolean expression. This expression is inserted in
the method definition with the decorator ``@boolean_solver()``.

Arguments of ``solver.execute(test, callable_function, truth_table)``
---------------------------------------------------------------------

1. The test case itself, to be able to perform tests, eg: ``self``

2. A function to optimize, passed as a callable (with no arguments).
   This function needs a 3 mock line definition with: line 1: decorator
   = ``@solve_boolean()`` line 2: signature eg: ``def myfunction(a, b)``
   line 3: body: only one line, eg: ``return False``. This line will be
   replaced by the boolean expression.

3. truth table is a set containing tuples. Where each row is a tuple the
   general form is:

   ``{tuple_row(tuple_inputs(a, b, ...), output), ...}``


