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): """ 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 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 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_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 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_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))"