def test_matrix():
A = Matrix([[x, y], [y*x, z**2]])
assert lambdarepr(A) == "MutableDenseMatrix([[x, y], [x*y, z**2]])"
# Test printing a Matrix that has an element that is printed differently
# with the LambdaPrinter than in the StrPrinter.
p = Piecewise((x, True), evaluate=False)
A = Matrix([p])
assert lambdarepr(A) == "MutableDenseMatrix([[((x) if (True) else None)]])"
def test_matrix():
A = Matrix([[x, y], [y*x, z**2]])
assert lambdarepr(A) == "ImmutableDenseMatrix([[x, y], [x*y, z**2]])"
# Test printing a Matrix that has an element that is printed differently
# with the LambdaPrinter than in the StrPrinter.
p = Piecewise((x, True), evaluate=False)
A = Matrix([p])
assert lambdarepr(A) == "ImmutableDenseMatrix([[((x) if (True) else None)]])"
def lambdastr(args, expr, printer=None):
"""
Returns a string that can be evaluated to a lambda function.
>>> from sympy.abc import x, y, z
>>> from sympy.utilities.lambdify import lambdastr
>>> lambdastr(x, x**2)
'lambda x: (x**2)'
>>> lambdastr((x,y,z), [z,y,x])
'lambda x,y,z: ([z, y, x])'
"""
if printer is not None:
if inspect.isfunction(printer):
lambdarepr = printer
else:
if inspect.isclass(printer):
lambdarepr = lambda expr: printer().doprint(expr)
else:
lambdarepr = lambda expr: printer.doprint(expr)
else:
#XXX: This has to be done here because of circular imports
from sympy.printing.lambdarepr import lambdarepr
# Transform everything to strings.
expr = lambdarepr(expr)
if isinstance(args, str):
pass
elif hasattr(args, "__iter__"):
args = ",".join(str(a) for a in args)
else:
args = str(args)
return "lambda %s: (%s)" % (args, expr)
def lambdastr(args, expr, printer=None):
"""
Returns a string that can be evaluated to a lambda function.
>>> from sympy.abc import x, y, z
>>> from sympy.utilities.lambdify import lambdastr
>>> lambdastr(x, x**2)
'lambda x: (x**2)'
>>> lambdastr((x,y,z), [z,y,x])
'lambda x,y,z: ([z, y, x])'
"""
if printer is not None:
if inspect.isfunction(printer):
lambdarepr = printer
else:
if inspect.isclass(printer):
lambdarepr = lambda expr: printer().doprint(expr)
else:
lambdarepr = lambda expr: printer.doprint(expr)
else:
#XXX: This has to be done here because of circular imports
from sympy.printing.lambdarepr import lambdarepr
# Transform everything to strings.
expr = lambdarepr(expr)
if isinstance(args, str):
pass
elif hasattr(args, "__iter__"):
args = ",".join(str(a) for a in args)
else:
args = str(args)
return "lambda %s: (%s)" % (args, expr)
def lambdastr(args, expr):
"""
Returns a string that can be evaluated to a lambda function.
>>> from sympy import symbols
>>> x,y,z = symbols('xyz')
>>> lambdastr(x, x**2)
'lambda x: (x**2)'
>>> lambdastr((x,y,z), [z,y,x])
'lambda x,y,z: ([z, y, x])'
"""
#XXX: This has to be done here because of circular imports
from sympy.printing.lambdarepr import lambdarepr
# Transform everything to strings.
expr = lambdarepr(expr)
if isinstance(args, str):
pass
elif hasattr(args, "__iter__"):
args = ",".join(str(a) for a in args)
else:
args = str(args)
return "lambda %s: (%s)" % (args, expr)
def test_piecewise():
p = Piecewise(
(x, x < 1),
(x**2, Interval(3, 4, True, False)),
(0, True)
)
assert lambdarepr(p) == 'iff(x < 1,x,iff(((x <= 4) and (3 < x)),x**2,iff(True,0,0)))'
def test_piecewise():
p = Piecewise(
(x, x < 1),
(x**2, Interval(3, 4, True, False)),
(0, True)
)
assert lambdarepr(p) == 'iff(x < 1,x,iff(((x <= 4) and (3 < x)),x**2,iff(True,0,0)))'
def lambdarepr(self):
"""
"""
from sympy.printing.lambdarepr import lambdarepr
temp_arr=numpy.empty(self.getShape(), dtype=object)
for idx,el in numpy.ndenumerate(self._arr):
atoms=el.atoms(sympy.Symbol) if isinstance(el,sympy.Basic) else []
# create a dictionary to convert names like [x]_0_0 to x[0,0]
symdict={}
for a in atoms:
n,c=Symbol._symComp(a)
if len(c)>0:
c=[str(i) for i in c]
symstr=n+'['+','.join(c)+']'
else:
symstr=n
symdict[a.name]=symstr
s=lambdarepr(el)
for key in symdict:
s=s.replace(key, symdict[key])
temp_arr[idx]=s
if self.getRank()==0:
return temp_arr.item()
else:
return 'combineData(%s,%s)'%(str(temp_arr.tolist()).replace("'",""),str(self.getShape()))
def lambdarepr(self):
"""
"""
from sympy.printing.lambdarepr import lambdarepr
temp_arr=numpy.empty(self.getShape(), dtype=object)
for idx,el in numpy.ndenumerate(self._arr):
atoms=el.atoms(sympy.Symbol) if isinstance(el,sympy.Basic) else []
# create a dictionary to convert names like [x]_0_0 to x[0,0]
symdict={}
for a in atoms:
n,c=Symbol._symComp(a)
if len(c)>0:
c=[str(i) for i in c]
symstr=n+'['+','.join(c)+']'
else:
symstr=n
symdict[a.name]=symstr
s=lambdarepr(el)
for key in symdict:
s=s.replace(key, symdict[key])
temp_arr[idx]=s
if self.getRank()==0:
return temp_arr.item()
else:
return 'combineData(%s,%s)'%(str(temp_arr.tolist()).replace("'",""),str(self.getShape()))
def lambdastr(args, expr):
"""
Returns a string that can be evaluated to a lambda function.
>>> from sympy import symbols
>>> x,y,z = symbols('xyz')
>>> lambdastr(x, x**2)
'lambda x: (x**2)'
>>> lambdastr((x,y,z), [z,y,x])
'lambda x,y,z: ([z, y, x])'
"""
#XXX: This has to be done here because of circular imports
from sympy.printing.lambdarepr import lambdarepr
# Transform everything to strings.
expr = lambdarepr(expr)
if isinstance(args, str):
pass
elif hasattr(args, "__iter__"):
args = ",".join(str(a) for a in args)
else:
args = str(args)
return "lambda %s: (%s)" % (args, expr)
def test_multiple_sums():
s = Sum(i * x + j, (i, a, b), (j, c, d))
l = lambdarepr(s)
assert l == "(builtins.sum(i*x + j for i in range(a, b+1) for j in range(c, d+1)))"
assert (lambdify((x, a, b, c, d), s)(2, 3, 4, 5, 6) ==
s.subs([(x, 2), (a, 3), (b, 4), (c, 5), (d, 6)]).doit())
def __get_symbols_str_from_interim_res(self, expressions,
sympy_import_name) -> str:
# Create a sympy symbols command for interim result
if len(expressions) == 0:
return ''
symbols = list(map(lambda e: lambdarepr(e[0]), expressions))
return self.__get_symbols(symbols, sympy_import_name)
def test_sum__2():
s = Sum(i * x, (i, a, b))
l = lambdarepr(s)
assert l == "(builtins.sum(i*x for i in range(a, b+1)))"
args = x, a, b
f = lambdify(args, s)
v = 2, 3, 8
assert f(*v) == s.subs(zip(args, v)).doit()
def test_sum__2():
s = Sum(i * x, (i, a, b))
l = lambdarepr(s)
assert l == "(builtins.sum(i*x for i in range(a, b+1)))"
args = x, a, b
f = lambdify(args, s)
v = 2, 3, 8
assert f(*v) == s.subs(zip(args, v)).doit()
def test_piecewise():
# In each case, test eval() the lambdarepr() to make sure there are a
# correct number of parentheses. It will give a SyntaxError if there aren't.
h = "lambda x: "
p = Piecewise((x, True), evaluate=False)
l = lambdarepr(p)
eval(h + l)
assert l == "((x) if (True) else None)"
p = Piecewise((x, x < 0))
l = lambdarepr(p)
eval(h + l)
assert l == "((x) if (x < 0) else None)"
p = Piecewise((1, x < 1), (2, x < 2), (0, True))
l = lambdarepr(p)
eval(h + l)
assert l == "((1) if (x < 1) else (((2) if (x < 2) else (((0) if (True) " "else None)))))"
p = Piecewise((1, x < 1), (2, x < 2))
l = lambdarepr(p)
eval(h + l)
assert l == "((1) if (x < 1) else (((2) if (x < 2) else None)))"
p = Piecewise((x, x < 1), (x ** 2, Interval(3, 4, True, False)), (0, True))
l = lambdarepr(p)
eval(h + l)
assert l == "((x) if (x < 1) else (((x**2) if (((x <= 4) " "and (3 < x))) else (((0) if (True) else None)))))"
p = Piecewise((x ** 2, x < 0), (x, Interval(0, 1, False, True)), (2 - x, x >= 1), (0, True))
l = lambdarepr(p)
eval(h + l)
assert (
l == "((x**2) if (x < 0) else (((x) if (((x < 1) and (0 <= x))) "
"else (((-x + 2) if (1 <= x) else (((0) if (True) else None)))))))"
)
p = Piecewise((x ** 2, x < 0), (x, Interval(0, 1, False, True)), (2 - x, x >= 1))
l = lambdarepr(p)
eval(h + l)
assert (
l == "((x**2) if (x < 0) else (((x) if (((x < 1) and " "(0 <= x))) else (((-x + 2) if (1 <= x) else None)))))"
)
p = Piecewise((1, x < 1), (2, x < 2), (3, x < 3), (4, x < 4), (5, x < 5), (6, True))
l = lambdarepr(p)
eval(h + l)
assert (
l == "((1) if (x < 1) else (((2) if (x < 2) else (((3) if "
"(x < 3) else (((4) if (x < 4) else (((5) if (x < 5) else (((6) if "
"(True) else None)))))))))))"
)
def test_sum():
# In each case, test eval() the lambdarepr() to make sure that
# it evaluates to the same results as the symbolic expression
s = Sum(x**i, (i, a, b))
l = lambdarepr(s)
assert l == "(builtins.sum(x**i for i in range(a, b+1)))"
assert (lambdify((x, a, b), s)(2, 3, 8) == s.subs([(x, 2), (a, 3),
(b, 8)]).doit())
s = Sum(i * x, (i, a, b))
l = lambdarepr(s)
assert l == "(builtins.sum(i*x for i in range(a, b+1)))"
assert (lambdify((x, a, b), s)(2, 3, 8) == s.subs([(x, 2), (a, 3),
(b, 8)]).doit())
def test_sum():
# In each case, test eval() the lambdarepr() to make sure that
# it evaluates to the same results as the symbolic expression
s = Sum(x ** i, (i, a, b))
l = lambdarepr(s)
assert l == "(builtins.sum(x**i for i in range(a, b+1)))"
assert (lambdify((x, a, b), s)(2, 3, 8) ==
s.subs([(x, 2), (a, 3), (b, 8)]).doit())
s = Sum(i * x, (i, a, b))
l = lambdarepr(s)
assert l == "(builtins.sum(i*x for i in range(a, b+1)))"
assert (lambdify((x, a, b), s)(2, 3, 8) ==
s.subs([(x, 2), (a, 3), (b, 8)]).doit())
def test_sum__1():
# In each case, test eval() the lambdarepr() to make sure that
# it evaluates to the same results as the symbolic expression
s = Sum(x**i, (i, a, b))
l = lambdarepr(s)
assert l == "(builtins.sum(x**i for i in range(a, b+1)))"
args = x, a, b
f = lambdify(args, s)
v = 2, 3, 8
assert f(*v) == s.subs(zip(args, v)).doit()
def test_sum__1():
# In each case, test eval() the lambdarepr() to make sure that
# it evaluates to the same results as the symbolic expression
s = Sum(x ** i, (i, a, b))
l = lambdarepr(s)
assert l == "(builtins.sum(x**i for i in range(a, b+1)))"
args = x, a, b
f = lambdify(args, s)
v = 2, 3, 8
assert f(*v) == s.subs(zip(args, v)).doit()
def test_multiple_sums():
s = Sum(i * x + j, (i, a, b), (j, c, d))
l = lambdarepr(s)
assert l == "(builtins.sum(i*x + j for i in range(a, b+1) for j in range(c, d+1)))"
args = x, a, b, c, d
f = lambdify(args, s)
vals = 2, 3, 4, 5, 6
f_ref = s.subs(zip(args, vals)).doit()
f_res = f(*vals)
assert f_res == f_ref
def test_multiple_sums():
s = Sum(i * x + j, (i, a, b), (j, c, d))
l = lambdarepr(s)
assert l == "(builtins.sum(i*x + j for i in range(a, b+1) for j in range(c, d+1)))"
args = x, a, b, c, d
f = lambdify(args, s)
vals = 2, 3, 4, 5, 6
f_ref = s.subs(zip(args, vals)).doit()
f_res = f(*vals)
assert f_res == f_ref
def callback_factory(args, expr, module, use_numba=False):
if module == 'numpy':
from sympy.utilities.lambdify import NUMPY_TRANSLATIONS as TRANSLATIONS
from sympy.printing.lambdarepr import NumPyPrinter as Printer
def lambdarepr(_x):
return Printer().doprint(_x)
else:
from sympy.printing.lambdarepr import lambdarepr
if module == 'mpmath':
from sympy.utilities.lambdify import MPMATH_TRANSLATIONS as TRANSLATIONS
elif module == 'sympy':
TRANSLATIONS = {}
else:
raise NotImplementedError("Lambdify does not yet support %s" % module)
mod = __import__(module)
from sympy import IndexedBase, Symbol
x = IndexedBase('x')
indices = [Symbol('..., %d' % i) for i in range(len(args))]
dummy_subs = dict(zip(args, [x[i] for i in indices]))
dummified = expr.xreplace(dummy_subs)
estr = lambdarepr(dummified)
namespace = mod.__dict__.copy()
# e.g. NumPyPrinter incomplete: https://github.com/sympy/sympy/issues/11023
# we need to read translations from lambdify
for k, v in TRANSLATIONS.items():
namespace[k] = namespace[v]
if module != 'mpmath':
namespace['Abs'] = abs
func = eval('lambda x: %s' % estr, namespace)
if use_numba:
from numba import njit
func = njit(func)
if module == 'numpy':
def wrapper(x):
return func(mod.asarray(x, dtype=mod.float64))
else:
wrapper = func
wrapper.__doc__ = estr
return wrapper
def evalf(eqn, context):
from sympy.printing.lambdarepr import lambdarepr
return eval(lambdarepr(eqn), {}, context)
def test_settings():
raises(TypeError, lambda: lambdarepr(sin(x), method="garbage"))
def lambdastr(args, expr, printer=None, dummify=False):
"""
Returns a string that can be evaluated to a lambda function.
>>> from sympy.abc import x, y, z
>>> from sympy.utilities.lambdify import lambdastr
>>> lambdastr(x, x**2)
'lambda x: (x**2)'
>>> lambdastr((x,y,z), [z,y,x])
'lambda x,y,z: ([z, y, x])'
"""
# Transforming everything to strings.
from sympy.matrices import DeferredVector
from sympy import Dummy, sympify, Symbol, Function
if printer is not None:
if inspect.isfunction(printer):
lambdarepr = printer
else:
if inspect.isclass(printer):
lambdarepr = lambda expr: printer().doprint(expr)
else:
lambdarepr = lambda expr: printer.doprint(expr)
else:
#XXX: This has to be done here because of circular imports
from sympy.printing.lambdarepr import lambdarepr
def sub_args(args, dummies_dict):
if isinstance(args, str):
return args
elif isinstance(args, DeferredVector):
return str(args)
elif iterable(args):
flatten = lambda *n: (e for a in n
for e in (flatten(*a)
if iterable(a) else (a, )))
dummies = flatten([sub_args(a, dummies_dict) for a in args])
return ",".join(str(a) for a in dummies)
else:
if isinstance(args, Function):
dummies = Dummy()
dummies_dict.update({args: dummies})
return str(dummies)
else:
return str(args)
def sub_expr(expr, dummies_dict):
try:
expr = sympify(expr).xreplace(dummies_dict)
except:
if isinstance(expr, DeferredVector):
pass
elif isinstance(expr, dict):
k = [sub_expr(sympify(a), dummies_dict) for a in expr.keys()]
v = [sub_expr(sympify(a), dummies_dict) for a in expr.values()]
expr = dict(zip(k, v))
elif isinstance(expr, tuple):
expr = tuple(sub_expr(sympify(a), dummies_dict) for a in expr)
elif isinstance(expr, list):
expr = [sub_expr(sympify(a), dummies_dict) for a in expr]
return expr
# Transform args
dummies_dict = {}
if dummify:
args = sub_args(args, dummies_dict)
else:
if isinstance(args, str):
pass
elif iterable(args, exclude=DeferredVector):
args = ",".join(str(a) for a in args)
# Transform expr
if dummify:
if isinstance(expr, str):
pass
else:
expr = sub_expr(expr, dummies_dict)
expr = lambdarepr(expr)
return "lambda %s: (%s)" % (args, expr)
def test_matrix():
# Test printing a Matrix that has an element that is printed differently
# with the LambdaPrinter than with the StrPrinter.
e = x % 2
assert lambdarepr(e) != str(e)
assert lambdarepr(Matrix([e])) == 'ImmutableDenseMatrix([[x % 2]])'
def main():
init_printing(use_unicode=False, wrap_line=False, no_global=True)
#init_printing(wrap_line=False)
# init_printing(use_latex='mathjax')
display = lambda x: sympy.pprint(x, use_unicode=False, wrap_line=False)
disp = lambda x: print(lambdarepr.lambdarepr(x))
sep = lambda: print('--------')
# ---
L = symbols('L')
theta_yaw, theta_tilt = symbols('theta_yaw,theta_tilt')
alpha_x, alpha_y, alpha_z = symbols('alpha_x,alpha_y,alpha_z')
ux1c, ux2c, ux3c, ux4c = symbols('ux1c,ux2c,ux3c,ux4c')
uy1c, uy2c, uy3c, uy4c = symbols('uy1c,uy2c,uy3c,uy4c')
uz1c, uz2c, uz3c, uz4c = symbols('uz1c,uz2c,uz3c,uz4c')
vx1c, vx2c, vx3c, vx4c = symbols('vx1c,vx2c,vx3c,vx4c')
vy1c, vy2c, vy3c, vy4c = symbols('vy1c,vy2c,vy3c,vy4c')
vz1c, vz2c, vz3c, vz4c = symbols('vz1c,vz2c,vz3c,vz4c')
rhoN_x, rhoN_y, rhoN_z = symbols(
'rhoN_x,rhoN_y,rhoN_z') # Position of Nac center of gravity in N
rNR_x, rNR_y, rNR_z = symbols(
'rNR_x,rNR_y,rNR_z') # Position of rotor center in N
# T_x,T_y,T_z = symbols('T_x,T_y,T_z') #Thurst components in nacelle system
T = symbols('T') #Thrust along the main shaft
M_RNA = symbols('M_RNA')
g = symbols('g')
subs = {}
subs.update({alpha_x: 0})
# subs.update({alpha_y:0})
subs.update({alpha_z: 0})
# alpha_z:0})
subs.update({ux1c: 1, ux2c: 1, ux3c: 1, ux4c: 1})
subs.update({uz1c: 1, uz2c: 1, uz3c: 1, uz4c: 1})
subs.update({uy1c: 1, uy2c: 1, uy3c: 1, uy4c: 1})
subs.update({theta_yaw: 0})
# subs.update({theta_tilt:0 })
# --- Main parameters
bTiltBeforeNac = False
main_axis = 'z'
nD = 1
theta_yaw = 0
nShapes_twr = 1
nShapes_bld = 0
nDOF = nShapes_twr + nShapes_bld * 3
q = np.zeros((nDOF, 1))
q[[0]] = 0
# q[[1]]=0.0
# q[[2]]=0*np.pi/4.
r_ET_inE = colvec([0, 0, 0])
r_TN_inT = colvec([0, 0, L])
g_inE = colvec([0, 0, -g])
r_NR_inN = colvec([rNR_x, 0, rNR_z])
rho_N_inN = colvec([rhoN_x, 0, rhoN_z])
# --- Independent bodies
Grd = GroundBody()
Twr = BeamBody('Twr', nShapes_twr, main_axis=main_axis, nD=nD)
Nac = RigidBody('Nac', 0, 0, 0)
# --- Connect bodies together
if bTiltBeforeNac:
# R_cn0 = R_z (theta_yaw) * R_y(theta_tilt)
R_cn0 = R_z(theta_yaw) * R_y(theta_tilt)
T_inN = colvec([T, 0, 0])
else:
R_cn0 = R_z(theta_yaw)
T_inN = colvec([T * cos(theta_tilt), 0, -T * sin(theta_tilt)])
Grd.connectTo(Twr, Point=r_ET_inE, Type='Rigid')
Twr.connectTo(Nac, Point=r_TN_inT, Type='Rigid', RelOrientation=R_cn0)
nq = Grd.setupDOFIndex(0)
print('Number of DOFs: ')
if nq != len(q):
print('>>> ', nq, len(q))
raise Exception('Wrong number of dof')
print(
'------------------ p=GROUND i=TOWER --------------------------------------'
)
Grd.updateChildrenKinematicsNonRecursive(q)
print(
'------------------ p=TOWER i=NACELLE --------------------------------------'
)
Twr.updateChildrenKinematicsNonRecursive(q)
print('------------------ TOWER --------------------------------------')
print('B_T')
display(Twr.B)
print(np.array(Twr.B.subs(subs)))
print('B_T_in_T')
display(Twr.B_inB)
print(np.array(Twr.B_inB.subs(subs)))
print('BB_T_in_T')
display(Twr.BB_inB)
print(np.array(Twr.BB_inB.subs(subs)))
print('------------------ NACELLE --------------------------------------')
print('B_N')
display(Nac.B)
print(np.array(Nac.B.subs(subs)))
print('B_N_in_N')
display(Nac.B_inB)
print(np.array(Nac.B_inB.subs(subs)))
print('BB_N_in_N')
display(Nac.BB_inB)
print(np.array(Nac.BB_inB.subs(subs)))
print(
'------------------ TOWER TOP FORCES IN EARTH--------------------------------------'
)
print('Thrust in E')
T_inE = Nac.R_0b * T_inN
display(T_inE)
print(np.array(T_inE.subs(subs)))
print('Moment from thrust in E')
r_NR_inE = Nac.R_0b * r_NR_inN
MT_inE = Matrix(cross(r_NR_inE, T_inE))
display(MT_inE)
print(np.array(MT_inE.subs(subs)))
W_inE = M_RNA * g_inE
rho_N_inE = Nac.R_0b * rho_N_inN
MW_inE = M_RNA * Matrix(cross(rho_N_inE, g_inE))
print('Moment from weight in E')
display(MW_inE)
print(np.array(MW_inE.subs(subs)))
print('FullForce in E')
F_inE = W_inE + T_inE
display(F_inE)
print(np.array(F_inE.subs(subs)))
print('Fullmoment in E at N')
M_inE = MW_inE + MT_inE
print(np.array(M_inE.subs(subs)))
print('FullLoad in E at N')
f_inE = Matrix(np.vstack((F_inE, M_inE)))
print(np.array(f_inE.subs(subs)))
print('')
print('Fx in E<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< ')
print(np.array(simplify(F_inE[0].subs(subs))))
print('')
print('My in E<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< ')
print(np.array(simplify(M_inE[1].subs(subs))))
print('')
print('Fz in E<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< ')
print(np.array(simplify(F_inE[2].subs(subs))))
print('')
print('Generalized force in E at N')
GF_N_fromE = Nac.B.T * f_inE
print(np.array(GF_N_fromE.subs(subs)))
print(
'------------------ TOWER TOP FORCES IN NAC--------------------------------------'
)
print('Thrust in N')
display(T_inN)
print(np.array(T_inN.subs(subs)))
print('Moment from thrust in N')
MT_inN = Matrix(cross(r_NR_inN, T_inN))
display(MT_inN)
print(np.array(MT_inN.subs(subs)))
g_inN = Nac.R_0b.T * g_inE
W_inN = M_RNA * g_inN
MW_inN = M_RNA * Matrix(cross(rho_N_inN, g_inN))
#
print('Moment from weight in N')
display(MW_inN)
print(np.array(MW_inN.subs(subs)))
print('FullForce in N')
F_inN = W_inN + T_inN
display(F_inN)
print(np.array(F_inN.subs(subs)))
print('Fullmoment in N at N')
M_inN = MW_inN + MT_inN
print(np.array(M_inN.subs(subs)))
print('FullLoad in E at N')
f_inN = Matrix(np.vstack((F_inN, M_inN)))
print(np.array(f_inE.subs(subs)))
print('Generalized force in N at N')
GF_N = Nac.B_inB.T * f_inN
print(np.array(GF_N.subs(subs)))
print('Generalized force in E at N')
print(np.array(GF_N_fromE.subs(subs)))
print('')
print('Generalized force simplified')
display(simplify(GF_N))
print('')
print('---------------------------')
display(simplify(GF_N - GF_N_fromE))
print('----------Fx in E----------')
display(simplify(F_inE[0]).subs(subs))
print('----------Fz in E----------')
display(simplify(F_inE[2]).subs(subs))
print('----------My in E----------')
display(simplify(M_inE[1]).subs(subs))
def set_content(self, interim_res: MasonResult):
# Build strings based on mason result
sympy_import_name = 'sp'
interim_strs = {
'det':
'determinant = {}'.format(lambdarepr(interim_res.determinant)),
'paths':
'paths = {}'.format(lambdarepr(interim_res.paths)),
'loops':
'loops = {}'.format(lambdarepr(interim_res.loops)),
'numerator':
'numerator = {}'.format(lambdarepr(interim_res.numerator)),
'denominator':
'denominator = {}'.format(lambdarepr(interim_res.denominator)),
'transfer_function':
'transfer_function = {}'.format(
lambdarepr(interim_res.transfer_function))
}
# Create full formula; the non-simplified versdion serves to
# derive the symbol list below
T = interim_res.transfer_function[0][0]
non_simplified = T.subs(interim_res.transfer_function) \
.subs(interim_res.numerator) \
.subs(interim_res.denominator) \
.subs(interim_res.determinant) \
.subs(interim_res.paths) \
.subs(interim_res.loops)
full_res = non_simplified.simplify()
t_evaluated_str = str(full_res)
# Combine all symbols to be on top for combined output, except the
# symbols of the forward paths
combined_symbols = ''
combined_symbols += self.__get_symbols_str_from_interim_res(
interim_res.determinant, sympy_import_name)
combined_symbols += self.__get_symbols_str_from_interim_res(
interim_res.loops, sympy_import_name)
combined_symbols += self.__get_symbols_str_from_interim_res(
interim_res.numerator, sympy_import_name)
combined_symbols += self.__get_symbols_str_from_interim_res(
interim_res.denominator, sympy_import_name)
combined_symbols += self.__get_symbols_str_from_interim_res(
interim_res.transfer_function, sympy_import_name)
combined_symbols += self.__get_symbols(
list(map(lambda x: str(x), non_simplified.free_symbols)),
sympy_import_name)
# Symbols of the forward path
path_symbols = self.__get_symbols_str_from_interim_res(
interim_res.paths, sympy_import_name)
# Now build the code that will be copied to the clipboard
# .. Import of sympy
combined_output = 'import sympy as {}\n'.format(sympy_import_name)
# .. all symbol definitions except for forward path
combined_output += combined_symbols
# calculation of the graph determinant
interim_outputs = '\n{loops}\n{det}\n{denominator}'
combined_output += interim_outputs.format_map(interim_strs)
# calculation of the forward path
interim_outputs = '{paths}\n{numerator}'
combined_output += '\n\n'
combined_output += path_symbols
combined_output += interim_outputs.format_map(interim_strs)
# calculation of transfer function
interim_outputs = '\n\n{transfer_function}'
combined_output += interim_outputs.format_map(interim_strs)
combined_output += '\nT=' + str(interim_res.transfer_function[0][0])
combined_output += '.subs(transfer_function).subs(numerator)'
combined_output += '.subs(denominator).subs(determinant).subs(paths)'
combined_output += '.subs(loops).simplify()'
combined_output += '\ndisplay(T)'
# Set combined output to clipboard
QApplication.clipboard().setText(combined_output)
# Set combined output to text browser
self.txt_brw_output.setPlainText(combined_output)
# Set evalulated result to text browser
self.txt_brw_eval.setPlainText(t_evaluated_str)
def set_content(self, interim_res: MasonResult):
# Build strings based on mason result
sympy_import_name = 'sp'
interim_strs = {
'det':
'determinant = {}'.format(lambdarepr(interim_res.determinant)),
'paths':
'paths = {}'.format(lambdarepr(interim_res.paths)),
'loops':
'loops = {}'.format(lambdarepr(interim_res.loops)),
'numerator':
'numerator = {}'.format(lambdarepr(interim_res.numerator)),
'denominator':
'denominator = {}'.format(lambdarepr(interim_res.denominator)),
'transfer_function':
'transfer_function = {}'.format(
lambdarepr(interim_res.transfer_function))
}
# Create full formula
T = interim_res.transfer_function[0][0]
full_res = T.subs(interim_res.transfer_function) \
.subs(interim_res.numerator) \
.subs(interim_res.denominator) \
.subs(interim_res.determinant) \
.subs(interim_res.paths) \
.subs(interim_res.loops) \
.simplify()
t_evaluated_str = str(full_res)
# Combine all symbols to be on top for combined output
combined_symbols = ''
combined_symbols += self.__get_symbols_str_from_interim_res(
interim_res.determinant, sympy_import_name)
combined_symbols += self.__get_symbols_str_from_interim_res(
interim_res.paths, sympy_import_name)
combined_symbols += self.__get_symbols_str_from_interim_res(
interim_res.loops, sympy_import_name)
combined_symbols += self.__get_symbols_str_from_interim_res(
interim_res.numerator, sympy_import_name)
combined_symbols += self.__get_symbols_str_from_interim_res(
interim_res.denominator, sympy_import_name)
combined_symbols += self.__get_symbols_str_from_interim_res(
interim_res.transfer_function, sympy_import_name)
combined_symbols += self.__get_symbols(
list(map(lambda x: str(x), full_res.free_symbols)),
sympy_import_name)
# Set combined output to clipboard
combined_output = 'import sympy as {}\n\n'.format(sympy_import_name)
combined_output += combined_symbols
# Build commands for interim results
interim_outputs = '\n{det}\n{paths}\n{loops}\n{numerator}'
interim_outputs += '\n{denominator}\n{transfer_function}'
combined_output += interim_outputs.format_map(interim_strs)
# Append substitution
combined_output += '\n\n' + str(interim_res.transfer_function[0][0])
combined_output += '.subs(transfer_function).subs(numerator)'
combined_output += '.subs(denominator).subs(determinant).subs(paths)'
combined_output += '.subs(loops)'
# Set combined output to clipboard
QApplication.clipboard().setText(combined_output)
# Set combined output to text browser
self.txt_brw_output.setPlainText(combined_output)
# Set evalulated result to text browser
self.txt_brw_eval.setPlainText(t_evaluated_str)
def lambdastr(args, expr, printer=None, dummify=None):
"""
Returns a string that can be evaluated to a lambda function.
Examples
========
>>> from sympy.abc import x, y, z
>>> from sympy.utilities.lambdify import lambdastr
>>> lambdastr(x, x**2)
'lambda x: (x**2)'
>>> lambdastr((x,y,z), [z,y,x])
'lambda x,y,z: ([z, y, x])'
Although tuples may not appear as arguments to lambda in Python 3,
lambdastr will create a lambda function that will unpack the original
arguments so that nested arguments can be handled:
>>> lambdastr((x, (y, z)), x + y)
'lambda _0,_1: (lambda x,y,z: (x + y))(_0,_1[0],_1[1])'
"""
# Transforming everything to strings.
from sympy.matrices import DeferredVector
from sympy import Dummy, sympify, Symbol, Function, flatten, Derivative, Basic
if printer is not None:
if inspect.isfunction(printer):
lambdarepr = printer
else:
if inspect.isclass(printer):
lambdarepr = lambda expr: printer().doprint(expr)
else:
lambdarepr = lambda expr: printer.doprint(expr)
else:
#XXX: This has to be done here because of circular imports
from sympy.printing.lambdarepr import lambdarepr
def sub_args(args, dummies_dict):
if isinstance(args, string_types):
return args
elif isinstance(args, DeferredVector):
return str(args)
elif iterable(args):
dummies = flatten([sub_args(a, dummies_dict) for a in args])
return ",".join(str(a) for a in dummies)
else:
# replace these with Dummy symbols
if isinstance(args, (Function, Symbol, Derivative)):
dummies = Dummy()
dummies_dict.update({args: dummies})
return str(dummies)
else:
return str(args)
def sub_expr(expr, dummies_dict):
try:
expr = sympify(expr).xreplace(dummies_dict)
except Exception:
if isinstance(expr, DeferredVector):
pass
elif isinstance(expr, dict):
k = [sub_expr(sympify(a), dummies_dict) for a in expr.keys()]
v = [sub_expr(sympify(a), dummies_dict) for a in expr.values()]
expr = dict(zip(k, v))
elif isinstance(expr, tuple):
expr = tuple(sub_expr(sympify(a), dummies_dict) for a in expr)
elif isinstance(expr, list):
expr = [sub_expr(sympify(a), dummies_dict) for a in expr]
return expr
# Transform args
def isiter(l):
return iterable(l, exclude=(str, DeferredVector, NotIterable))
def flat_indexes(iterable):
n = 0
for el in iterable:
if isiter(el):
for ndeep in flat_indexes(el):
yield (n, ) + ndeep
else:
yield (n, )
n += 1
if dummify is None:
dummify = any(
isinstance(a, Basic) and a.atoms(Function, Derivative)
for a in (args if isiter(args) else [args]))
if isiter(args) and any(isiter(i) for i in args):
dum_args = [str(Dummy(str(i))) for i in range(len(args))]
indexed_args = ','.join([
dum_args[ind[0]] + ''.join(["[%s]" % k for k in ind[1:]])
for ind in flat_indexes(args)
])
lstr = lambdastr(flatten(args), expr, printer=printer, dummify=dummify)
return 'lambda %s: (%s)(%s)' % (','.join(dum_args), lstr, indexed_args)
dummies_dict = {}
if dummify:
args = sub_args(args, dummies_dict)
else:
if isinstance(args, string_types):
pass
elif iterable(args, exclude=DeferredVector):
args = ",".join(str(a) for a in args)
# Transform expr
if dummify:
if isinstance(expr, string_types):
pass
else:
expr = sub_expr(expr, dummies_dict)
expr = lambdarepr(expr)
return "lambda %s: (%s)" % (args, expr)
def lambdastr(args, expr, printer=None, dummify=None):
"""
Returns a string that can be evaluated to a lambda function.
Examples
========
>>> from sympy.abc import x, y, z
>>> from sympy.utilities.lambdify import lambdastr
>>> lambdastr(x, x**2)
'lambda x: (x**2)'
>>> lambdastr((x,y,z), [z,y,x])
'lambda x,y,z: ([z, y, x])'
Although tuples may not appear as arguments to lambda in Python 3,
lambdastr will create a lambda function that will unpack the original
arguments so that nested arguments can be handled:
>>> lambdastr((x, (y, z)), x + y)
'lambda _0,_1: (lambda x,y,z: (x + y))(_0,_1[0],_1[1])'
"""
# Transforming everything to strings.
from sympy.matrices import DeferredVector
from sympy import Dummy, sympify, Symbol, Function, flatten, Derivative, Basic
if printer is not None:
if inspect.isfunction(printer):
lambdarepr = printer
else:
if inspect.isclass(printer):
lambdarepr = lambda expr: printer().doprint(expr)
else:
lambdarepr = lambda expr: printer.doprint(expr)
else:
#XXX: This has to be done here because of circular imports
from sympy.printing.lambdarepr import lambdarepr
def sub_args(args, dummies_dict):
if isinstance(args, str):
return args
elif isinstance(args, DeferredVector):
return str(args)
elif iterable(args):
dummies = flatten([sub_args(a, dummies_dict) for a in args])
return ",".join(str(a) for a in dummies)
else:
# replace these with Dummy symbols
if isinstance(args, (Function, Symbol, Derivative)):
dummies = Dummy()
dummies_dict.update({args : dummies})
return str(dummies)
else:
return str(args)
def sub_expr(expr, dummies_dict):
try:
expr = sympify(expr).xreplace(dummies_dict)
except Exception:
if isinstance(expr, DeferredVector):
pass
elif isinstance(expr, dict):
k = [sub_expr(sympify(a), dummies_dict) for a in expr.keys()]
v = [sub_expr(sympify(a), dummies_dict) for a in expr.values()]
expr = dict(zip(k, v))
elif isinstance(expr, tuple):
expr = tuple(sub_expr(sympify(a), dummies_dict) for a in expr)
elif isinstance(expr, list):
expr = [sub_expr(sympify(a), dummies_dict) for a in expr]
return expr
# Transform args
def isiter(l):
return iterable(l, exclude=(str, DeferredVector, NotIterable))
def flat_indexes(iterable):
n = 0
for el in iterable:
if isiter(el):
for ndeep in flat_indexes(el):
yield (n,) + ndeep
else:
yield (n,)
n += 1
if dummify is None:
dummify = any(isinstance(a, Basic) and
a.atoms(Function, Derivative) for a in (
args if isiter(args) else [args]))
if isiter(args) and any(isiter(i) for i in args):
dum_args = [str(Dummy(str(i))) for i in range(len(args))]
indexed_args = ','.join([
dum_args[ind[0]] + ''.join(["[%s]" % k for k in ind[1:]])
for ind in flat_indexes(args)])
lstr = lambdastr(flatten(args), expr, printer=printer, dummify=dummify)
return 'lambda %s: (%s)(%s)' % (','.join(dum_args), lstr, indexed_args)
dummies_dict = {}
if dummify:
args = sub_args(args, dummies_dict)
else:
if isinstance(args, str):
pass
elif iterable(args, exclude=DeferredVector):
args = ",".join(str(a) for a in args)
# Transform expr
if dummify:
if isinstance(expr, str):
pass
else:
expr = sub_expr(expr, dummies_dict)
expr = lambdarepr(expr)
return "lambda %s: (%s)" % (args, expr)
def test_piecewise():
# In each case, test eval() the lambdarepr() to make sure there are a
# correct number of parentheses. It will give a SyntaxError if there aren't.
h = "lambda x: "
p = Piecewise((x, True), evaluate=False)
l = lambdarepr(p)
eval(h + l)
assert l == "((x) if (True) else None)"
p = Piecewise((x, x < 0))
l = lambdarepr(p)
eval(h + l)
assert l == "((x) if (x < 0) else None)"
p = Piecewise((1, x < 1), (2, x < 2), (0, True))
l = lambdarepr(p)
eval(h + l)
assert l == "((1) if (x < 1) else (((2) if (x < 2) else (((0) if (True) "\
"else None)))))"
p = Piecewise(
(1, x < 1),
(2, x < 2),
)
l = lambdarepr(p)
eval(h + l)
assert l == "((1) if (x < 1) else (((2) if (x < 2) else None)))"
p = Piecewise(
(x, x < 1),
(x**2, Interval(3, 4, True, False)),
(0, True),
)
l = lambdarepr(p)
eval(h + l)
assert l == "((x) if (x < 1) else (((x**2) if (((x <= 4) "\
"and (3 < x))) else (((0) if (True) else None)))))"
p = Piecewise((x**2, x < 0), (x, Interval(0, 1, False, True)),
(2 - x, x >= 1), (0, True))
l = lambdarepr(p)
eval(h + l)
assert l == "((x**2) if (x < 0) else (((x) if (((x < 1) and (0 <= x))) "\
"else (((-x + 2) if (1 <= x) else (((0) if (True) else None)))))))"
p = Piecewise(
(x**2, x < 0),
(x, Interval(0, 1, False, True)),
(2 - x, x >= 1),
)
l = lambdarepr(p)
eval(h + l)
assert l == "((x**2) if (x < 0) else (((x) if (((x < 1) and "\
"(0 <= x))) else (((-x + 2) if (1 <= x) else None)))))"
p = Piecewise((1, x < 1), (2, x < 2), (3, x < 3), (4, x < 4), (5, x < 5),
(6, True))
l = lambdarepr(p)
eval(h + l)
assert l == "((1) if (x < 1) else (((2) if (x < 2) else (((3) if "\
"(x < 3) else (((4) if (x < 4) else (((5) if (x < 5) else (((6) if "\
"(True) else None)))))))))))"
def test_matrix():
A = Matrix([[x, y], [y * x, z**2]])
assert lambdarepr(A) == "Matrix([[ x, y],[x*y, z**2]])"
def lambdastr(args, expr, printer=None, dummify=False):
"""
Returns a string that can be evaluated to a lambda function.
>>> from sympy.abc import x, y, z
>>> from sympy.utilities.lambdify import lambdastr
>>> lambdastr(x, x**2)
'lambda x: (x**2)'
>>> lambdastr((x,y,z), [z,y,x])
'lambda x,y,z: ([z, y, x])'
"""
# Transforming everything to strings.
from sympy.matrices import DeferredVector
from sympy import Dummy, sympify, Symbol, Function
if printer is not None:
if inspect.isfunction(printer):
lambdarepr = printer
else:
if inspect.isclass(printer):
lambdarepr = lambda expr: printer().doprint(expr)
else:
lambdarepr = lambda expr: printer.doprint(expr)
else:
#XXX: This has to be done here because of circular imports
from sympy.printing.lambdarepr import lambdarepr
def sub_args(args, dummies_dict):
if isinstance(args, str):
return args
elif isinstance(args, DeferredVector):
return str(args)
elif iterable(args):
flatten = lambda *n: (e for a in n for e in
(flatten(*a) if iterable(a) else (a,)))
dummies = flatten([sub_args(a, dummies_dict) for a in args])
return ",".join(str(a) for a in dummies)
else:
if isinstance(args, Function):
dummies = Dummy()
dummies_dict.update({args : dummies})
return str(dummies)
else:
return str(args)
def sub_expr(expr, dummies_dict):
try:
expr = sympify(expr).xreplace(dummies_dict)
except:
if isinstance(expr, DeferredVector):
pass
elif isinstance(expr, dict):
k = [sub_expr(sympify(a), dummies_dict) for a in expr.keys()]
v = [sub_expr(sympify(a), dummies_dict) for a in expr.values()]
expr = dict(zip(k, v))
elif isinstance(expr, tuple):
expr = tuple(sub_expr(sympify(a), dummies_dict) for a in expr)
elif isinstance(expr, list):
expr = [sub_expr(sympify(a), dummies_dict) for a in expr]
return expr
# Transform args
dummies_dict = {}
if dummify:
args = sub_args(args, dummies_dict)
else:
if isinstance(args, str):
pass
elif iterable(args, exclude=DeferredVector):
args = ",".join(str(a) for a in args)
# Transform expr
if dummify:
if isinstance(expr, str):
pass
else:
expr = sub_expr(expr, dummies_dict)
expr = lambdarepr(expr)
return "lambda %s: (%s)" % (args, expr)
def test_settings():
raises(TypeError, lambda: lambdarepr(sin(x), method="garbage"))
def test_basic():
assert lambdarepr(x * y) == "x*y"
assert lambdarepr(x + y) in ["y + x", "x + y"]
assert lambdarepr(x**y) == "x**y"
def lambdastr(args, expr, printer=None, dummify=False):
"""
Returns a string that can be evaluated to a lambda function.
Examples
========
>>> from sympy.abc import x, y, z
>>> from sympy.utilities.lambdify import lambdastr
>>> lambdastr(x, x**2)
'lambda x: (x**2)'
>>> lambdastr((x,y,z), [z,y,x])
'lambda x,y,z: ([z, y, x])'
Although tuples may not appear as arguments to lambda in Python 3,
lambdastr will create a lambda function that will unpack the original
arguments so that nested arguments can be handled:
>>> lambdastr((x, (y, z)), x + y)
'lambda _0,_1: (lambda x,y,z: (x + y))(*list(__flatten_args__([_0,_1])))'
"""
# Transforming everything to strings.
from sympy.matrices import DeferredVector
from sympy import Dummy, sympify, Symbol, Function, flatten
if printer is not None:
if inspect.isfunction(printer):
lambdarepr = printer
else:
if inspect.isclass(printer):
lambdarepr = lambda expr: printer().doprint(expr)
else:
lambdarepr = lambda expr: printer.doprint(expr)
else:
#XXX: This has to be done here because of circular imports
from sympy.printing.lambdarepr import lambdarepr
def sub_args(args, dummies_dict):
if isinstance(args, str):
return args
elif isinstance(args, DeferredVector):
return str(args)
elif iterable(args):
dummies = flatten([sub_args(a, dummies_dict) for a in args])
return ",".join(str(a) for a in dummies)
else:
#Sub in dummy variables for functions or symbols
if isinstance(args, (Function, Symbol)):
dummies = Dummy()
dummies_dict.update({args: dummies})
return str(dummies)
else:
return str(args)
def sub_expr(expr, dummies_dict):
try:
expr = sympify(expr).xreplace(dummies_dict)
except Exception:
if isinstance(expr, DeferredVector):
pass
elif isinstance(expr, dict):
k = [sub_expr(sympify(a), dummies_dict) for a in expr.keys()]
v = [sub_expr(sympify(a), dummies_dict) for a in expr.values()]
expr = dict(zip(k, v))
elif isinstance(expr, tuple):
expr = tuple(sub_expr(sympify(a), dummies_dict) for a in expr)
elif isinstance(expr, list):
expr = [sub_expr(sympify(a), dummies_dict) for a in expr]
return expr
# Transform args
def isiter(l):
return iterable(l, exclude=(str, DeferredVector))
if isiter(args) and any(isiter(i) for i in args):
from sympy.utilities.iterables import flatten
import re
dum_args = [str(Dummy(str(i))) for i in range(len(args))]
iter_args = ','.join(
[i if isiter(a) else i for i, a in zip(dum_args, args)])
lstr = lambdastr(flatten(args), expr, printer=printer, dummify=dummify)
flat = '__flatten_args__'
rv = 'lambda %s: (%s)(*list(%s([%s])))' % (','.join(dum_args), lstr,
flat, iter_args)
if len(re.findall(r'\b%s\b' % flat, rv)) > 1:
raise ValueError('the name %s is reserved by lambdastr' % flat)
return rv
dummies_dict = {}
if dummify:
args = sub_args(args, dummies_dict)
else:
if isinstance(args, str):
pass
elif iterable(args, exclude=DeferredVector):
args = ",".join(str(a) for a in args)
# Transform expr
if dummify:
if isinstance(expr, str):
pass
else:
expr = sub_expr(expr, dummies_dict)
expr = lambdarepr(expr)
return "lambda %s: (%s)" % (args, expr)
def test_basic():
assert lambdarepr(x*y) == "x*y"
assert lambdarepr(x + y) in ["y + x", "x + y"]
assert lambdarepr(x**y) == "x**y"
def test_matrix():
A = Matrix([[x,y],[y*x,z**2]])
assert lambdarepr(A)=="Matrix([[ x, y],[x*y, z**2]])"
def test_piecewise():
# In each case, test eval() the lambdarepr() to make sure there are a
# correct number of parentheses. It will give a SyntaxError if there aren't.
h = "lambda x: "
p = Piecewise((x, True), evaluate=False)
l = lambdarepr(p)
eval(h + l)
assert l == "((x))"
p = Piecewise((x, x < 0))
l = lambdarepr(p)
eval(h + l)
assert l == "((x) if (x < 0) else None)"
p = Piecewise((1, x < 1), (2, x < 2), (0, True))
l = lambdarepr(p)
eval(h + l)
assert l == "((1) if (x < 1) else (2) if (x < 2) else (0))"
p = Piecewise(
(1, x < 1),
(2, x < 2),
)
l = lambdarepr(p)
eval(h + l)
assert l == "((1) if (x < 1) else (2) if (x < 2) else None)"
p = Piecewise(
(x, x < 1),
(x**2, Interval(3, 4, True, False).contains(x)),
(0, True),
)
l = lambdarepr(p)
eval(h + l)
assert l == "((x) if (x < 1) else (x**2) if (((x <= 4)) and ((x > 3))) else (0))"
p = Piecewise((x**2, x < 0), (x, x < 1), (2 - x, x >= 1), (0, True),
evaluate=False)
l = lambdarepr(p)
eval(h + l)
assert l == "((x**2) if (x < 0) else (x) if (x < 1)"\
" else (2 - x) if (x >= 1) else (0))"
p = Piecewise((x**2, x < 0), (x, x < 1), (2 - x, x >= 1), evaluate=False)
l = lambdarepr(p)
eval(h + l)
assert l == "((x**2) if (x < 0) else (x) if (x < 1)"\
" else (2 - x) if (x >= 1) else None)"
p = Piecewise((1, x >= 1), (2, x >= 2), (3, x >= 3), (4, x >= 4),
(5, x >= 5), (6, True))
l = lambdarepr(p)
eval(h + l)
assert l == "((1) if (x >= 1) else (2) if (x >= 2) else (3) if (x >= 3)"\
" else (4) if (x >= 4) else (5) if (x >= 5) else (6))"
p = Piecewise((1, x <= 1), (2, x <= 2), (3, x <= 3), (4, x <= 4),
(5, x <= 5), (6, True))
l = lambdarepr(p)
eval(h + l)
assert l == "((1) if (x <= 1) else (2) if (x <= 2) else (3) if (x <= 3)"\
" else (4) if (x <= 4) else (5) if (x <= 5) else (6))"
p = Piecewise((1, x > 1), (2, x > 2), (3, x > 3), (4, x > 4), (5, x > 5),
(6, True))
l = lambdarepr(p)
eval(h + l)
assert l =="((1) if (x > 1) else (2) if (x > 2) else (3) if (x > 3)"\
" else (4) if (x > 4) else (5) if (x > 5) else (6))"
p = Piecewise((1, x < 1), (2, x < 2), (3, x < 3), (4, x < 4), (5, x < 5),
(6, True))
l = lambdarepr(p)
eval(h + l)
assert l == "((1) if (x < 1) else (2) if (x < 2) else (3) if (x < 3)"\
" else (4) if (x < 4) else (5) if (x < 5) else (6))"
p = Piecewise((Piecewise((1, x > 0), (2, True)), y > 0), (3, True))
l = lambdarepr(p)
eval(h + l)
assert l == "((((1) if (x > 0) else (2))) if (y > 0) else (3))"
from sympy import init_printing
from sympy import lambdify
from sympy import cos, sin, expand_trig
from sympy import trigsimp
from sympy import simplify
from wtDigiTwin.yams.yams_sympy import colvec, R_x, R_y, R_z, cross
from wtDigiTwin.yams.yams_sympy import GroundBody
from wtDigiTwin.yams.yams_sympy import BeamBody
from wtDigiTwin.yams.yams_sympy import RigidBody
init_printing(use_unicode=False, wrap_line=False, no_global=True)
#init_printing(wrap_line=False)
# init_printing(use_latex='mathjax')
display = lambda x: sympy.pprint(x, use_unicode=False, wrap_line=False)
disp = lambda x: print(lambdarepr.lambdarepr(x))
sep = lambda: print('--------')
# ---
L = symbols('L')
theta_yaw, theta_tilt = symbols('theta_yaw,theta_tilt')
alpha_x, alpha_y, alpha_z = symbols('alpha_x,alpha_y,alpha_z')
ux1c, ux2c, ux3c, ux4c = symbols('ux1c,ux2c,ux3c,ux4c')
uy1c, uy2c, uy3c, uy4c = symbols('uy1c,uy2c,uy3c,uy4c')
uz1c, uz2c, uz3c, uz4c = symbols('uz1c,uz2c,uz3c,uz4c')
vx1c, vx2c, vx3c, vx4c = symbols('vx1c,vx2c,vx3c,vx4c')
vy1c, vy2c, vy3c, vy4c = symbols('vy1c,vy2c,vy3c,vy4c')
vz1c, vz2c, vz3c, vz4c = symbols('vz1c,vz2c,vz3c,vz4c')
rhoN_x, rhoN_y, rhoN_z = symbols(
'rhoN_x,rhoN_y,rhoN_z') # Position of Nac center of gravity in N
def lambdastr(args, expr, printer=None, dummify=False):
"""
Returns a string that can be evaluated to a lambda function.
Examples
========
>>> from sympy.abc import x, y, z
>>> from sympy.utilities.lambdify import lambdastr
>>> lambdastr(x, x**2)
'lambda x: (x**2)'
>>> lambdastr((x,y,z), [z,y,x])
'lambda x,y,z: ([z, y, x])'
Although tuples may not appear as arguments to lambda in Python 3,
lambdastr will create a lambda function that will unpack the original
arguments so that nested arguments can be handled:
>>> lambdastr((x, (y, z)), x + y)
'lambda _0,_1: (lambda x,y,z: (x + y))(*list(__flatten_args__([_0,_1])))'
"""
# Transforming everything to strings.
from sympy.matrices import DeferredVector
from sympy import Dummy, sympify, Symbol, Function, flatten
if printer is not None:
if inspect.isfunction(printer):
lambdarepr = printer
else:
if inspect.isclass(printer):
lambdarepr = lambda expr: printer().doprint(expr)
else:
lambdarepr = lambda expr: printer.doprint(expr)
else:
#XXX: This has to be done here because of circular imports
from sympy.printing.lambdarepr import lambdarepr
def sub_args(args, dummies_dict):
if isinstance(args, str):
return args
elif isinstance(args, DeferredVector):
return str(args)
elif iterable(args):
dummies = flatten([sub_args(a, dummies_dict) for a in args])
return ",".join(str(a) for a in dummies)
else:
#Sub in dummy variables for functions or symbols
if isinstance(args, (Function, Symbol)):
dummies = Dummy()
dummies_dict.update({args : dummies})
return str(dummies)
else:
return str(args)
def sub_expr(expr, dummies_dict):
try:
expr = sympify(expr).xreplace(dummies_dict)
except Exception:
if isinstance(expr, DeferredVector):
pass
elif isinstance(expr, dict):
k = [sub_expr(sympify(a), dummies_dict) for a in expr.keys()]
v = [sub_expr(sympify(a), dummies_dict) for a in expr.values()]
expr = dict(zip(k, v))
elif isinstance(expr, tuple):
expr = tuple(sub_expr(sympify(a), dummies_dict) for a in expr)
elif isinstance(expr, list):
expr = [sub_expr(sympify(a), dummies_dict) for a in expr]
return expr
# Transform args
def isiter(l):
return iterable(l, exclude=(str, DeferredVector))
if isiter(args) and any(isiter(i) for i in args):
from sympy.utilities.iterables import flatten
import re
dum_args = [str(Dummy(str(i))) for i in range(len(args))]
iter_args = ','.join([i if isiter(a) else i
for i, a in zip(dum_args, args)])
lstr = lambdastr(flatten(args), expr, printer=printer, dummify=dummify)
flat = '__flatten_args__'
rv = 'lambda %s: (%s)(*list(%s([%s])))' % (
','.join(dum_args), lstr, flat, iter_args)
if len(re.findall(r'\b%s\b' % flat, rv)) > 1:
raise ValueError('the name %s is reserved by lambdastr' % flat)
return rv
dummies_dict = {}
if dummify:
args = sub_args(args, dummies_dict)
else:
if isinstance(args, str):
pass
elif iterable(args, exclude=DeferredVector):
args = ",".join(str(a) for a in args)
# Transform expr
if dummify:
if isinstance(expr, str):
pass
else:
expr = sub_expr(expr, dummies_dict)
expr = lambdarepr(expr)
return "lambda %s: (%s)" % (args, expr)
def test_piecewise():
# In each case, test eval() the lambdarepr() to make sure there are a
# correct number of parentheses. It will give a SyntaxError if there aren't.
h = "lambda x: "
p = Piecewise((x, True), evaluate=False)
l = lambdarepr(p)
eval(h + l)
assert l == "((x))"
p = Piecewise((x, x < 0))
l = lambdarepr(p)
eval(h + l)
assert l == "((x) if (x < 0) else None)"
p = Piecewise(
(1, x < 1),
(2, x < 2),
(0, True)
)
l = lambdarepr(p)
eval(h + l)
assert l == "((1) if (x < 1) else (2) if (x < 2) else (0))"
p = Piecewise(
(1, x < 1),
(2, x < 2),
)
l = lambdarepr(p)
eval(h + l)
assert l == "((1) if (x < 1) else (2) if (x < 2) else None)"
p = Piecewise(
(x, x < 1),
(x**2, Interval(3, 4, True, False).contains(x)),
(0, True),
)
l = lambdarepr(p)
eval(h + l)
assert l == "((x) if (x < 1) else (x**2) if (((x <= 4)) and ((x > 3))) else (0))"
p = Piecewise(
(x**2, x < 0),
(x, x < 1),
(2 - x, x >= 1),
(0, True), evaluate=False
)
l = lambdarepr(p)
eval(h + l)
assert l == "((x**2) if (x < 0) else (x) if (x < 1)"\
" else (-x + 2) if (x >= 1) else (0))"
p = Piecewise(
(x**2, x < 0),
(x, x < 1),
(2 - x, x >= 1), evaluate=False
)
l = lambdarepr(p)
eval(h + l)
assert l == "((x**2) if (x < 0) else (x) if (x < 1)"\
" else (-x + 2) if (x >= 1) else None)"
p = Piecewise(
(1, x >= 1),
(2, x >= 2),
(3, x >= 3),
(4, x >= 4),
(5, x >= 5),
(6, True)
)
l = lambdarepr(p)
eval(h + l)
assert l == "((1) if (x >= 1) else (2) if (x >= 2) else (3) if (x >= 3)"\
" else (4) if (x >= 4) else (5) if (x >= 5) else (6))"
p = Piecewise(
(1, x <= 1),
(2, x <= 2),
(3, x <= 3),
(4, x <= 4),
(5, x <= 5),
(6, True)
)
l = lambdarepr(p)
eval(h + l)
assert l == "((1) if (x <= 1) else (2) if (x <= 2) else (3) if (x <= 3)"\
" else (4) if (x <= 4) else (5) if (x <= 5) else (6))"
p = Piecewise(
(1, x > 1),
(2, x > 2),
(3, x > 3),
(4, x > 4),
(5, x > 5),
(6, True)
)
l = lambdarepr(p)
eval(h + l)
assert l =="((1) if (x > 1) else (2) if (x > 2) else (3) if (x > 3)"\
" else (4) if (x > 4) else (5) if (x > 5) else (6))"
p = Piecewise(
(1, x < 1),
(2, x < 2),
(3, x < 3),
(4, x < 4),
(5, x < 5),
(6, True)
)
l = lambdarepr(p)
eval(h + l)
assert l == "((1) if (x < 1) else (2) if (x < 2) else (3) if (x < 3)"\
" else (4) if (x < 4) else (5) if (x < 5) else (6))"
p = Piecewise(
(Piecewise(
(1, x > 0),
(2, True)
), y > 0),
(3, True)
)
l = lambdarepr(p)
eval(h + l)
assert l == "((((1) if (x > 0) else (2))) if (y > 0) else (3))"
