- `get_code` will keep the previous behavior of `show_code`
- `get_code_str` will be equivalent to previous `str(show_code(...))`

- stencil plotting & transformation now in ps.stencil
- additional documentation & notebooks

This restructuring allows for easier separation of modules into
separate repositories later. Also, now pip install with repo url can be
used.

The setup.py files have also been updated to correctly reference each
other. Module versions are not extracted from git state

- counter-based philox RNG: counter/key is filled with cell coordinate
  and optional external parameters like block position and time step
- works on CPU and GPU - on CPU only for non-vectorized versions

- introduced more flexible "CustomCodeNode" that can inject
  backend-specific hand-written code

- new functions to easily extract stencil coefficients and visualize them
- Moved stencil functions from lbmpy to pystencils

- uses ast instead of text-based editing
- can handle Piecewise defined functions
- new decorator for simplified usage

- removed warnings
- added flake8 as CI target

- moved Dockerfiles into separate directory
- tests for minimal setup on ubuntu & conda
- adapted setup scripts to correctly handle dependencies
- new conda environment files for users and developers

- test run again
- notebooks not yet

- assignment collection
- sympyextensions

- Previously sympy.Eq was used to represent assignments. However Eq
  represents equality not assignment. This means that sometimes sympy
  "simplified" an equation like a = a  to True,
-> replaced sp.Eq by pystencils.Assignment everywhere
- renamed EquationCollection to AssignmentCollection

- switched to google style docstrings
- removed dead code
- started to annotate types

João Victor Tozatti Risso authored Dec 13, 2017 and Martin Bauer committed Jan 19, 2018

Concept: Generate code involving the (un)packing of fields (from)to linear
(1D) arrays, i.e. (de)serialization of the field values for buffered
communication.

A linear index is generated for the buffer, by inferring the strides and
variables of the loops over fields in the AST. In the CPU, this information is
obtained through the makeLoopOverDomain function, in
pystencils/transformations/transformations.py. On CUDA, the strides of
the fields (excluding buffers) are combined with the indexing variables to infer
the indexing of the buffer.

What is supported:
    - code generation for both CPU and GPU
    - (un)packing of fields with all the memory layouts supported by
    pystencils
    - (un)packing slices of fields (from)into the buffer
    - (un)packing subsets of cell values from the fields (from)into the buffer

Limitations:

- assumes that only one buffer and one field are being operated within
each kernel, however multiple equations involving the buffer and the
field are supported.

- (un)packing multiple cell values (from)into the buffer is supported,
however it is limited to the fields with indexDimensions=1. The same
applies to (un)packing subset of cell values of each cell.

Changes in this commit:

- add the FieldType enumeration to pystencils/field.py, to mark fields
of various types. This is replaces and is a generalization of the
isIndexedField boolean flag of the Field class. For now, the types
supported are: generic, indexed and buffer fields.

- add the fieldType property to the Field class, which indicates the
type of the field. Modifications were also performed to the member
functions of the Field class to add this property.

- add resolveBufferAccesses function, which replaces the fields marked
as buffers with the actual field access in the AST traversal.

Miscelaneous changes:

- add blockDim and gridDim variables as CUDA indexing variables.

- single function to create kernel for specified target
- data type creation from string - reuse numpy functionality
- bugfixes in dot display

- renaming because of clashes with types.py from other packages

and not as a string.
Changed name of the file TypedSymbol to types.
Fixed usage of dtype accordingly, however i might not have found every
usage of dtype.

- LoopOverDomain changed to be able to loop over rectangular sub-region of field
- support for slicing with makeSlice

- added sphinx files for documentation generation
- collected kernel creation functions in new "cpu" and "cudagpu" modules