Esempio n. 1
1
def main():
	A = sympy.Matrix([[3, 11], [22, 6]])
	b = sympy.Matrix([0, 0])
	print("Исходная матрица A:")
	sympy.pprint(A)
	x = gauss.gauss(A, b)
	if x:
		print("\nРезультат:", x)
Esempio n. 2
1
def main():
	A = sympy.Matrix([[1, -3, -1], [2, -2, 1], [3, -1, 2]])
	b = sympy.Matrix([-11, -7, -4])
	print("Исходная матрица A:")
	sympy.pprint(A)
	print("\nВектор b:")
	sympy.pprint(b)
	x = gauss.gauss(A, b)
	if x:
		print("\nРезультат:", x)
Esempio n. 3
0
def case1():
    a, x1, x2 = symbols('a x1 x2')              # Define symbols
    b = 3 * (a - 1)                             # Relation between a and b
    y = a * x1 + b * x2 + 5                     # Given function y
    # Error of x1 and x2
    Sigx1 = 0.8
    Sigx2 = 1.5

    print "In the case that x1 and x2 are dependent:\n"
    Sigx1x2 = Sigx1 * Sigx2     # Correlation coefficient equals to 1
    SigmaXX = np.matrix([[Sigx1**2, Sigx1x2],   # Define covariance
                         [Sigx1x2, Sigx2**2]])  # matrix of x1 and x2
    print "SigmaXX =\n"
    pprint(Matrix(SigmaXX))
    print

    # Jacobian matrix of y function with respect to x1 and x2
    Jyx = np.matrix([diff(y, x1), diff(y, x2)])

    SigmaYY = Jyx * SigmaXX * Jyx.T   # Compute covariance matrix of y function

    # Compute solution in witch the SigmaYY is minimum
    a = round(solve(diff(expand(SigmaYY[0, 0]), a))[0], 8)
    b = round(b.evalf(subs={'a': a}), 8)

    # Compute sigma y
    SigmaY = sqrt(SigmaYY[0, 0].evalf(subs={'a': a, 'b': b}))

    print "a = %.4f\nb = %.4f" % (a, b)
    print "SigmaY = %.4f" % float(SigmaY)
Esempio n. 4
0
def invertInteractive(f, X, Y):
  """
  Given function Y = f(X) return inverse f^{-1}(X).

  Note:
  - f could be fcn of multiple variables. This inverts in variable X
  - f must be a sympy function of sympy symbol/variable X
  - Returns function of Y and anything else f depends upon, removing
    dependence upon X
  - Accounts for non-unique inverse by prompting user to select
    from possible inverses
  """

  # Try to construct inverse
  finv = sp.solve(Y-f, X)

  # If inverse unique, return it. If not, prompt user to select one
  if len(finv) == 1:
    finv = finv[0]

  else:
    print "Please choose expression for the inverse X = f^{-1}(Y)\n"
    for opt, expr in enumerate(finv):
      print "\nOption %d:\n----------\n" % opt
      sp.pprint(expr)
    choice = int(raw_input("Your Choice: "))
    finv = finv[choice]
    os.system('clear')

  return finv
Esempio n. 5
0
def quick_equation(eq = None, latex = None):
	"""
	first print the given equation. optionally, in markdown mode, generate an
	image from an equation and write a link to it.
	"""
	if eq is not None:
		sympy.pprint(eq)
	else:
		print latex
	# print an empty line
	print
	if not markdown:
		return

	global plt
	if latex is None:
		latex = sympy.latex(eq)
	img_filename = hashlib.sha1(latex).hexdigest()[: 10]

	# create the figure and hide the border. set the height and width to
	# something far smaller than the resulting image - bbox_inches will
	# expand this later
	fig = plt.figure(figsize = (0.1, 0.1), frameon = False)
	ax = fig.add_axes([0, 0, 1, 1])
	ax.axis("off")
	fig = plt.gca()
	fig.axes.get_xaxis().set_visible(False)
	fig.axes.get_yaxis().set_visible(False)
	plt.text(0, 0, r"$%s$" % latex, fontsize = 25)
	plt.savefig("img/%s.png" % img_filename, bbox_inches = "tight")
	# don't use the entire latex string for the alt text as it could be long
	quick_write("![%s](img/%s.png)" % (latex[: 20], img_filename))
Esempio n. 6
0
def test1():
    """
    Wiedemann's Formel hat einen Fehler!
    """
    print("\n\n...................",    """Wiedemann's Formel hat einen Fehler!""")
    fs,ld = S.symbols('fs ld')
    QF  = S.Matrix([[1,0],[-1/fs,1]])
    DR  = S.Matrix([[1,ld],[0,1]])
    QD  = S.Matrix([[1,0],[1/fs,1]])
    FODO1 = QD*DR*QF
    FODO2 = FODO1.subs(fs, -fs)
    
    FODO = FODO1*FODO2
    FODO = S.expand(FODO)
    print('... this is the correct one:')
    S.pprint(FODO)

    T = 25.           # kin. energy [MeV]
    T=T*1.e-3         # [GeV] kin.energy 
    betakin=M.sqrt(1.-(1+T/E0)**-2)   # beta kinetic
    E=E0+T            # [GeV] energy
    k=0.2998*Bg/(betakin*E)    # [1/m^2]
    L=0.596                    # distance between quads [m]
    Ql=0.04                    # full quad length [m]
    f = 1./(k*Ql)
    fodo1 = FODO.subs(fs,2*f).subs(ld,L/2.)
    fodo1 = np.array(fodo1)
    fodo2 = Mfodo(2*f,L/2.)         # Wiedemann  (the book is wrong!!)
    my_debug('matrix probe: fodo1-fodo2 must be zero matrix')
    zero = fodo1-fodo2
    my_debug(f'{abs(zero[0][0])}  {abs(zero[0][1])}')
    my_debug(f'{abs(zero[1][0])}  {abs(zero[1][1])}')
    return
def getRelError(variables,func,showFunc = False):
	"""getError generates a function to calculate the error of a function. I.E. a function that
	gives you the error in its result given the error in its input. Output function is numpy ready. 
	Output function will take twice as many args as variables, one for the var and one for the error in that var.

	arguments
	variables      : a list of sympy symbols in func
	errorVariables : list of sympy ymbols representing the error in each value of variables. must be the same length as variables
	func           : a function containing your variables that you want the error of"""
	ErrorFunc = 0 # need to set function to start value
	erVars    = {}
	for i in range(len(variables)): #run through all variables in the function
		v                  = variables[i]
		dv                 =  Symbol('d'+str(v), positive = True)
		erVars['d'+str(v)] = dv
		D                  = (diff(func,v)*dv)**2
		ErrorFunc          += D

	ErrorFunc = sqrt(ErrorFunc)/func
	if showFunc:
		pprint(ErrorFunc)
		
	variables.extend(erVars.values()) #create a list of all sympy symbols involved
	func      = lambdify(tuple(variables), ErrorFunc ,"numpy") #convert ErrorFunc to a numpy rteady python lambda
	return(func)
Esempio n. 8
0
def p1_5(part=None):
    """
    Complete solution to problem 1.5

    Parameters
    ----------
    part: str, optional(default=None)
        The part number you would like evaluated. If this is left blank
        the default value of None is used and the entire problem will be
        solved.

    Returns
    -------
    i-dont-know-yet
    """
    f, fp, fp2, fp3, fp4, h, fplus, fminus = symbols('f, fp, fp2, fp3, fp4, \
                                                     h, fplus, fminus')
    eqns = (Eq(fplus, f + fp * h + fp2 * h ** 2 / 2 + \
                      fp3 * h ** 3 / 6 + fp4 * h ** 4 / 24),
            Eq(fminus, f - fp * h + fp2 * h ** 2 / 2 - \
                       fp3 * h ** 3 / 6 + fp4 * h ** 4 / 24))
    soln = solve(eqns, fp, fp2)
    pprint(soln)

    pass  # return nothing
Esempio n. 9
0
def showCookToomFilter(a,n,r,fractionsIn=FractionsInG):

    AT,G,BT,f = cookToomFilter(a,n,r,fractionsIn)

    print "AT = "
    pprint(AT)
    print ""

    print "G = "
    pprint(G)
    print ""

    print "BT = "
    pprint(BT)
    print ""

    if fractionsIn != FractionsInF:
        print "AT*((G*g)(BT*d)) ="
        pprint(filterVerify(n,r,AT,G,BT))
        print ""

    if fractionsIn == FractionsInF:
        print "fractions = "
        pprint(f)
        print ""
Esempio n. 10
0
 def display(self,opt='repr'):
     """
     Procedure Name: display
     Purpose: Displays the random variable in an interactive environment
     Arugments:  1. self: the random variable
     Output:     1. A print statement for each piece of the distribution
                     indicating the function and the relevant support
     """
     if self.ftype[0] in ['continuous','Discrete']:
         print ('%s %s'%(self.ftype[0],self.ftype[1]))
         for i in range(len(self.func)):
             cons_list=['0<'+str(cons) for cons in self.constraints[i]]
             cons_string=', '.join(cons_list)
             print('for x,y enclosed in the region:')
             print(cons_string)
             print('---------------------------')
             pprint(self.func[i])
             print('---------------------------')
             if i<len(self.func)-1:
                 print(' ');print(' ')
         
     if self.ftype[0]=='discrete':
         print '%s %s where {x->f(x)}:'%(self.ftype[0],
                                         self.ftype[1])
         for i in range(len(self.support)):
             if i!=(len(self.support)-1):
                 print '{%s -> %s}, '%(self.support[i],
                                       self.func[i]),
             else:
                 print '{%s -> %s}'%(self.support[i],
                                     self.func[i])
Esempio n. 11
0
def print_formulas(G):
    for node in G.nodes():
        print("Node {}:".format(node))
        pprint(G.formula_conj(node))
        #pprint(simplify(G.formula_conj(node)))
        #pprint(to_cnf(G.formula_conj(node), simplify=True))
    print("\n")
Esempio n. 12
0
def tests():
    x, y, z = symbols('x,y,z')
    #print(x + x + 1)
    expr = x**2 - y**2
    factors = factor(expr)
    print(factors, " | ", expand(factors))
    pprint(expand(factors))
Esempio n. 13
0
def showCookToomConvolution(a,n,r,fractionsIn=FractionsInG):

    AT,G,BT,f = cookToomFilter(a,n,r,fractionsIn)

    B = BT.transpose()
    A = AT.transpose()
    
    print "A = "
    pprint(A)
    print ""

    print "G = "
    pprint(G)
    print ""

    print "B = "
    pprint(B)
    print ""

    if fractionsIn != FractionsInF:
        print "Linear Convolution: B*((G*g)(A*d)) ="
        pprint(convolutionVerify(n,r,B,G,A))
        print ""

    if fractionsIn == FractionsInF:
        print "fractions = "
        pprint(f)
        print ""
Esempio n. 14
0
def main():

    print 'Initial metric:'
    pprint(gdd)
    print '-'*40
    print 'Christoffel symbols:'
    for i in [0,1,2,3]:
    	for k in [0,1,2,3]:
    		for l in [0,1,2,3]:
    			if Gamma.udd(i,k,l) != 0 :
		    		pprint_Gamma_udd(i,k,l)
    print'-'*40
    print'Ricci tensor:'
    for i in [0,1,2,3]:
    	for j in [0,1,2,3]:
    		if Rmn.dd(i,j) !=0:
    			pprint_Rmn_dd(i,j)
    
    print '-'*40
    #Solving EFE for A and B
    s = ( Rmn.dd(1,1)/ A(r) ) + ( Rmn.dd(0,0)/ B(r) )
    pprint (s)
    t = dsolve(s, A(r))
    pprint(t)
    metric = gdd.subs(A(r), t)
    print "metric:"
    pprint(metric)
    r22 = Rmn.dd(3,3).subs( A(r), 1/B(r))
    h = dsolve( r22, B(r) )
    pprint(h)
Esempio n. 15
0
    def pprint(self, **settings):
        """
        Print the PHS structure :math:`\\mathbf{b} = \\mathbf{M} \\cdot \\mathbf{a}`
        using sympy's pretty printings.

        Parameters
        ----------

        settings : dic
            Parameters for sympy.pprint function.

        See Also
        --------

        sympy.pprint

        """

        sympy.init_printing()

        b = types.matrix_types[0](self.dtx() +
                                  self.w +
                                  self.y +
                                  self.cy)

        a = types.matrix_types[0](self.dxH() +
                                  self.z +
                                  self.u +
                                  self.cu)

        sympy.pprint([b, self.M, a], **settings)
Esempio n. 16
0
def setup_loss(loss_type, native_lang = "C", verbose=False):
    """
    set up symbolic derivations
    """

    print "setting up autowrapped loss", loss_type

    x = x = sympy.Symbol("x")
    y = y = sympy.Symbol("y")
    z = z = sympy.Symbol("z")
    cx = cx = sympy.Symbol("cx")
    cy = cy = sympy.Symbol("cy")
    wx = wx = sympy.Symbol("wx")
    wy = wy = sympy.Symbol("wy")
    rx = rx = sympy.Symbol("rx")
    ry = ry = sympy.Symbol("ry")

    if loss_type == "algebraic_squared":
        fun = ((x-(cx + z*wx))**2/(rx*rx) + (y-(cy + z*wy))**2/(ry*ry) - 1)**2

    if loss_type == "algebraic_abs":
        fun = sympy.sqrt(((x-(cx + z*wx))**2/(rx*rx) + (y-(cy + z*wy))**2/(ry*ry) - 1)**2 + 0.01)

    #TODO replace x**2 with x*x
    fun = fun.expand(deep=True)

    if verbose:
        sympy.pprint(fun)

    d_cx = fun.diff(cx).expand(deep=True)
    d_cy = fun.diff(cy).expand(deep=True)
    d_wx = fun.diff(wx).expand(deep=True)
    d_wy = fun.diff(wy).expand(deep=True)
    d_rx = fun.diff(rx).expand(deep=True)
    d_ry = fun.diff(ry).expand(deep=True)

    if native_lang == "fortran":
        c_fun = autowrap(fun, language="F95", backend="f2py")
        c_d_cx = autowrap(d_cx)
        c_d_cy = autowrap(d_cy)
        w_d_wx = autowrap(d_wx)
        w_d_wy = autowrap(d_wy)
        c_d_rx = autowrap(d_rx)
        c_d_ry = autowrap(d_ry)
    else:
        c_fun = autowrap(fun, language="C", backend="Cython", tempdir=".")
        c_d_cx = autowrap(d_cx, language="C", backend="Cython", tempdir=".")
        c_d_cy = autowrap(d_cy, language="C", backend="Cython", tempdir=".")
        c_d_wx = autowrap(d_wx, language="C", backend="Cython", tempdir=".")
        c_d_wy = autowrap(d_wy, language="C", backend="Cython", tempdir=".")
        c_d_rx = autowrap(d_rx, language="C", backend="Cython", tempdir=".")
        c_d_ry = autowrap(d_ry, language="C", backend="Cython", tempdir=".")

    grads = {"cx": d_cx, "cy": d_cy, "wx": d_wx, "wy": d_wy, "rx": d_rx, "ry": d_ry}
    c_grads = {"cx": c_d_cx, "cy": c_d_cy, "wx": c_d_wx, "wy": c_d_wy, "rx": c_d_rx, "ry": c_d_ry}

    print "done setting up autowrapped loss"

    return c_fun, c_grads
Esempio n. 17
0
def triangle_length(l):
    sympy.init_printing()
    for n in range(1, 17):
        print("Triangle: ", n)
        print (l)
        sympy.pprint (l * sympy.sqrt(n), use_unicode=True) 
        sympy.pprint (l * sympy.sqrt(n+1), use_unicode=True) 
    print ("-------------------------")
Esempio n. 18
0
def print_formulas(G, label=None):
    if label:
        print("{}".format(label))
        print("----------------------")
    for node in G.nodes():
        print("Node {}:".format(node))
        pprint(G.formula_conj(node))
    print("\n")
Esempio n. 19
0
def main():
    A = sympy.Matrix([[3, -1],
                      [-6, 2]])
    b = sympy.Matrix([0, 0])
    print("\nInitial matrix:")
    sympy.pprint(A)
    x = gauss.sym_gauss(A, b)
    sympy.pprint(x)
Esempio n. 20
0
def main():
    a = Symbol('a')
    b = Symbol('b')
    c = Symbol('c')
    e = ( a*b*b + 2*b*a*b )**c

    print('')
    pprint(e)
    print('')
Esempio n. 21
0
File: ode.py Progetto: rikazry/compy
def non_homo_linear(rhs, *cds):
    char_func, eq, rs = homo_linear(*cds)
    print('\nnon-homogeneous ODE:')
    pprint(Eq(eq, rhs))
    eq -= rhs
    print('\nsolving non-homogeneous linear equation...\nresult:')
    rs = dsolve(eq)
    pprint(rs)
    return char_func, eq, rs
Esempio n. 22
0
def main():
    a = Symbol("a")
    b = Symbol("b")
    c = Symbol("c")
    e = (a * b * b + 2 * b * a * b) ** c

    print("")
    pprint(e)
    print("")
Esempio n. 23
0
def print_series(n):
    # initialize printing system with
    # reverse order
    init_printing(order='rev-lex')
    x = Symbol('x')
    series = x
    for i in range(2, n+1):
        series = series + (x**i)/i
    pprint(series)
Esempio n. 24
0
def main():
    a = sympy.Symbol('a')
    b = sympy.Symbol('b')
    c = sympy.Symbol('c')
    e = ( a*b*b + 2*b*a*b )**c

    print
    pprint(e)
    print
Esempio n. 25
0
def grad_test_times_grad_field(degree):
    """Calculate \int \nabla \phi _i \cdot \nabla \phi _j."""

    # Setup variables.
    r, s = sympy.symbols('r s')
    r_gll = sympy.symbols('r_0:%d' % (degree + 1))
    s_gll = sympy.symbols('s_0:%d' % (degree + 1))
    total_integration_points = (degree + 1) * (degree + 1)

    # Get N + 1 lagrange polynomials in each direction.
    generator_r = generating_polynomial_lagrange(degree, 'r', r_gll)
    generator_s = generating_polynomial_lagrange(degree, 's', s_gll)

    # Evalute bases
    basis = sympy.physics.quantum.TensorProduct(generator_r, generator_s)
    gll_coordinates, gll_weights = gauss_lobatto_legendre_quadruature_points_weights(degree + 1)
    basis = basis.subs([(v, c) for v, c in zip(r_gll, gll_coordinates)])
    basis = basis.subs([(v, c) for v, c in zip(s_gll, gll_coordinates)])

    # Get gradient of basis functions.
    basis_gradient_r = [sympy.diff(i, r) for i in basis]
    basis_gradient_s = [sympy.diff(i, s) for i in basis]

    # Get interpolating field.
    field = poly_2D(degree)

    # Take gradient of this field.
    grad_field = sympy.Matrix([[sympy.diff(field, r).subs({r: i, s: j})
                                for j in gll_coordinates
                                for i in gll_coordinates],
                               [sympy.diff(field, s).subs({r: i, s: j})
                                for j in gll_coordinates
                                for i in gll_coordinates]])

    # Take gradient of the tensor basis.
    grad_test = sympy.Matrix([basis_gradient_r,
                              basis_gradient_s])

    # Compute \nabla \phi _i \cdot \nabla \phi _j
    grad_test_grad_field = [grad_test.col(i).dot(grad_field.col(j))
                            for i in range(total_integration_points)
                            for j in range(total_integration_points)]

    # Sum over \phi _i
    final_grad = [sum(grad_test_grad_field[i:i + total_integration_points])
                  for i in range(0, len(grad_test_grad_field), total_integration_points)]

    # Integrate over 2D domain.
    integrated = [sympy.integrate(f, (r, -1, 1))
                  for f in final_grad]
    integrated = [sympy.integrate(f, (s, -1, 1))
                  for f in integrated]

    print("NABLA PHI_i \cdot NABLA PHI_j")
    sympy.pprint(integrated)
    print(sum(integrated))
Esempio n. 26
0
def test_pprint():
    import StringIO, sys
    fd = StringIO.StringIO()
    sso = sys.stdout
    sys.stdout = fd
    try:
        pprint(pi, use_unicode=False)
    finally:
        sys.stdout = sso
    assert fd.getvalue() == 'pi\n'
Esempio n. 27
0
def print_series(n, x_value):
	init_printing(order = 'rev-lex')
	x = Symbol('x')
	series = x
	for i in range(2, n+1):
		series = series + (x**i)/i
	pprint(series)

	series_value = series.subs({x:x_value})
	print('Value of the series at {0}: {1}'.format(x_value, series_value))
Esempio n. 28
0
def main():
    a = sympy.Symbol("a")
    b = sympy.Symbol("b")
    e = (a + b) ** 5

    print
    pprint(e)
    print "\n"
    pprint(e.expand())
    print
Esempio n. 29
0
def main():
    a = sympy.Symbol('a')
    b = sympy.Symbol('b')
    e = (a + b)**5

    print("\nExpression:")
    pprint(e)
    print('\nExpansion of the above expression:')
    pprint(e.expand())
    print()
Esempio n. 30
0
def printSeries(n, val):
    init_printing(order='rev-lex')
    x = Symbol('x')
    expr = x
    for i in range(2, n + 1):
        expr += (x**i / i)
    pprint(expr)

    res = expr.subs({x: val})
    print(res)
Esempio n. 31
0
def Subcriticalb():
    r, x = sy.symbols('r x', real=True)
    equation = r * x + 4 * x**3 - 9 * x**5
    system = [sy.Eq(equation, 0), sy.Eq(sy.diff(equation, x), 0)]
    sy.pprint(sy.solve(system))
    equation.subs((r, -4 / 9))
Esempio n. 32
0
def eq3():
    r = Symbol("r")
    e = Rmn.dd(2,2)
    e = e.subs(nu(r), -lam(r))
    pprint(dsolve(e, lam(r)))
Esempio n. 33
0
def pmatrix(Anp, s):
    import sympy
    msym = sympy.Matrix(Anp)
    print(s)
    sympy.pprint(msym)
Esempio n. 34
0
import sympy
from sympy.abc import pi

sympy.pprint(pi)

sympy.pprint("I am" + pi)
Esempio n. 35
0
# In[3]:

import sympy as sym
a = sym.sqrt(11)
a

# Podemos mejorar la apariencia de una expresión si en vez de usar print utilizamos:
# ~~~python
# sym.pprint(a)
# ~~~
# o si simplemente poniendo la expresión.

# In[4]:

sym.pprint(a)

# Podemos obtener el valor numérico con evalf(). Obtenga el valor numérico de $\sqrt{11}$

# In[5]:

a.evalf()

# Las variables comunes de álgebra son símbolos. Si quiero definir x:

# In[6]:

x = sym.symbols("x")

# Imprimimos x para verificar.
# -*- coding: utf-8 -*-

# Usage: python math/composition-shift.py

import sys, os

sys.path.append(os.path.join(os.path.dirname(__file__), ".."))
from CALPHAD_energies import *

from sympy import Eq, init_printing, Matrix, pprint, solve_linear_system, symbols

init_printing()
P_delta = 2 * s_delta / r_delta
P_laves = 2 * s_laves / r_laves

pprint(Eq(symbols("x_alpha_Cr"), xe_gam_Cr + DXAB(P_delta, P_laves)))
pprint(Eq(symbols("x_alpha_Nb"), xe_gam_Nb + DXAC(P_delta, P_laves)))
pprint(Eq(symbols("x_beta_Cr"), xe_del_Cr + DXBB(P_delta, P_laves)))
pprint(Eq(symbols("x_beta_Nb"), xe_del_Nb + DXBC(P_delta, P_laves)))
pprint(Eq(symbols("x_gamma_Cr"), xe_lav_Cr + DXGB(P_delta, P_laves)))
pprint(Eq(symbols("x_gamma_Nb"), xe_lav_Nb + DXGC(P_delta, P_laves)))

pprint(Eq(symbols("x_Cr"), levers[y]))
pprint(Eq(symbols("x_Nb"), levers[x]))
Esempio n. 37
0
def main():
    e = sympy.Rational(2)**50/sympy.Rational(10)**50
    pprint(e)
Esempio n. 38
0
#!/usr/bin/env python
from sympy import pi, Symbol, symbols, log, pprint

print(pi.evalf(50), '\n')  # <1>

x = Symbol('x')  # <2>
f = x**(1 - log(log(log(log(1 / x)))))  # <3>
pprint(f)

pprint(f.subs(x, pi).evalf())  # <4>
pprint(f.subs(x, 10).evalf())
pprint(f.subs(x, 3).evalf())
print()

a, b, c = symbols('a b c')  # <5>
exp = (a + b) * 40 - (c - a) / 0.5  # <6>
pprint(exp)
pprint(exp.evalf(6, subs={a: 6, b: 5, c: 2}))  # <7>
Esempio n. 39
0
p = x * (x + x)
print(p)

p = (x + 2) * (x + 3)
print(p)

expr = x**2 - y**2
factors = factor(expr)
print(factor(expr))

print(expand(factors))

expr = x**3 + 3 * x**2 * y + 3 * x * y**2 + y**3
factors = factor(expr)
print(factors)
pprint(factors)

n = 5
series = x
for i in range(2, n + 1):
    series = series + (x**i) / i
pprint(series)

expr = x * x + x * y + x * y + y * y
res = expr.subs({x: 1, y: 2})
print(res)

print(expr.subs({x: 1 - y}))

x = Symbol('x')
series = x
Esempio n. 40
0
print(expression_3)
print()

# 符号矩阵
print('符号矩阵:')
a, b = sympy.symbols('a b')
matrix = sympy.Matrix([[1, a], [0, b]])  # 使用sympy.Matrix()
print(matrix)
print()

sympy.init_printing(use_unicode=True)
# 符号矩阵的特征值和特征向量
print('符号矩阵的特征值和特征向量:')
eigenvalue = matrix.eigenvals()  # 使用.eigenvals()方法
print('特征值\n', eigenvalue, '\n')
sympy.pprint(eigenvalue)  # 使用sympy.pprint()输出
print('\n', sympy.pretty(eigenvalue))  # 使用sympy.pretty()美化后输出
print()

eigenvector = matrix.eigenvects()  # 使用.eigenvects()方法
print('特征向量\n', eigenvector, '\n')
sympy.pprint(eigenvector)
print('\n', sympy.pretty(eigenvector))
print()

P, D = matrix.diagonalize()  # 使用.diagonalize()方法
print('特征值\n', D, '\n')
print(sympy.pretty(D), '\n')
print('特征向量\n', P, '\n')
print(sympy.pretty(P), '\n')
print()
Esempio n. 41
0
def main():

    print(__doc__)

    # arrays are represented with IndexedBase, indices with Idx
    m = Symbol('m', integer=True)
    i = Idx('i', m)
    A = IndexedBase('A')
    B = IndexedBase('B')
    x = Symbol('x')

    print("Compiling ufuncs for radial harmonic oscillator solutions")

    # setup a basis of ho-solutions  (for l=0)
    basis_ho = {}
    for n in range(basis_dimension):

        # Setup the radial ho solution for this n
        expr = R_nl(n, orbital_momentum_l, omega2, x)

        # Reduce the number of operations in the expression by eval to float
        expr = expr.evalf(15)

        print("The h.o. wave function with l = %i and n = %i is" %
              (orbital_momentum_l, n))
        pprint(expr)

        # implement, compile and wrap it as a ufunc
        basis_ho[n] = ufuncify(x, expr)

    # now let's see if we can express a hydrogen radial wave in terms of
    # the ho basis.  Here's the solution we will approximate:
    H_ufunc = ufuncify(x, hydro_nl(hydrogen_n, orbital_momentum_l, 1, x))

    # The transformation to a different basis can be written like this,
    #
    #   psi(r) = sum_i c(i) phi_i(r)
    #
    # where psi(r) is the hydrogen solution, phi_i(r) are the H.O. solutions
    # and c(i) are scalar coefficients.
    #
    # So in order to express a hydrogen solution in terms of the H.O. basis, we
    # need to determine the coefficients c(i).  In position space, it means
    # that we need to evaluate an integral:
    #
    #  psi(r) = sum_i Integral(R**2*conj(phi(R))*psi(R), (R, 0, oo)) phi_i(r)
    #
    # To calculate the integral with autowrap, we notice that it contains an
    # element-wise sum over all vectors.  Using the Indexed class, it is
    # possible to generate autowrapped functions that perform summations in
    # the low-level code.  (In fact, summations are very easy to create, and as
    # we will see it is often necessary to take extra steps in order to avoid
    # them.)
    # we need one integration ufunc for each wave function in the h.o. basis
    binary_integrator = {}
    for n in range(basis_dimension):

        #
        # setup basis wave functions
        #
        # To get inline expressions in the low level code, we attach the
        # wave function expressions to a regular SymPy function using the
        # implemented_function utility.  This is an extra step needed to avoid
        # erroneous summations in the wave function expressions.
        #
        # Such function objects carry around the expression they represent,
        # but the expression is not exposed unless explicit measures are taken.
        # The benefit is that the routines that searches for repeated indices
        # in order to make contractions will not search through the wave
        # function expression.
        psi_ho = implemented_function(
            'psi_ho', Lambda(x, R_nl(n, orbital_momentum_l, omega2, x)))

        # We represent the hydrogen function by an array which will be an input
        # argument to the binary routine.  This will let the integrators find
        # h.o. basis coefficients for any wave function we throw at them.
        psi = IndexedBase('psi')

        #
        # setup expression for the integration
        #

        step = Symbol('step')  # use symbolic stepsize for flexibility

        # let i represent an index of the grid array, and let A represent the
        # grid array.  Then we can approximate the integral by a sum over the
        # following expression (simplified rectangular rule, ignoring end point
        # corrections):

        expr = A[i]**2 * psi_ho(A[i]) * psi[i] * step

        if n == 0:
            print("Setting up binary integrators for the integral:")
            pprint(Integral(x**2 * psi_ho(x) * Function('psi')(x), (x, 0, oo)))

        # Autowrap it.  For functions that take more than one argument, it is
        # a good idea to use the 'args' keyword so that you know the signature
        # of the wrapped function.  (The dimension m will be an optional
        # argument, but it must be present in the args list.)
        binary_integrator[n] = autowrap(expr,
                                        args=[A.label, psi.label, step, m])

        # Lets see how it converges with the grid dimension
        print("Checking convergence of integrator for n = %i" % n)
        for g in range(3, 8):
            grid, step = np.linspace(0, rmax, 2**g, retstep=True)
            print("grid dimension %5i, integral = %e" %
                  (2**g, binary_integrator[n](grid, H_ufunc(grid), step)))

    print("A binary integrator has been set up for each basis state")
    print("We will now use them to reconstruct a hydrogen solution.")

    # Note: We didn't need to specify grid or use gridsize before now
    grid, stepsize = np.linspace(0, rmax, gridsize, retstep=True)

    print("Calculating coefficients with gridsize = %i and stepsize %f" %
          (len(grid), stepsize))

    coeffs = {}
    for n in range(basis_dimension):
        coeffs[n] = binary_integrator[n](grid, H_ufunc(grid), stepsize)
        print("c(%i) = %e" % (n, coeffs[n]))

    print("Constructing the approximate hydrogen wave")
    hydro_approx = 0
    all_steps = {}
    for n in range(basis_dimension):
        hydro_approx += basis_ho[n](grid) * coeffs[n]
        all_steps[n] = hydro_approx.copy()
        if pylab:
            line = pylab.plot(grid, all_steps[n], ':', label='max n = %i' % n)

    # check error numerically
    diff = np.max(np.abs(hydro_approx - H_ufunc(grid)))
    print("Error estimate: the element with largest deviation misses by %f" %
          diff)
    if diff > 0.01:
        print("This is much, try to increase the basis size or adjust omega")
    else:
        print("Ah, that's a pretty good approximation!")

    # Check visually
    if pylab:
        print("Here's a plot showing the contribution for each n")
        line[0].set_linestyle('-')
        pylab.plot(grid, H_ufunc(grid), 'r-', label='exact')
        pylab.legend()
        pylab.show()

    print("""Note:
    These binary integrators were specialized to find coefficients for a
    harmonic oscillator basis, but they can process any wave function as long
    as it is available as a vector and defined on a grid with equidistant
    points. That is, on any grid you get from numpy.linspace.

    To make the integrators even more flexible, you can setup the harmonic
    oscillator solutions with symbolic parameters omega and l.  Then the
    autowrapped binary routine will take these scalar variables as arguments,
    so that the integrators can find coefficients for *any* isotropic harmonic
    oscillator basis.

    """)
from sympy import init_printing, pprint
init_printing(use_unicode=True)

# about `Points`

from sympy.vector import CoordSys3D

N = CoordSys3D("N")
pprint(N.origin)
print(type(N.origin))

# we can instantiate new points in space using locate_new method of `Point`
from sympy.abc import a, b, c

P = N.origin.locate_new("P", a*N.i + b*N.j + c*N.k)
Q = P.locate_new("Q", -b*N.j)

pprint(P)
pprint(Q)

# position vector
# v = P - Q
v = P.position_wrt(Q)
pprint(v)

v = Q.position_wrt(N.origin)
pprint(v)

v = P.position_wrt(N.origin)
pprint(v)
Esempio n. 43
0
def a():

    t = sym.symbols('t')
    xt =  4 * sym.sin(7*t)+ 25* sym.cos(15*t)
    #sym.plot(xt)
    sym.pprint(xt)
import sympy as sy
import matplotlib.pyplot as plt
import numpy as np
plt.close()
sy.init_printing()
#From  Johansson, R Numerical Python p.209 onward.
#Create symbols for the ODE
r,k,N0, t = sy.symbols('r k N_0 t' )
N = sy.symbols('N', function=True)
ode = N(t).diff(t) - (r*N(t)*(1-N(t)/k))# - N(t)**2/(1+N(t)**2))
sy.pprint(sy.Eq(ode))
#solve the ODE
ode_sol = sy.dsolve(ode, N(t))
ics = {N(0):N0}
print('+'*30)
print('Iniital conditions:')
sy.pprint(ics)
#Find the value of the integration constants
C_eq = sy.Eq(ode_sol.lhs.subs(t,0).subs(ics),ode_sol.rhs.subs(t,0))
print('+'*30)
print('Create equations at N(0))')
sy.pprint(C_eq)
print()
#Solve for C_eq
C_sol = sy.solve(C_eq,sy.Symbol('C1'))
soln = ode_sol.subs(sy.Symbol('C1'),C_sol[0])
sy.pprint(C_sol)
sy.pprint(soln)
print('+'*30)

ode_func = sy.lambdify(t, soln.rhs.subs({N0:100,r:.2,k:1000}) )
def getExpression(mode, submode):
    '''一阶电路示例'''
    if (mode == 1):
        if (submode == 1):
            Vc = symbols('Vc', cls=sp.Function)
            t = symbols('t')
            if (S.mode == 0):
                eq = Eq(diff(Vc(t), t, 1),
                        -Vc(t) / (S.R * S.C) + S.Vs / (S.R * S.C))
                sp.pprint(dsolve(eq, Vc(t), ics={Vc(0): S.V0}))
            elif (S.mode == 1):
                eq = Eq(
                    diff(Vc(t), t, 1), -Vc(t) / (S.R * S.C) +
                    S.Vs * sp.sin(2 * sp.pi * t / S.T0) / (S.R * S.C))
                sp.pprint(dsolve(eq, Vc(t), ics={Vc(0): S.V0}))

        elif (submode == 2):
            iL = symbols('iL', cls=sp.Function)
            t = symbols('t')
            if (S.mode == 0):
                eq = Eq(diff(iL(t), t, 1),
                        -iL(t) * S.R / S.L + S.iS * S.R / S.L)
                sp.pprint(dsolve(eq, iL(t), ics={iL(0): S.I0}))
            elif (S.mode == 1):
                eq = Eq(
                    diff(iL(t), t, 1), -iL(t) * S.R / S.L +
                    S.iS * sp.sin(2 * sp.pi * t / S.T0) * S.R / S.L)
                sp.pprint(dsolve(eq, iL(t), ics={iL(0): S.I0}))
        '''二阶电路示例'''
    elif (mode == 2):
        if (submode == 1):
            Vc, iL = symbols('Vc,iL', cls=sp.Function)
            t = symbols('t')
            if (S.mode == 0):
                eq1 = Eq(
                    diff(Vc(t), t, 2) + S.R * diff(Vc(t), t, 1) / S.L + Vc(t) /
                    (S.L * S.C), S.Vs / (S.L * S.C))
                sp.pprint(
                    dsolve(eq1,
                           Vc(t),
                           ics={
                               Vc(0): S.V0,
                               diff(Vc(t), t).subs(t, 0): S.I0 / S.C
                           }))
            elif (S.mode == 1):
                eq1 = Eq(
                    diff(Vc(t), t, 2) + S.R * diff(Vc(t), t, 1) / S.L + Vc(t) /
                    (S.L * S.C),
                    S.Vs * sp.sin(2 * sp.pi * t / S.T0) / (S.L * S.C))
                sp.pprint(
                    dsolve(eq1,
                           Vc(t),
                           ics={
                               Vc(0): S.V0,
                               diff(Vc(t), t).subs(t, 0): S.I0 / S.C
                           }))
Esempio n. 46
0
def _dev_iters_until_threshold():
    """
    INTERACTIVE DEVELOPMENT FUNCTION

    How many iterations of ewma until you hit the poisson / biniomal threshold

    This establishes a principled way to choose the threshold for the refresh
    criterion in my thesis. There are paramters --- moving parts --- that we
    need to work with: `a` the patience, `s` the span, and `mu` our ewma.

    `s` is a span paramter indicating how far we look back.

    `mu` is the average number of label-changing reviews in roughly the last
    `s` manual decisions.

    These numbers are used to estimate the probability that any of the next `a`
    manual decisions will be label-chanigng. When that probability falls below
    a threshold we terminate. The goal is to choose `a`, `s`, and the threshold
    `t`, such that the probability will fall below the threshold after a maximum
    of `a` consecutive non-label-chaning reviews. IE we want to tie the patience
    paramter (how far we look ahead) to how far we actually are willing to go.
    """
    import numpy as np
    import utool as ut
    import sympy as sym
    i = sym.symbols('i', integer=True, nonnegative=True, finite=True)
    # mu_i = sym.symbols('mu_i', integer=True, nonnegative=True, finite=True)
    s = sym.symbols('s', integer=True, nonnegative=True, finite=True)  # NOQA
    thresh = sym.symbols('tau', real=True, nonnegative=True, finite=True)  # NOQA
    alpha = sym.symbols('alpha', real=True, nonnegative=True, finite=True)  # NOQA
    c_alpha = sym.symbols('c_alpha', real=True, nonnegative=True, finite=True)
    # patience
    a = sym.symbols('a', real=True, nonnegative=True, finite=True)

    available_subs = {
        a: 20,
        s: a,
        alpha: 2 / (s + 1),
        c_alpha: (1 - alpha),
    }

    def subs(expr, d=available_subs):
        """ recursive expression substitution """
        expr1 = expr.subs(d)
        if expr == expr1:
            return expr1
        else:
            return subs(expr1, d=d)

    # mu is either the support for the poisson distribution
    # or is is the p in the binomial distribution
    # It is updated at timestep i based on ewma, assuming each incoming responce is 0
    mu_0 = 1.0
    mu_i = c_alpha ** i

    # Estimate probability that any event will happen in the next `a` reviews
    # at time `i`.
    poisson_i = 1 - sym.exp(-mu_i * a)
    binom_i = 1 - (1 - mu_i) ** a

    # Expand probabilities to be a function of i, s, and a
    part = ut.delete_dict_keys(available_subs.copy(), [a, s])
    mu_i = subs(mu_i, d=part)
    poisson_i = subs(poisson_i, d=part)
    binom_i = subs(binom_i, d=part)

    if True:
        # ewma of mu at time i if review is always not label-changing (meaningful)
        mu_1 = c_alpha * mu_0  # NOQA
        mu_2 = c_alpha * mu_1  # NOQA

    if True:
        i_vals = np.arange(0, 100)
        mu_vals = np.array([subs(mu_i).subs({i: i_}).evalf() for i_ in i_vals])  # NOQA
        binom_vals = np.array([subs(binom_i).subs({i: i_}).evalf() for i_ in i_vals])  # NOQA
        poisson_vals = np.array([subs(poisson_i).subs({i: i_}).evalf() for i_ in i_vals])  # NOQA

        # Find how many iters it actually takes my expt to terminate
        thesis_draft_thresh = np.exp(-2)
        np.where(mu_vals < thesis_draft_thresh)[0]
        np.where(binom_vals < thesis_draft_thresh)[0]
        np.where(poisson_vals < thesis_draft_thresh)[0]

    sym.pprint(sym.simplify(mu_i))
    sym.pprint(sym.simplify(binom_i))
    sym.pprint(sym.simplify(poisson_i))

    # Find the thresholds that force termination after `a` reviews have passed
    # do this by setting i=a
    poisson_thresh = poisson_i.subs({i: a})
    binom_thresh = binom_i.subs({i: a})

    print('Poisson thresh')
    print(sym.latex(sym.Eq(thresh, poisson_thresh)))
    print(sym.latex(sym.Eq(thresh, sym.simplify(poisson_thresh))))

    poisson_thresh.subs({a: 115, s: 30}).evalf()

    sym.pprint(sym.Eq(thresh, poisson_thresh))
    sym.pprint(sym.Eq(thresh, sym.simplify(poisson_thresh)))

    print('Binomial thresh')
    sym.pprint(sym.simplify(binom_thresh))

    sym.pprint(sym.simplify(poisson_thresh.subs({s: a})))

    def taud(coeff):
        return coeff * 360

    if 'poisson_cache' not in vars():
        poisson_cache = {}
        binom_cache = {}

    S, A = np.meshgrid(np.arange(1, 150, 1), np.arange(0, 150, 1))

    import plottool as pt
    SA_coords = list(zip(S.ravel(), A.ravel()))
    for sval, aval in ut.ProgIter(SA_coords):
        if (sval, aval) not in poisson_cache:
            poisson_cache[(sval, aval)] = float(poisson_thresh.subs({a: aval, s: sval}).evalf())
    poisson_zdata = np.array(
        [poisson_cache[(sval, aval)] for sval, aval in SA_coords]).reshape(A.shape)
    fig = pt.figure(fnum=1, doclf=True)
    pt.gca().set_axis_off()
    pt.plot_surface3d(S, A, poisson_zdata, xlabel='s', ylabel='a',
                      rstride=3, cstride=3,
                      zlabel='poisson', mode='wire', contour=True,
                      title='poisson3d')
    pt.gca().set_zlim(0, 1)
    pt.gca().view_init(elev=taud(1 / 16), azim=taud(5 / 8))
    fig.set_size_inches(10, 6)
    fig.savefig('a-s-t-poisson3d.png', dpi=300, bbox_inches=pt.extract_axes_extents(fig, combine=True))

    for sval, aval in ut.ProgIter(SA_coords):
        if (sval, aval) not in binom_cache:
            binom_cache[(sval, aval)] = float(binom_thresh.subs({a: aval, s: sval}).evalf())
    binom_zdata = np.array(
        [binom_cache[(sval, aval)] for sval, aval in SA_coords]).reshape(A.shape)
    fig = pt.figure(fnum=2, doclf=True)
    pt.gca().set_axis_off()
    pt.plot_surface3d(S, A, binom_zdata, xlabel='s', ylabel='a',
                      rstride=3, cstride=3,
                      zlabel='binom', mode='wire', contour=True,
                      title='binom3d')
    pt.gca().set_zlim(0, 1)
    pt.gca().view_init(elev=taud(1 / 16), azim=taud(5 / 8))
    fig.set_size_inches(10, 6)
    fig.savefig('a-s-t-binom3d.png', dpi=300, bbox_inches=pt.extract_axes_extents(fig, combine=True))

    # Find point on the surface that achieves a reasonable threshold

    # Sympy can't solve this
    # sym.solve(sym.Eq(binom_thresh.subs({s: 50}), .05))
    # sym.solve(sym.Eq(poisson_thresh.subs({s: 50}), .05))
    # Find a numerical solution
    def solve_numeric(expr, target, want, fixed, method=None, bounds=None):
        """
        Args:
            expr (Expr): symbolic expression
            target (float): numberic value
            fixed (dict): fixed values of the symbol

        expr = poisson_thresh
        expr.free_symbols
        fixed = {s: 10}

        solve_numeric(poisson_thresh, .05, {s: 30}, method=None)
        solve_numeric(poisson_thresh, .05, {s: 30}, method='Nelder-Mead')
        solve_numeric(poisson_thresh, .05, {s: 30}, method='BFGS')
        """
        import scipy.optimize
        # Find the symbol you want to solve for
        want_symbols = expr.free_symbols - set(fixed.keys())
        # TODO: can probably extend this to multiple params
        assert len(want_symbols) == 1, 'specify all but one var'
        assert want == list(want_symbols)[0]
        fixed_expr = expr.subs(fixed)
        def func(a1):
            expr_value = float(fixed_expr.subs({want: a1}).evalf())
            return (expr_value - target) ** 2
        # if method is None:
        #     method = 'Nelder-Mead'
        #     method = 'Newton-CG'
        #     method = 'BFGS'
        # Use one of the other params the startin gpoing
        a1 = list(fixed.values())[0]
        result = scipy.optimize.minimize(func, x0=a1, method=method, bounds=bounds)
        if not result.success:
            print('\n')
            print(result)
            print('\n')
        return result

    # Numeric measurments of thie line

    thresh_vals = [.001, .01, .05, .1, .135]
    svals = np.arange(1, 100)

    target_poisson_plots = {}
    for target in ut.ProgIter(thresh_vals, bs=False, freq=1):
        poisson_avals = []
        for sval in ut.ProgIter(svals, 'poisson', freq=1):
            expr = poisson_thresh
            fixed = {s: sval}
            want = a
            aval = solve_numeric(expr, target, want, fixed,
                                 method='Nelder-Mead').x[0]
            poisson_avals.append(aval)
        target_poisson_plots[target] = (svals, poisson_avals)

    fig = pt.figure(fnum=3)
    for target, dat in target_poisson_plots.items():
        pt.plt.plot(*dat, label='prob={}'.format(target))
    pt.gca().set_xlabel('s')
    pt.gca().set_ylabel('a')
    pt.legend()
    pt.gca().set_title('poisson')
    fig.set_size_inches(5, 3)
    fig.savefig('a-vs-s-poisson.png', dpi=300, bbox_inches=pt.extract_axes_extents(fig, combine=True))

    target_binom_plots = {}
    for target in ut.ProgIter(thresh_vals, bs=False, freq=1):
        binom_avals = []
        for sval in ut.ProgIter(svals, 'binom', freq=1):
            aval = solve_numeric(binom_thresh, target, a, {s: sval}, method='Nelder-Mead').x[0]
            binom_avals.append(aval)
        target_binom_plots[target] = (svals, binom_avals)

    fig = pt.figure(fnum=4)
    for target, dat in target_binom_plots.items():
        pt.plt.plot(*dat, label='prob={}'.format(target))
    pt.gca().set_xlabel('s')
    pt.gca().set_ylabel('a')
    pt.legend()
    pt.gca().set_title('binom')
    fig.set_size_inches(5, 3)
    fig.savefig('a-vs-s-binom.png', dpi=300, bbox_inches=pt.extract_axes_extents(fig, combine=True))

    # ----
    if True:

        fig = pt.figure(fnum=5, doclf=True)
        s_vals = [1, 2, 3, 10, 20, 30, 40, 50]
        for sval in s_vals:
            pp = poisson_thresh.subs({s: sval})

            a_vals = np.arange(0, 200)
            pp_vals = np.array([float(pp.subs({a: aval}).evalf()) for aval in a_vals])  # NOQA

            pt.plot(a_vals, pp_vals, label='s=%r' % (sval,))
        pt.legend()
        pt.gca().set_xlabel('a')
        pt.gca().set_ylabel('poisson prob after a reviews')
        fig.set_size_inches(5, 3)
        fig.savefig('a-vs-thresh-poisson.png', dpi=300, bbox_inches=pt.extract_axes_extents(fig, combine=True))

        fig = pt.figure(fnum=6, doclf=True)
        s_vals = [1, 2, 3, 10, 20, 30, 40, 50]
        for sval in s_vals:
            pp = binom_thresh.subs({s: sval})
            a_vals = np.arange(0, 200)
            pp_vals = np.array([float(pp.subs({a: aval}).evalf()) for aval in a_vals])  # NOQA
            pt.plot(a_vals, pp_vals, label='s=%r' % (sval,))
        pt.legend()
        pt.gca().set_xlabel('a')
        pt.gca().set_ylabel('binom prob after a reviews')
        fig.set_size_inches(5, 3)
        fig.savefig('a-vs-thresh-binom.png', dpi=300, bbox_inches=pt.extract_axes_extents(fig, combine=True))

        # -------

        fig = pt.figure(fnum=5, doclf=True)
        a_vals = [1, 2, 3, 10, 20, 30, 40, 50]
        for aval in a_vals:
            pp = poisson_thresh.subs({a: aval})
            s_vals = np.arange(1, 200)
            pp_vals = np.array([float(pp.subs({s: sval}).evalf()) for sval in s_vals])  # NOQA
            pt.plot(s_vals, pp_vals, label='a=%r' % (aval,))
        pt.legend()
        pt.gca().set_xlabel('s')
        pt.gca().set_ylabel('poisson prob')
        fig.set_size_inches(5, 3)
        fig.savefig('s-vs-thresh-poisson.png', dpi=300, bbox_inches=pt.extract_axes_extents(fig, combine=True))

        fig = pt.figure(fnum=5, doclf=True)
        a_vals = [1, 2, 3, 10, 20, 30, 40, 50]
        for aval in a_vals:
            pp = binom_thresh.subs({a: aval})
            s_vals = np.arange(1, 200)
            pp_vals = np.array([float(pp.subs({s: sval}).evalf()) for sval in s_vals])  # NOQA
            pt.plot(s_vals, pp_vals, label='a=%r' % (aval,))
        pt.legend()
        pt.gca().set_xlabel('s')
        pt.gca().set_ylabel('binom prob')
        fig.set_size_inches(5, 3)
        fig.savefig('s-vs-thresh-binom.png', dpi=300, bbox_inches=pt.extract_axes_extents(fig, combine=True))

    #---------------------
    # Plot out a table

    mu_i.subs({s: 75, a: 75}).evalf()
    poisson_thresh.subs({s: 75, a: 75}).evalf()

    sval = 50
    for target, dat in target_poisson_plots.items():
        slope = np.median(np.diff(dat[1]))
        aval = int(np.ceil(sval * slope))
        thresh = float(poisson_thresh.subs({s: sval, a: aval}).evalf())
        print('aval={}, sval={}, thresh={}, target={}'.format(aval, sval, thresh, target))

    for target, dat in target_binom_plots.items():
        slope = np.median(np.diff(dat[1]))
        aval = int(np.ceil(sval * slope))
from sympy import Symbol, Limit
from sympy import Symbol, exp, sqrt, pi, Integral
from sympy import pprint

# video1

t = Symbol('t')
St = 5 * t**2 + 2 * t + 8

t1 = Symbol('t1')
delta_t = Symbol('delta_t')

St1 = St.subs({t: t1})
St1_delta = St.subs({t: t1 + delta_t})

Limit((St1_delta - St1) / delta_t, delta_t, 0).doit()

# video2

x = Symbol('x')
p = exp(-(x - 10)**2 / 2) / sqrt(2 * pi)
pprint(Integral(p, (x, 11, 12)).doit().evalf())
def derivative(f, var):
    var = Symbol(var)
    d = Derivative(f, var).doit(
    )  # Define a function(f) and a variable(var) to differentiate
    pprint(d)
Esempio n. 49
0
    return f.diff(x, 2) + f.diff(y, 2)


r = sqrt(x**2 + y**2)
r_w = sqrt((x - x_w)**2 + (y - y_w)**2)
r_p_squared = (x - x_p)**2 + (y - y_p)**2
theta = atan(y / x)
u = r**(pi / omega) * sin(theta * pi / omega) + atan(
    alpha_w *
    (r_w - r0)) + exp(-alpha_p * r_p_squared) + exp(-(1 + y) / epsilon)
params = {
    omega: 3 * pi / 2,
    x_w: 0,
    y_w: -S(3) / 4,
    r0: S(3) / 4,
    alpha_p: 1000,
    alpha_w: 200,
    x_p: sqrt(5) / 4,
    y_p: -S(1) / 4,
    epsilon: S(1) / 100,
}
u = u.subs(params)
lhs = laplace(u)

print "lhs, as a formula:"
pprint(lhs)
print
print "-" * 60
print "lhs, as C code:"
print ccode(lhs)
Esempio n. 50
0
#!/usr/bin/env python

# Prerequisites: have sympy installed (or use Anaconda)
import sympy

# from math import tan
from sympy.solvers.solveset import nonlinsolve
from sympy.core.symbol import symbols
from sympy import tan, pprint

x1, y1, doa_1, theta_1 = symbols('x1, y1, doa1, theta1', real=True)
x2, y2, doa_2, theta_2 = symbols('x2, y2, doa2, theta2', real=True)
x3, y3, doa_3, theta_3 = symbols('x3, y3, doa3, theta3', real=True)
xr, yr, theta_r = symbols('xr, yr, theta_r', real=True)

# eq1 = doa_1 + theta_r - theta_1 # theta 1 = theta_r + doa_1
# eq2 = doa_2 + theta_r - theta_2 # theta 2 = theta_r + doa_2
# eq3 = doa_3 + theta_r - theta_3 # theta 3 = theta_r + doa_3
# eq4 = (y1 - yr) / (x1 - xr) - tan(theta_1)
# eq5 = (y2 - yr) / (x2 - xr) - tan(theta_2)
# eq6 = (y3 - yr) / (x3 - xr) - tan(theta_3)

eq1 = (y1 - yr) / (x1 - xr) - tan(doa_1 + theta_r)
eq2 = (y2 - yr) / (x2 - xr) - tan(doa_2 + theta_r)
eq3 = (y3 - yr) / (x3 - xr) - tan(doa_3 + theta_r)

result = nonlinsolve([eq1, eq2, eq3], [xr, yr, theta_r])

pprint(result, use_unicode=True)
Esempio n. 51
0
                 [ C1, C2, C3, C4 ])

# %% Se reemplaza aquí el valor de las constantes de integración
V = V.subs(sol)
M = M.subs(sol)
t = t.subs(sol)
v = v.subs(sol)

# %% Se simplifica lo calculado por sympy
V = sp.piecewise_fold(V.rewrite(sp.Piecewise)).nsimplify()
M = sp.piecewise_fold(M.rewrite(sp.Piecewise)).nsimplify()
t = sp.piecewise_fold(t.rewrite(sp.Piecewise))
v = sp.piecewise_fold(v.rewrite(sp.Piecewise))

# %% Se imprimen los resultados 
print("\n\nV(x) = "); sp.pprint(V)
print("\n\nM(x) = "); sp.pprint(M)
print("\n\nt(x) = "); sp.pprint(t)
print("\n\nv(x) = "); sp.pprint(v)

# %% Se grafican los resultados 
x_xmin_xmax = (x, 0+0.001, 6-0.001)
sp.plot(V, x_xmin_xmax, xlabel='x', ylabel='V(x)')
sp.plot(M, x_xmin_xmax, xlabel='x', ylabel='M(x)')
sp.plot(t, x_xmin_xmax, xlabel='x', ylabel='t(x)')
sp.plot(v, x_xmin_xmax, xlabel='x', ylabel='v(x)')

# %% Se calculan las reacciones en la viga 
print(f"Fy(x=0) = {float(+V.subs(sol).subs(x, 0))}") # Ry en x=0 
print(f"Fy(x=6) = {float(-V.subs(sol).subs(x, 6))}") # Ry en x=6 
Esempio n. 52
0
from sympy import symbols, solve, diff, pprint, integrate

# After a long​ study, tree scientists conclude that a eucalyptus tree will grow at the rate of

t = symbols('t')
R = 0.5 + 4 / (t + 1)**3
#  feet per​ year, where t is the time​ (in years).
pprint(R)

# Find the number of feet that the tree will grow in the second year.
a, b = 1, 2
round(integrate(R, (t, a, b)), 3)  # Round to three decimal places as​ needed.

# Find the number of feet that the tree will grow in the second year.
a, b = 2, 3
round(integrate(R, (t, a, b)), 3)  # Round to three decimal places as​ needed.
Esempio n. 53
0
X3_s_step_G_theta = G_theta * F_s_step
x3_t_step_G_theta = sym.inverse_laplace_transform(X3_s_step_G_theta, s, t)

X3_s_frequency_G_theta = G_theta * F_s_frequency
x3_t_frequency_G_theta = sym.inverse_laplace_transform(X3_s_frequency_G_theta,
                                                       s, t, w)

X1_s_impulse_G_x = G_x * F_s_impulse
x1_t_impulse_G_x = sym.inverse_laplace_transform(X1_s_impulse_G_x, s, t)

X1_s_step_G_x = G_x * F_s_step
x1_t_step_G_x = sym.inverse_laplace_transform(X1_s_step_G_x, s, t)

X1_s_frequency_G_x = G_x * F_s_frequency
x1_t_frequency_G_x = sym.inverse_laplace_transform(X1_s_frequency_G_x, s, t, w)

# Print the symbolic expressions
#sym.pprint(x3_t_impulse_G_theta.simplify())
#sym.pprint(x3_t_step_G_theta.simplify())
sym.pprint(x3_t_frequency_G_theta.simplify())
#sym.pprint(x1_t_impulse_G_x.simplify())
#sym.pprint(x1_t_step_G_x.simplify())
#sym.pprint(x1_t_frequency_G_x.simplify())

# Print the symbolic expressions for LaTex
#print(sym.latex(x3_t_impulse_G_theta.simplify()))
#print(sym.latex(x3_t_step_G_theta.simplify()))
#print(sym.latex(x3_t_frequency_G_theta.simplify()))
#print(sym.latex(x1_t_impulse_G_x.simplify()))
#print(sym.latex(x1_t_step_G_x.simplify()))
#print(sym.latex(x1_t_frequency_G_x.simplify()))
Esempio n. 54
0
def SARIMAEquation(trendparams:tuple=(0,0,0), seasonalparams:tuple=(0,0,0,1), trendAR=None, trendMA=None, seasonAR=None, seasonMA=None):
    p, d, q = trendparams
    P, D, Q, m = seasonalparams
    print(f'SARIMA({p},{d},{q})({P},{D},{Q},{m})')

    assert type(p) is int, 'Input parameter "p" is not an integer type.'
    assert type(d) is int, 'Input parameter "d" is not an integer type.'
    assert type(q) is int, 'Input parameter "q" is not an integer type.'
    assert type(P) is int, 'Input parameter "P" is not an integer type.'
    assert type(D) is int, 'Input parameter "D" is not an integer type.'
    assert type(Q) is int, 'Input parameter "Q" is not an integer type.'
    assert type(m) is int, 'Input parameter "m" is not an integer type.'

    if trendAR : assert len(trendAR) == p, f'The len(trendAR) must be {p}. Reset the parameters.'
    else : trendAR = [0]*p
    if trendMA : assert len(trendMA) == q, f'The len(trendMA) must be {q}. Reset the parameters.'
    else : trendMA = [0]*q
    if seasonAR : assert len(seasonAR) == P, f'The len(seasonAR) must be {P}. Reset the parameters.'
    else : seasonAR = [0]*P
    if seasonMA : assert len(seasonMA) == Q, f'The len(seasonMA) must be {Q}. Reset the parameters.'
    else : seasonMA = [0]*Q


    Y_order = p + P*m + d + D*m
    e_order = q + Q*m

    # define Y, e
    Y, e = sympy.symbols('Y_t, e_t')
    I, J = sympy.symbols('i, j')
    Y_ = {}; e_ = {}
    Y_['t'] = Y; Y__ = [ [Y_['t']] ]
    e_['t'] = e; e__ = [ [e_['t']] ]
    for i in range(1, Y_order+1):
        Y_[f't-{i}'] = sympy.symbols(f'Y_t-{i}')
        Y__.append( [Y_[f't-{i}']*(I**i)] )    # Y__ = [ [Y_['t']], [Y_['t-1']], ..., [Y_['t-(p+P*m+q+Q*m)']] ]
    for i in range(1, e_order+1):   
        e_[f't-{i}'] = sympy.symbols(f'e_t-{i}')
        e__.append( [e_[f't-{i}']*(J**i)] )    # e__ = [ [e_['t']], [e_['t-1']], ..., [e_['t-(q+Q*m)']] ]

    # define L
    L = sympy.symbols('L')
    S_Lag = L**m
    T_Lag = L
    S_Lag_Diff = (1-L**m)**D
    T_Lag_Diff = (1-L)**d

    # define coefficients : phis(T), Phis(S), thetas(T), Thetas(S)
    T_phi = {}; T_phis = []; L_byT_phi = []
    S_phi = {}; S_phis = []; L_byS_phi = []
    T_theta = {}; T_thetas = []; L_byT_theta = []
    S_theta = {}; S_thetas = []; L_byS_theta = []

    for p_ in range(0, p+1):
        T_phi[p_] = sympy.symbols(f'phi_{p_}')
        T_phis.append(-T_phi[p_])       # T_phis      = [T_phi[0], T_phi[1], ..., T_phi[p]]
        L_byT_phi.append([T_Lag**p_])   # L_byT_phi   = [[L**0], [L**1], ..., [L**p]]
    for P_ in range(0, P+1):
        S_phi[P_] = sympy.symbols(f'Phi_{P_}')
        S_phis.append(-S_phi[P_])       # S_phis      = [S_phi[0], S_phi[1], ..., S_phi[P]]
        L_byS_phi.append([S_Lag**P_])   # L_byS_phi   = [[(L**m)**0], [(L**m)**1], ..., [(L**m)**P]]
    for q_ in range(0, q+1):
        T_theta[q_] = sympy.symbols(f'theta_{q_}')
        T_thetas.append(T_theta[q_])    # T_thetas    = [T_theta[0], T_theta[1], ..., T_theta[q]]
        L_byT_theta.append([T_Lag**q_]) # L_byT_theta = [[L**0], [L**1], ..., [L**q]]
    for Q_ in range(0, Q+1):
        S_theta[Q_] = sympy.symbols(f'Theta_{Q_}')
        S_thetas.append(S_theta[Q_])    # S_thetas    = [T_theta[0], T_theta[1], ..., T_theta[Q]]
        L_byS_theta.append([S_Lag**Q_]) # L_byS_theta = [[(L**m)**0], [(L**m)**1], ..., [(L**m)**Q]]

    T_phi_Lag = sympy.Matrix([T_phis]) * sympy.Matrix(L_byT_phi)
    S_phi_Lag = sympy.Matrix([S_phis]) * sympy.Matrix(L_byS_phi)
    T_theta_Lag = sympy.Matrix([T_thetas]) * sympy.Matrix(L_byT_theta)
    S_theta_Lag = sympy.Matrix([S_thetas]) * sympy.Matrix(L_byS_theta)

    Y_operator = (T_phi_Lag * S_phi_Lag * T_Lag_Diff * S_Lag_Diff).subs(T_phi[0], -1).subs(S_phi[0], -1)[0]
    e_operator = (T_theta_Lag * S_theta_Lag).subs(T_theta[0], 1).subs(S_theta[0], 1)[0]

    Y_operation = sympy.collect(Y_operator.expand(), L)
    e_operation = sympy.collect(e_operator.expand(), L)

    Y_coeff = sympy.Poly(Y_operation, L).all_coeffs()[::-1]
    e_coeff = sympy.Poly(e_operation, L).all_coeffs()[::-1]

    Y_term = sympy.Matrix([Y_coeff]) * sympy.Matrix(Y__) # left-side
    e_term = sympy.Matrix([e_coeff]) * sympy.Matrix(e__) # right-side
    
    Time_Series = {}
    Time_Series['Y_t(i,j)'] = sympy.Poly(Y - Y_term[0] + e_term[0], (I,J))
    Time_Series['Y_t'] = Time_Series['Y_t(i,j)'].subs(I, 1).subs(J, 1)
    for i in range(1, int(p+P*m+d+D*m)+1):
        Time_Series['Y_t'] = sympy.collect(Time_Series['Y_t'], Y_[f't-{i}']).simplify()
    for i in range(1, int(q+Q*m)+1):
        Time_Series['Y_t'] = sympy.collect(Time_Series['Y_t'], e_[f't-{i}']).simplify()
    print('* Time Series Equation(Analytic Form)')
    sympy.pprint(Time_Series['Y_t']); print()

    Time_Series['Analytic_Coeff_of_Y'] = Time_Series['Y_t(i,j)'].subs(J, 0).all_coeffs()[::-1]
    Time_Series['Analytic_Coeff_of_e'] = Time_Series['Y_t(i,j)'].subs(I, 0).all_coeffs()[::-1]

    Time_Series['Numeric_Coeff_of_Y'] = Time_Series['Y_t(i,j)'].subs(J, 0) - e_['t']
    Time_Series['Numeric_Coeff_of_e'] = Time_Series['Y_t(i,j)'].subs(I, 0)
    for i, (phi, Np) in enumerate(zip(list(T_phi.values())[1:], trendAR)):
        Time_Series['Numeric_Coeff_of_Y'] = Time_Series['Numeric_Coeff_of_Y'].subs(phi, Np)
    for i, (Phi, NP) in enumerate(zip(list(S_phi.values())[1:], seasonAR)):
        Time_Series['Numeric_Coeff_of_Y'] = Time_Series['Numeric_Coeff_of_Y'].subs(Phi, NP)
    for i, (theta, Nt) in enumerate(zip(list(T_theta.values())[1:], trendMA)):
        Time_Series['Numeric_Coeff_of_e'] = Time_Series['Numeric_Coeff_of_e'].subs(theta, Nt)
    for i, (Theta, NT) in enumerate(zip(list(S_theta.values())[1:], seasonMA)):
        Time_Series['Numeric_Coeff_of_e'] = Time_Series['Numeric_Coeff_of_e'].subs(Theta, NT)
    print('* Time Series Equation(Numeric Form)')
    sympy.pprint((Time_Series['Numeric_Coeff_of_Y'] + Time_Series['Numeric_Coeff_of_e']).subs(I, 1).subs(J, 1))
    Time_Series['Numeric_Coeff_of_Y'] = sympy.Poly(Time_Series['Numeric_Coeff_of_Y'], I).all_coeffs()[::-1]
    Time_Series['Numeric_Coeff_of_e'] = sympy.Poly(Time_Series['Numeric_Coeff_of_e'], J).all_coeffs()[::-1]

    final_coeffs = [[], []]
    print('\n* Y params')
    print(f'- TAR({trendparams[0]}) phi : {trendAR}')
    print(f'- TMA({trendparams[2]}) theta : {trendMA}')
    for i, (A_coeff_Y, N_coeff_Y) in enumerate(zip(Time_Series['Analytic_Coeff_of_Y'], Time_Series['Numeric_Coeff_of_Y'])):
        if i == 0:
            pass
        elif i != 0:                
            A_coeff_Y = A_coeff_Y.subs(Y_[f"t-{i}"], 1)
            N_coeff_Y = N_coeff_Y.subs(Y_[f"t-{i}"], 1)
            print(f't-{i} : {A_coeff_Y} > {round(N_coeff_Y, 5)}')
            final_coeffs[0].append(N_coeff_Y)

    print('\n* e params')
    print(f'- SAR({seasonalparams[0]}) Phi : {seasonAR}')
    print(f'- SMA({seasonalparams[2]}) Theta : {seasonMA}')
    for i, (A_coeff_e, N_coeff_e) in enumerate(zip(Time_Series['Analytic_Coeff_of_e'], Time_Series['Numeric_Coeff_of_e'])):
        if i == 0:
            A_coeff_e = A_coeff_e.subs(e_[f"t"], 1)
            N_coeff_e = N_coeff_e.subs(e_[f"t"], 1)
            print(f't-{i} : {A_coeff_e} > {1}')

        elif i != 0:                
            A_coeff_e = A_coeff_e.subs(e_[f"t-{i}"], 1)
            N_coeff_e = N_coeff_e.subs(e_[f"t-{i}"], 1)
            print(f't-{i} : {A_coeff_e} > {round(N_coeff_e, 5)}')
            final_coeffs[1].append(N_coeff_e)

    print('\n* Convergence Factor')
    try:
        print('Y :', sympy.tensorcontraction(sympy.Array(final_coeffs[0]).applyfunc(lambda x: x**2), (0,)))
        print('e :', sympy.tensorcontraction(sympy.Array(final_coeffs[1]).applyfunc(lambda x: x**2), (0,)))
    except:
        pass
    
    #Time_Series['Y_t']
    """
    Y_t = (~)*Y_t-1 + ... + 1*e_t + (~)*e_t-1 + ...
    final_coeffs[0] : coeff[Y_t-1, Y_t-2, ...]
    final_coeffs[1] : coeff[e_t-1, e_t-2, ...]
    """
    return final_coeffs
# The equilibrium points
F0 = 0
x30 = 0
x40 = 0

# Substitute symbols with equilibrium points
phi_deriv_F_at_equlibrium = phi_deriv_F.subs([(F, F0), (x3, x30), (x4, x40)])
phi_deriv_x3_at_equlibrium = phi_deriv_x3.subs([(F, F0), (x3, x30), (x4, x40)])
phi_deriv_x4_at_equlibrium = phi_deriv_x4.subs([(F, F0), (x3, x30), (x4, x40)])

psi_deriv_F_at_equlibrium = psi_deriv_F.subs([(F, F0), (x3, x30), (x4, x40)])
psi_deriv_x3_at_equlibrium = psi_deriv_x3.subs([(F, F0), (x3, x30), (x4, x40)])
psi_deriv_x4_at_equlibrium = psi_deriv_x4.subs([(F, F0), (x3, x30), (x4, x40)])

# Print the partial derivatives
sym.pprint(phi_deriv_F_at_equlibrium)
sym.pprint(phi_deriv_x3_at_equlibrium)
sym.pprint(phi_deriv_x4_at_equlibrium)
sym.pprint(psi_deriv_F_at_equlibrium)
sym.pprint(psi_deriv_x3_at_equlibrium)
sym.pprint(psi_deriv_x4_at_equlibrium)

# Print the equations for LaTex
print(sym.latex(phi))
print(sym.latex(psi))
print(sym.latex(phi_deriv_F_at_equlibrium))
print(sym.latex(phi_deriv_x3_at_equlibrium))
print(sym.latex(phi_deriv_x4_at_equlibrium))
print(sym.latex(psi_deriv_F_at_equlibrium))
print(sym.latex(psi_deriv_x3_at_equlibrium))
print(sym.latex(psi_deriv_x4_at_equlibrium))
import sympy as sym
from sympy import Symbol
from sympy import pprint
# %matplotlib inline --> *for pycharm, use plt.show*
import matplotlib as mpl
import sympy.plotting as syp

sigma = Symbol('sigma')
mu = Symbol('mu')
x = Symbol('x')
part1 = 1 / (sym.sqrt(2 * sym.pi * sigma**2))
part2 = sym.exp(-1 * ((x - mu)**2) / (2 * sigma**2))
my_gaussfunction = part1 * part2
pprint(my_gaussfunction)

syp.plot(my_gaussfunction.subs({
    mu: 10,
    sigma: 30
}), (x, -100, 100),
         title='gauss distribution')

x_values = []
y_values = []

for value in range(-5, 5):
    y = my_gaussfunction.subs({mu: 10, sigma: 30, x: value}).evalf()
    y_values.append(y)
    x_values.append(value)
    print(value, y)

import matplotlib.pyplot as plt
Esempio n. 57
0
def eq4():
    r = Symbol("r")
    e = Rmn.dd(3,3)
    e = e.subs(nu(r), -lam(r))
    pprint(dsolve(e, lam(r)))
    pprint(dsolve(e, lam(r), 'best'))
Esempio n. 58
0
File: demo.py Progetto: spirali/nife
import nife
import sympy as sp

sp.init_printing()

triangle = nife.Polygon([sp.Point(0, 0), sp.Point(0, 1), sp.Point(1, 0)])
fn = nife.Function(sp.sympify("a*x + b*y + c"), sp.sympify("x, y"))

# V rozich
exprs = [fn.eval_point(p) for p in triangle.points]
sp.pprint(nife.make_shape_functions(fn, exprs))

# Integral pres hranu
exprs = [fn.line_itegrate(nife.segment_to_curve(e)) for e in triangle.edges]
sp.pprint(nife.make_shape_functions(fn, exprs))

# RT
phi = nife.Function(sp.Matrix(sp.sympify("a*x + b, a*y + c")),
                    sp.sympify("x, y"))

exprs = [sp.line_integrate(phi.expression.dot(nife.unit_normal(e)),
                           nife.segment_to_curve(e),
                           phi.vars)
         for e in triangle.edges]
sp.pprint(nife.make_shape_functions(phi, exprs))
Esempio n. 59
0
import sympy
from sympy import Symbol
from sympy import pprint
import sympy as sym
import sympy.plotting as syp
import sympy as sy
import matplotlib.pyplot as plt

sigma = Symbol('sigma')
mu = Symbol('mu')
x = Symbol('x')
part_1 = 1/(sym.sqrt(2*sym.pi*sigma*sigma))
part_2 = sym.exp(-1*((x-mu)**2)/(2*sigma**2))
my_gauss_function = part_1*part_2
print(pprint(my_gauss_function))

print(syp.plot(my_gauss_function.subs({mu:1,sigma:3}), (x, -10, 10), title='gauss'))

x_values = []
y_values = []
for value in range(-50,50):
    y = my_gauss_function.subs({mu:0,sigma:10,x:value}).evalf()
    y_values.append(y)
    x_values.append(value)
    print(value,y)

plt.plot(x_values,y_values)
Esempio n. 60
0
import sympy as sym
from sympy import Symbol
from sympy import pprint

p = Symbol('p')
x = Symbol('x')
n = Symbol('n')

my_f_3_part_0 = sym.factorial(n) / sym.factorial(x) * sym.factorial(n - x)

pprint(my_f_3_part_0)

my_f_3_part_1 = p**x

pprint(my_f_3_part_1)

my_f_3_part_2 = (1 - p)**(n - x)

pprint(my_f_3_part_2)

my_f_3 = my_f_3_part_0 * my_f_3_part_1 * my_f_3_part_2
pprint(my_f_3)

sym.plot(my_f_3.sub({
    p: 0.5,
    n: 50
}), (x, 0, 50),
         title='binomin distribution for n= 50')