doc/sphinx/stencil.rst

+*******
+Stencil
+*******
+
+.. automodule:: pystencils.stencil
+   :members:

doc/sphinx/tutorials.rst

+Tutorials
+=========
+
+These tutorials are a good place to start if you are new to pystencils.
+All tutorials and demos listed here are based on Jupyter notebooks that you can find in the pystencils repository.
+It is a good idea to download them and run them directly to be able to play around with the code.
+
+.. toctree::
+   :maxdepth: 1
+
+   /notebooks/01_tutorial_getting_started.ipynb
+   /notebooks/02_tutorial_basic_kernels.ipynb
+   /notebooks/03_tutorial_datahandling.ipynb
+   /notebooks/04_tutorial_advection_diffusion.ipynb
+   /notebooks/05_tutorial_phasefield_spinodal_decomposition.ipynb
+   /notebooks/06_tutorial_phasefield_dentritic_growth.ipynb
+   /notebooks/demo_assignment_collection.ipynb
+   /notebooks/demo_plotting_and_animation.ipynb
+   /notebooks/demo_derivatives.ipynb
+   /notebooks/demo_benchmark.ipynb
+   /notebooks/demo_wave_equation.ipynb

equationcollection/__init__.py

-from pystencils.equationcollection.equationcollection import EquationCollection
-from pystencils.equationcollection.simplificationstrategy import SimplificationStrategy

equationcollection/simplifications.py

-import sympy as sp
-from pystencils.sympyextensions import replaceAdditive
-
-
-def sympyCSE(equationCollection):
-    """
-    Searches for common subexpressions inside the equation collection, in both the existing subexpressions as well
-    as the equations themselves. It uses the sympy subexpression detection to do this. Return a new equation collection
-    with the additional subexpressions found
-    """
-    symbolGen = equationCollection.subexpressionSymbolNameGenerator
-    replacements, newEq = sp.cse(equationCollection.subexpressions + equationCollection.mainEquations,
-                                 symbols=symbolGen)
-    replacementEqs = [sp.Eq(*r) for r in replacements]
-
-    modifiedSubexpressions = newEq[:len(equationCollection.subexpressions)]
-    modifiedUpdateEquations = newEq[len(equationCollection.subexpressions):]
-
-    newSubexpressions = replacementEqs + modifiedSubexpressions
-    topologicallySortedPairs = sp.cse_main.reps_toposort([[e.lhs, e.rhs] for e in newSubexpressions])
-    newSubexpressions = [sp.Eq(a[0], a[1]) for a in topologicallySortedPairs]
-
-    return equationCollection.copy(modifiedUpdateEquations, newSubexpressions)
-
-
-def applyOnAllEquations(equationCollection, operation):
-    """Applies sympy expand operation to all equations in collection"""
-    result = [sp.Eq(eq.lhs, operation(eq.rhs)) for eq in equationCollection.mainEquations]
-    return equationCollection.copy(result)
-
-
-def applyOnAllSubexpressions(equationCollection, operation):
-    result = [sp.Eq(eq.lhs, operation(eq.rhs)) for eq in equationCollection.subexpressions]
-    return equationCollection.copy(equationCollection.mainEquations, result)
-
-
-def subexpressionSubstitutionInExistingSubexpressions(equationCollection):
-    """Goes through the subexpressions list and replaces the term in the following subexpressions"""
-    result = []
-    for outerCtr, s in enumerate(equationCollection.subexpressions):
-        newRhs = s.rhs
-        for innerCtr in range(outerCtr):
-            subExpr = equationCollection.subexpressions[innerCtr]
-            newRhs = replaceAdditive(newRhs, subExpr.lhs, subExpr.rhs, requiredMatchReplacement=1.0)
-            newRhs = newRhs.subs(subExpr.rhs, subExpr.lhs)
-        result.append(sp.Eq(s.lhs, newRhs))
-
-    return equationCollection.copy(equationCollection.mainEquations, result)
-
-
-def subexpressionSubstitutionInMainEquations(equationCollection):
-    """Replaces already existing subexpressions in the equations of the equationCollection"""
-    result = []
-    for s in equationCollection.mainEquations:
-        newRhs = s.rhs
-        for subExpr in equationCollection.subexpressions:
-            newRhs = replaceAdditive(newRhs, subExpr.lhs, subExpr.rhs, requiredMatchReplacement=1.0)
-        result.append(sp.Eq(s.lhs, newRhs))
-    return equationCollection.copy(result)
-
-
-def addSubexpressionsForDivisions(equationCollection):
-    """Introduces subexpressions for all divisions which have no constant in the denominator.
-    e.g.  :math:`\frac{1}{x}` is replaced, :math:`\frac{1}{3}` is not replaced."""
-    divisors = set()
-
-    def searchDivisors(term):
-        if term.func == sp.Pow:
-            if term.exp.is_integer and term.exp.is_number and term.exp < 0:
-                divisors.add(term)
-        else:
-            for a in term.args:
-                searchDivisors(a)
-
-    for eq in equationCollection.allEquations:
-        searchDivisors(eq.rhs)
-
-    newSymbolGen = equationCollection.subexpressionSymbolNameGenerator
-    substitutions = {divisor: newSymbol for newSymbol, divisor in zip(newSymbolGen, divisors)}
-    return equationCollection.copyWithSubstitutionsApplied(substitutions, True)

gpucuda/__init__.py

-from pystencils.gpucuda.kernelcreation import createCUDAKernel
-from pystencils.gpucuda.cudajit import makePythonFunction

llvm/__init__.py

-from .kernelcreation import createKernel