示例#1
0
    def euler(self):
        self.wm_attributes("-disable", True)
        self.toplevel_dialog = tk.Toplevel(self)
        self.toplevel_dialog.minsize(300, 100)

        self.toplevel_dialog.transient(self)
        self.toplevel_dialog.protocol("WM_DELETE_WINDOW", self.Close_Toplevel)

        l = len(self.couple)
        lg = len(self.sommets)
        if lg >= 2:
            g1 = Euler(lg)
            for i in range(l):
                g1.addEdge(self.couple[i][0], self.couple[i][1])
            self.var = g1.test()
            self.label = tk.Label(self.toplevel_dialog, text=self.var)
            self.label.pack(side='top')
        else:
            self.label = tk.Label(self.toplevel_dialog,
                                  text="Votre requette ne peut etre traiter")
            self.label.pack(side='top')

        self.yes_button = ttk.Button(self.toplevel_dialog,
                                     text='Retour',
                                     width=25,
                                     command=self.Close_Toplevel)
        self.yes_button.pack(side='right', fill='x', expand=True)
示例#2
0
    plt.title("Residual plot")
    plt.show()

def get_accuracy(YM, W):
    projv = eta(np.dot(YM, W))
    guess = np.around(projv)
    diff = guess - C
    wrong_guesses = np.count_nonzero(diff)
    accuracy = (1 - wrong_guesses / n)
    return accuracy

#arguments
Eargs = (M, h, K, Y0, sigma)
OFargs = (M, h, K, Y0, sigma, eta, C, W)
GCargs = (M, h, K, Y0, sigma, eta, C, W, eps)
Targs = (M, h, K, Y0, sigma, eta, C, W, eps, TOL, tau)

K, W, res_list = T.Train(*Targs)
res_plot(res_list)

#Training data accuracy
YM = E.Euler(M, h, K, Y0, sigma)
accu = get_accuracy(YM, W)
print("Accuracy on training set: " + str(accu))

#Test data accuracy
Y0, C = mcp.YC(n, 50, False)
YM = E.Euler(M, h, K, Y0, sigma)
accu = get_accuracy(YM, W)
print("Accuracy on test set: " + str(accu))
示例#3
0
        y_Euler.append(y1)
        y_RK.append(y2)
        y_theory.append(y3)
        #print("y2, y3=", y2, y3)
        time.append(t)
    return [y_Euler, y_RK, y_theory, time]


###########################
# Тест из методички
from_ = 0
to_ = 1
dt = 0.1
func_arr = [func_test_0, func_test_1, func_test_2, func_test_3]
y_start = [1, 1, 1, 1]
[res_x, res_y] = Euler.Euler(y_start, from_, to_, dt, func_arr)
[res_x_RK, res_y_RK] = RungeKutt.RungeKutt(y_start, 0, 1, 0.1, func_arr)

[y_Euler, y_RK, y_theory, time] = seminar_alg(dt, from_, to_)

print('Seminar Euler\n', y_Euler, '\n')
print('My Euler\n', res_y, '\n')

print('Seminar RK\n', y_RK, '\n')
print('My RK\n', res_y_RK, '\n')
'''fig = plt.figure()
subplot = fig.add_subplot(121)
subplot.set_title('методичка')

subplot.plot(time, y_theory, 'black', label='Seminar theory')
subplot.plot(time, y_Euler, 'm', label = 'Seminar Euler')
示例#4
0
def ObjFunc(M, h, K, Y0, sigma, eta, C, W):
    YM = E.Euler(M, h, K, Y0, sigma)
    projv = eta(np.dot(YM, W))
    return (1 / 2) * nl.norm(projv - C)**2
示例#5
0
def Wgrad(M, h, K, Y0, sigma, eta, C, W):
    YM = E.Euler(M, h, K, Y0, sigma)
    y = np.dot(YM, W)
    return np.dot(YM.T, etader(y)*(eta(y) - C))