def test_latex_formatting_of_cmath():
x = ufl.SpatialCoordinate(ufl.triangle)[0]
assert expr2latex(ufl.exp(x)) == r"e^{x_0}"
assert expr2latex(ufl.ln(x)) == r"\ln(x_0)"
assert expr2latex(ufl.sqrt(x)) == r"\sqrt{x_0}"
assert expr2latex(abs(x)) == r"\|x_0\|"
assert expr2latex(ufl.sin(x)) == r"\sin(x_0)"
assert expr2latex(ufl.cos(x)) == r"\cos(x_0)"
assert expr2latex(ufl.tan(x)) == r"\tan(x_0)"
assert expr2latex(ufl.asin(x)) == r"\arcsin(x_0)"
assert expr2latex(ufl.acos(x)) == r"\arccos(x_0)"
assert expr2latex(ufl.atan(x)) == r"\arctan(x_0)"
def test_cpp_formatting_of_cmath():
x, y = ufl.SpatialCoordinate(ufl.triangle)
# Test cmath functions
assert expr2cpp(ufl.exp(x)) == "exp(x[0])"
assert expr2cpp(ufl.ln(x)) == "log(x[0])"
assert expr2cpp(ufl.sqrt(x)) == "sqrt(x[0])"
assert expr2cpp(abs(x)) == "fabs(x[0])"
assert expr2cpp(ufl.sin(x)) == "sin(x[0])"
assert expr2cpp(ufl.cos(x)) == "cos(x[0])"
assert expr2cpp(ufl.tan(x)) == "tan(x[0])"
assert expr2cpp(ufl.asin(x)) == "asin(x[0])"
assert expr2cpp(ufl.acos(x)) == "acos(x[0])"
assert expr2cpp(ufl.atan(x)) == "atan(x[0])"
def test_cpp_formatting_precedence_handling():
x, y = ufl.SpatialCoordinate(ufl.triangle)
# Test precedence handling with sums
# Note that the automatic sorting is reflected in formatting!
assert expr2cpp(y + (2 + x)) == "x[1] + (2 + x[0])"
assert expr2cpp((x + 2) + y) == "x[1] + (2 + x[0])"
assert expr2cpp((2 + x) + (3 + y)) == "(2 + x[0]) + (3 + x[1])"
assert expr2cpp((x + 3) + 2 + y) == "x[1] + (2 + (3 + x[0]))"
assert expr2cpp(2 + (x + 3) + y) == "x[1] + (2 + (3 + x[0]))"
assert expr2cpp(2 + (3 + x) + y) == "x[1] + (2 + (3 + x[0]))"
assert expr2cpp(y + (2 + (3 + x))) == "x[1] + (2 + (3 + x[0]))"
assert expr2cpp(2 + x + 3 + y) == "x[1] + (3 + (2 + x[0]))"
assert expr2cpp(2 + x + 3 + y) == "x[1] + (3 + (2 + x[0]))"
# Test precedence handling with divisions
# This is more stable than sums since there is no sorting.
assert expr2cpp((x / 2) / 3) == "(x[0] / 2) / 3"
assert expr2cpp(x / (y / 3)) == "x[0] / (x[1] / 3)"
assert expr2cpp((x / 2) / (y / 3)) == "(x[0] / 2) / (x[1] / 3)"
assert expr2cpp(x / (2 / y) / 3) == "(x[0] / (2 / x[1])) / 3"
# Test precedence handling with highest level types
assert expr2cpp(ufl.sin(x)) == "sin(x[0])"
assert expr2cpp(ufl.cos(x + 2)) == "cos(2 + x[0])"
assert expr2cpp(ufl.tan(x / 2)) == "tan(x[0] / 2)"
assert expr2cpp(ufl.acos(x + 3 * y)) == "acos(x[0] + 3 * x[1])"
assert expr2cpp(ufl.asin(ufl.atan(x**4))) == "asin(atan(pow(x[0], 4)))"
assert expr2cpp(ufl.sin(y) + ufl.tan(x)) == "sin(x[1]) + tan(x[0])"
# Test precedence handling with mixed types
assert expr2cpp(3 * (2 + x)) == "3 * (2 + x[0])"
assert expr2cpp((2 * x) + (3 * y)) == "2 * x[0] + 3 * x[1]"
assert expr2cpp(2 * (x + 3) * y) == "x[1] * (2 * (3 + x[0]))"
assert expr2cpp(2 * (x + 3)**4 * y) == "x[1] * (2 * pow(3 + x[0], 4))"
def test_latex_formatting_precedence_handling():
x, y = ufl.SpatialCoordinate(ufl.triangle)
# Test precedence handling with sums
# Note that the automatic sorting is reflected in formatting!
assert expr2latex(y + (2 + x)) == "x_1 + (2 + x_0)"
assert expr2latex((x + 2) + y) == "x_1 + (2 + x_0)"
assert expr2latex((2 + x) + (3 + y)) == "(2 + x_0) + (3 + x_1)"
assert expr2latex((x + 3) + 2 + y) == "x_1 + (2 + (3 + x_0))"
assert expr2latex(2 + (x + 3) + y) == "x_1 + (2 + (3 + x_0))"
assert expr2latex(2 + (3 + x) + y) == "x_1 + (2 + (3 + x_0))"
assert expr2latex(y + (2 + (3 + x))) == "x_1 + (2 + (3 + x_0))"
assert expr2latex(2 + x + 3 + y) == "x_1 + (3 + (2 + x_0))"
assert expr2latex(2 + x + 3 + y) == "x_1 + (3 + (2 + x_0))"
# Test precedence handling with divisions
# This is more stable than sums since there is no sorting.
assert expr2latex((x / 2) / 3) == r"\frac{(\frac{x_0}{2})}{3}"
assert expr2latex(x / (y / 3)) == r"\frac{x_0}{(\frac{x_1}{3})}"
assert expr2latex((x / 2) / (y / 3)) == r"\frac{(\frac{x_0}{2})}{(\frac{x_1}{3})}"
assert expr2latex(x / (2 / y) / 3) == r"\frac{(\frac{x_0}{(\frac{2}{x_1})})}{3}"
# Test precedence handling with highest level types
assert expr2latex(ufl.sin(x)) == r"\sin(x_0)"
assert expr2latex(ufl.cos(x + 2)) == r"\cos(2 + x_0)"
assert expr2latex(ufl.tan(x / 2)) == r"\tan(\frac{x_0}{2})"
assert expr2latex(ufl.acos(x + 3 * y)) == r"\arccos(x_0 + 3 x_1)"
assert expr2latex(ufl.asin(ufl.atan(x**4))) == r"\arcsin(\arctan({x_0}^{4}))"
assert expr2latex(ufl.sin(y) + ufl.tan(x)) == r"\sin(x_1) + \tan(x_0)"
# Test precedence handling with mixed types
assert expr2latex(3 * (2 + x)) == "3 (2 + x_0)"
assert expr2latex((2 * x) + (3 * y)) == "2 x_0 + 3 x_1"
assert expr2latex(2 * (x + 3) * y) == "x_1 (2 (3 + x_0))"
def test_diff_then_integrate():
# Define 1D geometry
n = 21
mesh = UnitIntervalMesh(MPI.comm_world, n)
# Shift and scale mesh
x0, x1 = 1.5, 3.14
mesh.coordinates()[:] *= (x1 - x0)
mesh.coordinates()[:] += x0
x = SpatialCoordinate(mesh)[0]
xs = 0.1 + 0.8 * x / x1 # scaled to be within [0.1,0.9]
# Define list of expressions to test, and configure
# accuracies these expressions are known to pass with.
# The reason some functions are less accurately integrated is
# likely that the default choice of quadrature rule is not perfect
F_list = []
def reg(exprs, acc=10):
for expr in exprs:
F_list.append((expr, acc))
# FIXME: 0*dx and 1*dx fails in the ufl-ffc-jit framework somewhere
# reg([Constant(0.0, cell=cell)])
# reg([Constant(1.0, cell=cell)])
monomial_list = [x**q for q in range(2, 6)]
reg(monomial_list)
reg([2.3 * p + 4.5 * q for p in monomial_list for q in monomial_list])
reg([x**x])
reg([x**(x**2)], 8)
reg([x**(x**3)], 6)
reg([x**(x**4)], 2)
# Special functions:
reg([atan(xs)], 8)
reg([sin(x), cos(x), exp(x)], 5)
reg([ln(xs), pow(x, 2.7), pow(2.7, x)], 3)
reg([asin(xs), acos(xs)], 1)
reg([tan(xs)], 7)
try:
import scipy
except ImportError:
scipy = None
if hasattr(math, 'erf') or scipy is not None:
reg([erf(xs)])
else:
print(
"Warning: skipping test of erf, old python version and no scipy.")
# if 0:
# print("Warning: skipping tests of bessel functions, doesn't build on all platforms.")
# elif scipy is None:
# print("Warning: skipping tests of bessel functions, missing scipy.")
# else:
# for nu in (0, 1, 2):
# # Many of these are possibly more accurately integrated,
# # but 4 covers all and is sufficient for this test
# reg([bessel_J(nu, xs), bessel_Y(nu, xs), bessel_I(nu, xs), bessel_K(nu, xs)], 4)
# To handle tensor algebra, make an x dependent input tensor
# xx and square all expressions
def reg2(exprs, acc=10):
for expr in exprs:
F_list.append((inner(expr, expr), acc))
xx = as_matrix([[2 * x**2, 3 * x**3], [11 * x**5, 7 * x**4]])
x3v = as_vector([3 * x**2, 5 * x**3, 7 * x**4])
cc = as_matrix([[2, 3], [4, 5]])
reg2([xx])
reg2([x3v])
reg2([cross(3 * x3v, as_vector([-x3v[1], x3v[0], x3v[2]]))])
reg2([xx.T])
reg2([tr(xx)])
reg2([det(xx)])
reg2([dot(xx, 0.1 * xx)])
reg2([outer(xx, xx.T)])
reg2([dev(xx)])
reg2([sym(xx)])
reg2([skew(xx)])
reg2([elem_mult(7 * xx, cc)])
reg2([elem_div(7 * xx, xx + cc)])
reg2([elem_pow(1e-3 * xx, 1e-3 * cc)])
reg2([elem_pow(1e-3 * cc, 1e-3 * xx)])
reg2([elem_op(lambda z: sin(z) + 2, 0.03 * xx)], 2) # pretty inaccurate...
# FIXME: Add tests for all UFL operators:
# These cause discontinuities and may be harder to test in the
# above fashion:
# 'inv', 'cofac',
# 'eq', 'ne', 'le', 'ge', 'lt', 'gt', 'And', 'Or', 'Not',
# 'conditional', 'sign',
# 'jump', 'avg',
# 'LiftingFunction', 'LiftingOperator',
# FIXME: Test other derivatives: (but algorithms for operator
# derivatives are the same!):
# 'variable', 'diff',
# 'Dx', 'grad', 'div', 'curl', 'rot', 'Dn', 'exterior_derivative',
# Run through all operators defined above and compare integrals
debug = 0
for F, acc in F_list:
# Apply UFL differentiation
f = diff(F, SpatialCoordinate(mesh))[..., 0]
if debug:
print(F)
print(x)
print(f)
# Apply integration with DOLFIN
# (also passes through form compilation and jit)
M = f * dx
f_integral = assemble_scalar(M) # noqa
f_integral = MPI.sum(mesh.mpi_comm(), f_integral)
# Compute integral of f manually from anti-derivative F
# (passes through PyDOLFIN interface and uses UFL evaluation)
F_diff = F((x1, )) - F((x0, ))
# Compare results. Using custom relative delta instead
# of decimal digits here because some numbers are >> 1.
delta = min(abs(f_integral), abs(F_diff)) * 10**-acc
assert f_integral - F_diff <= delta
def test_div_grad_then_integrate_over_cells_and_boundary():
# Define 2D geometry
n = 10
mesh = RectangleMesh(Point(0.0, 0.0), Point(2.0, 3.0), 2 * n, 3 * n)
x, y = SpatialCoordinate(mesh)
xs = 0.1 + 0.8 * x / 2 # scaled to be within [0.1,0.9]
# ys = 0.1 + 0.8 * y / 3 # scaled to be within [0.1,0.9]
n = FacetNormal(mesh)
# Define list of expressions to test, and configure accuracies
# these expressions are known to pass with. The reason some
# functions are less accurately integrated is likely that the
# default choice of quadrature rule is not perfect
F_list = []
def reg(exprs, acc=10):
for expr in exprs:
F_list.append((expr, acc))
# FIXME: 0*dx and 1*dx fails in the ufl-ffc-jit framework somewhere
# reg([Constant(0.0, cell=cell)])
# reg([Constant(1.0, cell=cell)])
monomial_list = [x**q for q in range(2, 6)]
reg(monomial_list)
reg([2.3 * p + 4.5 * q for p in monomial_list for q in monomial_list])
reg([xs**xs])
reg(
[xs**(xs**2)], 8
) # Note: Accuracies here are from 1D case, not checked against 2D results.
reg([xs**(xs**3)], 6)
reg([xs**(xs**4)], 2)
# Special functions:
reg([atan(xs)], 8)
reg([sin(x), cos(x), exp(x)], 5)
reg([ln(xs), pow(x, 2.7), pow(2.7, x)], 3)
reg([asin(xs), acos(xs)], 1)
reg([tan(xs)], 7)
# To handle tensor algebra, make an x dependent input tensor
# xx and square all expressions
def reg2(exprs, acc=10):
for expr in exprs:
F_list.append((inner(expr, expr), acc))
xx = as_matrix([[2 * x**2, 3 * x**3], [11 * x**5, 7 * x**4]])
xxs = as_matrix([[2 * xs**2, 3 * xs**3], [11 * xs**5, 7 * xs**4]])
x3v = as_vector([3 * x**2, 5 * x**3, 7 * x**4])
cc = as_matrix([[2, 3], [4, 5]])
reg2(
[xx]
) # TODO: Make unit test for UFL from this, results in listtensor with free indices
reg2([x3v])
reg2([cross(3 * x3v, as_vector([-x3v[1], x3v[0], x3v[2]]))])
reg2([xx.T])
reg2([tr(xx)])
reg2([det(xx)])
reg2([dot(xx, 0.1 * xx)])
reg2([outer(xx, xx.T)])
reg2([dev(xx)])
reg2([sym(xx)])
reg2([skew(xx)])
reg2([elem_mult(7 * xx, cc)])
reg2([elem_div(7 * xx, xx + cc)])
reg2([elem_pow(1e-3 * xxs, 1e-3 * cc)])
reg2([elem_pow(1e-3 * cc, 1e-3 * xx)])
reg2([elem_op(lambda z: sin(z) + 2, 0.03 * xx)], 2) # pretty inaccurate...
# FIXME: Add tests for all UFL operators:
# These cause discontinuities and may be harder to test in the
# above fashion:
# 'inv', 'cofac',
# 'eq', 'ne', 'le', 'ge', 'lt', 'gt', 'And', 'Or', 'Not',
# 'conditional', 'sign',
# 'jump', 'avg',
# 'LiftingFunction', 'LiftingOperator',
# FIXME: Test other derivatives: (but algorithms for operator
# derivatives are the same!):
# 'variable', 'diff',
# 'Dx', 'grad', 'div', 'curl', 'rot', 'Dn', 'exterior_derivative',
# Run through all operators defined above and compare integrals
debug = 0
if debug:
F_list = F_list[1:]
for F, acc in F_list:
if debug:
print('\n', "F:", str(F))
# Integrate over domain and its boundary
int_dx = assemble(div(grad(F)) * dx(mesh)) # noqa
int_ds = assemble(dot(grad(F), n) * ds(mesh)) # noqa
if debug:
print(int_dx, int_ds)
# Compare results. Using custom relative delta instead of
# decimal digits here because some numbers are >> 1.
delta = min(abs(int_dx), abs(int_ds)) * 10**-acc
assert int_dx - int_ds <= delta
def test_dolfin_expression_compilation_of_math_functions(dolfin):
# Define some PyDOLFIN coefficients
mesh = dolfin.UnitSquareMesh(3, 3)
# Using quadratic element deliberately for accuracy
V = dolfin.FunctionSpace(mesh, "CG", 2)
u = dolfin.Function(V)
u.interpolate(dolfin.Expression("x[0]*x[1]"))
w0 = u
# Define ufl expression with math functions
v = abs(ufl.cos(u))/2 + 0.02
uexpr = ufl.sin(u) + ufl.tan(v) + ufl.exp(u) + ufl.ln(v) + ufl.atan(v) + ufl.acos(v) + ufl.asin(v)
#print dolfin.assemble(uexpr**2*dolfin.dx, mesh=mesh) # 11.7846508409
# Define expected output from compilation
ucode = 'v_w0[0]'
vcode = '0.02 + fabs(cos(v_w0[0])) / 2'
funcs = 'asin(%(v)s) + (acos(%(v)s) + (atan(%(v)s) + (log(%(v)s) + (exp(%(u)s) + (sin(%(u)s) + tan(%(v)s))))))'
oneliner = funcs % {'u':ucode, 'v':vcode}
# Oneliner version (ignoring reuse):
expected_lines = ['double s[1];',
'Array<double> v_w0(1);',
'w0->eval(v_w0, x);',
's[0] = %s;' % oneliner,
'values[0] = s[0];']
#cppcode = format_dolfin_expression(classname="DebugExpression", shape=(), eval_body=expected_lines)
#print '-'*100
#print cppcode
#print '-'*100
#dolfin.plot(dolfin.Expression(cppcode=cppcode, mesh=mesh))
#dolfin.interactive()
# Split version (handles reuse of v, no other reuse):
expected_lines = ['double s[2];',
'Array<double> v_w0(1);',
'w0->eval(v_w0, x);',
's[0] = %s;' % (vcode,),
's[1] = %s;' % (funcs % {'u':ucode,'v':'s[0]'},),
'values[0] = s[1];']
# Define expected evaluation values: [(x,value), (x,value), ...]
import math
x, y = 0.6, 0.7
u = x*y
v = abs(math.cos(u))/2 + 0.02
v0 = .52
expected0 = math.tan(v0) + 1 + math.log(v0) + math.atan(v0) + math.acos(v0) + math.asin(v0)
expected = math.sin(u) + math.tan(v) + math.exp(u) + math.log(v) + math.atan(v) + math.acos(v) + math.asin(v)
expected_values = [((0.0, 0.0), (expected0,)),
((x, y), (expected,)),
]
# Execute all tests
check_dolfin_expression_compilation(uexpr, expected_lines, expected_values, members={'w0':w0})