def weights_projection(net, equilibrium, rounding, z):
"""
:param net:
:param equilibrium:
:return:
"""
tol = 10 ** (-rounding)
# constraints matrix
c_mat = network_until_last_layer(net, equilibrium, rounding)[0]
c_mat = sp.Matrix(sp.nsimplify(sp.Matrix(c_mat), rational=True).T)
# compute projection matrix
if c_mat == sp.zeros(c_mat.shape[0], c_mat.shape[1]):
projection_mat = sp.eye(net.layers[-1].weight.shape[1])
else:
projection_mat = sp.eye(net.layers[-1].weight.shape[1]) \
- c_mat.T * (c_mat @ c_mat.T)**(-1) @ c_mat
# make the projection w/o gradient operations with torch.no_grad
if rounding > 0:
last_layer = np.round(net.layers[-1].weight.data.numpy(), rounding)
else:
last_layer = net.layers[-1].weight.data.numpy()
last_layer = sp.nsimplify(sp.Matrix(last_layer), rational=True, tolerance=tol)
new_last_layer = sp.Matrix(last_layer @ projection_mat)
return new_last_layer
def formula_to_string(formula):
"""
Parameters
----------
formula : dictionary or counter
Chemical formula
Returns
-------
formula_string : string
A formula string, with element order as given in the list
IUPAC_element_order.
If one or more keys in the dictionary are not one of the elements
in the periodic table, then they are added at the end of the string.
"""
formula_string = ''
for e in IUPAC_element_order:
if e in formula and np.abs(formula[e]) > 1.e-12:
if np.abs(formula[e] - 1.) < 1.e-12:
formula_string += e
else:
formula_string += e + str(nsimplify(formula[e]))
for e in formula:
if e not in IUPAC_element_order:
if e in formula and np.abs(formula[e]) > 1.e-12:
if np.abs(formula[e] - 1.) < 1.e-12:
formula_string += e
else:
formula_string += e + str(nsimplify(formula[e]))
return formula_string
def network_until_last_layer(net, x, rounding):
"""
:param net:
:param x:
:param equilibrium:
:return:
"""
z = x
jacobian = np.eye(net.input_size, net.input_size)
for idx, layer in enumerate(net.layers[:-1]):
if rounding < 0:
w = sp.Matrix(layer.weight.data.numpy())
if layer.bias is not None:
b = sp.Matrix(layer.bias.data.numpy()[:, None])
else:
b = sp.zeros(layer.out_features, 1)
elif rounding > 0:
w = sp.Matrix(np.round(layer.weight.data.numpy(), rounding))
if layer.bias is not None:
b = sp.Matrix(np.round(layer.bias.data.numpy(), rounding)[:, None])
else:
b = sp.zeros(layer.out_features, 1)
#
w = sp.Matrix(sp.nsimplify(w, rational=True))
b = sp.Matrix(sp.nsimplify(b, rational=True))
zhat = w @ z + b
z = activation_z3(net.acts[idx], zhat)
# Vdot
jacobian = w @ jacobian
jacobian = np.diagflat(activation_der_z3(net.acts[idx], zhat)) @ jacobian
return z, jacobian
def lp_clique(graph, rational=True):
V = list(graph.keys())
v_encode = {}
v_num = len(V)
for i in range(v_num):
temp = np.zeros(v_num)
temp[i] = -1
v_encode[V[i]] = temp
arr_sets = []
subsets(V, arr_sets=arr_sets)
b_clique = np.negative(np.ones(v_num))
A_clique = []
cliques = []
A_clique_set(graph, v_encode, arr_sets, A=A_clique, cliques=cliques)
A_clique = np.transpose(np.array(A_clique))
c_clique = np.ones(A_clique.shape[1])
res = linprog(c_clique, A_ub=A_clique, b_ub=b_clique, bounds=(0, None))
x_rational = list(map(lambda x: sy.nsimplify(x, tolerance=0.01), res.x))
x_cliques = {}
for i in range(len(x_rational)):
x_cliques[cliques[i]] = x_rational[i]
return sy.nsimplify(res.fun, tolerance=0.01), x_rational, x_cliques
def symbolic_hamiltonian(self):
variable_phase_symbols = []
variable_charge_symbols = []
for variable_id, variable in enumerate(self.variables):
variable.phase_symbol = sympy.Symbol(variable.name)
if variable.variable_type == 'variable':
variable.charge_symbol = sympy.Symbol('n' + variable.name)
else:
variable.charge_symbol = sympy.Symbol('U' + variable.name)
variable_phase_symbols.append(variable.phase_symbol)
variable_charge_symbols.append(variable.charge_symbol)
variable_phase_symbols = sympy.Matrix(variable_phase_symbols)
variable_charge_symbols = sympy.Matrix(variable_charge_symbols)
node_phase_symbols = self.linear_coordinate_transform * variable_phase_symbols
for node_id, node in enumerate(self.nodes):
node.phase_symbol = node_phase_symbols[node_id]
kinetic_energy = 0.5 * sympy.nsimplify(
(variable_charge_symbols.T *
self.capacitance_matrix_legendre_transform(symbolic=True) *
variable_charge_symbols)[0, 0])
potential_energy = 0
for element in self.elements:
if element.is_phase():
element_node_phases = []
element_node_voltages = []
for wire in self.wires:
if wire[0] == element.name:
for node_id, node in enumerate(self.nodes):
if wire[1] == node.name:
element_node_phases.append(
sympy.nsimplify(node.phase_symbol))
potential_energy += element.symbolic_energy_term(
element_node_phases, 0)
return kinetic_energy + potential_energy
def symbolic_hamiltonian(self):
variable_phase_symbols = []
variable_charge_symbols = []
for variable_id, variable in enumerate(self.variables):
variable.phase_symbol = sympy.Symbol(variable.name)
if variable.variable_type=='variable':
variable.charge_symbol = sympy.Symbol('n'+variable.name)
else:
variable.charge_symbol = sympy.Symbol('U'+variable.name)
variable_phase_symbols.append(variable.phase_symbol)
variable_charge_symbols.append(variable.charge_symbol)
variable_phase_symbols = sympy.Matrix(variable_phase_symbols)
variable_charge_symbols = sympy.Matrix(variable_charge_symbols)
node_phase_symbols = self.linear_coordinate_transform*variable_phase_symbols
for node_id, node in enumerate(self.nodes):
node.phase_symbol = node_phase_symbols[node_id]
kinetic_energy = 0.5*sympy.nsimplify((variable_charge_symbols.T * self.capacitance_matrix_legendre_transform(symbolic=True) * variable_charge_symbols)[0,0])
potential_energy = 0
for element in self.elements:
if element.is_phase():
element_node_phases = []
element_node_voltages = []
for wire in self.wires:
if wire[0]==element.name:
for node_id, node in enumerate(self.nodes):
if wire[1]==node.name:
element_node_phases.append(sympy.nsimplify(node.phase_symbol))
potential_energy += element.symbolic_energy_term(element_node_phases, 0)
return kinetic_energy + potential_energy
def newEq(theEquation, ans, theTerm, theVar):
"""
Content under Creative Commons Attribution license CC-BY 4.0,
code under MIT license (c)2018 Sergio Rojas ([email protected])
http://en.wikipedia.org/wiki/MIT_License
http://creativecommons.org/licenses/by/4.0/
Created on april, 2018
Last Modified on: may 15, 2018
This is a helper function to find step by step the solution
of any linear equation via operations on both
sides of the equation. In case of doubt, option 5 can be
used to check the answer. This also can also be used
to find solutions to any one variable non-linear equation.
"""
from sympy import symbols, Eq, solveset, S, sympify
from sympy import simplify, factor, expand, collect, nsimplify
LHS, RHS = theEquation.split('=')
LHS = sympify(LHS)
RHS = sympify(RHS)
if ans == 1:
term = sympify(theTerm)
RHS = nsimplify(RHS + term)
LHS = nsimplify(LHS + term)
elif ans == 2:
term = sympify(theTerm)
RHS = nsimplify(RHS - term)
LHS = nsimplify(LHS - term)
elif ans == 3:
term = sympify(theTerm)
#RHS = nsimplify( simplify(factor(RHS * term)) )
#LHS = nsimplify( simplify(factor(LHS * term)) )
RHS = nsimplify(simplify(RHS * term))
LHS = nsimplify(simplify(LHS * term))
elif ans == 4:
term = sympify(theTerm)
if term != 0:
#RHS = nsimplify( simplify(expand(RHS / term)) )
#LHS = nsimplify( simplify(expand(LHS / term)) )
RHS = nsimplify(simplify(RHS / term))
LHS = nsimplify(simplify(LHS / term))
elif ans == 5:
theVar = symbols(theVar)
RHS = nsimplify(simplify(RHS))
LHS = nsimplify(simplify(LHS))
#RHS = solveset( Eq(LHS, RHS), theVar) ).args[0]
RHS = list(solveset(Eq(LHS, RHS), theVar))
if len(RHS) == 1:
RHS = RHS[0]
LHS = theVar
else:
RHS = RHS
LHS = LHS
theneweq = '{0} = {1}'.format(LHS, RHS)
return theneweq
def sympy_equals(expr1, expr2):
"""
Test that whether two string expressions are equal using sympy, allowing
e.g. for ``sympy_equals("x * x", "x ** 2") == True``.
"""
s_expr1 = sympy.nsimplify(sympy.sympify(expr1).expand())
s_expr2 = sympy.nsimplify(sympy.sympify(expr2).expand())
return s_expr1 == s_expr2
def bug_calc_other_root():
var('GG', positive=True)
u = (209*GG**6 - 2696*GG**5 + 13872*GG**4 - 35776*GG**3 + 47104*GG**2 - 27648*GG + 4096)
h = (209*GG**3 + GG**2*(-1348 + 40*sqrt(5)) + GG*(-256*sqrt(5) + 2608) - 1312 + 416*sqrt(5))
assert 0 == expand(gcd(u,h,extension=True)*209 - h)
gg, = solve(h)
assert 0 == nsimplify(u.subs(GG, gg))
return all(0 != nsimplify(gg - _gg) for _gg in solve(u))
def inverse_symbolic(n, threshold=1e-5):
rl = mpmath.identify(n.real, tol=1e-3, maxcoeff=30)
im = mpmath.identify(n.imag, tol=1e-3, maxcoeff=30)
if not rl or abs(n.real - (nsimplify(rl).evalf())) > threshold:
rl = nsimplify(n.real).evalf(5)
if not im or abs(n.imag - (nsimplify(im).evalf())) > threshold:
im = nsimplify(n.imag).evalf(5)
return (sympify(rl) + sympify(im) * 1j)
def linear_approx(eq, point, approx_point):
subs = {x: point[0], y: point[1]}
point = (point[0], point[1], nsimplify(eq.evalf(subs=subs), [pi]))
plane = tangent_plane(eq, point)
pprint(plane)
approx_subs = {x: approx_point[0], y: approx_point[1]}
return nsimplify(plane.evalf(subs=approx_subs), [pi])
def formula_to_string(formula):
"""
Parameters
----------
formula : dictionary or counter
Chemical formula
Returns
-------
formula_string : string
A formula string, with element order based loosely
on electronegativity, following the scheme suggested by IUPAC,
except that H comes after the Group 16 elements, not before them.
If one or more keys in the dictionary are not one of the elements
in the periodic table, then they are added at the end of the string.
"""
IUPAC_element_order=['v', 'Og', 'Rn', 'Xe', 'Kr', 'Ar', 'Ne', 'He', # Group 18
'Fr', 'Cs', 'Rb', 'K', 'Na', 'Li', # Group 1 (omitting H)
'Ra', 'Ba', 'Sr', 'Ca', 'Mg', 'Be', # Group 2
'Lr', 'No', 'Md', 'Fm', 'Es', 'Cf', 'Bk', 'Cm',
'Am', 'Pu', 'Np', 'U', 'Pa', 'Th', 'Ac', # Actinides
'Lu', 'Yb', 'Tm', 'Er', 'Ho', 'Dy', 'Tb', 'Gd',
'Eu', 'Sm', 'Pm', 'Nd', 'Pr', 'Ce', 'La', # Lanthanides
'Y', 'Sc', # Group 3
'Rf', 'Hf', 'Zr', 'Ti', # Group 4
'Db', 'Ta', 'Nb', 'V', # Group 5
'Sg', 'W', 'Mo', 'Cr', # Group 6
'Bh', 'Re', 'Tc', 'Mn', # Group 7
'Hs', 'Os', 'Ru', 'Fe', # Group 8
'Mt', 'Ir', 'Rh', 'Co', # Group 9
'Ds', 'Pt', 'Pd', 'Ni', # Group 10
'Rg', 'Au', 'Ag', 'Cu', # Group 11
'Cn', 'Hg', 'Cd', 'Zn', # Group 12
'Nh', 'Tl', 'In', 'Ga', 'Al', 'B', # Group 13
'Fl', 'Pb', 'Sn', 'Ge', 'Si', 'C', # Group 14
'Mc', 'Bi', 'Sb', 'As', 'P', 'N', # Group 15
'Lv', 'Po', 'Te', 'Se', 'S', 'O', # Group 16
'H', # hydrogen
'Ts', 'At', 'I', 'Br', 'Cl', 'F']# Group 17
formula_string = ''
for e in IUPAC_element_order:
if e in formula and np.abs(formula[e])>1.e-12:
if np.abs(formula[e] - 1.) < 1.e-12:
formula_string += e
else:
formula_string += e + str(nsimplify(formula[e]))
for e in formula:
if e not in IUPAC_element_order:
if e in formula and np.abs(formula[e])>1.e-12:
if np.abs(formula[e] - 1.) < 1.e-12:
formula_string += e
else:
formula_string += e + str(nsimplify(formula[e]))
return formula_string
def __verify_C(A, B, angle_BAC, C):
O = (0, 0, 0)
OC, OB, OA = C, B, A = list(map(tuple, (C, B, A)))
R = len_OA = len_OB = distance(O, A)
L = len_AB = len_AC = distance(B, A)
len_BC = opposite_tri_edge(len_AB, angle_BAC, len_AC)
len_BC = my_sympify(len_BC)
assert nsimplify(distance(B, C) - len_BC) == 0
assert nsimplify(distance(A, C) - L) == 0
assert dot_product(cross_product(OB, OA), OC) > 0
def random_complex_number(a=2, b=-1, c=3, d=1, rational=False):
"""
Return a random complex number.
To reduce chance of hitting branch cuts or anything, we guarantee
b <= Im z <= d, a <= Re z <= c
"""
A, B = uniform(a, c), uniform(b, d)
if not rational:
return A + I * B
return nsimplify(A, rational=True) + I * nsimplify(B, rational=True)
def random_complex_number(a=2, b=-1, c=3, d=1, rational=False):
"""
Return a random complex number.
To reduce chance of hitting branch cuts or anything, we guarantee
b <= Im z <= d, a <= Re z <= c
"""
A, B = uniform(a, c), uniform(b, d)
if not rational:
return A + I * B
return nsimplify(A, rational=True) + I * nsimplify(B, rational=True)
def simplify(func):
""" Simplifies a scalar-valued or vector-valued function.
Args:
func: A symbolic functions.
"""
if type(func) == list:
for i in range(len(func)):
func[i] = sympy.simplify(sympy.nsimplify(func[i]))
else:
func = sympy.simplify(sympy.nsimplify(func))
def eta_vect(tableu, m, n, p, p_row, p_col):
etav = np.ndarray(m)
etav = etav.astype('object')
for row in range(m):
if row == p_row:
v = 1 / p
etav[row] = nsimplify(v, rational=True)
else:
a = tableu[row][p_col]
etav[row] = (a) / (-p)
etav[row] = nsimplify(etav[row], rational=True)
return etav
def __init__(self):
try:
self.expr = (sp.nsimplify(input("Enter an Expression : ")))
if self.expr.count(Equation.x) != 0:
self.interval = []
choice = input("Do you want to enter any interval ? \n " +
Fore.BLUE + " Enter ( y / n ) : ")
if choice == 'y':
self.interval.insert(
0,
sp.nsimplify(
input("Enter the lower bound of the Interval : ")))
self.interval.insert(
1,
sp.nsimplify(
input("Enter the upper bound of the Interval : ")))
if self.f_x(
self.expr,
self.interval[0]) == 'Math Error !!!' or self.f_x(
self.expr,
self.interval[1]) == 'Math Error !!!':
print("\nf(" + str(self.interval[0]) + ') = ', end='')
print(self.f_x(self.expr, self.interval[0]))
print("f(" + str(self.interval[1]) + ') = ', end='')
print(self.f_x(self.expr, self.interval[1]))
self.find_intervals()
if not self.root_exist():
self.find_intervals()
else:
self.find_intervals()
choice = input("Do you want to enter Tolerance ? \n" +
Fore.BLUE + " Enter ( y / n ) : ")
if choice == 'y':
self.Tolerance = float(
N(input("Enter the Tolerance (in decimals) : ")))
else:
self.Tolerance = 0.0001 # 10^-4
print(Fore.GREEN + "\t\tDefault Value Is Assigned to " +
str(self.Tolerance) + " Tolerance .")
choice = input("Do you want to enter no. of Decimal places ? \n " +
Fore.BLUE + " Enter ( y / n ) : ")
if choice == 'y':
Equation.dp = input("Enter the no.of decimal places : ")
else:
print(Fore.GREEN + "\t\tDefault Value Is Assigned to " +
str(Equation.dp) + " Decimal Places .")
except SympifyError:
print(Fore.RED + "\n\t\tInvalid Expression !!! ")
exit()
def get_v0v1(L, R):
assert 0 < L < 2 * R
v0 = (R, 0, 0)
len_Ov0 = len_Ov1 = R
len_v0v1 = L
angle_v0Ov1 = opposite_tri_angle(len_Ov0, len_v0v1, len_Ov1)
x = len_Ov1 * cos(angle_v0Ov1)
y = len_Ov1 * sin(angle_v0Ov1)
v1 = (x, y, 0)
assert nsimplify(vec_len(v1) - R) == 0
assert nsimplify(y) > 0
return v0, v1
def test_mod_float():
assert_equal("0.41\\mod 2", Mod(Rational('0.41'), 2))
assert_equal("143E-13\\mod 21", Mod(Rational('143E-13'), 21))
assert_equal("-9.80665\\mod 9.80665", Mod(-9.80665, 9.80665))
assert_equal("0.0000923423\\mod -8341.234802909",
nsimplify(Mod(0.0000923423, -8341.234802909)))
assert_equal("\\sqrt{5}\\mod \\sqrt{2}", Mod(sqrt(5), sqrt(2)))
assert_equal("987\\mod \\pi", Mod(987, pi))
assert_equal("\\pi\\mod ((1+\\sqrt{5})/2)",
Mod(pi, nsimplify(GoldenRatio)),
symbolically=True)
assert_equal("1234\\mod 1E-29", Mod(1234,
Rational('1E-29'),
evaluate=False))
def calc_g33334():
# solid2sorted_C_Ks:
## (3, 3, 3, 3, 4): ((1/2, sqrt(2)), (2, 1)),
solid = (3, 3, 3, 3, 4)
f = solid2zero_poly_GG(solid)
f = factor(f)
gg, = solve(f)
g33334 = sqrt(gg)
g33334 = nsimplify(g33334)
_g33334 = sqrt(-2*(42*sqrt(33) + 566)**(one/3)
- 128/(42*sqrt(33) + 566)**(one/3) + 44) / sqrt(21)
assert 0 == nsimplify(g33334 - _g33334)
assert verify_G(solid, g33334)
return g33334
def vyxalify(value: Any) -> Any:
"""Takes a value and returns it as one of the four types we use here."""
if isinstance(value, sympy.core.numbers.Integer):
return int(value)
elif is_sympy(value):
return sympy.nsimplify(value, rational=True)
elif isinstance(value, (float, complex, numpy.number)):
return sympy.nsimplify(value, rational=True)
elif isinstance(value,
(int, sympy.Rational, str, LazyList, types.FunctionType)):
return value
elif isinstance(value, list):
return list(map(vyxalify, value))
else:
return LazyList(map(vyxalify, value))
def _angle_simplify(ang):
if isinstance(ang, float):
nsimp = sympy.nsimplify(ang / np.pi)
numer, denom = nsimp.as_numer_denom()
if denom < 1e12:
return pi * numer / denom
return ang
def test_C22():
test = nsimplify(
((6 - 4 * sqrt(2)) * log(3 - 2 * sqrt(2)) +
(3 - 2 * sqrt(2)) * log(17 - 12 * sqrt(2)) + 32 - 24 * sqrt(2)) /
(48 * sqrt(2) - 72))
good = sqrt(2) / 3 - log(sqrt(2) - 1) / 3
assert test == good
def nsimplify_matrix(A_expr,constants=[],tolerance=None,full=False,rational=False):
A_nsimplified_expr = sympy.Matrix.zeros(A_expr.rows,A_expr.cols)
for r in range(A_expr.rows):
for c in range(A_expr.cols):
A_nsimplified_expr[r,c] = sympy.nsimplify(A_expr[r,c],constants,tolerance,full,rational)
return A_nsimplified_expr
def asin_pi2coeffs(f, x):
'''f = sum Ci asin(Ki/sqrt(4-x*x)) {i} + C*pi
f/-2/C + pi/2 = sum Ci/-2/C asin(Ki/(4-x*x)) {i}
return {Ki:Ci/-2/C for i}
'''
w = symbols('__W', positive=True)
f = f.subs((4-x*x), 1/w/w) # W=1/X=1/sqrt(4-gg); WW=1/(4-gg)
f = expand(sympify(f))
f0 = f
C_pi = get_coeff_of(f, pi)
f /= -2*C_pi
f += pi/2
f = expand(f)
#print(f)
A, B_ls = f.as_coeff_add()
assert A == 0
K = Wild('K')
C = Wild('C')
p = C*asin(K*w)
ls = []
for b in B_ls:
m = p.matches(b)
assert len(m) == 2
ls.append((m[K], m[C]))
_f = sum(c*asin(k*w) for k,c in ls)
assert f == _f
d = dict((nsimplify(k),c) for k,c in ls)
assert len(d) == len(ls)
return d
def calc_truncated_g(org_solid):
#org = mid_truncated_solid2org_solid[solid]
org_g = Platonic_solid2g[org_solid]
n = org_solid[0] # n-gon face of org_solid
angle = angle_of_regular_polygon(n)
# assume org_L = 2; 1 = org_L/2
org_L = 2 * one
org_L, X = symbols('org_L X', positive=True)
new_L = opposite_tri_edge(org_L, angle, org_L) * X
new_L_ = org_L * (1 - 2 * X)
x, = solve(new_L - new_L_, X)
x = my_sympify(x)
new_L = my_sympify(new_L.subs(X, x))
org_R = org_L / org_g
org_Rc = outer_radius_of_regular_polygon(n, org_L)
org_rc = inner_radius_of_regular_polygon(n, org_L)
org_HH = org_R**2 - org_Rc**2
new_rc_rc = org_rc**2 + (new_L / 2)**2
new_RR = org_HH + new_rc_rc
new_R = sqrt(new_RR)
new_g = new_L / new_R
g = my_sympify(new_g)
g = nsimplify(g)
if not g.is_number:
print(locals())
assert g.is_number
return g
def C(self, value):
self.validation.Csetter(self, value)
if value is None:
self._C = 0
else:
self._C = sp.nsimplify(value, tolerance=1e-6, rational=True)
self._C = sp.sympify(self._C)
def calcJacobian(self, oJv, pJv, pJw):
"""oJv: terna a la cual se calcula la velocidad de movimiento
pJv: terna en que se proyectan las velocidades lineales
pJw: terna en que se proyectan las velocidades rotacionales"""
J = sym.Matrix(sym.MatrixSymbol('J', 6, self.nAxis))
A = self.A
for qi in range(self.nAxis): #qi = eje de la terna i
Aojv = self.propagarTerna(qi, oJv) #del eje hasta la terna final
Apjv = self.propagarTerna(
qi, pJv) #del eje hasta la terna proyectada de velocidad
Apjw = self.propagarTerna(
qi, pJw) #del eje hasta la terna proyectada de rotacion w
p = Aojv[0:3, 3]
for i in range(3): #Itero por eje x, y, z
if self.jointType[qi] == 'r':
rv = Apjv[0:3, i]
J[i, qi] = p.cross(rv)[2]
rw = Apjw[0:3, i]
J[i + 3, qi] = rw[2]
else:
J[i, qi] = Apjw[2, i]
J[i + 3, qi] = 0
J = sym.nsimplify(J, tolerance=1E-10)
J = sym.trigsimp(J)
return J
def adjust(self, solutions, dim):
sols = []
x = sp.symbols('x1, x2,x3')
for tup in solutions:
# enleve la val de "v"
tup = tup[:len(tup) - 1]
l = []
for i in range(0, dim):
# les valeurs inconnues sont mises a 0 les autres sont recopiées
if (tup[i] != x[1] and tup[i] != x[0] and tup[i] != x[2]):
l.append(sp.nsimplify(tup[i]))
else:
l.append(0)
sols.append(tuple(l))
return sols
def Modified_M1():
# modified Magnus expansion from Iserles 2002a
# "ON THE GLOBAL ERROR OF DISCRETIZATION METHODS ... "
Use_symbolic = True
A = A_sym.subs(ts, ts0)
h = sym.Symbol("h", nonzero=True)
t_half = sym.Symbol("t_half")
A_half = A.subs(ts0, t_half)
"""
def B(t):
A_t = A.subs(ts0, t)
B = sym.exp((ts0 - t)*A_half)*(A_t - A_half)*sym.exp((t - ts0)*A_half)
return B
"""
B_ = sym.exp(-h * A_half) * (A.subs(ts0, ts1) - A_half) * sym.exp(
h * A_half)
B_ = sym.nsimplify(B_)
B_ = B_.rewrite(sym.cos)
B_ = sym.simplify(B_)
print("B = ", B_)
print()
if Use_symbolic:
Om = sym.integrate(B_, (ts1, ts0, ts))
Om_ = Om.subs({h: ts - ts0, t_half: (1 / 2) * (ts + ts0)})
print("Om = ", Om_)
print()
M_sym = sym.exp(h * A_half) * sym.exp(Om)
M_sym_ = M_sym.subs({h: ts - ts0, t_half: (1 / 2) * (ts + ts0)})
print("Modified Magnus 1 matrix = ", M_sym_)
print()
Mf = sym.lambdify((ts0, ts), M_sym_, modules=array2mat_c)
elif not Use_symbolic:
A_half_num = sym.lambdify((ts0, ts), A_half, modules=array2mat)
def B_num(t1, t0, t):
A_t = Eq["A_num"](t1)
A_h = A_half_num(t0, t)
B = linalg.expm((t0 - t) * A_h) @ (A_t - A_h) @ linalg.expm(
(t - t0) * A_h)
return B
"""
B_ = B(ts1)
B_num = sym.lambdify((ts1, ts0, ts), B_, modules=array2mat_c)
"""
MM1["name"] = MM1["name"] + " (numeric GL quad, maxiter=" + str(
quad_maxiter) + ")"
def Omega_num(t0, t):
Om = M_quad(B_num, t0, t, ARGS=(t0, t), MAXITER=quad_maxiter)
return Om
def Mf(t0, t):
M_ = linalg.expm(
(t - t0) * A_half_num(t0, t)) @ linalg.expm(Omega_num(t0, t))
return M_
return Mf
def calc_g3444_g3454(solid):
f = solid2zero_poly_GG(solid)
gg, = solve(f)
g = nsimplify(sqrt(gg))
assert verify_G(solid, g)
return g
def gradient(eq, point=None, verbose=True):
f_x = eq.diff(x)
f_y = eq.diff(y)
f_z = eq.diff(z)
if verbose:
pprint(eq)
pprint((f_x, f_y, f_z))
if point:
subs = {x: point[0], y: point[1], z: point[2]}
f_x = f_x.subs(subs)
f_y = f_y.subs(subs)
f_z = f_z.subs(subs)
return (nsimplify(f_x, [pi]), nsimplify(f_y, [pi]), nsimplify(f_z, [pi]))
def test_issue_2877():
f = Float(2.0)
assert (x + f).subs({f: 2}) == x + 2
def r(a,b,c):
return factor(a*x**2 + b*x + c)
e = r(5/6, 10, 5)
assert nsimplify(e) == 5*x**2/6 + 10*x + 5
def simplify_matrix(matrix):
"""
Replaces floats with ints and puts elements with fractions
on a single demoninator.
"""
m = matrix[:, :]
for i, e in enumerate(m):
m[i] = nsimplify(e, rational=True).cancel()
return m
def mark(self):
"""Splits up input into point location and MinMax Value"""
gradient = 0
attempt = self.parser.parse()
attemptPoints = attempt[0]
attemptMinMax = attempt[1]
function = equationMaker(self.qvariables)
diff = sympy.diff(function, x)
# Sympy can only solve for 0, so must take gradient from function
diff -= gradient
results = sympy.solve(diff, x)
# Simplify results and answer to avoid issue with fractions
for i in range(len(results)):
results[i] = sympy.nsimplify(results[i])
for i in range(len(attemptPoints)):
attemptPoints[i] = sympy.nsimplify(attemptPoints[i])
"""Differentiates a second time, works out if the point is positive, negative
or 0 and then sets the list accordingly. Minimum point is -1, Max is 1."""
diff2 = sympy.diff(diff, x)
minOrMax = []
for i in range(len(results)):
j = diff2.subs(x, results[i])
if j > 0:
minOrMax.append(-1)
elif j < 0:
minOrMax.append(1)
else:
minOrMax.append(0)
"""Redundant code for if we split marks up, if so it gives value for each part
correctly answered:
half = 1 if (set(minOrMax) == set(attemptMinMax)) else 0
half += 1 if (set(attemptPoints) == set(results)) else 0
"""
return True if (set(minOrMax) == set(attemptMinMax)) and (set(attemptPoints) == set(results)) else False
def _decimal(self, nbr, prec=None, fractions=None):
if prec is None:
prec = self.precision_calcul
if fractions is None:
fractions = self.convertir_decimaux_en_fractions
if fractions:
# On indique qu'il faudra reconvertir les résultats en décimaux.
self.reconvertir_en_decimaux = True
return nsimplify(nbr, rational=True)
return Float(nbr, prec)
def capacitance_matrix_variables(self, symbolic=False):
"""
Calculates the capacitance matrix for the energy term of the qubit Lagrangian in the variable respresentation.
"""
if symbolic:
C = self.linear_coordinate_transform.T*self.capacitance_matrix(symbolic)*self.linear_coordinate_transform
C = sympy.Matrix([sympy.nsimplify(sympy.ratsimp(x)) for x in C]).reshape(*(C.shape))
else:
C = np.einsum('ji,jk,kl->il', self.linear_coordinate_transform,self.capacitance_matrix(symbolic),self.linear_coordinate_transform)
return C
def isEquivalentExpressions(response, rubric, allowChangeOfVariable = False, allowSimplify = True, trigIdentities = False, logIdentities = False, forceAssumptions = False):
if not allowChangeOfVariable:
if isinstance(response, bool):
return (type(response) == type(rubric) and response == rubric)
elif trigIdentities:
return simplify(expand(nsimplify(response - rubric, rational=True), trig=True)) == 0
elif logIdentities and forceAssumptions:
return simplify(expand(nsimplify(response - rubric, rational=True), log=True, force=True)) == 0
elif logIdentities:
return simplify(expand(nsimplify(response - rubric, rational=True), log=True)) == 0
elif allowSimplify:
return simplify(nsimplify(response - rubric, rational=True)) == 0
else:
return response == rubric
if len(response.free_symbols) == 0:
return isEquivalent(response, rubric)
if len(response.free_symbols) > 1:
raise Exception("Don't know how to test change of variable equivalence of 2 expressions if they have more than 1 variable. Yet")
if len(response.free_symbols) != len(rubric.free_symbols):
return False
return isEquivalent(response.subs(response.free_symbols.pop(),rubric.free_symbols.pop()), rubric)
def as_expr(self): expr = 0 for i in range(len(self.coefs)): fact = 1 for j in range(len(self.vars)): fact = fact*self.vars[j]**self.exps[i][j] if self.rs is None: expr += self.coefs[i]*fact else: coef = 0 for j in range(len(self.rs)): coef += self.rs[j]*self.coefs[i][j] expr += coef*fact return spy.nsimplify(expr)
def test_action_verbs():
assert nsimplify((1/(exp(3*pi*x/5)+1))) == (1/(exp(3*pi*x/5)+1)).nsimplify()
assert ratsimp(1/x + 1/y) == (1/x + 1/y).ratsimp()
assert trigsimp(log(x), deep=True) == (log(x)).trigsimp(deep = True)
assert radsimp(1/(2+sqrt(2))) == (1/(2+sqrt(2))).radsimp()
assert powsimp(x**y*x**z*y**z, combine='all') == (x**y*x**z*y**z).powsimp(combine='all')
assert simplify(x**y*x**z*y**z) == (x**y*x**z*y**z).simplify()
assert together(1/x + 1/y) == (1/x + 1/y).together()
assert separate((x*(y*z)**3)**2) == ((x*(y*z)**3)**2).separate()
assert collect(a*x**2 + b*x**2 + a*x - b*x + c, x) == (a*x**2 + b*x**2 + a*x - b*x + c).collect(x)
assert apart(y/(y+2)/(y+1), y) == (y/(y+2)/(y+1)).apart(y)
assert combsimp(y/(x+2)/(x+1)) == (y/(x+2)/(x+1)).combsimp()
assert factor(x**2+5*x+6) == (x**2+5*x+6).factor()
assert refine(sqrt(x**2)) == sqrt(x**2).refine()
assert cancel((x**2+5*x+6)/(x+2)) == ((x**2+5*x+6)/(x+2)).cancel()
def printTransformations(infisAll, allVariables):
n = len(infisAll[0])
length1 = 8
length2 = 13
length3 = 14
transformations = [0]*len(infisAll)
types = [0]*len(infisAll)
outputs = []
for l in range(len(infisAll)):
for i in range(n):
infisAll[l][i] = spy.nsimplify(infisAll[l][i])
transformations[l], types[l] = buildTransformation(infisAll[l], allVariables)
outputs.append([])
for i in range(n):
if infisAll[l][i] != 0:
# get stuff for output line
outputs[-1].append(\
[str(allVariables[i]), str(infisAll[l][i]), str(transformations[l][i])])
# remove string extension
for v in ['Q', 'C', 'O', 'S', 'I', 'N', 'E']:
outputs[-1][-1][0] = outputs[-1][-1][0].replace(v + extension_str, v)
outputs[-1][-1][1] = outputs[-1][-1][1].replace(v + extension_str, v)
outputs[-1][-1][2] = outputs[-1][-1][2].replace(v + extension_str, v)
# search for longest string
if len(outputs[-1][-1][0]) > length1:
length1 = len(outputs[-1][-1][0])
if len(outputs[-1][-1][1]) > length2:
length2 = len(outputs[-1][-1][1])
if len(outputs[-1][-1][2]) > length3:
length3 = len(outputs[-1][-1][2])
# print all stuff
print ('{0:'+str(length1)+'s} : ').format('variable') \
+ ('{0:'+str(length2)+'s} : ').format('infinitesimal')\
+ str('transformation')
for l in range(len(infisAll)):
print '-'*(length1+length2+length3+6)
print '#' + str(l+1) + ': ' + types[l]
for lst in outputs[l]:
print ('{0:'+str(length1)+'s} : ').format(lst[0]) \
+ ('{0:'+str(length2)+'s} : ').format(str(lst[1]))\
+ str(lst[2])
def floats2rationals(expr):
u"""Convertit tous les flottants d'une expression sympy en rationnels.
Si l'expression est de type `list` ou `tuple`, la fonction est appelée
récursivement.
Sinon, si elle n'est pas de type sympy, l'expression est renvoyée telle
qu'elle.
"""
if isinstance(expr, (list, tuple)):
return expr.__class__(floats2rationals(item) for item in expr)
elif not isinstance(expr, Basic):
return expr
dico = {}
for a in expr.atoms():
if a.is_Float:
dico[a] = nsimplify(a, rational=True)
return expr.subs(dico)
def emit(name, iname, cdf, args, no_small=False):
V = []
for arg in sorted(args):
y = cdf(*arg)
if isinstance(y, mpf):
e = sp.nsimplify(y, rational=True)
if e.is_Rational and e.q <= 1000 and mp.almosteq(e, y, 1e-25):
y = e
else:
y = N(y)
V.append(arg + (y,))
for v in V:
if name:
test(name, *v)
for v in V:
if iname and (not no_small or 1/1000 <= v[-1] <= 999/1000):
test(iname, *(v[:-2] + v[:-3:-1]))
def test_power():
"""
Take units to some power.
"""
from sympy import nsimplify
pc_cgs = cm_per_pc
mK_cgs = 1e-3
u1_dims = mass * length**2 * time**-3 * temperature**4
u1 = Unit("g * pc**2 * s**-3 * mK**4")
u2 = u1**2
yield assert_true, u2.dimensions == u1_dims**2
yield assert_allclose_units, u2.base_value, (pc_cgs**2 * mK_cgs**4)**2, 1e-12
u3 = u1**(-1.0/3)
yield assert_true, u3.dimensions == nsimplify(u1_dims**(-1.0/3))
yield assert_allclose_units, u3.base_value, (pc_cgs**2 * mK_cgs**4)**(-1.0/3), 1e-12
def test_power():
"""
Take units to some power.
"""
from dimensionful.dimensions import mass, length, time, temperature
from sympy import nsimplify
pc_cgs = 3.08568e18
mK_cgs = 1e-3
u1_dims = mass * length ** 2 * time ** -3 * temperature ** 4
u1 = Unit("g * pc**2 * s**-3 * mK**4")
u2 = u1 ** 2
assert u2.dimensions == u1_dims ** 2
assert u2.cgs_value == (pc_cgs ** 2 * mK_cgs ** 4) ** 2
u3 = u1 ** (-1.0 / 3)
assert u3.dimensions == nsimplify(u1_dims ** (-1.0 / 3))
assert u3.cgs_value == (pc_cgs ** 2 * mK_cgs ** 4) ** (-1.0 / 3)
def euler_rotmat(order='xyz', frame='local', angles=None, unit='deg',
str_symbols=None, showA=True, showN=True):
"""Euler rotation matrix given sequence, frame, and angles.
This function calculates the algebraic rotation matrix (3x3) for a given
sequence ('order' argument) of up to three elemental rotations of a given
coordinate system ('frame' argument) around another coordinate system, the
Euler (or Eulerian) angles [1]_.
This function also calculates the numerical values of the rotation matrix
when numerical values for the angles are inputed for each rotation axis.
Use None as value if the rotation angle for the particular axis is unknown.
The symbols for the angles are: alpha, beta, and gamma for the first,
second, and third rotations, respectively.
The matrix product is calulated from right to left and in the specified
sequence for the Euler angles. The first letter will be the first rotation.
The function will print and return the algebraic rotation matrix and the
numerical rotation matrix if angles were inputed.
Parameters
----------
order : string, optional (default = 'xyz')
Sequence for the Euler angles, any combination of the letters
x, y, and z with 1 to 3 letters is accepted to denote the
elemental rotations. The first letter will be the first rotation.
frame : string, optional (default = 'local')
Coordinate system for which the rotations are calculated.
Valid values are 'local' or 'global'.
angles : list, array, or bool, optional (default = None)
Numeric values of the rotation angles ordered as the 'order'
parameter. Enter None for a rotation whith unknown value.
unit : str, optional (default = 'deg')
Unit of the input angles.
str_symbols : list of strings, optional (default = None)
New symbols for the angles, for instance, ['theta', 'phi', 'psi']
showA : bool, optional (default = True)
True (1) displays the Algebraic rotation matrix in rich format.
False (0) to not display.
showN : bool, optional (default = True)
True (1) displays the Numeric rotation matrix in rich format.
False (0) to not display.
Returns
-------
R : Matrix Sympy object
Rotation matrix (3x3) in algebraic format.
Rn : Numpy array or Matrix Sympy object (only if angles are inputed)
Numeric rotation matrix (if values for all angles were inputed) or
a algebraic matrix with some of the algebraic angles substituted
by the corresponding inputed numeric values.
Notes
-----
This code uses Sympy, the Python library for symbolic mathematics, to
calculate the algebraic rotation matrix and shows this matrix in latex form
possibly for using with the IPython Notebook, see [1]_.
References
----------
.. [1] http://nbviewer.ipython.org/github/duartexyz/BMC/blob/master/Transformation3D.ipynb
Examples
--------
>>> # import function
>>> from euler_rotmat import euler_rotmat
>>> # Default options: xyz sequence, local frame and show matrix
>>> R = euler_rotmat()
>>> # XYZ sequence (around global (fixed) coordinate system)
>>> R = euler_rotmat(frame='global')
>>> # Enter numeric values for all angles and show both matrices
>>> R, Rn = euler_rotmat(angles=[90, 90, 90])
>>> # show what is returned
>>> euler_rotmat(angles=[90, 90, 90])
>>> # show only the rotation matrix for the elemental rotation at x axis
>>> R = euler_rotmat(order='x')
>>> # zxz sequence and numeric value for only one angle
>>> R, Rn = euler_rotmat(order='zxz', angles=[None, 0, None])
>>> # input values in radians:
>>> import numpy as np
>>> R, Rn = euler_rotmat(order='zxz', angles=[None, np.pi, None], unit='rad')
>>> # shows only the numeric matrix
>>> R, Rn = euler_rotmat(order='zxz', angles=[90, 0, None], showA='False')
>>> # Change the angles' symbols
>>> R = euler_rotmat(order='zxz', str_symbols=['theta', 'phi', 'psi'])
>>> # Negativate the angles' symbols
>>> R = euler_rotmat(order='zxz', str_symbols=['-theta', '-phi', '-psi'])
>>> # all algebraic matrices for all possible sequences for the local frame
>>> s=['xyz','xzy','yzx','yxz','zxy','zyx','xyx','xzx','yzy','yxy','zxz','zyz']
>>> for seq in s: R = euler_rotmat(order=seq)
>>> # all algebraic matrices for all possible sequences for the global frame
>>> for seq in s: R = euler_rotmat(order=seq, frame='global')
"""
import numpy as np
import sympy as sym
try:
from IPython.core.display import Math, display
ipython = True
except:
ipython = False
angles = np.asarray(np.atleast_1d(angles), dtype=np.float64)
if ~np.isnan(angles).all():
if len(order) != angles.size:
raise ValueError("Parameters 'order' and 'angles' (when " +
"different from None) must have the same size.")
x, y, z = sym.symbols('x, y, z')
sig = [1, 1, 1]
if str_symbols is None:
a, b, g = sym.symbols('alpha, beta, gamma')
else:
s = str_symbols
if s[0][0] == '-': s[0] = s[0][1:]; sig[0] = -1
if s[1][0] == '-': s[1] = s[1][1:]; sig[1] = -1
if s[2][0] == '-': s[2] = s[2][1:]; sig[2] = -1
a, b, g = sym.symbols(s)
var = {'x': x, 'y': y, 'z': z, 0: a, 1: b, 2: g}
# Elemental rotation matrices for xyz (local)
cos, sin = sym.cos, sym.sin
Rx = sym.Matrix([[1, 0, 0], [0, cos(x), sin(x)], [0, -sin(x), cos(x)]])
Ry = sym.Matrix([[cos(y), 0, -sin(y)], [0, 1, 0], [sin(y), 0, cos(y)]])
Rz = sym.Matrix([[cos(z), sin(z), 0], [-sin(z), cos(z), 0], [0, 0, 1]])
if frame.lower() == 'global':
Rs = {'x': Rx.T, 'y': Ry.T, 'z': Rz.T}
order = order.upper()
else:
Rs = {'x': Rx, 'y': Ry, 'z': Rz}
order = order.lower()
R = Rn = sym.Matrix(sym.Identity(3))
str1 = r'\mathbf{R}_{%s}( ' %frame # last space needed for order=''
#str2 = [r'\%s'%var[0], r'\%s'%var[1], r'\%s'%var[2]]
str2 = [1, 1, 1]
for i in range(len(order)):
Ri = Rs[order[i].lower()].subs(var[order[i].lower()], sig[i] * var[i])
R = Ri * R
if sig[i] > 0:
str2[i] = '%s:%s' %(order[i], sym.latex(var[i]))
else:
str2[i] = '%s:-%s' %(order[i], sym.latex(var[i]))
str1 = str1 + str2[i] + ','
if ~np.isnan(angles).all() and ~np.isnan(angles[i]):
if unit[:3].lower() == 'deg':
angles[i] = np.deg2rad(angles[i])
Rn = Ri.subs(var[i], angles[i]) * Rn
#Rn = sym.lambdify(var[i], Ri, 'numpy')(angles[i]) * Rn
str2[i] = str2[i] + '=%.0f^o' %np.around(np.rad2deg(angles[i]), 0)
else:
Rn = Ri * Rn
Rn = sym.simplify(Rn) # for trigonometric relations
try:
# nsimplify only works if there are symbols
Rn2 = sym.latex(sym.nsimplify(Rn, tolerance=1e-8).n(chop=True, prec=4))
except:
Rn2 = sym.latex(Rn.n(chop=True, prec=4))
# there are no symbols, pass it as Numpy array
Rn = np.asarray(Rn)
if showA and ipython:
display(Math(str1[:-1] + ') =' + sym.latex(R, mat_str='matrix')))
if showN and ~np.isnan(angles).all() and ipython:
str2 = ',\;'.join(str2[:angles.size])
display(Math(r'\mathbf{R}_{%s}(%s)=%s' %(frame, str2, Rn2)))
if np.isnan(angles).all():
return R
else:
return R, Rn
def test_issue_9448():
tmp = sympify("1/(1 - (-1)**(2/3) - (-1)**(1/3)) + 1/(1 + (-1)**(2/3) + (-1)**(1/3))")
assert nsimplify(tmp) == S(1)/2
def test_nsimplify():
x = Symbol("x")
assert nsimplify(0) == 0
assert nsimplify(-1) == -1
assert nsimplify(1) == 1
assert nsimplify(1 + x) == 1 + x
assert nsimplify(2.7) == Rational(27, 10)
assert nsimplify(1 - GoldenRatio) == (1 - sqrt(5))/2
assert nsimplify((1 + sqrt(5))/4, [GoldenRatio]) == GoldenRatio/2
assert nsimplify(2/GoldenRatio, [GoldenRatio]) == 2*GoldenRatio - 2
assert nsimplify(exp(5*pi*I/3, evaluate=False)) == \
sympify('1/2 - sqrt(3)*I/2')
assert nsimplify(sin(3*pi/5, evaluate=False)) == \
sympify('sqrt(sqrt(5)/8 + 5/8)')
assert nsimplify(sqrt(atan('1', evaluate=False))*(2 + I), [pi]) == \
sqrt(pi) + sqrt(pi)/2*I
assert nsimplify(2 + exp(2*atan('1/4')*I)) == sympify('49/17 + 8*I/17')
assert nsimplify(pi, tolerance=0.01) == Rational(22, 7)
assert nsimplify(pi, tolerance=0.001) == Rational(355, 113)
assert nsimplify(0.33333, tolerance=1e-4) == Rational(1, 3)
assert nsimplify(2.0**(1/3.), tolerance=0.001) == Rational(635, 504)
assert nsimplify(2.0**(1/3.), tolerance=0.001, full=True) == \
2**Rational(1, 3)
assert nsimplify(x + .5, rational=True) == Rational(1, 2) + x
assert nsimplify(1/.3 + x, rational=True) == Rational(10, 3) + x
assert nsimplify(log(3).n(), rational=True) == \
sympify('109861228866811/100000000000000')
assert nsimplify(Float(0.272198261287950), [pi, log(2)]) == pi*log(2)/8
assert nsimplify(Float(0.272198261287950).n(3), [pi, log(2)]) == \
-pi/4 - log(2) + S(7)/4
assert nsimplify(x/7.0) == x/7
assert nsimplify(pi/1e2) == pi/100
assert nsimplify(pi/1e2, rational=False) == pi/100.0
assert nsimplify(pi/1e-7) == 10000000*pi
assert not nsimplify(
factor(-3.0*z**2*(z**2)**(-2.5) + 3*(z**2)**(-1.5))).atoms(Float)
e = x**0.0
assert e.is_Pow and nsimplify(x**0.0) == 1
assert nsimplify(3.333333, tolerance=0.1, rational=True) == Rational(10, 3)
assert nsimplify(3.333333, tolerance=0.01, rational=True) == Rational(10, 3)
assert nsimplify(3.666666, tolerance=0.1, rational=True) == Rational(11, 3)
assert nsimplify(3.666666, tolerance=0.01, rational=True) == Rational(11, 3)
assert nsimplify(33, tolerance=10, rational=True) == Rational(33)
assert nsimplify(33.33, tolerance=10, rational=True) == Rational(30)
assert nsimplify(37.76, tolerance=10, rational=True) == Rational(40)
assert nsimplify(-203.1) == -S(2031)/10
assert nsimplify(.2, tolerance=0) == S.One/5
assert nsimplify(-.2, tolerance=0) == -S.One/5
assert nsimplify(.2222, tolerance=0) == S(1111)/5000
assert nsimplify(-.2222, tolerance=0) == -S(1111)/5000
# issue 7211, PR 4112
assert nsimplify(S(2e-8)) == S(1)/50000000
# issue 7322 direct test
assert nsimplify(1e-42, rational=True) != 0
# issue 10336
inf = Float('inf')
infs = (-oo, oo, inf, -inf)
for i in infs:
ans = sign(i)*oo
assert nsimplify(i) == ans
assert nsimplify(i + x) == x + ans
assert nsimplify(0.33333333, rational=True, rational_conversion='exact') == Rational(0.33333333)
# Make sure nsimplify on expressions uses full precision
assert nsimplify(pi.evalf(100)*x, rational_conversion='exact').evalf(100) == pi.evalf(100)*x
def test_C17():
test = nsimplify((sqrt(3) + sqrt(2)) / (sqrt(3) - sqrt(2)))
good = 5 + 2*sqrt(6)
assert test == good
def test_C18():
assert nsimplify(sqrt(-2 + sqrt(-5)) * sqrt(-2 - sqrt(-5))) == 3
def test_C19():
assert radsimp(nsimplify((90 + 35*sqrt(7)) ** R(1, 3))) == 3 + sqrt(7)
def test_nsimplify():
x = Symbol("x")
assert nsimplify(0) == 0
assert nsimplify(-1) == -1
assert nsimplify(1) == 1
assert nsimplify(1+x) == 1+x
assert nsimplify(2.7) == Rational(27, 10)
assert nsimplify(1-GoldenRatio) == (1-sqrt(5))/2
assert nsimplify((1+sqrt(5))/4, [GoldenRatio]) == GoldenRatio/2
assert nsimplify(2/GoldenRatio, [GoldenRatio]) == 2*GoldenRatio - 2
assert nsimplify(exp(5*pi*I/3, evaluate=False)) == sympify('1/2 - sqrt(3)*I/2')
assert nsimplify(sin(3*pi/5, evaluate=False)) == sympify('sqrt(sqrt(5)/8 + 5/8)')
assert nsimplify(sqrt(atan('1', evaluate=False))*(2+I), [pi]) == sqrt(pi) + sqrt(pi)/2*I
assert nsimplify(2 + exp(2*atan('1/4')*I)) == sympify('49/17 + 8*I/17')
assert nsimplify(pi, tolerance=0.01) == Rational(22, 7)
assert nsimplify(pi, tolerance=0.001) == Rational(355, 113)
assert nsimplify(0.33333, tolerance=1e-4) == Rational(1, 3)
assert nsimplify(2.0**(1/3.), tolerance=0.001) == Rational(635, 504)
assert nsimplify(2.0**(1/3.), tolerance=0.001, full=True) == 2**Rational(1, 3)
assert nsimplify(x + .5, rational=True) == Rational(1, 2) + x
assert nsimplify(1/.3 + x, rational=True) == Rational(10, 3) + x
assert nsimplify(log(3).n(), rational=True) == \
sympify('109861228866811/100000000000000')
assert nsimplify(Float(0.272198261287950), [pi,log(2)]) == pi*log(2)/8
assert nsimplify(Float(0.272198261287950).n(3), [pi,log(2)]) == \
-pi/4 - log(2) + S(7)/4
assert nsimplify(x/7.0) == x/7
assert nsimplify(pi/1e2) == pi/100
assert nsimplify(pi/1e2, rational=False) == pi/100.0
assert nsimplify(pi/1e-7) == 10000000*pi
def test_nsimplify():
x = Symbol("x")
assert nsimplify(0) == 0
assert nsimplify(-1) == -1
assert nsimplify(1) == 1
assert nsimplify(1+x) == 1+x
assert nsimplify(2.7) == Rational(27, 10)
assert nsimplify(1-GoldenRatio) == (1-sqrt(5))/2
assert nsimplify((1+sqrt(5))/4, [GoldenRatio]) == GoldenRatio/2
assert nsimplify(2/GoldenRatio, [GoldenRatio]) == 2*GoldenRatio - 2
assert nsimplify(exp(5*pi*I/3, evaluate=False)) == sympify('1/2 - I*3**(1/2)/2')
assert nsimplify(sin(3*pi/5, evaluate=False)) == sympify('(5/8 + 1/8*5**(1/2))**(1/2)')
assert nsimplify(sqrt(atan('1', evaluate=False))*(2+I), [pi]) == sqrt(pi) + sqrt(pi)/2*I
assert nsimplify(2 + exp(2*atan('1/4')*I)) == sympify('49/17 + 8*I/17')
assert nsimplify(pi, tolerance=0.01) == Rational(22, 7)
assert nsimplify(pi, tolerance=0.001) == Rational(355, 113)
assert nsimplify(0.33333, tolerance=1e-4) == Rational(1, 3)
assert nsimplify(2.0**(1/3.), tolerance=0.001) == Rational(635, 504)
assert nsimplify(2.0**(1/3.), tolerance=0.001, full=True) == 2**Rational(1, 3)
assert nsimplify(x + .5, rational=True) == Rational(1, 2) + x
assert nsimplify(1/.3 + x, rational=True) == Rational(10, 3) + x
assert nsimplify(log(3).n(), rational=True) == \
sympify('109861228866811/100000000000000')
def test_C15():
test = nsimplify(sqrt(14 + 3*sqrt(3 + 2*sqrt(5 - 12*sqrt(3 - 2*sqrt(2))))))
good = sqrt(2) + 3
assert test == good
def print_latex():
#plt.clf()
#edo_main()
for i in range(1,7):Respostas[i] = nsimplify(Respostas[i], rational = True,tolerance = 0.05).evalf(prec)
# 0- Raizes; 1- Forma Natural da respsota; 2- Resposta Natural;
# 3- Resposta Particular; 4- Resposta Transitoria; 5- Respsota Forcada
# 6- Resposta Completa; 7-Sinal de entrada x(t); 8 - eq
###
eqDiferencialEntradaLatex = latex(Respostas[8])
##Perfumaria
dif = 0.9 -0.77
xdif = -0.15
font = {'family' : 'Sans',
'weight' : 'normal',
'size' : 18}
plt.rc('font', **font)
##Obtendo as respostas em Latex
RespostasEmLatex = [0]*(len(Respostas))
raizEmLatex = [0]*(len(Respostas[0]))
str_raizLatex =""
for i in range(len(Respostas[0])):
raizEmLatex[i] = '$'+str(latex(Respostas[0][i])) +'$'
for i in range(len(raizEmLatex)):
rn = "r"+str(i+1)+" = "
rn = '$'+str(latex(rn)) +'$'
str_raizLatex = str_raizLatex+"\t"+rn+raizEmLatex[i]
##print len(RespostasEmLatex)
for i in range(len(Respostas)):
RespostasEmLatex[i] = '$'+str(latex(Respostas[i])) +'$'
#print RespostasEmLatex
#xTLatex = '$' + latex(xT) +'$'
###Preparando para imprimir
log_figure = plt.figure("Representacao",facecolor='white')
ax1 = plt.axes(frameon = False)
ax1.get_xaxis().tick_bottom()
ax1.get_xaxis().set_visible(False)
ax1.axes.get_yaxis().set_visible(False)
for i in range(0,8,1):
plt.axhline(0.86-dif*i,xmin = -5,xmax = 5, color = 'black',lw =0.2, linestyle = ':')
#log_figure.figure("Forma_Representativa:")
plt.title('')
plt.text(xdif,0.89,"Eq dif: 0="+ur'$'+eqDiferencialEntradaLatex+'$'+"\tConds Iniciais: y(0)= "+str(cond_ini[0])+"\ty'(0)= "+str(cond_ini[1]))
plt.text(xdif,0.89-dif,'Forma Natural:'+ur''+RespostasEmLatex[1])
plt.text(xdif,0.9-2*dif,'yn(t) = '+ur''+RespostasEmLatex[2])
plt.text(xdif,0.9-3*dif,'ypar(t) = '+ur''+RespostasEmLatex[3])
plt.text(xdif,0.9-4*dif,'ytran(t) = '+ur''+RespostasEmLatex[4])
plt.text(xdif,0.9-5*dif,'yfor(t) = '+ur''+RespostasEmLatex[5])
plt.text(xdif,0.9-6*dif,'yc(t) = '+ur''+RespostasEmLatex[6])
plt.text(xdif,0.9-7*dif,'x(t) = '+ur''+RespostasEmLatex[7])
plt.text(xdif,0.9-8*dif,'Raiz(es): '+ur''+str_raizLatex)
plt.subplots_adjust(left=0.11, bottom=0.08, right=0.50, top=0.88,
wspace=0.22, hspace=0.21)
##log_figure.set_size_inches(19.2,10.8)
#log_figure.show()
#plt.show()
return log_figure
def test_C22():
test = nsimplify(((6 - 4*sqrt(2))*log(3 - 2*sqrt(2)) + (3 - 2*sqrt(2))*log(17
- 12*sqrt(2)) + 32 - 24*sqrt(2)) / (48*sqrt(2) - 72))
good = sqrt(2)/3 - log(sqrt(2) - 1)/3
assert test == good
def test_C21():
assert nsimplify((41 + 29*sqrt(2)) ** R(1, 5)) == 1 + sqrt(2)
def test_C20():
inside = (135 + 78*sqrt(3))
test = nsimplify((inside**R(2, 3) + 3) * sqrt(3) / inside**R(1, 3))
assert test == 12
