def batman_equations():
x = sm.symbols('x', real=True)
shoulder = ((sm.S(6) * sm.Abs(sm.sqrt(10)) / 7 +
(sm.S(3) / 2 - sm.Abs(x) / 2)) -
(sm.S(6) * sm.Abs(sm.sqrt(10)) / 14) *
sm.Abs(sm.sqrt(4 - (sm.Abs(x) - 1)**2)))
cheek = 9 - 8 * sm.Abs(x)
ear = 3 * sm.Abs(x) + sm.S(3) / 4
head = 2 + sm.S(2) / 4
top_wing = 3 * sm.sqrt(-x**2 + 49) / 7
bottom_wing = -top_wing
tail = ((sm.Abs(x / 2) - ((3 * sm.sqrt(33) - 7) / 112) * x**2 - 3) +
sm.sqrt(1 - (sm.Abs(sm.Abs(x) - 2) - 1)**2))
top = sm.Piecewise((top_wing, x >= 3), (shoulder, x >= 1),
(cheek, x >= sm.S(3) / 4), (ear, x >= sm.S(7) / 12),
(head, x >= -sm.S(7) / 12), (ear, x >= -sm.S(3) / 4),
(cheek, x >= -1), (shoulder, x >= -3), (top_wing, True))
bottom = sm.Piecewise((bottom_wing, x >= 4), (tail, x >= -4),
(bottom_wing, True))
return top, bottom
def test_trig_solution(theta, phi, lamb, xi, theta1, theta2):
r"""Test if arguments are a solution to a system of equations.
.. math::
\cos(\phi+\lambda) \cos(\\theta) = \cos(xi) * \cos(\\theta1+\\theta2)
\sin(\phi+\lambda) \cos(\\theta) = \sin(xi) * \cos(\\theta1-\\theta2)
\cos(\phi-\lambda) \sin(\\theta) = \cos(xi) * \sin(\\theta1+\\theta2)
\sin(\phi-\lambda) \sin(\\theta) = \sin(xi) * \sin(-\\theta1+\\theta2)
Returns the maximum absolute difference between right and left hand sides
as a Max symbol. See:
http://docs.sympy.org/latest/modules/functions/elementary.html?highlight=max
"""
delta1 = sympy.Abs(
sympy.cos(phi + lamb) * sympy.cos(theta) -
sympy.cos(xi) * sympy.cos(theta1 + theta2))
delta2 = sympy.Abs(
sympy.sin(phi + lamb) * sympy.cos(theta) -
sympy.sin(xi) * sympy.cos(theta1 - theta2))
delta3 = sympy.Abs(
sympy.cos(phi - lamb) * sympy.sin(theta) -
sympy.cos(xi) * sympy.sin(theta1 + theta2))
delta4 = sympy.Abs(
sympy.sin(phi - lamb) * sympy.sin(theta) -
sympy.sin(xi) * sympy.sin(-theta1 + theta2))
return sympy.Max(delta1, delta2, delta3, delta4)
def cylinder_grasp_affordance(self, gripper, obj_input):
frame = obj_input.get_frame()
shape = obj_input.get_dimensions()
cylinder_z = frame.col(2)
cylinder_pos = pos_of(frame)
gripper_x = gripper.frame.col(0)
gripper_z = gripper.frame.col(2)
gripper_pos = pos_of(gripper.frame)
c_to_g = gripper_pos - cylinder_pos
zz_align = sp.Abs(gripper_z.dot(cylinder_z))
xz_align = gripper_x.dot(cylinder_z)
dist_z = cylinder_z.dot(c_to_g)
border_z = (shape[2] - gripper.height) * 0.5
cap_dist_normalized_signed = dist_z / border_z
cap_dist_normalized = sp.Abs(cap_dist_normalized_signed)
cap_top_grasp = 1 - sp.Max(-xz_align * sp.Min(cap_dist_normalized_signed, 1), 0)
cap_bottom_grasp = 1 - sp.Min(xz_align * sp.Max(cap_dist_normalized_signed, -1), 0)
dist_z_center_normalized = sp.Max(1 - cap_dist_normalized, 0)
dist_ax = sp.sqrt(frame.col(0).dot(c_to_g) ** 2 + frame.col(1).dot(c_to_g) ** 2)
center_grasp = (1 - dist_z_center_normalized - dist_ax) * zz_align
return sp.Max(center_grasp, cap_top_grasp, cap_bottom_grasp) * obj_input.get_class_probability()
def tick(self, tick):
curr_unk = tick.blackboard.get('curr_unk')
eq1 = curr_unk.eqntosolve.RHS
eq2 = curr_unk.secondeqn.RHS
unknowns = tick.blackboard.get('unknowns')
R = tick.blackboard.get('Robot')
A = eq1.coeff(sp.sin(curr_unk.symbol))
B = eq1.coeff(sp.cos(curr_unk.symbol))
C = A * sp.sin(curr_unk.symbol) + B * sp.cos(curr_unk.symbol) - eq1
C = C.simplify()
D = A * sp.cos(curr_unk.symbol) - B * sp.sin(curr_unk.symbol) - eq2
D = D.simplify()
if C == 0 and D == 0:
print "Simultaneous Eqn Unsuccessful: divded by 0"
return b3.FAILURE
sol = sp.atan2(A * C - B * D, A * D + B * C)
curr_unk.solutions = [sol]
# enable test for atan(0,0) case
curr_unk.argument = sp.Abs(A*C - B*D) + \
sp.Abs(A*D + B*C)
curr_unk.nsolutions = 1
curr_unk.set_solved(R, unknowns)
return b3.SUCCESS
def testSolution(theta, phi, lamb, xi, theta1, theta2, eps):
sinxi = sympy.sin(xi)
cosxi = sympy.cos(xi)
sintheta = sympy.sin(theta)
costheta = sympy.cos(theta)
#the max value of the four deltas must be less than eps
delta1 = sympy.Abs(
sympy.cos(phi + lamb) * costheta - cosxi * sympy.cos(theta1 + theta2))
if delta1.evalf() > eps:
return False
delta2 = sympy.Abs(
sympy.sin(phi + lamb) * costheta - sinxi * sympy.cos(theta1 - theta2))
if delta2.evalf() > eps:
return False
delta3 = sympy.Abs(
sympy.cos(phi - lamb) * sintheta - cosxi * sympy.sin(theta1 + theta2))
if delta3.evalf() > eps:
return False
delta4 = sympy.Abs(
sympy.sin(phi - lamb) * sintheta - sinxi * sympy.sin(-theta1 + theta2))
if delta4.evalf() > eps:
return False
return True
def norm(A_expr, axis=None, ord=2):
assert axis is None or axis == 0 or axis == 1
if axis is None:
if not A_expr.is_Matrix:
return sympy.Abs(A_expr)
assert A_expr.cols == 1 or A_expr.rows == 1
if A_expr.cols == 1 and A_expr.rows == 1:
return sympy.Abs(A_expr)
if A_expr.cols == 1:
return sympy.root(
sympy.Add(*[a_expr**ord for a_expr in A_expr[:, 0]]), ord)
if A_expr.rows == 1:
return sympy.root(
sympy.Add(*[a_expr**ord for a_expr in A_expr[0, :]]), ord)
if axis == 0:
A_norm_expr = sympy.Matrix.zeros(1, A_expr.cols)
for c in range(A_expr.cols):
A_norm_expr[0, c] = sympy.root(
sympy.Add(*[a_expr**ord for a_expr in A_expr[:, c]]), ord)
return A_norm_expr
if axis == 1:
A_norm_expr = sympy.Matrix.zeros(A_expr.rows, 1)
for r in range(A_expr.rows):
A_norm_expr[r, 0] = sympy.root(
sympy.Add(*[a_expr**ord for a_expr in A_expr[r, :]]), ord)
return A_norm_expr
assert False
return None
def rfoo(x, Ycd, Ydd):
psubs = {em.bc: x[0], em.bd: x[1]}
res = [
sp.re(sp.Abs(fYc.subs(psubs) - Ycd).evalf()),
sp.re(sp.Abs(fYd.subs(psubs) - Ydd).evalf())
]
return res
def three_point_error(p: list, func) -> list:
'''
Calculated the actual errors of the list of points and their approximated derivatives that
were computed and passed from the above function, also computes the error bound, and prints
results.
--- Required ---
list of points must have pre estimated derivatives, and a list of inputs in the current domain
to try and maximize, or passed through the above function successfully
--- Parameters ---
p : (points) a list of p [x, fx, [m1, m2, ..], e_dfx], where e_dfx is the estimated derivative,
and [m1, ...] is the list of points in the domain to try for the maximizing equation
--- Returns ---
p : (updated) list of the original p plus the error bound and actual error for each point '''
x = sp.Symbol('x')
n = len(p)
h = p[1][0] - p[0][0]
df = sp.diff(func, x)
df2 = sp.diff(df, x)
df3 = sp.diff(df2, x)
dfx = sp.lambdify(x, df)
print(f'\n[Error Calcs]:')
for i in range(n):
d = 3 if (i == 0 or i == (n - 1)) else 6
print(f' for f\'({p[i][0]}) = {p[i][2]:<1.5f}')
[xm, fxm] = find_max_save_value(df3, p[i][3])
p[i][4] = sp.Abs((h**2) / d) * fxm # store bound
p[i][5] = sp.Abs(p[i][2] - dfx(p[i][0])) # store actual
print(
f' bound : Pick x = {xm} to maximize |(h^2/3)*{df3}| = {p[i][4]:1.6f}'
)
print(
f' actual : |{p[i][1]:<1.5f} - {df}| = |{p[i][1]:<1.5f} - {dfx(p[i][0]):<1.6f}| = {p[i][5]:<1.6f}'
)
# print the final table
for i in range(n):
if i == 0:
print('\n[Final Table]:')
print(f' {"-"*54}')
print(
f'|{" x":<8}|{" f(x)":<8}| {" df(x)":<10}| { " e actual":<11}| {" e bound":<11}|'
)
print(f' {"-"*54}')
print(
f'|{p[i][0]:<8}|{p[i][1]:<8.5f}| {p[i][2]:<9.5f}| {p[i][5]:<10.6f}| {p[i][4]:<10.6f}|'
)
print(f' {"-"*54}\n')
return p
def analyze_noise_power():
for lut_line in full_lut:
print("LUT Line: {}".format(lut_line))
vi2 = 0
kT4 = 4 * k * ahkab.constants.Tref
subs['R1_0'] = lut_line[R_idx]
subs['C1_0'] = lut_line[C_idx]
subs['C2_0'] = lut_line[C_idx]
subs['G1_0'] = lut_line[gm_idx]
subs['RO_0'] = lut_line[ro_idx]
# Integrate input-referred noise power using symbolic analysis
for s in nsrcs:
if s.startswith('INR'):
in2 = kT4 / subs[s[2:]]
elif s.startswith('INE') or s.startswith('ING'):
in2 = kT4 * nonideal_dict['gamma'] * lut_line[gm_idx]
tfn = run_sym(lpf, s)
# Just get the input-referred noise density at DC and multiply by the passband to speed up calculation
vni2 = sp.lambdify(
f,
sp.Abs(((tfn['gain'] / tf['gain']).subs(
subs_syms(tfn, subs))))**2 * in2)
vi2 += quad(vni2, 1, spec.passband_corner.f())[0]
# Input referred noise of 2nd stage (assuming same R and C)
vni2_2 = sp.lambdify(
f,
sp.Abs(((tfn['gain'] / tf['gain']**2).subs(
subs_syms(tfn, subs))))**2 * in2)
vi2 += quad(vni2, 1, spec.passband_corner.f())[0]
print("\tTotal input referred noise power: {} V^2".format(vi2))
# Assume allowable swing (zero-peak) is VDD/2 - V*
dr = 10**(spec.dynamic_range / 10)
vi_min = sp.sqrt(vi2 * dr * 2)
print('\tMin reqd voltage swing for DR: {} V'.format(vi_min))
if vi_min > 0.2:
print(
'\tFails dynamic range: voltage swing of {} V not attainable!'
.format(vi_min))
else:
print('\tPasses dynamic range!')
def power(Id):
diff_factor = 2
vdd = 1.2
stages = 2
branches = 2
return diff_factor * Id * vdd * stages * branches
p = power(lut_line[Id_idx])
print("\tPower: {} W".format(p))
yield (vi2, p)
def lagrange_error_bound(fx,
p: list,
x_p: float,
n: int,
p_out: bool = True) -> float:
'''
Finds a bound for the given function over the interval used in the Lagrange polynomial
interpolation, then compares the bound to the actual error using the error formula
--- Parameters ---
fx : the function in which we are comparing the Lagrange interpolation with
p : list of known unique points
x_p : the point where the comparason takes place with fx and Px (Lagrange polynomial)
n : the degree of the Lagrange polynomial to be constructed for the error comparing
p_out : disable of enable a printout of the computed error calculations, default is true
--- Returns ---
e : the actual error computed by the Lagrange interpolation polynomial vs. the function fx '''
if (len(p) < n or len(p) < 2):
raise ValueError('Not enough known points provided.')
if (n < 1):
raise ValueError('Degree has to be at least 1.')
# actual error
estimated = lagrange_interpolation(p, x_p, n)
actual = fx(x_p)
ae = sp.Abs(actual - estimated)
if (p_out):
# maximize the left side of the error funciton
max_left = fx(x)
for i in range(n + 1):
max_left = sp.diff(max_left, x)
p = sorted(p, key=lambda point: sp.Abs(x_p - point.x))
bound = [p[0].x, p[n].x]
max_left /= sp.factorial(n + 1)
max_left_o = find_max_save_value(max_left, bound)
# maximize the right size of the error funciton
max_right = 1
for i in range(n + 1):
max_right *= (x - p[i].x)
max_right_o = find_max_save_value(max_right, [x_p])
print(
f'[Max Error]:\nme = (f^(n + 1))(xi)/(n + 1)!)*|(x - x_j)*(x - x_j+1)...|'
)
print(f' = {sp.Abs(max_left)} * |{max_right}|')
print(f' = {max_left_o[1]*max_right_o[1]:.12}\n')
print(
f'[Actual Error]:\nae = |actual - estimated|\n = |{actual} - {estimated}|\n = {ae:.12}\n'
)
return ae
def _execute_controller(self):
rate = rospy.Rate(10)
P, I = sp.var('p i')
min_linear_vel = sp.var("minLinearVel")
min_angular_vel = sp.var("minAngularVel")
distErr, distVerticalErr, vertDiff, lastLinearOut = sp.var(
'distErr distVerticalErr vertDiff lastLinearOut')
anglErr, lastAngularOut, anglDiff = sp.var(
'anglErr lastAngularOut anglDiff')
self.linear_eq = sp.Piecewise(
(sp.Max(P * distErr + I * lastLinearOut, min_linear_vel),
sp.And(sp.Abs(anglErr) < anglDiff, distErr >= 0)),
(sp.Min(P * distErr + I * lastLinearOut, -min_linear_vel),
sp.And(sp.Abs(anglErr) < anglDiff, distErr < 0)),
(0, sp.Abs(anglErr) >= anglDiff))
self.linear_vertical_eq = sp.Piecewise(
(sp.Max(P * distVerticalErr + I * lastLinearOut,
min_linear_vel), distVerticalErr > vertDiff), (0, True))
angular_eq_temp = P * anglErr + I * lastAngularOut
self.angular_eq = sp.Piecewise(
(sp.Min(angular_eq_temp, -min_angular_vel), angular_eq_temp < 0),
(sp.Max(angular_eq_temp, min_angular_vel), angular_eq_temp >= 0))
constansts = {
P: self.current_config["p"],
I: self.current_config["i"],
min_linear_vel: self.current_config["min_linear_vel"],
min_angular_vel: self.current_config["min_angular_vel"],
anglDiff: self.current_config["angular_diff"],
vertDiff: self.current_config["vertical_diff"]
}
variables = [
distErr, distVerticalErr, lastLinearOut, anglErr, lastAngularOut
]
self.linear_eq = self.linear_eq.subs(constansts)
self.linear_vertical_eq = self.linear_vertical_eq.subs(constansts)
self.angular_eq = self.angular_eq.subs(constansts)
while not rospy.is_shutdown():
if self._goal != None and self._enabled:
self._command_to(self._goal, variables)
self._reach_publisher.publish(Bool(self._reach))
rate.sleep()
def y_max(self):
y = sp.symbols("y", real=True)
yset = list(
sp.solve(
sp.Eq(
sp.Abs(self.stability_function().subs(
sp.symbols("z", complex=True), sp.I * y))**2, 1), y))
return sp.Abs(
max([sp.re(ysol) for ysol in yset if sp.Abs(sp.im(y)) < 10**-7],
key=sp.Abs))
async def protected_power(a, b):
if a == 0 and b == 0:
raise EvaluationError('Cannot raise 0 to the power of 0')
sa = float(sympy.Abs(a))
sb = float(sympy.Abs(b))
if sa < 4000 and sb < 20:
return a ** b
try:
return await calculator.crucible.run(_protected_power_crucible, (a, b), timeout=2)
except asyncio.TimeoutError:
raise EvaluationError('Operation timed out. Perhaps the values were too large?')
def ellipse_orientation(J):
"""
Return the angle between the major semi-axis and the x-axis.
This angle is sometimes called the azimuth or psi.
"""
Ex = sympy.Abs(J[0, :])
Ey = sympy.Abs(J[1, :])
delta = phase(J)
numer = 2 * Ex * Ey * sympy.cos(delta)
denom = Ex**2 - Ey**2
psi = 0.5 * sympy.arctan2(numer, denom)
return psi
def batman_equations_heaviside():
# From : http://mathworld.wolfram.com/BatmanCurve.html
x = sm.symbols('x', real=True)
h_ = sm.symbols('h_')
w = 3 * sm.sqrt(1 - (x / 7)**2)
l = ((x + 3) / 2 - sm.S(3) / 7 * sm.sqrt(10) * sm.sqrt(4 - (x + 1)**2) +
sm.S(6) / 7 * sm.sqrt(10))
r = ((3 - x) / 2 - sm.S(3) / 7 * sm.sqrt(10) * sm.sqrt(4 - (x - 1)**2) +
sm.S(6) / 7 * sm.sqrt(10))
f = ((h_ - l) * sm.Heaviside(x + 1, 0) +
(r - h_) * sm.Heaviside(x - 1, 0) + (l - w) * sm.Heaviside(x + 3, 0) +
(w - r) * sm.Heaviside(x - 3, 0) + w)
f_of = f.xreplace(
{x: sm.Abs(x + sm.S(1) / 2) + sm.Abs(x - sm.S(1) / 2) + 6})
h = sm.S(1) / 2 * (f_of - 11 * (x + sm.S(3) / 4) + sm.Abs(x - sm.S(3) / 4))
f = f.xreplace({h_: h})
g = (sm.S(1) / 2 *
(sm.Abs(x / 2) + sm.sqrt(1 - (sm.Abs(sm.Abs(x) - 2) - 1)**2) -
sm.S(1) / 112 * (3 * sm.sqrt(33) - 7) * x**2 +
3 * sm.sqrt(1 - (sm.S(1) / 7 * x)**2) - 3) *
((x + 4) / sm.Abs(x + 4) -
(x - 4) / sm.Abs(x - 4)) - 3 * sm.sqrt(1 - (x / 7)**2))
return f, g
def VOF(j: ps.field.Field, v: ps.field.Field, ρ: ps.field.Field):
"""Volume-of-fluid discretization of advection
Args:
j: the staggered field to write the fluxes to. Should have a D2Q9/D3Q27 stencil. Other stencils work too, but
incur a small error (D2Q5/D3Q7: v^2, D3Q19: v^3).
v: the flow velocity field
ρ: the quantity to advect
"""
assert ps.FieldType.is_staggered(j)
fluxes = [[] for i in range(j.index_shape[0])]
v0 = v.center_vector
for d, neighbor in enumerate(j.staggered_stencil):
c = ps.stencil.direction_string_to_offset(neighbor)
v1 = v.neighbor_vector(c)
# going out
cond = sp.And(
*[sp.Or(c[i] * v0[i] > 0, c[i] == 0) for i in range(len(v0))])
overlap1 = [1 - sp.Abs(v0[i]) for i in range(len(v0))]
overlap2 = [c[i] * v0[i] for i in range(len(v0))]
overlap = sp.Mul(*[(overlap1[i] if c[i] == 0 else overlap2[i])
for i in range(len(v0))])
fluxes[d].append(ρ.center_vector * overlap * sp.Piecewise((1, cond),
(0, True)))
# coming in
cond = sp.And(
*[sp.Or(c[i] * v1[i] < 0, c[i] == 0) for i in range(len(v1))])
overlap1 = [1 - sp.Abs(v1[i]) for i in range(len(v1))]
overlap2 = [v1[i] for i in range(len(v1))]
overlap = sp.Mul(*[(overlap1[i] if c[i] == 0 else overlap2[i])
for i in range(len(v1))])
sign = (c == 1).sum() % 2 * 2 - 1
fluxes[d].append(sign * ρ.neighbor_vector(c) * overlap * sp.Piecewise(
(1, cond), (0, True)))
for i, ff in enumerate(fluxes):
fluxes[i] = ff[0]
for f in ff[1:]:
fluxes[i] += f
assignments = []
for i, d in enumerate(j.staggered_stencil):
for lhs, rhs in zip(
j.staggered_vector_access(d).values(), fluxes[i].values()):
assignments.append(ps.Assignment(lhs, rhs))
return assignments
def eliminate(rxns, wrt):
""" Linear combination coefficients for elimination of a substance
Parameters
----------
rxns : iterable of Equilibrium instances
wrt : str (substance key)
Examples
--------
>>> e1 = Equilibrium({'Cd+2': 4, 'H2O': 4}, {'Cd4(OH)4+4': 1, 'H+': 4}, 10**-32.5)
>>> e2 = Equilibrium({'Cd(OH)2(s)': 1}, {'Cd+2': 1, 'OH-': 2}, 10**-14.4)
>>> Equilibrium.eliminate([e1, e2], 'Cd+2')
[1, 4]
>>> print(1*e1 + 4*e2)
4 Cd(OH)2(s) + 4 H2O = Cd4(OH)4+4 + 4 H+ + 8 OH-; 7.94e-91
"""
import sympy
viol = [r.net_stoich([wrt])[0] for r in rxns]
factors = defaultdict(int)
for v in viol:
for f in sympy.primefactors(v):
factors[f] = max(factors[f], sympy.Abs(v//f))
rcd = reduce(mul, (k**v for k, v in factors.items()))
viol[0] *= -1
return [rcd//v for v in viol]
def group_param_rot_spec(robo, symo, j, lam, antRj):
"""Internal function. Groups inertia parameters according to the
special rule for a rotational joint.
Notes
=====
robo is the output paramete
"""
chainj = robo.chain(j)
r1, r2, orthog = Transform.find_r12(robo, chainj, antRj, j)
kRj, all_paral = Transform.kRj(robo, antRj, r1, chainj)
Kj = robo.get_inert_param(j)
to_replace = {0, 1, 2, 4, 5, 6, 7}
if Transform.z_paral(kRj):
Kj[0] = 0 # XX
Kj[1] = 0 # XY
Kj[2] = 0 # XZ
Kj[4] = 0 # YZ
to_replace -= {0, 1, 2, 4}
joint_axis = antRj[chainj[-1]].col(2)
if all_paral and robo.G.norm() == sympy.Abs(joint_axis.dot(robo.G)):
Kj[6] = 0 # MX
Kj[7] = 0 # MY
to_replace -= {6, 7}
if j == r1 or (j == r2 and orthog):
Kj[5] += robo.IA[j] # ZZ
robo.IA[j] = 0
for i in to_replace:
Kj[i] = symo.replace(Kj[i], inert_names[i], j)
robo.put_inert_param(Kj, j)
def gauss_meth_err_estimation(a, b, knots):
x_ = sp.Symbol("x")
f = -sp.Abs(sp.diff(function(0, diff=True), sp.Symbol("x"),
2 * len(knots)))
f = sp.utilities.lambdify(x_, f)
return (-optimize.minimize_scalar(f, bounds=(a, b), method='Bounded').fun / np.math.factorial(2*len(knots))) * \
integrate.quad(estimator_func, a, b, args=(knots, 2))[0]
def run_Lagrange_interp_abs_Cheb(N, ymin=None, ymax=None):
f = sp.Abs(1 - 2 * x)
fn = sp.lambdify([x], f)
psi, points = Lagrange_polynomials(x,
N, [0, 1],
point_distribution='Chebyshev')
u = interpolation(f, psi, points)
comparison_plot(f, u, Omega=[0, 1],
filename='Lagrange_interp_abs_Cheb_%d' % (N+1),
plot_title='Interpolation by Lagrange polynomials '\
'of degree %d' % N, ymin=ymin, ymax=ymax)
print 'Interpolation points:', points
# Make figures of Lagrange polynomials (psi)
plt.figure()
xcoor = np.linspace(0, 1, 1001)
legends = []
for i in (2, (N + 1) / 2 + 1):
fn = sp.lambdify([x], psi[i])
ycoor = fn(xcoor)
plt.plot(xcoor, ycoor)
legends.append(r'$\psi_%d$' % i)
plt.hold('on')
plt.legend(legends)
plt.plot(points, [0] * len(points), 'ro')
#if ymin is not None and ymax is not None:
# axis([xcoor[0], xcoor[-1], ymin, ymax])
plt.savefig('Lagrange_basis_Cheb_%d.pdf' % (N + 1))
plt.savefig('Lagrange_basis_Cheb_%d.png' % (N + 1))
def dichotomie(a,b,R,A,Z,Q,L):
eps=R*1e-6
if b>=R:
b=R
b_9=0.9*b
fb_9=func(b_9,R,A,Z,Q,L)
fb=func(b,R,A,Z,Q,L)
while fb_9*fb>0:
b=b_9
b_9=0.9*b
fb_9=func(b_9,R,A,Z,Q,L)
fb=func(b,R,A,Z,Q,L)
a=b_9
fa=func(a,R,A,Z,Q,L)
ab_2=(a+b)/2.0
fb=func(ab_2,R,A,Z,Q,L)
if fa*fb>0:
a=ab_2
b=(a+b)/2.0
else:
b=ab_2
while sp.Abs(b-a)>eps:
fb=func(b,R,A,Z,Q,L)
ab_2=(a+b)/2
fab_2=func(ab_2,R,A,Z,Q,L)
if fab_2==0:
return ab_2
break
if fb*fab_2<0:
a=ab_2
else:
b=ab_2
return ab_2
def run_abs_by_Lagrange_interp__conv(N=[3, 6, 12, 24]):
f = sym.Abs(1 - 2 * x)
f = sym.sin(2 * sym.pi * x)
fn = sym.lambdify([x], f, modules='numpy')
resolution = 50001
xcoor = np.linspace(0, 1, resolution)
fcoor = fn(xcoor)
Einf = []
E2 = []
h = []
for _N in N:
psi, points = Lagrange_polynomials_01(x, _N)
u, c = interpolation(f, psi, points)
un = sym.lambdify([x], u, modules='numpy')
ucoor = un(xcoor)
e = fcoor - ucoor
Einf.append(e.max())
E2.append(np.sqrt(np.sum(e * e / e.size)))
h.append(1. / _N)
print(Einf)
print(E2)
print(h)
print(N)
# Assumption: error = CN**(-N)
print('convergence rates:')
for i in range(len(E2)):
C1 = E2[i] / (N[i]**(-N[i] / 2))
C2 = Einf[i] / (N[i]**(-N[i] / 2))
print((N[i], C1, C2))
def calculate_absolute_uncertainty(
self,
*assumptions: List[AppliedPredicate],
refine: bool = False,
delta_char: str = '\\Delta ') -> 'Expression':
"""Calculate the absolute uncertainty in the expression (IB way), assuming all args given are independent.
:return: the absolute uncertainty of this expression
:rtype: Expression
>>> Expression([a], c * a).calculate_absolute_uncertainty(sympy.Q.positive(c), refine=True, delta_char='Δ')
f(Δa) = c*Δa
>>> Expression([a, b, c], a + b - c).calculate_absolute_uncertainty(refine=True, delta_char='Δ')
f(Δa, Δb, Δc) = Δa + Δb + Δc
"""
uncertainty_expr = sympy.Integer(0) # just in case
uncertainty_args = []
global_assumptions.add(*assumptions)
for var in self.args:
d_var = sympy.Symbol(delta_char + sympy.latex(var))
uncertainty_args.append(d_var)
uncertainty_expr += sympy.Abs(self.expr.diff(var)) * d_var
global_assumptions.add(sympy.Q.positive(var))
if refine:
uncertainty_expr = sympy.refine(uncertainty_expr)
global_assumptions.clear()
return Expression(uncertainty_args, uncertainty_expr)
def _analytic_continuation(rho: sp.Symbol, s: sp.Symbol,
s_threshold: sp.Symbol) -> sp.Expr:
return sp.Piecewise(
(
sp.I * rho / sp.pi * sp.log(sp.Abs((1 + rho) / (1 - rho))),
s < 0,
),
(
rho + sp.I * rho / sp.pi * sp.log(sp.Abs((1 + rho) / (1 - rho))),
s > s_threshold,
),
(
2 * sp.I * rho / sp.pi * sp.atan(1 / rho),
True,
),
)
def opt_sto(self, r1, zeta, n):
r = sp.Symbol('r')
f = r ** (n - 1) * sp.exp(-zeta * sp.Abs(r))
N = sp.sqrt(1 / sp.integrate(4 * sp. pi * f * f * r * r, (r, 0, +sp.oo)))
N = N.subs(sp.pi, np.pi)
f = r1 ** (n - 1) * np.exp(-zeta * np.abs(r1))
return f * N
def lhs_eq(t, m, b, s, u, damping='linear'):
"""Return lhs of differential equation as sympy expression."""
v = sym.diff(u, t)
if damping == 'linear':
return m * sym.diff(u, t, t) + b * v + s(u)
else:
return m * sym.diff(u, t, t) + b * v * sym.Abs(v) + s(u)
def __init__(self, transformed=True):
if transformed:
self.logV = sympy.var('logV') # dropping the C_g subscript
self.Khat = sympy.var('Khat')
self.Ksigned = -self.Khat**5
self.V = sympy.exp(self.logV)
else:
self.V = sympy.var('V')
self.Ksigned = sympy.var('Ksigned')
self.K = sympy.Abs(self.Ksigned)
self.L = sympy.var('L') # dropping the asterisk superscript
self.Cg = sympy.var('Cg')
self.m0 = sympy.var('m0')
self.B0 = sympy.var('B0')
self.R_E = sympy.var('R_E')
self.c_squared = sympy.var('c^2')
# Lots of things depend on the pitch angle alpha or its sine `y`,
# which is obnoxious to compute given V/K/L. So, we compute it
# numerically and couch the rest of our equations in terms of it.
self.y = y = sympy.var('y')
# Here are various useful quantities that don't depend on the
# diffusion coefficients:
self.mu = self.V / (self.K + self.Cg)**2
self.B = self.B0 / self.L**3
self.p_squared = 2 * self.m0 * self.B * self.mu / y**2
mc2 = self.m0 * self.c_squared
self.Ekin = sympy.sqrt(self.p_squared * self.c_squared + mc2**2) - mc2
self.gamma = self.Ekin / mc2 + 1
self.beta = sympy.sqrt(1 - self.gamma**-2)
def intrinsic_func(node):
name = str(node).upper()
if name == "EXP" or name == "DEXP":
return sympy.exp
elif name == "LOG":
return sympy.log
elif name == "LOG10":
return lambda x: sympy.log(x, 10)
elif name == "SQRT":
return sympy.sqrt
elif name == "SIN":
return sympy.sin
elif name == "COS":
return sympy.cos
elif name == "ABS":
return sympy.Abs
elif name == "TAN":
return sympy.tan
elif name == "ASIN":
return sympy.asin
elif name == "ACOS":
return sympy.acos
elif name == "ATAN":
return sympy.atan
elif name == "INT":
return lambda x: sympy.sign(x) * sympy.floor(sympy.Abs(x))
elif name == "GAMLN":
return sympy.loggamma
else: # name == "PHI":
return lambda x: (1 + sympy.erf(x) / sympy.sqrt(2)) / 2
def bisection_s(q,func,iterate0,usinglines):
q = q[0]
mp.dps = 100
epsilon = mpf('0.001')
test = 12.
qp_mid = 0.
q = mpf(q)
q_plus = q + epsilon
q_minus = q - epsilon
for i in range(1000):
q_mid = (q_plus + q_minus) * mpf('0.5')
qp_plus = combine_s(q+epsilon,usinglines)
qp_minus = combine_s(q-epsilon,usinglines)
qp_mid = combine_s(mpf((q_plus + q_minus)* mpf('0.5') ),usinglines)
if func(qp_plus,iterate0)[1] * func(qp_minus,iterate0)[1] > 0:
return qp_mid
if func(qp_minus,iterate0)[1] * func(qp_mid,iterate0)[1] < 0:
q_plus = q_mid
else:
q_minus = q_mid
difference = q_plus - q_minus
if sym.Abs(difference) < 10 ** (-30):
print("break")
break
return qp_mid
def test_events():
# use bouncing ball to test events work
# simulate in block diagram
int_opts = block_diagram.DEFAULT_INTEGRATOR_OPTIONS.copy()
int_opts['rtol'] = 1E-12
int_opts['atol'] = 1E-15
int_opts['nsteps'] = 1000
int_opts['max_step'] = 2**-3
x = x1, x2 = Array(dynamicsymbols('x_1:3'))
mu, g = sp.symbols('mu g')
constants = {mu: 0.8, g: 9.81}
ic = np.r_[10, 15]
sys = SwitchedSystem(
x1, Array([0]),
state_equations=r_[x2, -g],
state_update_equation=r_[sp.Abs(x1), -mu*x2],
state=x,
constants_values=constants,
initial_condition=ic
)
bd = BlockDiagram(sys)
res = bd.simulate(5, integrator_options=int_opts)
# compute actual impact time
tvar = dynamicsymbols._t
impact_eq = (x2*tvar - g*tvar**2/2 + x1).subs(
{x1: ic[0], x2: ic[1], g: 9.81}
)
t_impact = sp.solve(impact_eq, tvar)[-1]
# make sure simulation actually changes velocity sign around impact
abs_diff_impact = np.abs(res.t - t_impact)
impact_idx = np.where(abs_diff_impact == np.min(abs_diff_impact))[0]
assert np.sign(res.x[impact_idx-1, 1]) != np.sign(res.x[impact_idx+1, 1])
