def slice_sample(symbol, distr, prev_x=None, domain=sm.S.Reals, __cache={}):
"""
Return a randomly chosen value of x in domain from distr.
"""
distr = distr.subs(symbol, SLICE_X)
sm.pretty_print(distr)
if prev_x == None:
prev_x = random_from_set(max_univariate_value(distr, SLICE_X, domain))
free_symbols = distr.free_symbols
if len(free_symbols) > 1:
others = []
others.extend(free_symbols)
others.remove(SLICE_X)
distr = bay.without(distr, others) #get marginal distribution
if not (distr, domain) in __cache:
__cache[distr, domain] = sm.solveset(distr >= SLICE_Y, SLICE_X, domain=domain)
at_least_set = __cache[distr, domain]
max_y = distr.subs(SLICE_X, prev_x).evalf()
y = nm.random.rand() * max_y
x_slice = at_least_set.subs(SLICE_Y, y).reduce().intersection(domain)
sm.pretty_print(x_slice)
#x_slice = sm.solveset(distr >= y, symbol, domain=domain).intersection(domain)
return random_from_set(x_slice)
def _variable_force_(fx, lower_bound, upper_bound,
variable_of_integration) -> object:
"""Work Done by Variable Force:
we need to recall the mass-density formula of a one-dimensional object,
as well as how to calculate the work done on an object by a variable force.
Linear density of the string is equal to the mass divided by the length
of the string:
- p = m/L, where m is mass and L is length of the object.
As the string is wound up, the portion of the cable that is hanging down
decreases. The mass of the cable alone can therefore be expressed as
the linear density multiplied by x, the length of the hanging portion
of the cable. Since we also know that F=ma and the acceleration is equal
to g, the force from the cable alone is equal to:
- F(x) = ρxg
The force from the weight of the crate is equal to its mass multiplied
by g. The total force is therefore:
- F(x) = pxg + pL
The mass m of a one-dimensional object oriented along the x-axis over the
interval [a,b] is given by:
- m = ∫ [a, b] ρ(x) dx,
where ρ(x) is the linear density of the object at a point x in the interval.
When linear density is constant, this simplifies to:
- m = ∫ [a, b] ρ dx.
If a variable force F(x) moves an object in a positive direction along the
x-axis from point a to point b, then the work done on the object is:
- W = ∫ [a, b] F(x) dx.
:param fx:
:param lower_bound:
:param upper_bound:
:param variable_of_integration:
:return:
"""
_l_ = lower_bound
_u_ = upper_bound
_var_ = variable_of_integration
_work_ = Integral(fx, (_var_, _l_, _u_))
_work_sol_ = _work_.doit()
print("\nWork Integral: \n")
pretty_print(_work_)
print("\nWork = \n")
pretty_print(_work_sol_)
return _work_sol_
def _circle_(radius) -> object:
"""Area = π * r^2
:param radius: The radius of the circle
"""
print("\n")
print('Radius: \n')
pretty_print(radius)
area = pi * radius ** 2
print('\nArea of circle: \n')
pretty_print(area)
return area
def _mean_value_(fx, lower_bound, upper_bound,
variable_of_integration, average_rate_change=None) -> object:
"""The Mean Value Theorem:
Let f be a function such that:
1. It is continuous on the closed interval [a, b].
2. It is differentiable on the open interval (a, b).
Then there is (at least) a number c in (a, b) such that
- f'(c) = [ f(b) - f(a) ] / [ b - a ]
Comment: Notice that the left side is the instantaneous rate of
change / slope of the tangent line at c, while the right side is
the average rate of change / slope of the secant line from a to b.
Thus the theorem guarantees that there is at least one place in (a, b)
where the tangent line there is parallel to the secant line connecting
the points (a, f (a)) and (b, f (b)) on the curve y = f (x).
:param fx:
:param lower_bound:
:param upper_bound:
:param variable_of_integration:
:param average_rate_change:
:return:
"""
a = lower_bound
b = upper_bound
_var_ = variable_of_integration
_area_ = Integral(fx, (_var_, a, b))
avg_roc = average_rate_change
if avg_roc is not None:
_mean_avg_roc_ = Fraction(1 / (b - a)).limit_denominator() * avg_roc
elif avg_roc is None:
_mean_avg_roc_ = "None"
_given_c = "None"
_mean_value_theorem_of_integral_ = Fraction(1 / (b - a)).limit_denominator() * _area_.doit()
if _mean_value_theorem_of_integral_ > 0:
c = solve(fx - _mean_value_theorem_of_integral_)
elif _mean_value_theorem_of_integral_ < 0:
c = solve(fx + _mean_value_theorem_of_integral_)
print("\nf({}) = \n".format(_var_))
pretty_print(fx)
print("\nIntegral: \n")
pretty_print(_area_)
print("\nMean value theorem for integral: \n")
pretty_print(_mean_value_theorem_of_integral_)
print("\nMean value given a rate of change: \n")
pretty_print(_mean_avg_roc_)
print("\nc from Mean value theorem for integral: \n")
pretty_print(c)
def sp_derive():
import sympy as sp
vars = 'G_s, s_n, s_p_n, w_n, dw_n, ds_n, G_s, G_w, c, phi'
syms = sp.symbols(vars)
for var, sym in zip(vars.split(','), syms):
globals()[var.strip()] = sym
s_n1 = s_n + ds_n
w_n1 = w_n + dw_n
tau_trial = G_s * (s_n1 - s_p_n)
print('diff', sp.diff(tau_trial, ds_n))
print(tau_trial)
sig_n1 = G_w * w_n1
print(sig_n1)
tau_fr = (c + sig_n1 * sp.tan(phi)) * \
sp.Heaviside(sig_n1 - c / sp.tan(phi))
print(tau_fr)
d_tau_fr = sp.diff(tau_fr, dw_n)
print(d_tau_fr)
f_trial = sp.abs(tau_trial) - tau_fr
print(f_trial)
d_gamma = f_trial / G_s
print('d_gamma')
sp.pretty_print(d_gamma)
print('d_gamma_s')
sp.pretty_print(sp.diff(d_gamma, ds_n))
print('tau_n1')
tau_n1 = sp.simplify(tau_trial - d_gamma * G_s * sp.sign(tau_trial))
sp.pretty_print(tau_n1)
print('dtau_n1_w')
dtau_n1_w = sp.diff(tau_n1, dw_n)
sp.pretty_print(dtau_n1_w)
print('dtau_n1_s')
dtau_n1_s = sp.diff(d_gamma * sp.sign(tau_trial), ds_n)
print(dtau_n1_s)
s_p_n1 = s_p_n + d_gamma * sp.sign(tau_trial)
print(s_p_n1)
def print_out_expression(self, expression_data, message):
"""
prints out the message and the pretty printed version of expression_data
also logs the message and latex of the expression_data in full_output
"""
print("")
print("")
sympy_str = self.data_to_sympy_expression(expression_data)
print(message)
pretty_print(sympy_str)
latex_str = latex(sympify(sympy_str))
self.full_output.append({"message": message, "latex": latex_str})
def sp_derive():
import sympy as sp
vars = 'G_s, s_n, s_p_n, w_n, dw_n, ds_n, G_s, G_w, c, phi'
syms = sp.symbols(vars)
for var, sym in zip(vars.split(','), syms):
globals()[var.strip()] = sym
s_n1 = s_n + ds_n
w_n1 = w_n + dw_n
tau_trial = G_s * (s_n1 - s_p_n)
print 'diff', sp.diff(tau_trial, ds_n)
print tau_trial
sig_n1 = G_w * w_n1
print sig_n1
tau_fr = (c + sig_n1 * sp.tan(phi)) * sp.Heaviside(sig_n1 - c / sp.tan(phi))
print tau_fr
d_tau_fr = sp.diff(tau_fr, dw_n)
print d_tau_fr
f_trial = sp.abs(tau_trial) - tau_fr
print f_trial
d_gamma = f_trial / G_s
print 'd_gamma'
sp.pretty_print(d_gamma)
print 'd_gamma_s'
sp.pretty_print(sp.diff(d_gamma, ds_n))
print 'tau_n1'
tau_n1 = sp.simplify(tau_trial - d_gamma * G_s * sp.sign(tau_trial))
sp.pretty_print(tau_n1)
print 'dtau_n1_w'
dtau_n1_w = sp.diff(tau_n1, dw_n)
sp.pretty_print(dtau_n1_w)
print 'dtau_n1_s'
dtau_n1_s = sp.diff(d_gamma * sp.sign(tau_trial), ds_n)
print dtau_n1_s
s_p_n1 = s_p_n + d_gamma * sp.sign(tau_trial)
print s_p_n1
def main():
# Print with the [1 t t^2 ...] M [P0 P1 P2 ...]^T notation
print compute_uniform_bspline_matrix(3)
print
print compute_uniform_bspline_matrix(4)
print
sp.pretty_print(cubic_sym_span_matrix())
print
nb_ctrlpts = 4
res = cubic_open_placement_matrix(nb_ctrlpts)
for i in xrange(nb_ctrlpts + 3):
print res[:, :, i]
print
res = cubic_closed_placement_matrix(nb_ctrlpts)
for i in xrange(nb_ctrlpts + 3):
print res[:, :, i]
def main ():
# Print with the [1 t t^2 ...] M [P0 P1 P2 ...]^T notation
print compute_uniform_bspline_matrix(3)
print
print compute_uniform_bspline_matrix(4)
print
sp.pretty_print(cubic_sym_span_matrix())
print
nb_ctrlpts = 4
res = cubic_open_placement_matrix(nb_ctrlpts)
for i in xrange(nb_ctrlpts+3):
print res[:,:,i]
print
res = cubic_closed_placement_matrix(nb_ctrlpts)
for i in xrange(nb_ctrlpts+3):
print res[:,:,i]
def equality():
g = sympy.Symbol('g(x)')
f = sympy.Symbol('f(x)')
lam_0 = sympy.Symbol('lambda_0')
alpha = sympy.Symbol('alpha')
half = sympy.Rational(1, 2)
lam = lam_0 - ((1 / alpha) * g)
lagrangian = f + -(lam * g) + -alpha * half * ((lam - lam_0)**2)
print("L(x, lambda) = ...")
sympy.pretty_print(sympy.simplify(lagrangian))
print("\n\n\n\n")
print("lambda(i + 1) = ...")
sympy.pretty_print(lam)
def print_out_equation(self, message, expression_data=None, sympy_ob=None):
"""
logs equation and prints out equation in console
can be from expression_data or a sympy equation object
"""
print("")
print("")
if expression_data:
sympy_data = self.data_to_sympy_equation(expression_data)
if sympy_ob != None:
sympy_data = sympy_ob
print(message)
pretty_print(sympy_data)
latex_str = latex(sympify(sympy_data))
self.full_output.append({"message": message, "latex": latex_str})
def runge_kutta(f, t, y, h, m=4):
'''Runge-Kutta method
Examples:
>>> ...
'''
# parameters
𝜆s = sympy.symbols(f'𝜆1:{m+1}')
𝛼s = sympy.symbols(f'𝛼2:{m+1}')
𝛽s = [sympy.symbols(f'𝛽{i+2}(1:{i+2})') for i in range(m - 1)]
# Ks
Ks = [None] * m
Ks[0] = h * f(t, y)
for i in range(m - 1):
t_ = t + 𝛼s[i] * h
y_ = y + sum(𝛽 * K for 𝛽, K in zip(𝛽s[i], Ks[:i + 1]))
result, _ = taylor_in_two_variables(f,
t_,
y_,
t,
y,
m - 1,
error=False)
Ks[i + 1] = h * result
# y_{n+1} - y_{n}
Y = f(t, y)
T = h * Y
I = sympy.integrate(f(t, y), t)
for i in range(m - 1):
Y = sympy.diff(Y.subs(y, I), t).subs(I, y)
T += h**(i + 2) / sympy.factorial(i + 2) * Y
T = T.subs(I, y)
# combine parameters
R = sum(𝜆 * K for 𝜆, K in zip(𝜆s, Ks))
T = (T - R).simplify()
x = sympy.symbols('x')
i = 1
for j in range(m - 1, -1, -1):
for k in range(j + 1):
T = T.subs(sympy.diff(f(t, y), (t, k), (y, j - k)), x**i)
coeffs = sympy.polys.poly(T, x).all_coeffs()
sympy.pretty_print(tuple(filter(bool, coeffs)))
return R
def train_run(epochs):
epochs=int(epochs)
for epoch in range(epochs):
tmodel.train()
for batch_ids,(features,targets) \
in enumerate(dataloaders['train']):
features=features.to(dev)
targets=targets.to(dev).long()
logits=tmodel(features)
cost=tnnf.cross_entropy(logits,targets)
optimizer.zero_grad(); cost.backward()
optimizer.step()
str1='epoch: %03d/%03d | batch: %03d/%03d | cost: %.4f'
if not batch_ids%10:
sp.pretty_print(str1%(epoch+1,epochs,batch_ids,
len(dataloaders['train']),cost))
tmodel.eval()
with torch.set_grad_enabled(False):
sp.pretty_print('epoch: %03d/%03d'%(epoch+1,epochs))
str2='train acc/loss: %.2f%%/%.2f valid acc/loss: %.2f%%/%.2f'
sp.pretty_print(str2%\
(model_acc(tmodel,dataloaders['train']),
epoch_loss(tmodel,dataloaders['train']),
model_acc(tmodel,dataloaders['valid']),
epoch_loss(tmodel,dataloaders['valid'])))
def main():
'''
This is a "derivation" of the simple rule
'''
a = sympy.Symbol('a')
b = sympy.Symbol('b')
c = sympy.Symbol('c')
t = sympy.Symbol('(t - t_0)')
u_list = []
eqns = []
for n in range(3):
u = sympy.Symbol('u_{}'.format(n))
tt = t - n
eqns.append((a * (tt ** 2)) + (b * tt) + c - u)
u_list.append(u)
sympy.pretty_print(eqns)
soln = sympy.solve(eqns, [a, b, c])
f = (soln[a] * (t * t)) + (soln[b] * t) + c
sympy.pretty_print(f)
df_dt = sympy.diff(f, t)
sympy.pretty_print(sympy.factor(df_dt))
def _radial_density_(px, radius, variable_of_integration) -> object:
"""
We need to recall how to calculate the mass of a circular object
from its radial density function.
Let ρ(x) be an integrable function representing the radial density
of a disk of radius r. Then the mass of the disk is given by:
- m = ∫ [0, r] 2π x ρ(x) dx.
:param px:
:param radius:
:param variable_of_integration:
:return:
"""
x, b = symbols('x, b')
_l_ = 0
_u_ = radius
_var_ = variable_of_integration
_mass_ = Integral(2 * pi * x * px, (_var_, _l_, _u_))
_demo_ = Integral(2 * pi * x * px, (_var_, _l_, b))
_mass_sol_ = _mass_.doit()
print("\nIntegral mass: \n")
pretty_print(_mass_)
print("\nMass of the object: \n")
pretty_print(_demo_.doit())
print("\nMass of the object: \n")
pretty_print(_mass_sol_)
return [_mass_, _mass_sol_]
def _linear_density_(px, lower_bound, upper_bound,
variable_of_integration) -> object:
"""
Let R denote a region bounded above by the graph of a continuous function
f(x), below by the x-axis, and on the left and right by the lines x = a
and x = b, respectively. Let ρ denote the density of the associated lamina.
Then we can make the following statements:
- i. The mass of the lamina is:
- m = ρ ∫ [a, b] f(x)dx
- ii. The moments M_x and M_y of the lamina with respect to the x-axis and y-axes,
respectively, are
- M_x = ρ ∫ [a, b] [f(x)]^2/2 dx
and
- M_y = ρ ∫ [a, b] x f(x) dx
- iii. The coordinates of the center of mass ( X̅, y̅ ) are:
- X̅ = M_y/m and y̅ = M_x/m
:param px:
:param lower_bound:
:param upper_bound:
:param variable_of_integration:
:return:
"""
_l_ = lower_bound
_u_ = upper_bound
_var_ = variable_of_integration
_mass_ = Integral(px, (_var_, _l_, _u_))
_mass_sol_ = _mass_.doit()
print("\nIntegral mass: \n")
pretty_print(_mass_)
print("\nMass of the object: \n")
pretty_print(_mass_sol_)
return [_mass_, _mass_sol_]
def _volume_disk_(fx, lower_bound, upper_bound,
variable_of_integration) -> object:
"""The Disk Method:
If a region in the plane is revolved about a line in the same
plane, the resulting object is known as a solid of revolution.
For example, a solid right circular cylinder can be generated by
revolving a rectangle. Similarly, a solid spherical ball can be
generated by revolving a semi-disk. The line about which we
rotate the shape is called the axis of revolution.
The disk method is used when we rotate a single curve y = f(x)
around the x or y axis. Suppose that y = f(x) is a continuous
non-negative function on the interval [a, b].
The volume of the solid formed by revolving the region bounded by
the curve y - f(x) and the x-axis between x = a and x = b about
the x-axis is given by:
- V = π ∫ [a,b] [ f(x) ]^2 dx
The cross section perpendicular to the axis of revolution has
the form of a disk of radius R = f(x).
Similarly, we can find the volume of the solid when the region
is bounded by the curve x = f(y) and the y-axis between y = c
and y = d, and is rotated about the y-axis. The resulting formula is:
- V = π ∫ [c, d] [ f(y)]^2 dy
:param fx: f(x) is the function on the interval
:param lower_bound:
:param upper_bound:
:param variable_of_integration:
:return:
"""
r = fx
a = lower_bound
b = upper_bound
_v_ = variable_of_integration
c, d = symbols('c, d')
_area_ = ar.circle_(r)
_integral_ = Integral(_area_, (_v_, c, d))
_integral_sol = Integral(_area_, (_v_, a, b))
_solution_ = _integral_sol.doit()
print("\nVolume of the region, Integral notation: \n")
pretty_print(_integral_sol)
print(
'\nThe antiderivative of the function with respect to {} is:\n'.format(
_v_))
pretty_print(_integral_.doit())
print('\nVolume of the region is : \n')
pretty_print(_solution_)
from sympy import Symbol from sympy.matrices import Matrix, eye, zeros, ones, diag from sympy import pretty_print from SymbolicCollisions.core.cm_symbols import * from SymbolicCollisions.core.MatrixGenerator import MatrixGenerator from SymbolicCollisions.core.printers import * matrixGenerator = MatrixGenerator(ex_D2Q9, ey_D2Q9, None, moments_dict[f'D2Q9']) Mraw = matrixGenerator.get_raw_moments_matrix() Nraw = matrixGenerator.get_shift_matrix() Traw = matrixGenerator.get_raw_x_shift_moments_matrix() Nraw_alternative = Traw * Mraw.inv() Nraw_alternative_simplified = Matrix([round_and_simplify(Nraw_alternative[i, :]) for i in range(len(ex_D2Q9))]) # print_as_vector(f1, 'f1') pretty_print(Mraw) pretty_print(Nraw) pretty_print(Nraw_alternative)
from sympy import symbols, solve, Eq, pretty_print
from sympy.physics.units import Quantity, mass, acceleration, power, velocity
from sympy.physics.units import convert_to
from sympy.physics.units import kilo
from sympy.physics.units import km, hour, m, s, kg, W
from sympy.physics.units.systems import SI
a = symbols("a")
m_ = Quantity("m")
v = Quantity("v")
W_ = Quantity("W")
SI.set_quantity_dimension(a, acceleration)
SI.set_quantity_dimension(m_, mass)
SI.set_quantity_scale_factor(m_, 1000*kg)
SI.set_quantity_dimension(v, velocity)
SI.set_quantity_scale_factor(v, 60*km/hour)
SI.set_quantity_dimension(W_, power)
SI.set_quantity_scale_factor(W_, 120*kilo*W)
eq = Eq(W_, m_*a*v)
result = solve(eq, a)[0]
pretty_print(result)
pretty_print(convert_to(result, m / s ** 2).n())
from sympy import symbols
init_printing()
# let ve - orbital speed of Earth
# v0 - initial spaceship speed
# v - spaceship speed on 'exit' from Solar system
# Ms, Me - mass of the Sun and Earth resp
# R, r - Earth orbit radius and Earth radius
ve, v, v0 = symbols('v_e v v_0')
G, Ms, Me = symbols('G M_s M_e')
R, r = symbols('R, r')
# For the Earth itself
eq_E = Eq(ve**2 / 2 - G * Ms / R, -G * Ms / R / 2)
pretty_print(eq_E)
# For the ship near the Earth and on "exit"
eq_ship = Eq(v0**2 / 2 - G * Ms / R - G * Me / r, v**2 / 2)
pretty_print(eq_ship)
res = solve([eq_E, eq_ship], v**2, G * Ms / R)
pretty_print(res)
# but for 1st space speed of 11 km/s we have
v1 = symbols('v1')
eq_v1 = Eq(v1**2 / 2 - G * Me / r, -G * Me / r / 2)
pretty_print(eq_v1)
# but for 2dn space speed
from SymbolicCollisions.core.cm_symbols import *
from SymbolicCollisions.core.printers import print_as_vector, get_print_symbols_in_indx_notation
from sympy import pretty_print
print("\n\n=== from raw moments to ortho moments ===\n")
T_raw_to_ortho = M_ortho_GS * Mraw_D2Q9.inv()
# pretty_print(T_raw_to_ortho)
print("\n\n=== relax raw moments in ortho space ===\n")
S_relax2 = T_raw_to_ortho.inv() * S_relax_MRT_GS * T_raw_to_ortho
pretty_print(S_relax2)
print("\n\n deja-vu! \n")
pretty_print(S_relax_hydro_D2Q9)
print("\n\n=== PRETTY CODE: relax relax_MRT_relax_raw_mom_into_ortho ===\n\n")
DF_in_str = 'f_in' # symbol defining DF
mom_DF_str = 'm'
mom_relaxed_DF_str = 'm_relaxed'
print("CudaDeviceFunction void relax_MRT_relax_raw_mom_into_ortho("
"real_t %s[9], "
"real_t tau, "
"\n{" % DF_in_str)
print("\nreal_t %s = 1./tau;" % omega_v)
print("\nreal_t %s[9]; real_t %s[9]; \n" % (mom_DF_str, mom_relaxed_DF_str))
populations = get_print_symbols_in_indx_notation(print_symbol=DF_in_str)
m_DF = get_print_symbols_in_indx_notation(print_symbol=mom_DF_str)
from sympy import pretty_print, Eq, solve, symbols
from sympy.interactive import init_printing
init_printing()
g = 9.8
P = 0.025 * g
k = 15.3
m = 0.050
h = 0.09
delta_x = symbols('delta_x')
eq = Eq(m**2 / (P + m * g) * g * h, -m * delta_x + k / (2 * g) * delta_x**2)
pretty_print(eq)
solution = solve(eq, delta_x)
pretty_print(solution)
delta_x = solution[1]
result = h + delta_x
print("result is {0:.1f} cm".format(result * 100))
from sympy import Symbol
from sympy.matrices import Matrix, eye, zeros, ones, diag
from sympy import pretty_print
from SymbolicCollisions.core.DiscreteCMTransforms import get_DF
from SymbolicCollisions.core.cm_symbols import Shift_ortho_Straka_d2q5
"""
See
'New Cascaded Thermal Lattice Boltzmann Method for simulations for advection-diffusion and convective heat transfer'
by K.V. Sharma, R. Straka, F.W. Tavares, 2017
"""
# Smat = get_shift_matrix(K_ortho_Straka_d2q5, ex_Straka_d2_q5, ey_Straka_d2_q5)
# pretty_print(Smat)
Smat = Shift_ortho_Straka_d2q5
k = get_DF(q=4, print_symbol='k')
Relax = diag(Symbol('w2'), Symbol('w3'), Symbol('w4'), Symbol('w5')) #
cm_neq = get_DF(q=4, print_symbol='cm_neq')
k = Smat.inv()*Relax*cm_neq
pretty_print(k)
from SymbolicCollisions.core.cm_symbols import *
from SymbolicCollisions.core.DiscreteCMTransforms import get_DF
from SymbolicCollisions.core.printers import print_as_vector
from sympy import pretty_print
print("\n\n=== from raw moments to ortho moments ===\n")
T_raw_to_ortho = M_ortho_GS * Mraw_D2Q9.inv()
# pretty_print(T_raw_to_ortho)
print("\n\n=== relax raw moments in ortho space ===\n")
S_relax2 = T_raw_to_ortho.inv() * S_relax_MRT_GS*T_raw_to_ortho
pretty_print(S_relax2)
print("\n\n deja-vu! \n")
pretty_print(S_relax_hydro_D2Q9)
print("\n\n=== PRETTY CODE: relax relax_MRT_relax_raw_mom_into_ortho ===\n\n")
DF_in_str = 'f_in' # symbol defining DF
mom_DF_str = 'm'
mom_relaxed_DF_str = 'm_relaxed'
print("CudaDeviceFunction void relax_MRT_relax_raw_mom_into_ortho("
"real_t %s[9], "
"real_t tau, "
"\n{"
% DF_in_str)
from sympy.interactive import init_printing
from sympy.physics.units import Quantity
from sympy.physics.units import convert_to
from utils import *
init_printing()
E = Quantity("E")
c = Quantity("c")
set_quantity(E, un.energy, 2.15e12 * un.kilo * un.watts * un.hour)
set_quantity(c, un.speed, 3.00e8 * un.m / un.s)
E = convert_to(E, un.joule).n()
print('Heavy water:')
pretty_print(Eq(symbols('D2O'), 2 * symbols('D') + symbols('O')))
print('Let nucleosynthesis reaction be like below:')
pretty_print(Eq(symbols('D'), symbols('H_^2')))
pretty_print(Eq(symbols('H^2') + symbols('H^2'), symbols('He_^4')))
print('a).')
m = symbols('m')
pretty_print(Eq(m, symbols('E') / c**2))
m = E / c**2
m = convert_to(m, un.kg).n()
pretty_print("Energy to mass : {}".format(m))
print('b).')
M_D = Quantity('M_D')
import sympy as sp
import matplotlib.pyplot as plt
from matplotlib import rcParams, animation
rcParams['font.family'] = 'serif'
rcParams['font.size'] = 16
plt.ion()
from sympy import init_session
init_session()
from sympy.utilities.lambdify import lambdify
x, nu, t = sp.symbols('x nu t')
phi = sp.exp((-(x-4*t)**2)/(4*nu*(t+1))) + \
sp.exp(-((x-4*t-2*np.pi)**2)/(4*nu*(t+1)))
phi
sp.pretty_print (phi)
phiprime = phi.diff(x)
phiprime
sp.pretty_print (phiprime)
u = -2*nu*(phiprime/phi)+4
print(u)
ufunc = lambdify((t,x,nu),u)
print('The value of u at t=1, x=4, nu=3 is {}.'.format(ufunc(1,4,3)))
#Variable Declarations
nx = 101
nt = 100
dx = 2*np.pi/(nx-1)
res_v = solve([
Eq(s1,
v * sqrt(2) * t),
Eq(v * sqrt(2), 2 * g * t),
Eq(delta_h, g * t**2 / 2),
Eq((v * sqrt(2) / 2)**2, 2 * g * delta_h)
], v, t, delta_h)[1]
A = A.subs({"v": res_v[0]})
res_s2 = solve([
Eq(s2,
v * sqrt(2) / 2 * t),
Eq(h,
v * sqrt(2) / 2 * t + g * t**2 / 2),
Eq(s, s1 + s2),
Eq(v**2, res_v[0]**2)
], s2, s1, t, v)
s1 = res_s2[1][1]
A = A.subs({"s1": s1})
pretty_print(A)
n = 3
distances = [19.4, 60.0, 86.1]
masses = [7.26, 2.00, 0.81]
for i in range(n):
print(A.subs({g: 9.81, m: masses[i], s: distances[i], h: 1.8}))
f2 = Mraw_D2Q9.inv() * Nraw.inv() * cm
print_as_vector(f2, 'f2')
from numpy.testing import assert_almost_equal
for i in range(0):
assert_almost_equal(f1[i], f2[i])
print("\n\n=== from raw moments to ortho moments ===\n")
T_raw_to_ortho = M_ortho_GS * Mraw_D2Q9.inv()
S_relax = S_relax_MRT_GS.subs({
's_v': 0.0321,
})
X1 = Nraw * T_raw_to_ortho * Mraw_D2Q9
X2 = T_raw_to_ortho * Nraw * Mraw_D2Q9
pretty_print(X1*cm)
pretty_print(X2*cm)
XX1 = Mraw_D2Q9.inv() * T_raw_to_ortho.inv() * Nraw.inv() * S_relax * Nraw * T_raw_to_ortho * Mraw_D2Q9
XX2 = Mraw_D2Q9.inv() * Nraw.inv() * T_raw_to_ortho.inv() * S_relax * T_raw_to_ortho * Nraw * Mraw_D2Q9
a1 = Nraw * Mraw_D2Q9 * cm
a2 = ShiftMat*M_ortho_GS.inv()*cm
from SymbolicCollisions.core.DiscreteCMTransforms import get_DF
from SymbolicCollisions.core.cm_symbols import *
from sympy.matrices import Matrix
from sympy import pretty_print, exp
from SymbolicCollisions.core.cm_symbols import ex_D2Q9, ey_D2Q9
from SymbolicCollisions.core.printers import print_as_vector
import numpy as np
from sympy.utilities.iterables import flatten
DF = get_DF('g')
# pretty_print(M_ortho_GS*DF)
print("\n\n=== is orthogonal and orthonormal? ===\n")
pretty_print(M_ortho_GS*M_ortho_GS.transpose()) # TODO: why not M_ortho_GS.transpose()* M_ortho_GS ?!
pretty_print(K_ortho_Geier.transpose()*K_ortho_Geier)
print("\n\n=== from raw moments to ortho moments ===\n")
T_raw_to_ortho = M_ortho_GS * Mraw_D2Q9.inv()
pretty_print(T_raw_to_ortho)
print("\n\n=== relax raw moments in ortho space and go back to raw moments ===\n")
S_relax_ortho = T_raw_to_ortho.inv() * S_relax_MRT_GS * T_raw_to_ortho
pretty_print(S_relax_ortho)
# print("\n\n=== normalize matrix ===\n")
# from sklearn.preprocessing import normalize
f2 = -x**7 + 2*x**3*y + y**3
f3 = (y**2-x**2)*(x-1)*(2*x-3) - 4*(x**2+y**2-2*x)**2
f4 = y**2 + x**3 - x**2
f5 = (x**2 + y**2)**3 + 3*x**2*y - y**3
f6 = y**4 - y**2*x + x**2
f7 = y**3 - (x**3 + y)**2 + 1
f8 = (x**6)*y**3 + 2*x**3*y - 1
f9 = 2*x**7*y + 2*x**7 + y**3 + 3*y**2 + 3*y
f10= (x**3)*y**4 + 4*x**2*y**2 + 2*x**3*y - 1
f = f2
a = 0
N = 10
print "Curve:\n"
sympy.pretty_print(f)
PT = puiseux(f,x,y,a,degree_bound=N,parametric=T,version='rational')
Px = puiseux(f,x,y,a,degree_bound=N,parametric=False,version='rational')
sympy.pprint(PT)
sympy.pprint(Px)
# import cProfile, pstats
# cProfile.run(
# "P = puiseux(f,x,y,a,degree_bound=N,parametric=False,version='rational')"
# ,'puiseux.profile')
# p = pstats.Stats('puiseux.profile')
# p.strip_dirs()
# p.sort_stats('time').print_stats(15)
# p.sort_stats('cumulative').print_stats(15)
def to_sparse(matrix):
entries = {}
for row in range(matrix.rows):
for col in range(matrix.cols):
val = matrix[row, col]
# Exactly uniquely zero! Not almost zero! No bullshit!
if val != 0:
entries[(row, col)] = val
return sparse.SparseMatrix(matrix.shape, entries)
if __name__ == '__main__':
a = vector('a', 5)
b = vector('b', 5)
sympy.pretty_print(a)
A = matrix('A', (5, 5))
sympy.pretty_print(A)
sympy.pretty_print(norm(a - b))
sA = to_sparse(A)
sb = to_sparse(b)
sparse.diagstack(sA, sA, sA, sA, sb).spy()
# from matplotlib import pyplot as plt
# plt.show()
def print_taylor(my_function, x0=0, n=5, by=1, what_to_diff=sy.Symbol('x')):
# Approximate up until n starting from 1 and using steps of by
for j in range(1, n + 1, by):
func = taylor(my_function, x0, j, what_to_diff)
print('\n\nTaylor expansion at n=%s' % str(j))
pretty_print(func)
img_files=['00_05_001.png','00_06_001.png']
img_size=64; data_img_size=160
batch_size2=8; img_size2=64
max_img_size=224; steps=60
""" ## ✒️ Data Loading and Preprocessing"""
def get_file(file_path,file_name):
input_file=urllib.request.urlopen(file_path+file_name)
output_file=open(file_name,'wb')
output_file.write(input_file.read())
output_file.close(); input_file.close()
get_file(file_path,file_name)
with h5py.File(file_name,'r') as f:
keys=list(f.keys())
sp.pretty_print('file keys: '+', '.join(keys))
images=np.array(f[keys[0]])
images=tf.image.resize(
images,[data_img_size,data_img_size]).numpy()
labels=np.array(f[keys[1]],dtype='float32')
names=[el.decode('utf-8') for el in f[keys[2]]]
f.close()
N=labels.shape[0]; n=int(.1*N); num_classes=len(names)
shuffle_ids=np.arange(N)
np.random.RandomState(12).shuffle(shuffle_ids)
images=images[shuffle_ids]; labels=labels[shuffle_ids]
x_test,x_valid,x_train=images[:n],images[n:2*n],images[2*n:]
y_test,y_valid,y_train=labels[:n],labels[n:2*n],labels[2*n:]
df=pd.DataFrame(
[[x_train.shape,x_valid.shape,x_test.shape],
from sympy import symbols, log, sqrt, pretty_print
S, E, r, σ, T, t = symbols('S, E, r, σ, T, t')
numerator_l = log(S / E) + r * (T - t)
numerator_r = σ**2 * (T - t) / 2
denominator = σ * sqrt(T - t)
d1 = (numerator_l + numerator_r) / denominator
d2 = (numerator_l - numerator_r) / denominator
# Process:
__Δ = d1 - d2
# = 2*numerator_r / denominator
# = σ**2*(T-t) / σ*sqrt(T-t)
# = σ * sqrt(T-t)
# = _______
# σ⋅╲╱ T - t
if __name__ == "__main__":
pretty_print(__Δ.simplify())
m[1].append(n * 2 * (x * y + w * z)) m[1].append(1 - n * 2 * (x**2 + z**2)) m[1].append(n * 2 * (y * z - w * x)) m[1].append(0) m.append([]) m[2].append(n * 2 * (x * z - w * y)) m[2].append(n * 2 * (y * z + w * x)) m[2].append(1 - n * 2 * (x**2 + y**2)) m[2].append(0) m.append([]) m[3] = [0, 0, 0, 1] A = sym.Matrix(m) sym.pretty_print(A) vec = sym.Matrix([0, 0, 1, 0]) # col vec #sym.pretty_print(vec) expr = A * vec s = expr.subs([(w, 0.854), (x, -0.546), (y, 0.354), (z, 0.354)]) sp = expr.subs([(w, 0.854), (x, -0.55), (y, 0.354), (z, 0.354)]) dx = -0.55 - (-0.546) ds = sp - s sym.pretty_print(s) sym.pretty_print(sp) sym.pretty_print(ds) point = sym.Matrix([a, b, c, 0])
from sympy import Symbol
from sympy.matrices import Matrix, eye, zeros, ones, diag
from sympy import pretty_print
from SymbolicCollisions.core.cm_symbols import Shift_ortho_Straka_d2q5
from SymbolicCollisions.core.printers import get_print_symbols_in_indx_notation
"""
See
'New Cascaded Thermal Lattice Boltzmann Method for simulations for advection-diffusion and convective heat transfer'
by K.V. Sharma, R. Straka, F.W. Tavares, 2017
"""
# Smat = get_shift_matrix(K_ortho_Straka_d2q5, ex_Straka_d2_q5, ey_Straka_d2_q5)
# pretty_print(Smat)
Smat = Shift_ortho_Straka_d2q5
k = get_print_symbols_in_indx_notation(q=4, print_symbol='k')
Relax = diag(Symbol('w2'), Symbol('w3'), Symbol('w4'), Symbol('w5')) #
cm_neq = get_print_symbols_in_indx_notation(q=4, print_symbol='cm_neq')
k = Smat.inv()*Relax*cm_neq
pretty_print(k)
Hx2 = 4*x*s.sqrt(omega)*x*s.sqrt(omega) - 2
Hx3 = 8*x*s.sqrt(omega)*x*s.sqrt(omega)*x*s.sqrt(omega) - 12*x*s.sqrt(omega)
Hy0 = 1
Hy1 = 2*y*s.sqrt(omega)
Hy2 = 4*y*s.sqrt(omega)*y*s.sqrt(omega) - 2
Hy3 = 8*y*s.sqrt(omega)*y*s.sqrt(omega)*y*s.sqrt(omega) - 12*y*s.sqrt(omega)
phi = exp(-omega*(x*x+y*y)/2)
phi0 = phi*Hx0*Hy0
phi1 = phi*Hx1*Hy1
phi2 = phi*Hx2*Hy2
phi3 = phi*Hx3*Hy3
print("Grad H0")
s.pretty_print(((s.diff(phi0,x)/phi)).simplify().simplify())
print("\nGrad H1")
s.pretty_print(((s.diff(phi1,x)/phi)).simplify().simplify())
print("\nGrad H2")
s.pretty_print(((s.diff(phi2,x)/phi)).simplify().simplify())
print("\nGrad H2")
s.pretty_print(((s.diff(phi3,x)/phi)).simplify().simplify())
print("-----------------------------------------------------------------------")
print("Lap H0")
s.pretty_print(((s.diff(s.diff(phi0,x),x)/phi)+s.diff(s.diff(phi0,y),y)/phi).simplify().simplify())
print("\nLap H1")
s.pretty_print(((s.diff(s.diff(phi1,x),x)/phi)+s.diff(s.diff(phi1,y),y)/phi).simplify().simplify())
print("\nLap H2")
s.pretty_print(((s.diff(s.diff(phi2,x),x)/phi)+s.diff(s.diff(phi2,y),y)/phi).simplify().simplify())
print("\nLap H3")
s.pretty_print(((s.diff(s.diff(phi3,x),x)/phi)+s.diff(s.diff(phi3,y),y)/phi).simplify().simplify())
r'- T_{i}_b(tau)) + {dTbi_TopDown} * {sumA_k}) + G_c * c_v * ({A_c} * '
r'(T_2_c - T_{i}_b(tau)) + {Tbi_DownTop} * {sumA_c}) + 3.6 * '
r'K_{i}_b * F_{i}_b * (T_n - T_{i}_b(tau))')
T_tau_template = r'T_{i}_b(tau)'
eqs = []
#T_tau_list = []
tau = smp.Symbol('tau')
for i in range(1, n+1):
eq_left = smp.S(eq_left_template.format(i=i, A_k=A_k(i), dTbi_TopDown=dTbi_TopDown(i),
sumA_k=sumA_k(i), A_c=A_c(i),
Tbi_DownTop=Tbi_DownTop(i), sumA_c=sumA_c(i)) )
eq_right = smp.S(eq_right_template.format(i=i))
eq = smp.Eq(eq_left, eq_right.diff(tau))
##T_tau = smp.Function(T_tau_template.format(i=i))
#T_tau_list.append(T_tau)
smp.pretty_print(eq)
eqs.append(eq)
if n == 99:
rhs = []
for req in smp.dsolve(eqs):
print(req)
rhs.append(smp.Eq(req.rhs.subs(tau, 0), 15))
print(" Розв'язок задачі Коші: ".center(50, '-'))
C1, C2, C3 = smp.symbol('C1 C2 C3')
print(smp.solve(rhs), [C1, C2, C3])
#smp.pretty_print()
print("Розв'язок символьним (аналітичним) методом завершено!")
raise SystemExit(0)
import sympy as sp
import numpy as np
M = sp.Matrix(sp.var('m0 m1 m2 m3 m4 m5 m6 m7 m8')).reshape(3, 3)
r = sp.Matrix(sp.var('x y z'))
t = sp.Matrix(sp.var('t0 t1 t2'))
eq = M * r - t
sp.pretty_print(eq)
solution = [sp.solve(surface, z) for surface in eq]
vm = np.array(((1.0, 0.1, -0.1), (0.1, 1.0, -0.1), (-0.1, -0.1, 1.0))).reshape(9)
vt = (np.random.random(3) - 0.5) * 0.1
p = sp.Plot()
p[1] = solution[0][0].subs(zip(M[:], vm)).subs(zip(t[:], vt))
p[2] = solution[1][0].subs(zip(M[:], vm)).subs(zip(t[:], vt))
p[3] = solution[2][0].subs(zip(M[:], vm)).subs(zip(t[:], vt))
from sympy import Eq, Function
from sympy import init_printing, pretty_print
from sympy import solve, simplify
from sympy import symbols
init_printing()
x, rho, pi, r, R, G = symbols('x rho pi r R G')
M = Function('M')(r)
a_0 = Function('a_0')(x)
a_1 = Function('a_1')(x)
a_2 = Function('a_2')(x)
eq_M = Eq(M, 4 * rho * pi * r**3 / 3)
pretty_print(eq_M)
M0 = eq_M.args[1].subs(r, R)
M2 = eq_M.args[1].subs(r, R / 4)
M1 = M0 - M2
eq_a_0 = Eq(a_0, a_1 + a_2)
pretty_print(eq_a_0)
eq_a_0 = eq_a_0.subs({
a_0: G * M0 / (x + R)**2,
a_2: G * M2 / (x + R + R / 4)**2
})
pretty_print(eq_a_0)
from sympy.functions import exp
import sympy as s
alpha,beta,a,x1,x2,y1,y2,r12,r1,r2 = s.symbols('alpha beta a x1 x2 y1 y2 r12 r1 r2')
#r12 = s.sqrt((x1-x2)**2)
#r1 = x1**2
#r2 = x2**2
r12 = s.sqrt((x1-x2)**2 + (y1-y2)**2)
r1 = x1**2 + y1**2
r2 = x2**2 + y2**2
sep = x1 -x2
obr12 = 1+beta*r12
Exp1 = exp(-alpha*(r1+r2)/2)
Exp2 = exp(a*r12/(1+r12*beta))
s.pretty_print(s.diff(Exp1,x1))
print("\n\n\n")
s.pretty_print(s.diff(Exp2,x1))
#s.pretty_print(1/r12)
#print("\n")
#s.pretty_print(sep/obr12**2*s.diff(1/r12,x1))
#print("\n")
#s.pretty_print(1/obr12**2)
#print("\n")
#s.pretty_print(sep/r12*s.diff(1/obr12**2,x1))
else:
import hotshot
prof = hotshot.Profile("profile.valgrind")
prof.runcall(main)
prof.close()
import sympy
t=sympy.Symbol("t")
mu=sympy.Symbol("mu")
sigma=sympy.Symbol("s")
normal=1./(sigma*sympy.sqrt(2*sympy.pi))*sympy.exp(-(t/2/sigma)**2)
print "normal", normal
sympy.pretty_print(normal)
print sympy.printing.latex(normal)
sine=sympy.exp(sympy.I * 2*sympy.pi*mu*t/nBins)
print "sine", sine
sympy.pretty_print(sine)
print "product", normal*sine
sympy.pretty_print(normal*sine)
integral = sympy.integrate(normal*sine,t)
print "integral", integral
sympy.Plot(integral.subs(sigma,standardDelay*1))
@Docstring : Solve the quadratic equation.
@Require : Python==3.7.6; sympy==1.4
@Result : \\
Poly(C2*x**2 + C1*x + C0, x, domain='ZZ[C0,C1,C2]')
________________
/ 2
C1 \/ -4*C0*C2 + C1
- ---- - -------------------
2*C2 2*C2
________________
/ 2
C1 \/ -4*C0*C2 + C1
- ---- + -------------------
2*C2 2*C2
'''
from sympy import symbols, Poly, roots, pretty_print
from sympy.assumptions import assuming, Q
# variables declaration
degree = 2
C = symbols(f'C0:{degree+1}') # C_0, C_1, ..., C_degree
x = symbols('x') # x^0, x^1, ..., x^degree
# calculate roots
with assuming(Q.nonzero(C[-1]), *map(Q.complex, C[:-1])):
quadratic_equation = Poly(reversed(C), x)
solutions = roots(quadratic_equation)
# display results
pretty_print(quadratic_equation, use_unicode=False)
for solution in solutions:
pretty_print(solution, use_unicode=False)
