def __new__(cls, a, b):
# Conversion
a = as_ufl(a)
b = as_ufl(b)
# Type checking
if not is_true_ufl_scalar(a):
error("Cannot take the power of a non-scalar expression %s." %
ufl_err_str(a))
if not is_true_ufl_scalar(b):
error("Cannot raise an expression to a non-scalar power %s." %
ufl_err_str(b))
# Simplification
if isinstance(a, ScalarValue) and isinstance(b, ScalarValue):
return as_ufl(a._value**b._value)
if isinstance(b, Zero):
return IntValue(1)
if isinstance(a, Zero) and isinstance(b, ScalarValue):
if isinstance(b, ComplexValue):
error("Cannot raise zero to a complex power.")
bf = float(b)
if bf < 0:
error("Division by zero, cannot raise 0 to a negative power.")
else:
return zero()
if isinstance(b, ScalarValue) and b._value == 1:
return a
# Construction
self = Operator.__new__(cls)
self._init(a, b)
return self
def __new__(cls, a, b):
# Conversion
a = as_ufl(a)
b = as_ufl(b)
# Type checking
# TODO: Enabled workaround for nonscalar division in __div__,
# so maybe we can keep this assertion. Some algorithms may
# need updating.
if not is_ufl_scalar(a):
error("Expecting scalar nominator in Division.")
if not is_true_ufl_scalar(b):
error("Division by non-scalar is undefined.")
if isinstance(b, Zero):
error("Division by zero!")
# Simplification
# Simplification a/b -> a
if isinstance(a, Zero) or (isinstance(b, ScalarValue)
and b._value == 1):
return a
# Simplification "literal a / literal b" -> "literal value of
# a/b". Avoiding integer division by casting to float
if isinstance(a, ScalarValue) and isinstance(b, ScalarValue):
return as_ufl(float(a._value) / float(b._value))
# Simplification "a / a" -> "1"
# if not a.ufl_free_indices and not a.ufl_shape and a == b:
# return as_ufl(1)
# Construction
self = Operator.__new__(cls)
self._init(a, b)
return self
def __rmul__(self, integrand):
"""Multiply a scalar expression with measure to construct a form with
a single integral.
This is to implement the notation
form = integrand * self
Integration properties are taken from this Measure object.
"""
# Avoid circular imports
from ufl.integral import Integral
from ufl.form import Form
# Allow python literals: 1*dx and 1.0*dx
if isinstance(integrand, (int, float)):
integrand = as_ufl(integrand)
# Let other types implement multiplication with Measure if
# they want to (to support the dolfin-adjoint TimeMeasure)
if not isinstance(integrand, Expr):
return NotImplemented
# Allow only scalar integrands
if not is_true_ufl_scalar(integrand):
error("Can only integrate scalar expressions. The integrand is a "
"tensor expression with value shape %s and free indices with labels %s." %
(integrand.ufl_shape, integrand.ufl_free_indices))
# If we have a tuple of domain ids, delegate composition to
# Integral.__add__:
subdomain_id = self.subdomain_id()
if isinstance(subdomain_id, tuple):
return sum(integrand*self.reconstruct(subdomain_id=d) for d in subdomain_id)
# Check that we have an integer subdomain or a string
# ("everywhere" or "otherwise", any more?)
if not isinstance(subdomain_id, (str, numbers.Integral,)):
error("Expecting integer or string domain id.")
# If we don't have an integration domain, try to find one in
# integrand
domain = self.ufl_domain()
if domain is None:
domains = extract_domains(integrand)
if len(domains) == 1:
domain, = domains
elif len(domains) == 0:
error("This integral is missing an integration domain.")
else:
error("Multiple domains found, making the choice of integration domain ambiguous.")
# Otherwise create and return a one-integral form
integral = Integral(integrand=integrand,
integral_type=self.integral_type(),
domain=domain,
subdomain_id=subdomain_id,
metadata=self.metadata(),
subdomain_data=self.subdomain_data())
return Form([integral])
def __init__(self, left, right):
Operator.__init__(self, (left, right))
if not (is_true_ufl_scalar(left) and is_true_ufl_scalar(right)):
error("Expecting scalar arguments.")
def __init__(self, left, right):
Operator.__init__(self, (left, right))
if not (is_true_ufl_scalar(left) and is_true_ufl_scalar(right)):
error("Expecting scalar arguments.")