def _calculate_Lie_derivative(self, expr: sp.Expr) -> sp.Expr:
"""Calculates Lie derivative using chain rule."""
result = sp.Integer(0)
for var in expr.free_symbols.difference(
self.variables.parameter).difference(self.variables.input):
var_diff_eq = list(
filter(lambda eq: eq.args[0] == make_derivative_symbol(var),
self._equations))[0]
var_diff = var_diff_eq.args[1]
result += expr.diff(var) * var_diff
for input_var in expr.free_symbols.intersection(self.variables.input):
input_var_dot = make_derivative_symbol(input_var)
self.variables.input.add(input_var_dot)
result += expr.diff(input_var) * input_var_dot
return self._apply_substitutions(
self._apply_substitutions(result).expand())
def incertezarápido(f: sp.Expr) -> sp.Expr:
uf = 0
udict = {}
for s in f.free_symbols:
udict[s] = sp.Symbol('u' + str(s))
uf += udict[s] ** 2 * (f.diff(s) ** 2)
uf = sp.sqrt(uf)
return uf
def incerteza_absoluta(f: sp.Expr) -> sp.Expr:
uf = 0
udict = {}
for s in f.free_symbols:
udict[s] = sp.Symbol('u' + str(s))
uf += udict[s]**2 * sp.simplify(f.diff(s)**2)
uf = sp.sqrt(uf)
return uf
def incerteza_relativa(f: sp.Expr, v: sp.Symbol) -> sp.Expr:
uf = 0
udict = {}
for s in f.free_symbols:
udict[s] = sp.Symbol('u' + str(s))
df = sp.simplify(f.diff(s)**2 / f**2)
uf += udict[s]**2 * df
uf = v * sp.sqrt(uf)
return uf
def evaluate_partial_error(formula: sympy.Expr, variable: sympy.Symbol,
values: {sympy.Symbol: float}, avg_common: dict,
avg_results: {sympy.Symbol: {
str: float
}}, settings: dict):
rnd = lambda x: round_to_n(x, settings['round']
) if 'round' in settings else x
differential = rnd(formula.diff(variable).evalf(subs=values))
result = {
'result':
rnd(differential * (avg_results[variable]['error'] if variable
in avg_results else avg_common[variable]['error']))
}
if settings['extended']:
result['symbol'] = variable
result['differential'] = formula.diff(variable)
result['differential_value'] = differential
result['partial_error'] = rnd(
avg_results[variable]['error'] if variable in
avg_results else avg_common[variable]['error'])
return result
def solve_scalar(f: sp.Expr, x0, tol):
"""
solve scalar equation y=f(x) starting with x0
derivative can be obtained as f.diff()
evaluate: float(f.subs(x, x0))
"""
xs = []
ys = []
x1 = x0
i = 1
max_iterations = 500
xs.append(x0)
ys.append(float(f.evalf(subs={x: x0})))
while i < max_iterations:
x_prev = x1
x1 = x1 - float(f.evalf(subs={x: x1})) / float(f.diff().evalf(subs={x: x1})) # x(n+1) = x(n) - f(x(n))/f'(x(n))
xs.append(x1)
ys.append(float(f.evalf(subs={x: x1})))
err = abs(x1 - x_prev)
if err < tol:
break
i += 1
return xs, ys
def __init__(self, f: Expr, g: Expr):
self.f = f
self.g = g
x = sorted(f.atoms(), key=lambda s: s.name)
self.m = m = len(g)
self.n = len(x)
l = array_sym("lambda", m)
s = Symbol("obj_factor")
L = s * f + sum(l_i * g_i for l_i, g_i in zip(l, g))
"""Lagrangian"""
jac_g = [[g_i.diff(x_i) for x_i in x] for g_i in g]
jac_g_sparse, jac_g_sparsity_indices = sparsify(jac_g)
h = [[dL.diff(x_j) for x_j in x] for dL in [L.diff(x_i) for x_i in x]]
h_sparse, h_sparsity_indices = sparsify(ll_triangular(h))
self.grad_f = [f.diff(x_i) for x_i in x]
self.jac_g = jac_g_sparse
self.h = h_sparse
self.h_sparsity_indices = transpose(h_sparsity_indices)
self.jac_g_sparsity_indices = transpose(jac_g_sparsity_indices)
def amp_and_shift(expr: Expr, x: Symbol) -> Tuple[Expr, Expr]:
amp = simplify(cancel(sqrt(expr**2 + expr.diff(x)**2).subs(x, 0)))
shift = arg(expr.subs(x, 0) + I * expr.diff(x).subs(x, 0))
return amp, shift
