Demo entry 6799606

test

   

Submitted by anonymous on May 20, 2019 at 19:07
Language: ANTLR With Python Target. Code size: 45.5 kB.

#-*-coding:utf8 -*-
from math import *
from Tkinter import *
import time
root=Tk()
root.title('Курсовая работа: ')
z=Frame(root) #рамка для начального окна меню
intg_dif=Button(z, text='Задача 1') # запуск 1-ой задачи
u1=Label(z, text='-----------------------------------------------------')
unlin_dif=Button(z, text='Задача 2') # запуск 2-ой задачи
u2=Label(z, text='-----------------------------------------------------')
graph=Button(z, text='Задача 3') # запуск 3-ой задачи
u3=Label(z, text='-----------------------------------------------------')
examp=Button(z, text='Задача 4') # запуск 4-ой задачи
u4=Label(z, text='-----------------------------------------------------')
u5=Label(z, text='-----------------------------------------------------')
ex=Button(z, text='Выход', command=root.destroy) #кнопка выхода из меню

def func(x, y_str):
    return eval(y_str) # функция, которая решает уравнения относительно х 
def func1 (t, y): 
    return eval (y) # функция, которая решает уравнения относительно х

def canvas(): # функция создания координатной плоскости для 2-ой задачи
    root=Tk()
    can=Canvas(root, width=500, height=500) # размеры 
    global can
    x0=250; y0=250; x_k=10; y_k=10
    can.create_line(x_k, y0, x0+240, y0, fill='black', arrow=BOTH)
    can.create_line(x0, y_k, x0, y0+240, fill='black', arrow=BOTH)
    can.create_text(x0+20, y_k, text='Y')
    can.create_text(x0+240, y0+20, text='X') # создание осей

    can.create_text(x0-10,y0+10, text='0')
    x_nach=x0+50
    s=1
    for i in range(4): # создание ед. отрезков вдоль "+" оси х
        can.create_line(x_nach, y0-5, x_nach, y0+5 )
        can.create_text(x_nach, y0+10, text=s)
        x_nach=x_nach+50
        s=s+1

    x_nach=x0-50
    s=-1
    for i in range(4): # создание ед. отрезков вдоль "-" оси х
        can.create_line(x_nach, y0-5, x_nach, y0+5 )
        can.create_text(x_nach, y0+10, text=s)
        x_nach=x_nach-50
        s=s-1
        
    y_nach=y0-50
    s=1
    for i in range(4): # создание ед. отрезков вдоль "+" оси у
        can.create_line(x0-5, y_nach, x0+5, y_nach )
        can.create_text(x0-10, y_nach, text=s)
        y_nach=y_nach-50
        s=s+1

    y_nach=y0+50
    s=-1
    for i in range(4): # создание ед. отрезков вдоль "-" оси у
        can.create_line(x0-5, y_nach, x0+5, y_nach )
        can.create_text(x0-10, y_nach, text=s)
        y_nach=y_nach+50
        s=s-1

def intg_dif_start(u): # вывод меню для первой задачи
    z.grid_remove()
    z0=Frame(root) # рамка для меню 1-ой задачи
    dif0=Button(z0, text='Дифференцирование')
    u1=Label(z0, text='-----------------------------------------------------')
    intg0=Button(z0, text='Интегрирование')
    u2=Label(z0, text='-----------------------------------------------------')
    q=Button(z0, text='Обратно')

    def diff(u):
        z0.grid_remove()
        z_=Frame(root) # рамка для отдела по дифференцированию
        x0=Label(z_, width=20, text='введите значение аргумента:')
        x1=Entry(z_)
        y0=Label(z_, width=20, text='введите фукцию:')
        y1=Entry(z_)
        h0=Label(z_, width=20, text='введите длину шага:')
        h1=Entry(z_, width=10)
        g=Button(z_,text='Счет...')
        l1=Label(z_, width=30, text='Производная функции в точке...')
        q1=Button(z_, text='Обратно')
        def dif(s):
            x=float(x1.get())
            y=str(y1.get())
            h=float(h1.get())
            x3=x-h
            x4=x+h

            y_dec=(func(x4, y)-func(x3, y))/(2*h) # нахождение дефференциала по формуле из теории
            y_dec=str(y_dec)
            l1['text']=''.join(y_dec) # вывод соответствующего значения
        def zab(s): # фукция выхода из отдела по диф.
            z_.grid_remove()
            z0.grid()

        z_.grid()
        x0.pack()
        x1.pack()
        y0.pack()   #упаковка всех элементов
        y1.pack()
        h0.pack()
        h1.pack()
        g.pack()
        l1.pack()
        q1.pack()
        g.bind('<Button-1>', dif)
        q1.bind('<Button-1>', zab)

    def intg_1(u):
        z0.grid_remove()
        z_0=Frame(root) # рамка для отдела по интегрированию 
        a0=Label(z_0, width=30, text='введите нижний предел:')
        c1=Entry(z_0)
        b0=Label(z_0, width=30, text='введите верхний предел:')
        b1=Entry(z_0)
        y0=Label(z_0, width=30, text='введите функцию:')
        y1=Entry(z_0)
        h0=Label(z_0, width=20, text='введите длину шага:')
        h1=Entry(z_0, width=10)
        g1=Button(z_0, text='Значение интеграла в точке по методу прямоугольников...')
        l2=Label(z_0, width=50, text='...')
        g2=Button(z_0, text='Значение интеграла в точке по методу трапеций...')
        l4=Label(z_0, width=50, text='...')
        g3=Button(z_0, text='Значение интеграла в точке по методу Симпсона...')
        l6=Label(z_0, width=50, text='...')
        g4=Button(z_0, text='Обратно')
        def intg_rec(s): # функция по интегированию методом прямоугольников
            b=float(b1.get())
            a=float(c1.get())
            y=str(y1.get())
            h=float(h1.get())

            c=int((b-a)/h) # количесвто отрезков на интервале функции, равное длине шага

            i=0
            a2=a
            y_intg=0 # значение площади под функцией на интервале [a, b] по умолчанию
            for i in range(c): 
                f1=func(a2, y) # нахождение значения у (высоты)
                s=h*f1 # нахождние площади интервала, равного длине шага 
                y_intg=y_intg+s #добавление площади к общей предыдущей
                a2=a2+h
            y_intg=str(y_intg)    
            l2['text']=''.join(y_intg) # вывод итогового значения площади (и есть интеграл)

        def intg_trap(s): # функция по интегированию методом трапеций
            b=float(b1.get())
            a=float(c1.get())
            y=str(y1.get())
            h=float(h1.get())

            c=int((b-a)/h) # количесвто отрезков на интервале функции, равное длине шага

            i=0
            a2=a
            y_intg=0 # значение площади под функцией на интервале [a, b] по умолчанию
            for i in range(c):
                f1=func(a2, y)# нахождение значения у1 (первого основания) 
                a2=a2+h
                f2=func(a2, y) # нахождение значения у2 (второго основания) 
                s=(f1+f2)*h*0.5 # нахождние площади интервала, равного длине шага
                y_intg=y_intg+s #добавление площади к общей предыдущей
            y_intg=str(y_intg)
            l4['text']=''.join(y_intg) # вывод итогового значения площади (и есть интеграл)
                    
        def intg_simp(s): # функция по интегированию методом парабол (Симпсона)
            b=float(b1.get())
            a=float(c1.get())
            y=str(y1.get())
            h=float(h1.get())

            c=int((b-a)/h) # количесвто отрезков на интервале функции, равное длине шага

            i=0
            y_intg=0 # значение площади под функцией на интервале [a, b] по умолчанию
                        
            for i in range (c):
                a1=a # назначение трех точек по оси х на интервале длинной в шаг h
                a2=a+(h/2) # назначение трех точек по оси х на интервале длинной в шаг h
                a3=a+h # назначение трех точек по оси х на интервале длинной в шаг h
                f1=func(a1, y) # вычисление соотв. значения у 
                f2=func(a2, y) # вычисление соотв. значения у 
                f3=func(a3, y) # вычисление соотв. значения у 
                k1=(f3-((a3*(f2-f1)+a2*f1-a1*f2)/(a2-a1)))/(a3*(a3-a1-a2)+a1*a2) # нахождение коэф. а для квадратного уравнения
                k2=(f2-f1)/(a2-a1)-k1*(a1+a2) # нахождение коэф. b для квадратного уравнения
                k3=(a2*f1-a1*f2)/(a2-a1)+k1*a1*a2 # нахождение коэф. c для квадратного уравнения
                y_intg=y_intg+(k1*(a3**3/3)+k2*(a3**2/2)+k3*a3-k1*(a1**3/3)-k2*(a1**2/2)-k3*a1) # аналистиечское вычисление числ интегралла на шаге h
                a=a+h # выбор следующего шага
            y_intg=str(y_intg)
            l6['text']=''.join(y_intg) # вывод итогового значения площади (и есть интеграл)

        def forg(s): # функция выхода из отдела интегрирования
            z_0.grid_remove()
            z0.grid()


        g1.bind('<Button-1>', intg_rec)
        g2.bind('<Button-1>', intg_trap)
        g3.bind('<Button-1>', intg_simp)
        g4.bind('<Button-1>', forg)
        z_0.grid()
        a0.pack()
        c1.pack()
        b0.pack()
        b1.pack()
        y0.pack()   #упаковка всех соотв. элементов
        y1.pack()
        h0.pack()
        h1.pack()
        g1.pack()
        l2.pack()
        g2.pack()
        l4.pack()
        g3.pack()
        l6.pack()
        g4.pack()
            

    def quit_1(u): # функция выхода из меню 1-ой задачи
        z0.grid_remove()
        z.grid()
            
    z0.grid()  
    dif0.bind('<Button-1>', diff)
    intg0.bind('<Button-1>', intg_1)
    q.bind('<Button-1>', quit_1) 
    intg0.pack()    #упаковка всех соотв. элементов
    u1.pack()
    dif0.pack()
    u2.pack()
    q.pack()

def unlin_dif_start (s): # вывод меню для второй задачи
    z.grid_remove()
    z1=Frame(root) #рамка для меню 2-ой задачи
    unlin=Button(z1, text='Нелинейные уравнения')
    u1=Label(z1, text='-----------------------------------------------------')
    dif=Button(z1, text='Дифференциальные уравнения')
    u2=Label(z1, text='-----------------------------------------------------')
    q=Button(z1, text='Обратно')

    def unlin_start(s): # вывод меню нелинйеных уравнений 
        z1.grid_remove()
        z2=Frame(root) # рамка для отдела нелинйеных уравнений 
        a_=Label(z2, text='Введите начальное значене по оси х:')
        a_1=Entry(z2)
        b_=Label(z2, text='Введите конечное значене по оси х:')
        b_1=Entry(z2)
        y_=Label(z2, text='Введите уравнение:')
        y_1=Entry(z2, width=30)
        h_=Label(z2, text='Введите точность (кол-во знаков после запятой):')
        h_1=Entry(z2)
        m1=Button(z2, text='Метод половинного деления')
        n1=Label(z2, text='...')
        m2=Button(z2, text='Метод простых итераций')
        n2=Label(z2, text='...')
        m3=Button(z2, text='Метод хорд')
        n3=Label(z2, text='...')
        m4=Button(z2, text='Метод касательных')
        n4=Label(z2, text='...')
        m5=Button(z2, text='Метод комбинированный')
        n5=Label(z2, text='...')
        q1=Button(z2, text='Обратно')
        def delen(u): # способ половинного деления
            a1=[] # список для значений (решений) x1
            b1=[] # список для значений (решений) x2
            c1=[] # список для значений (решений) x=0
            a=int(a_1.get())
            b=int(b_1.get())
            y=str(y_1.get())  # импорт из полей данных
            h=float(h_1.get())

            h1=h*111 # кол-во разбиений (по умолчанию) выбранного интервала

            x1=a
            h0=(b-a)/h1
            x2=x1+h0
            h1=int(h1)
            h=int(h)
            for i in range(h1): # функция по разбиению интервала на "h1" маленьких интервалов...
                y1=func(x1, y)  # ...и выборка тех из них, концы которых имеют разные знаки по оси у
                if y1==0:
                    c1.append(x1) # добавление значения х=0 (одного из решений)
                y2=func(x2, y)
                y3=y1*y2
                if y3<0:
                    a1.append(x1) # добавление значения х1 подходящего интервала
                    b1.append(x2) # добавление значения х2 подходящего интервала
                x1=x2
                x2=x2+h0
            i=0
            v=0

            if len(a1)==0 and len(c1)==0: 
                n1['text']=''.join('значения x не найдены, задайте болшую точность')
            else:
                x_d=''
                for s in range(len(a1)):
                    x1=a1[s]
                    x2=b1[s]
                    for i in range(h1):
                        mid=(x2-x1)/2
                        y1=func(x1, y)
                        y2=func(x2, y)
                        y3=y1*y2
                        if y3>0:        # выполнение половинного деления (согласно теории)
                            x1=x1+mid
                            x2=x2+mid
                        else:
                            x1=x1
                            x2=x1+mid
                    x1=round(x1, h)
                    x1=str(x1)
                    x_d=x_d+'x='+x1+' '
                    i=0
                    
                v=0
                for v in range (len(c1)):
                    c1[v]=round(c1[v], h)
                    c1[v]=str(c1[v])
                    x_d=x_d+'x='+c1[v]+' '
                n1['text']=x_d # вывод значения x=0 с требуемой точностью

        def it(u): # способ итераций
            a1=[] # список для значений (решений) x1
            c1=[] # список для значений (решений) x=0
            a=a_1.get()
            a=float(a)
            b=b_1.get()
            b=int(b)
            y=y_1.get()   # импорт из полей данных
            y=str(y)
            h=h_1.get()
            h=int(h)

            x1=a
            n=h*111 # кол-во разбиений (по умолчанию) выбранного интервала
            step=(b-a)/(n) # длина шага при разбиении интервала на более мальенькие интервалы
            for i in range(n):  # функция по разбиению интервала на "n1" маленьких интервалов...
                y1=func(x1, y) # ...и выборка тех из них, концы которых имеют разные знаки по оси у
                if y1==0: 
                    c1.append(x1) # добавление значения х=0 (одного из решений)
                x2=x1+step
                y2=func((x2), y)
                y3=y1*y2
                if y3<0:
                    a1.append(x1) # добавление значения х1 подходящего интервала

                x1=x2

            if len(a1)==0 and len(c1)==0:
               n2['text']=''.join('значения x не найдены, задайте болшую точность')
            else:
                x_d=''
                for s in range(len(a1)):
                    for l in range (n):
                        x=a1[s]
                        x3=x-0.001
                        x4=x+0.001
                        y_dec=(func(x4, y)-func(x3, y))/(0.002) # выполнение итераций (согласно теории)
                        kon=1/y_dec
                        f=x-(kon*func(x, y))
                        x=f
                    x=round(x, h)
                    x=str(x)
                    x_d=x_d+'x='+x+' '
                    l=0

                i=0
                v=0
                for i in range (len(c1)):
                    c1[v]=round(c1[v],h)
                    c1[v]=str(c1[v])
                    x_d=x_d+'x='+c1[v]+' '
                n2['text']=x_d # вывод значения x=0 с требуемой точностью

        def khord(u):# способ хорд
            x_sp=[]# список для значений x1 и х2 подходящего интервала
            x_p=[]
            x_n=[]
            x_a=[]
            x_b=[]
            c1=[]  # список для значений (решений) x=0

            a=float(a_1.get())
            b=float(b_1.get())
            y=str(y_1.get())  # импорт из полей данных
            h=int(h_1.get())

            n=h*5 # кол-во разбиений (по умолчанию) выбранного интервала
            step=(b-a)/n # длина шага при разбиении интервала на более мальенькие интервалы
            x1=a
            for i in range(n): # функция по разбиению интервала на "n" маленьких интервалов...
                y1=func(x1, y) # ...и выборка тех из них, концы которых имеют разные знаки по оси у
                if y1==0:
                    c1.append(x1) # добавление значения х=0 (одного из решений)
                x2=x1+step
                y2=func((x2), y)
                y3=y1*y2
                if y3<0:
                    x_sp.append(x1) # добавление значения х1 подходящего интервала
                    x_sp.append(x2) # добавление значения х2 подходящего интервала

                x1=x2
                
            i=0
            s=0
            for i in range((len(x_sp)/2)): # функция по вычислению выпукслости выбранных выше интервалов
                a=x_sp[s]
                b=x_sp[s+1]
                d=0.001
                x=a+((b-a)/2)
                y1=func((x-d), y)
                y2=func(x, y)
                y3=func((x+d), y)
                y_sec=(y3-2*y2+y1)/(h**2) # вычисление знака двойной производной, которая отвечает за выпуклость
                if y_sec>0:
                    x_p.append(a) # добавление значения х1 интервала впуклого вверх
                    x_p.append(b) # добавление значения х2 интервала впуклого вверх
                if y_sec<0:
                    x_n.append(a) # добавление значения х1 интервала впуклого вниз
                    x_n.append(b) # добавление значения х2 интервала впуклого вниз
                s=s+2

            i=0
            s=0
            for i in range (len(x_p)/2): # функция по определению возрастания/убывания графика функции...  
                x1=x_p[s] # выпуклого вверх на интервале
                x2=x_p[s+1]
                y1=func(x1, y)
                y2=func(x2, y)
                if x1<x2 and y1>0 and y2<0:
                    x_b.append(x1) # добавление значения х1 при возрастании 
                    x_b.append(x2) # добавление значения х2 при возрастании 
                else:
                    x_a.append(x1) # добавление значения х1 при убывании
                    x_a.append(x2) # добавление значения х2 при убывании
                s=s+2

            i=0
            s=0
            for i in range (len(x_n)/2): # функция по определению возрастания/убывания графика функции... 
                x1=x_n[s] # выпуклого вниз на интервале
                x2=x_n[s+1]
                y1=func(x1, y)
                y2=func(x2, y)
                if x1<x2 and y1>0 and y2<0:
                    x_a.append(x1) # добавление значения х1 при возрастании 
                    x_a.append(x2) # добавление значения х1 при возрастании 
                else:
                    x_b.append(x1) # добавление значения х1 при убывании 
                    x_b.append(x2) # добавление значения х1 при убывании
                s=s+2
                
            i=0
            s=0
            f=0

            if len(x_a)==0 and len(x_b)==0 and len(c1)==0:
                n3['text']=('значения x не найдены, задайте болшую точность')
            else:
                x_d=''
                for i in range (len(x_a)/2):
                    x1=x_a[s]
                    x2=x_a[s+1]
                    y2=func(x2, y)      # выполнение метода хорд (согласно теории) при статической точки А
                    for f in range (n):
                        y1=func(x1, y)
                        x3=x1-((y1/(y2-y1))*(x2-x1))
                        x1=x3
                    
                    f=0
                    s=s+2
                    x1=round(x1, h)
                    x1=str(x1)
                    x_d=x_d+'x='+x1+' ' 

                i=0
                s=0
                f=0
                for i in range (len(x_b)/2):
                    x1=x_b[s]
                    x2=x_b[s+1]
                    y1=func(x1, y)      # выполнение метода хорд (согласно теории) при статической точки B
                    for f in range (n):
                        y2=func(x2, y)
                        x3=x1-((y1/(y2-y1))*(x2-x1))
                        x2=x3
                    
                    f=0
                    s=s+2
                    x2=round(x2, h)
                    x2=str(x2)
                    x_d=x_d+'x='+x2+' ' 

                i=0
                v=0
                for i in range (len(c1)):
                    c1[v]=round(c1[v],h)
                    c1[v]=str(c1[v])
                    x_d=x_d+'x='+c1[v]+' '
                n3['text']=x_d # вывод значения x=0 с требуемой точностью
            
            
            

        def kas(u): # способ касательных 
            a1=[]# список для значений (решений) x1
            c1=[] # список для значений (решений) x=0
            a=float(a_1.get())
            b=float(b_1.get())
            y=str(y_1.get())  # импорт из полей данных
            h=int(h_1.get())
            
            n=h*5  # кол-во разбиений (по умолчанию) выбранного интервала
            step=(b-a)/n # длина шага при разбиении интервала на более мальенькие интервалы
            x1=a
            
            for i in range(n): # функция по разбиению интервала на "n" маленьких интервалов...
                y1=func(x1, y) # ...и выборка тех из них, концы которых имеют разные знаки по оси у
                if y1==0:
                    c1.append(x1) # добавление значения х=0 (одного из решений)
                x2=x1+step
                y2=func((x2), y)
                y3=y1*y2
                if y3<0:
                    a1.append(x1) # добавление значения х1 подходящего интервала
                    a1.append(x2) # добавление значения х2 подходящего интервала
                    
                x1=x2

            if len(a1)==0 and len(c1)==0:
                n4['text']=('значения x не найдены, задайте болшую точность')
            else:
                x_d=''
                s=0
                i=0
                v=0
                for i in range (len(a1)/2):
                    x1=a1[s]
                    x2=a1[s+1]
                    x_0=x1+((x2-x1)/2)
                    for v in range(20):
                        x3=x_0-0.001
                        x4=x_0+0.001
                        y_0=func(x_0, y)    # выполнение метода ксательных (согласно теории)
                        d_y=(func(x4, y)-func(x3, y))/(0.002)   
                        x=((0-y_0)/d_y)+x_0
                        x_0=x
                    x_0=round(x_0, h)
                    x_0=str(x_0)
                    x_d=x_d+'x='+x_0+' '
                    s=s+2
                    v=0
                    
                i=0
                v=0
                for i in range (len(c1)):
                    c1[v]=round(c1[v],h)
                    c1[v]=str(c1[v])
                    x_d=x_d+'x='+c1[v]+' '
                n4['text']=x_d # вывод значения x=0 с требуемой точностью
                    
        def komb(u): # комбинированный способ
            x_sp=[] #аналогично методу хорд
            x_p=[] #аналогично методу хорд
            x_n=[] #аналогично методу хорд
            x_a=[] #аналогично методу хорд
            x_b=[] #аналогично методу хорд
            c1=[] #аналогично методу касательных
            a1=[] #аналогично методу касательных

            a=float(a_1.get())
            b=float(b_1.get())
            y=str(y_1.get())  # импорт из полей данных
            h=int(h_1.get())
#---------------------------------------------------------------------
            # функция по разбиению интервала на "n" маленьких интервалов...
            n=h*11
            step=(b-a)/n
            x1=a
            
            for i in range(n):
                y1=func(x1, y)
                if y1==0:
                    c1.append(x1)
                x2=x1+step
                y2=func((x2), y)
                y3=y1*y2
                if y3<0:
                    a1.append(x1)
                    a1.append(x2)
                    
                x1=x2
#--------------------------------------------------------------------- метод хорд              
            i=0
            x1=a
            for i in range(n):
                y1=func(x1, y)
                if y1==0:
                    c1.append(x1)
                x2=x1+step
                y2=func((x2), y)
                y3=y1*y2
                if y3<0:
                    x_sp.append(x1)
                    x_sp.append(x2)
                    

                x1=x2    
            i=0
            s=0
            for i in range((len(x_sp)/2)):
                a=x_sp[s]
                b=x_sp[s+1]
                d=0.001
                x=a+((b-a)/2)
                y1=func((x-d), y)
                y2=func(x, y)
                y3=func((x+d), y)
                y_sec=(y3-2*y2+y1)/(h**2)
                if y_sec>0:
                    x_p.append(a)
                    x_p.append(b)
                if y_sec<0:
                    x_n.append(a)
                    x_n.append(b)
                s=s+2
                
            i=0
            s=0
            for i in range (len(x_p)/2):
                x1=x_p[s]
                x2=x_p[s+1]
                y1=func(x1, y)
                y2=func(x2, y)
                if x1<x2 and y1>0 and y2<0:
                    x_b.append(x1)
                    x_b.append(x2)
                else:
                    x_a.append(x1)
                    x_a.append(x2)
                s=s+2

            i=0
            s=0
            for i in range (len(x_n)/2):
                x1=x_n[s]
                x2=x_n[s+1]
                y1=func(x1, y)
                y2=func(x2, y)
                if x1<x2 and y1>0 and y2<0:
                    x_a.append(x1)
                    x_a.append(x2)
                else:
                    x_b.append(x1)
                    x_b.append(x2)
                s=s+2

            i=0
            s=0
            f=0  
                                                            # метод хорд
#---------------------------------------------------------------------            

            if len(x_a)==0 and len(x_b)==0 and len(a1) and len(c1)==0:
                 n5['text']=('значения x не найдены, задайте болшую точность')
            else:
                x_d=''
                x1=round(x1, h)
                x2=round(x1,h)
                x_0=round(x1+2, h)
                s=0
#--------------------------------------------------------------------- метод касательных
                for k in range (len(a1)/2):
                    x1=10000
                    x4=10000
                    if len(x_a)!=0:
                        if s<=(len(x_a)/2):
                            x1=x_a[s]
                            x2=x_a[s+1]
                            y2=func(x2, y)
                    
                    if len(x_b)!=0:
                        if s<=(len(x_b)/2):
                            x3=x_b[s]
                            x4=x_b[s+1]
                            y4=func(x3, y)

                    x6=a1[s]
                    x7=a1[s+1]
                    x_0=x6+((x7-x6)/2)

#--------------------------------------------------------------------- совмещение метода касательных и хорд                       
                    while x_0!=x1 and x_0!=x4:
                        if len(x_a)!=0:
                            y1=func(x1, y)
                            x30=x1-((y1/(y2-y1))*(x2-x1))
                            x1=x30
                            x1=round(x1, h)

                        if len(x_b)!=0:    
                            y5=func(x4, y)
                            x5=x3-((y4/(y5-y4))*(x4-x3))
                            x4=x5
                            x4=round(x4, h)

                        x8=x_0-0.001
                        x9=x_0+0.001
                        y_0=func(x_0, y)
                        d_y=(func(x9, y)-func(x8, y))/(0.002)
                        x=((0-y_0)/d_y)+x_0
                        x_0=x
                        x_0=round(x_0, h)
                        x_00=x_0
                    x_00=str(x_00)    
                    x_d=x_d+'x='+x_00+' '
                    s=s+2
                i=0
                v=0
                for i in range (len(c1)):
                    c1[v]=round(c1[v],h)
                    c1[v]=str(c1[v])
                    x_d=x_d+'x='+c1[v]+' ' 
                n5['text']=x_d # вывод значения x=0 с требуемой точностью
        
        def quit__(s): # функция выхода из раздела интегрирования
            z2.grid_remove()
            z1.grid()
            
        m1.bind('<Button-1>', delen)
        m2.bind('<Button-1>', it)
        m3.bind('<Button-1>', khord)
        m4.bind('<Button-1>', kas)
        m5.bind('<Button-1>', komb)
        q1.bind('<Button-1>', quit__)
        
        a_.pack()
        a_1.pack()
        b_.pack()
        b_1.pack()
        y_.pack()
        y_1.pack()
        h_.pack()
        h_1.pack() # упаковка соотв. элементов
        m1.pack()
        n1.pack()
        m2.pack()
        n2.pack()
        m3.pack()
        n3.pack()
        m4.pack()
        n4.pack()
        m5.pack()
        n5.pack()
        z2.grid()
        q1.pack()
            
        
    def dif_start(s): # вывод меню дифференциальных уравнений
        z1.grid_remove()
        z3=Frame(root) # рамка для отдела дифференциальных уравнений
        a_=Label(z3, text='Введите начало отрезка по оси х:')
        a_1=Entry(z3)
        b_=Label(z3, text='Введите конечное значение отрезка по оси x:')
        b_1=Entry(z3)
        h_=Label(z3, text='Введите длину шага:')
        h_1=Entry(z3)
        y_=Label(z3, text='Введите значение у0 (удовлетворяющее условию у(х0)=у0):')
        y_1=Entry(z3)
        y__=Label(z3, text='Введите занчение производной в виде y"=f(x;y):')
        y_2=Entry(z3)
        m1=Button(z3, text='Метод Эйлера')
        n1=Label(z3, text='смотрите график...')
        m2=Button(z3, text='Метод Рунге-Кутты 4 порядка')
        n2=Label(z3, text='смотрите график...')
        q1=Button(z3, text='Обратно')
        def Ailer(u): # метод Эйлера
            x_it=[] # список для всех значений х
            y_it=[] # список для всех значений y
            a=int(a_1.get())
            b=int(b_1.get())
            h=float(h_1.get())
            y_0=float(y_1.get())
            y_p=str(y_2.get())

            n=int((b-a)/h) # количесвто отрезков на интервале функции, равное длине шага
            x=a
            for i in range (n+1): # добавление всех значений х в список для дальнейшео использования
                x=round(x, 5) 
                x_it.append(x)
                x=x+h

            y=y_0
            global y
            for i in range (n+1): # вычисление и  добавление всех значений y в список для дальнейшео использования
                y=round(y, 5)
                y_it.append(y)
                y2=y+h*(func(x_it[i], y_p))
                y=y2
                if y>1000: #если значение у>1000, то цикл прерывается, так как они слишком велики для коорд. пл.
                    break
      
            canvas() # вызов функции создания коорд. пл.
            v=0
            can.create_text(40, 10, text='метод Эйлера')
            can.create_line((x_it[v]*50)+250,(y_it[v]*(-50))+250, (x_it[v]*50)+250,(y_it[v]*(-50))+250)
            for i in range (len(x_it)-1): #создание необходимых точек и соединение их в один график функции
                can.create_line((x_it[v+1]*50)+250,(y_it[v+1]*(-50))+250, (x_it[v+1]*50)+250,(y_it[v+1]*(-50))+250)    
                can.create_line((x_it[v]*50)+250,(y_it[v]*(-50))+250, (x_it[v+1]*50)+250,(y_it[v+1]*(-50))+250, fill='red')
                v=v+1
            can.pack() # упаковка холста с графиком функции
            
        def Roung(u): # метод Рунге-Кутты
            x_it=[] #список для всех значений х
            y_it=[] #список для всех значений y
            a=int(a_1.get())
            b=int(b_1.get())
            h=float(h_1.get())
            y_0=float(y_1.get())
            y_p=str(y_2.get())

            n=int((b-a)/h) # количесвто отрезков на интервале функции, равное длине шага
            x=a
            for i in range (n+1): #добавление всех значений х в список для дальнейшео использования
                x=round(x, 5) 
                x_it.append(x)
                x=x+h
            global y
            y=y_0    
            for i in range (n+1): # вычисление и  добавление всех значений y в список для дальнейшео использования
                y=round(y, 5)
                y_it.append(y)
                k1=h*(func(x_it[i], y_p))
                y=y+(k1/2)
                k2=h*(func(x_it[i]+(h/2), y_p))
                y=y+(k2/2)-(k1/2)
                k3=h*(func(x_it[i]+(h/2), y_p))
                y=y-(k2/2)+k3
                k4=h*(func(x_it[i]+h, y_p))
                y=y-k3
                y2=y+(k1+2*k2+2*k3+k4)/6
                y=y2
                print(y)

            canvas() # вызов функции создания коорд. пл.
            v=0
            can.create_text(60, 10, text='метод Рунге-Кутты')
            can.create_line((x_it[v]*50)+250,(y_it[v]*(-50))+250, (x_it[v]*50)+250,(y_it[v]*(-50))+250)
            for i in range (len(x_it)-1): #создание необходимых точек и соединение их в один график функции
                can.create_line((x_it[v+1]*50)+250,(y_it[v+1]*(-50))+250, (x_it[v+1]*50)+250,(y_it[v+1]*(-50))+250)    
                can.create_line((x_it[v]*50)+250,(y_it[v]*(-50))+250, (x_it[v+1]*50)+250,(y_it[v+1]*(-50))+250, fill='red')
                v=v+1
            can.pack()  # упаковка холста с графиком функции
            
        def quit__(u): #функция выхода из отдела по дифференциальным уравнениям
            z3.grid_remove()
            z1.grid()
        m1.bind('<Button-1>', Ailer)
        m2.bind('<Button-1>', Roung)
        q1.bind('<Button-1>', quit__)
        a_.pack()
        a_1.pack()
        b_.pack()
        b_1.pack()
        h_.pack()
        h_1.pack()
        y_.pack()   #упаковка соотв. элементов
        y_1.pack()
        y__.pack()
        y_2.pack()
        m1.pack()
        n1.pack()
        m2.pack()
        n2.pack()
        z3.grid()
        q1.pack()
        

    def quit_(s): #функция выхода из меню 2-ой задачи
        z1.grid_remove()
        z.grid()
    unlin.bind('<Button-1>', unlin_start)
    dif.bind('<Button-1>', dif_start)
    q.bind('<Button-1>', quit_)
    z1.grid()
    unlin.pack()    #упаковка соотв. элементов
    u1.pack()
    dif.pack()
    u2.pack()
    q.pack()

def graph_start(u): # вывод меню для третьей задачи
    z.grid_remove()
    z4=Frame(root) # рамка для меню 3-ей задачи
    m0=Label(z4, text='если нет какой либо константы, введите "0"')
    m1=Label(z4, text='r:')
    n1=Entry(z4)
    m2=Label(z4, text='k:')
    n2=Entry(z4)
    m3=Label(z4, text='R:')
    n3=Entry(z4)
    m4=Label(z4, text='a')
    n4=Entry(z4)
    m5=Label(z4, text='m')
    n5=Entry(z4)
    m6=Label(z4, text='h')
    n6=Entry(z4)
    m7=Label(z4, text='t')
    n7=Entry(z4)
    m8=Label(z4, text='Введите функцию x(t)')
    n8=Entry(z4, width=50)
    m9=Label(z4, text='Введите функцию y(t)')
    n9=Entry(z4, width=50)
    g10=Button(z4, text='Построение')
    g11=Button(z4, text='Очистить')
    clock=Label(z4)
    q__1=Button(z4, text='Обратно')
    def graph_(u): #функция по реализации анимации графика
        x_it=[] # список для всех значений х
        y_it=[] # список для всех значений у
        r=float(n1.get())
        k=float(n2.get())
        R=float(n3.get())
        a=float(n4.get())
        m=float(n5.get())
        h=float(n6.get())
        t=float(n7.get())
        x=str(n8.get())
        y=str(n9.get())
        global r
        global k
        global R
        global a
        global m    # назначение всех переменных шлобальными для... 
        global h    # ...дальнейшего использования в локальных циклах
        global t
        global x
        global y

        t_nach=0
        while t_nach<=t: # вычисление и добавление значений х для дальнейшего использования
            x1=func1(t_nach, x)
            x_it.append(x1)
            t_nach=t_nach+0.1
        t_nach=0
        while t_nach<=t: # вычисление и добавление значений у для дальнейшего использования
             y1=func1(t_nach, y)
             y_it.append(y1)
             t_nach=t_nach+0.1

        x_max=int(max(x_it)+1) # нахождение макс. знач х для разметки коорд. пл.
        y_max=int(max(y_it)+1) # нахождение макс. знач у для разметки коорд. пл.
        
        d_x=int(240/x_max) # вычисление длины единичного отрезка для разметки коорд. пл. по оси х
        d_y=int(240/y_max) # вычисление длины единичного отрезка для разметки коорд. пл. по оси у
        
            
        can=Canvas(z4, width=510, height=510) #создание холста размером 510х510
        global can # назначаем холст глобальным для дальейшего использования в локальных циклах
        x0=250; y0=250; x_k=10; y_k=10
        can.create_line(x_k, y0, x0+240, y0, fill='black', arrow=BOTH) #создание коорд. осей 
        can.create_line(x0, y_k, x0, y0+240, fill='black', arrow=BOTH)
        can.create_text(x0+20, y_k, text='Y')
        can.create_text(x0+240, y0+20, text='X')
        can.create_text(x0-10,y0+10, text='0')

        x_nach=x0+d_x
        s=1
        for i in range(x_max-1): # создание ед. отрезков вдоль "+" оси х
            can.create_line(x_nach, y0-5, x_nach, y0+5 )
            can.create_text(x_nach, y0+10, text=s)
            x_nach=x_nach+d_x
            s=s+1
        x_nach=x0-d_x
        s=-1
        for i in range(x_max-1): # создание ед. отрезков вдоль "-" оси х
            can.create_line(x_nach, y0-5, x_nach, y0+5 )
            can.create_text(x_nach, y0+10, text=s)
            x_nach=x_nach-d_x
            s=s-1

        y_nach=y0-d_y
        s=1
        for i in range(y_max-1): # создание ед. отрезков вдоль "+" оси у
            can.create_line(x0-5, y_nach, x0+5, y_nach )
            can.create_text(x0-10, y_nach, text=s)
            y_nach=y_nach-d_y
            s=s+1

        y_nach=y0+d_y
        s=-1
        for i in range(y_max-1): # создание ед. отрезков вдоль "-" оси у
            can.create_line(x0-5, y_nach, x0+5, y_nach )
            can.create_text(x0-10, y_nach, text=s)
            y_nach=y_nach+d_y
            s=s-1
       
        s=0
        t_nach=0.1
        can.create_line((x0+(x_it[s]*d_x)), (y0-(y_it[s]*d_y)), (x0+(x_it[s]*d_x)), (y0-(y_it[s]*d_y)))
        for i in range(len(x_it)-1): # создание необходимых линий и соединение их в один график функции
            can.create_line((x0+(x_it[s+1]*d_x)), (y0-(y_it[s+1]*d_y)), (x0+(x_it[s+1]*d_x)), (y0-(y_it[s+1]*d_y)))
            can.create_line((x0+(x_it[s]*d_x)), (y0-(y_it[s]*d_y)), (x0+(x_it[s+1]*d_x)), (y0-(y_it[s+1]*d_y)), fill='red')
            s=s+1
            clock['text']=''.join (str(t_nach)) #вывод таймера постройки графика (=10с реального времени)
            can.update() # обновление холста 
            time.sleep(1) # заморозка холста на 1 с.
            t_nach=t_nach+0.1
            can.grid(row=6, column=0, columnspan=4) # упаковка холста

    def zab1(u): # функция выхода из меню 3-ей задачи
            z4.grid_remove()
            z.grid()

    g10.bind('<Button-1>', graph_)
    g11.bind ('<Button-1>', lambda(x): can.delete ('all') ) #простая функция очистки всего холста
    q__1.bind('<Button-1>', zab1)
    z4.grid()
    m0.grid(row=0, column=0, columnspan=8)
    m1.grid(row=1, column=0)
    n1.grid(row=2, column=0)
    m2.grid(row=1, column=1)
    n2.grid(row=2, column=1)
    m3.grid(row=1, column=2)
    n3.grid(row=2, column=2)
    m4.grid(row=1, column=3)    #упаковка соответствующих элементов
    n4.grid(row=2, column=3)
    m5.grid(row=1, column=4)
    n5.grid(row=2, column=4)
    m6.grid(row=1, column=5)
    n6.grid(row=2, column=5)
    m7.grid(row=1, column=6)
    n7.grid(row=2, column=6)
    m8.grid(row=3, column=0)
    n8.grid(row=3, column=1, columnspan=3)
    m9.grid(row=4, column=0)
    n9.grid(row=4, column=1,columnspan=3)
    g10.grid(row=5, column=0)
    g11.grid(row=5, column=1)
    q__1.grid(row=5, column=2)
    clock.grid(row=5, column=4)
 
def examp_start(u): # вывод меню для четвертой задачи
    z.grid_remove()
    z5=Frame(root) # рамка для меню 4-ой задачи
    A1=Label(z5, text='Начальная амплитуда (см)')
    A2=Entry(z5)
    r1=Label(z5, text='Сопротивление среды')
    r2=Entry(z5)
    m1=Label(z5, text='Масса маятника (кг)')
    m2=Entry(z5)
    l1=Label(z5, text='Длина нити (см)')
    l2=Entry(z5)
    n1=Label(z5, text='Начальный угол (в градусах)')
    n2=Entry(z5)
    inf=Label(z5, text='''Информация:
    <0.0001 - сопрртивление вакуума
    0.0001-0.007 - сопротивление воздуха
    0.07-0.1 - сопротивление спирта
    0.1-0.3 - сопротивление растительного масла
    0.4-0.6 - сопротивление воды
    1 - 1.5 - сопротивление молока
    2-3 - сопротивление меда''')
    q=Button(z5, text='Обратно')
    g=Button(z5, text='Начать заново')
    g1=Button(z5, text='Начать')
    g2=Button(z5, text='Остановить')

    f1=Label(z5, text='------------------------------------------------------------------------------------------------------------')
    f2=Label(z5, text='------------------------------------------------------------------------------------------------------------')

    t1=0 # начальное время
    global t1 # глобализация для дальнейшего использования в локальных циклах
       
    def mat(u): # функция реализации анимации колебаний мат. маятника
        global t1 # повторная глобализация для дальнейшего использования в локальных циклах
        z_=[] # список для активации команды "стоп"
        zan_=[] # список для активации команды "начать заново"
        A=float(A2.get())
        r=float(r2.get())
        m=float(m2.get())
        l=float(l2.get())
        n=float(n2.get())
        canv=Canvas(z5, width=500, height=500) # создание холста (размером 500х500)
        canv.create_line(10, 250, 490, 250) #создание вспомогательной линии
        canv.create_oval(240, 5, 260, 15, fill='black')
        h=canv.create_line(250, 10, 250, 10+l)
        h1=canv.create_oval(240, 10+l-10, 260, 10+l+10)
        canv.grid(row=10, column=0, columnspan=4) #упаковка холста
        st=0 # флажок для команды "стоп" в положении выкл. (по умолчанию)
        canv.delete(h)
        canv.delete(h1)
        b=r/(2*m)
        k=(m*9.81)/(0.001*l)
        w=sqrt(9.81/l)
        x=A*exp(-b*t1)*sin(w*t1+n)
        y=sqrt(l**2-x**2)+10
        h=canv.create_line(250, 10, x+250, y)
        h1=canv.create_oval(x+250-15, y-15, x+250+15, y+15, fill='black')
        while t1>-1:
            def zan(u):
                zan_.append(1)
            if len(zan_)>0: # активация режима "Начать заново"
                t1=0
                del zan_[0]
            g.bind('<Button-1>', zan) # кнопка активации "Начать заново"
            def stop_1(u):
                st=1 # флажок для команды "стоп" в положении вкл. 
                z_.append(st) # активация режима "стоп"
            if len(z_)>0:
                break # остановка анимации
            g2.bind('<Button-1>', stop_1) # кнопка активации "стоп"
                
            
            t1=t1+0.1
            canv.delete(h) # очистка холста от прежнего положения нити и самого матяника
            canv.delete(h1)
            x2=A*exp(-b*t1)*sin(w*t1+n)
            y2=sqrt(l**2-x**2)+10
            h=canv.create_line(250, 10, x2+250, y2) # добавление новго положения нити
            h1=canv.create_oval(x2+250-15, y2-15, x2+250+15, y2+15, fill='black') # добавление новго положения маятника
            canv.update() # обновление холста
            time.sleep(0.02) # заморозка холста на 0.02 секунды, чтобы показать анимацию движения мат. маятника
            x=x2; y=y2
                
            canv.grid(row=10, column=0, columnspan=4) # упаковка холста
 
            
    def quit_4(u): # функция выхода из меню 4-ой программы
        z5.grid_remove()
        z.grid()

    z5.grid()    
    q.bind('<Button-1>', quit_4)
    g1.bind('<Button-1>', mat)
    A1.grid(row=0, column=0)
    A2.grid(row=0, column=1)
    r1.grid(row=1, column=0)
    r2.grid(row=1, column=1)
    m1.grid(row=2, column=0)    # упаковка соотв. элементов
    m2.grid(row=2, column=1)
    l1.grid(row=3, column=0)
    l2.grid(row=3, column=1)
    n1.grid(row=4, column=0)
    n2.grid(row=4, column=1)
    inf.grid(row=0, column=2, rowspan=7, columnspan=4)
    q.grid(row=7, column=0)
    g.grid(row=7, column=1)
    g1.grid(row=7, column=2)
    g2.grid(row=7, column=3)
    f1.grid(row=8, column=0, columnspan=4)
    f2.grid(row=9, column=0, columnspan=4)

    
unlin_dif.bind('<Button-1>', unlin_dif_start)
intg_dif.bind('<Button-1>', intg_dif_start)
graph.bind('<Button-1>', graph_start)   # назначение кнопок начального меню
examp.bind('<Button-1>', examp_start)
z.grid()
intg_dif.pack()
u1.pack()
unlin_dif.pack()
u2.pack()
graph.pack()        # упаковка элементов начального меню
u3.pack()
examp.pack()
u4.pack()
u5.pack()
ex.pack()
root.mainloop()

This snippet took 0.13 seconds to highlight.

Back to the Entry List or Home.

Delete this entry (admin only).