Esempio n. 1
0
async def graph(client, message):
    args = message.command
    try:
        if "arg" not in args:
            return  # nothing to plot
        await client.send_chat_action(message.chat.id, "upload_document")
        expr = args["arg"]
        logger.info(f"Plotting \'{expr}\'")
        eq = []
        for a in expr.split(", "):
            eq.append(parse_expr(a).simplify())

        if "-3d" in args["flags"]:
            plot3d(*eq, show=False).save("graph.png")
        else:
            plot(*eq, show=False).save("graph.png")

        await client.send_photo(message.chat.id,
                                "graph.png",
                                reply_to_message_id=message.message_id,
                                caption=f"` → {eq} `")
    except Exception as e:
        traceback.print_exc()
        await edit_or_reply(message, "`[!] → ` " + str(e))
    await client.send_chat_action(message.chat.id, "cancel")
    await client.set_offline()
Esempio n. 2
0
def da_solver(DA_type):
    import sympy
    #Currently LDA is definitely broken.
    #A bug was introduced when I was refactoring
    if (DA_type == 'LDA'):
        lhs_inv_cov = invcovall
        lhs_det = sympy.Matrix([0])
        rhs_inv_cov = invcovall
        rhs_det = sympy.Matrix([0])
    if (DA_type == 'QDA'):
        lhs_inv_cov = invcov1
        lhs_det = sympy.Matrix([np.log(np.sqrt(1 / detcov1))])
        rhs_inv_cov = invcov2
        rhs_det = sympy.Matrix([np.log(np.sqrt(1 / detcov2))])

    sympy.var('y0')
    sympy.var('x0')
    cept_mat = sympy.Matrix([x0 - x1_mean, y0 - y1_mean])
    lhs_inv_cov = sympy.Matrix(lhs_inv_cov)
    LHS = ((cept_mat.T).multiply(lhs_inv_cov)).multiply(cept_mat)

    cept_mat = sympy.Matrix([x0 - x2_mean, y0 - y2_mean])
    rhs_inv_cov = sympy.Matrix(rhs_inv_cov)
    RHS = ((cept_mat.T).multiply(rhs_inv_cov)).multiply(cept_mat)

    equation = (LHS - RHS)
    if (DA_type == 'QDA'):
        s1p = sympy.plot_implicit((equation[0]) > 0)
    if (DA_type == 'LDA'):
        solution = sympy.solve(equation[0], y0)
        sympy.plot(solution[0][y0])
    return equation
Esempio n. 3
0
    def animate(ti):
        p = sym.plot(x.subs(t, tau), (tau, taud[0], taud[-1]), show=False)
        line_x.set_segments(p[0].get_segments())

        p = sym.plot(h.subs(t, t - tau).subs(t, ti), (tau, taud[0], taud[-1]),
                     show=False)
        line_h.set_segments(p[0].get_segments())

        p = sym.plot(y, (t, taud[0], taud[-1]), show=False)
        line_y.set_segments(p[0].get_segments())

        p = sym.plot(x.subs(t, tau) * h.subs(t, ti - tau), (tau, -5, 5),
                     show=False)
        
        # see https://github.com/sympy/sympy/issues/21392
        #points = np.array(p[0].get_points())
        # alternative via lambdify
        func = sym.lambdify(tau, x.subs(t, tau) * h.subs(t, ti - tau), modules=['numpy', {'Heaviside':my_heaviside}])
        tt = np.linspace(-5,5,100)
        points = np.vstack((tt, np.asarray(func(tt))))
        
        verts = [[(xi[0], xi[1]) for xi in points.T]]
        fill.set_verts(verts)
        
        dot.set_data(ti, y.subs(t, ti))
Esempio n. 4
0
def metoda_najmniejszych_kwadratow(polynomial_degree, *points):
    y_matrix = Matrix([[]])
    x_matrix = Matrix([[]])

    for point in points:
        y_matrix = y_matrix.col_join(Matrix([[point[1]]]))
        auxiliary = Matrix([[]])
        for i in range(polynomial_degree + 1):
            auxiliary = auxiliary.row_join(Matrix([[point[0]**i]]))
        x_matrix = x_matrix.col_join(auxiliary)

    x_transposed = x_matrix.T
    x_transposed_times_x = x_transposed * x_matrix
    if x_transposed_times_x.det() == 0:
        print(
            "Macierz X^T * X ma wyznacznik równy 0, nie jest więc odwracalna.")
        return
    b_matrix = x_transposed_times_x**-1 * x_transposed * y_matrix
    x, y = symbols("x, y")
    polynomial_formula_matrix = Matrix([[]])
    for i in range(polynomial_degree + 1):
        polynomial_formula_matrix = polynomial_formula_matrix.row_join(
            Matrix([[x**i]]))
    polynomial_formula_matrix = polynomial_formula_matrix * b_matrix
    print("y = " + str(simplify(polynomial_formula_matrix[0, 0])) + "\n")
    # for plotting to work the Python interpreter must have matplotlib available for use
    # otherwise SymPy will use TextBackend library for plotting which does not work whatsoever
    if matplotlib_is_available:
        plot(polynomial_formula_matrix[0, 0])
Esempio n. 5
0
def serie_potencias_graficar(fn, a, ns, f0):
    # funcion, variable, suma
    f, x, g = sp.symbols('f,x,g')

    f = fn

    L = sp.plot(f, (x, -1, 1), ylim=(0.5, -6), show=False, legend=True)
    L.label = '$f$'

    for n in ns:
        g = sp.diff(f, x, 0).subs(x, a) / sp.factorial(0) * ((x - a) ** 0)
        conTerminos = 0
        i = 1
        # sumatoria en for dependiendo del número de terminos
        # Se itera en base al número de términos que sean VALIDOS
        while conTerminos <= n - 1:
            termino_nuevo = sp.diff(f, x, i).subs(x, a) / sp.factorial(i) * ((x - a) ** i)
            termino_nuevo_ev = termino_nuevo.evalf(subs={x: f0})
            # print(termino_nuevo_ev)
            if (termino_nuevo_ev != 0):
                conTerminos += 1
                g += termino_nuevo
            i += 1

        M = sp.plot(g, (x, -1, 1), ylim=(0.5, -6), show=False, legend=True)
        M[0].label = 'n={}'.format(n)
        ##color random
        r = lambda: random.randint(0, 255)
        color = '#%02X%02X%02X' % (r(), r(), r())
        M[0].line_color = color

        L.append(M[0])

    L.show()
def falsi():
    x = symbols('x')
    f = x ** 3 + x - 1
    func = lambdify(x, f)
    a = -1
    b = 1
    tol = 0.000001

    xc = (b * func(a) - a * func(b)) / (func(a) - func(b))
    while b - a > tol:
        f_xc = func(xc)
        if f_xc == 0:
            break
        else:
            f_a = func(a)
            f_b = func(b)
            if (f_a * f_xc) < 0:
                b = xc
            else:
                a = xc
        xc = (b * f_a - a * f_b) / (f_a - f_b)

    # 输出结果并打印函数图像
    print("方程[ %s = 0 ]在误差范围为(%f)的近似解为x = %f" % (f, tol, xc))
    plot(f, (x, -1, 1))
Esempio n. 7
0
async def graph_cmd(client, message):
    """plot provided function

	This command will run sympy `plot` and return result as image.
	You can add the `-3d` argument to plot in 3d (pass functions with 3 variables!)
	"""
    if len(message.command) < 1:
        return await edit_or_reply(message, "`[!] → ` No input")
    prog = ProgressChatAction(client,
                              message.chat.id,
                              action="upload_document")
    expr = message.command.text
    eq = []
    for a in expr.split(", "):
        eq.append(parse_expr(a).simplify())

    if message.command["-3d"]:
        plot3d(*eq, show=False).save("graph.png")
    else:
        plot(*eq, show=False).save("graph.png")

    await client.send_photo(message.chat.id,
                            "graph.png",
                            reply_to_message_id=message.message_id,
                            caption=f"` → {eq} `",
                            progress=prog.tick)
Esempio n. 8
0
def DrawFourier(a0, an, bn, wo, t, n, armonicos):
    Ft = an * sym.cos(n * w0 * t) + bn * sym.sin(n * w0 * t)
    j = a0
    for i in range(1, armonicos):

        j += Ft.subs(n, i)

    sym.plot(j)
def serie_potencias_calcular_estimar(fn, a, n, f0):

    #funcion, variable, suma
    f, x, g = sp.symbols('f,x,g')

    f = fn

    L = sp.plot(sp.integrate(f), (x, -1, 1), show=False, legend=True)
    L.label = '$f$'

    error = 10000

    while abs(error) > (10**(-4)):
        g = (sp.diff(f, x, 0).subs(x, a) / sp.factorial(0)) * ((x - a)**0)
        conTerminos = 0
        i = 1
        #sumatoria en for dependiendo del número de terminos
        #Se itera en base al número de términos que sean VALIDOS
        while (conTerminos <= n - 1):
            termino_nuevo = sp.diff(f, x, i).subs(x, a) / sp.factorial(i) * (
                (x - a)**i)
            termino_nuevo_ev = termino_nuevo.evalf(subs={x: f0})
            if (termino_nuevo_ev != 0):
                conTerminos += 1
                g += termino_nuevo
            i += 1

        g_next_diff = sp.diff(f, x, n + 1)

        M = sp.plot(sp.integrate(g), (x, -1, 1), show=False, legend=True)
        M[0].label = 'n={}'.format(n)
        ##color random
        r = lambda: random.randint(0, 255)
        color = '#%02X%02X%02X' % (r(), r(), r())
        M[0].line_color = color
        L.append(M[0])

        g = sp.integrate(g)
        #obtenemos M
        m = get_m(g_next_diff, f0, a)
        #print(m)
        #Calculamos el error absoluto
        error = np.float(((np.float(m)) * ((np.abs(f0 - a))**(n + 1))) /
                         np.math.factorial(n + 1))

        #print(g)
        val_estimado = g.evalf(subs={x: 1.0})
        print(
            f'El valor estimado da igual por la serie para x=pi/60 es igual =  {val_estimado:.8}'
        )
        print(
            f'The absolute error for function {f}, Maclaurin Serie around a={a}, evaluating x={f0:.5}, with {n} terms is {np.float(error):.8}'
        )
        print('\n')
        n += 1
    L.show()
Esempio n. 10
0
def basic_plot():
  p1=plot(g1, rnge, show=False, line_color='b', ylim=(0., 1.))
  p2=plot(g2, rnge, show=False, line_color='g')
  p3=plot(g3, rnge, show=False, line_color='y')
  p4=plot(g4, rnge, show=False, line_color='r')

  p1.extend(p2)
  p1.extend(p3)
  p1.extend(p4)
  return p1
Esempio n. 11
0
def basic_plot():
    p1 = plot(g1, rnge, show=False, line_color='b', ylim=(0., 1.))
    p2 = plot(g2, rnge, show=False, line_color='g')
    p3 = plot(g3, rnge, show=False, line_color='y')
    p4 = plot(g4, rnge, show=False, line_color='r')

    p1.extend(p2)
    p1.extend(p3)
    p1.extend(p4)
    return p1
Esempio n. 12
0
def bisection(eq, x: sym.Symbol, error_bound, graph=False):
	sym.plot(eq)
	low, high = change_x('Enter X bounds that bracket the root: ')
	y_low = eq.subs({x: low})
	y_high = eq.subs({x: high})

	# bounds are symmetric about the x axis, then add a small amount to avoid divide by zero error
	if low * -1 == high:
		low -= 0.0000001

	'''
	True means positive and False is negative.
	This will be used to determine where is the function crosses
	the x axis and changes from positive to negative
	'''
	low_sign = get_sign(y_low)
	high_sign = get_sign(y_high)
	mid = (high + low) / 2
	end = False
	i = 0

	if not low_sign ^ high_sign:
		print("Not a simple root/ Unable to center about a single root")
		end = True

	# stops looping if the root is found or floating point precision becomes significant
	while not end:
		i += 1
		mid = (high + low) / 2
		y_mid = eq.subs({x: mid})
		mid_sign = get_sign(y_mid)

		# if mid and low are on other sides of the x axis
		if mid_sign ^ low_sign:
			high = mid
			error_approx = 100 * (low - mid) / mid
		elif mid_sign ^ high_sign:
			low = mid
			error_approx = 100 * (high - mid) / mid
		else:
			end = True
			error_approx = 0.0

		# 1 x 10^-15 to max out floating point precision

		if abs(error_approx) < error_bound:
			end = True

		if graph:
			sym.plot(eq, xlim=[low, high])
		# print(f"high {high}, low {low}")

	print(f'iteration reached {i} loops. Approximate Error is {error_approx}%')
	return mid
def graph(z):
    e = get_integer(MIN, MAX, '> Lower limit')
    f = get_integer(MIN, MAX, '> Upper limit')
    if not e:
        e = 0
    if not f:
        f = 100
    try:
        sp.plot(z, (x, e, f))
    except:
        input('Invalid data.\n<enter>')
Esempio n. 14
0
    def test_surplus_tax(self):
        """Practice problem 2.3
        """
        sp.var('x p W')
        benefit = et.benefit_from_demand(x, p, 100 - p)
        sp.plot(benefit, (x, 0, 100))

        cons = Consumer(x, p, benefit)
        cons_sub = Consumer(x, p, benefit, other=W - x*p/2)
        self.assertEqual(cons_sub.surplus().subs(p, 50) - cons.surplus().subs(p, 50),
                         1562.5)
Esempio n. 15
0
def DrawFourierDeriv(a0, an, bn, wo, t, n, armonicos):

    anp = bn * n * wo
    bnp = -1 * an * n * wo
    fpt = anp * sym.cos(n * wo * t) + bnp * sym.sin(n * wo * t)
    j = 0
    for i in range(1, armonicos):

        j += fpt.subs(n, i)

    sym.plot(j)
Esempio n. 16
0
 def plotPolyNet(self,
                 ylimits=(-100, 100),
                 xlimits=(x, -10, 10),
                 samplePoints=None):
     if samplePoints == None:
         sp.plot(self.constructedPolynomial, xlimits, ylim=ylimits)
     else:
         sp.plot(self.constructedPolynomial,
                 xlimits,
                 ylim=ylimits,
                 adaptive=False,
                 nb_of_points=samplePoints)
def calc():
    X0, X1 = 1, 1 / s
    W = parse_expr(e1.get())
    Y0 = X0 * W
    Y1 = X1 * W
    y0 = inverse_laplace_transform(Y0, s, t)
    y1 = inverse_laplace_transform(Y1, s, t)
    l2['text'] = y0
    l3['text'] = y1
    p = sp.plot(y0, (t, T_min, T_max), line_color='r', show=False)
    p.extend(sp.plot(y1, (t, T_min, T_max), line_color='g', show=False))
    p.show()
Esempio n. 18
0
def graph(expr):
    """ Try to find good plotting range and plot the graph """

    var = fa.get_variables(expr)

    try:
        [xran, yran] = fpl.find_plot_range(expr)
        sp.plot(expr, (var[0], xran[0], xran[1]),
                axis_center=(0, 0),
                ylim=(yran[0], yran[1]))
    except:
        sp.plot(expr)
Esempio n. 19
0
    def test_surplus_tax(self):
        """Practice problem 2.3
        """
        sp.var('x p W')
        benefit = et.benefit_from_demand(x, p, 100 - p)
        sp.plot(benefit, (x, 0, 100))

        cons = Consumer(x, p, benefit)
        cons_sub = Consumer(x, p, benefit, other=W - x * p / 2)
        self.assertEqual(
            cons_sub.surplus().subs(p, 50) - cons.surplus().subs(p, 50),
            1562.5)
def newtons_method(u):
    error = 1E-12
    xpoints = linspace(-0.99, 0.99, 100)
    ypoints = []
    x = xpoints[0]
    x1 = xpoints[1]
    accuracy = abs(x1 - x)
    while accuracy > error:
        x1 = x - f(x, u)/derivative(x)
        x1 = x
        ypoints.append(x1)

    plot(xpoints, ypoints)
Esempio n. 21
0
def false_pos(eq, z, error_bound):
	# x_temp = x(i+1) , x_new = x(i), x_old = x(i-1)
	sym.plot(eq)
	x_old, x_new = change_x('Enter 2 X bounds that bracket to the root: ')
	y_old = eq.subs({z: x_old})
	y_new = eq.subs({z: x_new})

	end = False
	i = 0

	while not end:
		i += 1
		old_sign = get_sign(y_old)
		new_sign = get_sign(y_new)

		if not (old_sign ^ new_sign):
			print(f"Bounds {x_old} and {x_new} don't bracket the root")
			sys.exit()

		x_temp = x_new - (y_new * (x_old - x_new)) / (y_old - y_new)
		y_temp = eq.subs({z: x_temp})
		temp_sign = get_sign(y_temp)

		# the only difference between secant and false position method is that

		# if temp and old are on other sides of the x axis, the Old stays the same and temp becomes new
		if old_sign ^ temp_sign:
			error_approx = 100 * (x_temp - x_new) / x_temp
			x_new, y_new = x_temp, y_temp

		# if new and temp are on opposite side of the x axis, new become the old, and temp becomes new
		elif new_sign ^ temp_sign:
			error_approx = 100 * (x_temp - x_old) / x_temp
			x_old, y_old = x_new, y_new
			x_new, y_new = x_temp, y_temp

		# bounds don't bracket the root
		else:
			end = True
			print("Not a simple root/ Unable to center about a single root")
			error_approx = 0.0

		# print(f"x_i = {x_new}, and x_i-1 = {x_old}, iterations = {i}")

		# ending at the user specified percent error
		if abs(error_approx) < error_bound:
			end = True
			print(f"approximate error is {abs(error_approx)} % \n iterations = {i}")

	return x_new
def get_simulated_imu_data(t_max, dt, plot=False):

    t_W_B, v_W_B, a_W_B = simulate_pos_vel_acc(0.7, 1.0, .5, 2.0, 1.0, 2.0,
                                               0.7, 1.0, 1.0)

    R_W_B = simulate_rotation_matrix(0.5, 0.05, 0.2, 1.0, 2.0, 1.0, 0.0, 1.0,
                                     4.0)

    B_w_W_B = rotation_rate_from_rotation_matrix(R_W_B)

    if plot:
        # Plot symbolic
        sy.plot(B_w_W_B[0], B_w_W_B[1], B_w_W_B[2], (t, 0, 2.0))
        sy.plotting.plot3d_parametric_line(t_W_B[0], t_W_B[1], t_W_B[2],
                                           (t, 0, 2.0))
        sy.plot(t_W_B[0], v_W_B[0], a_W_B[0], (t, 0, 2.0))
        sy.plot(t_W_B[1], v_W_B[1], a_W_B[1], (t, 0, 2.0))
        sy.plot(t_W_B[2], v_W_B[2], a_W_B[2], (t, 0, 2.0))

    # Evaluate symbolic trajectory for specific time instances
    t_W_B_val, v_W_B_val, a_W_B_val, R_W_B_val, B_w_W_B_val = \
        evaluate_symbolic_trajectory(t_W_B, v_W_B, a_W_B, R_W_B, B_w_W_B, 0.0, t_max, dt)

    # Transform IMU Measurements to body frame, where they are measured.
    n = np.shape(t_W_B_val)[0]
    B_a_W_B = np.zeros((n, 3), dtype=np.float32)
    for i in range(n):
        R_B_W = np.transpose(np.reshape(R_W_B_val[i, :], (3, 3)))
        B_a_W_B[i, :] = np.dot(R_B_W, a_W_B_val[i, :])

    return t_W_B_val, v_W_B_val, R_W_B_val, B_a_W_B, B_w_W_B_val
def save_plots(t1,t2,f,yt,yder,yder2):
    Pf = plot((f,(t,0,t2+1)),title=r"$f(t)$",xlabel="",ylabel="",show=False)  # vypis formulacie
    Py = plot((yt,(t,0,t2+1)),depth=12,title=r"$y(t)$",xlabel="",ylabel="",show=False)
    Pdy  = plot((yder,(t,0,t2+1)),title=r"$y'(t)$",xlabel="",ylabel="",show=False)
    Pddy = plot((yder2,(t,0,t2+1)),sings=[t1,t2],title=r"$y''(t)$",xlabel="",ylabel="",show=False)
    ffn = mkstemp(suffix=".pdf",dir=".")[1]
    yfn = mkstemp(suffix=".pdf",dir=".")[1]
    dyfn  = mkstemp(suffix=".pdf",dir=".")[1]
    ddyfn = mkstemp(suffix=".pdf",dir=".")[1]
    Pf.save(ffn)
    Py.save(yfn)
    Pdy.save(dyfn)
    Pddy.save(ddyfn)
    return ffn, yfn, dyfn, ddyfn
Esempio n. 24
0
def plotSymbolicEq():
    b1, b2, x = symbols('b1 b2 x')

    def calculateRoots():
        roots = solve([
            Eq(90 * 0.05 + 90 * exp(b1 - (b2 * 90)) - 90, 0.0),
            Eq(99 * 0.95 + 99 * exp(b1 - (b2 * 99)) - 99, 0.0)
        ], [b1, b2])
        return roots

    roots = calculateRoots()
    f = x / (x + exp(b1 - b2 * x))
    res = {b1: roots.get(b1), b2: roots.get(b2)}
    plot(f.subs(res), (x, 0, 100))
Esempio n. 25
0
    def retaTangentePonto(self,
                          funcao,
                          coord_x=0.0,
                          coord_y=0.0,
                          show_tangente=False,
                          legenda="f(x)=",
                          plot_eixo_x_limites=(-10, 10),
                          plot_eixo_y_limites=(-10, 10)):
        """Mostra o grafico de uma função, suporta mostrar a reta tangente num ponto (x, y) dadas as coordenadas

        Args:
            funcao (string): Função a mostrar em formato grafico
            coord_x (float, optional): Ponto x da reta tangente. Defaults to 0.0.
            coord_y (float, optional): Ponto y da reta tangente. Defaults to 0.0.
            show_tangente (bool, optional): Mostrar reta tangente da função, True para mostrar, False para omitir. Defaults to False.
            legenda (str, optional): Identificador do tipo de função, exemplos; f(x), f'(x), f''(x), etc. Defaults to "f(x)=".
        """

        m, x, y = s.symbols('m x y')

        funcao_pretty = self.handler.pretty_ready(funcao)

        funcao_plot = s.plot(funcao, show=False)
        funcao_plot.legend = True
        funcao_plot[0].label = legenda + funcao_pretty
        funcao_plot.xlim = plot_eixo_x_limites
        funcao_plot.ylim = plot_eixo_y_limites

        #Reta tangente no ponto (x,y)
        if show_tangente == True:
            m = self.DecliveValor(funcao, coord_x)
            y = s.sympify(m * (x - coord_x) + coord_y)

            rt = s.plot(y, show=False)

            rt.xlim = plot_eixo_x_limites
            rt.ylim = plot_eixo_y_limites

            funcao_plot.append(rt[0])

            reta_tangente_pretty = "Reta tangente no ponto (" + str(
                coord_x) + ", " + str(
                    coord_y) + ") de f(x)=" + self.handler.pretty_ready(funcao)
            funcao_plot[1].label = reta_tangente_pretty
            funcao_plot[1].line_color = 'firebrick'

        funcao_latex = self.sympyLatexify(funcao)
        funcao_plot.title = f"${funcao_latex}$"
        funcao_plot.show()
Esempio n. 26
0
def test_solve_plane(f, x0, y0):
    """
    Проверяем решение векторных уравнений
    """
    # get iterations
    tol = 1e-9
    xs, ys, zs = solve_plane(f, x0, y0, tol)
    f_eval = f.subs({x: xs[-1], y: ys[-1]})
    assert np.linalg.norm([float(f_eval[0]), float(f_eval[1])]) < tol

    # plot f() lines
    # p = sp.plot(show=False, backend=sp.plotting.plot_backends['matplotlib'])
    p = sp.plot(show=False)
    p.extend(sp.plot_implicit(f[0], depth=1, line_color='k', show=False))
    p.extend(sp.plot_implicit(f[1], depth=1, line_color='k', show=False))

    # plot iterations
    traj = List2DSeries(xs, ys)
    traj.line_color = 'm'
    p.append(traj)
    p.title = f'{f[0]}\n{f[1]}'
    p.xlabel = 'x'
    p.ylabel = 'y'
    p.show()

    # plot accuracy
    plt.figure()
    plt.plot(-np.log10(np.abs(zs)), 'b.:')
    plt.suptitle(p.title)
    plt.xlabel('N step')
    plt.ylabel('Accuracy')
    plt.show()
Esempio n. 27
0
def bisection(funcion, xi, xs, nIter, iter):
    results = {}
    if nIter > 0:
        x = sm.symbols('x')
        fxi = sm.sympify(funcion).subs(x, xi)
        fxs = sm.sympify(funcion).subs(x, xs)
        sm.plot(funcion)
        if (fxi == 0):
            print(fxi)
        elif (fxs == 0):
            print(fxs)
        elif (fxs * fxi < 0):
            xm = (xi + xs) / 2
            fxm = sm.sympify(funcion).subs(x, xm)
            count = 1
            error = iter + 1
            results[count] = [
                float(xi),
                float(xm),
                float(xs),
                float(fxm),
                float(error)
            ]
            while ((error > iter) and (count < nIter)):
                if (fxi * fxm < 0):
                    xs = xm
                else:
                    xi = xm
                xaux = xm
                xm = (xi + xs) / 2
                fxm = sm.sympify(funcion).subs(x, xm)
                error = abs(xm - xaux)
                count += 1
                results[count] = [
                    float(xi),
                    float(xm),
                    float(xs),
                    float(fxm),
                    float(error)
                ]
            print(results)
        return results
    else:
        results['message'] = 'Error'
        print('el intervalo no sirve')
        return results
Esempio n. 28
0
async def plot(ctx, *, exp):
    exp = syp.sympify(exp)

    img_path = path.join(log_dir, 'figure.png')
    img = syp.plot(exp, show=False)
    img.save(img_path)

    return await bot.upload(img_path)
    def animate(ti):
        p = sym.plot(x.subs(t, tau), (tau, taud[0], taud[-1]), show=False)
        line_x.set_segments(p[0].get_segments())

        p = sym.plot(h.subs(t, t - tau).subs(t, ti), (tau, taud[0], taud[-1]),
                     show=False)
        line_h.set_segments(p[0].get_segments())

        p = sym.plot(y, (t, taud[0], taud[-1]), show=False)
        line_y.set_segments(p[0].get_segments())

        p = sym.plot(x.subs(t, tau) * h.subs(t, ti - tau), (tau, -5, 5),
                     show=False)
        points = p[0].get_points()
        verts = [[(xi[0], xi[1]) for xi in np.transpose(np.array(points))]]
        fill.set_verts(verts)

        dot.set_data(ti, y.subs(t, ti))
Esempio n. 30
0
def plot_function_overlay(empirical_distribution_function, empirical_arg,
                          gamma_distribution_function, gamma_arg, bound):
    """
    :param empirical_distribution_function: империческая функция распределения - символьная функция
    :param empirical_arg: аргумент символьной функции империческая функция распределениz
    :param gamma_distribution_function: функция гамма распределения - символьная функция
    :param gamma_arg: аргумент символьной гамма функции распределения
    :param bound: кортеж -  границы построения графика
    :return: обьект графика
    """
    p1 = plot(gamma_distribution_function, (gamma_arg, bound[0], bound[1]),
              show=False)
    p2 = plot(empirical_distribution_function,
              (empirical_arg, bound[0], bound[1]),
              show=False)
    p2[0].line_color = 'red'
    p1.append(p2[0])
    return p1
def lagrange(f, vectorX, vectorY):
    f = sy.sympify(f)
    indice = 0
    n = len(vectorX)
    resultado = 0
    x = symbols('x')
    while indice != n:
        resultado += vectorY[indice] * multiplicacionL(vectorX, indice, n)
        indice += 1
    print(resultado)
    resultado = sy.sympify(resultado)
    p1 = plot(resultado, (x, vectorX[0], vectorX[n - 1]),
              show=False,
              line_color='r')
    p2 = plot(f, (x, vectorX[0], vectorX[n - 1]), show=False)
    p1.append(p2[0])
    p1.show()
    return resultado
Esempio n. 32
0
    def plot_graphic(self, file_name):
        file = '{}.png'.format(file_name)

        graph = plot(self.f, (x, Float(
            self.interval.split()[0]), Float(self.interval.split()[1])),
                     show=False,
                     line_color='r')
        # graph.append(List2DSeries(x1, y1))

        graph.save(file)
def plot_sympy(*args, ax=None, **kwargs):
    """Plot a SymPy expression into a Matplotlib plot."""
    from matplotlib.collections import LineCollection
    if ax is None:
        ax = _plt.gca()
    for line in _sp.plot(*args, show=False, **kwargs):
        x, y = line.get_points()
        # if the function is constant, SymPy only emits one value:
        x, y = _np.broadcast_arrays(x, y)
        ax.plot(x, y)
    ax.autoscale()
Esempio n. 34
0
def normal_form():
    #x=sy.Function('f')
    (r, x) = sy.symbols('r x')
    #eq=sy.Eq(sy.Derivative(x(t),t),x(t)**3-3*x(t)**2+(r+2)*x(t)-r)
    eq = [
        sy.Eq(x**3 - 3 * x**2 + (r + 2) * x - r, 0),
        sy.Eq(3 * x**2 - 6 * x + (r + 2), 0)
    ]
    solution = sy.solve(eq)[0]

    (y, t) = sy.symbols('y t')

    newEq = [
        sy.expand(eq[0].subs([(x, y + solution[x]), (r, t + solution[r])])),
        sy.expand(eq[0].subs([(x, y + solution[x]), (r, t + solution[r])]))
    ]
    expression = x**3 - 3 * x**2 + (r + 2) * x - r
    newExp = expression.subs([(x, y + solution[x]), (r, t + solution[r])])
    print(sy.expand(newExp))
    sy.plot(newExp.subs(t, 0))
Esempio n. 35
0
import modsolve
from sympy import plot

# feature-positive discrimination
m = modsolve.model()
m.train( {'A':0, 'AB':1} )
VB1 = m.V( 'B', 1 )
VB1rem = m.bind( VB1, 'rem' )
VB1p87 = m.bind( VB1, 'p87' )
VB1p94 = m.bind( VB1, 'p94' )
(r, c) = (m.symbols['r'], m.symbols['c'])
plot( (VB1rem, (r,0,1)), (VB1p87, (c,0,1)), (VB1p94, (c,0,1)) )

# external inhibition
m = modsolve.model()
m.train( {'A':1} )
VAB1 = m.V( 'AB', 1 )
VAB1rem = m.bind( VAB1, 'rem' )
VAB1p87 = m.bind( VAB1, 'p87' )
VAB1p94 = m.bind( VAB1, 'p94' )
(r, c) = (m.symbols['r'], m.symbols['c'])
plot( (VAB1rem, (r,0,1)), (VAB1p87, (c,0,1)), (VAB1p94, (c,0,1)) )

# summation
m = modsolve.model()
m.train( {'A':1, 'B':1} )
VAB1 = m.V( 'AB', 1 )
VAB1rem = m.bind( VAB1, 'rem' )
VAB1p87 = m.bind( VAB1, 'p87' )
VAB1p94 = m.bind( VAB1, 'p94' )
(r, c) = (m.symbols['r'], m.symbols['c'])
Esempio n. 36
0
rw = np.matrix([sx, sy, 1])

#%%
x = np.linspace(-200, 200, num=100)
y = np.linspace(-200, 200, num=100)
X, Y = np.meshgrid(x, y)
matplotlib.rcParams['xtick.direction'] = 'out'
matplotlib.rcParams['ytick.direction'] = 'out'


#%%
Q = np.matrix(np.random.uniform(low=-1., high=1., size=(3, 3)))
Q /= np.linalg.norm(Q)
#Q = np.matrix(np.random.normal(size=(2, 2)))
#P = np.matrix(np.random.normal(size=(1, 2)))
eq = rw * (Q * rw.T) #+ P*rw.T
eqsy = sympy.solve(eq[0,0], sy)
sympy.plot(*[(teq, (sx, -1, 1)) for teq in eqsy])

#%%
Z = np.zeros(X.shape)
for y in range(Z.shape[0]):
  for x in range(Z.shape[1]):
    posvec = np.matrix([Y[y, x], X[y, x], 1.])
    Z[y, x] = posvec*(Q * posvec.T) #+ P*posvec.T
plt.figure()
CS = plt.contour(X, Y, Z)
plt.clabel(CS, inline=1, fontsize=10)
plt.title('Quadric contours')

Esempio n. 37
0
# -*- coding: utf-8 -*-
"""
Created on Sat Apr 05 14:04:50 2014

@author: lassnech
"""

from sympy import plot, log, re, Abs
from sympy.abc import x

sh_entropy = re(-x*log(x)/log(2)-(1-x)*log(1-x)/log(2))
ind_p_1 = 1-Abs(0.5-x)**1 * 2
ind_p_2 = 1-Abs(0.5-x)**2 * 4
ind_p_3 = 1-Abs(0.5-x)**3 * 8
ind_p_4 = 1-Abs(0.5-x)**4 * 16
rnge = (x, 0, 1)
p1 = plot(sh_entropy, rnge, show=False, line_color='b')
p2 = plot(ind_p_2, rnge, show=False, line_color='g')
p3 = plot(ind_p_3, rnge, show=False, line_color='y')
p4 = plot(ind_p_4, rnge, show=False, line_color='r')
p5 = plot(ind_p_1, rnge, show=False, line_color='purple')

p1.extend(p2)
p1.extend(p3)
p1.extend(p4)
p1.extend(p5)
p1.title = 'entropies'
p1.save('impurities.png')
p1.show()
Esempio n. 38
0
# Check the plot docstring

from sympy import Symbol, plot, exp, sin, cos

lx = range(5)
ly = [i**2 for i in lx]

x = Symbol('x')
y = Symbol('y')
u = Symbol('u')
v = Symbol('v')
expr = x**2 - 1

#a = plot(lx, ly, show=False)  # list plot
b = plot(expr, (x, 2, 4), show=False) # cartesian plot
#c = plot((lx, ly), (expr, (x, 2, 4)), ('x*cos(x)', 'x*sin(x)', (x, 0, 15)), show=False) # list, cartesian and parametric plot
#d = plot(1/(x**2+y**2+1), (x, -10, 10), (y, -10, 10), 'contour') # contour plot
e = plot(exp(-x),(x, 0, 4), show=False) # cartesian plot (and coloring, see below)
f = plot(sin(x), cos(x), x, (x,0,10), show=False)  # 3d parametric line plot
g = plot(sin(x)*cos(y), (x, -5, 5), (y, -10, 10), show=False) # 3d surface cartesian plot
h = plot(cos(u)*v,sin(u)*v,u,(u,0,10),(v,-2,2), show=False) # 3d parametric surface plot

# Some global options
#c.title = 'Big nice title'
#c.xlabel = 'my argument'
#c.ylabel = 'my function'
#c.legend = True

# Some aesthetics
e[0].line_color = lambda x : x/4
f[0].line_color = lambda x, y, z : z/10
Esempio n. 39
0
  p3=plot(g3, rnge, show=False, line_color='y')
  p4=plot(g4, rnge, show=False, line_color='r')

  p1.extend(p2)
  p1.extend(p3)
  p1.extend(p4)
  return p1

p1 = basic_plot()
p1.title = 'sample result distributions'
p1.save('dist_basic.png')
p1.show()

means = 1./4.*(g1+g2+g3+g4)
p1.title = 'averaging'
p1.extend(plot(means, rnge, show=False, line_color='black'))
p1.save('dist_means.png')
p1.show()


p1 = basic_plot()
p1.title = 'multiplication'
mult = g1*g2*g3*g4
# Find pseudo max of mult.
multf = lambdify(x, mult)
xv = np.linspace(0, 12, 1000)
sumv = 0.
maxv = 0.
for val in xv:
  v = multf(val)
  sumv += v
Esempio n. 40
0
def plot_riesenie(t1,yt,yder,yder2):
    Py = plot((yt,(t,0,t1)),depth=12,title=r"$y(t)$",xlabel="",ylabel="")
    Pdy  = plot((yder,(t,0,t1)),title=r"$y'(t)$",xlabel="",ylabel="")
    Pddy = plot((yder2,(t,0,t1)),sings=[t1,t2],title=r"$y''(t)$",xlabel="",ylabel="")
print(x2) #final answer printed out

############################################################
#part b

points = []
y = [];

def new_f(x,c):
    return (1 - math.exp(-c*x) - x)

def new_df(x, c):
    return c*math.exp(-c*x) - 1

for c in linspace(0,3,3):
    x1 = 1
    x2 = 1
    target = 1e-6
    points.append(c)
    while True:
        x1=x2
        x2=x1-new_f(x1, c)/new_df(x1, c)
        if abs(x2-x1) < target:
            if x2 is not None:
                y.append(x2)
            else:
                y.append(0)
                break

plot(points, y)
show()
Esempio n. 42
0
# from sympy.plotting import plot
# from sympy import Symbol
# x = Symbol('x')
# plot(2*x+3)

from sympy import plot, Symbol
x = Symbol('x')
plot(2*x + 3, (x, -5, 5), title='A Line', xlabel='x', ylabel='2x+3')
Esempio n. 43
0
def plot_and_save(name):
    x = Symbol("x")
    y = Symbol("y")
    z = Symbol("z")

    ###
    # Examples from the 'introduction' notebook
    ###

    p = plot(x, show=False)
    p = plot(x * sin(x), x * cos(x), show=False)
    p.extend(p)
    p[0].line_color = lambda a: a
    p[1].line_color = "b"
    p.title = "Big title"
    p.xlabel = "the x axis"
    p[1].label = "straight line"
    p.legend = True
    p.aspect_ratio = (1, 1)
    p.xlim = (-15, 20)
    p.save(tmp_file("%s_basic_options_and_colors.png" % name))

    p.extend(plot(x + 1, show=False))
    p.append(plot((x + 3,), (x ** 2,), show=False)[1])
    p.save(tmp_file("%s_plot_extend_append.png" % name))

    p[2] = x ** 2, (x, -2, 3)
    p.save(tmp_file("%s_plot_setitem.png" % name))

    p = plot(sin(x), (x, -2 * pi, 4 * pi), show=False)
    p.save(tmp_file("%s_line_explicit.png" % name))

    p = plot(sin(x), (-2 * pi, 4 * pi), show=False)
    p.save(tmp_file("%s_line_implicit_var.png" % name))

    p = plot(sin(x), show=False)
    p.save(tmp_file("%s_line_default_range.png" % name))

    p = plot((x,), (x * sin(x), x * cos(x)), show=False)
    p.save(tmp_file("%s_two_curves.png" % name))

    p = plot(sin(x), cos(x), x, show=False)
    p.save(tmp_file("%s_3d_line.png" % name))

    p = plot(x * y, show=False)
    p.save(tmp_file("%s_surface.png" % name))

    p = plot(x * sin(z), x * cos(z), z, show=False)
    p.save(tmp_file("%s_parametric_surface.png" % name))

    ###
    # Examples from the 'colors' notebook
    ###

    p = plot(sin(x), show=False)
    p[0].line_color = lambda a: a
    p.save(tmp_file("%s_colors_line_arity1.png" % name))

    p[0].line_color = lambda a, b: b
    p.save(tmp_file("%s_colors_line_arity2.png" % name))

    p = plot(x * sin(x), x * cos(x), (0, 10), show=False)
    p[0].line_color = lambda a: a
    p.save(tmp_file("%s_colors_param_line_arity1.png" % name))

    p[0].line_color = lambda a, b: a
    p.save(tmp_file("%s_colors_param_line_arity2a.png" % name))

    p[0].line_color = lambda a, b: b
    p.save(tmp_file("%s_colors_param_line_arity2b.png" % name))

    p = plot(
        sin(x) + 0.1 * sin(x) * cos(7 * x),
        cos(x) + 0.1 * cos(x) * cos(7 * x),
        0.1 * sin(7 * x),
        (0, 2 * pi),
        show=False,
    )
    p[0].line_color = lambda a: sin(4 * a)
    p.save(tmp_file("%s_colors_3d_line_arity1.png" % name))
    p[0].line_color = lambda a, b: b
    p.save(tmp_file("%s_colors_3d_line_arity2.png" % name))
    p[0].line_color = lambda a, b, c: c
    p.save(tmp_file("%s_colors_3d_line_arity3.png" % name))

    p = plot(sin(x) * y, (0, 6 * pi), show=False)
    p[0].surface_color = lambda a: a
    p.save(tmp_file("%s_colors_surface_arity1.png" % name))
    p[0].surface_color = lambda a, b: b
    p.save(tmp_file("%s_colors_surface_arity2.png" % name))
    p[0].surface_color = lambda a, b, c: c
    p.save(tmp_file("%s_colors_surface_arity3a.png" % name))
    p[0].surface_color = lambda a, b, c: sqrt((a - 3 * pi) ** 2 + b ** 2)
    p.save(tmp_file("%s_colors_surface_arity3b.png" % name))

    p = plot(x * cos(4 * y), x * sin(4 * y), y, (-1, 1), (-1, 1), show=False)
    p[0].surface_color = lambda a: a
    p.save(tmp_file("%s_colors_param_surf_arity1.png" % name))
    p[0].surface_color = lambda a, b: a * b
    p.save(tmp_file("%s_colors_param_surf_arity2.png" % name))
    p[0].surface_color = lambda a, b, c: sqrt(a ** 2 + b ** 2 + c ** 2)
    p.save(tmp_file("%s_colors_param_surf_arity3.png" % name))

    ###
    # Examples from the 'advanced' notebook
    ###

    i = Integral(log((sin(x) ** 2 + 1) * sqrt(x ** 2 + 1)), (x, 0, y))
    p = plot(i, (1, 5), show=False)
    p.save(tmp_file("%s_advanced_integral.png" % name))

    s = summation(1 / x ** y, (x, 1, oo))
    p = plot(s, (2, 10), show=False)
    p.save(tmp_file("%s_advanced_inf_sum.png" % name))

    p = plot(summation(1 / x, (x, 1, y)), (2, 10), show=False)
    p[0].only_integers = True
    p[0].steps = True
    p.save(tmp_file("%s_advanced_fin_sum.png" % name))

    ###
    # Test expressions that can not be translated to np and generate complex
    # results.
    ###

    # with warnings.catch_warnings(record=True) as w:
    #    warnings.simplefilter("always")
    #    plot(sqrt(sqrt(-x)), show=False).save(tmp_file())
    #    assert len(w) == 1
    #    assert "Complex values as arguments to numpy functions encountered." == str(w[-1].message)
    # with warnings.catch_warnings(record=True) as w:
    #    warnings.simplefilter("always")
    #    plot(LambertW(x), show=False).save(tmp_file())
    #    assert len(w) > 10 #TODO trace where do the other warnings come from
    #    assert "Complex values as arguments to python math functions encountered." == str(w[-1].message)
    # with warnings.catch_warnings(record=True) as w:
    #    warnings.simplefilter("always")
    #    plot(sqrt(LambertW(x)), show=False).save(tmp_file())
    #    assert len(w) == 1
    #    assert "Complex values as arguments to python math functions encountered." == str(w[-1].message)
    # TODO these test do not work properly.
    plot(sin(x) + I * cos(x)).save(tmp_file())
    plot(sqrt(sqrt(-x)), show=False).save(tmp_file())
    plot(LambertW(x), show=False).save(tmp_file())
    plot(sqrt(LambertW(x)), show=False).save(tmp_file())

    ###
    # Test all valid input args for plot()
    ###

    # 2D line with all possible inputs
    plot(x).save(tmp_file())
    plot(x, (x,)).save(tmp_file())
    plot(x, (-10, 10)).save(tmp_file())
    plot(x, (x, -10, 10)).save(tmp_file())

    # two 2D lines
    plot((x,), (x + 1, (x, -10, 10))).save(tmp_file())
    plot((x, (x,)), (x + 1, (x, -10, 10))).save(tmp_file())
    plot((x, (-10, 10)), (x + 1, (x, -10, 10))).save(tmp_file())
    plot((x, (x, -10, 10)), (x + 1, (x, -10, 10))).save(tmp_file())
    plot([x, x + 1]).save(tmp_file())
    plot([x, x + 1], (x,)).save(tmp_file())
    plot([x, x + 1], (-10, 10)).save(tmp_file())
    plot([x, x + 1], (x, -10, 10)).save(tmp_file())

    # 2D and 3D parametric lines
    plot(x, 2 * x).save(tmp_file())
    plot(x, 2 * x, sin(x)).save(tmp_file())

    # surface and parametric surface
    plot(x * y).save(tmp_file())
    plot(x * y, 1 / x, 1 / y).save(tmp_file())

    # some bizarre combinatrions
    ## two 3d parametric lines and a surface
    plot(([x, -x], x ** 2, sin(x)), (x * y,)).save(tmp_file())
Esempio n. 44
0
def plot_and_save(name):
    x = Symbol('x')
    y = Symbol('y')
    z = Symbol('z')

    ###
    # Examples from the 'introduction' notebook
    ###

    p = plot(x, show=False)
    p = plot(x*sin(x),x*cos(x), show=False)
    p.extend(p)
    p[0].line_color = lambda a : a
    p[1].line_color='b'
    p.title = 'Big title'
    p.xlabel = 'the x axis'
    p[1].label = 'straight line'
    p.legend = True
    p.aspect_ratio = (1,1)
    p.xlim = (-15,20)
    p.save(tmp_file('%s_basic_options_and_colors.png' % name))

    p.extend(plot(x+1, show=False))
    p.append(plot((x+3,),(x**2,), show=False)[1])
    p.save(tmp_file('%s_plot_extend_append.png' % name))

    p[2] = x**2, (x, -2, 3)
    p.save(tmp_file('%s_plot_setitem.png' % name))

    p = plot(sin(x),(x,-2*pi,4*pi), show=False)
    p.save(tmp_file('%s_line_explicit.png' % name))

    p = plot(sin(x),(-2*pi,4*pi), show=False)
    p.save(tmp_file('%s_line_implicit_var.png' % name))

    p = plot(sin(x), show=False)
    p.save(tmp_file('%s_line_default_range.png' % name))

    p = plot((x,), (x*sin(x), x*cos(x)), show=False)
    p.save(tmp_file('%s_two_curves.png' % name))

    p = plot(sin(x),cos(x),x, show=False)
    p.save(tmp_file('%s_3d_line.png' % name))

    p = plot(x*y, show=False)
    p.save(tmp_file('%s_surface.png' % name))

    p = plot(x*sin(z),x*cos(z),z, show=False)
    p.save(tmp_file('%s_parametric_surface.png' % name))

    ###
    # Examples from the 'colors' notebook
    ###

    p = plot(sin(x), show=False)
    p[0].line_color = lambda a : a
    p.save(tmp_file('%s_colors_line_arity1.png' % name))

    p[0].line_color = lambda a, b : b
    p.save(tmp_file('%s_colors_line_arity2.png' % name))

    p = plot(x*sin(x), x*cos(x), (0,10), show=False)
    p[0].line_color = lambda a : a
    p.save(tmp_file('%s_colors_param_line_arity1.png' % name))

    p[0].line_color = lambda a, b : a
    p.save(tmp_file('%s_colors_param_line_arity2a.png' % name))

    p[0].line_color = lambda a, b : b
    p.save(tmp_file('%s_colors_param_line_arity2b.png' % name))

    p = plot(sin(x)+0.1*sin(x)*cos(7*x),
             cos(x)+0.1*cos(x)*cos(7*x),
             0.1*sin(7*x),
             (0, 2*pi),
             show=False)
    p[0].line_color = lambda a : sin(4*a)
    p.save(tmp_file('%s_colors_3d_line_arity1.png' % name))
    p[0].line_color = lambda a, b : b
    p.save(tmp_file('%s_colors_3d_line_arity2.png' % name))
    p[0].line_color = lambda a, b, c : c
    p.save(tmp_file('%s_colors_3d_line_arity3.png' % name))

    p = plot(sin(x)*y, (0,6*pi), show=False)
    p[0].surface_color = lambda a : a
    p.save(tmp_file('%s_colors_surface_arity1.png' % name))
    p[0].surface_color = lambda a, b : b
    p.save(tmp_file('%s_colors_surface_arity2.png' % name))
    p[0].surface_color = lambda a, b, c : c
    p.save(tmp_file('%s_colors_surface_arity3a.png' % name))
    p[0].surface_color = lambda a, b, c : sqrt((a-3*pi)**2+b**2)
    p.save(tmp_file('%s_colors_surface_arity3b.png' % name))

    p = plot(x*cos(4*y), x*sin(4*y), y,
             (-1, 1), (-1, 1), show=False)
    p[0].surface_color = lambda a : a
    p.save(tmp_file('%s_colors_param_surf_arity1.png' % name))
    p[0].surface_color = lambda a, b : a*b
    p.save(tmp_file('%s_colors_param_surf_arity2.png' % name))
    p[0].surface_color = lambda a, b, c : sqrt(a**2+b**2+c**2)
    p.save(tmp_file('%s_colors_param_surf_arity3.png' % name))

    ###
    # Examples from the 'advanced' notebook
    ###

    i = Integral(log((sin(x)**2+1)*sqrt(x**2+1)),(x,0,y))
    p = plot(i,(1,5), show=False)
    p.save(tmp_file('%s_advanced_integral.png' % name))

    s = summation(1/x**y,(x,1,oo))
    p = plot(s, (2,10), show=False)
    p.save(tmp_file('%s_advanced_inf_sum.png' % name))

    p = plot(summation(1/x,(x,1,y)), (2,10), show=False)
    p[0].only_integers = True
    p[0].steps = True
    p.save(tmp_file('%s_advanced_fin_sum.png' % name))


    ###
    # Test expressions that can not be translated to np and generate complex
    # results.
    ###


    plot(sin(x)+I*cos(x), show=False).save(tmp_file())
    plot(sqrt(sqrt(-x)), show=False).save(tmp_file())
    plot(LambertW(x), show=False).save(tmp_file())
    plot(sqrt(LambertW(x)), show=False).save(tmp_file())


    ###
    # Test all valid input args for plot()
    ###

    # 2D line with all possible inputs
    plot(x              , show=False).save(tmp_file())
    plot(x, (x,        ), show=False).save(tmp_file())
    plot(x, (   -10, 10), show=False).save(tmp_file())
    plot(x, (x, -10, 10), show=False).save(tmp_file())

    # two 2D lines
    plot((x,             ), (x+1, (x, -10, 10)), show=False).save(tmp_file())
    plot((x, (x,        )), (x+1, (x, -10, 10)), show=False).save(tmp_file())
    plot((x, (   -10, 10)), (x+1, (x, -10, 10)), show=False).save(tmp_file())
    plot((x, (x, -10, 10)), (x+1, (x, -10, 10)), show=False).save(tmp_file())
    plot([x, x+1],               show=False).save(tmp_file())
    plot([x, x+1], (x,        ), show=False).save(tmp_file())
    plot([x, x+1], (   -10, 10), show=False).save(tmp_file())
    plot([x, x+1], (x, -10, 10), show=False).save(tmp_file())

    # 2D and 3D parametric lines
    plot(x, 2*x, show=False).save(tmp_file())
    plot(x, 2*x, sin(x), show=False).save(tmp_file())

    # surface and parametric surface
    plot(x*y, show=False).save(tmp_file())
    plot(x*y, 1/x, 1/y,show=False).save(tmp_file())

    # some bizarre combinatrions
    ## two 3d parametric lines and a surface
    plot(([x, -x], x**2, sin(x)), (x*y,), show=False).save(tmp_file())
def plotexprt(ft,sings=[],depth=10,xlabel='t',ylabel='y(t)'):
    P=plot(ft,singularities=sings,depth=depth,xlabel=xlabel,ylabel=ylabel)
def plotnp(ft,t1,t2, xlab=r'$t$',ylab=r'$y(t)$',npts=200):
    tn = linspace(t1,t2,npts)
    yn = array([ft(ta) for ta in tn],dtype='float')
    plot(tn,yn)
    xlabel(xlab); ylabel(ylab)