def eval(cls, *_args):
"""."""
if not _args:
return
if not len(_args) == 1:
raise ValueError('Expecting one argument')
expr = _args[0]
if isinstance(expr, Add):
args = expr.args
args = [cls.eval(a) for a in expr.args]
return Add(*args)
elif isinstance(expr, Mul):
coeffs = [a for a in expr.args if isinstance(a, _coeffs_registery)]
vectors = [a for a in expr.args if not(a in coeffs)]
a = S.One
if coeffs:
a = Mul(*coeffs)
b = S.One
if vectors:
if len(vectors) == 1:
f = vectors[0]
b = cls(f)
elif len(vectors) == 2:
f,g = vectors
b = f*cls(g) + g*cls(f) + 2 * Dot(Grad(f), Grad(g))
else:
b = cls(Mul(*vectors), evaluate=False)
return Mul(a, b)
elif isinstance(expr, _coeffs_registery):
return S.Zero
# ... check consistency between space type and the operator
# TODO add appropriate space types
if _is_sympde_atom(expr):
if not isinstance(expr.space.kind, UndefinedSpaceType):
msg = '> Wrong space kind, given {}'.format(expr.space.kind)
raise ArgumentTypeError(msg)
# ...
return cls(expr, evaluate=False)
def eval(cls, *_args):
"""."""
if not _args:
return
if not len(_args) == 1:
raise ValueError('Expecting one argument')
expr = _args[0]
if isinstance(expr, Add):
args = expr.args
args = [cls.eval(a) for a in expr.args]
return Add(*args)
elif isinstance(expr, Mul):
coeffs = [a for a in expr.args if isinstance(a, _coeffs_registery)]
vectors = [a for a in expr.args if not(a in coeffs)]
a = S.One
if coeffs:
a = Mul(*coeffs)
b = S.One
if vectors:
if len(vectors) == 2:
a,b = vectors
# TODO remove try/except using regularity from space
try:
if isinstance(a, (Tuple, VectorTestFunction, VectorField)):
f = b ; F = a
return f*Div(F) + Dot(F, grad(f))
elif isinstance(b, (Tuple, VectorTestFunction, VectorField)):
f = a ; F = b
return f*Div(F) + Dot(F, grad(f))
except:
return cls(Mul(*vectors), evaluate=False)
b = cls(Mul(*vectors), evaluate=False)
return Mul(a, b)
elif isinstance(expr, Cross):
a,b = expr._args
return Dot(b, Curl(a)) - Dot(a, Curl(b))
elif isinstance(expr, Curl):
return S.Zero
# ... check consistency between space type and the operator
if _is_sympde_atom(expr):
if not isinstance(expr.space.kind, (UndefinedSpaceType,
HdivSpaceType,
H1SpaceType)):
msg = '> Wrong space kind, given {}'.format(expr.space.kind)
raise ArgumentTypeError(msg)
# ...
return cls(expr, evaluate=False)
def eval(cls, *_args):
"""."""
if not _args:
return
if not len(_args) == 1:
raise ValueError('Expecting one argument')
expr = _args[0]
if isinstance(expr, Add):
args = expr.args
args = [cls.eval(a) for a in expr.args]
return Add(*args)
elif isinstance(expr, Mul):
coeffs = [a for a in expr.args if isinstance(a, _coeffs_registery)]
vectors = [a for a in expr.args if not(a in coeffs)]
a = S.One
if coeffs:
a = Mul(*coeffs)
b = S.One
if vectors:
if len(vectors) == 2:
a,b = vectors
if isinstance(a, (Tuple, VectorTestFunction, VectorField,
Grad)):
f = b ; F = a
return f*Curl(F) + Cross(grad(f), F)
elif isinstance(b, (Tuple, VectorTestFunction, VectorField,
Grad)):
f = a ; F = b
return f*Curl(F) + Cross(grad(f), F)
b = cls(Mul(*vectors), evaluate=False)
return Mul(a, b)
elif isinstance(expr, Cross):
try:
a,b = expr._args
return a * Div(b) - b*Div(a) + Convect(b, a) - Convect(a, b)
except:
return cls(expr, evaluate=False)
elif isinstance(expr, Grad):
return S.Zero
elif isinstance(expr, Curl):
f = expr._args[0]
return Grad(Div(f)) - Laplace(f)
# ... check consistency between space type and the operator
if _is_sympde_atom(expr):
if not isinstance(expr.space.kind, (UndefinedSpaceType,
HcurlSpaceType,
H1SpaceType)):
msg = '> Wrong space kind, given {}'.format(expr.space.kind)
raise ArgumentTypeError(msg)
# ...
return cls(expr, evaluate=False)
def eval(cls, *_args):
"""."""
if not _args:
return
if not len(_args) == 1:
raise ValueError('Expecting one argument')
expr = _args[0]
if isinstance(expr, Add):
args = [cls.eval(a) for a in expr.args]
return Add(*args)
elif isinstance(expr, Mul):
coeffs = [a for a in expr.args if isinstance(a, _coeffs_registery)]
vectors = [a for a in expr.args if not(a in coeffs)]
a = S.One
if coeffs:
a = Mul(*coeffs)
b = S.One
if vectors:
try:
if len(vectors) == 1:
f = vectors[0]
b = cls(f)
elif len(vectors) == 2:
f,g = vectors
b = f*cls(g) + g*cls(f)
else:
left = vectors[0]
right = Mul(*vectors[1:])
f_left = cls(left, evaluate=True)
f_right = cls(right, evaluate=True)
b = left * f_right + f_left * right
except:
b = cls(Mul(*vectors), evaluate=False)
return Mul(a, b)
elif isinstance(expr, Pow): # TODO: fix this for the case where e is not a number
b = expr.base
e = expr.exp
return e*cls(b)*Pow(b, e-1)
elif isinstance(expr, Dot):
try:
a,b = expr._args
return Cross(a, Curl(b)) - Cross(Curl(a), b) + Convect(a,b) + Convect(b,a)
except:
return cls(expr, evaluate=False)
elif isinstance(expr, _coeffs_registery):
return S.Zero
# ... check consistency between space type and the operator
if _is_sympde_atom(expr):
if not isinstance(expr.space.kind, (UndefinedSpaceType, H1SpaceType)):
msg = '> Wrong space kind, given {}'.format(expr.space.kind)
raise ArgumentTypeError(msg)
# ...
return cls(expr, evaluate=False)
def eval(cls, *_args):
"""."""
if not _args:
return
if not len(_args) == 2:
raise ValueError('Expecting two arguments')
left,right = _args
if (left == 0) or (right == 0):
return 0
# ...
if isinstance(left, Add):
args = [cls.eval(i, right) for i in left.args]
return Add(*args)
# ...
# ...
if isinstance(right, Add):
args = [cls.eval(left, i) for i in right.args]
return Add(*args)
# ...
# ... from now on, we construct left and right with some coeffs
# return is done at the end
alpha = S.One
if isinstance(left, Mul):
coeffs = [a for a in left.args if isinstance(a, _coeffs_registery)]
vectors = [a for a in left.args if not(a in coeffs)]
a = S.One
if coeffs:
a = Mul(*coeffs)
b = S.One
if vectors:
b = Mul(*vectors)
alpha *= a
left = b
if isinstance(right, Mul):
coeffs = [a for a in right.args if isinstance(a, _coeffs_registery)]
vectors = [a for a in right.args if not(a in coeffs)]
a = S.One
if coeffs:
a = Mul(*coeffs)
b = S.One
if vectors:
b = Mul(*vectors)
alpha *= a
right = b
# ...
if isinstance(right, _coeffs_registery):
return S.Zero
# ... check consistency between space type and the operator
# TODO add appropriate space types
if _is_sympde_atom(right):
if not isinstance(right.space.kind, UndefinedSpaceType):
msg = '> Wrong space kind, given {}'.format(right.space.kind)
raise ArgumentTypeError(msg)
# ...
return alpha*cls(left, right, evaluate=False)