我们从Python开源项目中，提取了以下12个代码示例，用于说明如何使用sympy.flatten()。
def state_update_equation(self, state_update_equation): if state_update_equation is None: if self.dim_state > 0: state_update_equation = self.state else: state_update_equation = self.input assert state_update_equation.atoms(sp.Symbol) <= set( self.constants_values.keys()) | set([dynamicsymbols._t]) self._state_update_equation = state_update_equation if self.dim_state: assert find_dynamicsymbols(state_update_equation) <= \ set(self.state) self.state_update_equation_function = self.code_generator( [dynamicsymbols._t] + sp.flatten(self.state), self._state_update_equation.subs(self.constants_values), **self.code_generator_args ) else: assert find_dynamicsymbols(state_update_equation) <= \ set(self.input) self.state_update_equation_function = self.code_generator( [dynamicsymbols._t] + sp.flatten(self.input), self._state_update_equation.subs(self.constants_values), **self.code_generator_args )
def event_variable_equation(self, event_variable_equation): assert event_variable_equation.atoms(sp.Symbol) <= set( self.constants_values.keys()) | set([dynamicsymbols._t]) self._event_variable_equation = event_variable_equation if self.dim_state: assert find_dynamicsymbols(event_variable_equation) <= \ set(self.state) self.event_variable_equation_function = self.code_generator( [dynamicsymbols._t] + sp.flatten(self.state), self._event_variable_equation.subs(self.constants_values), **self.code_generator_args ) else: assert find_dynamicsymbols(event_variable_equation) <= \ set(self.input) self.event_variable_equation_function = self.code_generator( [dynamicsymbols._t] + sp.flatten(self.input), self._event_variable_equation.subs(self.constants_values), **self.code_generator_args )
def test_solve_biquadratic(): x0, y0, x1, y1, r = symbols('x0 y0 x1 y1 r') f_1 = (x - 1)**2 + (y - 1)**2 - r**2 f_2 = (x - 2)**2 + (y - 2)**2 - r**2 assert solve_poly_system([f_1, f_2], x, y) == \ [(S(3)/2 - sqrt(-1 + 2*r**2)/2, S(3)/2 + sqrt(-1 + 2*r**2)/2), (S(3)/2 + sqrt(-1 + 2*r**2)/2, S(3)/2 - sqrt(-1 + 2*r**2)/2)] f_1 = (x - 1)**2 + (y - 2)**2 - r**2 f_2 = (x - 1)**2 + (y - 1)**2 - r**2 assert solve_poly_system([f_1, f_2], x, y) == \ [(1 - sqrt(((2*r - 1)*(2*r + 1)))/2, S(3)/2), (1 + sqrt(((2*r - 1)*(2*r + 1)))/2, S(3)/2)] query = lambda expr: expr.is_Pow and expr.exp is S.Half f_1 = (x - 1 )**2 + (y - 2)**2 - r**2 f_2 = (x - x1)**2 + (y - 1)**2 - r**2 result = solve_poly_system([f_1, f_2], x, y) assert len(result) == 2 and all(len(r) == 2 for r in result) assert all(r.count(query) == 1 for r in flatten(result)) f_1 = (x - x0)**2 + (y - y0)**2 - r**2 f_2 = (x - x1)**2 + (y - y1)**2 - r**2 result = solve_poly_system([f_1, f_2], x, y) assert len(result) == 2 and all(len(r) == 2 for r in result) assert all(len(r.find(query)) == 1 for r in flatten(result))
def system_from_matrix_DE(mat_DE, mat_var, mat_input=None, constants={}): """ Construct a symbolic DynamicalSystem using matrices. See riccati_system example. Parameters ---------- mat_DE : sympy Matrix The matrix derivative expression (right hand side) mat_var : sympy Matrix The matrix state mat_input : list-like of input expressions, optional A list-like of input expressions in the matrix differential equation constants : dict, optional Dictionary of constants substitutions. Returns ------- sys : DynamicalSystem A DynamicalSystem which can be used to numerically solve the matrix differential equation. """ vec_var = list(set(sp.flatten(mat_var.tolist()))) vec_DE = sp.Matrix.zeros(len(vec_var), 1) iterator = np.nditer(mat_DE, flags=['multi_index', 'refs_ok']) for it in iterator: i, j = iterator.multi_index idx = vec_var.index(mat_var[i, j]) vec_DE[idx] = mat_DE[i, j] sys = DynamicalSystem(vec_DE, sp.Matrix(vec_var), mat_input, constants_values=constants) return sys
def update_state_equation_function(self): if not self.dim_state or self.state_equation == empty_array(): return self.state_equation_function = self.code_generator( [dynamicsymbols._t] + sp.flatten(self.state) + sp.flatten(self.input), self.state_equation.subs(self.constants_values), **self.code_generator_args )
def update_state_jacobian_function(self): if not self.dim_state or self.state_equation == empty_array(): return self.state_jacobian_equation_function = self.code_generator( [dynamicsymbols._t] + sp.flatten(self.state) + sp.flatten(self.input), self.state_jacobian_equation.subs(self.constants_values), **self.code_generator_args )
def update_output_equation_function(self): if not self.dim_output or self.output_equation == empty_array(): return if self.dim_state: self.output_equation_function = self.code_generator( [dynamicsymbols._t] + sp.flatten(self.state), self.output_equation.subs(self.constants_values), **self.code_generator_args ) else: self.output_equation_function = self.code_generator( [dynamicsymbols._t] + sp.flatten(self.input), self.output_equation.subs(self.constants_values), **self.code_generator_args )
def test_get_derivatives(navier_stokes_problem, grid): """ Ensure that spatial and temporal Derivative objects are identified and returned correctly. """ expanded_equations = navier_stokes_problem.get_expanded(navier_stokes_problem.equations) expanded_formulas = navier_stokes_problem.get_expanded(navier_stokes_problem.formulas) spatial_derivatives, temporal_derivatives = get_derivatives(flatten(expanded_equations)) assert str(spatial_derivatives) == "[Derivative(rhou0[x0, x1, t], x0), Derivative(rhou1[x0, x1, t], x1), Derivative(rhou0[x0, x1, t]*u1[x0, x1, t], x1), Derivative(p[x0, x1, t] + rhou0[x0, x1, t]*u0[x0, x1, t], x0), Derivative(u1[x0, x1, t], x0, x1), Derivative(u0[x0, x1, t], x0, x0), Derivative(u0[x0, x1, t], x1, x1), Derivative(rhou1[x0, x1, t]*u0[x0, x1, t], x0), Derivative(p[x0, x1, t] + rhou1[x0, x1, t]*u1[x0, x1, t], x1), Derivative(u0[x0, x1, t], x0, x1), Derivative(u1[x0, x1, t], x1, x1), Derivative(u1[x0, x1, t], x0, x0), Derivative((p[x0, x1, t] + rhoE[x0, x1, t])*u0[x0, x1, t], x0), Derivative((p[x0, x1, t] + rhoE[x0, x1, t])*u1[x0, x1, t], x1), Derivative(u0[x0, x1, t], x0), Derivative(u1[x0, x1, t], x1), Derivative(u0[x0, x1, t], x1), Derivative(u1[x0, x1, t], x0), Derivative(T[x0, x1, t], x0, x0), Derivative(T[x0, x1, t], x1, x1)]" assert str(temporal_derivatives) == "[Derivative(rho[x0, x1, t], t), Derivative(rhou0[x0, x1, t], t), Derivative(rhou1[x0, x1, t], t), Derivative(rhoE[x0, x1, t], t)]" return
def test_maximum_derivative_order(mass, momentum, energy): """ Check that the maximum Derivative order is second-order. """ assert maximum_derivative_order(flatten([mass.expanded, momentum.expanded, energy.expanded])) == 2
def test_expand(): """ Ensure that an equation is expanded correctly. """ equations = ["Eq(Der(rho,t), -c*Conservative(rhou_j,x_j))"] substitutions = [] ndim = 1 constants = ["c"] coordinate_symbol = "x" metrics = [False, False] formulas = ["Eq(u_i, rhou_i/rho)"] problem = Problem(equations, substitutions, ndim, constants, coordinate_symbol, metrics, formulas) expanded_equations = flatten(problem.get_expanded(problem.equations)) expanded_formulas = flatten(problem.get_expanded(problem.formulas)) assert len(expanded_equations) == 1 assert str(expanded_equations[0].lhs) == "Derivative(rho[x0, t], t)" assert str(expanded_equations[0].rhs) == "-c*Derivative(rhou0[x0, t], x0)" assert len(expanded_formulas) == 1 assert str(expanded_formulas[0].lhs) == "u0[x0, t]" assert str(expanded_formulas[0].rhs) == "rhou0[x0, t]/rho[x0, t]" # Test the other way of expanding equations assert expanded_equations == flatten(problem.get_expanded(problem.expand(equations))) return
def hasNullSpace(self): if self.rawStoichiometryMatrix is None: return False for var in flatten(self.rawStoichiometryMatrix): if var in [SympyInf, -SympyInf, SympyNan]: return False return True
