SymPy#

Recipes for calculations that start as algebra in SymPy. SymPy shows its own expressions as maths; handcalcs takes over when the algebra is done and the numbers go in.

Calculate with an expression from SymPy#

Work out the expression symbolically, in a cell you don’t render or at the top of the script:

import sympy as sp
from math import sqrt

w, L, x = sp.symbols("w L x")
M_x = sp.integrate(sp.integrate(-w, x) + w * L / 2, x)   # bending moment along a beam
M_mid = M_x.subs(x, L / 2)                               # w*L**2/8

Then give the symbols values and mark the line that uses the expression with # hc: -y:

w = 5
L = 6
M = M_mid  # hc: -y
M_f = 1.5 * M
Output (MarkdownRenderer)
\[\begin{aligned} w &= 5 \\ L &= 6 \\ M &= \frac{w \cdot L^{2}}{8} = \frac{5 \cdot 6^{2}}{8} = 22.5 \\ M_{f} &= 1.5 \cdot M = 1.5 \cdot 22.5 = 33.75 \end{aligned}\]
$$\begin{aligned} w &= 5 \\ L &= 6 \\ M &= \frac{w \cdot L^{2}}{8} = \frac{5 \cdot 6^{2}}{8} = 22.5 \\ M_{f} &= 1.5 \cdot M = 1.5 \cdot 22.5 = 33.75 \end{aligned}$$

The line runs as M = w*L**2/8: the expression M_mid holds is written into the line just before it runs, with the values w and L have at that moment. So M holds a number, and every later line calculates with it. M_mid itself is left unchanged.

The line must be name = name, where the right-hand name holds a SymPy expression, an equation (sp.Eq(R, w * L / 2), whose right-hand side is used) or a one-item list of solutions (sp.solve(...)).

On its own line, # hc: -y applies to every following name = name line whose right-hand name holds a SymPy expression, until # hc: sympy = False:

# hc: -y
M = M_mid
V = V_end
# hc: sympy = False

Note

Giving a symbol a number replaces the SymPy symbol of that name. Finish the symbolic work, with every integrate, solve and subs, before the line that gives it a value; a SymPy step after it calculates with the number instead.

Functions and constants#

The expression is written with the names of the functions it uses (sqrt, sin, exp, log, atan2, …) and of pi, e and inf. Import them from math (from math import sqrt, pi) to show them as √ and π, or import math to use them as math.sqrt and math.pi. SymPy’s Abs, Max and Min become Python’s abs, max and min.

An expression that still holds something unevaluated, like an Integral or a Piecewise, is an error: evaluate it with SymPy first (.doit()), or split it into lines.

In a function#

@handcalc substitutes too. The expression is looked up when the function is called, in its arguments and then the module’s variables, so it can also be passed in:

@handcalc()
def midspan_moment(w, L):
    M = M_mid  # hc: -y
    return M

@handcalc()
def moment(expr, w, L):
    M = expr  # hc: -y
    return M

moment(M_mid, w=5, L=6)

The symbols are the function’s parameters (or variables assigned before the line). A function defined inside another function, using its variables, can’t be rewritten.

In a notebook#

In a %%render cell the expression comes from an earlier cell or from the same one. The cell runs a statement at a time so that each # hc: -y line is rewritten just before it runs. -y can’t be combined with %%render inputs=... (or HandCalcs(..., inputs=...)), and needs handcalcs to run the code, so not with supplied_globals.