def test_nsolve(): # onedimensional from sympy import Symbol, sin, pi x = Symbol('x') assert nsolve(sin(x), 2) - pi.evalf() < 1e-16 assert nsolve(Eq(2*x, 2), x, -10) == nsolve(2*x - 2, -10) # multidimensional x1 = Symbol('x1') x2 = Symbol('x2') f1 = 3 * x1**2 - 2 * x2**2 - 1 f2 = x1**2 - 2 * x1 + x2**2 + 2 * x2 - 8 f = Matrix((f1, f2)).T F = lambdify((x1, x2), f.T, modules='mpmath') for x0 in [(-1, 1), (1, -2), (4, 4), (-4, -4)]: x = nsolve(f, (x1, x2), x0, tol=1.e-8) assert mnorm(F(*x),1) <= 1.e-10 # The Chinese mathematician Zhu Shijie was the very first to solve this # nonlinear system 700 years ago (z was added to make it 3-dimensional) x = Symbol('x') y = Symbol('y') z = Symbol('z') f1 = -x + 2*y f2 = (x**2 + x*(y**2 - 2) - 4*y) / (x + 4) f3 = sqrt(x**2 + y**2)*z f = Matrix((f1, f2, f3)).T F = lambdify((x, y, z), f.T, modules='mpmath') def getroot(x0): root = nsolve((f1, f2, f3), (x, y, z), x0) assert mnorm(F(*root),1) <= 1.e-8 return root assert map(round, getroot((1, 1, 1))) == [2.0, 1.0, 0.0]
def velocity_field(psi): #takes a symbolic function and returns two lambda functions #to evaluate the derivatives in both x and y. global w if velocity_components: u = lambdify((x,y), eval(x_velocity), modules='numpy') v = lambdify((x,y), eval(y_velocity), modules='numpy') else: if is_complex_potential: print "Complex potential, w(z) given" #define u, v symbolically as the imaginary part of the derivatives u = lambdify((x, y), sympy.im(psi.diff(y)), modules='numpy') v = lambdify((x, y), -sympy.im(psi.diff(x)), modules='numpy') else: #define u,v as the derivatives print "Stream function, psi given" u = sympy.lambdify((x, y), psi.diff(y), 'numpy') v = sympy.lambdify((x, y), -psi.diff(x), 'numpy') if (branch_cuts): # If it's indicated that there are branch cuts in the mapping, # then we need to return vectorized numpy functions to evaluate # everything numerically, instead of symbolically # This of course results in a SIGNIFICANT time increase # (I don't know how to handle more than the primitive root # (symbolically in Sympy return np.vectorize(u),np.vectorize(v) else: # If there are no branch cuts, then return the symbolic lambda functions (MUCH faster) return u,v
def test_msolve(): x1 = Symbol('x1') x2 = Symbol('x2') f1 = 3 * x1**2 - 2 * x2**2 - 1 f2 = x1**2 - 2 * x1 + x2**2 + 2 * x2 - 8 f = Matrix((f1, f2)).T F = lambdify((x1, x2), f.T) # numeric.newton is tested in this example too for x0 in [(-1., 1.), (1., -2.), (4., 4.), (-4., -4.)]: x = msolve((x1, x2), f, x0, tol=1.e-8) assert maxnorm(F(*x)) <= 1.e-11 # The Chinese mathematician Zhu Shijie was the very first to solve this # nonlinear system 700 years ago (z was added to make it 3-dimensional) x = Symbol('x') y = Symbol('y') z = Symbol('z') f1 = -x + 2*y f2 = (x**2 + x*(y**2 - 2) - 4*y) / (x + 4) f3 = sqrt(x**2 + y**2)*z f = Matrix((f1, f2, f3)).T F = lambdify((x, y, z), f.T) def getroot(x0): root = msolve((x, y, z), (f1, f2, f3), x0) assert maxnorm(F(*root)) <= 1.e-8 return root assert map(round, getroot((1., 1., 1.))) == [2.0, 1.0, 0.0]
def compile_function(self, module="numpy"): import sympy from sympy.utilities.lambdify import lambdify expr = sympy.sympify(self._str_expression) rvars = sympy.symbols([s.name for s in expr.free_symbols], real=True) real_expr = expr.subs({orig: real_ for (orig, real_) in zip(expr.free_symbols, rvars)}) # just replace with the assumption that all our variables are real expr = real_expr eval_expr = expr.evalf() # Extract parameters parameters = [symbol for symbol in expr.free_symbols if symbol.name != "x"] parameters.sort(key=lambda x: x.name) # to have a reliable order # Extract x x, = [symbol for symbol in expr.free_symbols if symbol.name == "x"] # Create compiled function self._f = lambdify([x] + parameters, eval_expr, modules=module, dummify=False) parnames = [symbol.name for symbol in parameters] self._parameter_strings = parnames for parameter in parameters: grad_expr = sympy.diff(eval_expr, parameter) setattr( self, "_f_grad_%s" % parameter.name, lambdify([x] + parameters, grad_expr.evalf(), modules=module, dummify=False), ) setattr( self, "grad_%s" % parameter.name, _fill_function_args(getattr(self, "_f_grad_%s" % parameter.name)).__get__(self, Expression), )
def twin_function_expr(self, value): if not value: self.twin_function = None self.twin_inverse_function = None self._twin_function_expr = "" self._twin_inverse_sympy = None return expr = sympy.sympify(value) if len(expr.free_symbols) > 1: raise ValueError("The expression must contain only one variable.") elif len(expr.free_symbols) == 0: raise ValueError("The expression must contain one variable, " "it contains none.") x = tuple(expr.free_symbols)[0] self.twin_function = lambdify(x, expr.evalf()) self._twin_function_expr = value if not self.twin_inverse_function: y = sympy.Symbol(x.name + "2") try: inv = sympy.solveset(sympy.Eq(y, expr), x) self._twin_inverse_sympy = lambdify(y, inv) self._twin_inverse_function = None except BaseException: # Not all may have a suitable solution. self._twin_inverse_function = None self._twin_inverse_sympy = None _logger.warning( "The function {} is not invertible. Setting the value of " "{} will raise an AttributeError unless you set manually " "``twin_inverse_function_expr``. Otherwise, set the " "value of its twin parameter instead.".format(value, self))
def find_CI(quartile, variable, critical, search = "left", grid_left = None, grid_right = None, precision = 0.001): ''' We take {regions} points in our domain and test every point for its likelihood value, then we look at points where values of ll ratio criteria cross critical value of chi^2 distribution It means, we should choose {regions} in such way that at least one point lays in the confidence interval at the first step. ''' regions = 20 solution = solutions[quartile] ll_hat = -0.5 * commons.chi2(solution) critical_val = chi2.ppf(critical, df=1) other1 = variable_to_others[variable][0] other2 = variable_to_others[variable][1] variable_bounds = (grid_left if not grid_left is None else commons.bounds[quartile][variable_index[variable]][0], grid_right if not grid_right is None else commons.bounds[quartile][variable_index[variable]][1]) grid = np.linspace(start = variable_bounds[0], stop = variable_bounds[1], num = regions) other_bounds = (commons.bounds[quartile][variable_index[other1]], commons.bounds[quartile][variable_index[other2]]) ll_prev_criteria = None #print("Critical value is {}".format(critical_val)) for i, v in enumerate(grid): #print("Check {} = {}".format(variable, v)) ys = sp.Matrix([variable_ref[other1], variable_ref[other2]]) pll_func_sym = commons.chi2_sym.subs(variable_ref[variable], v) pll_func = lambda args: lambdify(ys, pll_func_sym, 'numpy')(*args)[0, 0] pll_func_jacob = lambda args: lambdify(ys, pll_func_sym.jacobian(ys), 'numpy')(*args) result = opt.minimize(pll_func, [solution[variable_index[other1]], solution[variable_index[other2]]], method='TNC', jac=pll_func_jacob, bounds=other_bounds) pll_val = -.5 * result.fun ll_criteria = 2 * (ll_hat - pll_val) #print("\tProfile LL ratio value = {}".format(ll_criteria)) if not ll_prev_criteria is None: l = grid[i - 1] r = grid[i] if ll_prev_criteria > critical_val and ll_criteria < critical_val and search == "left": #print("Critical point lays between {} and {}\n".format(l, r)) if (r - l) < precision: return l, r else: return find_CI(quartile, variable, critical, search = search, grid_left = l, grid_right = r, precision = precision) elif ll_prev_criteria < critical and ll_criteria > critical and search == "right": #print("Critical point lays between {} and {}\n".format(l, r)) if (r - l) < precision: return l, r else: return find_CI(quartile, variable, critical, search = search, grid_left = l, grid_right = r, precision = precision) ll_prev_criteria = ll_criteria
def msolve(args, f, x0, tol=None, maxsteps=None, verbose=False, norm=None, modules=['mpmath', 'sympy']): """ Solves a nonlinear equation system numerically. f is a vector function of symbolic expressions representing the system. args are the variables. x0 is a starting vector close to a solution. Be careful with x0, not using floats might give unexpected results. Use modules to specify which modules should be used to evaluate the function and the Jacobian matrix. Make sure to use a module that supports matrices. For more information on the syntax, please see the docstring of lambdify. Currently only fully determined systems are supported. >>> from sympy import Symbol, Matrix >>> x1 = Symbol('x1') >>> x2 = Symbol('x2') >>> f1 = 3 * x1**2 - 2 * x2**2 - 1 >>> f2 = x1**2 - 2 * x1 + x2**2 + 2 * x2 - 8 >>> msolve((x1, x2), (f1, f2), (-1., 1.)) [-1.19287309935246] [ 1.27844411169911] """ if isinstance(f, (list, tuple)): f = Matrix(f).T if len(args) != f.cols: raise NotImplementedError('need exactly as many variables as equations') if verbose: print 'f(x):' print f # derive Jacobian J = f.jacobian(args) if verbose: print 'J(x):' print J # create functions f = lambdify(args, f.T, modules) J = lambdify(args, J, modules) # solve system using Newton's method kwargs = {} if tol: kwargs['tol'] = tol if maxsteps: kwargs['maxsteps'] = maxsteps kwargs['verbose'] = verbose if norm: kwargs['norm'] = norm x = newton(f, x0, J, **kwargs) return x
def __init__(self, state_vector, next_state_func, observation_vector, observation_func, x0, initial_cov, process_noise_cov, measurement_noise_cov): """Create the filter :param state_vector: sympy matrix `x`, the full state of the filter :param next_state_func: sympy matrix, `x_next` as a function of `x` - The dynamics jacobian will be generated internally """ dynamics_jacobian = self.form_dynamics_jacobian(state_vector, next_state_func) observation_jacobian = self.form_observation_jacobian(state_vector, observation_vector, observation_func) self.x_dim = dynamics_jacobian.shape[0] self.observation_dim = observation_vector.shape[0] # # Input validation # Before the arguments even get off the ship, we validate them # observation jacobian asserts assert observation_jacobian.shape[1] == self.x_dim, "Observation jacobian has the wrong dimension to map to state" assert observation_jacobian.shape[0] == self.observation_dim, "Observation jacobian is not the right shape" # measurement covariance asserts assert measurement_noise_cov.shape[0] == measurement_noise_cov.shape[1], \ "Measurement noise is not the same shape as symbolic measurement" assert measurement_noise_cov.shape[0] == observation_vector.shape[0], "Measurement noise is not square" # process covariance asserts assert process_noise_cov.shape[0] == process_noise_cov.shape[1], "Process noise is not square" assert process_noise_cov.shape[0] == state_vector.shape[0], "Process noise is not the same shape as symbolic state" # initial state asserts assert x0.shape[0] == state_vector.shape[0], "Supplied initial state is not the same shape as symbolic state" self.make_A = lambdify( state_vector, dynamics_jacobian, 'numpy' ) self.make_H = lambdify( state_vector, observation_jacobian, 'numpy' ) # # State/Covariance initialization # self.x = x0 self.P = initial_cov self.Q = process_noise_cov self.R = measurement_noise_cov
def test_1d(): B = gen_BrownianMotion() Bs = implemented_function("B", B) t = sympy.Symbol('t') expr = 3*sympy.exp(Bs(t)) + 4 expected = 3*np.exp(B.y)+4 ee_vec = lambdify(t, expr, "numpy") assert_almost_equal(ee_vec(B.x), expected) # with any arbitrary symbol b = sympy.Symbol('b') expr = 3*sympy.exp(Bs(b)) + 4 ee_vec = lambdify(b, expr, "numpy") assert_almost_equal(ee_vec(B.x), expected)
def make_callable(model, variables, mode=None): """ Take a SymPy object and create a callable function. Parameters ---------- model, SymPy object Abstract representation of function variables, list Input variables, ordered in the way the return function will expect mode, ['numpy', 'numexpr', 'sympy'], optional Method to use when 'compiling' the function. SymPy mode is slow and should only be used for debugging. If Numexpr is installed, it can offer speed-ups when calling the energy function many times on multi-core CPUs. Returns ------- Function that takes arguments in the same order as 'variables' and returns the energy according to 'model'. Examples -------- None yet. """ energy = None if mode is None: # no mode specified; use numexpr if available, otherwise numpy # Note: numexpr support appears to break in multi-component situations # See numexpr#167 on GitHub for details # For now, default to numpy until a solution/workaround is available #if _NUMEXPR: # mode = 'numexpr' #else: # mode = 'numpy' mode = 'numpy' if mode == 'sympy': energy = lambda *vs: model.subs(zip(variables, vs)).evalf() elif mode == 'numpy': logical_np = [{'And': np.logical_and, 'Or': np.logical_or}, 'numpy'] energy = lambdify(tuple(variables), model, dummify=True, modules=logical_np, printer=NumPyPrinter) elif mode == 'numexpr': energy = lambdify(tuple(variables), model, dummify=True, modules='numexpr', printer=SpecialNumExprPrinter) else: energy = lambdify(tuple(variables), model, dummify=True, modules=mode) return energy
def make_callable(model, variables, mode=None): """ Take a SymPy object and create a callable function. Parameters ---------- model, SymPy object Abstract representation of function variables, list Input variables, ordered in the way the return function will expect mode, ['numpy', 'numba', 'sympy'], optional Method to use when 'compiling' the function. SymPy mode is slow and should only be used for debugging. If Numba is installed, it can offer speed-ups when calling the energy function many times on multi-core CPUs. Returns ------- Function that takes arguments in the same order as 'variables' and returns the energy according to 'model'. Examples -------- None yet. """ energy = None if mode is None: # no mode specified; use numba if available, otherwise numpy if _NUMBA: mode = 'numba' else: mode = 'numpy' if mode == 'sympy': energy = lambda *vs: model.subs(zip(variables, vs)).evalf() elif mode == 'numpy': energy = lambdify(tuple(variables), model, dummify=True, modules=[{'where': np.where}, 'numpy'], printer=NumPyPrinter) elif mode == 'numba': variables = tuple(variables) varsig = 'float64({})'.format(','.join(['float64'] * len(variables))) energy = lambdify(variables, model, dummify=True, modules=[{'where': nbwhere}, 'numpy'], printer=NumPyPrinter) # target=parallel seems to incur too much overhead on small arrays energy = _NUMBA.vectorize([varsig], nopython=True, target='cpu')(energy) else: energy = lambdify(tuple(variables), model, dummify=True, modules=mode) return energy
def test_blocks(): on_off = [[1,2],[3,4]] tval = np.array([0.4,1.4,2.4,3.4]) b = blocks(on_off) lam = lambdify(t, b) assert_array_equal(lam(tval), [0, 1, 0, 1]) b = blocks(on_off, amplitudes=[3,5]) lam = lambdify(t, b) assert_array_equal(lam(tval), [0, 3, 0, 5]) # Check what happens with names # Default is from step function assert_false(re.match(r'step\d+\(t\)$', str(b)) is None) # Can pass in another b = blocks(on_off, name='funky_chicken') assert_equal(str(b), 'funky_chicken(t)')
def num_eval(self, symbol=None, values=None, uncertainties=None): if symbol == None: return self.value(), self.uncertainty() valfunc = lambdify(symbol, self.value(), 'numpy') if uncertainties == None: uncertaintyfunc = lambdify(symbol, self.uncertainty(), 'numpy') return valfunc(values), uncertaintyfunc(values) else: u_sym = sympy.symbols('u_sym') usquared = self.uncertainty_squared() + \ (self.formula.diff(symbol).subs(self.values) * u_sym)**2 u = sympy.sqrt(usquared) uncertaintyfunc = lambdify((symbol, u_sym), u, 'numpy') return valfunc(values), uncertaintyfunc(values, uncertainties)
def test_step_function(): # test step function # step function is a function of t s = step_function([0,4,5],[2,4,6]) tval = np.array([-0.1,0,3.9,4,4.1,5.1]) lam = lambdify(t, s) assert_array_equal(lam(tval), [0, 2, 2, 4, 4, 6]) s = step_function([0,4,5],[4,2,1]) lam = lambdify(t, s) assert_array_equal(lam(tval), [0, 4, 4, 2, 2, 1]) # Name default assert_false(re.match(r'step\d+\(t\)$', str(s)) is None) # Name reloaded s = step_function([0,4,5],[4,2,1], name='goodie_goodie_yum_yum') assert_equal(str(s), 'goodie_goodie_yum_yum(t)')
def test_implemented_function(): # Here we check if the default returned functions are anonymous - in # the sense that we can have more than one function with the same name f = implemented_function('f', lambda x: 2*x) g = implemented_function('f', lambda x: np.sqrt(x)) l1 = lambdify(x, f(x)) l2 = lambdify(x, g(x)) assert_equal(str(f(x)), str(g(x))) assert_equal(l1(3), 6) assert_equal(l2(3), np.sqrt(3)) # check that we can pass in a sympy function as input func = sympy.Function('myfunc') assert_false(hasattr(func, '_imp_')) f = implemented_function(func, lambda x: 2*x) assert_true(hasattr(func, '_imp_'))
def get_error(expr): """ calculates error of an expression possibly containing quantities Returns: tuple of error and error formula (as Expr object) """ integrand = 0 error_formula = 0 for varToDiff in expr.free_symbols: if varToDiff.error is not None: differential = diff(expr,varToDiff) error_formula += ( Symbol(varToDiff.name+"_err",positive=True) * differential )**2 diffFunction = lambdify(differential.free_symbols,differential, modules="numpy") diffValues = [] for var in differential.free_symbols: diffValues.append(var.value) integrand += ( varToDiff.error*diffFunction(*diffValues) )**2 if isinstance(integrand,np.ndarray): if (integrand==0).all(): return (None,None) elif integrand == 0: return (None,None) return (np.sqrt(integrand),sym_sqrt (error_formula))
def getRelError(variables,func,showFunc = False): """getError generates a function to calculate the error of a function. I.E. a function that gives you the error in its result given the error in its input. Output function is numpy ready. Output function will take twice as many args as variables, one for the var and one for the error in that var. arguments variables : a list of sympy symbols in func errorVariables : list of sympy ymbols representing the error in each value of variables. must be the same length as variables func : a function containing your variables that you want the error of""" ErrorFunc = 0 # need to set function to start value erVars = {} for i in range(len(variables)): #run through all variables in the function v = variables[i] dv = Symbol('d'+str(v), positive = True) erVars['d'+str(v)] = dv D = (diff(func,v)*dv)**2 ErrorFunc += D ErrorFunc = sqrt(ErrorFunc)/func if showFunc: pprint(ErrorFunc) variables.extend(erVars.values()) #create a list of all sympy symbols involved func = lambdify(tuple(variables), ErrorFunc ,"numpy") #convert ErrorFunc to a numpy rteady python lambda return(func)
def fit(x_data, y_data, fit_function, parameters, weighted=None): args = [x_data] args.extend(parameters) np_func = lambdify(tuple(args), fit_function, "numpy") start_params = [] for p in parameters: if p.value == None: start_params.append(np.float_(1)) else: if isinstance(p.value,np.ndarray): raise ValueError("fit parameter '%s' is a data set." % p.name) else: start_params.append(p.value) if weighted is False: errors = None else: errors = y_data.error if weighted is True and y_data.error is None: raise RuntimeError("can't perform weighted fit because error of '%s' is not set." % y_data.name) params_opt, params_covar = curve_fit (np_func,x_data.value,y_data.value,sigma=errors,p0=start_params) params_err = np.sqrt(np.diag(params_covar)) return (params_opt,params_err)
def get_ode_fcn_floating_dp(g_, a1_, L1_, m1_, I1_, a2_, L2_, m2_, I2_): """ Returns a function object that can be called with fnc(t,x, u), where x = [q1, q2, q3, q4, qd1, qd2, qd3, qd4], and tau = [tau1, tau2, tau3, tau4], is the torques at each joint respectively. The function implements the ode for the floating inverted double pendulum. For faster return of already constructed models, the set of parameters are checked against a pickled dict. """ params = (g_, a1_, L1_, m1_, I1_, a2_, L2_, m2_, I2_) tau1, tau2, tau3, tau4 = sy.symbols('tau1, tau2, tau3, tau4') q1, q2, q3, q4, qd1, qd2, qd3, qd4 = symbols('q1, q2, q3, q4, qd1, qd2, qd3, qd4', real=True) s1 = sy.sin(q1); s1_ = Symbol('s1') c1 = sy.cos(q1); c1_ = Symbol('c1') s2 = sy.sin(q2); s2_ = Symbol('s2') c2 = sy.cos(q2); c2_ = Symbol('c2') s12 = sy.sin(q1+q2); s12_ = Symbol('s12') c12 = sy.cos(q1+q2); c12_ = Symbol('c12') odes = get_symbolic_ode_floating_dp(params) # Substitute functions for faster evaluation odes = odes.subs(s1, s1_).subs(c1,c1_).subs(s2,s2_).subs(c2,c2_).subs(s12,s12_).subs(c12,c12_) lmb = lambdify( (q1, q2, q3, q4, q1dot, q2dot, q3dot, q4dot, s1_, c1_, s2_, c2_, s12_, c12_, tau1, tau2, tau3, tau4), odes) return partial(lambda_ode, lambdafunc=lmb)
def __init__(self, firing_rate, record=False, **kwargs): if isinstance(firing_rate, str): self.firing_rate_string = str(firing_rate) self.closure = lambdify(sym_t,symp.parse_expr(self.firing_rate_string, local_dict={'Heaviside':lambda x: Piecewise((0,x<0), (1,x>0),(.5,True))})) elif hasattr(firing_rate, "__call__"): self.closure = firing_rate else: self.firing_rate_string = str(firing_rate) self.closure = lambdify(sym_t,symp.parse_expr(self.firing_rate_string)) self.record = record self.type = "external" # Additional metadata: self.metadata = kwargs
def test_2d(): B1, B2 = [gen_BrownianMotion() for _ in range(2)] B1s = implemented_function("B1", B1) B2s = implemented_function("B2", B2) s, t = sympy.symbols(('s', 't')) e = B1s(s)+B2s(t) ee = lambdify((s,t), e) assert_almost_equal(ee(B1.x, B2.x), B1.y + B2.y)
def numerical_equilibrium(self): res = self.deterministic() f = lambdify(res.keys(), res.values()) g = lambda y, t: f(*y) r = odeint(g, y0=np.ones(len(res.keys())), t=[0.0, 1e6])[-1] r = odeint(g, y0=r, t=[0.0, 1e6])[-1] return dict(zip(res.keys(), r))
def Makeufunc(): import sympy from sympy.utilities.lambdify import lambdify x, nu, t = sympy.symbols('x nu t') phi = sympy.exp(-(x-4*t)**2/(4*nu*(t+1))) + sympy.exp(-(x-4*t-2*np.pi)**2/(4*nu*(t+1))) u = -2*nu*(phi.diff(x)/phi)+4 return lambdify((t,x,nu),u)
def _lambdify(self): lambda_list = [] vars = [range_[0] for range_ in self._ranges[1:]] for sym_sol in self.sym_sols: lambda_list.append(lambdify(vars,sym_sol)) self.__call__.__func__.__doc__ += ('Function signature is f(' +','.join([str(var) for var in vars] )+')\n') return vars,lambda_list
def num_eval_correlation(self, symbol=None, values=None, uncertainties=None): if symbol == None: return self.value(), self.uncertainty() valfunc = lambdify(symbol, self.value_correlation(), 'numpy') if uncertainties == None: uncertaintyfunc = lambdify(symbol, self.uncertainty(), 'numpy') return valfunc(values), uncertaintyfunc(values) else: #We define u_sym as a 'DeferredVector' to be able to use it in lambdify as one input. u_sym = sympy.DeferredVector('u_sym') #To be able to square term by term in a sympy matrix, square terms separately: usquared = {} for j in range(4): usquared[j] = self.uncertainty_squared_correlation()[j] + \ (self.formula.diff(symbol).subs(self.values)[j] * u_sym[j])**2 u = (sympy.sqrt(usquared[0]),sympy.sqrt(usquared[1]),sympy.sqrt(usquared[2]),sympy.sqrt(usquared[3])) uncertaintyfunc = lambdify((symbol, u_sym), u, 'numpy') return valfunc(values), uncertaintyfunc(values, uncertainties)
def __init__(self, firing_rate, record=False, **kwargs): self.firing_rate_string = str(firing_rate) self.closure = lambdify(sym_t, symp.parse_expr(self.firing_rate_string)) self.record = record self.type = "external" # Additional metadata: self.metadata = kwargs
def get_value(expr): """ calculates number value of an expression possibly containing quantities """ calcFunction=lambdify(expr.free_symbols, expr, modules="numpy") depValues=[] for var in expr.free_symbols: if var.value is None: raise RuntimeError ("quantity '%s' doesn't have a value, yet." % var.name) depValues.append(var.value) return calcFunction(*depValues)
def sympy_to_py(func, vars, params): """ Turn a symbolic expression into a Python lambda function, which has the names of the variables and parameters as it's argument names. :param func: sympy expression :param vars: variables in this model :param params: parameters in this model :return: lambda function to be used for numerical evaluation of the model. """ return lambdify((vars + params), func, modules='numpy', dummify=False)
def _compare_tensorflow_matrix(variables, expr): f = lambdify(variables, expr, 'tensorflow') random_matrices = [Matrix([[random.randint(0, 10) for k in range(i.shape[1])] for j in range(i.shape[0])]) for i in variables] random_variables = [eval(tensorflow_code(i)) for i in random_matrices] r = session.run(f(*random_variables)) e = expr.subs({k: v for k, v in zip(variables, random_matrices)}).doit() if e.is_Matrix: e = e.tolist() assert (r == e).all()
def test_issue_11463(): numpy = import_module('numpy') if not numpy: skip("numpy not installed.") x = Symbol('x') f = lambdify(x, real_root((log(x/(x-2))), 3), 'numpy') # numpy.select evaluates all options before considering conditions, # so it raises a warning about root of negative number which does # not affect the outcome. This warning is suppressed here with ignore_warnings(RuntimeWarning): assert f(numpy.array(-1)) < -1
def calculate_speed(self): self.sp_func["speed"] = sp.sqrt(self.sp_func["x"] * self.sp_func["x"] + self.sp_func["y"] * self.sp_func["y"]) self.np_func["speed"] = lambdify(self.sp_func["t"], self.sp_func["speed"], 'numpy') self.np_array["speed"] = self.np_func["speed"](self.np_array["t"])
def test_log2(): if not np: skip("NumPy not installed") assert abs(lambdify((a,), log2(a), 'numpy')(256) - 8) < 1e-16
def Restrictions(i): x1 = Symbol('x1') x2 = Symbol('x2') x3 = Symbol('x3') x4 = Symbol('x4') x5 = Symbol('x5') x6 = Symbol('x6') x7 = Symbol('x7') inf1 = -log((x1 - 2.6)*10**6) inf2 = -log((x2 - 0.7)*10**6) inf3 = -log((x3 - 17)*10**6) inf4 = -log((x4 - 7.3)*10**6) inf5 = -log((x5 - 7.8)*10**6) inf6 = -log((x6 - 2.9)*10**6) inf7 = -log((x7 - 5)*10**6) sup1 = -log((3.6 - x1)*10**6) sup2 = -log((0.8 - x2)*10**6) sup3 = -log((28 - x3)*10**6) sup4 = -log((8.3 - x4)*10**6) sup5 = -log((8.3 - x5)*10**6) sup6 = -log((3.9 - x6)*10**6) sup7 = -log((5.5 - x7)*10**6) h = inf1 + inf2**2 + inf3 + inf4 + inf5 + inf6 + inf7 + sup1 + sup2 + sup3 + sup4 + sup5 + sup6 + sup7 #h = (inf1 + sup1)**(1/2) + (inf2 + sup2)**(1/2) + (inf3 + sup3)**(1/2) + (inf4 + sup4)**(1/2) + (inf5 + sup5)**(1/2) + (inf6 + sup6)**(1/2) + (inf7 + sup7)**(1/2) g = [[inf1], [inf2], [inf3], [inf4], [inf5], [inf6], [inf7], [sup1], [sup2], [sup3], [sup4], [sup5], [sup6], [sup7]] if i == 1: return h else: g = np.array([lambdify([x1, x2, x3, x4, x5, x6, x7], g(x1), 'numpy')], [lambdify([x1, x2, x3, x4, x5, x6, x7], g(x2), 'numpy')], [lambdify([x1, x2, x3, x4, x5, x6, x7], g(x3), 'numpy')], [lambdify([x1, x2, x3, x4, x5, x6, x7], g(x4), 'numpy')], [lambdify([x1, x2, x3, x4, x5, x6, x7], g(x5), 'numpy')], [lambdify([x1, x2, x3, x4, x5, x6, x7], g(x6), 'numpy')], [lambdify([x1, x2, x3, x4, x5, x6, x7], g(x7), 'numpy')], [lambdify([x1, x2, x3, x4, x5, x6, x7], g(x1), 'numpy')], [lambdify([x1, x2, x3, x4, x5, x6, x7], g(x2), 'numpy')], [lambdify([x1, x2, x3, x4, x5, x6, x7], g(x3), 'numpy')], [lambdify([x1, x2, x3, x4, x5, x6, x7], g(x4), 'numpy')], [lambdify([x1, x2, x3, x4, x5, x6, x7], g(x5), 'numpy')], [lambdify([x1, x2, x3, x4, x5, x6, x7], g(x6), 'numpy')], [lambdify([x1, x2, x3, x4, x5, x6, x7], g(x7), 'numpy')]) return g
_E1 = a1 * sp.Matrix(E1) + b1 * sp.Matrix(E2) + c1 * sp.Matrix(P_i) _E2 = a2 * sp.Matrix(E1) + b2 * sp.Matrix(E2) + c2 * sp.Matrix(P_i) R = s * sp.Matrix(E1) + t * sp.Matrix(E2) f = Matrix([ _E1.dot(_E1) - 1, _E2.dot(_E2) - 1, _E1.dot(_E2), R.dot(R) - 1, _E1.dot(R) - sp.Matrix(E1).dot(R), _E2.dot(R) - sp.Matrix(E2).dot(R), sp.Matrix(P_i).dot(_E1) - x2_s, sp.Matrix(P_i).dot(_E2) - y2_s ]) lam_f = lambdify(var, sp.simplify(f), 'numpy') def lam(x2, y2, p, e_1, e_2): return lambda a1,b1,c1,a2,b2,c2,t,s: \ ((lam_f(x2, y2, sp.Matrix(p), sp.Matrix(e_1), sp.Matrix(e_2), a1, b1, c1, a2, b2, c2, t, s)) ** 2).sum() # np.linalg.norm(~) よりも高速。(速いとは言ってない) arr = np.array([1, 1, 1, 1, 1, 1, 1, 1]) X_sample = 3 * np.random.random_sample((100, 1)) - 1.5 Y_sample = 3 * np.random.random_sample((100, 1)) - 1.5 print("ready")
def test_sqrt(): if not np: skip("NumPy not installed") assert abs(lambdify((a,), sqrt(a), 'numpy')(4) - 2) < 1e-16
def _setup_design(self): """ Initialize design Create a callable object to evaluate the design matrix at a given set of parameter values to be specified by a recarray and observed Term values, also specified by a recarray. """ # the design expression is the differentiation of the expression # for the mean. It is a list d = self.design_expr # Before evaluating, we recreate the formula # with numbered terms, and numbered parameters. # This renaming has no impact on the # final design matrix as the # callable, self._f below, is a lambda # that does not care about the names of the terms. # First, find all terms in the mean expression, # and rename them in the form "__t%d__" with a # random offset. # This may cause a possible problem # when there are parameters named something like "__t%d__". # Using the random offset will minimize the possibility # of this happening. # This renaming is here principally because of the intercept. random_offset = np.random.random_integers(low=0, high=2**30) terms = getterms(self.mean) newterms = [] for i, t in enumerate(terms): newt = sympy.Symbol("__t%d__" % (i + random_offset)) for j, _ in enumerate(d): d[j] = d[j].subs(t, newt) newterms.append(newt) # Next, find all parameters that remain in the design expression. # In a standard regression model, there will be no parameters # because they will all be differentiated away in computing # self.design_expr. In nonlinear models, parameters will remain. params = getparams(self.design_expr) newparams = [] for i, p in enumerate(params): newp = Dummy("__p%d__" % (i + random_offset)) for j, _ in enumerate(d): d[j] = d[j].subs(p, newp) newparams.append(newp) # If there are any aliased functions, these need to be added # to the name space before sympy lambdifies the expression # These "aliased" functions are used for things like # the natural splines, etc. You can represent natural splines # with sympy but the expression is pretty awful. Note that # ``d`` here is list giving the differentiation of the # expression for the mean. self._f(...) therefore also returns # a list self._f = lambdify(newparams + newterms, d, ("numpy")) # The input to self.design will be a recarray of that must # have field names that the Formula will expect to see. # However, if any of self.terms are FactorTerms, then the field # in the recarray will not actually be in the Term. # # For example, if there is a Factor 'f' with levels ['a','b'], # there will be terms 'f_a' and 'f_b', though the input to # design will have a field named 'f'. In this sense, # the recarray used in the call to self.design # is not really made up of terms, but "preterms". # In this case, the callable preterm = [] for t in terms: if not is_factor_term(t): preterm.append(str(t)) else: preterm.append(t.factor_name) preterm = list(set(preterm)) # There is also an argument for parameters that are not # Terms. self._dtypes = { 'param': np.dtype([(str(p), np.float) for p in params]), 'term': np.dtype([(str(t), np.float) for t in terms]), 'preterm': np.dtype([(n, np.float) for n in preterm]) } self.__terms = terms
def createMMSSourceFunctionsHydroOnly(rho, u, E, gamma_value, cv_value, alpha_value, display_equations=False): # declare symbolic variables x, t, alpha, Qpsim, Qpsip = symbols('x t alpha Qpsim Qpsip') gamma, cv, a = symbols('gamma c_v a') # compute other thermodynamic quantities based on ideal gas EOS e = E / rho - u * u / 2 p = rho * e * (gamma - 1) rhou = rho * u # temporal derivatives drhodt = diff(rho, t) drhoudt = diff(rhou, t) dEdt = diff(E, t) # spatial derivatives drhoudx = diff(rhou, x) drhouudx = diff(rhou * u, x) dpdx = diff(p, x) dEfluxdx = diff((E + p) * u, x) # compute sources Qrho = drhodt + drhoudx Qu = drhoudt + drhouudx + dpdx QE = dEdt + dEfluxdx Qpsim = 0 Qpsip = 0 # display equations if display_equations: # initialize printing to use prettiest format available (e.g., LaTeX, Unicode) init_printing() # create an equation and then display it eq = Eq(symbols('rho'), rho) display(eq) eq = Eq(symbols('u'), u) display(eq) eq = Eq(symbols('E'), E) display(eq) eq = Eq(symbols('e'), e) display(eq) eq = Eq(symbols('p'), p) display(eq) eq = Eq(symbols('Q_rho'), Qrho) display(eq) eq = Eq(symbols('Q_u'), Qu) display(eq) eq = Eq(symbols('Q_E'), QE) display(eq) # substitute for all symbols except x and t substitutions = dict() substitutions['alpha'] = alpha_value substitutions['a'] = GC.RAD_CONSTANT substitutions['c_v'] = cv_value substitutions['gamma'] = gamma_value # make substitutions Qrho_sub = Qrho.subs(substitutions) Qu_sub = Qu.subs(substitutions) QE_sub = QE.subs(substitutions) # create MMS source functions rho_f = lambdify((symbols('x'), symbols('t')), Qrho_sub, "numpy") u_f = lambdify((symbols('x'), symbols('t')), Qu_sub, "numpy") E_f = lambdify((symbols('x'), symbols('t')), QE_sub, "numpy") psim_f = lambdify((symbols('x'), symbols('t')), Qpsim, "numpy") psip_f = lambdify((symbols('x'), symbols('t')), Qpsip, "numpy") return (rho_f, u_f, E_f, psim_f, psip_f)
def test_exp2(): if not np: skip("NumPy not installed") assert abs(lambdify((a,), exp2(a), 'numpy')(5) - 32) < 1e-16
def __init__(self, sympy_function, sympy_variables, args={}): self.sympy_function = sympy_function.subs(args) self.sympy_variables = sympy_variables self.lambdified = lambdify(self.sympy_variables, self.sympy_function) clear_cache() # I need a unique way to identify the integrand libraries I will be # generating. id(self) works sort of, but it may or may not be unique # I think. I'm going to try a hash of the underlying sympy function, # but I can't allow negative numbers (C gets confused), so I have to # generate a positive integer instead. Stackoverflow had this idea: self.unique_id = ctypes.c_size_t(hash(self.sympy_function)).value # stackoverflow.com/questions/18766535/... # positive-integer-from-python-hash-function filename_prefix = os.path.join('integrand_libs', 'integrand' + str(self.unique_id)) libname_prefix = os.path.join('integrand_libs', '' + str(self.unique_id)) # Enable the use of ctypes objects in nquad, once multivariate ctypes objects # are appropriate arguments for the QUADPACK library functions. try: self.generated_code = codegen( ('integrand', self.sympy_function), 'C', filename_prefix, argument_sequence=self.sympy_variables, to_files=True) except IOError: import pdb pdb.set_trace() args_str = ",".join([ "args[" + str(ind) + "]" for ind in range(len(self.sympy_variables)) ]) extra_c_code = "".join([ r""" double integrand_wrapper(int n, double args[n]) { return integrand(""", args_str, """); } """ ]) extra_h_code = """ double integrand_wrapper(int n, double args[n]); """ f = open(filename_prefix + ".c", 'a') f.write(extra_c_code) f.close() f = open(filename_prefix + ".h", 'a') f.write(extra_h_code) f.close() cmd = ("gcc -dynamiclib -O3 -I. " + filename_prefix + ".c -o " + filename_prefix + ".dylib") subprocess.call(cmd, shell=True) self.ctypeslib = ctypes.CDLL(filename_prefix + '.dylib') self.ctypesified = self.ctypeslib.integrand_wrapper self.ctypesified.restype = ctypes.c_double # Test the reliability of ctypesified function. This should be # disabled eventually. self.ctypesified.argtypes = (ctypes.c_int, len(self.sympy_variables) * ctypes.c_double) test = [] for indx in range(0): randargs = [random.random() for item in self.sympy_variables] temp = (self.lambdified(*randargs) - self.ctypesified( ctypes.c_int(len(self.sympy_variables)), (len(self.sympy_variables) * ctypes.c_double)(*randargs))) if temp**2 > .00000001: test.append(temp) if test: raise IntegrationError("Ctypesified and lambdified do not match!") self.ctypesified.argtypes = ctypes.c_int, ctypes.c_double return None
import sympy as sp import numpy as np import scipy.optimize as opt from commons import * from sympy.utilities.lambdify import lambdify, implemented_function chi2_sym = (y_theo_sym - summer2015['y_exp']).T * summer2015['y_covar_inv'] * ( y_theo_sym - summer2015['y_exp']) chi2 = lambda args: lambdify(ys, chi2_sym, 'numpy')(*args)[0, 0] #Symbolic solutions #print("Symbolic: ") #print(sp.solvers.solve(chi2_sym.jacobian(ys), ys)) #Numerical solutions print("Numerical: ") #Calculate using Newton result = opt.minimize(chi2, [0, 0, 0.01], method='TNC', bounds=bounds[1]) print("Newton's method") print(result.fun) print(result.x.tolist()) #Calculate using jacobian print("Newton's with Jacobian matrix") jacobian = lambda x: lambdify(ys, chi2_sym.jacobian(ys), 'numpy')(*x) hessian = lambda x: sp.hessian(ys, sp.hessian(chi2_sym, ys), 'numpy')(*x) result = opt.minimize( chi2,
from numpy import * from math import * import sympy as sym from sympy.utilities.lambdify import lambdify, implemented_function x = sym.Symbol('x') s = '5*x-8*sym.log(x)-8' #сюда функцию в каноническом виде f = lambdify(x, eval(s), 'numpy') f_dash = lambdify(x, sym.diff(eval(s), x, 1), 'numpy') f_2dash = lambdify(x, sym.diff(eval(s), x, 2), 'numpy') x0 = 345345 #начальное приближение e = 1e-5 #точность n = 0 while (True): n += 1 print("Итерация {0} - x сейчас равен {1}".format(n, x0)) x = x0 - f(x0) / f_dash(x0) - (f(x0)**2 * f_2dash(x0)) / (2 * (f_dash(x0)**3)) if abs(x0 - x) <= e: break x0 = x print("За {0} итераций получили корень {1} с точностью {2}".format(n, x0, e))
def numericalDer(f, x0, h, aprox='All'): t = Symbol('x') fp = diff(f, t) evalfp = lambdify(t, fp, modules=['numpy']) evalf = lambdify(t, f, modules=['numpy']) fp_value = evalfp(x0) ef = np.fabs(fp_value - forwardFD(evalf, x0, h)) eb = np.fabs(fp_value - backwardFD(evalf, x0, h)) ec = np.fabs(fp_value - centeredFD(evalf, x0, h)) xl = np.linspace(x0 - 0.5 * np.pi, x0 + 0.5 * np.pi, 50) xv = np.linspace(x0 - np.pi, x0 + np.pi, 50) lf = line(xl, x0, x0 + h, evalf(x0), evalf(x0 + h)) lb = line(xl, x0, x0 - h, evalf(x0), evalf(x0 - h)) lc = line(xl, x0 - h, x0 + h, evalf(x0 - h), evalf(x0 + h)) yv = evalf(xv) yp = evalfp(xv) ancho_linea = 2.0 fig = plt.figure(figsize=(10, 5)) fig.suptitle('EF = {:10.4e}, EB = {:10.4e}, EC = {:10.4e}'.format( ef, eb, ec)) ax1 = plt.subplot(1, 2, 1) plt.plot(xv, yv, '--', lw=3, color='b', label='f = {}'.format(f)) plt.scatter(x0, evalf(x0), facecolor='b', edgecolor='k', zorder=10) if aprox == 'All': plt.scatter(x0 + h, evalf(x0 + h), facecolor='w', edgecolor='k', zorder=10) plt.scatter(x0 - h, evalf(x0 - h), facecolor='w', edgecolor='k', zorder=10) plt.scatter(x0 - 2 * h, evalf(x0 - 2 * h), facecolor='w', edgecolor='k', zorder=10) plt.plot(xl, lf, lw=ancho_linea, label="f' = Forward") plt.plot(xl, lb, lw=ancho_linea, label="f' = Backward") plt.plot(xl, lc, lw=ancho_linea, label="f' = Centered") elif aprox == 'Forward': plt.scatter(x0 + h, evalf(x0 + h), facecolor='w', edgecolor='k', zorder=10) plt.plot(xl, lf, lw=ancho_linea, label="f' = Forward") elif aprox == 'Backward': plt.scatter(x0 - h, evalf(x0 - h), facecolor='w', edgecolor='k', zorder=10) plt.plot(xl, lb, lw=ancho_linea, label="f' = Backward") elif aprox == 'Centered': plt.scatter(x0 + h, evalf(x0 + h), facecolor='w', edgecolor='k', zorder=10) plt.scatter(x0 - h, evalf(x0 - h), facecolor='w', edgecolor='k', zorder=10) plt.plot(xl, lc, lw=ancho_linea, label="f' = Centered") plt.legend(loc=(-1.0, 0.5)) ax2 = plt.subplot(1, 2, 2) plt.plot(xv, yp, '--', lw=3, color='k', label="f'= {}".format(fp)) if aprox == 'All': plt.plot(xv, forwardFD(evalf, xv, h), lw=ancho_linea) plt.plot(xv, backwardFD(evalf, xv, h), lw=ancho_linea) plt.plot(xv, centeredFD(evalf, xv, h), lw=ancho_linea) elif aprox == 'Forward': plt.plot(xv, forwardFD(evalf, xv, h), lw=ancho_linea) elif aprox == 'Backward': plt.plot(xv, backwardFD(evalf, xv, h), lw=ancho_linea) elif aprox == 'Centered': plt.plot(xv, centeredFD(evalf, xv, h), lw=ancho_linea) plt.legend() plt.show() return [ef, eb, ec]
def jacobian(functions, variables, constants): symbols = dict((v, Symbol("x[%d]" % i)) for (i, v) in enumerate(variables)) f = Matrix([parse_func(expr, symbols, constants) for expr in functions]) x = Matrix(list(symbols.values())) return lambdify("x", f), lambdify("x", f.jacobian(x))
def normal_lines(self, p, prec=None): """Normal lines between `p` and the ellipse. Parameters ========== p : Point Returns ======= normal_lines : list with 1, 2 or 4 Lines Examples ======== >>> from sympy import Line, Point, Ellipse >>> e = Ellipse((0, 0), 2, 3) >>> c = e.center >>> e.normal_lines(c + Point(1, 0)) [Line(Point(0, 0), Point(1, 0))] >>> e.normal_lines(c) [Line(Point(0, 0), Point(0, 1)), Line(Point(0, 0), Point(1, 0))] Off-axis points require the solution of a quartic equation. This often leads to very large expressions that may be of little practical use. An approximate solution of `prec` digits can be obtained by passing in the desired value: >>> e.normal_lines((3, 3), prec=2) [Line(Point(-38/47, -85/31), Point(9/47, -21/17)), Line(Point(19/13, -43/21), Point(32/13, -8/3))] Whereas the above solution has an operation count of 12, the exact solution has an operation count of 2020. """ p = Point(p) # XXX change True to something like self.angle == 0 if the arbitrarily # rotated ellipse is introduced. # https://github.com/sympy/sympy/issues/2815) if True: rv = [] if p.x == self.center.x: rv.append(Line(self.center, slope=oo)) if p.y == self.center.y: rv.append(Line(self.center, slope=0)) if rv: # at these special orientations of p either 1 or 2 normals # exist and we are done return rv # find the 4 normal points and construct lines through them with # the corresponding slope x, y = Dummy('x', real=True), Dummy('y', real=True) eq = self.equation(x, y) dydx = idiff(eq, y, x) norm = -1 / dydx slope = Line(p, (x, y)).slope seq = slope - norm points = [] if prec is not None: yis = solve(seq, y)[0] xeq = eq.subs(y, yis).as_numer_denom()[0].expand() try: iv = list(zip(*Poly(xeq).intervals()))[0] # bisection is safest here since other methods may miss root xsol = [ S(nroot(lambdify(x, xeq), i, solver="anderson")) for i in iv ] points = [ Point(i, solve(eq.subs(x, i), y)[0]).n(prec) for i in xsol ] except PolynomialError: pass if not points: points = [Point(*s) for s in solve((seq, eq), (x, y))] # complicated expressions may not be decidably real so evaluate to # check whether they are real or not points = [ i.n(prec) if prec is not None else i for i in points if all( j.n(2).is_real for j in i.args) ] slopes = [norm.subs(zip((x, y), pt.args)) for pt in points] if prec is not None: slopes = [ i.n(prec) if i not in (-oo, oo, zoo) else i for i in slopes ] return [Line(pt, slope=s) for pt, s in zip(points, slopes)]
time_derivative(eta_sol, N) + 4 * eta_sol * (eta_sol - 1) * (eta_sol - 0.5) - divergence(kappa * gradient(eta_sol, N), N)) parameters = ((kappa, params['kappa']), (A1, 0.0075), (B1, 8.0 * pi), (A2, 0.03), (B2, 22.0 * pi), (C2, 0.0625 * pi)) # substitute coefficient values subs = [sub.subs(parameters) for sub in (eq_sol, eta_sol)] # generate FiPy lambda functions from sympy.utilities.lambdify import lambdify, lambdastr (eq_fp, eta_fp) = [ lambdify((N[0], N[1], t), sub, modules=fp.numerix) for sub in subs ] kappa_fp = float(kappa.subs(parameters)) # Can't pickle lambda functions (eq_str, eta_str) = [lambdastr((N[0], N[1], t), sub) for sub in subs] data.categories["eq"] = eq_str data.categories["eta"] = eta_str data.categories["kappa"] = kappa_fp # initialize and store variables totaltime = params['totaltime'] dt = float(params['dt'])
def optimize(self, ip): ''' Optimizes a series of instructions starting from ip to a single lambda function. ''' # symbolic registers sreg = sympy.symbols(', '.join( ['r[%d]' % n for n in range(self.nregs)])) # values of symbolic regs sregv = list(sreg) ip_start = ip bbl = 0 while True: # create symbolic representation of instruction op, args = self.program[ip] s = self.ins2sym((op, args), 'sregv') bbl += 1 if DEBUG: print('%s %s' % (op.__name__, args)) print(s) # execute symbolic representation of op #print('-------') #print(s) #print(args[2], sregv) #print(sregv[3]) exec(s) # convert bool to int #if op.__name__.startswith('eq') or op.__name__.startswith('gt'): #if sregv[args[2]] == sympy.true: #sregv[args[2]] = 1 #elif sregv[args[2]] == sympy.false: #sregv[args[2]] = 0 # increment symbolic ip sregv[self.ip] += 1 # increment optimizer ip & continue if args[2] != self.ip: ip += 1 continue # ip was written to - attempt chaining # covers cases we have observed in the input if op.__name__ == 'seti': ip = args[0] + 1 continue elif op.__name__ == 'addi' and args[0] == self.ip: ip += args[1] + 1 continue else: sregv = [sympy.expand(sr) for sr in sregv] ip_str = '{0:2d} {0:2d}'.format(ip_start, ip) print('B', ip_str, self.ins2sym((op, args), 'r'), file=sys.stderr) print('C', ip_str, sregv, file=sys.stderr) break self.opt[ip_start] = (lambdify(sreg, sregv, ('math')), bbl) return self.opt[ip_start]
def _generate_features(self, df, new_feat_cols): """ Generate additional features based on the feature formulas for all data points in the df. Only works after the model was fitted. Inputs: - df: pandas dataframe with original features - new_feat_cols: names of new features that should be generated (keys of self.feature_formulas_) Returns: - df: dataframe with the additional feature columns added """ check_is_fitted(self, ["feature_formulas_"]) if not new_feat_cols: return df if not new_feat_cols[0] in self.feature_formulas_: raise RuntimeError( "[AutoFeat] First call fit or fit_transform to generate the features!" ) if self.verbose: print("[AutoFeat] Computing %i new features." % len(new_feat_cols)) # generate all good feature; unscaled this time feat_array = np.zeros((len(df), len(new_feat_cols))) for i, expr in enumerate(new_feat_cols): if self.verbose: print("[AutoFeat] %5i/%5i new features" % (i, len(new_feat_cols)), end="\r") if expr not in self.feature_functions_: # generate a substitution expression based on all the original symbols of the original features # for the given generated feature in good cols # since sympy can handle only up to 32 original features in ufunctify, we need to check which features # to consider here, therefore perform some crude check to limit the number of features used cols = [ c for i, c in enumerate(self.feateng_cols_) if colnames2symbols(c, i) in expr ] if not cols: # this can happen if no features were selected and the expr is "E" (i.e. the constant e) f = None f_jit = None else: try: f = lambdify([self.feature_formulas_[c] for c in cols], self.feature_formulas_[expr]) f_jit = nb.njit(f) except Exception: print( "[AutoFeat] Error while processing expression: %r" % expr) raise self.feature_functions_[expr] = (cols, f, f_jit) else: cols, f, f_jit = self.feature_functions_[expr] if f is not None: # only generate features for completely not-nan rows not_na_idx = df[cols].notna().all(axis=1) try: try: feat = f_jit(*(df[c].to_numpy(dtype=float)[not_na_idx] for c in cols)) except nb.TypingError: # lambified abs fn with non trivial inputs doesn't jit compile with numba, yet # fallback on the non jitted version of the function feat = f(*(df[c].to_numpy(dtype=float)[not_na_idx] for c in cols)) # henceforth, always use the non jitted version of the function self.feature_functions_[expr] = (cols, f, f) feat_array[not_na_idx, i] = feat feat_array[~not_na_idx, i] = np.nan except RuntimeWarning: print( "[AutoFeat] WARNING: Problem while evaluating expression: %r with columns %r" % (expr, cols), " - is the data in a different range then when calling .fit()? Are maybe some values 0 that shouldn't be?" ) raise if self.verbose: print("[AutoFeat] %5i/%5i new features ...done." % (len(new_feat_cols), len(new_feat_cols))) df = df.join( pd.DataFrame(feat_array, columns=new_feat_cols, index=df.index)) return df
def calculate_arc_length(self): self.sp_func["arc"] = sp.integrate(self.sp_func["speed"], self.sp_func["t"]) self.np_func["arc"] = lambdify(self.sp_func["t"], self.sp_func["arc"], 'numpy') self.np_array["arc"] = self.np_func["arc"](self.np_array["t"])
# l<n, |m|<=l n = 3 l = 1 m = 0 print('generating triplets') R = np.linspace(0, 20, 20) T = np.linspace(0, np.pi, 10) P = np.linspace(0, 2 * np.pi, 20) R, T, P = np.meshgrid(R, T, P) print('generating orbital') Psi = abs(lambdify( (Orb.r, Orb.theta, Orb.phi), Orb.RealOrbital.orbital(n, l, m).evalf(), 'numpy')(R, T, P)) Psi = normalize(Psi) print('orbital generated') print('generating points') x0, y0, z0 = Orb.SphToCart(R, T, P) print('points generated') fig = plt.figure() ax0 = fig.add_subplot(111, projection='3d') print('plotting') print('generating colors')
def Homotopy_Continuation(t, input_variables, input_functions, number_of_steps = 5, expanded_functions = None, expansion_variables = None,\ matrix_A = A, det_matrix = det_4by4_matrix, inverse_matrix = inverse_4by4_matrix, remainder_tolerance = 1e-2, check_determinant_H = 1e-6, \ newton_ratio_accuracy = 1e-10, max_newton_step = 5, debug = False, \ Newtons_method = True, save_path = False, file_name = 'Homotopy_Roots'): """ Perfroms the Homotopy Continuation to determine the roots of a given function F, within a certain accuracy using the RK4 method during the predictor step and either Newton's method of Minuit for the root-finding step. Parameters: t : Just given as a variable, the time step. input_variables : Symbols to use as variables. Must be given as an array or list. Length determines the the number of dimensions to consider. Example: [x,y] for 2 dimension, where the symbols used must first be imported above. Must not contain t. input_functions : Function to be determined. Should be given as a list or array of variables. Example: F = [x**2 , y**2] number_of_steps : Number of steps for the Homotopy Continuation. Default : 5 expanded_functions : expansion into complex, Ex: [a + 1j*b, c + 1j*d] Variables must first be imported above, and cannot contain those in input_variables or t Only needed when Minuit is used expansion_variables = Array of variables for expansion to complex numbers, Ex for 2D : [a,b,c,d] Only needed when Minuit is used remainder_tolerance : Tolerance for roots to be considered, how far is the function from zero. check_determinant_H : check that determinant is not below this tolerance newton_ratio_accuracy : Convergence criteria for Newton's max_newton_step = Max number of steps for Newton's method Newtons_method : Default True else use Minuit save_path : Tracks and saves how roots evolve file_name : Save roots in file """ time_start = time.time() #convert F to a function F = lambdify([input_variables], input_functions) #store the least accurate root max_remainder_value = 0 #count the number of roots found number_of_count = 0 #step size delta_t = 1/number_of_steps #determine the number of dimensions considered dimension = len(input_variables) #generate gamma gamma = Gamma_Generator() #determine roots of easy polynomial G_roots = G_Roots(dimension) #construct homotopy H = Homotopy(t, G(input_variables), F(input_variables), gamma) #first derivative of H wrt to all the x variables derivative_H_wrt_x = sy.Matrix([[H[i].diff(input_variables[j]) for j in range(len(input_variables))] for i in range(len(input_variables))]) print(len(derivative_H_wrt_x)) print('here') if dimension < 4: time1 = time.time() determinant_H = derivative_H_wrt_x.det(method='lu') print('Cal: {}'.format(determinant_H)) #invert the matrix of the derivatives of H wrt to x variables inverse_derivative_H_wrt_x = derivative_H_wrt_x.inv(method = 'LU') print('inv:{}'.format(inverse_derivative_H_wrt_x)) time2 = time.time() print('Time for calculation : {}'.format(time2 - time1)) else: time3 = time.time() determinant_H = det_matrix.subs(zip(list(matrix_A), list(derivative_H_wrt_x))) inverse_derivative_H_wrt_x = inverse_matrix.subs(list(zip(matrix_A, derivative_H_wrt_x))) time4 = time.time() print('Time for sub : {}'.format(time4 - time3)) #check the determinant does not go to zero so can invert if determinant_H == 0: raise TypeError('1. The determinant of H is zero!') print('reA H') #function of determinant H determinant_H_func = lambdify((t, input_variables), determinant_H) #derivative of H with respect to t derivative_H_wrt_t = sy.Matrix([H[i].diff(t) for i in range(len(input_variables))]) print('halp') #differentiate of x wrt to t x_derivative_t = -inverse_derivative_H_wrt_x*derivative_H_wrt_t x_derivative_t_func = lambdify((t, input_variables), [x_derivative_t[i] for i in range(len(x_derivative_t))]) x_derivative_t_func_1d = lambdify((t,input_variables), H[0].diff(t)/H[0].diff(x)) #determine H/H' to use in Newton's method H_over_derivative_H_wrt_x = inverse_derivative_H_wrt_x*sy.Matrix(H) H_over_derivative_H_wrt_x_func = lambdify((t, input_variables), [H_over_derivative_H_wrt_x[i] for i in range(len(H_over_derivative_H_wrt_x))]) #track paths of roots paths = [] #track roots solutions = [] #track accuracy of each root accuracies = [] print('reached here') #run for all roots in the starting system for x_old in G_roots: #path of each root trace = [] #root number being found number_of_count += 1 #set homotopy to inital system t_new = 0 #convert 1D to an array if dimension == 1: x_old = np.array([x_old]) #run for all steps starting at t=0 ending at t=1 while round(t_new,5) < 1: trace.append(x_old) t_old = t_new #increment time by step size t_new += delta_t if dimension == 1: #perform RK4 for 1 D predictor = spi.solve_ivp(x_derivative_t_func_1d, (t_old, t_new), x_old) predicted_solution = np.array([predictor.y[-1][-1]]) if dimension != 1: #check determinant to make sure does not go to zero if abs(determinant_H_func(t_new, x_old)) < check_determinant_H: raise TypeError('2. The determinant of H is zero!') #perform RK4 method for n dimensions predictor = spi.solve_ivp(x_derivative_t_func, (t_old, t_new), x_old) predicted_solution = predictor.y[:,-1] x_old = predicted_solution #newton's method #track how root changes and the number of steps used ratio = np.full(dimension, 1) number_of_newton_steps = 0 change_in_x = np.full(dimension, newton_ratio_accuracy) if Newtons_method is True: method_used = 'Newton-Raphson with ' + str(max_newton_step) + ' steps.' #track amount of time newton uses for debugging time_newtons_start = time.time() #convergence criteria for step size in Newton's Method while max(ratio) > newton_ratio_accuracy and number_of_newton_steps < max_newton_step: if debug: print("Before Newton", x_old) #check determinant to ensure can invert if dimension != 1: if abs(determinant_H_func(t_new, x_old)) < check_determinant_H: raise TypeError('3. The determinant of H is zero!') #find new position of root x_old_intermediate = x_old - H_over_derivative_H_wrt_x_func(t_new, x_old) change_in_x_old = change_in_x change_in_x = abs(x_old_intermediate - x_old) #calculate change in position of root ratio = [change_in_x[j]/(change_in_x_old[j] + 1e-10) for j in range(dimension)] x_old = x_old_intermediate number_of_newton_steps += 1 time_newtons_end = time.time() if debug: print("After Newton", x_old) if debug: print('Time for Newton: {}'.format(time_newtons_end - time_newtons_start)) #Minuit else: method_used = 'Minuit' #Minuit only runs for more than 1 dimension if dimension == 1: raise TypeError('Minuit only runs for more than 1 dimension!') #track time for debugging time_minuit_start = time.time() #substitute time t at each step into Homotopy equation H_at_fixed_t = Homotopy(t_new, G(expanded_functions), F(expanded_functions), gamma) if debug: print("Homotopy at current step: ", H_at_fixed_t) #split real and imaginary and sum absolute value of expressions H_im_real = sum([abs(sy.re(i_re)) for i_re in H_at_fixed_t] + [abs(sy.im(i_im)) for i_im in H_at_fixed_t]) if debug: print("Homotopy Absolute value at current step: ", H_im_real) #convert into function H_im_real_func = lambdify([expansion_variables], H_im_real) x_old_re_im = [] #split x_old to real and imaginary for i in range(dimension): x_old_re_im.append(np.real(x_old[i])) x_old_re_im.append(np.imag(x_old[i])) #convert variables to strings for input into Minuit string_variables = [str(j) for j in expansion_variables] #call iminuit function if debug: print("Before Minuit we start at", x_old_re_im) printlevel = 10 if debug else 0 #find roots using Minuit m = im.Minuit.from_array_func(H_im_real_func, x_old_re_im, forced_parameters= string_variables,print_level=printlevel) m.migrad(resume=False) x_old_im_re_vals = m.values #reconstruct roots from real and imaginary parts x_old = [x_old_im_re_vals[j] + 1j*x_old_im_re_vals[j+1] for j in range(0, 2*dimension, 2)] if debug: print("After Minuit we got", x_old) time_minuit_end = time.time() if debug: print('Time for Minuit: {}'.format(time_minuit_end - time_minuit_start)) trace.append(x_old) #check root is found by ensuring roots found is within the tolerance if dimension == 1 : remainder = list(map(abs, F([x_old]))) remainder = list(map(abs, F(x_old))) if max(remainder) < remainder_tolerance: #make root real if imaginary part is below the zero tolerance x_old = [x_old[i].real if abs(x_old[i].imag) < check_determinant_H else x_old[i] for i in range(len(x_old))] #store the maximum remainder max_rem = max(remainder) if max_remainder_value < max_rem: max_remainder_value = max_rem solutions.append(x_old) #if paths are wanted if save_path is True: paths.append(trace) accuracies.append(remainder) time_end = time.time() if save_path is False: paths = np.full(len(solutions),'-') #save information into csv file other_info = ['Function Used'] + input_functions + [''] + ['Time Taken'] + [time_end - time_start] + [''] + \ ['Root Finding Method Used'] + [method_used] + [''] + ['Worst Accuracy'] + [max_remainder_value] + \ [''] + ['Number of Homotopy Steps'] + [number_of_steps] len_solutions = len(solutions) total_length = max(len(other_info), len_solutions) other_info = other_info + list(np.full(total_length - len(other_info), '')) solutions = solutions + list(np.full(total_length - len_solutions, '')) accuracies = accuracies + list(np.full(total_length - len_solutions, '')) paths = list(paths) + list(np.full(total_length - len_solutions, '')) df = pd.DataFrame({'Roots' : solutions, 'Accuracy' : accuracies, 'Paths' : paths, 'Other Info' : other_info}) df.to_csv(file_name + '.csv', index=True) return solutions, paths
var = (x_pre, y_pre, x_new, y_new, p_norm, a1, b1, c1, a2, b2, c2, t, s) f = Matrix([ a1 * a1 + b1 * b1 + c1 * c1 * p_norm + 2 * (a1 * c1 * x_pre + b1 * c1 * y_pre) - 1, a2 * a2 + b2 * b2 + c2 * c2 * p_norm + 2 * (a2 * c2 * x_pre + b2 * c2 * y_pre) - 1, a1 * a2 + b1 * b2 + c1 * c2 * p_norm + x_pre * (a1 * c2 + c1 * a2) + y_pre * (b1 * c2 + c1 * b2), s * s + t * t - 1, s * (a1 + c1 * x_pre - 1) + t * (b1 + c1 * y_pre), s * (a2 + c2 * x_pre) + t * (b2 + c2 * y_pre - 1), a1 * x_pre + b1 * y_pre + c1 * p_norm - x_new, a2 * x_pre + b2 * y_pre + c2 * p_norm - y_new ]) func = sp.Matrix.norm(f) lam_f = lambdify(var, func, 'numpy') def lam(x_pre, y_pre, x_new, y_new, p_norm): return lambda a1,b1,c1,a2,b2,c2,t,s: \ lam_f(x_pre,y_pre,x_new,y_new,p_norm,a1,b1,c1,a2,b2,c2,t,s) arr_init = np.array([1, 0, 0, 0, 1, 0, 1, 1]) print("lambda: ready") ######## Graph Drawing ######## root = Tk() w = Canvas(root, width=_width, height=_height, bg='White') w.pack() circles = []
def createMMSSourceFunctionsRadHydro(rho, u, E, psim, psip, sigma_s_value, sigma_a_value, gamma_value, cv_value, alpha_value, display_equations=False): # declare symbolic variables x, t, alpha = symbols('x t alpha') sigs, siga, sigt = symbols('sigma_s sigma_a sigma_t') gamma, cv, c, a = symbols('gamma c_v c a') # compute other thermodynamic quantities based on ideal gas EOS e = E / rho - u * u / 2 p = rho * e * (gamma - 1) T = e / cv rhou = rho * u # compute other radiation quantities phi = psim + psip Er = phi / c Fr = (psip - psim) / sqrt(3) Fr0 = Fr - sympify('4/3') * Er * u Q0 = siga * a * c * T**4 - sigt * u / c * Fr0 Q1 = sympify('4/3') * sigt * Er * u Qm = Q0 - sympify('3/sqrt(3)') * Q1 Qp = Q0 + sympify('3/sqrt(3)') * Q1 # temporal derivatives drhodt = diff(rho, t) drhoudt = diff(rhou, t) dEdt = diff(E, t) dpsimdt = diff(psim, t) dpsipdt = diff(psip, t) # spatial derivatives drhoudx = diff(rhou, x) drhouudx = diff(rhou * u, x) dpdx = diff(p, x) dEfluxdx = diff((E + p) * u, x) dpsimdx = diff(psim, x) dpsipdx = diff(psip, x) # compute sources Qrho = drhodt + drhoudx Qu = drhoudt + drhouudx + dpdx - sigt / c * Fr0 QE = dEdt + dEfluxdx + siga * c * (a * T**4 - Er) - sigt * u / c * Fr0 Qpsim = dpsimdt / c - dpsimdx / sqrt( 3) + sigt * psim - sigs / 2 * phi - Qm / 2 Qpsip = dpsipdt / c + dpsipdx / sqrt( 3) + sigt * psip - sigs / 2 * phi - Qp / 2 # display equations if display_equations: # initialize printing to use prettiest format available (e.g., LaTeX, Unicode) init_printing() # create an equation and then display it eq = Eq(symbols('rho'), rho) display(eq) eq = Eq(symbols('u'), u) display(eq) eq = Eq(symbols('E'), E) display(eq) eq = Eq(symbols('e'), simplify(e)) display(eq) eq = Eq(symbols('T'), T) display(eq) eq = Eq(symbols('p'), p) display(eq) eq = Eq(symbols('Psi^-'), psim) display(eq) eq = Eq(symbols('Psi^+'), psip) display(eq) eq = Eq(symbols('E_r'), Er) display(eq) eq = Eq(symbols('F_r'), Fr) display(eq) eq = Eq(symbols('Q_rho'), Qrho) display(eq) eq = Eq(symbols('Q_u'), Qu) display(eq) eq = Eq(symbols('Q_E'), QE) display(eq) eq = Eq(symbols('Q_-'), Qpsim) display(eq) eq = Eq(symbols('Q_+'), Qpsip) display(eq) # substitute for all symbols except x and t substitutions = dict() substitutions['alpha'] = alpha_value substitutions['a'] = GC.RAD_CONSTANT substitutions['c'] = GC.SPD_OF_LGT substitutions['c_v'] = cv_value substitutions['gamma'] = gamma_value substitutions['sigma_s'] = sigma_s_value substitutions['sigma_a'] = sigma_a_value sigma_t_value = sigma_s_value + sigma_a_value substitutions['sigma_t'] = sigma_t_value # make substitutions Qrho_sub = Qrho.subs(substitutions) Qu_sub = Qu.subs(substitutions) QE_sub = QE.subs(substitutions) Qpsim_sub = Qpsim.subs(substitutions) Qpsip_sub = Qpsip.subs(substitutions) # create MMS source functions rho_f = lambdify((symbols('x'), symbols('t')), Qrho_sub, "numpy") u_f = lambdify((symbols('x'), symbols('t')), Qu_sub, "numpy") E_f = lambdify((symbols('x'), symbols('t')), QE_sub, "numpy") psim_f = lambdify((symbols('x'), symbols('t')), Qpsim_sub, "numpy") psip_f = lambdify((symbols('x'), symbols('t')), Qpsip_sub, "numpy") return (rho_f, u_f, E_f, psim_f, psip_f)
def test_hypot(): if not np: skip("NumPy not installed") assert abs(lambdify((a, b), hypot(a, b), 'numpy')(3, 4) - 5) < 1e-16
zmin, zmax = 0, 10 x0 = 3 start_fsolve = ymin posun_z = 0 delkax = 2 delkay = 2 tecna_rovina_kreslit = False bez_znacek = False fig = plt.figure() ax = fig.gca(projection='3d') # vypocet gradientu a tecne roviny from sympy.abc import x, y from sympy.utilities.lambdify import lambdify, implemented_function gradfx = lambdify((x, y), f(x, y).diff(x)) gradfy = lambdify((x, y), f(x, y).diff(y)) if lambdifyf: f = lambdify((x, y), f(x, y), 'numpy') # dopocitani bodu na vrstevnici from scipy import * from scipy import optimize g = lambda y: f(x0, y) try: y0 = optimize.fsolve(g, start_fsolve)[0] except: print "nenalezeno y0" y0 = 0
def test_log10(): if not np: skip("NumPy not installed") assert abs(lambdify((a,), log10(a), 'numpy')(100) - 2) < 1e-16
def test_codegen_extra(): if not tf: skip("TensorFlow not installed") graph = tf.Graph() with graph.as_default(): session = tf.compat.v1.Session() M = MatrixSymbol("M", 2, 2) N = MatrixSymbol("N", 2, 2) P = MatrixSymbol("P", 2, 2) Q = MatrixSymbol("Q", 2, 2) ma = tf.constant([[1, 2], [3, 4]]) mb = tf.constant([[1, -2], [-1, 3]]) mc = tf.constant([[2, 0], [1, 2]]) md = tf.constant([[1, -1], [4, 7]]) cg = CodegenArrayTensorProduct(M, N) assert tensorflow_code(cg) == \ 'tensorflow.linalg.einsum("ab,cd", M, N)' f = lambdify((M, N), cg, 'tensorflow') y = session.run(f(ma, mb)) c = session.run(tf.einsum("ij,kl", ma, mb)) assert (y == c).all() cg = CodegenArrayElementwiseAdd(M, N) assert tensorflow_code(cg) == 'tensorflow.math.add(M, N)' f = lambdify((M, N), cg, 'tensorflow') y = session.run(f(ma, mb)) c = session.run(ma + mb) assert (y == c).all() cg = CodegenArrayElementwiseAdd(M, N, P) assert tensorflow_code(cg) == \ 'tensorflow.math.add(tensorflow.math.add(M, N), P)' f = lambdify((M, N, P), cg, 'tensorflow') y = session.run(f(ma, mb, mc)) c = session.run(ma + mb + mc) assert (y == c).all() cg = CodegenArrayElementwiseAdd(M, N, P, Q) assert tensorflow_code(cg) == \ 'tensorflow.math.add(' \ 'tensorflow.math.add(tensorflow.math.add(M, N), P), Q)' f = lambdify((M, N, P, Q), cg, 'tensorflow') y = session.run(f(ma, mb, mc, md)) c = session.run(ma + mb + mc + md) assert (y == c).all() cg = CodegenArrayPermuteDims(M, [1, 0]) assert tensorflow_code(cg) == 'tensorflow.transpose(M, [1, 0])' f = lambdify((M, ), cg, 'tensorflow') y = session.run(f(ma)) c = session.run(tf.transpose(ma)) assert (y == c).all() cg = CodegenArrayPermuteDims(CodegenArrayTensorProduct(M, N), [1, 2, 3, 0]) assert tensorflow_code(cg) == \ 'tensorflow.transpose(' \ 'tensorflow.linalg.einsum("ab,cd", M, N), [1, 2, 3, 0])' f = lambdify((M, N), cg, 'tensorflow') y = session.run(f(ma, mb)) c = session.run(tf.transpose(tf.einsum("ab,cd", ma, mb), [1, 2, 3, 0])) assert (y == c).all() cg = CodegenArrayDiagonal(CodegenArrayTensorProduct(M, N), (1, 2)) assert tensorflow_code(cg) == \ 'tensorflow.linalg.einsum("ab,bc->acb", M, N)' f = lambdify((M, N), cg, 'tensorflow') y = session.run(f(ma, mb)) c = session.run(tf.einsum("ab,bc->acb", ma, mb)) assert (y == c).all()
def compileExpr(self, inputSymb, inputExpr, backend=None, compileType=False): ''' Compiles the expression given the symbols. Determines the backend if required. Parameters ---------- inputSymb: list the set of symbols for the input expression inputExpr: expr expression in sympy backend: optional the backend we want to use to compile compileType: optional defaults to False. If True, return an extra output that informs the end user of the method used to compile the equation, can be one of (np, mpmath, sympy) Returns ------- Compiled function taking arguments of the input symbols ''' if backend is None: backend = self._backend # unless specified, we are always going to use np and forget # about the floating point importance compiledFunc = None compileTypeChosen = None try: if backend == 'f2py': compiledFunc = autowrap(expr=inputExpr, args=inputSymb, backend='f2py') compileTypeChosen = 'np' elif backend == 'lambda': compiledFunc = lambdify(expr=inputExpr, args=inputSymb, modules='numpy') compileTypeChosen = 'np' elif backend.lower() in ('cython', 'np'): # note that we have another test layer because of the # bug previously mentioned in __init__ of this class try: compiledFunc = autowrap(expr=inputExpr, args=inputSymb, backend='Cython') compileTypeChosen = 'np' except: # although we don't think it is possible given the checks # previously performed, we should still try it try: compiledFunc = autowrap(expr=inputExpr, args=inputSymb, backend='f2py') compileTypeChosen = 'np' except: compiledFunc = lambdify(expr=inputExpr, args=inputSymb, modules='numpy') compileTypeChosen = 'np' else: raise ExpressionErrror("The problem is too tough") except: try: compiledFunc = lambdify(expr=inputExpr, args=inputSymb, modules='mpmath') compileTypeChosen = 'mpmath' except: compiledFunc = lambdify(expr=inputExpr, args=inputSymb, modules='sympy') compileTypeChosen = 'sympy' logging.debug('Compiled expression as {}'.format(compileTypeChosen)) if compileType: return compiledFunc, compileTypeChosen else: return compiledFunc
def _basis_elem(l, m, x, y, z): calculation = SH._basis_elem_sympy(l, m) func = lambdify([SH.x, SH.y, SH.z], calculation) return func(x, y, z)
def test_expm1(): if not np: skip("NumPy not installed") f = lambdify((a,), expm1(a), 'numpy') assert abs(f(1e-10) - 1e-10 - 5e-21) < 1e-22
def test_log1p(): if not np: skip("NumPy not installed") f = lambdify((a,), log1p(a), 'numpy') assert abs(f(1e-99) - 1e-99) < 1e-100