import matplotlib.pyplot as plt
import numpy as np
from sympy import *


# Metoda graficzna
x = np.arange(-1.5, -0.5, 0.001)


y1 = 2*x**2 + x - 3
plt.plot(x, y1)

y2 = -3*x**2/(-2*x+3)
plt.plot(x, y2)

plt.grid(True)
plt.show()
liczba_probek = 10

# Metoda iteracyjnego podstawiania
x1 = Symbol('x1')
y1 = Symbol('y1')
x2 = Symbol('x2')
y2 = Symbol('y2')
x3 = Symbol('x3')
y3 = Symbol('y3')

def it_pr(x, y):
    for i in range(0, liczba_probek):
        x = np.append(x, 3*y[i]/(-3*x[i] + 2*y[i]))
        y = np.append(y, 2*x[i+1]**2 + x[i+1] - 3)

        global blad_x_ip
        global blad_y_ip
        blad_x_ip = np.append(blad_x_ip, np.absolute((x[i+1]-x[i])/x[i+1]))
        blad_y_ip = np.append(blad_y_ip, np.absolute((y[i+1]-y[i])/y[i+1]))

    blad_x_ip[0] = 1
    blad_x_ip = blad_x_ip *100

    blad_y_ip[0] = 1
    blad_y_ip = blad_y_ip *100

    return [x[len(x)-1], y[len(y)-1]]

x1 = [0.75]
y1 = [-1.125]
x2 = [-1.30278]
y2 = [-0.908327]
x3 = [3.0]
y3 = [8.0]

blad_x_ip = [x1]
blad_y_ip = [y1]
pierwszy_it_pr = it_pr(x1, y1)

blad_x_ip = [x2]
blad_y_ip = [y2]
drugi_it_pr = it_pr(x2, y2)

blad_x_ip = [x3]
blad_y_ip = [y3]
trzeci_it_pr = it_pr(x3, y3)

print()
print('------------------------------------------------------')
print('Metoda iteracyjnego podstawiania dla wartosci poczatkowych x = '+str(x1[0])+' y = '+str(y1[0]))
print('Argument: ' + str(pierwszy_it_pr[0]))
print('Wynik: ' + str(pierwszy_it_pr[1]))
print()
print('Metoda iteracyjnego podstawiania dla wartosci poczatkowych x = '+str(x2[0])+' y = '+str(y2[0]))
print('Argument: ' + str(drugi_it_pr[0]))
print('Wynik: ' + str(drugi_it_pr[1]))
print('Zupelnie nie lapie drugiego pierwiastka')
print()
print('Metoda iteracyjnego podstawiania dla wartosci poczatkowych x = '+str(x3[0])+' y = '+str(y3[0]))
print('Argument: ' + str(trzeci_it_pr[0]))
print('Wynik: ' + str(trzeci_it_pr[1]))
print('------------------------------------------------------')

# Metoda Newtona - Raphsona

x = Symbol('x')
y = Symbol('y')


def f1(x, y):
    return 2*x**2 + x - y - 3


def f2(x, y):
    return -3*x**2 + 2*x*y - 3*y

pochodna_1_1 = diff(f1(x, y), x)
pochodna_1_2 = diff(f1(x, y), y)
pochodna_2_1 = diff(f2(x, y), x)
pochodna_2_2 = diff(f2(x, y), y)


def ne_ra(x_it, y_it):
    for i in range(0, liczba_probek):
        wartosc_1_1 = pochodna_1_1.subs([(x, x_it[len(x_it)-1]), (y, y_it[len(y_it)-1])])
        wartosc_1_2 = pochodna_1_2.subs([(x, x_it[len(x_it)-1]), (y, y_it[len(y_it)-1])])
        wartosc_2_1 = pochodna_2_1.subs([(x, x_it[len(x_it)-1]), (y, y_it[len(y_it)-1])])
        wartosc_2_2 = pochodna_2_2.subs([(x, x_it[len(x_it)-1]), (y, y_it[len(y_it)-1])])

        wyznacznik = wartosc_1_1 * wartosc_2_2 - wartosc_1_2 * wartosc_2_1

        wartosc_funkcji_1 = f1(x_it[len(x_it)-1], y_it[len(y_it)-1])
        wartosc_funkcji_2 = f2(x_it[len(x_it)-1], y_it[len(y_it)-1])

        x_it = np.append(x_it, x_it[len(x_it)-1] - (wartosc_funkcji_1 * wartosc_2_2 - wartosc_funkcji_2 * wartosc_1_2)/wyznacznik)
        y_it = np.append(y_it, y_it[len(y_it)-1] - (wartosc_funkcji_2 * wartosc_1_1 - wartosc_funkcji_1 * wartosc_2_1)/wyznacznik)

        global blad_x_n_r
        global blad_y_n_r
        blad_x_n_r = np.append(blad_x_n_r, np.absolute((x_it[len(x_it)-1] - x_it[len(x_it)-2])/x_it[len(x_it)-1]))
        blad_y_n_r = np.append(blad_y_n_r, np.absolute((y_it[len(y_it)-1] - y_it[len(y_it)-2])/y_it[len(y_it)-1]))

    blad_x_n_r[0] = 1
    blad_x_n_r = blad_x_n_r *100

    blad_y_n_r[0] = 1
    blad_y_n_r = blad_y_n_r *100

    return [x_it[len(x_it)-1], y_it[len(y_it)-1]]

x_it_1 = [x1[0]]
y_it_1 = [y1[0]]
x_it_2 = [x2[0]]
y_it_2 = [y2[0]]
x_it_3 = [x3[0]]
y_it_3 = [y3[0]]

blad_x_n_r = [x_it_1]
blad_y_n_r = [y_it_1]
pierwszy_ne_ra = ne_ra(x_it_1, y_it_1)

blad_x_n_r = [x_it_2]
blad_y_n_r = [y_it_2]
drugi_ne_ra = ne_ra(x_it_2, y_it_2)

blad_x_n_r = [x_it_3]
blad_y_n_r = [y_it_3]
trzeci_ne_ra = ne_ra(x_it_3, y_it_3)


print('Metoda Newtona - Raphsona dla wartosci poczatkowych x = '+str(x_it_1[0])+' y = '+str(y_it_1[0]))
print('Argument: ' + str(pierwszy_ne_ra[0]))
print('Wynik: ' + str(pierwszy_ne_ra[1]))
print()
print('Metoda Newtona - Raphsona dla wartosci poczatkowych x = '+str(x_it_2[0])+' y = '+str(y_it_2[0]))
print('Argument: ' + str(drugi_ne_ra[0]))
print('Wynik: ' + str(drugi_ne_ra[1]))
print()
print('Metoda Newtona - Raphsona dla wartosci poczatkowych x = '+str(x_it_3[0])+' y = '+str(y_it_3[0]))
print('Argument: ' + str(trzeci_ne_ra[0]))
print('Wynik: ' + str(trzeci_ne_ra[1]))
print('------------------------------------------------------')
print()
print('Bardziej wrazliwa na dobor punktu startowego jest metoda Newtona - Raphsona. Mozna to argumentowac tym, ze w tym przypadku '
      ', w odroznieniu od metody iteracyjnego podstawiania, znajduje wszystkie pierwiastki.')

os_x = np.arange(0, liczba_probek + 1, 1)

plt.plot(os_x, blad_x_n_r, marker='o', lw=2, label="Metoda Newtona-Raphsona")
plt.plot(os_x, blad_x_ip, marker='x', lw=2, label="Metoda iteracyjnego podstawiania")

plt.legend()
plt.axis([-0.25, liczba_probek+1, -5, 105])
plt.grid(True)
plt.show()